pax_global_header00006660000000000000000000000064132113146230014506gustar00rootroot0000000000000052 comment=2b10d8492e1185039be4d5f2242a5b11ea102303 mongo-tools-r3.6.3/000077500000000000000000000000001321131462300141565ustar00rootroot00000000000000mongo-tools-r3.6.3/.eslintrc.yml000066400000000000000000000077471321131462300166210ustar00rootroot00000000000000env: es6: true mongo: true rules: # Rules are documented at http://eslint.org/docs/rules/ # # Possible Errors comma-dangle: ["error", "only-multiline"] no-cond-assign: 2 no-console: 2 no-constant-condition: 2 no-control-regex: 2 no-debugger: 2 no-dupe-args: 2 no-dupe-keys: 2 no-duplicate-case: 2 no-empty: 2 no-empty-character-class: 2 no-extra-parens: 0 no-ex-assign: 2 no-extra-boolean-cast: 2 no-extra-semi: 2 no-func-assign: 2 no-inner-declarations: 0 no-invalid-regexp: 2 no-irregular-whitespace: 2 no-negated-in-lhs: 2 no-obj-calls: 2 no-prototype-builtins: 0 no-regex-spaces: 2 no-sparse-arrays: 2 no-unexpected-multiline: 2 no-unreachable: 2 no-unsafe-finally: 2 use-isnan: 2 valid-jsdoc: 0 valid-typeof: 2 # # Best Practices accessor-pairs: 0 array-callback-return: 2 block-scoped-var: 0 consistent-return: 0 curly: ["error", "all"] default-case: 2 dot-location: 0 dot-notation: 0 eqeqeq: 2 guard-for-in: 2 no-alert: 2 no-caller: 2 no-case-declarations: 0 no-div-regex: 2 no-else-return: 2 no-empty-function: 2 no-empty-pattern: 2 no-eq-null: 0 no-eval: 2 no-extend-native: 0 no-extra-bind: 2 no-extra-label: 2 no-fallthrough: 2 no-floating-decimal: 0 no-implicit-coercion: 0 no-implicit-globals: 0 no-implied-eval: 2 no-invalid-this: 2 no-iterator: 0 no-labels: 2 no-lone-blocks: 2 no-loop-func: 2 no-magic-numbers: 0 no-multi-spaces: 2 no-multi-str: 0 no-native-reassign: 2 no-new: 0 no-new-func: 0 no-new-wrappers: 2 no-octal: 2 no-octal-escape: 2 no-param-reassign: 0 no-proto: 2 no-redeclare: 2 no-return-assign: 2 no-script-url: 2 no-self-assign: 2 no-self-compare: 2 no-sequences: 2 no-throw-literal: 2 no-unmodified-loop-condition: 2 no-unused-expressions: 2 no-unused-labels: 2 no-useless-call: 2 no-useless-concat: 2 no-useless-escape: 2 no-void: 2 no-warning-comments: 0 no-with: 2 radix: 0 vars-on-top: 0 wrap-iife: 2 yoda: 2 # # Variables init-declarations: 0 no-catch-shadow: 2 no-delete-var: 0 no-label-var: 2 no-restricted-globals: 0 no-shadow: 0 no-shadow-restricted-names: 2 no-undef: 0 no-undef-init: 0 no-undefined: 0 no-unused-vars: ["error", {"varsIgnorePattern": "testName"}] no-use-before-define: 2 # # Style array-bracket-spacing: ["error", "never"] block-spacing: ["error", "always"] brace-style: ["error", "1tbs"] camelcase: 0 comma-spacing: ["error", {"before": false, "after": true}] comma-style: ["error", "last"] computed-property-spacing: ["error", "never"] consistent-this: 0 eol-last: 2 func-names: 0 func-style: 0 id-blacklist: 0 id-length: 0 id-match: 0 indent: ["error", 2] jsx-quotes: 0 key-spacing: 2 keyword-spacing: ["error", {"before": true, "after": true}] linebreak-style: 2 lines-around-comment: 0 max-depth: 0 max-len: 0 max-lines: 0 max-nested-callbacks: 0 max-params: 0 max-statements: 0 max-statements-per-line: 0 new-cap: 0 new-parens: 2 newline-after-var: 0 newline-before-return: 0 newline-per-chained-call: 0 no-array-constructor: 2 no-bitwise: 0 no-continue: 0 no-inline-comments: 0 no-lonely-if: 2 no-mixed-operators: 0 no-mixed-spaces-and-tabs: 2 no-multiple-empty-lines: 2 no-negated-condition: 0 no-nested-ternary: 0 no-new-object: 0 no-plusplus: 0 no-restricted-syntax: 0 no-spaced-func: 2 no-ternary: 0 no-trailing-spaces: 2 no-underscore-dangle: 0 no-unneeded-ternary: 2 no-whitespace-before-property: 2 object-curly-newline: 0 object-curly-spacing: 2 object-property-newline: 0 one-var: 0 one-var-declaration-per-line: 0 operator-assignment: 0 operator-linebreak: 0 padded-blocks: 0 quote-props: 0 quotes: 0 require-jsdoc: 0 semi: 2 semi-spacing: 2 sort-vars: 0 space-before-blocks: 2 space-before-function-paren: 0 space-in-parens: 2 space-infix-ops: 0 space-unary-ops: 2 spaced-comment: 2 unicode-bom: 0 wrap-regex: 0 mongo-tools-r3.6.3/.gitattributes000066400000000000000000000001061321131462300170460ustar00rootroot00000000000000# Force gpm to always have lf endings even on Windows gpm text eol=lf mongo-tools-r3.6.3/.gitignore000066400000000000000000000002431321131462300161450ustar00rootroot00000000000000*.bson *.dump *.exe *.json *.log *.out *.pcap *.playback *.pyc *.swp *.swp *.tape *.temp *.zip *temp* bin/ vendor/pkg .gopath .godeps .idea tags node_modules mongo-tools-r3.6.3/CONTRIBUTING.md000066400000000000000000000056761321131462300164250ustar00rootroot00000000000000Contributing to the MongoDB Tools Project =================================== Pull requests are always welcome, and the MongoDB engineering team appreciates any help the community can give to make the MongoDB tools better. For any particular improvement you want to make, you can begin a discussion on the [MongoDB Developers Forum](https://groups.google.com/forum/?fromgroups#!forum/mongodb-dev). This is the best place to discuss your proposed improvement (and its implementation) with the core development team. If you're interested in contributing, we have a list of some suggested tickets that are easy enough to get started on [here](https://jira.mongodb.org/issues/?jql=project%20%3D%20TOOLS%20AND%20labels%20%3D%20community%20and%20status%20%3D%20open) Getting Started --------------- 1. Create a [MongoDB JIRA account](https://jira.mongodb.org/secure/Signup!default.jspa). 2. Create a [Github account](https://github.com/signup/free). 3. [Fork](https://help.github.com/articles/fork-a-repo/) the repository on Github at https://github.com/mongodb/mongo-tools. 4. For more details see http://www.mongodb.org/about/contributors/. 5. Submit a [pull request](https://help.github.com/articles/creating-a-pull-request/) against the project for review. Note: if you are a MongoDB engineer, please use the internal code review tool instead of github. JIRA Tickets ------------ 1. File a JIRA ticket in the [TOOLS project](https://jira.mongodb.org/browse/TOOLS). 2. All commit messages to the MongoDB Tools repository must be prefaced with the relevant JIRA ticket number e.g. "TOOLS-XXX add support for xyz". In filing JIRA tickets for bugs, please clearly describe the issue you are resolving, including the platforms on which the issue is present and clear steps to reproduce. For improvements or feature requests, be sure to explain the goal or use case, and the approach your solution will take. Style Guide ----------- All commits to the MongoDB Tools repository must pass golint: ```go run vendor/src/github.com/3rf/mongo-lint/golint/golint.go mongo* bson* common/*``` _We use a modified version of [golint](https://github.com/golang/lint)_ Testing ------- To run unit and integration tests: ``` go test -v -test.types=unit,integration ``` This should be run in all package directories - common, mongorestore, mongoexport, etc. The `test.types` flag indicates what kinds of tests to run. Integration tests require a `mongod` (running on port 33333) while unit tests do not. To run the quality assurance tests, you need to have the latest stable version of the rebuilt tools, `mongod`, `mongos`, and `mongo` in your current working directory. ``` cd test/qa-tests python buildscripts/smoke.py bson export files import oplog restore stat top ``` _Some tests require older binaries that are named accordingly (e.g. `mongod-2.4`, `mongod-2.6`, etc). You can use [setup_multiversion_mongodb.py](test/qa-tests/buildscripts/setup_multiversion_mongodb.py) to download those binaries_ mongo-tools-r3.6.3/Godeps000066400000000000000000000030611321131462300153220ustar00rootroot00000000000000gopkg.in/mgo.v2 39b4000d99037e917f3a3b9d2dcab667a9ef284a github.com/10gen/mgo gopkg.in/tomb.v2 14b3d72120e8d10ea6e6b7f87f7175734b1faab8 github.com/jtolds/gls 8ddce2a84170772b95dd5d576c48d517b22cac63 github.com/jacobsa/oglematchers 3ecefc49db07722beca986d9bb71ddd026b133f0 github.com/smartystreets/assertions 287b4346dc4e71a038c346375a9d572453bc469b github.com/smartystreets/goconvey bf58a9a1291224109919756b4dcc469c670cc7e4 github.com/jessevdk/go-flags 97448c91aac742cbca3d020b3e769013a420a06f github.com/3rf/mongo-lint 3550fdcf1f43b89aaeabaa4559eaae6dc4407e42 github.com/spacemonkeygo/openssl 2869e8ca1a6eb35fb727f41611fd52b55cd0f49c github.com/10gen/openssl github.com/spacemonkeygo/spacelog f936fb050dc6b5fe4a96b485a6f069e8bdc59aeb github.com/howeyc/gopass 44476384cd4721b68705e72f19e95d1a3a504370 github.com/nsf/termbox-go 0723e7c3d0a317dea811f0fbe4d6edd81908c971 github.com/mattn/go-runewidth d6bea18f789704b5f83375793155289da36a3c7f golang.org/x/crypto 1f22c0103821b9390939b6776727195525381532 github.com/golang/crypto github.com/10gen/llmgo master github.com/google/gopacket 1b0b78901cdd351ecfc68bf1a2adafcd2ff30220 github.com/patrickmn/go-cache 1881a9bccb818787f68c52bfba648c6cf34c34fa github.com/10gen/escaper 17fe61c658dcbdcbf246c783f4f7dc97efde3a8b github.com/golang/snappy d9eb7a3d35ec988b8585d4a0068e462c27d28380 mongo-tools-r3.6.3/LICENSE.md000066400000000000000000000010521321131462300155600ustar00rootroot00000000000000Copyright 2014 MongoDB, Inc. 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. mongo-tools-r3.6.3/README.md000066400000000000000000000034451321131462300154430ustar00rootroot00000000000000MongoDB Tools =================================== - **bsondump** - _display BSON files in a human-readable format_ - **mongoimport** - _Convert data from JSON, TSV or CSV and insert them into a collection_ - **mongoexport** - _Write an existing collection to CSV or JSON format_ - **mongodump/mongorestore** - _Dump MongoDB backups to disk in .BSON format, or restore them to a live database_ - **mongostat** - _Monitor live MongoDB servers, replica sets, or sharded clusters_ - **mongofiles** - _Read, write, delete, or update files in [GridFS](http://docs.mongodb.org/manual/core/gridfs/)_ - **mongotop** - _Monitor read/write activity on a mongo server_ - **mongoreplay** - _Capture, observe, and replay traffic for MongoDB_ Report any bugs, improvements, or new feature requests at https://jira.mongodb.org/browse/TOOLS Setup --------------- Clone the repo and run `. ./set_gopath.sh` (`set_gopath.bat` on Windows) to setup your GOPATH: ``` git clone https://github.com/mongodb/mongo-tools cd mongo-tools . ./set_gopath.sh ``` Building Tools --------------- To build the tools, you need to have Go version 1.3 and up. An additional flag, `-tags`, can be passed to the `go build` command in order to build the tools with support for SSL and/or SASL. For example: ``` mkdir bin go build -o bin/mongoimport mongoimport/main/mongoimport.go # build mongoimport go build -o bin/mongoimport -tags ssl mongoimport/main/mongoimport.go # build mongoimport with SSL support enabled go build -o bin/mongoimport -tags "ssl sasl" mongoimport/main/mongoimport.go # build mongoimport with SSL and SASL support enabled ``` Contributing --------------- See our [Contributor's Guide](CONTRIBUTING.md). Documentation --------------- See the MongoDB packages [documentation](http://docs.mongodb.org/master/reference/program/). mongo-tools-r3.6.3/THIRD-PARTY-NOTICES000066400000000000000000001774561321131462300167760ustar00rootroot00000000000000MongoDB uses third-party libraries or other resources that may be distributed under licenses different than the MongoDB software. In the event that we accidentally failed to list a required notice, please bring it to our attention through any of the ways detailed here : mongodb-dev@googlegroups.com The attached notices are provided for information only. License notice for github.com/10gen/escaper ------------------------------------------------------------ The MIT License (MIT) Copyright (c) 2016 Lucas Morales 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. License notice for github.com/10gen/llmgo ------------------------------------------------------------ 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. License notice for github.com/3rf/mongo-lint ------------------------------------------------------------ Copyright (c) 2013 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. License notice for github.com/golang/snappy ------------------------------------------------------------ Copyright (c) 2011 The Snappy-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. License notice for github.com/google/gopacket ------------------------------------------------------------ Copyright (c) 2012 Google, Inc. All rights reserved. Copyright (c) 2009-2011 Andreas Krennmair. 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 Andreas Krennmair, Google, 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. License notice for github.com/howeyc/gopass ------------------------------------------------------------ Copyright (c) 2012 Chris Howey Permission to use, copy, modify, and distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies. THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. License notice for github.com/jacobsa/oglematchers ------------------------------------------------------------ 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. License notice for github.com/jessevdk/go-flags ------------------------------------------------------------ Copyright (c) 2012 Jesse van den Kieboom. 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. License notice for github.com/jtolds/gls ------------------------------------------------------------ Copyright (c) 2013, Space Monkey, Inc. 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. License notice for github.com/nsf/termbox-go ------------------------------------------------------------ Copyright (C) 2012 termbox-go authors 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. License notice for github.com/patrickmn/go-cache ------------------------------------------------------------ Copyright (c) 2012-2015 Patrick Mylund Nielsen and the go-cache contributors 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. License notice for github.com/smartystreets/assertions ------------------------------------------------------------ Copyright (c) 2015 SmartyStreets, LLC 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. NOTE: Various optional and subordinate components carry their own licensing requirements and restrictions. Use of those components is subject to the terms and conditions outlined the respective license of each component. License notice for github.com/smartystreets/goconvey ------------------------------------------------------------ Copyright (c) 2014 SmartyStreets, LLC 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. NOTE: Various optional and subordinate components carry their own licensing requirements and restrictions. Use of those components is subject to the terms and conditions outlined the respective license of each component. License notice for github.com/spacemonkeygo/openssl ------------------------------------------------------------ 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: You must give any other recipients of the Work or Derivative Works a copy of this License; and You must cause any modified files to carry prominent notices stating that You changed the files; and 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 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. License notice for github.com/spacemonkeygo/spacelog ------------------------------------------------------------ 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: You must give any other recipients of the Work or Derivative Works a copy of this License; and You must cause any modified files to carry prominent notices stating that You changed the files; and 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 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. License notice for golang.org/x/crypto ------------------------------------------------------------ Copyright (c) 2009 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. License notice for gopkg.in/mgo.v2 ------------------------------------------------------------ mgo - MongoDB driver for Go Copyright (c) 2010-2013 - Gustavo Niemeyer 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. 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. License notice for gopkg.in/tomb.v2 ------------------------------------------------------------ tomb - support for clean goroutine termination in Go. Copyright (c) 2010-2011 - Gustavo Niemeyer 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 copyright holder 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. License notice for github.com/mattn/go-runewidth ------------------------------------------------------------ Copyright © 2013-2017 Yasuhiro Matsumoto, http://mattn.kaoriya.net 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. License notice for JSON and CSV code from github.com/golang/go ------------------------------------------------------------ Copyright (c) 2009 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. mongo-tools-r3.6.3/binaryurl.py000066400000000000000000000043741321131462300165470ustar00rootroot00000000000000#!/usr/bin/env python """ Command line utility returns the URL of the most recent archive file satisfying given version, edition, and operating system requirements. """ import argparse import json import sys import urllib2 url_current = "http://downloads.mongodb.org/current.json" url_full = "http://downloads.mongodb.org/full.json" parser = argparse.ArgumentParser() parser.add_argument("--arch", help="processor architecture (e.g. 'x86_64', 'arm64')") parser.add_argument("--edition", help="edition of MongoDB to use (e.g. 'targeted', 'enterprise'); defaults to 'base'") parser.add_argument("--target", help="system in use (e.g. 'ubuntu1204', 'windows_x86_64-2008plus-ssl', 'rhel71')") parser.add_argument("--version", help="version branch (e.g. '2.6', '3.2.8-rc1', 'latest')") opts = parser.parse_args() if not opts.edition: opts.edition = "base" if not opts.arch: sys.exit("must specify arch") if not opts.target: sys.exit("must specify target") if not opts.version: sys.exit("must specify version") # prior to the 2.6 branch, the enterprise edition was called 'subscription' if opts.version == "2.4" and opts.edition == "enterprise": opts.edition = "subscription" def isCorrectVersion(version): actual = version["version"].split(".") desired = opts.version.split(".") for i in range(len(desired)): if desired[i] and not actual[i] == desired[i]: return False return True def isCorrectDownload(download): return download["edition"] == opts.edition and download["target"] == opts.target and download["arch"] == opts.arch def locateUrl(specs, override): versions = specs["versions"] if not override: versions = filter(isCorrectVersion, versions) for item in versions: downloads = filter(isCorrectDownload, item["downloads"]) urls = map(lambda download : download["archive"]["url"], downloads) if len(urls) > 0: if override: return urls[0].replace(item["version"], override) return urls[0] override = "latest" if opts.version == "latest" else None specs = json.load(urllib2.urlopen(url_current)) url = locateUrl(specs, override) if not url: specs = json.load(urllib2.urlopen(url_full)) url = locateUrl(specs, override) if not url: sys.exit("No info for version "+opts.version+" found") sys.stdout.write(url) mongo-tools-r3.6.3/bsondump/000077500000000000000000000000001321131462300160055ustar00rootroot00000000000000mongo-tools-r3.6.3/bsondump/bsondump.go000066400000000000000000000144551321131462300201740ustar00rootroot00000000000000// Copyright (C) MongoDB, Inc. 2014-present. // // 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 // Package bsondump converts BSON files into human-readable formats such as JSON. package bsondump import ( "bytes" "fmt" "github.com/mongodb/mongo-tools/common/bsonutil" "github.com/mongodb/mongo-tools/common/db" "github.com/mongodb/mongo-tools/common/json" "github.com/mongodb/mongo-tools/common/log" "github.com/mongodb/mongo-tools/common/options" "github.com/mongodb/mongo-tools/common/util" "gopkg.in/mgo.v2/bson" "io" "os" "strings" ) // BSONDump is a container for the user-specified options and // internal state used for running bsondump. type BSONDump struct { // generic mongo tool options ToolOptions *options.ToolOptions // BSONDumpOptions defines options used to control how BSON data is displayed BSONDumpOptions *BSONDumpOptions // File handle for the output data. Out io.WriteCloser BSONSource *db.BSONSource } type ReadNopCloser struct { io.Reader } func (ReadNopCloser) Close() error { return nil } type WriteNopCloser struct { io.Writer } func (WriteNopCloser) Close() error { return nil } // GetWriter opens and returns an io.WriteCloser for the OutFileName in BSONDumpOptions // or nil if none is set. The caller is responsible for closing it. func (bdo *BSONDumpOptions) GetWriter() (io.WriteCloser, error) { if bdo.OutFileName != "" { file, err := os.Create(util.ToUniversalPath(bdo.OutFileName)) if err != nil { return nil, err } return file, nil } return WriteNopCloser{os.Stdout}, nil } // GetBSONReader opens and returns an io.ReadCloser for the BSONFileName in BSONDumpOptions // or nil if none is set. The caller is responsible for closing it. func (bdo *BSONDumpOptions) GetBSONReader() (io.ReadCloser, error) { if bdo.BSONFileName != "" { file, err := os.Open(util.ToUniversalPath(bdo.BSONFileName)) if err != nil { return nil, fmt.Errorf("couldn't open BSON file: %v", err) } return file, nil } return ReadNopCloser{os.Stdin}, nil } func formatJSON(doc *bson.Raw, pretty bool) ([]byte, error) { decodedDoc := bson.D{} err := bson.Unmarshal(doc.Data, &decodedDoc) if err != nil { return nil, err } extendedDoc, err := bsonutil.ConvertBSONValueToJSON(decodedDoc) if err != nil { return nil, fmt.Errorf("error converting BSON to extended JSON: %v", err) } jsonBytes, err := json.Marshal(extendedDoc) if pretty { var jsonFormatted bytes.Buffer json.Indent(&jsonFormatted, jsonBytes, "", "\t") jsonBytes = jsonFormatted.Bytes() } if err != nil { return nil, fmt.Errorf("error converting doc to JSON: %v", err) } return jsonBytes, nil } // JSON iterates through the BSON file and for each document it finds, // recursively descends into objects and arrays and prints the human readable // JSON representation. // It returns the number of documents processed and a non-nil error if one is // encountered before the end of the file is reached. func (bd *BSONDump) JSON() (int, error) { numFound := 0 if bd.BSONSource == nil { panic("Tried to call JSON() before opening file") } decodedStream := db.NewDecodedBSONSource(bd.BSONSource) var result bson.Raw for decodedStream.Next(&result) { if bytes, err := formatJSON(&result, bd.BSONDumpOptions.Pretty); err != nil { log.Logvf(log.Always, "unable to dump document %v: %v", numFound+1, err) //if objcheck is turned on, stop now. otherwise keep on dumpin' if bd.BSONDumpOptions.ObjCheck { return numFound, err } } else { bytes = append(bytes, '\n') _, err := bd.Out.Write(bytes) if err != nil { return numFound, err } } numFound++ } if err := decodedStream.Err(); err != nil { return numFound, err } return numFound, nil } // Debug iterates through the BSON file and for each document it finds, // recursively descends into objects and arrays and prints a human readable // BSON representation containing the type and size of each field. // It returns the number of documents processed and a non-nil error if one is // encountered before the end of the file is reached. func (bd *BSONDump) Debug() (int, error) { numFound := 0 if bd.BSONSource == nil { panic("Tried to call Debug() before opening file") } var result bson.Raw for { doc := bd.BSONSource.LoadNext() if doc == nil { break } result.Data = doc if bd.BSONDumpOptions.ObjCheck { validated := bson.M{} err := bson.Unmarshal(result.Data, &validated) if err != nil { // ObjCheck is turned on and we hit an error, so short-circuit now. return numFound, fmt.Errorf("failed to validate bson during objcheck: %v", err) } } err := printBSON(result, 0, bd.Out) if err != nil { log.Logvf(log.Always, "encountered error debugging BSON data: %v", err) } numFound++ } if err := bd.BSONSource.Err(); err != nil { // This error indicates the BSON document header is corrupted; // either the 4-byte header couldn't be read in full, or // the size in the header would require reading more bytes // than the file has left return numFound, err } return numFound, nil } func printBSON(raw bson.Raw, indentLevel int, out io.Writer) error { indent := strings.Repeat("\t", indentLevel) fmt.Fprintf(out, "%v--- new object ---\n", indent) fmt.Fprintf(out, "%v\tsize : %v\n", indent, len(raw.Data)) //Convert raw into an array of RawD we can iterate over. var rawD bson.RawD err := bson.Unmarshal(raw.Data, &rawD) if err != nil { return err } for _, rawElem := range rawD { fmt.Fprintf(out, "%v\t\t%v\n", indent, rawElem.Name) // the size of an element is the combined size of the following: // 1. 1 byte for the BSON type // 2. 'e_name' : the BSON key, which is a null-terminated cstring // 3. The BSON value // So size == 1 [size of type byte] + 1 [null byte for cstring key] + len(bson key) + len(bson value) // see http://bsonspec.org/spec.html for more details fmt.Fprintf(out, "%v\t\t\ttype: %4v size: %v\n", indent, int8(rawElem.Value.Kind), 2+len(rawElem.Name)+len(rawElem.Value.Data)) //For nested objects or arrays, recurse. if rawElem.Value.Kind == 0x03 || rawElem.Value.Kind == 0x04 { err = printBSON(rawElem.Value, indentLevel+3, out) if err != nil { return err } } } return nil } mongo-tools-r3.6.3/bsondump/bsondump_test.go000066400000000000000000000110741321131462300212250ustar00rootroot00000000000000// Copyright (C) MongoDB, Inc. 2014-present. // // 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 package bsondump import ( "bytes" "os" "os/exec" "testing" . "github.com/smartystreets/goconvey/convey" ) func TestBsondump(t *testing.T) { Convey("Test bsondump reading from stdin and writing to stdout", t, func() { cmd := exec.Command("../bin/bsondump") // Attach a file to stdin of the command. inFile, err := os.Open("testdata/sample.bson") So(err, ShouldBeNil) cmd.Stdin = inFile // Attach a buffer to stdout of the command. cmdOutput := &bytes.Buffer{} cmd.Stdout = cmdOutput err = cmd.Run() So(err, ShouldBeNil) // Get the correct bsondump result from a file to use as a reference. outReference, err := os.Open("testdata/sample.json") So(err, ShouldBeNil) bufRef := new(bytes.Buffer) bufRef.ReadFrom(outReference) bufRefStr := bufRef.String() bufDumpStr := cmdOutput.String() So(bufDumpStr, ShouldEqual, bufRefStr) }) Convey("Test bsondump reading from stdin and writing to a file", t, func() { cmd := exec.Command("../bin/bsondump", "--outFile", "out.json") // Attach a file to stdin of the command. inFile, err := os.Open("testdata/sample.bson") So(err, ShouldBeNil) cmd.Stdin = inFile err = cmd.Run() So(err, ShouldBeNil) // Get the correct bsondump result from a file to use as a reference. outReference, err := os.Open("testdata/sample.json") So(err, ShouldBeNil) bufRef := new(bytes.Buffer) bufRef.ReadFrom(outReference) bufRefStr := bufRef.String() // Get the output from a file. outDump, err := os.Open("out.json") So(err, ShouldBeNil) bufDump := new(bytes.Buffer) bufDump.ReadFrom(outDump) bufDumpStr := bufDump.String() So(bufDumpStr, ShouldEqual, bufRefStr) }) Convey("Test bsondump reading from a file with --bsonFile and writing to stdout", t, func() { cmd := exec.Command("../bin/bsondump", "--bsonFile", "testdata/sample.bson") // Attach a buffer to stdout of the command. cmdOutput := &bytes.Buffer{} cmd.Stdout = cmdOutput err := cmd.Run() So(err, ShouldBeNil) // Get the correct bsondump result from a file to use as a reference. outReference, err := os.Open("testdata/sample.json") So(err, ShouldBeNil) bufRef := new(bytes.Buffer) bufRef.ReadFrom(outReference) bufRefStr := bufRef.String() bufDumpStr := cmdOutput.String() So(bufDumpStr, ShouldEqual, bufRefStr) }) Convey("Test bsondump reading from a file with a positional arg and writing to stdout", t, func() { cmd := exec.Command("../bin/bsondump", "testdata/sample.bson") // Attach a buffer to stdout of command. cmdOutput := &bytes.Buffer{} cmd.Stdout = cmdOutput err := cmd.Run() So(err, ShouldBeNil) // Get the correct bsondump result from a file to use as a reference. outReference, err := os.Open("testdata/sample.json") So(err, ShouldBeNil) bufRef := new(bytes.Buffer) bufRef.ReadFrom(outReference) bufRefStr := bufRef.String() bufDumpStr := cmdOutput.String() So(bufDumpStr, ShouldEqual, bufRefStr) }) Convey("Test bsondump reading from a file with --bsonFile and writing to a file", t, func() { cmd := exec.Command("../bin/bsondump", "--outFile", "out.json", "--bsonFile", "testdata/sample.bson") err := cmd.Run() So(err, ShouldBeNil) // Get the correct bsondump result from a file to use as a reference. outReference, err := os.Open("testdata/sample.json") So(err, ShouldBeNil) bufRef := new(bytes.Buffer) bufRef.ReadFrom(outReference) bufRefStr := bufRef.String() // Get the output from a file. outDump, err := os.Open("out.json") So(err, ShouldBeNil) bufDump := new(bytes.Buffer) bufDump.ReadFrom(outDump) bufDumpStr := bufDump.String() So(bufDumpStr, ShouldEqual, bufRefStr) }) Convey("Test bsondump reading from a file with a positional arg and writing to a file", t, func() { cmd := exec.Command("../bin/bsondump", "--outFile", "out.json", "testdata/sample.bson") err := cmd.Run() So(err, ShouldBeNil) // Get the correct bsondump result from a file to use as a reference. outReference, err := os.Open("testdata/sample.json") So(err, ShouldBeNil) bufRef := new(bytes.Buffer) bufRef.ReadFrom(outReference) bufRefStr := bufRef.String() // Get the output from a file. outDump, err := os.Open("out.json") So(err, ShouldBeNil) bufDump := new(bytes.Buffer) bufDump.ReadFrom(outDump) bufDumpStr := bufDump.String() So(bufDumpStr, ShouldEqual, bufRefStr) }) } mongo-tools-r3.6.3/bsondump/main/000077500000000000000000000000001321131462300167315ustar00rootroot00000000000000mongo-tools-r3.6.3/bsondump/main/bsondump.go000066400000000000000000000054071321131462300211150ustar00rootroot00000000000000// Copyright (C) MongoDB, Inc. 2014-present. // // 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 // Main package for the bsondump tool. package main import ( "github.com/mongodb/mongo-tools/bsondump" "github.com/mongodb/mongo-tools/common/db" "github.com/mongodb/mongo-tools/common/log" "github.com/mongodb/mongo-tools/common/options" "github.com/mongodb/mongo-tools/common/signals" "github.com/mongodb/mongo-tools/common/util" "os" ) func main() { // initialize command-line opts opts := options.New("bsondump", bsondump.Usage, options.EnabledOptions{}) bsonDumpOpts := &bsondump.BSONDumpOptions{} opts.AddOptions(bsonDumpOpts) args, err := opts.ParseArgs(os.Args[1:]) if err != nil { log.Logvf(log.Always, "error parsing command line options: %v", err) log.Logvf(log.Always, "try 'bsondump --help' for more information") os.Exit(util.ExitBadOptions) } // print help, if specified if opts.PrintHelp(false) { return } // print version, if specified if opts.PrintVersion() { return } log.SetVerbosity(opts.Verbosity) signals.Handle() if len(args) > 1 { log.Logvf(log.Always, "too many positional arguments: %v", args) log.Logvf(log.Always, "try 'bsondump --help' for more information") os.Exit(util.ExitBadOptions) } // If the user specified a bson input file if len(args) == 1 { if bsonDumpOpts.BSONFileName != "" { log.Logvf(log.Always, "Cannot specify both a positional argument and --bsonFile") os.Exit(util.ExitBadOptions) } bsonDumpOpts.BSONFileName = args[0] } dumper := bsondump.BSONDump{ ToolOptions: opts, BSONDumpOptions: bsonDumpOpts, } reader, err := bsonDumpOpts.GetBSONReader() if err != nil { log.Logvf(log.Always, "Getting BSON Reader Failed: %v", err) os.Exit(util.ExitError) } dumper.BSONSource = db.NewBSONSource(reader) defer dumper.BSONSource.Close() writer, err := bsonDumpOpts.GetWriter() if err != nil { log.Logvf(log.Always, "Getting Writer Failed: %v", err) os.Exit(util.ExitError) } dumper.Out = writer defer dumper.Out.Close() log.Logvf(log.DebugLow, "running bsondump with --objcheck: %v", bsonDumpOpts.ObjCheck) if len(bsonDumpOpts.Type) != 0 && bsonDumpOpts.Type != "debug" && bsonDumpOpts.Type != "json" { log.Logvf(log.Always, "Unsupported output type '%v'. Must be either 'debug' or 'json'", bsonDumpOpts.Type) os.Exit(util.ExitBadOptions) } var numFound int if bsonDumpOpts.Type == "debug" { numFound, err = dumper.Debug() } else { numFound, err = dumper.JSON() } log.Logvf(log.Always, "%v objects found", numFound) if err != nil { log.Logv(log.Always, err.Error()) os.Exit(util.ExitError) } } mongo-tools-r3.6.3/bsondump/options.go000066400000000000000000000025021321131462300200260ustar00rootroot00000000000000// Copyright (C) MongoDB, Inc. 2014-present. // // 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 package bsondump var Usage = ` View and debug .bson files. See http://docs.mongodb.org/manual/reference/program/bsondump/ for more information.` type BSONDumpOptions struct { // Format to display the BSON data file Type string `long:"type" value-name:"" default:"json" default-mask:"-" description:"type of output: debug, json (default 'json')"` // Validate each BSON document before displaying ObjCheck bool `long:"objcheck" description:"validate BSON during processing"` // Display JSON data with indents Pretty bool `long:"pretty" description:"output JSON formatted to be human-readable"` // Path to input BSON file BSONFileName string `long:"bsonFile" description:"path to BSON file to dump to JSON; default is stdin"` // Path to output file OutFileName string `long:"outFile" description:"path to output file to dump BSON to; default is stdout"` } func (_ *BSONDumpOptions) Name() string { return "output" } func (_ *BSONDumpOptions) PostParse() error { return nil } func (_ *BSONDumpOptions) Validate() error { return nil } mongo-tools-r3.6.3/bsondump/testdata/000077500000000000000000000000001321131462300176165ustar00rootroot00000000000000mongo-tools-r3.6.3/bsondump/testdata/sample.bson000066400000000000000000000004331321131462300217620ustar00rootroot00000000000000R_idTfQçKöäË|Sað?bI am a stringcçQfTd TEST T3STR_idTfQ÷KöäË|Sa@bI am a stringc÷QfTd TEST T3SC0_idTfRKöäË|Sa@bstring2G_idTfR%KöäË|Sa ×£p= @bstring3ckeyvaluemongo-tools-r3.6.3/bsondump/testdata/sample.json000066400000000000000000000007251321131462300217760ustar00rootroot00000000000000{"_id":{"$oid":"546651e74bf6e4cb017c5312"},"a":1.0,"b":"I am a string","c":{"$timestamp":{"t":1415991783,"i":1}},"d":{"$binary":"VEVTVCBUM1NU","$type":"00"}} {"_id":{"$oid":"546651f74bf6e4cb017c5313"},"a":2.5,"b":"I am a string","c":{"$timestamp":{"t":1415991799,"i":1}},"d":{"$binary":"VEVTVCBUM1ND","$type":"00"}} {"_id":{"$oid":"546652084bf6e4cb017c5314"},"a":4.0,"b":"string2"} {"_id":{"$oid":"546652254bf6e4cb017c5315"},"a":4.01,"b":"string3","c":{"key":"value"}} mongo-tools-r3.6.3/build.bat000066400000000000000000000005351321131462300157500ustar00rootroot00000000000000@echo off REM This is not handling tags if exist "%cd%\vendor\pkg" rd /s /q "%cd%\vendor\pkg" call set_gopath.bat if not exist "%cd%\bin" mkdir "%cd%\bin" for %%i in (bsondump, mongostat, mongofiles, mongoexport, mongoimport, mongorestore, mongodump, mongotop) do ( echo Building %%i go build -o "%cd%\bin\%%i.exe" "%cd%\%%i\main\%%i.go" ) mongo-tools-r3.6.3/build.sh000077500000000000000000000015361321131462300156210ustar00rootroot00000000000000#!/bin/sh set -o errexit tags="" if [ ! -z "$1" ] then tags="$@" fi # make sure we're in the directory where the script lives SCRIPT_DIR="$(cd "$(dirname ${BASH_SOURCE[0]})" && pwd)" cd $SCRIPT_DIR sed -i.bak -e "s/built-without-version-string/$(git describe)/" \ -e "s/built-without-git-spec/$(git rev-parse HEAD)/" \ common/options/options.go # remove stale packages rm -rf vendor/pkg . ./set_gopath.sh mkdir -p bin ec=0 for i in bsondump mongostat mongofiles mongoexport mongoimport mongorestore mongodump mongotop mongoreplay; do echo "Building ${i}..." go build -o "bin/$i" -tags "$tags" "$i/main/$i.go" || { echo "Error building $i"; ec=1; break; } ./bin/$i --version | head -1 done if [ -t /dev/stdin ]; then stty sane fi mv -f common/options/options.go.bak common/options/options.go exit $ec mongo-tools-r3.6.3/common.yml000066400000000000000000001471451321131462300162050ustar00rootroot00000000000000####################################### # Tools Driver Config for MCI # ####################################### # default command type command_type: system # run the same task in the previous revision if the current task fails stepback: true mongo_tools_variables: ## List of tests to run on each buildvariant mongo_tools_task_lists: mac_1012_task_list: &macos_1012_tasks - name: db - name: dist - name: integration - name: integration-auth - name: legacy28 - name: legacy26 - name: qa-tests - name: qa-tests-3.2 - name: qa-tests-3.4 - name: qa-dump-restore-gzip - name: qa-dump-restore-gzip-3.2 - name: qa-dump-restore-archiving - name: qa-dump-restore-archiving-3.2 - name: unit # disabled until BUILD-2273 is done # - name: replay-dist # - name: replay-sanity_check # - name: replay-go_test # - name: replay-auth_test # - name: replay-sharded_test # - name: replay-repl_test # - name: replay-replay_test macos_1012_ssl_task_list: &macos_1012_ssl_tasks - name: dist - name: qa-tests - name: native-cert-ssl ubuntu1404_task_list: &ubuntu1404_tasks - name: db - name: dist - name: integration - name: integration-auth - name: legacy28 - name: legacy28-wt - name: lint-go - name: lint-js - name: qa-tests - name: qa-tests-3.2 - name: qa-tests-3.4 - name: qa-tests-unstable - name: qa-dump-restore-gzip - name: qa-dump-restore-gzip-3.2 - name: qa-dump-restore-archiving - name: qa-dump-restore-archiving-3.2 - name: unit - name: vet - name: replay-dist - name: replay-sanity_check - name: replay-go_test - name: replay-auth_test - name: replay-sharded_test - name: replay-repl_test - name: replay-replay_test ubuntu1404_ssl_task_list: &ubuntu1404_ssl_tasks - name: dist - name: integration - name: integration-auth - name: legacy28 - name: qa-tests - name: qa-tests-unstable - name: native-cert-ssl ubuntu1404_enterprise_task_list: &ubuntu1404_enterprise_tasks - name: db - name: dist - name: integration - name: integration-auth - name: kerberos - name: legacy28 - name: legacy26 - name: qa-tests - name: native-cert-ssl - name: replay-dist - name: replay-sanity_check - name: replay-go_test - name: replay-auth_test - name: replay-sharded_test - name: replay-repl_test - name: replay-replay_test ubuntu1404_race_task_list: &ubuntu1404_race_tasks - name: db - name: dist - name: integration - name: integration-auth - name: legacy28 - name: legacy28-wt - name: legacy26 - name: qa-tests - name: unit - name: replay-dist - name: replay-sanity_check - name: replay-go_test - name: replay-auth_test - name: replay-sharded_test - name: replay-repl_test - name: replay-replay_test windows_64_task_list: &windows_64_tasks - name: db - name: dist - name: integration - name: integration-auth - name: legacy28 distros: - windows-64-vs2013-test - name: qa-tests distros: - windows-64-vs2013-test - name: qa-tests-3.2 distros: - windows-64-vs2013-test - name: qa-tests-3.4 distros: - windows-64-vs2013-test - name: qa-dump-restore-archiving distros: - windows-64-vs2013-test - name: qa-dump-restore-archiving-3.2 distros: - windows-64-vs2013-test - name: qa-dump-restore-gzip distros: - windows-64-vs2013-test - name: qa-dump-restore-gzip-3.2 distros: - windows-64-vs2013-test - name: qa-tests-unstable - name: unit windows_64_ssl_task_list: &windows_64_ssl_tasks - name: dist - name: integration - name: integration-auth - name: legacy28 - name: qa-tests - name: native-cert-ssl windows_64_enterprise_task_list: &windows_64_enterprise_tasks - name: db - name: dist - name: integration - name: integration-auth - name: kerberos - name: legacy28 distros: - windows-64-vs2013-test - name: qa-tests distros: - windows-64-vs2013-test - name: unit - name: native-cert-ssl rhel71_enterprise_task_list: &rhel71_enterprise_tasks - name: db - name: dist - name: integration - name: integration-auth #- name: kerberos - name: qa-dump-restore-archiving - name: qa-dump-restore-gzip - name: qa-tests - name: qa-tests-unstable - name: native-cert-ssl # disabled until BUILD-2273 is done # - name: replay-dist # - name: replay-sanity_check # - name: replay-go_test # - name: replay-auth_test # - name: replay-sharded_test # - name: replay-repl_test # - name: replay-replay_test rhel72_enterprise_task_list: &rhel72_enterprise_tasks - name: db - name: dist - name: integration - name: integration-auth - name: kerberos - name: qa-dump-restore-archiving - name: qa-dump-restore-gzip - name: qa-tests-unstable - name: native-cert-ssl # disabled until BUILD-2273 is done # - name: replay-dist # - name: replay-sanity_check # - name: replay-go_test # - name: replay-auth_test # - name: replay-sharded_test # - name: replay-repl_test # - name: replay-replay_test ubuntu1604_ssl_task_list: &ubuntu1604_ssl_tasks - name: db - name: dist - name: integration - name: integration-auth - name: qa-dump-restore-archiving - name: qa-dump-restore-gzip - name: qa-tests-unstable - name: native-cert-ssl ## Common mongodb arguments mongod_arguments: default: &mongod_default_startup_args mongod_args: "" mongod_port: 33333 ssl: &mongod_ssl_startup_args mongod_args: "--sslMode requireSSL --sslCAFile common/db/openssl/testdata/ca.pem --sslPEMKeyFile common/db/openssl/testdata/server.pem" mongod_port: 33333 # Set storage engine as mmapv1 for 32 bit variants because WiredTiger requires 64 bit support. win32: &mongod_win32_startup_args mongod_args: "--storageEngine=mmapv1" mongod_port: 33333 mongo_arguments: default: &mongo_default_startup_args mongo_args: &mongo_default_startup_args_string "--port 33333" mongod_port: 33333 ssl: &mongo_ssl_startup_args mongo_args: "--port 33333 --ssl --sslCAFile ./common/db/openssl/testdata/ca.pem --sslPEMKeyFile ./common/db/openssl/testdata/server.pem --sslAllowInvalidCertificates" mongod_port: 33333 functions: "run legacy tests": command: shell.exec type: test params: working_dir: src script: | set -x set -v set -e chmod +x bin/* mv bin/* ${test_path}/ cd ${test_path} python buildscripts/smoke.py ${smoke_use_ssl} --nopreallocj --with-cleanbb --mongod ./mongod --mongo ./mongo --report-file ../../report.json --continue-on-failure --buildlogger-builder MCI_${build_variant} --buildlogger-buildnum ${builder_num|} --buildlogger-credentials ./mci.buildlogger --buildlogger-phase ${task_name}_${execution} ${smoke_args} tool "run qa-tests": command: shell.exec type: test params: working_dir: src script: | set -x set -v set -e chmod +x bin/* mv bin/* test/qa-tests/ cd test/qa-tests rm -rf /data/mci/install /data/mci/multiversion mkdir -p /data/mci/install /data/mci/multiversion if [ "${multiversion_override}" != "skip" ]; then python buildscripts/setup_multiversion_mongodb.py /data/mci/install /data/mci/multiversion ${arch} ${multiversion_override|2.6} --latest ${smoke_use_ssl} --os="${mongo_os}" fi chmod 400 jstests/libs/key* PATH=$PATH:/data/mci/multiversion python buildscripts/resmoke.py --suite=${resmoke_suite} --continueOnFailure --log=buildlogger --reportFile=../../report.json ${resmoke_args} --excludeWithAnyTags="${excludes}" "build tool": command: shell.exec type: test params: working_dir: src script: | set -x set -v set -e echo "Building ${tool}..." if [ "Windows_NT" = "$OS" ]; then set -o igncr fi; # In RHEL 5.5, /usr/bin/ld can't handle --build-id parameters, so # use a wrapper if it's present on the system # if [ -d /opt/ldwrapper/bin ] then export PATH=/opt/ldwrapper/bin:$PATH fi sed -i.bak "s/built-without-version-string/$(git describe)/" common/options/options.go sed -i.bak "s/built-without-git-spec/$(git rev-parse HEAD)/" common/options/options.go . ./set_gopath.sh ${gorootvars} go build ${args} -tags "failpoints ${build_tags}" -o bin/${tool} ${tool}/main/${tool}.go ./bin/${tool} --version "download mongod": command: shell.exec params: working_dir: src script: | set -x set -v set -e mongotarget=$(if [ "${mongo_target}" ]; then echo "${mongo_target}"; else echo "${mongo_os}"; fi) mongoversion=$(if [ "${mongo_version_always_use_latest}" ]; then echo "latest"; else echo "${mongo_version}"; fi) dlurl=$(python binaryurl.py --edition=${mongo_edition} --target=$mongotarget --version=$mongoversion --arch=${mongo_arch|x86_64}) filename=$(echo $dlurl | sed -e "s_.*/__") mkdir -p bin curl -s $dlurl --output $filename ${decompress} $filename rm $filename if [ "${only_shell}" ]; then mv -f ./mongodb-*/bin/mongo${extension} ./bin/ else mv -f ./mongodb-*/bin/mongo${extension} ./bin/ mv -f ./mongodb-*/bin/mongos${extension} ./bin/ mv -f ./mongodb-*/bin/mongod${extension} ./bin/ fi chmod +x ./bin/* rm -rf ./mongodb-* "fetch tool" : command: s3.get params: bucket: mciuploads aws_key: ${aws_key} aws_secret: ${aws_secret} local_file: src/bin/${tool}${extension} remote_file: mongo-tools/binaries/${build_id}/${edition|community}/${tool}${extension} "generate coverage html + text": command: shell.exec type: test params: working_dir: src script: | set -x set -v set -e if [ "${coverage}" = "true" ]; then if [ "Windows_NT" = "$OS" ]; then set -o igncr fi; . ./set_gopath.sh ${gorootvars} go tool cover -html=coverage.out -o coverage.html ${gorootvars} go tool cover -func=coverage.out -o coverage.txt fi; "get buildnumber": command: keyval.inc params: key: "${build_variant}_tools" destination: "builder_num" "move coverage data": command: shell.exec params: working_dir: src script: | set -x set -v set -e if [ "${coverage}" = "true" ]; then mv ${package}/coverage.out . fi "run unit test": command: shell.exec type: test params: working_dir: src script: | set -x set -v if [ "Windows_NT" = "$OS" ]; then set -o igncr fi; . ./set_gopath.sh export MONGODB_KERBEROS_PASSWORD=${kerberos_password} export basedir=$PWD cd ${package} ${gorootvars} go test ${coverage_args} ${args} -tags "${build_tags}" -test.v > unit.suite export exitcode=$? cat unit.suite cp unit.suite $basedir/. exit $exitcode "setup integration test": command: shell.exec params: working_dir: src # Set up Kerberos stuff: run kinit if necessary, and add KDC to registry # on Windows (see https://wiki.mongodb.com/display/DH/Testing+Kerberos) script: | set -x set -v set -e if [ '${run_kinit}' = 'true' ] then echo "${kerberos_password}" | kinit -p drivers@LDAPTEST.10GEN.CC; fi; if [ "Windows_NT" = "$OS" ]; then cmd /c "REG ADD HKLM\SYSTEM\ControlSet001\Control\Lsa\Kerberos\Domains\LDAPTEST.10GEN.CC /v KdcNames /d ldaptest.10gen.cc /t REG_MULTI_SZ /f" fi; "setup permissions": command: shell.exec params: working_dir: src script: | set -x set -v set -e chmod 700 set_gopath.sh "run tool unit tests": command: shell.exec type: test params: working_dir: src script: | set -x set -v if [ "Windows_NT" = "$OS" ]; then set -o igncr fi; . ./set_gopath.sh # run unit tests under common package for i in archive bsonutil failpoint intents json log options progress text util; do cd common/$i COMMON_SUBPKG=$i COVERAGE_ARGS="" if [ "${run_coverage}" ]; then COVERAGE_ARGS="-coverprofile=coverage_$COMMON_SUBPKG.out" fi; ${gorootvars} go test $COVERAGE_ARGS ${args} -tags "failpoints ${build_tags}" -test.v > $COMMON_SUBPKG.suite if [ $? -ne 0 ]; then echo "suite failed, will exit with error on finish" export exitcode=1 fi cat $COMMON_SUBPKG.suite cp $COMMON_SUBPKG.suite ../../ cd ../.. done #TODO mongotop needs a test for i in mongoimport mongoexport mongostat mongorestore mongodump mongofiles; do cd $i COVERAGE_ARGS="" if [ "${run_coverage}" ]; then COVERAGE_ARGS="-coverprofile=coverage_$i.out" fi; ${gorootvars} go test $COVERAGE_ARGS ${args} -tags "${build_tags}" -test.v > $i.suite if [ $? -ne 0 ]; then echo "suite failed, will exit with error on finish" export exitcode=1 fi cat $i.suite cp $i.suite ../. cd .. done exit $exitcode "run tool integration tests": command: shell.exec type: test params: working_dir: src script: | set -x set -v if [ "Windows_NT" = "$OS" ]; then set -o igncr export MONGODB_KERBEROS_PASSWORD=${kerberos_password} fi; . ./set_gopath.sh if [ "${create_mongod_users_command}" != "" ]; then export AUTH_USERNAME=${auth_username} export AUTH_PASSWORD=${auth_password} echo "${create_mongod_users_command}" | ./bin/mongo${extension} ${mongo_args} admin fi; for i in mongoimport mongoexport mongostat mongorestore mongodump mongofiles; do cd $i COVERAGE_ARGS="" if [ "${run_coverage}" ]; then COVERAGE_ARGS="-coverprofile=coverage_$i.out" fi; ${gorootvars} go test $COVERAGE_ARGS -test.v ${args} -tags "${build_tags}" > $i.suite if [ $? -ne 0 ]; then echo "suite failed, will exit with error on finish" export exitcode=1 fi cat $i.suite cp $i.suite ../. cd .. done exit $exitcode "create coverage reports": command: shell.exec type: test params: working_dir: src script: | set -x set -v set -e set -o verbose if [ "Windows_NT" = "$OS" ]; then set -o igncr fi; . ./set_gopath.sh for i in mongoimport mongoexport mongostat mongorestore mongodump mongofiles; do cd $i perl -pe 's/.*src/github.com\/mongodb\/mongo-tools/' coverage_$i.out > coverage_$i_rewrite.out ${gorootvars} go tool cover -html=coverage_$i_rewrite.out -o coverage_$i.html ${gorootvars} go tool cover -func=coverage_$i_rewrite.out -o coverage_$i.txt cd .. done "upload html coverage": command: s3.put params: aws_key: ${aws_key} aws_secret: ${aws_secret} local_file: src/${coverage_pkg}/coverage_${coverage_pkg}.html remote_file: mongo-tools/coverage/${coverage_pkg}/${task_id}.html bucket: mciuploads permissions: public-read content_type: text/html build_variants: ["ubuntu", "windows-64"] display_name: ${coverage_pkg}-html "upload text coverage": command: s3.put params: aws_key: ${aws_key} aws_secret: ${aws_secret} local_file: src/${coverage_pkg}/coverage_${coverage_pkg}.txt remote_file: mongo-tools/coverage/${coverage_pkg}/${task_id}.txt bucket: mciuploads permissions: public-read content_type: text/plain build_variants: ["ubuntu", "windows-64"] display_name: ${coverage_pkg}-text "setup credentials" : command: shell.exec params: working_dir: src silent: true script: | set -x set -v set -e cat > mci.buildlogger < ${filename}.suite pre: - command: shell.exec params: silent: true script: | set -x set -v ${killall_mci|pkill -9 mongo; pkill -9 mongodump; pkill -9 mongoexport; pkill -9 mongoimport; pkill -9 mongofiles; pkill -9 mongorestore; pkill -9 mongostat; pkill -9 mongotop; pkill -9 mongod; pkill -9 mongos; pkill -f buildlogger.py; pkill -f smoke.py} >/dev/null 2>&1 rm -rf src /data/db/* exit 0 post: - command: attach.results params: file_location: src/report.json - command: shell.exec params: silent: true script: | set -x set -v ${killall_mci|pkill -9 mongo; pkill -9 mongodump; pkill -9 mongoexport; pkill -9 mongoimport; pkill -9 mongofiles; pkill -9 mongorestore; pkill -9 mongostat; pkill -9 mongotop; pkill -9 mongod; pkill -9 mongos; pkill -f buildlogger.py; pkill -f smoke.py} >/dev/null 2>&1 exit 0 - command: gotest.parse_files params: files: ["src/*.suite"] - command: shell.exec params: script: | set -x set -v rm -rf /data/db/* rm -rf /data/mci/multiversion rm -rf /data/mci/install exit 0 timeout: - command: shell.exec params: silent: true script: | set -x set -v # don't attempt to abort on any distro which has a special way of # killing everything (i.e. using taskkill on Windows) if [ "${killall_mci}" = "" ]; then all_tools="bsondump mongodump mongoexport mongofiles mongoimport mongorestore mongostat mongotop" # send SIGABRT to print a stacktrace for any hung tool pkill -ABRT "^($(echo -n $all_tools | tr ' ' '|'))\$" # git the processes a second or two to dump their stacks sleep 10 fi tasks: - name: db commands: - func: "fetch source" - command: expansions.update params: updates: - key: "package" value: "common/db" - key: "args" value: "${args} -test.types=db" - func: "download mongod" vars: mongo_version: "3.6" - func: "start mongod" - func: "wait for mongod to be ready" - func: "setup integration test" - func: "run unit test" - name: dist depends_on: commands: - func: "fetch source" # bsondump - func: "build tool" vars: tool: bsondump - func: "upload tool" vars: tool: bsondump # mongodump - func: "build tool" vars: tool: mongodump - func: "upload tool" vars: tool: mongodump # mongoexport - func: "build tool" vars: tool: mongoexport - func: "upload tool" vars: tool: mongoexport # mongofiles - func: "build tool" vars: tool: mongofiles - func: "upload tool" vars: tool: mongofiles # mongoimport - func: "build tool" vars: tool: mongoimport - func: "upload tool" vars: tool: mongoimport # mongorestore - func: "build tool" vars: tool: mongorestore - func: "upload tool" vars: tool: mongorestore # mongostat - func: "build tool" vars: tool: mongostat - func: "upload tool" vars: tool: mongostat # mongotop - func: "build tool" vars: tool: mongotop - func: "upload tool" vars: tool: mongotop - name: integration commands: - func: "fetch source" - command: expansions.update params: updates: - key: "args" value: "${args} -test.types=${integration_test_args}" - func: "download mongod" vars: mongo_version: "3.6" - func: "start mongod" - func: "wait for mongod to be ready" - func: "run tool integration tests" - name: integration-auth commands: - func: "fetch source" # Concat auth args - command: expansions.update params: updates: - key: "args" value: "${args} -test.types=${integration_test_args},auth" - key: "mongod_args" concat: " --auth" - key: "auth_username" value: "passwordIsTaco" - key: "auth_password" value: "Taco" - key: "create_mongod_users_command" value: "db.createUser({ user: '${auth_username}', pwd: '${auth_password}', roles: [{ role: '__system', db: 'admin' }] });" - func: "download mongod" vars: mongo_version: "3.6" - func: "start mongod" - func: "wait for mongod to be ready" - func: "run tool integration tests" - name: kerberos commands: - func: "fetch source" # Explicitly run ONLY Kerberos tests - command: expansions.update params: updates: - key: "args" value: "${args} -test.types=kerberos" - func: "setup integration test" - func: "run tool integration tests" - name: legacy28 depends_on: - name: dist commands: - func: "fetch source" - func: "get buildnumber" - func: "setup credentials" - func: "download mongod" vars: mongo_version: "3.0" - func: "fetch tool" vars: tool: mongoimport - func: "fetch tool" vars: tool: mongoexport - func: "fetch tool" vars: tool: mongodump - func: "fetch tool" vars: tool: mongostat - func: "fetch tool" vars: tool: mongorestore - func: "fetch tool" vars: tool: mongofiles - func: "run legacy tests" vars: test_path: "test/legacy28" smoke_args: "--authMechanism SCRAM-SHA-1" - name: legacy28-wt depends_on: - name: dist commands: - func: "fetch source" - func: "get buildnumber" - func: "setup credentials" - func: "download mongod" vars: mongo_version: "3.0" - func: "fetch tool" vars: tool: mongoimport - func: "fetch tool" vars: tool: mongoexport - func: "fetch tool" vars: tool: mongodump - func: "fetch tool" vars: tool: mongostat - func: "fetch tool" vars: tool: mongorestore - func: "fetch tool" vars: tool: mongofiles - func: "run legacy tests" vars: test_path: "test/legacy28" smoke_args: "--authMechanism SCRAM-SHA-1 --storageEngine=wiredTiger" - name: legacy26 depends_on: - name: dist commands: - func: "fetch source" - func: "get buildnumber" - func: "setup credentials" - func: "download mongod" vars: mongo_version: "2.6" - func: "fetch tool" vars: tool: mongoimport - func: "fetch tool" vars: tool: mongoexport - func: "fetch tool" vars: tool: mongodump - func: "fetch tool" vars: tool: mongostat - func: "fetch tool" vars: tool: mongorestore - func: "fetch tool" vars: tool: mongofiles - func: "run legacy tests" vars: test_path: "test/legacy26" smoke_use_ssl: "" - name: lint-go commands: - func: "fetch source" - command: shell.exec type: test params: working_dir: src script: | set -x set -v set -e ${gorootvars} retVal=$(. ./set_gopath.sh && go run vendor/src/github.com/3rf/mongo-lint/golint/golint.go mongo* bson* common/*); if [ "$retVal" = "" ]; then exit 0; else echo $retVal; exit 1; fi; - name: lint-js commands: - func: "fetch source" - command: shell.exec type: test params: working_dir: src script: | set -x set -v set -e PATH="/opt/node/bin:$PATH" /opt/node/bin/npm install eslint@3.2 /opt/node/bin/node node_modules/eslint/bin/eslint.js test/qa-tests/jstests/**/*.js - name: qa-tests-unstable depends_on: - name: dist commands: - func: "fetch source" - func: "get buildnumber" - func: "setup credentials" - func: "download mongod" vars: mongo_version: "latest" - func: "fetch tool" vars: tool: mongoimport - func: "fetch tool" vars: tool: mongoexport - func: "fetch tool" vars: tool: mongodump - func: "fetch tool" vars: tool: mongorestore - func: "fetch tool" vars: tool: mongostat - func: "fetch tool" vars: tool: mongotop - func: "fetch tool" vars: tool: mongofiles - func: "fetch tool" vars: tool: bsondump - func: "run qa-tests" vars: resmoke_suite: "core${resmoke_use_ssl}" - name: qa-tests depends_on: - name: dist commands: - func: "fetch source" - func: "get buildnumber" - func: "setup credentials" - func: "download mongod" vars: mongo_version: "3.6" - func: "fetch tool" vars: tool: mongoimport - func: "fetch tool" vars: tool: mongoexport - func: "fetch tool" vars: tool: mongodump - func: "fetch tool" vars: tool: mongorestore - func: "fetch tool" vars: tool: mongostat - func: "fetch tool" vars: tool: mongotop - func: "fetch tool" vars: tool: mongofiles - func: "fetch tool" vars: tool: bsondump - func: "run qa-tests" vars: resmoke_suite: "core${resmoke_use_ssl}" excludes: "requires_unstable,${excludes}" - name: qa-tests-3.4 depends_on: - name: dist commands: - func: "fetch source" - func: "get buildnumber" - func: "setup credentials" - func: "download mongod" vars: mongo_version: "3.4" - func: "fetch tool" vars: tool: mongoimport - func: "fetch tool" vars: tool: mongoexport - func: "fetch tool" vars: tool: mongodump - func: "fetch tool" vars: tool: mongorestore - func: "fetch tool" vars: tool: mongostat - func: "fetch tool" vars: tool: mongotop - func: "fetch tool" vars: tool: mongofiles - func: "fetch tool" vars: tool: bsondump - func: "run qa-tests" vars: resmoke_suite: "core${resmoke_use_ssl}" excludes: "requires_unstable,requires_mongo_36,${excludes}" - name: qa-tests-3.2 depends_on: - name: dist commands: - func: "fetch source" - func: "get buildnumber" - func: "setup credentials" - func: "download mongod" vars: mongo_version: "3.2" - func: "fetch tool" vars: tool: mongoimport - func: "fetch tool" vars: tool: mongoexport - func: "fetch tool" vars: tool: mongodump - func: "fetch tool" vars: tool: mongorestore - func: "fetch tool" vars: tool: mongostat - func: "fetch tool" vars: tool: mongotop - func: "fetch tool" vars: tool: mongofiles - func: "fetch tool" vars: tool: bsondump - func: "run qa-tests" vars: resmoke_suite: "core${resmoke_use_ssl}" excludes: "requires_unstable,requires_mongo_34,requires_mongo_36,${excludes}" - name: native-cert-ssl depends_on: - name: dist commands: - func: "fetch source" - func: "get buildnumber" - func: "setup credentials" - func: "download mongod" vars: mongo_version: "3.6" - func: "fetch tool" vars: tool: mongoimport - func: "fetch tool" vars: tool: mongoexport - func: "fetch tool" vars: tool: mongodump - func: "fetch tool" vars: tool: mongorestore - func: "fetch tool" vars: tool: mongostat - func: "fetch tool" vars: tool: mongotop - func: "fetch tool" vars: tool: mongofiles - func: "fetch tool" vars: tool: bsondump - command: shell.exec type: test params: working_dir: src/test/qa-tests script: | set -x set -v set -e chmod +x ../../bin/* mv ../../bin/* . rm -rf /data/mci/install /data/mci/multiversion mkdir -p /data/mci/install /data/mci/multiversion python buildscripts/setup_multiversion_mongodb.py /data/mci/install /data/mci/multiversion ${arch} "2.6" --latest ${smoke_use_ssl} --os="${mongo_os}" || true chmod 400 jstests/libs/key* PATH=$PATH:/data/mci/multiversion python buildscripts/resmoke.py --suite=native_cert_ssl --continueOnFailure --log=buildlogger --reportFile=../../report.json ${resmoke_args} --excludeWithAnyTags="${excludes}" - name: qa-dump-restore-archiving depends_on: - name: dist commands: - func: "fetch source" - func: "get buildnumber" - func: "setup credentials" - func: "download mongod" vars: mongo_version: "3.6" - func: "fetch tool" vars: tool: mongodump - func: "fetch tool" vars: tool: mongorestore - func: "run qa-tests" vars: resmoke_suite: "restore_archive" excludes: "requires_unstable,${excludes}" - name: qa-dump-restore-archiving-3.2 depends_on: - name: dist commands: - func: "fetch source" - func: "get buildnumber" - func: "setup credentials" - func: "download mongod" vars: mongo_version: "3.2" - func: "fetch tool" vars: tool: mongodump - func: "fetch tool" vars: tool: mongorestore - func: "run qa-tests" vars: resmoke_suite: "restore_archive" excludes: "requires_unstable,requires_mongo_34,requires_mongo_36,${excludes}" - name: qa-dump-restore-gzip depends_on: - name: dist commands: - func: "fetch source" - func: "get buildnumber" - func: "setup credentials" - func: "download mongod" vars: mongo_version: "3.6" - func: "fetch tool" vars: tool: mongodump - func: "fetch tool" vars: tool: mongorestore - func: "run qa-tests" vars: resmoke_suite: "restore_gzip" excludes: "requires_unstable,${excludes}" - name: qa-dump-restore-gzip-3.2 depends_on: - name: dist commands: - func: "fetch source" - func: "get buildnumber" - func: "setup credentials" - func: "download mongod" vars: mongo_version: "3.2" - func: "fetch tool" vars: tool: mongodump - func: "fetch tool" vars: tool: mongorestore - func: "run qa-tests" vars: resmoke_suite: "restore_gzip" excludes: "requires_unstable,requires_mongo_34,requires_mongo_36,${excludes}" - name: unit commands: - command: expansions.update params: updates: - key: "run_coverage" value: "true" - func: "fetch source" - func: "run tool unit tests" - func: "create coverage reports" - command: expansions.update params: updates: - key: "coverage_pkg" value: "mongoimport" - func: "upload html coverage" - func: "upload text coverage" - command: expansions.update params: updates: - key: "coverage_pkg" value: "mongoexport" - func: "upload html coverage" - func: "upload text coverage" - command: expansions.update params: updates: - key: "coverage_pkg" value: "mongostat" - func: "upload html coverage" - func: "upload text coverage" - command: expansions.update params: updates: - key: "coverage_pkg" value: "mongodump" - func: "upload html coverage" - func: "upload text coverage" - command: expansions.update params: updates: - key: "coverage_pkg" value: "mongorestore" - func: "upload html coverage" - func: "upload text coverage" - name: vet commands: - func: "fetch source" - command: shell.exec type: test params: working_dir: src script: | set -x set -v set -e . ./set_gopath.sh ${gorootvars} go tool vet bsondump common mongo* - name: replay-dist commands: - func: "fetch source" - func: "build tool" vars: tool: mongoreplay - func: "upload tool" vars: tool: mongoreplay - func: "build tool" - name: replay-sanity_check depends_on: - name: replay-dist commands: - func: "fetch source" - func: "fetch tool" vars: tool: mongoreplay - func: "download mongod" vars: mongo_version: "3.6" - func: "start mongod" - func: "wait for mongod to be ready" - command: shell.exec params: working_dir: src script: | set -x set -v set -e chmod +x bin/mongoreplay echo "Running sanity check" PATH=$PATH:$PWD/bin ./mongoreplay/sanity_check.sh -p ${mongod_port} - name: replay-go_test depends_on: - name: replay-dist commands: - func: "fetch source" - func: "fetch tool" vars: tool: mongoreplay - func: "fetch pcap" vars: pcapFname: getmore_multi_channel.pcap - func: "fetch pcap" vars: pcapFname: getmore_single_channel.pcap - func: "download mongod" vars: mongo_version: "3.6" - func: "start mongod" - func: "wait for mongod to be ready" - func: "run go_test" vars: filename: playtest environment_vars: DB_PORT=${mongod_port} additional_args: github.com/mongodb/mongo-tools/mongoreplay - name: replay-sharded_test depends_on: - name: replay-dist commands: - func: "fetch source" - func: "fetch tool" vars: tool: mongoreplay - func: "fetch pcap" vars: pcapFname: getmore_multi_channel.pcap - func: "fetch pcap" vars: pcapFname: getmore_single_channel.pcap - func: "download mongod" vars: mongo_version: "3.6" - func: "create sharded_cluster" - func: "run go_test" vars: filename: sharded environment_vars: DB_PORT=${mongod_port} additional_args: github.com/mongodb/mongo-tools/mongoreplay --run "LiveDB" - name: replay-auth_test depends_on: - name: replay-dist commands: - func: "fetch source" - func: "fetch tool" vars: tool: mongoreplay - func: "fetch pcap" vars: pcapFname: getmore_multi_channel.pcap - func: "fetch pcap" vars: pcapFname: getmore_single_channel.pcap - func: "download mongod" vars: mongo_version: "3.6" - func: "start mongod" vars: additional_args: --auth - func: "wait for mongod to be ready" - func: "create auth_user" vars: mongod_port: ${mongod_port} - func: "run go_test" vars: filename: authtest environment_vars: AUTH=1 DB_PORT=${mongod_port} additional_args: github.com/mongodb/mongo-tools/mongoreplay --run "(LiveDB)|(Authed)" - name: replay-repl_test depends_on: - name: replay-dist commands: - func: "fetch source" - func: "fetch tool" vars: tool: mongoreplay - func: "fetch pcap" vars: pcapFname: getmore_multi_channel.pcap - func: "fetch pcap" vars: pcapFname: getmore_single_channel.pcap - func: "download mongod" vars: mongo_version: "3.6" - func: "create repl_set" vars: mongod_port: ${mongod_port} - func: "run go_test" vars: filename: repltest environment_vars: DB_PORT=${mongod_port} additional_args: github.com/mongodb/mongo-tools/mongoreplay --run "LiveDB" - name: replay-replay_test depends_on: - name: replay-dist commands: - func: "fetch source" - func: "fetch tool" vars: tool: mongoreplay - func: "download mongod" vars: mongo_version: "3.6" - func: "fetch ftdc" - command: shell.exec params: working_dir: src script: | set -x set -v set -e . ./set_gopath.sh chmod +x bin/mongoreplay echo "Running replay test" PATH=$PATH:$PWD/bin:$PWD/vendor/bin ./mongoreplay/replay_test.sh --verbose --explicit --keep - command: shell.exec params: working_dir: src script: | set -x set -v set -e tar czf replay.tar.gz tmp.* - func: "upload archive" vars: filename: replay.tar.gz - func: "create timeseries" - func: "upload timeseries" buildvariants: ####################################### # macOS Buildvariant # ####################################### - name: macOS-1012 display_name: macOS 10.12 64-bit run_on: - macos-1012 expansions: <<: *mongod_default_startup_args <<: *mongo_default_startup_args mongo_os: "osx" mongo_target: "osx-ssl" arch: "osx/x86_64" excludes: requires_many_files gorootvars: CGO_CPPFLAGS=-I/opt/mongodbtoolchain/v2/include CGO_CFLAGS=-mmacosx-version-min=10.10 CGO_LDFLAGS=-mmacosx-version-min=10.10 tasks: *macos_1012_tasks - name: macOS-1012-ssl display_name: macOS 10.12 64-bit SSL run_on: - macos-1012 expansions: <<: *mongod_ssl_startup_args <<: *mongo_ssl_startup_args mongo_os: "osx" mongo_target: "osx-ssl" arch: "osx/x86_64" build_tags: "ssl" edition: ssl excludes: requires_many_files gorootvars: CGO_CPPFLAGS=-I/opt/mongodbtoolchain/v2/include CGO_CFLAGS=-mmacosx-version-min=10.10 CGO_LDFLAGS=-mmacosx-version-min=10.10 tasks: *macos_1012_ssl_tasks ####################################### # Ubuntu Buildvariants # ####################################### - name: ubuntu display_name: Linux 64-bit run_on: - ubuntu1404-test expansions: <<: *mongod_default_startup_args <<: *mongo_default_startup_args mongo_os: "ubuntu1404" mongo_edition: "targeted" build_tags: "ssl" arch: "linux/x86_64" integration_test_args: integration resmoke_args: --jobs $(grep -c ^processor /proc/cpuinfo) tasks: *ubuntu1404_tasks - name: ubuntu-ssl display_name: Linux 64-bit SSL run_on: - ubuntu1404-test expansions: <<: *mongod_ssl_startup_args <<: *mongo_ssl_startup_args mongo_os: "ubuntu1404" mongo_edition: "enterprise" build_tags: "ssl" edition: ssl arch: "linux/x86_64" smoke_use_ssl: --use-ssl resmoke_use_ssl: _ssl resmoke_args: --jobs $(grep -c ^processor /proc/cpuinfo) integration_test_args: "integration,ssl" tasks: *ubuntu1404_ssl_tasks - name: ubuntu-enterprise display_name: Linux 64-bit Enterprise run_on: - ubuntu1404-test expansions: <<: *mongod_default_startup_args <<: *mongo_default_startup_args mongo_os: "ubuntu1404" mongo_edition: "enterprise" build_tags: "ssl sasl" smoke_use_ssl: --use-ssl resmoke_use_ssl: _ssl arch: "linux/x86_64" edition: enterprise run_kinit: true integration_test_args: integration resmoke_args: --jobs $(grep -c ^processor /proc/cpuinfo) tasks: *ubuntu1404_enterprise_tasks - name: rhel71-ppc64le-enterprise display_name: Linux PPC64LE RHEL 7.1 Enterprise run_on: - rhel71-power8-test expansions: <<: *mongod_default_startup_args <<: *mongo_default_startup_args mongo_os: "rhel71" mongo_edition: "enterprise" mongo_arch: "ppc64le" # RHEL 7.1 PPC64LE machines kerberos setup does not work for mongo-tools #args: ... libsasl2; build_tags "sasl ssl" args: -gccgoflags "$(pkg-config --libs --cflags libssl)" build_tags: 'ssl' resmoke_use_ssl: _ssl gorootvars: PATH="/opt/mongodbtoolchain/v2/bin/:$PATH" resmoke_args: -j 4 excludes: requires_mmap_available,requires_large_ram,requires_mongo_24,requires_mongo_26,requires_mongo_30 multiversion_override: "skip" arch: "linux/ppc64le" edition: enterprise run_kinit: true integration_test_args: integration tasks: *rhel71_enterprise_tasks - name: rhel72-s390x-enterprise display_name: Linux s390x RHEL 7.2 Enterprise run_on: - rhel72-zseries-test expansions: <<: *mongod_default_startup_args <<: *mongo_default_startup_args mongo_os: "rhel72" mongo_edition: "enterprise" mongo_arch: "s390x" args: -gccgoflags "$(pkg-config --libs --cflags libssl libsasl2)" build_tags: "sasl ssl" resmoke_use_ssl: _ssl gorootvars: PATH="/opt/mongodbtoolchain/v2/bin/:$PATH" excludes: requires_mmap_available,requires_mongo_24,requires_mongo_26,requires_mongo_30 resmoke_args: -j 2 multiversion_override: "skip" arch: "linux/s390x" edition: enterprise run_kinit: true integration_test_args: integration tasks: *rhel72_enterprise_tasks - name: ubuntu1604-arm64 display_name: Linux ARM64 Ubuntu 16.04 SSL run_on: - ubuntu1604-arm64-small expansions: <<: *mongod_default_startup_args <<: *mongo_default_startup_args mongo_os: "ubuntu1604" mongo_edition: "targeted" mongo_arch: "arm64" args: -gccgoflags "$(pkg-config --libs --cflags libcrypto libssl)" build_tags: "ssl" resmoke_use_ssl: _ssl gorootvars: PATH="/opt/mongodbtoolchain/v2/bin/:$PATH" excludes: requires_mmap_available,requires_large_ram,requires_mongo_24,requires_mongo_26,requires_mongo_30 resmoke_args: -j 2 multiversion_override: "skip" arch: "linux/arm64" edition: ssl integration_test_args: integration tasks: *ubuntu1604_ssl_tasks ####################################### # Windows Buildvariants # ####################################### - name: windows-64 display_name: Windows 64-bit run_on: - windows-64-vs2013-test expansions: <<: *mongod_default_startup_args <<: *mongo_default_startup_args mongo_os: "windows-64" mongo_target: "windows_x86_64-2008plus-ssl" resmoke_args: --jobs $(grep -c ^processor /proc/cpuinfo) excludes: requires_large_ram extension: .exe arch: "win32/x86_64" preproc_gpm: "perl -pi -e 's/\\r\\n/\\n/g' " integration_test_args: "integration" tasks: *windows_64_tasks - name: windows-64-ssl display_name: Windows 64-bit SSL run_on: - windows-64-vs2013-compile expansions: <<: *mongod_ssl_startup_args <<: *mongo_ssl_startup_args mongo_os: "windows-64" mongo_target: "windows_x86_64-2008plus-ssl" build_tags: "ssl" edition: ssl smoke_use_ssl: --use-ssl resmoke_use_ssl: _ssl resmoke_args: --jobs $(grep -c ^processor /proc/cpuinfo) excludes: requires_large_ram,requires_mongo_24 multiversion_override: "2.6" extension: .exe arch: "win32/x86_64" gorootvars: PATH="/cygdrive/c/mingw-w64/x86_64-4.9.1-posix-seh-rt_v3-rev1/mingw64/bin:/cygdrive/c/sasl/:$PATH" preproc_gpm: "perl -pi -e 's/\\r\\n/\\n/g' " integration_test_args: "integration,ssl" tasks: *windows_64_ssl_tasks - name: windows-64-enterprise display_name: Windows 64-bit Enterprise run_on: - windows-64-vs2013-compile expansions: <<: *mongod_default_startup_args <<: *mongo_default_startup_args mongo_os: "windows-64" mongo_edition: "enterprise" mongo_target: "windows" build_tags: "sasl ssl" smoke_use_ssl: --use-ssl resmoke_args: --jobs $(grep -c ^processor /proc/cpuinfo) resmoke_use_ssl: _ssl excludes: requires_large_ram,requires_mongo_24 multiversion_override: "2.6" edition: enterprise extension: .exe arch: "win32/x86_64" gorootvars: PATH="/cygdrive/c/mingw-w64/x86_64-4.9.1-posix-seh-rt_v3-rev1/mingw64/bin:/cygdrive/c/sasl/:$PATH" preproc_gpm: "perl -pi -e 's/\\r\\n/\\n/g' " integration_test_args: "integration" tasks: *windows_64_enterprise_tasks ####################################### # Experimental Buildvariants # ####################################### - name: ubuntu-race stepback: false batchtime: 1440 # daily display_name: z Race Detector Linux 64-bit run_on: - ubuntu1404-test expansions: <<: *mongod_default_startup_args <<: *mongo_default_startup_args mongo_os: "ubuntu1404" mongo_edition: "enterprise" build_tags: "ssl" arch: "linux/x86_64" args: "-race" excludes: requires_large_ram integration_test_args: integration tasks: *ubuntu1404_race_tasks ####################################### # Dist only Buildvariants # ####################################### - name: suse11 display_name: SUSE 11 SSL run_on: - suse11-test expansions: build_tags: "sasl ssl" tasks: - name: dist - name: suse12 display_name: SUSE 12 SSL run_on: - suse12-test expansions: build_tags: "sasl ssl" tasks: - name: dist - name: rhel62 display_name: RHEL 6.2 SSL run_on: - rhel62-test expansions: gorootvars: PATH="/opt/go/bin:$PATH" build_tags: "sasl ssl" tasks: - name: dist - name: rhel70 display_name: RHEL 7.0 SSL run_on: - rhel70 expansions: gorootvars: PATH="/opt/go/bin:$PATH" build_tags: "sasl ssl" tasks: - name: dist - name: ubuntu1404 display_name: Ubuntu 14.04 SSL run_on: - ubuntu1404-test expansions: build_tags: "sasl ssl" tasks: - name: dist - name: debian71 display_name: Debian 7.1 SSL run_on: - debian71-test expansions: gorootvars: PATH="/opt/go/bin:$PATH" build_tags: "sasl ssl" tasks: - name: dist mongo-tools-r3.6.3/common/000077500000000000000000000000001321131462300154465ustar00rootroot00000000000000mongo-tools-r3.6.3/common/archive/000077500000000000000000000000001321131462300170675ustar00rootroot00000000000000mongo-tools-r3.6.3/common/archive/archive.go000066400000000000000000000044041321131462300210410ustar00rootroot00000000000000// Copyright (C) MongoDB, Inc. 2014-present. // // 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 package archive import "io" // NamespaceHeader is a data structure that, as BSON, is found in archives where it indicates // that either the subsequent stream of BSON belongs to this new namespace, or that the // indicated namespace will have no more documents (EOF) type NamespaceHeader struct { Database string `bson:"db"` Collection string `bson:"collection"` EOF bool `bson:"EOF"` CRC int64 `bson:"CRC"` } // CollectionMetadata is a data structure that, as BSON, is found in the prelude of the archive. // There is one CollectionMetadata per collection that will be in the archive. type CollectionMetadata struct { Database string `bson:"db"` Collection string `bson:"collection"` Metadata string `bson:"metadata"` Size int `bson:"size"` } // Header is a data structure that, as BSON, is found immediately after the magic // number in the archive, before any CollectionMetadatas. It is the home of any archive level information type Header struct { ConcurrentCollections int32 `bson:"concurrent_collections"` FormatVersion string `bson:"version"` ServerVersion string `bson:"server_version"` ToolVersion string `bson:"tool_version"` } const minBSONSize = 4 + 1 // an empty BSON document should be exactly five bytes long var terminator int32 = -1 var terminatorBytes = []byte{0xFF, 0xFF, 0xFF, 0xFF} // TODO, rectify this with terminator // MagicNumber is four bytes that are found at the beginning of the archive that indicate that // the byte stream is an archive, as opposed to anything else, including a stream of BSON documents const MagicNumber uint32 = 0x8199e26d const archiveFormatVersion = "0.1" // Writer is the top level object to contain information about archives in mongodump type Writer struct { Out io.WriteCloser Prelude *Prelude Mux *Multiplexer } // Reader is the top level object to contain information about archives in mongorestore type Reader struct { In io.ReadCloser Demux *Demultiplexer Prelude *Prelude } mongo-tools-r3.6.3/common/archive/demultiplexer.go000066400000000000000000000364131321131462300223100ustar00rootroot00000000000000// Copyright (C) MongoDB, Inc. 2014-present. // // 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 package archive import ( "bytes" "fmt" "hash" "hash/crc64" "io" "sync" "sync/atomic" "github.com/mongodb/mongo-tools/common/db" "github.com/mongodb/mongo-tools/common/intents" "github.com/mongodb/mongo-tools/common/log" "gopkg.in/mgo.v2/bson" ) // DemuxOut is a Demultiplexer output consumer // The Write() and Close() occur in the same thread as the Demultiplexer runs in. type DemuxOut interface { Write([]byte) (int, error) Close() error Sum64() (uint64, bool) } const ( NamespaceUnopened = iota NamespaceOpened NamespaceClosed ) // Demultiplexer implements Parser. type Demultiplexer struct { In io.Reader //TODO wrap up these three into a structure outs map[string]DemuxOut lengths map[string]int64 currentNamespace string buf [db.MaxBSONSize]byte NamespaceChan chan string NamespaceErrorChan chan error NamespaceStatus map[string]int } func CreateDemux(namespaceMetadatas []*CollectionMetadata, in io.Reader) *Demultiplexer { demux := &Demultiplexer{ NamespaceStatus: make(map[string]int), In: in, } for _, cm := range namespaceMetadatas { ns := cm.Database + "." + cm.Collection demux.NamespaceStatus[ns] = NamespaceUnopened } return demux } // Run creates and runs a parser with the Demultiplexer as a consumer func (demux *Demultiplexer) Run() error { parser := Parser{In: demux.In} err := parser.ReadAllBlocks(demux) if len(demux.outs) > 0 { log.Logvf(log.Always, "demux finishing when there are still outs (%v)", len(demux.outs)) } log.Logvf(log.DebugLow, "demux finishing (err:%v)", err) return err } type demuxError struct { Err error Msg string } // Error is part of the Error interface. It formats a demuxError for human readability. func (pe *demuxError) Error() string { err := fmt.Sprintf("error demultiplexing archive; %v", pe.Msg) if pe.Err != nil { err = fmt.Sprintf("%v ( %v )", err, pe.Err) } return err } // newError creates a demuxError with just a message func newError(msg string) error { return &demuxError{ Msg: msg, } } // newWrappedError creates a demuxError with a message as well as an underlying cause error func newWrappedError(msg string, err error) error { return &demuxError{ Err: err, Msg: msg, } } // HeaderBSON is part of the ParserConsumer interface and receives headers from parser. // Its main role is to implement opens and EOFs of the embedded stream. func (demux *Demultiplexer) HeaderBSON(buf []byte) error { colHeader := NamespaceHeader{} err := bson.Unmarshal(buf, &colHeader) if err != nil { return newWrappedError("header bson doesn't unmarshal as a collection header", err) } log.Logvf(log.DebugHigh, "demux namespaceHeader: %v", colHeader) if colHeader.Collection == "" { return newError("collection header is missing a Collection") } demux.currentNamespace = colHeader.Database + "." + colHeader.Collection if _, ok := demux.outs[demux.currentNamespace]; !ok { if demux.NamespaceStatus[demux.currentNamespace] != NamespaceUnopened { return newError("namespace header for already opened namespace") } demux.NamespaceStatus[demux.currentNamespace] = NamespaceOpened if demux.NamespaceChan != nil { demux.NamespaceChan <- demux.currentNamespace err := <-demux.NamespaceErrorChan if err == io.EOF { // if the Prioritizer sends us back an io.EOF then it's telling us that // it's finishing and doesn't need any more namespace announcements. close(demux.NamespaceChan) demux.NamespaceChan = nil return nil } if err != nil { return newWrappedError("failed arranging a consumer for new namespace", err) } } } if colHeader.EOF { if rcr, ok := demux.outs[demux.currentNamespace].(*RegularCollectionReceiver); ok { rcr.err = io.EOF } demux.outs[demux.currentNamespace].Close() demux.NamespaceStatus[demux.currentNamespace] = NamespaceClosed length := int64(demux.lengths[demux.currentNamespace]) crcUInt64, ok := demux.outs[demux.currentNamespace].Sum64() if ok { crc := int64(crcUInt64) if crc != colHeader.CRC { return fmt.Errorf("CRC mismatch for namespace %v, %v!=%v", demux.currentNamespace, crc, colHeader.CRC, ) } log.Logvf(log.DebugHigh, "demux checksum for namespace %v is correct (%v), %v bytes", demux.currentNamespace, crc, length) } else { log.Logvf(log.DebugHigh, "demux checksum for namespace %v was not calculated.", demux.currentNamespace) } delete(demux.outs, demux.currentNamespace) delete(demux.lengths, demux.currentNamespace) // in case we get a BSONBody with this block, // we want to ensure that that causes an error demux.currentNamespace = "" } return nil } // End is part of the ParserConsumer interface and receives the end of archive notification. func (demux *Demultiplexer) End() error { log.Logvf(log.DebugHigh, "demux End") var err error if len(demux.outs) != 0 { openNss := []string{} for ns := range demux.outs { openNss = append(openNss, ns) if rcr, ok := demux.outs[ns].(*RegularCollectionReceiver); ok { rcr.err = newError("archive io error") } demux.outs[ns].Close() } err = newError(fmt.Sprintf("archive finished but contained files were unfinished (%v)", openNss)) } else { for ns, status := range demux.NamespaceStatus { if status != NamespaceClosed { err = newError(fmt.Sprintf("archive finished before all collections were seen (%v)", ns)) } } } if demux.NamespaceChan != nil { close(demux.NamespaceChan) } return err } // BodyBSON is part of the ParserConsumer interface and receives BSON bodies from the parser. // Its main role is to dispatch the body to the Read() function of the current DemuxOut. func (demux *Demultiplexer) BodyBSON(buf []byte) error { if demux.currentNamespace == "" { return newError("collection data without a collection header") } demux.lengths[demux.currentNamespace] += int64(len(buf)) out, ok := demux.outs[demux.currentNamespace] if !ok { return newError("no demux consumer currently consuming namespace " + demux.currentNamespace) } _, err := out.Write(buf) return err } // Open installs the DemuxOut as the handler for data for the namespace ns func (demux *Demultiplexer) Open(ns string, out DemuxOut) { // In the current implementation where this is either called before the demultiplexing is running // or while the demutiplexer is inside of the NamespaceChan NamespaceErrorChan conversation // I think that we don't need to lock outs, but I suspect that if the implementation changes // we may need to lock when outs is accessed log.Logvf(log.DebugHigh, "demux Open") if demux.outs == nil { demux.outs = make(map[string]DemuxOut) demux.lengths = make(map[string]int64) } demux.outs[ns] = out demux.lengths[ns] = 0 } // RegularCollectionReceiver implements the intents.file interface. type RegularCollectionReceiver struct { pos int64 // updated atomically, aligned at the beginning of the struct readLenChan chan int readBufChan chan []byte Intent *intents.Intent Origin string Demux *Demultiplexer partialReadArray []byte partialReadBuf []byte hash hash.Hash64 closeOnce sync.Once openOnce sync.Once err error } func (receiver *RegularCollectionReceiver) Sum64() (uint64, bool) { return receiver.hash.Sum64(), true } // Read() runs in the restoring goroutine func (receiver *RegularCollectionReceiver) Read(r []byte) (int, error) { if receiver.partialReadBuf != nil && len(receiver.partialReadBuf) > 0 { wLen := len(receiver.partialReadBuf) copyLen := copy(r, receiver.partialReadBuf) if wLen == copyLen { receiver.partialReadBuf = nil } else { receiver.partialReadBuf = receiver.partialReadBuf[copyLen:] } atomic.AddInt64(&receiver.pos, int64(copyLen)) return copyLen, nil } // Since we're the "reader" here, not the "writer" we need to start with a read, in case the chan is closed wLen, ok := <-receiver.readLenChan if !ok { close(receiver.readBufChan) return 0, receiver.err } if wLen > db.MaxBSONSize { return 0, fmt.Errorf("incomming buffer size is too big %v", wLen) } rLen := len(r) if wLen > rLen { // if the incomming write size is larger then the incomming read buffer then we need to accept // the write in a larger buffer, fill the read buffer, then cache the remainder receiver.partialReadBuf = receiver.partialReadArray[:wLen] receiver.readBufChan <- receiver.partialReadBuf writtenLength := <-receiver.readLenChan if wLen != writtenLength { return 0, fmt.Errorf("regularCollectionReceiver didn't send what it said it would") } receiver.hash.Write(receiver.partialReadBuf) copy(r, receiver.partialReadBuf) receiver.partialReadBuf = receiver.partialReadBuf[rLen:] atomic.AddInt64(&receiver.pos, int64(rLen)) return rLen, nil } // Send the read buff to the BodyBSON ParserConsumer to fill receiver.readBufChan <- r // Receiver the wLen of data written wLen = <-receiver.readLenChan receiver.hash.Write(r[:wLen]) atomic.AddInt64(&receiver.pos, int64(wLen)) return wLen, nil } func (receiver *RegularCollectionReceiver) Pos() int64 { return atomic.LoadInt64(&receiver.pos) } // Open is part of the intents.file interface. It creates the chan's in the // RegularCollectionReceiver and adds the RegularCollectionReceiver to the set of // RegularCollectonReceivers in the demultiplexer func (receiver *RegularCollectionReceiver) Open() error { // TODO move this implementation to some non intents.file method, to be called from prioritizer.Get // So that we don't have to enable this double open stuff. // Currently the open needs to finish before the prioritizer.Get finishes, so we open the intents.file // in prioritizer.Get even though it's going to get opened again in DumpIntent. receiver.openOnce.Do(func() { receiver.readLenChan = make(chan int) receiver.readBufChan = make(chan []byte) receiver.hash = crc64.New(crc64.MakeTable(crc64.ECMA)) receiver.Demux.Open(receiver.Origin, receiver) }) return nil } func (receiver *RegularCollectionReceiver) TakeIOBuffer(ioBuf []byte) { receiver.partialReadArray = ioBuf } func (receiver *RegularCollectionReceiver) ReleaseIOBuffer() { receiver.partialReadArray = nil } // Write is part of the DemuxOut interface. func (receiver *RegularCollectionReceiver) Write(buf []byte) (int, error) { // As a writer, we need to write first, so that the reader can properly detect EOF // Additionally, the reader needs to know the write size, so that it can give us a // properly sized buffer. Sending the incomming buffersize fills both of these needs. receiver.readLenChan <- len(buf) // Receive from the reader a buffer to put the bytes into readBuf := <-receiver.readBufChan if len(readBuf) < len(buf) { return 0, fmt.Errorf("readbuf is not large enough for incoming BodyBSON (%v<%v)", len(readBuf), len(buf)) } copy(readBuf, buf) // Send back the length of the data copied in to the buffer receiver.readLenChan <- len(buf) return len(buf), nil } // Close is part of the DemuxOut as well as the intents.file interface. It only closes the readLenChan, as that is what will // cause the RegularCollectionReceiver.Read() to receive EOF // Close will get called twice, once in the demultiplexer, and again when the restore goroutine is done with its intent.file func (receiver *RegularCollectionReceiver) Close() error { receiver.closeOnce.Do(func() { close(receiver.readLenChan) // make sure that we don't return until any reader has finished <-receiver.readBufChan }) return nil } // SpecialCollectionCache implemnts both DemuxOut as well as intents.file type SpecialCollectionCache struct { pos int64 // updated atomically, aligned at the beginning of the struct Intent *intents.Intent Demux *Demultiplexer buf bytes.Buffer hash hash.Hash64 } func NewSpecialCollectionCache(intent *intents.Intent, demux *Demultiplexer) *SpecialCollectionCache { return &SpecialCollectionCache{ Intent: intent, Demux: demux, hash: crc64.New(crc64.MakeTable(crc64.ECMA)), } } // Open is part of the both interfaces, and it does nothing func (cache *SpecialCollectionCache) Open() error { return nil } // Close is part of the both interfaces, and it does nothing func (cache *SpecialCollectionCache) Close() error { cache.Intent.Size = int64(cache.buf.Len()) return nil } func (cache *SpecialCollectionCache) Read(p []byte) (int, error) { n, err := cache.buf.Read(p) atomic.AddInt64(&cache.pos, int64(n)) return n, err } func (cache *SpecialCollectionCache) Pos() int64 { return atomic.LoadInt64(&cache.pos) } func (cache *SpecialCollectionCache) Write(b []byte) (int, error) { cache.hash.Write(b) return cache.buf.Write(b) } func (cache *SpecialCollectionCache) Sum64() (uint64, bool) { return cache.hash.Sum64(), true } // MutedCollection implements both DemuxOut as well as intents.file. It serves as a way to // let the demutiplexer ignore certain embedded streams type MutedCollection struct { Intent *intents.Intent Demux *Demultiplexer } // Read is part of the intents.file interface, and does nothing func (*MutedCollection) Read([]byte) (int, error) { // Read is part of the intents.file interface, and does nothing return 0, io.EOF } // Write is part of the intents.file interface, and does nothing func (*MutedCollection) Write(b []byte) (int, error) { return len(b), nil } // Close is part of the intents.file interface, and does nothing func (*MutedCollection) Close() error { return nil } // Open is part of the intents.file interface, and does nothing func (*MutedCollection) Open() error { return nil } // Sum64 is part of the DemuxOut interface func (*MutedCollection) Sum64() (uint64, bool) { return 0, false } //===== Archive Manager Prioritizer ===== // NewPrioritizer careates a new Prioritizer and hooks up its Namespace channels to the ones in demux func (demux *Demultiplexer) NewPrioritizer(mgr *intents.Manager) *Prioritizer { return &Prioritizer{ NamespaceChan: demux.NamespaceChan, NamespaceErrorChan: demux.NamespaceErrorChan, mgr: mgr, } } // Prioritizer is a completely reactive prioritizer // Intents are handed out as they arrive in the archive type Prioritizer struct { NamespaceChan <-chan string NamespaceErrorChan chan<- error mgr *intents.Manager } // Get waits for a new namespace from the NamespaceChan, and returns a Intent found for it func (prioritizer *Prioritizer) Get() *intents.Intent { namespace, ok := <-prioritizer.NamespaceChan if !ok { return nil } intent := prioritizer.mgr.IntentForNamespace(namespace) if intent == nil { prioritizer.NamespaceErrorChan <- fmt.Errorf("no intent for namespace %v", namespace) } else { if intent.BSONFile != nil { intent.BSONFile.Open() } if intent.IsOplog() { // once we see the oplog we // cause the RestoreIntents to finish because we don't // want RestoreIntents to restore the oplog prioritizer.NamespaceErrorChan <- io.EOF return nil } prioritizer.NamespaceErrorChan <- nil } return intent } // Finish is part of the IntentPrioritizer interface, and does nothing func (prioritizer *Prioritizer) Finish(*intents.Intent) { // no-op return } mongo-tools-r3.6.3/common/archive/multiplexer.go000066400000000000000000000222641321131462300217760ustar00rootroot00000000000000// Copyright (C) MongoDB, Inc. 2014-present. // // 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 package archive import ( "fmt" "hash" "hash/crc64" "io" "reflect" "github.com/mongodb/mongo-tools/common/db" "github.com/mongodb/mongo-tools/common/intents" "github.com/mongodb/mongo-tools/common/log" "gopkg.in/mgo.v2/bson" ) // bufferSize enables or disables the MuxIn buffering // TODO: remove this constant and the non-buffered MuxIn implementations const bufferWrites = true const bufferSize = db.MaxBSONSize // Multiplexer is what one uses to create interleaved intents in an archive type Multiplexer struct { Out io.WriteCloser Control chan *MuxIn Completed chan error // shutdownInputs allows the mux to tell the intent dumping worker // go routines to shutdown, so that we can shutdown shutdownInputs notifier // ins and selectCases are correlating slices ins []*MuxIn selectCases []reflect.SelectCase currentNamespace string } type notifier interface { Notify() } // NewMultiplexer creates a Multiplexer and populates its Control/Completed chans // it takes a WriteCloser, which is where in imputs will get multiplexed on to, // and it takes a notifier, which should allow the multiplexer to ask for the shutdown // of the inputs. func NewMultiplexer(out io.WriteCloser, shutdownInputs notifier) *Multiplexer { mux := &Multiplexer{ Out: out, Control: make(chan *MuxIn), Completed: make(chan error), shutdownInputs: shutdownInputs, ins: []*MuxIn{ nil, // There is no MuxIn for the Control case }, } mux.selectCases = []reflect.SelectCase{ reflect.SelectCase{ Dir: reflect.SelectRecv, Chan: reflect.ValueOf(mux.Control), Send: reflect.Value{}, }, } return mux } // Run multiplexes until it receives an EOF on its Control chan. func (mux *Multiplexer) Run() { var err, completionErr error for { index, value, notEOF := reflect.Select(mux.selectCases) EOF := !notEOF if index == 0 { //Control index if EOF { log.Logvf(log.DebugLow, "Mux finish") mux.Out.Close() if completionErr != nil { mux.Completed <- completionErr } else if len(mux.selectCases) != 1 { mux.Completed <- fmt.Errorf("Mux ending but selectCases still open %v", len(mux.selectCases)) } else { mux.Completed <- nil } return } muxIn, ok := value.Interface().(*MuxIn) if !ok { mux.Completed <- fmt.Errorf("non MuxIn received on Control chan") // one for the MuxIn.Open return } log.Logvf(log.DebugLow, "Mux open namespace %v", muxIn.Intent.Namespace()) mux.selectCases = append(mux.selectCases, reflect.SelectCase{ Dir: reflect.SelectRecv, Chan: reflect.ValueOf(muxIn.writeChan), Send: reflect.Value{}, }) mux.ins = append(mux.ins, muxIn) } else { if EOF { // We need to let the MuxIn know that we've // noticed this close. This fixes a race where // the intent processing threads finish, then the main // thread closes the mux's control chan and the mux // processes the close on the control chan before it processes // the close on the MuxIn chan mux.ins[index].writeCloseFinishedChan <- struct{}{} err = mux.formatEOF(index, mux.ins[index]) if err != nil { mux.shutdownInputs.Notify() mux.Out = &nopCloseNopWriter{} completionErr = err } log.Logvf(log.DebugLow, "Mux close namespace %v", mux.ins[index].Intent.Namespace()) mux.currentNamespace = "" mux.selectCases = append(mux.selectCases[:index], mux.selectCases[index+1:]...) mux.ins = append(mux.ins[:index], mux.ins[index+1:]...) } else { bsonBytes, ok := value.Interface().([]byte) if !ok { mux.Completed <- fmt.Errorf("multiplexer received a value that wasn't a []byte") return } err = mux.formatBody(mux.ins[index], bsonBytes) if err != nil { mux.shutdownInputs.Notify() mux.Out = &nopCloseNopWriter{} completionErr = err } } } } } type nopCloseNopWriter struct{} func (*nopCloseNopWriter) Close() error { return nil } func (*nopCloseNopWriter) Write(p []byte) (int, error) { return len(p), nil } // formatBody writes the BSON in to the archive, potentially writing a new header // if the document belongs to a different namespace from the last header. func (mux *Multiplexer) formatBody(in *MuxIn, bsonBytes []byte) error { var err error var length int defer func() { in.writeLenChan <- length }() if in.Intent.Namespace() != mux.currentNamespace { // Handle the change of which DB/Collection we're writing docs for // If mux.currentNamespace then we need to terminate the current block if mux.currentNamespace != "" { l, err := mux.Out.Write(terminatorBytes) if err != nil { return err } if l != len(terminatorBytes) { return io.ErrShortWrite } } header, err := bson.Marshal(NamespaceHeader{ Database: in.Intent.DB, Collection: in.Intent.C, }) if err != nil { return err } l, err := mux.Out.Write(header) if err != nil { return err } if l != len(header) { return io.ErrShortWrite } } mux.currentNamespace = in.Intent.Namespace() length, err = mux.Out.Write(bsonBytes) if err != nil { return err } return nil } // formatEOF writes the EOF header in to the archive func (mux *Multiplexer) formatEOF(index int, in *MuxIn) error { var err error if mux.currentNamespace != "" { l, err := mux.Out.Write(terminatorBytes) if err != nil { return err } if l != len(terminatorBytes) { return io.ErrShortWrite } } eofHeader, err := bson.Marshal(NamespaceHeader{ Database: in.Intent.DB, Collection: in.Intent.C, EOF: true, CRC: int64(in.hash.Sum64()), }) if err != nil { return err } l, err := mux.Out.Write(eofHeader) if err != nil { return err } if l != len(eofHeader) { return io.ErrShortWrite } l, err = mux.Out.Write(terminatorBytes) if err != nil { return err } if l != len(terminatorBytes) { return io.ErrShortWrite } return nil } // MuxIn is an implementation of the intents.file interface. // They live in the intents, and are potentially owned by different threads than // the thread owning the Multiplexer. // They are out the intents write data to the multiplexer type MuxIn struct { writeChan chan []byte writeLenChan chan int writeCloseFinishedChan chan struct{} buf []byte hash hash.Hash64 Intent *intents.Intent Mux *Multiplexer } // Read does nothing for MuxIns func (muxIn *MuxIn) Read([]byte) (int, error) { return 0, nil } func (muxIn *MuxIn) Pos() int64 { return 0 } // Close closes the chans in the MuxIn. // Ultimately the multiplexer will detect that they are closed and cause a // formatEOF to occur. func (muxIn *MuxIn) Close() error { // the mux side of this gets closed in the mux when it gets an eof on the read log.Logvf(log.DebugHigh, "MuxIn close %v", muxIn.Intent.Namespace()) if bufferWrites { muxIn.writeChan <- muxIn.buf length := <-muxIn.writeLenChan if length != len(muxIn.buf) { return io.ErrShortWrite } muxIn.buf = nil } close(muxIn.writeChan) close(muxIn.writeLenChan) // We need to wait for the close on the writeChan to be processed before proceeding // Otherwise we might assume that all work is finished and exit the program before // the mux finishes writing the end of the archive <-muxIn.writeCloseFinishedChan return nil } // Open is implemented in Mux.open, but in short, it creates chans and a select case // and adds the SelectCase and the MuxIn in to the Multiplexer. func (muxIn *MuxIn) Open() error { log.Logvf(log.DebugHigh, "MuxIn open %v", muxIn.Intent.Namespace()) muxIn.writeChan = make(chan []byte) muxIn.writeLenChan = make(chan int) muxIn.writeCloseFinishedChan = make(chan struct{}) muxIn.buf = make([]byte, 0, bufferSize) muxIn.hash = crc64.New(crc64.MakeTable(crc64.ECMA)) if bufferWrites { muxIn.buf = make([]byte, 0, db.MaxBSONSize) } muxIn.Mux.Control <- muxIn return nil } // Write hands a buffer to the Multiplexer and receives a written length from the multiplexer // after the length is received, the buffer is free to be reused. func (muxIn *MuxIn) Write(buf []byte) (int, error) { size := int( (uint32(buf[0]) << 0) | (uint32(buf[1]) << 8) | (uint32(buf[2]) << 16) | (uint32(buf[3]) << 24), ) // TODO remove these checks, they're for debugging if len(buf) < size { panic(fmt.Errorf("corrupt bson in MuxIn.Write (size %v/%v)", size, len(buf))) } if buf[size-1] != 0 { panic(fmt.Errorf("corrupt bson in MuxIn.Write bson has no-zero terminator %v, (size %v/%v)", buf[size-1], size, len(buf))) } if bufferWrites { if len(muxIn.buf)+len(buf) > cap(muxIn.buf) { muxIn.writeChan <- muxIn.buf length := <-muxIn.writeLenChan if length != len(muxIn.buf) { return 0, io.ErrShortWrite } muxIn.buf = muxIn.buf[:0] } muxIn.buf = append(muxIn.buf, buf...) } else { muxIn.writeChan <- buf length := <-muxIn.writeLenChan if length != len(buf) { return 0, io.ErrShortWrite } } muxIn.hash.Write(buf) return len(buf), nil } mongo-tools-r3.6.3/common/archive/multiplexer_roundtrip_test.go000066400000000000000000000131071321131462300251370ustar00rootroot00000000000000// Copyright (C) MongoDB, Inc. 2014-present. // // 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 package archive import ( "bytes" "hash" "hash/crc32" "io" "os" "testing" "github.com/mongodb/mongo-tools/common/db" "github.com/mongodb/mongo-tools/common/intents" . "github.com/smartystreets/goconvey/convey" "gopkg.in/mgo.v2/bson" ) var testIntents = []*intents.Intent{ &intents.Intent{ DB: "foo", C: "bar", Location: "foo.bar", }, &intents.Intent{ DB: "ding", C: "bats", Location: "ding.bats", }, &intents.Intent{ DB: "flim", C: "flam.fooey", Location: "flim.flam.fooey", }, &intents.Intent{ DB: "crow", C: "bar", Location: "crow.bar", }, } type testDoc struct { Bar int Baz string } type closingBuffer struct { bytes.Buffer } func (*closingBuffer) Close() error { return nil } type testNotifier struct{} func (n *testNotifier) Notify() {} func TestBasicMux(t *testing.T) { var err error Convey("with 10000 docs in each of five collections", t, func() { buf := &closingBuffer{bytes.Buffer{}} mux := NewMultiplexer(buf, new(testNotifier)) muxIns := map[string]*MuxIn{} inChecksum := map[string]hash.Hash{} inLengths := map[string]*int{} outChecksum := map[string]hash.Hash{} outLengths := map[string]*int{} // To confirm that what we multiplex is the same as what we demultiplex, we // create input and output hashes for each namespace. After we finish // multiplexing and demultiplexing we will compare all of the CRCs for each // namespace errChan := make(chan error) makeIns(testIntents, mux, inChecksum, muxIns, inLengths, errChan) Convey("each document should be multiplexed", func() { go mux.Run() for range testIntents { err := <-errChan So(err, ShouldBeNil) } close(mux.Control) err = <-mux.Completed So(err, ShouldBeNil) demux := &Demultiplexer{ In: buf, NamespaceStatus: make(map[string]int), } demuxOuts := map[string]*RegularCollectionReceiver{} errChan := make(chan error) makeOuts(testIntents, demux, outChecksum, demuxOuts, outLengths, errChan) Convey("and demultiplexed successfully", func() { demux.Run() So(err, ShouldBeNil) for range testIntents { err := <-errChan So(err, ShouldBeNil) } for _, dbc := range testIntents { ns := dbc.Namespace() So(*inLengths[ns], ShouldEqual, *outLengths[ns]) inSum := inChecksum[ns].Sum([]byte{}) outSum := outChecksum[ns].Sum([]byte{}) So(inSum, ShouldResemble, outSum) } }) }) }) return } func TestParallelMux(t *testing.T) { Convey("parallel mux/demux over a pipe", t, func() { readPipe, writePipe, err := os.Pipe() So(err, ShouldBeNil) mux := NewMultiplexer(writePipe, new(testNotifier)) muxIns := map[string]*MuxIn{} demux := &Demultiplexer{ In: readPipe, NamespaceStatus: make(map[string]int), } demuxOuts := map[string]*RegularCollectionReceiver{} inChecksum := map[string]hash.Hash{} inLengths := map[string]*int{} outChecksum := map[string]hash.Hash{} outLengths := map[string]*int{} writeErrChan := make(chan error) readErrChan := make(chan error) makeIns(testIntents, mux, inChecksum, muxIns, inLengths, writeErrChan) makeOuts(testIntents, demux, outChecksum, demuxOuts, outLengths, readErrChan) go demux.Run() go mux.Run() for range testIntents { err := <-writeErrChan So(err, ShouldBeNil) err = <-readErrChan So(err, ShouldBeNil) } close(mux.Control) muxErr := <-mux.Completed So(muxErr, ShouldBeNil) for _, dbc := range testIntents { ns := dbc.Namespace() So(*inLengths[ns], ShouldEqual, *outLengths[ns]) inSum := inChecksum[ns].Sum([]byte{}) outSum := outChecksum[ns].Sum([]byte{}) So(inSum, ShouldResemble, outSum) } }) return } func makeIns(testIntents []*intents.Intent, mux *Multiplexer, inChecksum map[string]hash.Hash, muxIns map[string]*MuxIn, inLengths map[string]*int, errCh chan<- error) { for index, dbc := range testIntents { ns := dbc.Namespace() sum := crc32.NewIEEE() muxIn := &MuxIn{Intent: dbc, Mux: mux} inLength := 0 inChecksum[ns] = sum muxIns[ns] = muxIn inLengths[ns] = &inLength go func(index int) { err := muxIn.Open() if err != nil { errCh <- err return } staticBSONBuf := make([]byte, db.MaxBSONSize) for i := 0; i < 10000; i++ { bsonBytes, _ := bson.Marshal(testDoc{Bar: index * i, Baz: ns}) bsonBuf := staticBSONBuf[:len(bsonBytes)] copy(bsonBuf, bsonBytes) muxIn.Write(bsonBuf) sum.Write(bsonBuf) inLength += len(bsonBuf) } err = muxIn.Close() errCh <- err }(index) } } func makeOuts(testIntents []*intents.Intent, demux *Demultiplexer, outChecksum map[string]hash.Hash, demuxOuts map[string]*RegularCollectionReceiver, outLengths map[string]*int, errCh chan<- error) { for _, dbc := range testIntents { ns := dbc.Namespace() sum := crc32.NewIEEE() muxOut := &RegularCollectionReceiver{ Intent: dbc, Demux: demux, Origin: ns, } outLength := 0 outChecksum[ns] = sum demuxOuts[ns] = muxOut outLengths[ns] = &outLength demuxOuts[ns].Open() go func() { bs := make([]byte, db.MaxBSONSize) var err error for { var length int length, err = muxOut.Read(bs) if err != nil { break } sum.Write(bs[:length]) outLength += len(bs[:length]) } if err == io.EOF { err = nil } errCh <- err }() } } mongo-tools-r3.6.3/common/archive/parser.go000066400000000000000000000114721321131462300207170ustar00rootroot00000000000000// Copyright (C) MongoDB, Inc. 2014-present. // // 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 package archive import ( "fmt" "io" "github.com/mongodb/mongo-tools/common/db" ) // parser.go implements the parsing of the low-level archive format // The low level archive format is defined as zero or more blocks // where each block is defined as: // a header BSON document // zero or more body BSON documents // a four byte terminator (0xFFFFFFFF) // ParserConsumer is the interface that one needs to implement to consume data from the Parser type ParserConsumer interface { HeaderBSON([]byte) error BodyBSON([]byte) error End() error } // Parser encapsulates the small amount of state that the parser needs to keep type Parser struct { In io.Reader buf [db.MaxBSONSize]byte length int } type parserError struct { Err error Msg string } // Error is part of the Error interface. It formats a parserError for human readability. func (pe *parserError) Error() string { err := fmt.Sprintf("corruption found in archive; %v", pe.Msg) if pe.Err != nil { err = fmt.Sprintf("%v ( %v )", err, pe.Err) } return err } // newParserError creates a parserError with just a message func newParserError(msg string) error { return &parserError{ Msg: msg, } } // newParserWrappedError creates a parserError with a message as well as an underlying cause error func newParserWrappedError(msg string, err error) error { return &parserError{ Err: err, Msg: msg, } } // readBSONOrTerminator reads at least four bytes, determines // if the first four bytes are a terminator, a bson lenght, or something else. // If they are a terminator, true,nil are returned. If they are a BSON length, // then the remainder of the BSON document are read in to the parser, otherwise // an error is returned. func (parse *Parser) readBSONOrTerminator() (isTerminator bool, err error) { parse.length = 0 _, err = io.ReadFull(parse.In, parse.buf[0:4]) if err == io.EOF { return false, err } if err != nil { return false, newParserWrappedError("I/O error reading length or terminator", err) } size := int32( (uint32(parse.buf[0]) << 0) | (uint32(parse.buf[1]) << 8) | (uint32(parse.buf[2]) << 16) | (uint32(parse.buf[3]) << 24), ) if size == terminator { return true, nil } if size < minBSONSize || size > db.MaxBSONSize { return false, newParserError(fmt.Sprintf("%v is neither a valid bson length nor a archive terminator", size)) } // TODO Because we're reusing this same buffer for all of our IO, we are basically guaranteeing that we'll // copy the bytes twice. At some point we should fix this. It's slightly complex, because we'll need consumer // methods closing one buffer and acquiring another _, err = io.ReadFull(parse.In, parse.buf[4:size]) if err != nil { // any error, including EOF is an error so we wrap it up return false, newParserWrappedError("read bson", err) } if parse.buf[size-1] != 0x00 { return false, newParserError(fmt.Sprintf("bson (size: %v, byte: %d) doesn't end with a null byte", size, parse.buf[size-1])) } parse.length = int(size) return false, nil } // ReadAllBlocks calls ReadBlock() until it returns an error. // If the error is EOF, then nil is returned, otherwise it returns the error func (parse *Parser) ReadAllBlocks(consumer ParserConsumer) (err error) { for err == nil { err = parse.ReadBlock(consumer) } endError := consumer.End() if err == io.EOF { return endError } return err } // ReadBlock reads one archive block ( header + body* + terminator ) // calling consumer.HeaderBSON() on the header, consumer.BodyBSON() on each piece of body, // and consumer.EOF() when EOF is encountered before any data was read. // It returns nil if a whole block was read, io.EOF if nothing was read, // and a parserError if there was any io error in the middle of the block, // if either of the consumer methods return error, or if there was any sort of // parsing failure. func (parse *Parser) ReadBlock(consumer ParserConsumer) (err error) { isTerminator, err := parse.readBSONOrTerminator() if err != nil { return err } if isTerminator { return newParserError("consecutive terminators / headerless blocks are not allowed") } err = consumer.HeaderBSON(parse.buf[:parse.length]) if err != nil { return newParserWrappedError("ParserConsumer.HeaderBSON()", err) } for { isTerminator, err = parse.readBSONOrTerminator() if err != nil { // all errors, including EOF are errors here return newParserWrappedError("ParserConsumer.BodyBSON()", err) } if isTerminator { return nil } err = consumer.BodyBSON(parse.buf[:parse.length]) if err != nil { return newParserWrappedError("ParserConsumer.BodyBSON()", err) } } } mongo-tools-r3.6.3/common/archive/parser_test.go000066400000000000000000000104701321131462300217530ustar00rootroot00000000000000// Copyright (C) MongoDB, Inc. 2014-present. // // 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 package archive import ( "bytes" "fmt" "io" "testing" . "github.com/smartystreets/goconvey/convey" "gopkg.in/mgo.v2/bson" ) type testConsumer struct { headers []string // header data bodies []string // body data eof bool } func (tc *testConsumer) HeaderBSON(b []byte) error { ss := strStruct{} err := bson.Unmarshal(b, &ss) tc.headers = append(tc.headers, ss.Str) return err } func (tc *testConsumer) BodyBSON(b []byte) error { ss := strStruct{} err := bson.Unmarshal(b, &ss) tc.bodies = append(tc.bodies, ss.Str) return err } func (tc *testConsumer) End() (err error) { if tc.eof { err = fmt.Errorf("double end") } tc.eof = true return err } type strStruct struct { Str string } var term = []byte{0xFF, 0xFF, 0xFF, 0xFF} var notTerm = []byte{0xFF, 0xFF, 0xFF, 0xFE} func TestParsing(t *testing.T) { Convey("With a parser with a simple parser consumer", t, func() { tc := &testConsumer{} parser := Parser{} Convey("a well formed header and body", func() { buf := bytes.Buffer{} b, _ := bson.Marshal(strStruct{"header"}) buf.Write(b) b, _ = bson.Marshal(strStruct{"body"}) buf.Write(b) buf.Write(term) parser.In = &buf Convey("ReadBlock data parses correctly", func() { err := parser.ReadBlock(tc) So(err, ShouldBeNil) So(tc.eof, ShouldBeFalse) So(tc.headers[0], ShouldEqual, "header") So(tc.bodies[0], ShouldEqual, "body") err = parser.ReadBlock(tc) So(err, ShouldEqual, io.EOF) }) Convey("ReadAllBlock data parses correctly", func() { err := parser.ReadAllBlocks(tc) So(err, ShouldEqual, nil) So(tc.eof, ShouldBeTrue) So(tc.headers[0], ShouldEqual, "header") So(tc.bodies[0], ShouldEqual, "body") }) }) Convey("a well formed header and multiple body datas parse correctly", func() { buf := bytes.Buffer{} b, _ := bson.Marshal(strStruct{"header"}) buf.Write(b) b, _ = bson.Marshal(strStruct{"body0"}) buf.Write(b) b, _ = bson.Marshal(strStruct{"body1"}) buf.Write(b) b, _ = bson.Marshal(strStruct{"body2"}) buf.Write(b) buf.Write(term) parser.In = &buf err := parser.ReadBlock(tc) So(err, ShouldBeNil) So(tc.eof, ShouldBeFalse) So(tc.headers[0], ShouldEqual, "header") So(tc.bodies[0], ShouldEqual, "body0") So(tc.bodies[1], ShouldEqual, "body1") So(tc.bodies[2], ShouldEqual, "body2") err = parser.ReadBlock(tc) So(err, ShouldEqual, io.EOF) So(tc.eof, ShouldBeFalse) }) Convey("an incorrect terminator should cause an error", func() { buf := bytes.Buffer{} b, _ := bson.Marshal(strStruct{"header"}) buf.Write(b) b, _ = bson.Marshal(strStruct{"body"}) buf.Write(b) buf.Write(notTerm) parser.In = &buf err := parser.ReadBlock(tc) So(err, ShouldNotBeNil) }) Convey("an empty block should result in EOF", func() { buf := bytes.Buffer{} parser.In = &buf err := parser.ReadBlock(tc) So(err, ShouldEqual, io.EOF) So(tc.eof, ShouldBeFalse) }) Convey("an error comming from the consumer should propigate through the parser", func() { tc.eof = true buf := bytes.Buffer{} parser.In = &buf err := parser.ReadAllBlocks(tc) So(err.Error(), ShouldContainSubstring, "double end") }) Convey("a partial block should result in a non-EOF error", func() { buf := bytes.Buffer{} b, _ := bson.Marshal(strStruct{"header"}) buf.Write(b) b, _ = bson.Marshal(strStruct{"body"}) buf.Write(b) parser.In = &buf err := parser.ReadBlock(tc) So(err, ShouldNotBeNil) So(tc.eof, ShouldBeFalse) So(tc.headers[0], ShouldEqual, "header") So(tc.bodies[0], ShouldEqual, "body") }) Convey("a block with a missing terminator shoud result in a non-EOF error", func() { buf := bytes.Buffer{} b, _ := bson.Marshal(strStruct{"header"}) buf.Write(b) b, _ = bson.Marshal(strStruct{"body"}) buf.Write(b[:len(b)-1]) buf.Write([]byte{0x01}) buf.Write(notTerm) parser.In = &buf err := parser.ReadBlock(tc) So(err, ShouldNotBeNil) So(tc.eof, ShouldBeFalse) So(tc.headers[0], ShouldEqual, "header") So(tc.bodies, ShouldBeNil) }) }) return } mongo-tools-r3.6.3/common/archive/prelude.go000066400000000000000000000265561321131462300210740ustar00rootroot00000000000000// Copyright (C) MongoDB, Inc. 2014-present. // // 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 package archive import ( "bytes" "fmt" "io" "path/filepath" "sync/atomic" "github.com/mongodb/mongo-tools/common" "github.com/mongodb/mongo-tools/common/intents" "github.com/mongodb/mongo-tools/common/log" "github.com/mongodb/mongo-tools/common/options" "gopkg.in/mgo.v2/bson" ) //MetadataFile implements intents.file type MetadataFile struct { pos int64 // updated atomically, aligned at the beginning of the struct *bytes.Buffer Intent *intents.Intent } func (md *MetadataFile) Open() error { return nil } func (md *MetadataFile) Close() error { return nil } func (md *MetadataFile) Read(p []byte) (int, error) { n, err := md.Buffer.Read(p) atomic.AddInt64(&md.pos, int64(n)) return n, err } func (md *MetadataFile) Pos() int64 { return atomic.LoadInt64(&md.pos) } // DirLike represents the group of methods done on directories and files in dump directories, // or in archives, when mongorestore is figuring out what intents to create. type DirLike interface { Name() string Path() string Size() int64 IsDir() bool Stat() (DirLike, error) ReadDir() ([]DirLike, error) Parent() DirLike } // Prelude represents the knowledge gleaned from reading the prelude out of the archive. type Prelude struct { Header *Header DBS []string NamespaceMetadatas []*CollectionMetadata NamespaceMetadatasByDB map[string][]*CollectionMetadata } // Read consumes and checks the magic number at the beginning of the archive, // then it runs the parser with a Prelude as its consumer. func (prelude *Prelude) Read(in io.Reader) error { readMagicNumberBuf := make([]byte, 4) _, err := io.ReadAtLeast(in, readMagicNumberBuf, 4) if err != nil { return fmt.Errorf("I/O failure reading beginning of archive: %v", err) } readMagicNumber := uint32( (uint32(readMagicNumberBuf[0]) << 0) | (uint32(readMagicNumberBuf[1]) << 8) | (uint32(readMagicNumberBuf[2]) << 16) | (uint32(readMagicNumberBuf[3]) << 24), ) if readMagicNumber != MagicNumber { return fmt.Errorf("stream or file does not appear to be a mongodump archive") } if prelude.NamespaceMetadatasByDB != nil { prelude.NamespaceMetadatasByDB = make(map[string][]*CollectionMetadata, 0) } parser := Parser{In: in} parserConsumer := &preludeParserConsumer{prelude: prelude} return parser.ReadBlock(parserConsumer) } // NewPrelude generates a Prelude using the contents of an intent.Manager. func NewPrelude(manager *intents.Manager, concurrentColls int, serverVersion string) (*Prelude, error) { prelude := Prelude{ Header: &Header{ FormatVersion: archiveFormatVersion, ServerVersion: serverVersion, ToolVersion: options.VersionStr, ConcurrentCollections: int32(concurrentColls), }, NamespaceMetadatasByDB: make(map[string][]*CollectionMetadata, 0), } allIntents := manager.Intents() for _, intent := range allIntents { if intent.MetadataFile != nil { archiveMetadata, ok := intent.MetadataFile.(*MetadataFile) if !ok { return nil, fmt.Errorf("MetadataFile is not an archive.Metadata") } prelude.AddMetadata(&CollectionMetadata{ Database: intent.DB, Collection: intent.C, Metadata: archiveMetadata.Buffer.String(), }) } else { prelude.AddMetadata(&CollectionMetadata{ Database: intent.DB, Collection: intent.C, }) } } return &prelude, nil } // AddMetadata adds a metadata data structure to a prelude and does the required bookkeeping. func (prelude *Prelude) AddMetadata(cm *CollectionMetadata) { prelude.NamespaceMetadatas = append(prelude.NamespaceMetadatas, cm) if prelude.NamespaceMetadatasByDB == nil { prelude.NamespaceMetadatasByDB = make(map[string][]*CollectionMetadata) } _, ok := prelude.NamespaceMetadatasByDB[cm.Database] if !ok { prelude.DBS = append(prelude.DBS, cm.Database) } prelude.NamespaceMetadatasByDB[cm.Database] = append(prelude.NamespaceMetadatasByDB[cm.Database], cm) log.Logvf(log.Info, "archive prelude %v.%v", cm.Database, cm.Collection) } // Write writes the archive header. func (prelude *Prelude) Write(out io.Writer) error { magicNumberBytes := make([]byte, 4) for i := range magicNumberBytes { magicNumberBytes[i] = byte(uint32(MagicNumber) >> uint(i*8)) } _, err := out.Write(magicNumberBytes) if err != nil { return err } buf, err := bson.Marshal(prelude.Header) if err != nil { return err } _, err = out.Write(buf) if err != nil { return err } for _, cm := range prelude.NamespaceMetadatas { buf, err = bson.Marshal(cm) if err != nil { return err } _, err = out.Write(buf) if err != nil { return err } } _, err = out.Write(terminatorBytes) if err != nil { return err } return nil } // preludeParserConsumer wraps a Prelude, and implements ParserConsumer. type preludeParserConsumer struct { prelude *Prelude } // HeaderBSON is part of the ParserConsumer interface, it unmarshals archive Headers. func (hpc *preludeParserConsumer) HeaderBSON(data []byte) error { hpc.prelude.Header = &Header{} err := bson.Unmarshal(data, hpc.prelude.Header) if err != nil { return err } return nil } // BodyBSON is part of the ParserConsumer interface, it unmarshals CollectionMetadata's. func (hpc *preludeParserConsumer) BodyBSON(data []byte) error { cm := &CollectionMetadata{} err := bson.Unmarshal(data, cm) if err != nil { return err } hpc.prelude.AddMetadata(cm) return nil } // BodyBSON is part of the ParserConsumer interface. func (hpc *preludeParserConsumer) End() error { return nil } // PreludeExplorer implements DirLike. PreludeExplorer represent the databases, collections, // and their metadata json files, of an archive, in such a way that they can be explored like a filesystem. type PreludeExplorer struct { prelude *Prelude database string collection string isMetadata bool } // NewPreludeExplorer creates a PreludeExplorer from a Prelude. func (prelude *Prelude) NewPreludeExplorer() (*PreludeExplorer, error) { pe := &PreludeExplorer{ prelude: prelude, } return pe, nil } // Name is part of the DirLike interface. It synthesizes a filename for the given "location" the prelude. func (pe *PreludeExplorer) Name() string { if pe.collection == "" { return pe.database } if pe.isMetadata { return pe.collection + ".metadata.json" } return pe.collection + ".bson" } // Path is part of the DirLike interface. It creates the full path for the "location" in the prelude. func (pe *PreludeExplorer) Path() string { if pe.collection == "" { return pe.database } if pe.database == "" { return pe.Name() } return filepath.Join(pe.database, pe.Name()) } // Size is part of the DirLike interface. It returns the size from the metadata // of the prelude, if the "location" is a collection. func (pe *PreludeExplorer) Size() int64 { if pe.IsDir() { return 0 } for _, ns := range pe.prelude.NamespaceMetadatas { if ns.Database == pe.database && ns.Collection == pe.collection { return int64(ns.Size) } } return 0 } // IsDir is part of the DirLike interface. All pes that are not collections are Dirs. func (pe *PreludeExplorer) IsDir() bool { return pe.collection == "" } // Stat is part of the DirLike interface. os.Stat returns a FileInfo, and since // DirLike is similar to FileInfo, we just return the pe, here. func (pe *PreludeExplorer) Stat() (DirLike, error) { return pe, nil } // ReadDir is part of the DirLIke interface. ReadDir generates a list of PreludeExplorers // whose "locations" are encapsulated by the current pes "location". // // "dump/oplog.bson" => &PreludeExplorer{ database: "", collection: "oplog.bson" } // "dump/test/" => &PreludeExplorer{ database: "test", collection: "foo.bson" } // "dump/test/foo.bson" => &PreludeExplorer{ database: "test", collection: "" } // "dump/test/foo.json" => &PreludeExplorer{ database: "test", collection: "foo", isMetadata: true } // func (pe *PreludeExplorer) ReadDir() ([]DirLike, error) { if !pe.IsDir() { return nil, fmt.Errorf("not a directory") } pes := []DirLike{} if pe.database == "" { // when reading the top level of the archive, we need return all of the // collections that are not bound to a database, aka, the oplog, and then all of // the databases the prelude stores all top-level collections as collections in // the "" database topLevelNamespaceMetadatas, ok := pe.prelude.NamespaceMetadatasByDB[""] if ok { for _, topLevelNamespaceMetadata := range topLevelNamespaceMetadatas { pes = append(pes, &PreludeExplorer{ prelude: pe.prelude, collection: topLevelNamespaceMetadata.Collection, }) if topLevelNamespaceMetadata.Metadata != "" { pes = append(pes, &PreludeExplorer{ prelude: pe.prelude, collection: topLevelNamespaceMetadata.Collection, isMetadata: true, }) } } } for _, db := range pe.prelude.DBS { pes = append(pes, &PreludeExplorer{ prelude: pe.prelude, database: db, }) } } else { // when reading the contents of a database directory, we just return all of the bson and // json files for all of the collections bound to that database namespaceMetadatas, ok := pe.prelude.NamespaceMetadatasByDB[pe.database] if !ok { return nil, fmt.Errorf("no such directory") //TODO: replace with real ERRNOs? } for _, namespaceMetadata := range namespaceMetadatas { pes = append(pes, &PreludeExplorer{ prelude: pe.prelude, database: pe.database, collection: namespaceMetadata.Collection, }) if namespaceMetadata.Metadata != "" { pes = append(pes, &PreludeExplorer{ prelude: pe.prelude, database: pe.database, collection: namespaceMetadata.Collection, isMetadata: true, }) } } } return pes, nil } // Parent is part of the DirLike interface. It returns a pe without a collection, if there is one, // otherwise, without a database. func (pe *PreludeExplorer) Parent() DirLike { if pe.collection != "" { return &PreludeExplorer{ prelude: pe.prelude, database: pe.database, } } return &PreludeExplorer{ prelude: pe.prelude, } } // MetadataPreludeFile is part of the intents.file. It allows the metadata contained in the prelude to be opened and read type MetadataPreludeFile struct { pos int64 // updated atomically, aligned at the beginning of the struct Intent *intents.Intent Origin string Prelude *Prelude *bytes.Buffer } // Open is part of the intents.file interface, it finds the metadata in the prelude and creates a bytes.Buffer from it. func (mpf *MetadataPreludeFile) Open() error { db, c := common.SplitNamespace(mpf.Origin) dbMetadatas, ok := mpf.Prelude.NamespaceMetadatasByDB[db] if !ok { return fmt.Errorf("no metadata found for '%s'", db) } for _, metadata := range dbMetadatas { if metadata.Collection == c { mpf.Buffer = bytes.NewBufferString(metadata.Metadata) return nil } } return fmt.Errorf("no matching metadata found for '%s'", mpf.Origin) } // Close is part of the intents.file interface. func (mpf *MetadataPreludeFile) Close() error { mpf.Buffer = nil return nil } func (mpf *MetadataPreludeFile) Read(p []byte) (int, error) { n, err := mpf.Buffer.Read(p) atomic.AddInt64(&mpf.pos, int64(n)) return n, err } func (mpf *MetadataPreludeFile) Pos() int64 { return atomic.LoadInt64(&mpf.pos) } mongo-tools-r3.6.3/common/archive/prelude_test.go000066400000000000000000000027711321131462300221240ustar00rootroot00000000000000// Copyright (C) MongoDB, Inc. 2014-present. // // 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 package archive import ( "bytes" . "github.com/smartystreets/goconvey/convey" // "gopkg.in/mgo.v2/bson" "testing" ) func TestPrelude(t *testing.T) { var err error Convey("WritePrelude/ReadPrelude roundtrip", t, func() { cm1 := &CollectionMetadata{ Database: "db1", Collection: "c1", Metadata: "m1", } cm2 := &CollectionMetadata{ Database: "db1", Collection: "c2", Metadata: "m2", } cm3 := &CollectionMetadata{ Database: "db2", Collection: "c3", Metadata: "m3", } cm4 := &CollectionMetadata{ Database: "db3", Collection: "c4", Metadata: "m4", } archivePrelude := &Prelude{ Header: &Header{ FormatVersion: "version-foo", }, NamespaceMetadatas: []*CollectionMetadata{cm1, cm2, cm3, cm4}, DBS: []string{"db1", "db2", "db3"}, NamespaceMetadatasByDB: map[string][]*CollectionMetadata{ "db1": []*CollectionMetadata{cm1, cm2}, "db2": []*CollectionMetadata{cm3}, "db3": []*CollectionMetadata{cm4}, }, } buf := &bytes.Buffer{} err = archivePrelude.Write(buf) So(err, ShouldBeNil) archivePrelude2 := &Prelude{} err := archivePrelude2.Read(buf) So(err, ShouldBeNil) So(archivePrelude2, ShouldResemble, archivePrelude) }) } mongo-tools-r3.6.3/common/auth/000077500000000000000000000000001321131462300164075ustar00rootroot00000000000000mongo-tools-r3.6.3/common/auth/auth_info.go000066400000000000000000000043331321131462300207150ustar00rootroot00000000000000// Copyright (C) MongoDB, Inc. 2014-present. // // 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 // Package auth provides utilities for performing tasks related to authentication. package auth import ( "fmt" "github.com/mongodb/mongo-tools/common/db" "gopkg.in/mgo.v2/bson" "strings" ) // GetAuthVersion gets the authentication schema version of the connected server // and returns that value as an integer along with any error that occurred. func GetAuthVersion(commander db.CommandRunner) (int, error) { results := bson.M{} err := commander.Run( bson.D{ {"getParameter", 1}, {"authSchemaVersion", 1}, }, &results, "admin", ) if err != nil { errMessage := err.Error() // as a necessary hack, if the error message takes a certain form, // we can infer version 1. This is because early versions of mongodb // had no concept of an "auth schema version", so asking for the // authSchemaVersion value will return a "no option found" or "no such cmd" if errMessage == "no option found to get" || strings.HasPrefix(errMessage, "no such cmd") { return 1, nil } // otherwise it's a connection error, so bubble it up return 0, err } version, ok := results["authSchemaVersion"].(int) if !ok { // very unlikely this will ever happen return 0, fmt.Errorf( "getParameter command returned non-numeric result: %v", results["authSchemaVersion"]) } return version, nil } // VerifySystemAuthVersion returns an error if authentication is not set up for // the given server. func VerifySystemAuthVersion(sessionProvider *db.SessionProvider) error { session, err := sessionProvider.GetSession() if err != nil { return fmt.Errorf("error getting session from server: %v", err) } defer session.Close() authSchemaQuery := bson.M{"_id": "authSchema"} versionEntries := session.DB("admin").C("system.version").Find(authSchemaQuery) if count, err := versionEntries.Count(); err != nil { return fmt.Errorf("error checking pressence of auth version: %v", err) } else if count == 0 { return fmt.Errorf("found no auth version") } return nil } mongo-tools-r3.6.3/common/bsonutil/000077500000000000000000000000001321131462300173055ustar00rootroot00000000000000mongo-tools-r3.6.3/common/bsonutil/bsonutil.go000066400000000000000000000257051321131462300215040ustar00rootroot00000000000000// Copyright (C) MongoDB, Inc. 2014-present. // // 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 // Package bsonutil provides utilities for processing BSON data. package bsonutil import ( "encoding/base64" "encoding/hex" "errors" "fmt" "github.com/mongodb/mongo-tools/common/json" "github.com/mongodb/mongo-tools/common/util" "gopkg.in/mgo.v2" "gopkg.in/mgo.v2/bson" "strconv" "time" ) var ErrNoSuchField = errors.New("no such field") // ConvertJSONDocumentToBSON iterates through the document map and converts JSON // values to their corresponding BSON values. It also replaces any extended JSON // type value (e.g. $date) with the corresponding BSON type. func ConvertJSONDocumentToBSON(doc map[string]interface{}) error { for key, jsonValue := range doc { var bsonValue interface{} var err error switch v := jsonValue.(type) { case map[string]interface{}, bson.D: // subdocument bsonValue, err = ParseSpecialKeys(v) default: bsonValue, err = ConvertJSONValueToBSON(v) } if err != nil { return err } doc[key] = bsonValue } return nil } // GetExtendedBsonD iterates through the document and returns a bson.D that adds type // information for each key in document. func GetExtendedBsonD(doc bson.D) (bson.D, error) { var err error var bsonDoc bson.D for _, docElem := range doc { var bsonValue interface{} switch v := docElem.Value.(type) { case map[string]interface{}, bson.D: // subdocument bsonValue, err = ParseSpecialKeys(v) default: bsonValue, err = ConvertJSONValueToBSON(v) } if err != nil { return nil, err } bsonDoc = append(bsonDoc, bson.DocElem{ Name: docElem.Name, Value: bsonValue, }) } return bsonDoc, nil } // FindValueByKey returns the value of keyName in document. If keyName is not found // in the top-level of the document, ErrNoSuchField is returned as the error. func FindValueByKey(keyName string, document *bson.D) (interface{}, error) { for _, key := range *document { if key.Name == keyName { return key.Value, nil } } return nil, ErrNoSuchField } // ParseSpecialKeys takes a JSON document and inspects it for any extended JSON // type (e.g $numberLong) and replaces any such values with the corresponding // BSON type. func ParseSpecialKeys(special interface{}) (interface{}, error) { // first ensure we are using a correct document type var doc map[string]interface{} switch v := special.(type) { case bson.D: doc = v.Map() case map[string]interface{}: doc = v default: return nil, fmt.Errorf("%v (type %T) is not valid input to ParseSpecialKeys", special, special) } // check document to see if it is special switch len(doc) { case 1: // document has a single field if jsonValue, ok := doc["$date"]; ok { switch v := jsonValue.(type) { case string: return util.FormatDate(v) case bson.D: asMap := v.Map() if jsonValue, ok := asMap["$numberLong"]; ok { n, err := parseNumberLongField(jsonValue) if err != nil { return nil, err } return time.Unix(n/1e3, n%1e3*1e6), err } return nil, errors.New("expected $numberLong field in $date") case map[string]interface{}: if jsonValue, ok := v["$numberLong"]; ok { n, err := parseNumberLongField(jsonValue) if err != nil { return nil, err } return time.Unix(n/1e3, n%1e3*1e6), err } return nil, errors.New("expected $numberLong field in $date") case json.Number: n, err := v.Int64() return time.Unix(n/1e3, n%1e3*1e6), err case float64: n := int64(v) return time.Unix(n/1e3, n%1e3*1e6), nil case int32: n := int64(v) return time.Unix(n/1e3, n%1e3*1e6), nil case int64: return time.Unix(v/1e3, v%1e3*1e6), nil case json.ISODate: return v, nil default: return nil, errors.New("invalid type for $date field") } } if jsonValue, ok := doc["$code"]; ok { switch v := jsonValue.(type) { case string: return bson.JavaScript{Code: v}, nil default: return nil, errors.New("expected $code field to have string value") } } if jsonValue, ok := doc["$oid"]; ok { switch v := jsonValue.(type) { case string: if !bson.IsObjectIdHex(v) { return nil, errors.New("expected $oid field to contain 24 hexadecimal character") } return bson.ObjectIdHex(v), nil default: return nil, errors.New("expected $oid field to have string value") } } if jsonValue, ok := doc["$numberLong"]; ok { return parseNumberLongField(jsonValue) } if jsonValue, ok := doc["$numberInt"]; ok { switch v := jsonValue.(type) { case string: // all of decimal, hex, and octal are supported here n, err := strconv.ParseInt(v, 0, 32) return int32(n), err default: return nil, errors.New("expected $numberInt field to have string value") } } if jsonValue, ok := doc["$timestamp"]; ok { ts := json.Timestamp{} var tsDoc map[string]interface{} switch internalDoc := jsonValue.(type) { case map[string]interface{}: tsDoc = internalDoc case bson.D: tsDoc = internalDoc.Map() default: return nil, errors.New("expected $timestamp key to have internal document") } if seconds, ok := tsDoc["t"]; ok { if asUint32, err := util.ToUInt32(seconds); err == nil { ts.Seconds = asUint32 } else { return nil, errors.New("expected $timestamp 't' field to be a numeric type") } } else { return nil, errors.New("expected $timestamp to have 't' field") } if inc, ok := tsDoc["i"]; ok { if asUint32, err := util.ToUInt32(inc); err == nil { ts.Increment = asUint32 } else { return nil, errors.New("expected $timestamp 'i' field to be a numeric type") } } else { return nil, errors.New("expected $timestamp to have 'i' field") } // see BSON spec for details on the bit fiddling here return bson.MongoTimestamp(int64(ts.Seconds)<<32 | int64(ts.Increment)), nil } if jsonValue, ok := doc["$numberDecimal"]; ok { switch v := jsonValue.(type) { case string: return bson.ParseDecimal128(v) default: return nil, errors.New("expected $numberDecimal field to have string value") } } if _, ok := doc["$undefined"]; ok { return bson.Undefined, nil } if _, ok := doc["$maxKey"]; ok { return bson.MaxKey, nil } if _, ok := doc["$minKey"]; ok { return bson.MinKey, nil } case 2: // document has two fields if jsonValue, ok := doc["$code"]; ok { code := bson.JavaScript{} switch v := jsonValue.(type) { case string: code.Code = v default: return nil, errors.New("expected $code field to have string value") } if jsonValue, ok = doc["$scope"]; ok { switch v2 := jsonValue.(type) { case map[string]interface{}, bson.D: x, err := ParseSpecialKeys(v2) if err != nil { return nil, err } code.Scope = x return code, nil default: return nil, errors.New("expected $scope field to contain map") } } else { return nil, errors.New("expected $scope field with $code field") } } if jsonValue, ok := doc["$regex"]; ok { regex := bson.RegEx{} switch pattern := jsonValue.(type) { case string: regex.Pattern = pattern default: return nil, errors.New("expected $regex field to have string value") } if jsonValue, ok = doc["$options"]; !ok { return nil, errors.New("expected $options field with $regex field") } switch options := jsonValue.(type) { case string: regex.Options = options default: return nil, errors.New("expected $options field to have string value") } // Validate regular expression options for i := range regex.Options { switch o := regex.Options[i]; o { default: return nil, fmt.Errorf("invalid regular expression option '%v'", o) case 'g', 'i', 'm', 's': // allowed } } return regex, nil } if jsonValue, ok := doc["$binary"]; ok { binary := bson.Binary{} switch data := jsonValue.(type) { case string: bytes, err := base64.StdEncoding.DecodeString(data) if err != nil { return nil, err } binary.Data = bytes default: return nil, errors.New("expected $binary field to have string value") } if jsonValue, ok = doc["$type"]; !ok { return nil, errors.New("expected $type field with $binary field") } switch typ := jsonValue.(type) { case string: kind, err := hex.DecodeString(typ) if err != nil { return nil, err } else if len(kind) != 1 { return nil, errors.New("expected single byte (as hexadecimal string) for $type field") } binary.Kind = kind[0] default: return nil, errors.New("expected $type field to have string value") } return binary, nil } if jsonValue, ok := doc["$ref"]; ok { dbRef := mgo.DBRef{} switch data := jsonValue.(type) { case string: dbRef.Collection = data default: return nil, errors.New("expected string for $ref field") } if jsonValue, ok = doc["$id"]; ok { switch v2 := jsonValue.(type) { case map[string]interface{}, bson.D: x, err := ParseSpecialKeys(v2) if err != nil { return nil, fmt.Errorf("error parsing $id field: %v", err) } dbRef.Id = x default: dbRef.Id = v2 } return dbRef, nil } } case 3: if jsonValue, ok := doc["$ref"]; ok { dbRef := mgo.DBRef{} switch data := jsonValue.(type) { case string: dbRef.Collection = data default: return nil, errors.New("expected string for $ref field") } if jsonValue, ok = doc["$id"]; ok { switch v2 := jsonValue.(type) { case map[string]interface{}, bson.D: x, err := ParseSpecialKeys(v2) if err != nil { return nil, fmt.Errorf("error parsing $id field: %v", err) } dbRef.Id = x default: dbRef.Id = v2 } if dbValue, ok := doc["$db"]; ok { switch v3 := dbValue.(type) { case string: dbRef.Database = v3 default: return nil, errors.New("expected string for $db field") } return dbRef, nil } } } } // nothing matched, so we recurse deeper switch v := special.(type) { case bson.D: return GetExtendedBsonD(v) case map[string]interface{}: return ConvertJSONValueToBSON(v) default: return nil, fmt.Errorf("%v (type %T) is not valid input to ParseSpecialKeys", special, special) } } // ParseJSONValue takes any value generated by the json package and returns a // BSON version of that value. func ParseJSONValue(jsonValue interface{}) (interface{}, error) { switch v := jsonValue.(type) { case map[string]interface{}, bson.D: // subdocument return ParseSpecialKeys(v) default: return ConvertJSONValueToBSON(v) } } func parseNumberLongField(jsonValue interface{}) (int64, error) { switch v := jsonValue.(type) { case string: // all of decimal, hex, and octal are supported here return strconv.ParseInt(v, 0, 64) default: return 0, errors.New("expected $numberLong field to have string value") } } mongo-tools-r3.6.3/common/bsonutil/converter.go000066400000000000000000000216621321131462300216520ustar00rootroot00000000000000// Copyright (C) MongoDB, Inc. 2014-present. // // 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 package bsonutil import ( "encoding/base64" "errors" "fmt" "github.com/mongodb/mongo-tools/common/json" "github.com/mongodb/mongo-tools/common/util" "gopkg.in/mgo.v2" "gopkg.in/mgo.v2/bson" "time" ) // ConvertJSONValueToBSON walks through a document or an array and // replaces any extended JSON value with its corresponding BSON type. func ConvertJSONValueToBSON(x interface{}) (interface{}, error) { switch v := x.(type) { case nil: return nil, nil case bool: return v, nil case map[string]interface{}: // document for key, jsonValue := range v { bsonValue, err := ParseJSONValue(jsonValue) if err != nil { return nil, err } v[key] = bsonValue } return v, nil case bson.D: for i := range v { var err error v[i].Value, err = ParseJSONValue(v[i].Value) if err != nil { return nil, err } } return v, nil case []interface{}: // array for i, jsonValue := range v { bsonValue, err := ParseJSONValue(jsonValue) if err != nil { return nil, err } v[i] = bsonValue } return v, nil case string, float64, int32, int64: return v, nil // require no conversion case json.ObjectId: // ObjectId s := string(v) if !bson.IsObjectIdHex(s) { return nil, errors.New("expected ObjectId to contain 24 hexadecimal characters") } return bson.ObjectIdHex(s), nil case json.Decimal128: return v.Decimal128, nil case json.Date: // Date n := int64(v) return time.Unix(n/1e3, n%1e3*1e6), nil case json.ISODate: // ISODate n := string(v) return util.FormatDate(n) case json.NumberLong: // NumberLong return int64(v), nil case json.NumberInt: // NumberInt return int32(v), nil case json.NumberFloat: // NumberFloat return float64(v), nil case json.BinData: // BinData data, err := base64.StdEncoding.DecodeString(v.Base64) if err != nil { return nil, err } return bson.Binary{v.Type, data}, nil case json.DBRef: // DBRef var err error v.Id, err = ParseJSONValue(v.Id) if err != nil { return nil, err } return mgo.DBRef{v.Collection, v.Id, v.Database}, nil case json.DBPointer: // DBPointer, for backwards compatibility return bson.DBPointer{v.Namespace, v.Id}, nil case json.RegExp: // RegExp return bson.RegEx{v.Pattern, v.Options}, nil case json.Timestamp: // Timestamp ts := (int64(v.Seconds) << 32) | int64(v.Increment) return bson.MongoTimestamp(ts), nil case json.JavaScript: // Javascript return bson.JavaScript{v.Code, v.Scope}, nil case json.MinKey: // MinKey return bson.MinKey, nil case json.MaxKey: // MaxKey return bson.MaxKey, nil case json.Undefined: // undefined return bson.Undefined, nil default: return nil, fmt.Errorf("conversion of JSON value '%v' of type '%T' not supported", v, v) } } func convertKeys(v bson.M) (bson.M, error) { for key, value := range v { jsonValue, err := ConvertBSONValueToJSON(value) if err != nil { return nil, err } v[key] = jsonValue } return v, nil } func getConvertedKeys(v bson.M) (bson.M, error) { out := bson.M{} for key, value := range v { jsonValue, err := GetBSONValueAsJSON(value) if err != nil { return nil, err } out[key] = jsonValue } return out, nil } // ConvertBSONValueToJSON walks through a document or an array and // converts any BSON value to its corresponding extended JSON type. // It returns the converted JSON document and any error encountered. func ConvertBSONValueToJSON(x interface{}) (interface{}, error) { switch v := x.(type) { case nil: return nil, nil case bool: return v, nil case *bson.M: // document doc, err := convertKeys(*v) if err != nil { return nil, err } return doc, err case bson.M: // document return convertKeys(v) case map[string]interface{}: return convertKeys(v) case bson.D: for i, value := range v { jsonValue, err := ConvertBSONValueToJSON(value.Value) if err != nil { return nil, err } v[i].Value = jsonValue } return MarshalD(v), nil case MarshalD: return v, nil case []interface{}: // array for i, value := range v { jsonValue, err := ConvertBSONValueToJSON(value) if err != nil { return nil, err } v[i] = jsonValue } return v, nil case string: return v, nil // require no conversion case int: return json.NumberInt(v), nil case bson.ObjectId: // ObjectId return json.ObjectId(v.Hex()), nil case bson.Decimal128: return json.Decimal128{v}, nil case time.Time: // Date return json.Date(v.Unix()*1000 + int64(v.Nanosecond()/1e6)), nil case int64: // NumberLong return json.NumberLong(v), nil case int32: // NumberInt return json.NumberInt(v), nil case float64: return json.NumberFloat(v), nil case float32: return json.NumberFloat(float64(v)), nil case []byte: // BinData (with generic type) data := base64.StdEncoding.EncodeToString(v) return json.BinData{0x00, data}, nil case bson.Binary: // BinData data := base64.StdEncoding.EncodeToString(v.Data) return json.BinData{v.Kind, data}, nil case mgo.DBRef: // DBRef return json.DBRef{v.Collection, v.Id, v.Database}, nil case bson.DBPointer: // DBPointer return json.DBPointer{v.Namespace, v.Id}, nil case bson.RegEx: // RegExp return json.RegExp{v.Pattern, v.Options}, nil case bson.MongoTimestamp: // Timestamp timestamp := int64(v) return json.Timestamp{ Seconds: uint32(timestamp >> 32), Increment: uint32(timestamp), }, nil case bson.JavaScript: // JavaScript var scope interface{} var err error if v.Scope != nil { scope, err = ConvertBSONValueToJSON(v.Scope) if err != nil { return nil, err } } return json.JavaScript{v.Code, scope}, nil default: switch x { case bson.MinKey: // MinKey return json.MinKey{}, nil case bson.MaxKey: // MaxKey return json.MaxKey{}, nil case bson.Undefined: // undefined return json.Undefined{}, nil } } return nil, fmt.Errorf("conversion of BSON value '%v' of type '%T' not supported", x, x) } // GetBSONValueAsJSON is equivalent to ConvertBSONValueToJSON, but does not mutate its argument. func GetBSONValueAsJSON(x interface{}) (interface{}, error) { switch v := x.(type) { case nil: return nil, nil case bool: return v, nil case *bson.M: // document doc, err := getConvertedKeys(*v) if err != nil { return nil, err } return doc, err case bson.M: // document return getConvertedKeys(v) case map[string]interface{}: return getConvertedKeys(v) case bson.D: out := bson.D{} for _, value := range v { jsonValue, err := GetBSONValueAsJSON(value.Value) if err != nil { return nil, err } out = append(out, bson.DocElem{ Name: value.Name, Value: jsonValue, }) } return MarshalD(out), nil case MarshalD: out, err := GetBSONValueAsJSON(bson.D(v)) if err != nil { return nil, err } return MarshalD(out.(bson.D)), nil case []interface{}: // array out := []interface{}{} for _, value := range v { jsonValue, err := GetBSONValueAsJSON(value) if err != nil { return nil, err } out = append(out, jsonValue) } return out, nil case string: return v, nil // require no conversion case int: return json.NumberInt(v), nil case bson.ObjectId: // ObjectId return json.ObjectId(v.Hex()), nil case bson.Decimal128: return json.Decimal128{v}, nil case time.Time: // Date return json.Date(v.Unix()*1000 + int64(v.Nanosecond()/1e6)), nil case int64: // NumberLong return json.NumberLong(v), nil case int32: // NumberInt return json.NumberInt(v), nil case float64: return json.NumberFloat(v), nil case float32: return json.NumberFloat(float64(v)), nil case []byte: // BinData (with generic type) data := base64.StdEncoding.EncodeToString(v) return json.BinData{0x00, data}, nil case bson.Binary: // BinData data := base64.StdEncoding.EncodeToString(v.Data) return json.BinData{v.Kind, data}, nil case mgo.DBRef: // DBRef return json.DBRef{v.Collection, v.Id, v.Database}, nil case bson.DBPointer: // DBPointer return json.DBPointer{v.Namespace, v.Id}, nil case bson.RegEx: // RegExp return json.RegExp{v.Pattern, v.Options}, nil case bson.MongoTimestamp: // Timestamp timestamp := int64(v) return json.Timestamp{ Seconds: uint32(timestamp >> 32), Increment: uint32(timestamp), }, nil case bson.JavaScript: // JavaScript var scope interface{} var err error if v.Scope != nil { scope, err = GetBSONValueAsJSON(v.Scope) if err != nil { return nil, err } } return json.JavaScript{v.Code, scope}, nil default: switch x { case bson.MinKey: // MinKey return json.MinKey{}, nil case bson.MaxKey: // MaxKey return json.MaxKey{}, nil case bson.Undefined: // undefined return json.Undefined{}, nil } } return nil, fmt.Errorf("conversion of BSON value '%v' of type '%T' not supported", x, x) } mongo-tools-r3.6.3/common/bsonutil/converter_test.go000066400000000000000000000245671321131462300227200ustar00rootroot00000000000000// Copyright (C) MongoDB, Inc. 2014-present. // // 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 package bsonutil import ( "encoding/base64" "fmt" "github.com/mongodb/mongo-tools/common/json" "github.com/mongodb/mongo-tools/common/testutil" . "github.com/smartystreets/goconvey/convey" "gopkg.in/mgo.v2" "gopkg.in/mgo.v2/bson" "testing" "time" ) func TestObjectIdBSONToJSON(t *testing.T) { testutil.VerifyTestType(t, testutil.UnitTestType) Convey("Converting a BSON ObjectId", t, func() { Convey("that is valid to JSON should produce a json.ObjectId", func() { bsonObjId := bson.NewObjectId() jsonObjId := json.ObjectId(bsonObjId.Hex()) _jObjId, err := ConvertBSONValueToJSON(bsonObjId) So(err, ShouldBeNil) jObjId, ok := _jObjId.(json.ObjectId) So(ok, ShouldBeTrue) So(jObjId, ShouldNotEqual, bsonObjId) So(jObjId, ShouldEqual, jsonObjId) }) }) } func TestArraysBSONToJSON(t *testing.T) { testutil.VerifyTestType(t, testutil.UnitTestType) Convey("Converting BSON arrays to JSON arrays", t, func() { Convey("should work for empty arrays", func() { jArr, err := ConvertBSONValueToJSON([]interface{}{}) So(err, ShouldBeNil) So(jArr, ShouldResemble, []interface{}{}) }) Convey("should work for one-level deep arrays", func() { objId := bson.NewObjectId() bsonArr := []interface{}{objId, 28, 0.999, "plain"} _jArr, err := ConvertBSONValueToJSON(bsonArr) So(err, ShouldBeNil) jArr, ok := _jArr.([]interface{}) So(ok, ShouldBeTrue) So(len(jArr), ShouldEqual, 4) So(jArr[0], ShouldEqual, json.ObjectId(objId.Hex())) So(jArr[1], ShouldEqual, 28) So(jArr[2], ShouldEqual, 0.999) So(jArr[3], ShouldEqual, "plain") }) Convey("should work for arrays with embedded objects", func() { bsonObj := []interface{}{ 80, bson.M{ "a": int64(20), "b": bson.M{ "c": bson.RegEx{Pattern: "hi", Options: "i"}, }, }, } __jObj, err := ConvertBSONValueToJSON(bsonObj) So(err, ShouldBeNil) _jObj, ok := __jObj.([]interface{}) So(ok, ShouldBeTrue) jObj, ok := _jObj[1].(bson.M) So(ok, ShouldBeTrue) So(len(jObj), ShouldEqual, 2) So(jObj["a"], ShouldEqual, json.NumberLong(20)) jjObj, ok := jObj["b"].(bson.M) So(ok, ShouldBeTrue) So(jjObj["c"], ShouldResemble, json.RegExp{"hi", "i"}) So(jjObj["c"], ShouldNotResemble, json.RegExp{"i", "hi"}) }) }) } func TestDateBSONToJSON(t *testing.T) { testutil.VerifyTestType(t, testutil.UnitTestType) timeNow := time.Now() secs := int64(timeNow.Unix()) nanosecs := timeNow.Nanosecond() millis := int64(nanosecs / 1e6) timeNowSecs := time.Unix(secs, int64(0)) timeNowMillis := time.Unix(secs, int64(millis*1e6)) Convey("Converting BSON time.Time 's dates to JSON", t, func() { // json.Date is stored as an int64 representing the number of milliseconds since the epoch Convey(fmt.Sprintf("should work with second granularity: %v", timeNowSecs), func() { _jObj, err := ConvertBSONValueToJSON(timeNowSecs) So(err, ShouldBeNil) jObj, ok := _jObj.(json.Date) So(ok, ShouldBeTrue) So(int64(jObj), ShouldEqual, secs*1e3) }) Convey(fmt.Sprintf("should work with millisecond granularity: %v", timeNowMillis), func() { _jObj, err := ConvertBSONValueToJSON(timeNowMillis) So(err, ShouldBeNil) jObj, ok := _jObj.(json.Date) So(ok, ShouldBeTrue) So(int64(jObj), ShouldEqual, secs*1e3+millis) }) Convey(fmt.Sprintf("should work with nanosecond granularity: %v", timeNow), func() { _jObj, err := ConvertBSONValueToJSON(timeNow) So(err, ShouldBeNil) jObj, ok := _jObj.(json.Date) So(ok, ShouldBeTrue) // we lose nanosecond precision So(int64(jObj), ShouldEqual, secs*1e3+millis) }) }) } func TestMaxKeyBSONToJSON(t *testing.T) { testutil.VerifyTestType(t, testutil.UnitTestType) Convey("Converting a BSON Maxkey to JSON", t, func() { Convey("should produce a json.MaxKey", func() { _jObj, err := ConvertBSONValueToJSON(bson.MaxKey) So(err, ShouldBeNil) jObj, ok := _jObj.(json.MaxKey) So(ok, ShouldBeTrue) So(jObj, ShouldResemble, json.MaxKey{}) }) }) } func TestMinKeyBSONToJSON(t *testing.T) { testutil.VerifyTestType(t, testutil.UnitTestType) Convey("Converting a BSON Maxkey to JSON", t, func() { Convey("should produce a json.MinKey", func() { _jObj, err := ConvertBSONValueToJSON(bson.MinKey) So(err, ShouldBeNil) jObj, ok := _jObj.(json.MinKey) So(ok, ShouldBeTrue) So(jObj, ShouldResemble, json.MinKey{}) }) }) } func Test64BitIntBSONToJSON(t *testing.T) { testutil.VerifyTestType(t, testutil.UnitTestType) Convey("Converting a BSON int64 to JSON", t, func() { Convey("should produce a json.NumberLong", func() { _jObj, err := ConvertBSONValueToJSON(int32(243)) So(err, ShouldBeNil) jObj, ok := _jObj.(json.NumberInt) So(ok, ShouldBeTrue) So(jObj, ShouldEqual, json.NumberInt(243)) }) }) } func Test32BitIntBSONToJSON(t *testing.T) { testutil.VerifyTestType(t, testutil.UnitTestType) Convey("Converting a BSON int32 integer to JSON", t, func() { Convey("should produce a json.NumberInt", func() { _jObj, err := ConvertBSONValueToJSON(int64(888234334343)) So(err, ShouldBeNil) jObj, ok := _jObj.(json.NumberLong) So(ok, ShouldBeTrue) So(jObj, ShouldEqual, json.NumberLong(888234334343)) }) }) } func TestRegExBSONToJSON(t *testing.T) { testutil.VerifyTestType(t, testutil.UnitTestType) Convey("Converting a BSON Regular Expression (= /decision/gi) to JSON", t, func() { Convey("should produce a json.RegExp", func() { _jObj, err := ConvertBSONValueToJSON(bson.RegEx{"decision", "gi"}) So(err, ShouldBeNil) jObj, ok := _jObj.(json.RegExp) So(ok, ShouldBeTrue) So(jObj, ShouldResemble, json.RegExp{"decision", "gi"}) }) }) } func TestUndefinedValueBSONToJSON(t *testing.T) { testutil.VerifyTestType(t, testutil.UnitTestType) Convey("Converting a BSON Undefined type to JSON", t, func() { Convey("should produce a json.Undefined", func() { _jObj, err := ConvertBSONValueToJSON(bson.Undefined) So(err, ShouldBeNil) jObj, ok := _jObj.(json.Undefined) So(ok, ShouldBeTrue) So(jObj, ShouldResemble, json.Undefined{}) }) }) } func TestDBRefBSONToJSON(t *testing.T) { testutil.VerifyTestType(t, testutil.UnitTestType) Convey("Converting BSON DBRef to JSON", t, func() { Convey("should produce a json.DBRef", func() { _jObj, err := ConvertBSONValueToJSON(mgo.DBRef{"coll1", "some_id", "test"}) So(err, ShouldBeNil) jObj, ok := _jObj.(json.DBRef) So(ok, ShouldBeTrue) So(jObj, ShouldResemble, json.DBRef{"coll1", "some_id", "test"}) So(jObj, ShouldNotResemble, json.DBRef{"coll1", "test", "some_id"}) }) }) } func TestTimestampBSONToJSON(t *testing.T) { testutil.VerifyTestType(t, testutil.UnitTestType) Convey("Converting a BSON Timestamp to JSON", t, func() { Convey("should produce a json.Timestamp", func() { // {t:803434343, i:9} == bson.MongoTimestamp(803434343*2**32 + 9) _jObj, err := ConvertBSONValueToJSON(bson.MongoTimestamp(uint64(803434343<<32) | uint64(9))) So(err, ShouldBeNil) jObj, ok := _jObj.(json.Timestamp) So(ok, ShouldBeTrue) So(jObj, ShouldResemble, json.Timestamp{Seconds: 803434343, Increment: 9}) So(jObj, ShouldNotResemble, json.Timestamp{Seconds: 803434343, Increment: 8}) }) }) } func TestBinaryBSONToJSON(t *testing.T) { testutil.VerifyTestType(t, testutil.UnitTestType) Convey("Converting BSON Binary data to JSON", t, func() { Convey("should produce a json.BinData", func() { _jObj, err := ConvertBSONValueToJSON(bson.Binary{'\x01', []byte("\x05\x20\x02\xae\xf7")}) So(err, ShouldBeNil) jObj, ok := _jObj.(json.BinData) So(ok, ShouldBeTrue) base64data1 := base64.StdEncoding.EncodeToString([]byte("\x05\x20\x02\xae\xf7")) base64data2 := base64.StdEncoding.EncodeToString([]byte("\x05\x20\x02\xaf\xf7")) So(jObj, ShouldResemble, json.BinData{'\x01', base64data1}) So(jObj, ShouldNotResemble, json.BinData{'\x01', base64data2}) }) }) } func TestGenericBytesBSONToJSON(t *testing.T) { testutil.VerifyTestType(t, testutil.UnitTestType) Convey("Converting Go bytes to JSON", t, func() { Convey("should produce a json.BinData with Type=0x00 (Generic)", func() { _jObj, err := ConvertBSONValueToJSON([]byte("this is something that's cool")) So(err, ShouldBeNil) jObj, ok := _jObj.(json.BinData) So(ok, ShouldBeTrue) base64data := base64.StdEncoding.EncodeToString([]byte("this is something that's cool")) So(jObj, ShouldResemble, json.BinData{0x00, base64data}) So(jObj, ShouldNotResemble, json.BinData{0x01, base64data}) }) }) } func TestUnknownBSONTypeToJSON(t *testing.T) { testutil.VerifyTestType(t, testutil.UnitTestType) Convey("Converting an unknown BSON type to JSON", t, func() { Convey("should produce an error", func() { _, err := ConvertBSONValueToJSON(func() {}) So(err, ShouldNotBeNil) }) }) } func TestDBPointerBSONToJSON(t *testing.T) { testutil.VerifyTestType(t, testutil.UnitTestType) Convey("Converting BSON DBPointer to JSON", t, func() { Convey("should produce a json.DBPointer", func() { objId := bson.NewObjectId() _jObj, err := ConvertBSONValueToJSON(bson.DBPointer{"dbrefnamespace", objId}) So(err, ShouldBeNil) jObj, ok := _jObj.(json.DBPointer) So(ok, ShouldBeTrue) So(jObj, ShouldResemble, json.DBPointer{"dbrefnamespace", objId}) }) }) } func TestJSCodeBSONToJSON(t *testing.T) { testutil.VerifyTestType(t, testutil.UnitTestType) Convey("Converting BSON Javascript code to JSON", t, func() { Convey("should produce a json.Javascript", func() { Convey("without scope if the scope for the BSON Javascript code is nil", func() { _jObj, err := ConvertBSONValueToJSON(bson.JavaScript{"function() { return null; }", nil}) So(err, ShouldBeNil) jObj, ok := _jObj.(json.JavaScript) So(ok, ShouldBeTrue) So(jObj, ShouldResemble, json.JavaScript{"function() { return null; }", nil}) }) Convey("with scope if the scope for the BSON Javascript code is non-nil", func() { _jObj, err := ConvertBSONValueToJSON(bson.JavaScript{"function() { return x; }", bson.M{"x": 2}}) So(err, ShouldBeNil) jObj, ok := _jObj.(json.JavaScript) So(ok, ShouldBeTrue) So(jObj.Scope.(bson.M)["x"], ShouldEqual, 2) So(jObj.Code, ShouldEqual, "function() { return x; }") }) }) }) } mongo-tools-r3.6.3/common/bsonutil/date_test.go000066400000000000000000000106421321131462300216130ustar00rootroot00000000000000// Copyright (C) MongoDB, Inc. 2014-present. // // 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 package bsonutil import ( "fmt" "github.com/mongodb/mongo-tools/common/json" . "github.com/smartystreets/goconvey/convey" "testing" "time" ) func TestDateValue(t *testing.T) { Convey("When converting JSON with Date values", t, func() { Convey("works for Date object", func() { key := "key" jsonMap := map[string]interface{}{ key: json.Date(100), } err := ConvertJSONDocumentToBSON(jsonMap) So(err, ShouldBeNil) jsonValue, ok := jsonMap[key].(time.Time) So(ok, ShouldBeTrue) So(jsonValue.Equal(time.Unix(0, int64(100*time.Millisecond))), ShouldBeTrue) }) Convey("works for Date document", func() { dates := []string{ "2006-01-02T15:04:05.000Z", "2006-01-02T15:04:05.000-0700", "2006-01-02T15:04:05Z", "2006-01-02T15:04:05-0700", "2006-01-02T15:04Z", "2006-01-02T15:04-0700", } for _, dateString := range dates { example := fmt.Sprintf(`{ "$date": "%v" }`, dateString) Convey(fmt.Sprintf("of string ('%v')", example), func() { key := "key" jsonMap := map[string]interface{}{ key: map[string]interface{}{ "$date": dateString, }, } err := ConvertJSONDocumentToBSON(jsonMap) So(err, ShouldBeNil) // dateString is a valid time format string date, err := time.Parse(dateString, dateString) So(err, ShouldBeNil) jsonValue, ok := jsonMap[key].(time.Time) So(ok, ShouldBeTrue) So(jsonValue.Equal(date), ShouldBeTrue) }) } date := time.Unix(0, int64(time.Duration(1136214245000)*time.Millisecond)) Convey(`of $numberLong ('{ "$date": { "$numberLong": "1136214245000" } }')`, func() { key := "key" jsonMap := map[string]interface{}{ key: map[string]interface{}{ "$date": map[string]interface{}{ "$numberLong": "1136214245000", }, }, } err := ConvertJSONDocumentToBSON(jsonMap) So(err, ShouldBeNil) jsonValue, ok := jsonMap[key].(time.Time) So(ok, ShouldBeTrue) So(jsonValue.Equal(date), ShouldBeTrue) }) Convey(`of json.Number ('{ "$date": 1136214245000 }')`, func() { key := "key" jsonMap := map[string]interface{}{ key: map[string]interface{}{ "$date": json.Number("1136214245000"), }, } err := ConvertJSONDocumentToBSON(jsonMap) So(err, ShouldBeNil) jsonValue, ok := jsonMap[key].(time.Time) So(ok, ShouldBeTrue) So(jsonValue.Equal(date), ShouldBeTrue) }) Convey(`of numeric int64 ('{ "$date": 1136214245000 }')`, func() { key := "key" jsonMap := map[string]interface{}{ key: map[string]interface{}{ "$date": int64(1136214245000), }, } err := ConvertJSONDocumentToBSON(jsonMap) So(err, ShouldBeNil) jsonValue, ok := jsonMap[key].(time.Time) So(ok, ShouldBeTrue) So(jsonValue.Equal(date), ShouldBeTrue) }) Convey(`of numeric float64 ('{ "$date": 1136214245000 }')`, func() { key := "key" jsonMap := map[string]interface{}{ key: map[string]interface{}{ "$date": float64(1136214245000), }, } err := ConvertJSONDocumentToBSON(jsonMap) So(err, ShouldBeNil) jsonValue, ok := jsonMap[key].(time.Time) So(ok, ShouldBeTrue) So(jsonValue.Equal(date), ShouldBeTrue) }) Convey(`of numeric int32 ('{ "$date": 2136800000 }')`, func() { key := "key" date = time.Unix(0, int64(time.Duration(2136800000)*time.Millisecond)) jsonMap := map[string]interface{}{ key: map[string]interface{}{ "$date": int32(2136800000), }, } err := ConvertJSONDocumentToBSON(jsonMap) So(err, ShouldBeNil) jsonValue, ok := jsonMap[key].(time.Time) So(ok, ShouldBeTrue) So(jsonValue.Equal(date), ShouldBeTrue) }) Convey(`of negative numeric int32 ('{ "$date": -2136800000 }')`, func() { key := "key" date = time.Unix(0, int64(time.Duration(-2136800000)*time.Millisecond)) jsonMap := map[string]interface{}{ key: map[string]interface{}{ "$date": int32(-2136800000), }, } err := ConvertJSONDocumentToBSON(jsonMap) So(err, ShouldBeNil) jsonValue, ok := jsonMap[key].(time.Time) So(ok, ShouldBeTrue) So(jsonValue.Equal(date), ShouldBeTrue) }) }) }) } mongo-tools-r3.6.3/common/bsonutil/marshal_d.go000066400000000000000000000034401321131462300215670ustar00rootroot00000000000000// Copyright (C) MongoDB, Inc. 2014-present. // // 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 package bsonutil import ( "bytes" "fmt" "github.com/mongodb/mongo-tools/common/json" "github.com/mongodb/mongo-tools/common/util" "gopkg.in/mgo.v2/bson" ) // MarshalD is a wrapper for bson.D that allows unmarshalling // of bson.D with preserved order. Necessary for printing // certain database commands. type MarshalD bson.D // MarshalJSON makes the MarshalD type usable by // the encoding/json package. func (md MarshalD) MarshalJSON() ([]byte, error) { var buff bytes.Buffer buff.WriteString("{") for i, item := range md { key, err := json.Marshal(item.Name) if err != nil { return nil, fmt.Errorf("cannot marshal key %v: %v", item.Name, err) } val, err := json.Marshal(item.Value) if err != nil { return nil, fmt.Errorf("cannot marshal value %v: %v", item.Value, err) } buff.Write(key) buff.WriteString(":") buff.Write(val) if i != len(md)-1 { buff.WriteString(",") } } buff.WriteString("}") return buff.Bytes(), nil } // MakeSortString takes a bson.D object and converts it to a slice of strings // that can be used as the input args to mgo's .Sort(...) function. // For example: // {a:1, b:-1} -> ["+a", "-b"] func MakeSortString(sortObj bson.D) ([]string, error) { sortStrs := make([]string, 0, len(sortObj)) for _, docElem := range sortObj { valueAsNumber, err := util.ToFloat64(docElem.Value) if err != nil { return nil, err } prefix := "+" if valueAsNumber < 0 { prefix = "-" } sortStrs = append(sortStrs, fmt.Sprintf("%v%v", prefix, docElem.Name)) } return sortStrs, nil } mongo-tools-r3.6.3/common/bsonutil/marshal_d_test.go000066400000000000000000000100711321131462300226240ustar00rootroot00000000000000// Copyright (C) MongoDB, Inc. 2014-present. // // 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 package bsonutil import ( "encoding/json" . "github.com/smartystreets/goconvey/convey" "gopkg.in/mgo.v2/bson" "strings" "testing" ) func TestMarshalDMarshalJSON(t *testing.T) { Convey("With a valid bson.D", t, func() { testD := bson.D{ {"cool", "rad"}, {"aaa", 543.2}, {"I", 0}, {"E", 0}, {"map", bson.M{"1": 1, "2": "two"}}, } Convey("wrapping with MarshalD should allow json.Marshal to work", func() { asJSON, err := json.Marshal(MarshalD(testD)) So(err, ShouldBeNil) strJSON := string(asJSON) Convey("with order preserved", func() { So(strings.Index(strJSON, "cool"), ShouldBeLessThan, strings.Index(strJSON, "aaa")) So(strings.Index(strJSON, "aaa"), ShouldBeLessThan, strings.Index(strJSON, "I")) So(strings.Index(strJSON, "I"), ShouldBeLessThan, strings.Index(strJSON, "E")) So(strings.Index(strJSON, "E"), ShouldBeLessThan, strings.Index(strJSON, "map")) So(strings.Count(strJSON, ","), ShouldEqual, 5) // 4 + 1 from internal map }) Convey("but still usable by the json parser", func() { var asMap bson.M err := json.Unmarshal(asJSON, &asMap) So(err, ShouldBeNil) Convey("with types & values preserved", func() { So(asMap["cool"], ShouldEqual, "rad") So(asMap["aaa"], ShouldEqual, 543.2) So(asMap["I"], ShouldEqual, 0) So(asMap["E"], ShouldEqual, 0) So(asMap["map"].(map[string]interface{})["1"], ShouldEqual, 1) So(asMap["map"].(map[string]interface{})["2"], ShouldEqual, "two") }) }) Convey("putting it inside another map should still be usable by json.Marshal", func() { _, err := json.Marshal(bson.M{"x": 0, "y": MarshalD(testD)}) So(err, ShouldBeNil) }) }) }) Convey("With en empty bson.D", t, func() { testD := bson.D{} Convey("wrapping with MarshalD should allow json.Marshal to work", func() { asJSON, err := json.Marshal(MarshalD(testD)) So(err, ShouldBeNil) strJSON := string(asJSON) So(strJSON, ShouldEqual, "{}") Convey("but still usable by the json parser", func() { var asInterface interface{} err := json.Unmarshal(asJSON, &asInterface) So(err, ShouldBeNil) asMap, ok := asInterface.(map[string]interface{}) So(ok, ShouldBeTrue) So(len(asMap), ShouldEqual, 0) }) }) }) } func TestFindValueByKey(t *testing.T) { Convey("Given a bson.D document and a specific key", t, func() { subDocument := &bson.D{ bson.DocElem{Name: "field4", Value: "c"}, } document := &bson.D{ bson.DocElem{Name: "field1", Value: "a"}, bson.DocElem{Name: "field2", Value: "b"}, bson.DocElem{Name: "field3", Value: subDocument}, } Convey("the corresponding value top-level keys should be returned", func() { value, err := FindValueByKey("field1", document) So(value, ShouldEqual, "a") So(err, ShouldBeNil) }) Convey("the corresponding value top-level keys with sub-document values should be returned", func() { value, err := FindValueByKey("field3", document) So(value, ShouldEqual, subDocument) So(err, ShouldBeNil) }) Convey("for non-existent keys nil and an error should be returned", func() { value, err := FindValueByKey("field4", document) So(value, ShouldBeNil) So(err, ShouldNotBeNil) }) }) } func TestEscapedKey(t *testing.T) { Convey("Given a bson.D document with a key that requires escaping", t, func() { document := bson.D{ bson.DocElem{Name: `foo"bar`, Value: "a"}, } Convey("it can be marshaled without error", func() { asJSON, err := json.Marshal(MarshalD(document)) So(err, ShouldBeNil) Convey("and subsequently unmarshaled without error", func() { var asMap bson.M err := json.Unmarshal(asJSON, &asMap) So(err, ShouldBeNil) Convey("with the original value being correctly found with the unescaped key", func() { So(asMap[`foo"bar`], ShouldEqual, "a") }) }) }) }) } mongo-tools-r3.6.3/common/bsonutil/maxkey_test.go000066400000000000000000000021131321131462300221660ustar00rootroot00000000000000// Copyright (C) MongoDB, Inc. 2014-present. // // 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 package bsonutil import ( "github.com/mongodb/mongo-tools/common/json" . "github.com/smartystreets/goconvey/convey" "gopkg.in/mgo.v2/bson" "testing" ) func TestMaxKeyValue(t *testing.T) { Convey("When converting JSON with MaxKey values", t, func() { Convey("works for MaxKey literal", func() { key := "key" jsonMap := map[string]interface{}{ key: json.MaxKey{}, } err := ConvertJSONDocumentToBSON(jsonMap) So(err, ShouldBeNil) So(jsonMap[key], ShouldResemble, bson.MaxKey) }) Convey(`works for MaxKey document ('{ "$maxKey": 1 }')`, func() { key := "key" jsonMap := map[string]interface{}{ key: map[string]interface{}{ "$maxKey": 1, }, } err := ConvertJSONDocumentToBSON(jsonMap) So(err, ShouldBeNil) So(jsonMap[key], ShouldResemble, bson.MaxKey) }) }) } mongo-tools-r3.6.3/common/bsonutil/minkey_test.go000066400000000000000000000021131321131462300221640ustar00rootroot00000000000000// Copyright (C) MongoDB, Inc. 2014-present. // // 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 package bsonutil import ( "github.com/mongodb/mongo-tools/common/json" . "github.com/smartystreets/goconvey/convey" "gopkg.in/mgo.v2/bson" "testing" ) func TestMinKeyValue(t *testing.T) { Convey("When converting JSON with MinKey values", t, func() { Convey("works for MinKey literal", func() { key := "key" jsonMap := map[string]interface{}{ key: json.MinKey{}, } err := ConvertJSONDocumentToBSON(jsonMap) So(err, ShouldBeNil) So(jsonMap[key], ShouldResemble, bson.MinKey) }) Convey(`works for MinKey document ('{ "$minKey": 1 }')`, func() { key := "key" jsonMap := map[string]interface{}{ key: map[string]interface{}{ "$minKey": 1, }, } err := ConvertJSONDocumentToBSON(jsonMap) So(err, ShouldBeNil) So(jsonMap[key], ShouldResemble, bson.MinKey) }) }) } mongo-tools-r3.6.3/common/bsonutil/number.go000066400000000000000000000011631321131462300211250ustar00rootroot00000000000000// Copyright (C) MongoDB, Inc. 2014-present. // // 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 package bsonutil import ( "fmt" "reflect" ) var floatType = reflect.TypeOf(float64(0)) func getFloat(unk interface{}) (float64, error) { v := reflect.ValueOf(unk) v = reflect.Indirect(v) if !v.Type().ConvertibleTo(floatType) { return 0, fmt.Errorf("cannot convert %v to float64", v.Type()) } fv := v.Convert(floatType) return fv.Float(), nil } mongo-tools-r3.6.3/common/bsonutil/numberint_test.go000066400000000000000000000021121321131462300226720ustar00rootroot00000000000000// Copyright (C) MongoDB, Inc. 2014-present. // // 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 package bsonutil import ( "github.com/mongodb/mongo-tools/common/json" . "github.com/smartystreets/goconvey/convey" "testing" ) func TestNumberIntValue(t *testing.T) { Convey("When converting JSON with NumberInt values", t, func() { Convey("works for NumberInt constructor", func() { key := "key" jsonMap := map[string]interface{}{ key: json.NumberInt(42), } err := ConvertJSONDocumentToBSON(jsonMap) So(err, ShouldBeNil) So(jsonMap[key], ShouldEqual, int32(42)) }) Convey(`works for NumberInt document ('{ "$numberInt": "42" }')`, func() { key := "key" jsonMap := map[string]interface{}{ key: map[string]interface{}{ "$numberInt": "42", }, } err := ConvertJSONDocumentToBSON(jsonMap) So(err, ShouldBeNil) So(jsonMap[key], ShouldEqual, int32(42)) }) }) } mongo-tools-r3.6.3/common/bsonutil/numberlong_test.go000066400000000000000000000021211321131462300230370ustar00rootroot00000000000000// Copyright (C) MongoDB, Inc. 2014-present. // // 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 package bsonutil import ( "github.com/mongodb/mongo-tools/common/json" . "github.com/smartystreets/goconvey/convey" "testing" ) func TestNumberLongValue(t *testing.T) { Convey("When converting JSON with NumberLong values", t, func() { Convey("works for NumberLong constructor", func() { key := "key" jsonMap := map[string]interface{}{ key: json.NumberLong(42), } err := ConvertJSONDocumentToBSON(jsonMap) So(err, ShouldBeNil) So(jsonMap[key], ShouldEqual, int64(42)) }) Convey(`works for NumberLong document ('{ "$numberLong": "42" }')`, func() { key := "key" jsonMap := map[string]interface{}{ key: map[string]interface{}{ "$numberLong": "42", }, } err := ConvertJSONDocumentToBSON(jsonMap) So(err, ShouldBeNil) So(jsonMap[key], ShouldEqual, int64(42)) }) }) } mongo-tools-r3.6.3/common/bsonutil/objectid_test.go000066400000000000000000000023331321131462300224570ustar00rootroot00000000000000// Copyright (C) MongoDB, Inc. 2014-present. // // 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 package bsonutil import ( "github.com/mongodb/mongo-tools/common/json" . "github.com/smartystreets/goconvey/convey" "gopkg.in/mgo.v2/bson" "testing" ) func TestObjectIdValue(t *testing.T) { Convey("When converting JSON with ObjectId values", t, func() { Convey("works for ObjectId constructor", func() { key := "key" jsonMap := map[string]interface{}{ key: json.ObjectId("0123456789abcdef01234567"), } err := ConvertJSONDocumentToBSON(jsonMap) So(err, ShouldBeNil) So(jsonMap[key], ShouldEqual, bson.ObjectIdHex("0123456789abcdef01234567")) }) Convey(`works for ObjectId document ('{ "$oid": "0123456789abcdef01234567" }')`, func() { key := "key" jsonMap := map[string]interface{}{ key: map[string]interface{}{ "$oid": "0123456789abcdef01234567", }, } err := ConvertJSONDocumentToBSON(jsonMap) So(err, ShouldBeNil) So(jsonMap[key], ShouldEqual, bson.ObjectIdHex("0123456789abcdef01234567")) }) }) } mongo-tools-r3.6.3/common/bsonutil/regexp_test.go000066400000000000000000000035211321131462300221660ustar00rootroot00000000000000// Copyright (C) MongoDB, Inc. 2014-present. // // 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 package bsonutil import ( "github.com/mongodb/mongo-tools/common/json" . "github.com/smartystreets/goconvey/convey" "gopkg.in/mgo.v2/bson" "testing" ) func TestRegExpValue(t *testing.T) { Convey("When converting JSON with RegExp values", t, func() { Convey("works for RegExp constructor", func() { key := "key" jsonMap := map[string]interface{}{ key: json.RegExp{"foo", "i"}, } err := ConvertJSONDocumentToBSON(jsonMap) So(err, ShouldBeNil) So(jsonMap[key], ShouldResemble, bson.RegEx{"foo", "i"}) }) Convey(`works for RegExp document ('{ "$regex": "foo", "$options": "i" }')`, func() { key := "key" jsonMap := map[string]interface{}{ key: map[string]interface{}{ "$regex": "foo", "$options": "i", }, } err := ConvertJSONDocumentToBSON(jsonMap) So(err, ShouldBeNil) So(jsonMap[key], ShouldResemble, bson.RegEx{"foo", "i"}) }) Convey(`can use multiple options ('{ "$regex": "bar", "$options": "gims" }')`, func() { key := "key" jsonMap := map[string]interface{}{ key: map[string]interface{}{ "$regex": "bar", "$options": "gims", }, } err := ConvertJSONDocumentToBSON(jsonMap) So(err, ShouldBeNil) So(jsonMap[key], ShouldResemble, bson.RegEx{"bar", "gims"}) }) Convey(`fails for an invalid option ('{ "$regex": "baz", "$options": "y" }')`, func() { key := "key" jsonMap := map[string]interface{}{ key: map[string]interface{}{ "$regex": "baz", "$options": "y", }, } err := ConvertJSONDocumentToBSON(jsonMap) So(err, ShouldNotBeNil) }) }) } mongo-tools-r3.6.3/common/bsonutil/timestamp_test.go000066400000000000000000000024141321131462300226770ustar00rootroot00000000000000// Copyright (C) MongoDB, Inc. 2014-present. // // 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 package bsonutil import ( "github.com/mongodb/mongo-tools/common/json" . "github.com/smartystreets/goconvey/convey" "gopkg.in/mgo.v2/bson" "testing" ) func TestTimestampValue(t *testing.T) { Convey("When converting JSON with Timestamp values", t, func() { testTS := bson.MongoTimestamp(123456<<32 | 55) Convey("works for Timestamp literal", func() { jsonMap := map[string]interface{}{ "ts": json.Timestamp{123456, 55}, } err := ConvertJSONDocumentToBSON(jsonMap) So(err, ShouldBeNil) So(jsonMap["ts"], ShouldEqual, testTS) }) Convey(`works for Timestamp document`, func() { Convey(`{"ts":{"$timestamp":{"t":123456, "i":55}}}`, func() { jsonMap := map[string]interface{}{ "ts": map[string]interface{}{ "$timestamp": map[string]interface{}{ "t": 123456.0, "i": 55.0, }, }, } bsonMap, err := ConvertJSONValueToBSON(jsonMap) So(err, ShouldBeNil) So(bsonMap.(map[string]interface{})["ts"], ShouldEqual, testTS) }) }) }) } mongo-tools-r3.6.3/common/bsonutil/undefined_test.go000066400000000000000000000021541321131462300226360ustar00rootroot00000000000000// Copyright (C) MongoDB, Inc. 2014-present. // // 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 package bsonutil import ( "github.com/mongodb/mongo-tools/common/json" . "github.com/smartystreets/goconvey/convey" "gopkg.in/mgo.v2/bson" "testing" ) func TestUndefinedValue(t *testing.T) { Convey("When converting JSON with undefined values", t, func() { Convey("works for undefined literal", func() { key := "key" jsonMap := map[string]interface{}{ key: json.Undefined{}, } err := ConvertJSONDocumentToBSON(jsonMap) So(err, ShouldBeNil) So(jsonMap[key], ShouldResemble, bson.Undefined) }) Convey(`works for undefined document ('{ "$undefined": true }')`, func() { key := "key" jsonMap := map[string]interface{}{ key: map[string]interface{}{ "$undefined": true, }, } err := ConvertJSONDocumentToBSON(jsonMap) So(err, ShouldBeNil) So(jsonMap[key], ShouldResemble, bson.Undefined) }) }) } mongo-tools-r3.6.3/common/common.go000066400000000000000000000011371321131462300172670ustar00rootroot00000000000000// Copyright (C) MongoDB, Inc. 2014-present. // // 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 // Package common contains subpackages that are shared amongst the mongo // tools. package common import ( "strings" ) // SplitNamespace returns the db and column from a single namespace string. func SplitNamespace(ns string) (string, string) { i := strings.Index(ns, ".") if i != -1 { return ns[:i], ns[i+1:] } return "", ns } mongo-tools-r3.6.3/common/connstring/000077500000000000000000000000001321131462300176325ustar00rootroot00000000000000mongo-tools-r3.6.3/common/connstring/connstring.go000066400000000000000000000345541321131462300223600ustar00rootroot00000000000000// Copyright (C) MongoDB, Inc. 2014-present. // // 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 package connstring import ( "errors" "fmt" "net" "net/url" "runtime" "strconv" "strings" "time" ) // Parse parses the provided uri and returns a URI object. func ParseURIConnectionString(s string) (ConnString, error) { var p parser err := p.parse(s) if err != nil { err = fmt.Errorf("error parsing uri (%s): %s", s, err) } return p.ConnString, err } // ConnString represents a connection string to mongodb. type ConnString struct { Original string AppName string AuthMechanism string AuthMechanismProperties map[string]string AuthSource string Connect ConnectMode ConnectTimeout time.Duration Database string FSync bool HeartbeatInterval time.Duration Hosts []string Journal bool KerberosService string KerberosServiceHost string MaxConnIdleTime time.Duration MaxConnLifeTime time.Duration MaxConnsPerHost uint16 MaxConnsPerHostSet bool MaxIdleConnsPerHost uint16 MaxIdleConnsPerHostSet bool Password string PasswordSet bool ReadPreference string ReadPreferenceTagSets []map[string]string ReplicaSet string ServerSelectionTimeout time.Duration SocketTimeout time.Duration Username string UseSSL bool W string WTimeout time.Duration UsingSRV bool Options map[string][]string UnknownOptions map[string][]string } func (u *ConnString) String() string { return u.Original } // ConnectMode informs the driver on how to connect // to the server. type ConnectMode uint8 // ConnectMode constants. const ( AutoConnect ConnectMode = iota SingleConnect ) type parser struct { ConnString haveWTimeoutMS bool } func (p *parser) parse(original string) error { p.Original = original uri := original var err error var isSRV bool if strings.HasPrefix(uri, "mongodb+srv://") { isSRV = true p.UsingSRV = true // SSL should be turned on by default when retrieving hosts from SRV p.UseSSL = true // remove the scheme uri = uri[14:] } else if strings.HasPrefix(uri, "mongodb://") { // remove the scheme uri = uri[10:] } else { return fmt.Errorf("scheme must be \"mongodb\" or \"mongodb+srv\"") } if idx := strings.Index(uri, "@"); idx != -1 { userInfo := uri[:idx] uri = uri[idx+1:] username := userInfo var password string if idx := strings.Index(userInfo, ":"); idx != -1 { username = userInfo[:idx] password = userInfo[idx+1:] p.PasswordSet = true } if len(username) > 1 { if strings.Contains(username, "/") { return fmt.Errorf("unescaped slash in username") } } p.Username, err = url.QueryUnescape(username) if err != nil { return fmt.Errorf("invalid username: %s", err) } if len(password) > 1 { if strings.Contains(password, ":") { return fmt.Errorf("unescaped colon in password") } if strings.Contains(password, "/") { return fmt.Errorf("unescaped slash in password") } p.Password, err = url.QueryUnescape(password) if err != nil { return fmt.Errorf("invalid password: %s", err) } } } // fetch the hosts field hosts := uri if idx := strings.IndexAny(uri, "/?@"); idx != -1 { if uri[idx] == '@' { return fmt.Errorf("unescaped @ sign in user info") } if uri[idx] == '?' { return fmt.Errorf("must have a / before the query ?") } hosts = uri[:idx] } var connectionArgsFromTXT []string parsedHosts := strings.Split(hosts, ",") if isSRV { parsedHosts = strings.Split(hosts, ",") if len(parsedHosts) != 1 { return fmt.Errorf("URI with SRV must include one and only one hostname") } parsedHosts, err = fetchSeedlistFromSRV(parsedHosts[0]) if err != nil { return err } // error ignored because finding a TXT record should not be // considered an error. recordsFromTXT, _ := net.LookupTXT(hosts) // This is a temporary fix to get around bug https://github.com/golang/go/issues/21472. // It will currently incorrectly concatenate multiple TXT records to one // on windows. if runtime.GOOS == "windows" { recordsFromTXT = []string{strings.Join(recordsFromTXT, "")} } if len(recordsFromTXT) > 1 { return errors.New("multiple records from TXT not supported") } if len(recordsFromTXT) > 0 { connectionArgsFromTXT = strings.FieldsFunc(recordsFromTXT[0], func(r rune) bool { return r == ';' || r == '&' }) err := validateTXTResult(connectionArgsFromTXT) if err != nil { return err } } } for _, host := range parsedHosts { err = p.addHost(host) if err != nil { return fmt.Errorf("invalid host \"%s\": %s", host, err) } } if len(p.Hosts) == 0 { return fmt.Errorf("must have at least 1 host") } uri = uri[len(hosts):] extractedDatabase, err := extractDatabaseFromURI(uri) if err != nil { return err } uri = extractedDatabase.uri p.Database = extractedDatabase.db connectionArgsFromQueryString, err := extractQueryArgsFromURI(uri) connectionArgPairs := append(connectionArgsFromTXT, connectionArgsFromQueryString...) for _, pair := range connectionArgPairs { err = p.addOption(pair) if err != nil { return err } } return nil } func fetchSeedlistFromSRV(host string) ([]string, error) { var err error _, _, err = net.SplitHostPort(host) if err == nil { // we were able to successfully extract a port from the host, // but should not be able to when using SRV return nil, fmt.Errorf("URI with srv must not include a port number") } _, addresses, err := net.LookupSRV("mongodb", "tcp", host) if err != nil { return nil, err } parsedHosts := make([]string, len(addresses)) for i, address := range addresses { trimmedAddressTarget := strings.TrimSuffix(address.Target, ".") err := validateSRVResult(trimmedAddressTarget, host) if err != nil { return nil, err } parsedHosts[i] = fmt.Sprintf("%s:%d", trimmedAddressTarget, address.Port) } return parsedHosts, nil } func (p *parser) addHost(host string) error { if host == "" { return nil } host, err := url.QueryUnescape(host) if err != nil { return fmt.Errorf("invalid host \"%s\": %s", host, err) } _, port, err := net.SplitHostPort(host) // this is unfortunate that SplitHostPort actually requires // a port to exist. if err != nil { if addrError, ok := err.(*net.AddrError); !ok || addrError.Err != "missing port in address" { return err } } if port != "" { d, err := strconv.Atoi(port) if err != nil { return fmt.Errorf("port must be an integer: %s", err) } if d <= 0 || d >= 65536 { return fmt.Errorf("port must be in the range [1, 65535]") } } p.Hosts = append(p.Hosts, host) return nil } func (p *parser) addOption(pair string) error { kv := strings.SplitN(pair, "=", 2) if len(kv) != 2 || kv[0] == "" { return fmt.Errorf("invalid option") } key, err := url.QueryUnescape(kv[0]) if err != nil { return fmt.Errorf("invalid option key \"%s\": %s", kv[0], err) } value, err := url.QueryUnescape(kv[1]) if err != nil { return fmt.Errorf("invalid option value \"%s\": %s", kv[1], err) } lowerKey := strings.ToLower(key) switch lowerKey { case "appname": p.AppName = value case "authmechanism": p.AuthMechanism = value case "authmechanismproperties": p.AuthMechanismProperties = make(map[string]string) pairs := strings.Split(value, ",") for _, pair := range pairs { kv := strings.SplitN(pair, ":", 2) if len(kv) != 2 || kv[0] == "" { return fmt.Errorf("invalid authMechanism property") } p.AuthMechanismProperties[kv[0]] = kv[1] } case "authsource": p.AuthSource = value case "connect": switch strings.ToLower(value) { case "auto", "automatic": p.Connect = AutoConnect case "direct", "single": p.Connect = SingleConnect default: return fmt.Errorf("invalid 'connect' value: %s", value) } case "connecttimeoutms": n, err := strconv.Atoi(value) if err != nil || n < 0 { return fmt.Errorf("invalid value for %s: %s", key, value) } p.ConnectTimeout = time.Duration(n) * time.Millisecond case "heartbeatintervalms", "heartbeatfrequencyms": n, err := strconv.Atoi(value) if err != nil || n < 0 { return fmt.Errorf("invalid value for %s: %s", key, value) } p.HeartbeatInterval = time.Duration(n) * time.Millisecond case "fsync": f, err := strconv.ParseBool(value) if err != nil { return fmt.Errorf("invalid value for %s: %s", key, value) } p.FSync = f case "j": j, err := strconv.ParseBool(value) if err != nil { return fmt.Errorf("invalid value for %s: %s", key, value) } p.Journal = j case "gssapiservicename": p.KerberosService = value case "gssapihostname": p.KerberosServiceHost = value case "maxconnsperhost": n, err := strconv.Atoi(value) if err != nil || n < 0 { return fmt.Errorf("invalid value for %s: %s", key, value) } p.MaxConnsPerHost = uint16(n) p.MaxConnsPerHostSet = true case "maxidleconnsperhost": n, err := strconv.Atoi(value) if err != nil || n < 0 { return fmt.Errorf("invalid value for %s: %s", key, value) } p.MaxIdleConnsPerHost = uint16(n) p.MaxIdleConnsPerHostSet = true case "maxidletimems": n, err := strconv.Atoi(value) if err != nil || n < 0 { return fmt.Errorf("invalid value for %s: %s", key, value) } p.MaxConnIdleTime = time.Duration(n) * time.Millisecond case "maxlifetimems": n, err := strconv.Atoi(value) if err != nil || n < 0 { return fmt.Errorf("invalid value for %s: %s", key, value) } p.MaxConnLifeTime = time.Duration(n) * time.Millisecond case "maxpoolsize": n, err := strconv.Atoi(value) if err != nil || n < 0 { return fmt.Errorf("invalid value for %s: %s", key, value) } p.MaxConnsPerHost = uint16(n) p.MaxConnsPerHostSet = true p.MaxIdleConnsPerHost = uint16(n) p.MaxIdleConnsPerHostSet = true case "readpreference": p.ReadPreference = value case "readpreferencetags": tags := make(map[string]string) items := strings.Split(value, ",") for _, item := range items { parts := strings.Split(item, ":") if len(parts) != 2 { return fmt.Errorf("invalid value for %s: %s", key, value) } tags[parts[0]] = parts[1] } p.ReadPreferenceTagSets = append(p.ReadPreferenceTagSets, tags) case "replicaset": p.ReplicaSet = value case "serverselectiontimeoutms": n, err := strconv.Atoi(value) if err != nil || n < 0 { return fmt.Errorf("invalid value for %s: %s", key, value) } p.ServerSelectionTimeout = time.Duration(n) * time.Millisecond case "sockettimeoutms": n, err := strconv.Atoi(value) if err != nil || n < 0 { return fmt.Errorf("invalid value for %s: %s", key, value) } p.SocketTimeout = time.Duration(n) * time.Millisecond case "ssl": b, err := strconv.ParseBool(value) if err != nil { return fmt.Errorf("invalid value for %s: %s", key, value) } p.UseSSL = b case "w": p.W = value case "wtimeoutms": n, err := strconv.Atoi(value) if err != nil || n < 0 { return fmt.Errorf("invalid value for %s: %s", key, value) } p.WTimeout = time.Duration(n) * time.Millisecond p.haveWTimeoutMS = true case "wtimeout": if p.haveWTimeoutMS { // use wtimeoutMS if it exists break } n, err := strconv.Atoi(value) if err != nil || n < 0 { return fmt.Errorf("invalid value for %s: %s", key, value) } p.WTimeout = time.Duration(n) * time.Millisecond default: if p.UnknownOptions == nil { p.UnknownOptions = make(map[string][]string) } p.UnknownOptions[lowerKey] = append(p.UnknownOptions[lowerKey], value) } if p.Options == nil { p.Options = make(map[string][]string) } p.Options[lowerKey] = append(p.Options[lowerKey], value) return nil } func validateSRVResult(recordFromSRV, inputHostName string) error { separatedInputDomain := strings.Split(inputHostName, ".") separatedRecord := strings.Split(recordFromSRV, ".") if len(separatedRecord) < 2 { return errors.New("DNS name must contain at least 2 labels") } if len(separatedRecord) < len(separatedInputDomain) { return errors.New("Domain suffix from SRV record not matched input domain") } inputDomainSuffix := separatedInputDomain[1:] domainSuffixOffset := len(separatedRecord) - (len(separatedInputDomain) - 1) recordDomainSuffix := separatedRecord[domainSuffixOffset:] for ix, label := range inputDomainSuffix { if label != recordDomainSuffix[ix] { return errors.New("Domain suffix from SRV record not matched input domain") } } return nil } var allowedTXTOptions = map[string]struct{}{ "authsource": {}, "replicaset": {}, } func validateTXTResult(paramsFromTXT []string) error { for _, param := range paramsFromTXT { kv := strings.SplitN(param, "=", 2) if len(kv) != 2 { return errors.New("Invalid TXT record") } key := strings.ToLower(kv[0]) if _, ok := allowedTXTOptions[key]; !ok { return fmt.Errorf("Cannot specify option '%s' in TXT record", kv[0]) } } return nil } func extractQueryArgsFromURI(uri string) ([]string, error) { if len(uri) == 0 { return nil, nil } if uri[0] != '?' { return nil, errors.New("must have a ? separator between path and query") } uri = uri[1:] if len(uri) == 0 { return nil, nil } return strings.FieldsFunc(uri, func(r rune) bool { return r == ';' || r == '&' }), nil } type extractedDatabase struct { uri string db string } // extractDatabaseFromURI is a helper function to retreive information about // the database from the passed in URI. It accepts as an argument the currently // parsed URI and returns the remainder of the uri, the database it found, // and any error it encounters while parsing. func extractDatabaseFromURI(uri string) (extractedDatabase, error) { if len(uri) == 0 { return extractedDatabase{}, nil } if uri[0] != '/' { return extractedDatabase{}, errors.New("must have a / separator between hosts and path") } uri = uri[1:] if len(uri) == 0 { return extractedDatabase{}, nil } database := uri if idx := strings.IndexRune(uri, '?'); idx != -1 { database = uri[:idx] } escapedDatabase, err := url.QueryUnescape(database) if err != nil { return extractedDatabase{}, fmt.Errorf("invalid database \"%s\": %s", database, err) } uri = uri[len(database):] return extractedDatabase{ uri: uri, db: escapedDatabase, }, nil } mongo-tools-r3.6.3/common/db/000077500000000000000000000000001321131462300160335ustar00rootroot00000000000000mongo-tools-r3.6.3/common/db/bson_stream.go000066400000000000000000000075041321131462300207040ustar00rootroot00000000000000// Copyright (C) MongoDB, Inc. 2014-present. // // 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 package db import ( "fmt" "gopkg.in/mgo.v2/bson" "io" ) // BSONSource reads documents from the underlying io.ReadCloser, Stream which // wraps a stream of BSON documents. type BSONSource struct { reusableBuf []byte Stream io.ReadCloser err error } // DecodedBSONSource reads documents from the underlying io.ReadCloser, Stream which // wraps a stream of BSON documents. type DecodedBSONSource struct { RawDocSource err error } // RawDocSource wraps basic functions for reading a BSON source file. type RawDocSource interface { LoadNext() []byte Close() error Err() error } // NewBSONSource creates a BSONSource with a reusable I/O buffer func NewBSONSource(in io.ReadCloser) *BSONSource { return &BSONSource{make([]byte, MaxBSONSize), in, nil} } // NewBufferlessBSONSource creates a BSONSource without a reusable I/O buffer func NewBufferlessBSONSource(in io.ReadCloser) *BSONSource { return &BSONSource{nil, in, nil} } // Close closes the BSONSource, rendering it unusable for I/O. // It returns an error, if any. func (bs *BSONSource) Close() error { return bs.Stream.Close() } func NewDecodedBSONSource(ds RawDocSource) *DecodedBSONSource { return &DecodedBSONSource{ds, nil} } // Err returns any error in the DecodedBSONSource or its RawDocSource. func (dbs *DecodedBSONSource) Err() error { if dbs.err != nil { return dbs.err } return dbs.RawDocSource.Err() } // Next unmarshals the next BSON document into result. Returns true if no errors // are encountered and false otherwise. func (dbs *DecodedBSONSource) Next(result interface{}) bool { doc := dbs.LoadNext() if doc == nil { return false } if err := bson.Unmarshal(doc, result); err != nil { dbs.err = err return false } dbs.err = nil return true } // LoadNext reads and returns the next BSON document in the stream. If the // BSONSource was created with NewBSONSource then each returned []byte will be // a slice of a single reused I/O buffer. If the BSONSource was created with // NewBufferlessBSONSource then each returend []byte will be individually // allocated func (bs *BSONSource) LoadNext() []byte { var into []byte if bs.reusableBuf == nil { into = make([]byte, 4) } else { into = bs.reusableBuf } // read the bson object size (a 4 byte integer) _, err := io.ReadAtLeast(bs.Stream, into[0:4], 4) if err != nil { if err != io.EOF { bs.err = err return nil } // we hit EOF right away, so we're at the end of the stream. bs.err = nil return nil } bsonSize := int32( (uint32(into[0]) << 0) | (uint32(into[1]) << 8) | (uint32(into[2]) << 16) | (uint32(into[3]) << 24), ) // Verify that the size of the BSON object we are about to read can // actually fit into the buffer that was provided. If not, either the BSON is // invalid, or the buffer passed in is too small. // Verify that we do not have an invalid BSON document with size < 5. if bsonSize > MaxBSONSize || bsonSize < 5 { bs.err = fmt.Errorf("invalid BSONSize: %v bytes", bsonSize) return nil } if int(bsonSize) > cap(into) { bigInto := make([]byte, bsonSize) copy(bigInto, into) into = bigInto if bs.reusableBuf != nil { bs.reusableBuf = bigInto } } into = into[:int(bsonSize)] _, err = io.ReadAtLeast(bs.Stream, into[4:], int(bsonSize-4)) if err != nil { if err != io.EOF { bs.err = err return nil } // this case means we hit EOF but read a partial document, // so there's a broken doc in the stream. Treat this as error. bs.err = fmt.Errorf("invalid bson: %v", err) return nil } bs.err = nil return into } func (bs *BSONSource) Err() error { return bs.err } mongo-tools-r3.6.3/common/db/bson_stream_test.go000066400000000000000000000025701321131462300217410ustar00rootroot00000000000000// Copyright (C) MongoDB, Inc. 2014-present. // // 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 package db import ( "bytes" . "github.com/smartystreets/goconvey/convey" "gopkg.in/mgo.v2/bson" "io/ioutil" "testing" ) func TestBufferlessBSONSource(t *testing.T) { var testValues = []bson.M{ {"_": bson.Binary{Kind: 0x80, Data: []byte("apples")}}, {"_": bson.Binary{Kind: 0x80, Data: []byte("bananas")}}, {"_": bson.Binary{Kind: 0x80, Data: []byte("cherries")}}, } Convey("with a buffer containing several bson documents with binary fields", t, func() { writeBuf := bytes.NewBuffer(make([]byte, 0, 1024)) for _, tv := range testValues { data, err := bson.Marshal(&tv) So(err, ShouldBeNil) _, err = writeBuf.Write(data) So(err, ShouldBeNil) } Convey("that we parse correctly with a BufferlessBSONSource", func() { bsonSource := NewDecodedBSONSource( NewBufferlessBSONSource(ioutil.NopCloser(writeBuf))) docs := []bson.M{} count := 0 doc := &bson.M{} for bsonSource.Next(doc) { count++ docs = append(docs, *doc) doc = &bson.M{} } So(bsonSource.Err(), ShouldBeNil) So(count, ShouldEqual, len(testValues)) So(docs, ShouldResemble, testValues) }) }) } mongo-tools-r3.6.3/common/db/buffered_bulk.go000066400000000000000000000044111321131462300211610ustar00rootroot00000000000000// Copyright (C) MongoDB, Inc. 2014-present. // // 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 package db import ( "fmt" "gopkg.in/mgo.v2" "gopkg.in/mgo.v2/bson" ) // BufferedBulkInserter implements a bufio.Writer-like design for queuing up // documents and inserting them in bulk when the given doc limit (or max // message size) is reached. Must be flushed at the end to ensure that all // documents are written. type BufferedBulkInserter struct { bulk *mgo.Bulk collection *mgo.Collection continueOnError bool docLimit int byteCount int docCount int unordered bool } // NewBufferedBulkInserter returns an initialized BufferedBulkInserter // for writing. func NewBufferedBulkInserter(collection *mgo.Collection, docLimit int, continueOnError bool) *BufferedBulkInserter { bb := &BufferedBulkInserter{ collection: collection, continueOnError: continueOnError, docLimit: docLimit, } bb.resetBulk() return bb } func (bb *BufferedBulkInserter) Unordered() { bb.unordered = true bb.bulk.Unordered() } // throw away the old bulk and init a new one func (bb *BufferedBulkInserter) resetBulk() { bb.bulk = bb.collection.Bulk() if bb.continueOnError || bb.unordered { bb.bulk.Unordered() } bb.byteCount = 0 bb.docCount = 0 } // Insert adds a document to the buffer for bulk insertion. If the buffer is // full, the bulk insert is made, returning any error that occurs. func (bb *BufferedBulkInserter) Insert(doc interface{}) error { rawBytes, err := bson.Marshal(doc) if err != nil { return fmt.Errorf("bson encoding error: %v", err) } // flush if we are full if bb.docCount >= bb.docLimit || bb.byteCount+len(rawBytes) > MaxBSONSize { err = bb.Flush() } // buffer the document bb.docCount++ bb.byteCount += len(rawBytes) bb.bulk.Insert(bson.Raw{Data: rawBytes}) return err } // Flush writes all buffered documents in one bulk insert then resets the buffer. func (bb *BufferedBulkInserter) Flush() error { if bb.docCount == 0 { return nil } defer bb.resetBulk() if _, err := bb.bulk.Run(); err != nil { return err } return nil } mongo-tools-r3.6.3/common/db/buffered_bulk_test.go000066400000000000000000000065201321131462300222230ustar00rootroot00000000000000// Copyright (C) MongoDB, Inc. 2014-present. // // 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 package db import ( "github.com/mongodb/mongo-tools/common/options" "github.com/mongodb/mongo-tools/common/testutil" . "github.com/smartystreets/goconvey/convey" "gopkg.in/mgo.v2/bson" "testing" ) func TestBufferedBulkInserterInserts(t *testing.T) { var bufBulk *BufferedBulkInserter testutil.VerifyTestType(t, "db") Convey("With a valid session", t, func() { opts := options.ToolOptions{ Connection: &options.Connection{ Port: DefaultTestPort, }, SSL: &options.SSL{}, Auth: &options.Auth{}, } provider, err := NewSessionProvider(opts) So(provider, ShouldNotBeNil) So(err, ShouldBeNil) session, err := provider.GetSession() So(session, ShouldNotBeNil) So(err, ShouldBeNil) Convey("using a test collection and a doc limit of 3", func() { testCol := session.DB("tools-test").C("bulk1") bufBulk = NewBufferedBulkInserter(testCol, 3, false) So(bufBulk, ShouldNotBeNil) Convey("inserting 10 documents into the BufferedBulkInserter", func() { flushCount := 0 for i := 0; i < 10; i++ { So(bufBulk.Insert(bson.D{}), ShouldBeNil) if bufBulk.docCount%3 == 0 { flushCount++ } } Convey("should have flushed 3 times with one doc still buffered", func() { So(flushCount, ShouldEqual, 3) So(bufBulk.byteCount, ShouldBeGreaterThan, 0) So(bufBulk.docCount, ShouldEqual, 1) }) }) }) Convey("using a test collection and a doc limit of 1", func() { testCol := session.DB("tools-test").C("bulk2") bufBulk = NewBufferedBulkInserter(testCol, 1, false) So(bufBulk, ShouldNotBeNil) Convey("inserting 10 documents into the BufferedBulkInserter and flushing", func() { for i := 0; i < 10; i++ { So(bufBulk.Insert(bson.D{}), ShouldBeNil) } So(bufBulk.Flush(), ShouldBeNil) Convey("should have no docs buffered", func() { So(bufBulk.docCount, ShouldEqual, 0) So(bufBulk.byteCount, ShouldEqual, 0) }) }) }) Convey("using a test collection and a doc limit of 1000", func() { testCol := session.DB("tools-test").C("bulk3") bufBulk = NewBufferedBulkInserter(testCol, 100, false) So(bufBulk, ShouldNotBeNil) Convey("inserting 1,000,000 documents into the BufferedBulkInserter and flushing", func() { session.SetSocketTimeout(0) for i := 0; i < 1000000; i++ { bufBulk.Insert(bson.M{"_id": i}) } So(bufBulk.Flush(), ShouldBeNil) Convey("should have inserted all of the documents", func() { count, err := testCol.Count() So(err, ShouldBeNil) So(count, ShouldEqual, 1000000) // test values testDoc := bson.M{} err = testCol.Find(bson.M{"_id": 477232}).One(&testDoc) So(err, ShouldBeNil) So(testDoc["_id"], ShouldEqual, 477232) err = testCol.Find(bson.M{"_id": 999999}).One(&testDoc) So(err, ShouldBeNil) So(testDoc["_id"], ShouldEqual, 999999) err = testCol.Find(bson.M{"_id": 1}).One(&testDoc) So(err, ShouldBeNil) So(testDoc["_id"], ShouldEqual, 1) }) }) }) Reset(func() { session.DB("tools-test").DropDatabase() session.Close() provider.Close() }) }) } mongo-tools-r3.6.3/common/db/command.go000066400000000000000000000146251321131462300200100ustar00rootroot00000000000000// Copyright (C) MongoDB, Inc. 2014-present. // // 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 package db import ( "fmt" "gopkg.in/mgo.v2" "gopkg.in/mgo.v2/bson" "strings" ) // Query flags const ( Snapshot = 1 << iota LogReplay Prefetch ) type NodeType string const ( Mongos NodeType = "mongos" Standalone = "standalone" ReplSet = "replset" Unknown = "unknown" ) // CommandRunner exposes functions that can be run against a server type CommandRunner interface { Run(command interface{}, out interface{}, database string) error FindOne(db, collection string, skip int, query interface{}, sort []string, into interface{}, opts int) error Remove(db, collection string, query interface{}) error DatabaseNames() ([]string, error) CollectionNames(db string) ([]string, error) } // Remove removes all documents matched by query q in the db database and c collection. func (sp *SessionProvider) Remove(db, c string, q interface{}) error { session, err := sp.GetSession() if err != nil { return err } defer session.Close() _, err = session.DB(db).C(c).RemoveAll(q) return err } // Run issues the provided command on the db database and unmarshals its result // into out. func (sp *SessionProvider) Run(command interface{}, out interface{}, db string) error { session, err := sp.GetSession() if err != nil { return err } defer session.Close() return session.DB(db).Run(command, out) } // DatabaseNames returns a slice containing the names of all the databases on the // connected server. func (sp *SessionProvider) DatabaseNames() ([]string, error) { session, err := sp.GetSession() if err != nil { return nil, err } session.SetSocketTimeout(0) defer session.Close() return session.DatabaseNames() } // CollectionNames returns the names of all the collections in the dbName database. func (sp *SessionProvider) CollectionNames(dbName string) ([]string, error) { session, err := sp.GetSession() if err != nil { return nil, err } defer session.Close() session.SetSocketTimeout(0) return session.DB(dbName).CollectionNames() } // GetNodeType checks if the connected SessionProvider is a mongos, standalone, or replset, // by looking at the result of calling isMaster. func (sp *SessionProvider) GetNodeType() (NodeType, error) { session, err := sp.GetSession() if err != nil { return Unknown, err } session.SetSocketTimeout(0) defer session.Close() masterDoc := struct { SetName interface{} `bson:"setName"` Hosts interface{} `bson:"hosts"` Msg string `bson:"msg"` }{} err = session.Run("isMaster", &masterDoc) if err != nil { return Unknown, err } if masterDoc.SetName != nil || masterDoc.Hosts != nil { return ReplSet, nil } else if masterDoc.Msg == "isdbgrid" { // isdbgrid is always the msg value when calling isMaster on a mongos // see http://docs.mongodb.org/manual/core/sharded-cluster-query-router/ return Mongos, nil } return Standalone, nil } // IsReplicaSet returns a boolean which is true if the connected server is part // of a replica set. func (sp *SessionProvider) IsReplicaSet() (bool, error) { nodeType, err := sp.GetNodeType() if err != nil { return false, err } return nodeType == ReplSet, nil } // IsMongos returns true if the connected server is a mongos. func (sp *SessionProvider) IsMongos() (bool, error) { nodeType, err := sp.GetNodeType() if err != nil { return false, err } return nodeType == Mongos, nil } // SupportsRepairCursor takes in an example db and collection name and // returns true if the connected server supports the repairCursor command. // It returns false and the error that occurred if it is not supported. func (sp *SessionProvider) SupportsRepairCursor(db, collection string) (bool, error) { session, err := sp.GetSession() if err != nil { return false, err } session.SetSocketTimeout(0) defer session.Close() // This check is slightly hacky, but necessary to allow users to run repair without // permissions to all collections. There are multiple reasons a repair command could fail, // but we are only interested in the ones that imply that the repair command is not // usable by the connected server. If we do not get one of these specific error messages, // we will let the error happen again later. repairIter := session.DB(db).C(collection).Repair() repairIter.Next(bson.D{}) err = repairIter.Err() if err == nil { return true, nil } if strings.Index(err.Error(), "no such cmd: repairCursor") > -1 { // return a helpful error message for early server versions return false, fmt.Errorf("--repair flag cannot be used on mongodb versions before 2.7.8") } if strings.Index(err.Error(), "repair iterator not supported") > -1 { // helpful error message if the storage engine does not support repair (WiredTiger) return false, fmt.Errorf("--repair is not supported by the connected storage engine") } return true, nil } // SupportsWriteCommands returns true if the connected server supports write // commands, returns false otherwise. func (sp *SessionProvider) SupportsWriteCommands() (bool, error) { session, err := sp.GetSession() if err != nil { return false, err } session.SetSocketTimeout(0) defer session.Close() masterDoc := struct { Ok int `bson:"ok"` MaxWire int `bson:"maxWireVersion"` }{} err = session.Run("isMaster", &masterDoc) if err != nil { return false, err } // the connected server supports write commands if // the maxWriteVersion field is present return (masterDoc.Ok == 1 && masterDoc.MaxWire >= 2), nil } // FindOne retuns the first document in the collection and database that matches // the query after skip, sort and query flags are applied. func (sp *SessionProvider) FindOne(db, collection string, skip int, query interface{}, sort []string, into interface{}, flags int) error { session, err := sp.GetSession() if err != nil { return err } defer session.Close() q := session.DB(db).C(collection).Find(query).Sort(sort...).Skip(skip) q = ApplyFlags(q, session, flags) return q.One(into) } // ApplyFlags applies flags to the given query session. func ApplyFlags(q *mgo.Query, session *mgo.Session, flags int) *mgo.Query { if flags&Snapshot > 0 { q = q.Snapshot() } if flags&LogReplay > 0 { q = q.LogReplay() } if flags&Prefetch > 0 { session.SetPrefetch(1.0) } return q } mongo-tools-r3.6.3/common/db/connector.go000066400000000000000000000046241321131462300203620ustar00rootroot00000000000000// Copyright (C) MongoDB, Inc. 2014-present. // // 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 package db import ( "net" "time" "github.com/mongodb/mongo-tools/common/db/kerberos" "github.com/mongodb/mongo-tools/common/options" "github.com/mongodb/mongo-tools/common/util" "gopkg.in/mgo.v2" ) // Interface type for connecting to the database. type DBConnector interface { // configure, based on the options passed in Configure(options.ToolOptions) error // dial the database and get a fresh new session GetNewSession() (*mgo.Session, error) } // Basic connector for dialing the database, with no authentication. type VanillaDBConnector struct { dialInfo *mgo.DialInfo } // Configure sets up the db connector using the options in opts. It parses the // connection string and then sets up the dial information using the default // dial timeout. func (self *VanillaDBConnector) Configure(opts options.ToolOptions) error { timeout := time.Duration(opts.Timeout) * time.Second // create the dialer func that will be used to connect dialer := func(addr *mgo.ServerAddr) (net.Conn, error) { conn, err := net.DialTimeout("tcp", addr.String(), timeout) if err != nil { return nil, err } // enable TCP keepalive err = util.EnableTCPKeepAlive(conn, time.Duration(opts.TCPKeepAliveSeconds)*time.Second) if err != nil { return nil, err } return conn, nil } // set up the dial info self.dialInfo = &mgo.DialInfo{ Direct: opts.Direct, ReplicaSetName: opts.ReplicaSetName, Username: opts.Auth.Username, Password: opts.Auth.Password, Source: opts.GetAuthenticationDatabase(), Mechanism: opts.Auth.Mechanism, DialServer: dialer, Timeout: timeout, } // create or fetch the addresses to be used to connect if opts.URI != nil && opts.URI.ConnectionString != "" { self.dialInfo.Addrs = opts.URI.GetConnectionAddrs() } else { self.dialInfo.Addrs = util.CreateConnectionAddrs(opts.Host, opts.Port) } kerberos.AddKerberosOpts(opts, self.dialInfo) return nil } // GetNewSession connects to the server and returns the established session and any // error encountered. func (self *VanillaDBConnector) GetNewSession() (*mgo.Session, error) { return mgo.DialWithInfo(self.dialInfo) } mongo-tools-r3.6.3/common/db/connector_sasl_test.go000066400000000000000000000031651321131462300224420ustar00rootroot00000000000000// Copyright (C) MongoDB, Inc. 2014-present. // // 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 // +build sasl package db // This file runs Kerberos tests if build with sasl is enabled import ( "fmt" "os" "runtime" "testing" "github.com/mongodb/mongo-tools/common/options" "github.com/mongodb/mongo-tools/common/testutil" . "github.com/smartystreets/goconvey/convey" "gopkg.in/mgo.v2/bson" ) var ( KERBEROS_HOST = "ldaptest.10gen.cc" KERBEROS_USER = "drivers@LDAPTEST.10GEN.CC" ) func TestKerberosAuthMechanism(t *testing.T) { Convey("should be able to successfully connect", t, func() { connector := &VanillaDBConnector{} opts := options.ToolOptions{ Connection: &options.Connection{ Host: KERBEROS_HOST, Port: "27017", }, Auth: &options.Auth{ Username: KERBEROS_USER, Mechanism: "GSSAPI", }, Kerberos: &options.Kerberos{ Service: "mongodb", ServiceHost: KERBEROS_HOST, }, } if runtime.GOOS == "windows" { opts.Auth.Password = os.Getenv(testutil.WinKerberosPwdEnv) if opts.Auth.Password == "" { panic(fmt.Sprintf("Need to set %v environment variable to run kerberos tests on windows", testutil.WinKerberosPwdEnv)) } } So(connector.Configure(opts), ShouldBeNil) session, err := connector.GetNewSession() So(err, ShouldBeNil) So(session, ShouldNotBeNil) n, err := session.DB("kerberos").C("test").Find(bson.M{}).Count() So(err, ShouldBeNil) So(n, ShouldEqual, 1) }) } mongo-tools-r3.6.3/common/db/connector_test.go000066400000000000000000000064051321131462300214200ustar00rootroot00000000000000// Copyright (C) MongoDB, Inc. 2014-present. // // 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 package db import ( "github.com/mongodb/mongo-tools/common/options" "github.com/mongodb/mongo-tools/common/testutil" . "github.com/smartystreets/goconvey/convey" "gopkg.in/mgo.v2" "testing" "time" ) func TestVanillaDBConnector(t *testing.T) { testutil.VerifyTestType(t, "db") Convey("With a vanilla db connector", t, func() { var connector *VanillaDBConnector Convey("calling Configure should populate the addrs and dial timeout"+ " appropriately with no error", func() { connector = &VanillaDBConnector{} opts := options.ToolOptions{ Connection: &options.Connection{ Host: "host1,host2", Port: "20000", }, Auth: &options.Auth{}, } So(connector.Configure(opts), ShouldBeNil) So(connector.dialInfo.Addrs, ShouldResemble, []string{"host1:20000", "host2:20000"}) So(connector.dialInfo.Timeout, ShouldResemble, time.Duration(opts.Timeout)*time.Second) }) Convey("calling GetNewSession with a running mongod should connect"+ " successfully", func() { connector = &VanillaDBConnector{} opts := options.ToolOptions{ Connection: &options.Connection{ Host: "localhost", Port: DefaultTestPort, }, Auth: &options.Auth{}, } So(connector.Configure(opts), ShouldBeNil) session, err := connector.GetNewSession() So(err, ShouldBeNil) So(session, ShouldNotBeNil) session.Close() }) }) } func TestVanillaDBConnectorWithAuth(t *testing.T) { testutil.VerifyTestType(t, "auth") session, err := mgo.Dial("localhost:33333") if err != nil { t.Fatalf("error dialing server: %v", err) } err = testutil.CreateUserAdmin(session) So(err, ShouldBeNil) err = testutil.CreateUserWithRole(session, "cAdmin", "password", mgo.RoleClusterAdmin, true) So(err, ShouldBeNil) session.Close() Convey("With a vanilla db connector and a mongod running with"+ " auth", t, func() { var connector *VanillaDBConnector Convey("connecting without authentication should not be able"+ " to run commands", func() { connector = &VanillaDBConnector{} opts := options.ToolOptions{ Connection: &options.Connection{ Host: "localhost", Port: DefaultTestPort, }, Auth: &options.Auth{}, } So(connector.Configure(opts), ShouldBeNil) session, err := connector.GetNewSession() So(err, ShouldBeNil) So(session, ShouldNotBeNil) So(session.DB("admin").Run("top", &struct{}{}), ShouldNotBeNil) session.Close() }) Convey("connecting with authentication should succeed and"+ " authenticate properly", func() { connector = &VanillaDBConnector{} opts := options.ToolOptions{ Connection: &options.Connection{ Host: "localhost", Port: DefaultTestPort, }, Auth: &options.Auth{ Username: "cAdmin", Password: "password", }, } So(connector.Configure(opts), ShouldBeNil) session, err := connector.GetNewSession() So(err, ShouldBeNil) So(session, ShouldNotBeNil) So(session.DB("admin").Run("top", &struct{}{}), ShouldBeNil) session.Close() }) }) } mongo-tools-r3.6.3/common/db/db.go000066400000000000000000000170751321131462300167610ustar00rootroot00000000000000// Copyright (C) MongoDB, Inc. 2014-present. // // 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 // Package db implements generic connection to MongoDB, and contains // subpackages for specific methods of connection. package db import ( "github.com/mongodb/mongo-tools/common/options" "github.com/mongodb/mongo-tools/common/password" "gopkg.in/mgo.v2" "gopkg.in/mgo.v2/bson" "fmt" "io" "strings" "sync" ) type ( sessionFlag uint32 // Used to get appropriate the DBConnector(s) based on opts GetConnectorFunc func(opts options.ToolOptions) DBConnector ) // Session flags. const ( None sessionFlag = 0 Monotonic sessionFlag = 1 << iota DisableSocketTimeout ) // MongoDB enforced limits. const ( MaxBSONSize = 16 * 1024 * 1024 // 16MB - maximum BSON document size ) // Default port for integration tests const ( DefaultTestPort = "33333" ) const ( ErrLostConnection = "lost connection to server" ErrNoReachableServers = "no reachable servers" ErrNsNotFound = "ns not found" // replication errors list the replset name if we are talking to a mongos, // so we can only check for this universal prefix ErrReplTimeoutPrefix = "waiting for replication timed out" ErrCouldNotContactPrimaryPrefix = "could not contact primary for replica set" ErrWriteResultsUnavailable = "write results unavailable from" ErrCouldNotFindPrimaryPrefix = `could not find host matching read preference { mode: "primary"` ErrUnableToTargetPrefix = "unable to target" ErrNotMaster = "not master" ErrConnectionRefusedSuffix = "Connection refused" ) var ( GetConnectorFuncs = []GetConnectorFunc{} ) // Used to manage database sessions type SessionProvider struct { // For connecting to the database connector DBConnector // used to avoid a race condition around creating the master session masterSessionLock sync.Mutex // the master session to use for connection pooling masterSession *mgo.Session // flags for generating the master session bypassDocumentValidation bool flags sessionFlag readPreference mgo.Mode tags bson.D } // ApplyOpsResponse represents the response from an 'applyOps' command. type ApplyOpsResponse struct { Ok bool `bson:"ok"` ErrMsg string `bson:"errmsg"` } // Oplog represents a MongoDB oplog document. type Oplog struct { Timestamp bson.MongoTimestamp `bson:"ts"` HistoryID int64 `bson:"h"` Version int `bson:"v"` Operation string `bson:"op"` Namespace string `bson:"ns"` Object bson.RawD `bson:"o"` Query bson.RawD `bson:"o2"` UI *bson.Binary `bson:"ui,omitempty"` } // Returns a session connected to the database server for which the // session provider is configured. func (self *SessionProvider) GetSession() (*mgo.Session, error) { self.masterSessionLock.Lock() defer self.masterSessionLock.Unlock() // The master session is initialized if self.masterSession != nil { return self.masterSession.Copy(), nil } // initialize the provider's master session var err error self.masterSession, err = self.connector.GetNewSession() if err != nil { return nil, fmt.Errorf("error connecting to db server: %v", err) } // update masterSession based on flags self.refresh() // copy the provider's master session, for connection pooling return self.masterSession.Copy(), nil } // Close closes the master session in the connection pool func (self *SessionProvider) Close() { self.masterSessionLock.Lock() defer self.masterSessionLock.Unlock() if self.masterSession != nil { self.masterSession.Close() } } // refresh is a helper for modifying the session based on the // session provider flags passed in with SetFlags. // This helper assumes a lock is already taken. func (self *SessionProvider) refresh() { // handle bypassDocumentValidation self.masterSession.SetBypassValidation(self.bypassDocumentValidation) // handle readPreference self.masterSession.SetMode(self.readPreference, true) // disable timeouts if (self.flags & DisableSocketTimeout) > 0 { self.masterSession.SetSocketTimeout(0) } if self.tags != nil { self.masterSession.SelectServers(self.tags) } } // SetFlags allows certain modifications to the masterSession after initial creation. func (self *SessionProvider) SetFlags(flagBits sessionFlag) { self.masterSessionLock.Lock() defer self.masterSessionLock.Unlock() self.flags = flagBits // make sure we update the master session if one already exists if self.masterSession != nil { self.refresh() } } // SetReadPreference sets the read preference mode in the SessionProvider // and eventually in the masterSession func (self *SessionProvider) SetReadPreference(pref mgo.Mode) { self.masterSessionLock.Lock() defer self.masterSessionLock.Unlock() self.readPreference = pref if self.masterSession != nil { self.refresh() } } // SetBypassDocumentValidation sets whether to bypass document validation in the SessionProvider // and eventually in the masterSession func (self *SessionProvider) SetBypassDocumentValidation(bypassDocumentValidation bool) { self.masterSessionLock.Lock() defer self.masterSessionLock.Unlock() self.bypassDocumentValidation = bypassDocumentValidation if self.masterSession != nil { self.refresh() } } // SetTags sets the server selection tags in the SessionProvider // and eventually in the masterSession func (self *SessionProvider) SetTags(tags bson.D) { self.masterSessionLock.Lock() defer self.masterSessionLock.Unlock() self.tags = tags if self.masterSession != nil { self.refresh() } } // NewSessionProvider constructs a session provider but does not attempt to // create the initial session. func NewSessionProvider(opts options.ToolOptions) (*SessionProvider, error) { // create the provider provider := &SessionProvider{ readPreference: mgo.Primary, bypassDocumentValidation: false, } // finalize auth options, filling in missing passwords if opts.Auth.ShouldAskForPassword() { opts.Auth.Password = password.Prompt() } // create the connector for dialing the database provider.connector = getConnector(opts) // configure the connector err := provider.connector.Configure(opts) if err != nil { return nil, fmt.Errorf("error configuring the connector: %v", err) } return provider, nil } // IsConnectionError returns a boolean indicating if a given error is due to // an error in an underlying DB connection (as opposed to some other write // failure such as a duplicate key error) func IsConnectionError(err error) bool { if err == nil { return false } lowerCaseError := strings.ToLower(err.Error()) if lowerCaseError == ErrNoReachableServers || err == io.EOF || strings.HasPrefix(lowerCaseError, ErrReplTimeoutPrefix) || strings.HasPrefix(lowerCaseError, ErrCouldNotContactPrimaryPrefix) || strings.HasPrefix(lowerCaseError, ErrWriteResultsUnavailable) || strings.HasPrefix(lowerCaseError, ErrCouldNotFindPrimaryPrefix) || strings.HasPrefix(lowerCaseError, ErrUnableToTargetPrefix) || lowerCaseError == ErrNotMaster || strings.HasSuffix(lowerCaseError, ErrConnectionRefusedSuffix) { return true } return false } // Get the right type of connector, based on the options func getConnector(opts options.ToolOptions) DBConnector { for _, getConnectorFunc := range GetConnectorFuncs { if connector := getConnectorFunc(opts); connector != nil { return connector } } return &VanillaDBConnector{} } mongo-tools-r3.6.3/common/db/db_ssl.go000066400000000000000000000012661321131462300176350ustar00rootroot00000000000000// Copyright (C) MongoDB, Inc. 2014-present. // // 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 // +build ssl package db import ( "github.com/mongodb/mongo-tools/common/db/openssl" "github.com/mongodb/mongo-tools/common/options" ) func init() { GetConnectorFuncs = append(GetConnectorFuncs, getSSLConnector) } // return the SSL DB connector if using SSL, otherwise, return nil. func getSSLConnector(opts options.ToolOptions) DBConnector { if opts.SSL.UseSSL { return &openssl.SSLDBConnector{} } return nil } mongo-tools-r3.6.3/common/db/db_test.go000066400000000000000000000073761321131462300200230ustar00rootroot00000000000000// Copyright (C) MongoDB, Inc. 2014-present. // // 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 package db import ( "github.com/mongodb/mongo-tools/common/options" "github.com/mongodb/mongo-tools/common/testutil" . "github.com/smartystreets/goconvey/convey" "gopkg.in/mgo.v2" "reflect" "testing" ) func TestNewSessionProvider(t *testing.T) { testutil.VerifyTestType(t, "db") Convey("When initializing a session provider", t, func() { Convey("with the standard options, a provider with a standard"+ " connector should be returned", func() { opts := options.ToolOptions{ Connection: &options.Connection{ Port: DefaultTestPort, }, SSL: &options.SSL{}, Auth: &options.Auth{}, } provider, err := NewSessionProvider(opts) So(err, ShouldBeNil) So(reflect.TypeOf(provider.connector), ShouldEqual, reflect.TypeOf(&VanillaDBConnector{})) Convey("and should be closeable", func() { provider.Close() }) }) Convey("the master session should be successfully "+ " initialized", func() { opts := options.ToolOptions{ Connection: &options.Connection{ Port: DefaultTestPort, }, SSL: &options.SSL{}, Auth: &options.Auth{}, } provider, err := NewSessionProvider(opts) So(err, ShouldBeNil) So(provider.masterSession, ShouldBeNil) session, err := provider.GetSession() So(err, ShouldBeNil) So(session, ShouldNotBeNil) session.Close() So(provider.masterSession, ShouldNotBeNil) err = provider.masterSession.Ping() So(err, ShouldBeNil) provider.Close() So(func() { provider.masterSession.Ping() }, ShouldPanic) }) }) } func TestGetIndexes(t *testing.T) { testutil.VerifyTestType(t, "db") Convey("With a valid session", t, func() { opts := options.ToolOptions{ Connection: &options.Connection{ Port: DefaultTestPort, }, SSL: &options.SSL{}, Auth: &options.Auth{}, } provider, err := NewSessionProvider(opts) So(err, ShouldBeNil) session, err := provider.GetSession() So(err, ShouldBeNil) existing := session.DB("exists").C("collection") missing := session.DB("exists").C("missing") missingDB := session.DB("missingDB").C("missingCollection") err = existing.Database.DropDatabase() So(err, ShouldBeNil) err = existing.Create(&mgo.CollectionInfo{}) So(err, ShouldBeNil) err = missingDB.Database.DropDatabase() So(err, ShouldBeNil) Convey("When GetIndexes is called on", func() { Convey("an existing collection there should be no error", func() { indexesIter, err := GetIndexes(existing) So(err, ShouldBeNil) Convey("and indexes should be returned", func() { So(indexesIter, ShouldNotBeNil) var indexes []mgo.Index err := indexesIter.All(&indexes) So(err, ShouldBeNil) So(len(indexes), ShouldBeGreaterThan, 0) }) }) Convey("a missing collection there should be no error", func() { indexesIter, err := GetIndexes(missing) So(err, ShouldBeNil) Convey("and there should be no indexes", func() { So(indexesIter, ShouldBeNil) }) }) Convey("a missing database there should be no error", func() { indexesIter, err := GetIndexes(missingDB) So(err, ShouldBeNil) Convey("and there should be no indexes", func() { So(indexesIter, ShouldBeNil) }) }) }) Reset(func() { existing.Database.DropDatabase() session.Close() provider.Close() }) }) } type listDatabasesCommand struct { Databases []map[string]interface{} `json:"databases"` Ok bool `json:"ok"` } func (self *listDatabasesCommand) AsRunnable() interface{} { return "listDatabases" } mongo-tools-r3.6.3/common/db/kerberos/000077500000000000000000000000001321131462300176475ustar00rootroot00000000000000mongo-tools-r3.6.3/common/db/kerberos/gssapi.go000066400000000000000000000016641321131462300214730ustar00rootroot00000000000000// Copyright (C) MongoDB, Inc. 2014-present. // // 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 // Package kerberos implements authentication to MongoDB using kerberos package kerberos // #cgo windows CFLAGS: -Ic:/sasl/include // #cgo windows LDFLAGS: -Lc:/sasl/lib import ( "github.com/mongodb/mongo-tools/common/options" "gopkg.in/mgo.v2" ) const authMechanism = "GSSAPI" func AddKerberosOpts(opts options.ToolOptions, dialInfo *mgo.DialInfo) { if dialInfo == nil { return } if opts.Kerberos == nil { return } if opts.Auth == nil || (opts.Auth.Mechanism != authMechanism && dialInfo.Mechanism != authMechanism) { return } dialInfo.Service = opts.Kerberos.Service dialInfo.ServiceHost = opts.Kerberos.ServiceHost dialInfo.Mechanism = authMechanism } mongo-tools-r3.6.3/common/db/namespaces.go000066400000000000000000000132421321131462300205030ustar00rootroot00000000000000// Copyright (C) MongoDB, Inc. 2014-present. // // 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 package db import ( "encoding/hex" "fmt" "strings" "github.com/mongodb/mongo-tools/common/log" "gopkg.in/mgo.v2" "gopkg.in/mgo.v2/bson" ) type CollectionInfo struct { Name string `bson:"name"` Type string `bson:"type"` Options *bson.D `bson:"options"` Info *bson.D `bson:"info"` } func (ci *CollectionInfo) IsView() bool { return ci.Type == "view" } func (ci *CollectionInfo) GetUUID() string { if ci.Info == nil { return "" } for _, v := range *ci.Info { if v.Name == "uuid" { switch x := v.Value.(type) { case bson.Binary: if x.Kind == 4 { return hex.EncodeToString(x.Data) } } } } return "" } // IsNoCmd reeturns true if err indicates a query command is not supported, // otherwise, returns false. func IsNoCmd(err error) bool { e, ok := err.(*mgo.QueryError) return ok && strings.HasPrefix(e.Message, "no such cmd:") } // IsNoNamespace returns true if err indicates a query resulted in a // "NamespaceNotFound" error otherwise, returns false. func IsNoNamespace(err error) bool { e, ok := err.(*mgo.QueryError) return ok && e.Code == 26 } // buildBsonArray takes a cursor iterator and returns an array of // all of its documents as bson.D objects. func buildBsonArray(iter *mgo.Iter) ([]bson.D, error) { ret := make([]bson.D, 0, 0) index := new(bson.D) for iter.Next(index) { ret = append(ret, *index) index = new(bson.D) } if iter.Err() != nil { return nil, iter.Err() } return ret, nil } // GetIndexes returns an iterator to thethe raw index info for a collection by // using the listIndexes command if available, or by falling back to querying // against system.indexes (pre-3.0 systems). nil is returned if the collection // does not exist. func GetIndexes(coll *mgo.Collection) (*mgo.Iter, error) { var cmdResult struct { Cursor struct { FirstBatch []bson.Raw `bson:"firstBatch"` NS string Id int64 } } err := coll.Database.Run(bson.D{{"listIndexes", coll.Name}, {"cursor", bson.M{}}}, &cmdResult) switch { case err == nil: ns := strings.SplitN(cmdResult.Cursor.NS, ".", 2) if len(ns) < 2 { return nil, fmt.Errorf("server returned invalid cursor.ns `%v` on listIndexes for `%v`: %v", cmdResult.Cursor.NS, coll.FullName, err) } ses := coll.Database.Session return ses.DB(ns[0]).C(ns[1]).NewIter(ses, cmdResult.Cursor.FirstBatch, cmdResult.Cursor.Id, nil), nil case IsNoCmd(err): log.Logvf(log.DebugLow, "No support for listIndexes command, falling back to querying system.indexes") return getIndexesPre28(coll) case IsNoNamespace(err): return nil, nil default: return nil, fmt.Errorf("error running `listIndexes`. Collection: `%v` Err: %v", coll.FullName, err) } } func getIndexesPre28(coll *mgo.Collection) (*mgo.Iter, error) { indexColl := coll.Database.C("system.indexes") iter := indexColl.Find(&bson.M{"ns": coll.FullName}).Iter() return iter, nil } func GetCollections(database *mgo.Database, name string) (*mgo.Iter, bool, error) { var cmdResult struct { Cursor struct { FirstBatch []bson.Raw `bson:"firstBatch"` NS string Id int64 } } command := bson.D{{"listCollections", 1}, {"cursor", bson.M{}}} if len(name) > 0 { command = bson.D{{"listCollections", 1}, {"filter", bson.M{"name": name}}, {"cursor", bson.M{}}} } err := database.Run(command, &cmdResult) switch { case err == nil: ns := strings.SplitN(cmdResult.Cursor.NS, ".", 2) if len(ns) < 2 { return nil, false, fmt.Errorf("server returned invalid cursor.ns `%v` on listCollections for `%v`: %v", cmdResult.Cursor.NS, database.Name, err) } return database.Session.DB(ns[0]).C(ns[1]).NewIter(database.Session, cmdResult.Cursor.FirstBatch, cmdResult.Cursor.Id, nil), false, nil case IsNoCmd(err): log.Logvf(log.DebugLow, "No support for listCollections command, falling back to querying system.namespaces") iter, err := getCollectionsPre28(database, name) return iter, true, err default: return nil, false, fmt.Errorf("error running `listCollections`. Database: `%v` Err: %v", database.Name, err) } } func getCollectionsPre28(database *mgo.Database, name string) (*mgo.Iter, error) { indexColl := database.C("system.namespaces") selector := bson.M{} if len(name) > 0 { selector["name"] = database.Name + "." + name } iter := indexColl.Find(selector).Iter() return iter, nil } func GetCollectionInfo(coll *mgo.Collection) (*CollectionInfo, error) { iter, useFullName, err := GetCollections(coll.Database, coll.Name) if err != nil { return nil, err } defer iter.Close() comparisonName := coll.Name if useFullName { comparisonName = coll.FullName } collInfo := &CollectionInfo{} for iter.Next(collInfo) { if collInfo.Name == comparisonName { if useFullName { collName, err := StripDBFromNamespace(collInfo.Name, coll.Database.Name) if err != nil { return nil, err } collInfo.Name = collName } break } } if err := iter.Err(); err != nil { return nil, err } return collInfo, nil } func StripDBFromNamespace(namespace string, dbName string) (string, error) { namespacePrefix := dbName + "." // if the collection info came from querying system.indexes (2.6 or earlier) then the // "name" we get includes the db name as well, so we must remove it if strings.HasPrefix(namespace, namespacePrefix) { return namespace[len(namespacePrefix):], nil } return "", fmt.Errorf("namespace '%v' format is invalid - expected to start with '%v'", namespace, namespacePrefix) } mongo-tools-r3.6.3/common/db/namespaces_test.go000066400000000000000000000030131321131462300215350ustar00rootroot00000000000000// Copyright (C) MongoDB, Inc. 2014-present. // // 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 package db import ( "fmt" "testing" . "github.com/smartystreets/goconvey/convey" ) type stripDBFromNamespaceTestCase struct { inputNamespace string inputDBName string outputNamespace string outputError error } func TestStripDBFromNamespace(t *testing.T) { Convey("When testing StripDBFromNamespace with cases", t, func() { testCases := []stripDBFromNamespaceTestCase{ { inputNamespace: "database.col", inputDBName: "database", outputNamespace: "col", outputError: nil, }, { inputNamespace: "database2.col", inputDBName: "database", outputNamespace: "", outputError: fmt.Errorf("namespace 'database2.col' format is invalid - expected to start with 'database.'"), }, { inputNamespace: "database.col", inputDBName: "notAPrefix", outputNamespace: "", outputError: fmt.Errorf("namespace 'database.col' format is invalid - expected to start with 'notAPrefix.'"), }, } Convey("cases should match expected", func() { for _, tc := range testCases { resultNamespace, resultError := StripDBFromNamespace(tc.inputNamespace, tc.inputDBName) So(resultError, ShouldResemble, tc.outputError) So(resultNamespace, ShouldEqual, tc.outputNamespace) } }) }) } mongo-tools-r3.6.3/common/db/openssl/000077500000000000000000000000001321131462300175165ustar00rootroot00000000000000mongo-tools-r3.6.3/common/db/openssl/openssl.go000066400000000000000000000135701321131462300215360ustar00rootroot00000000000000// Copyright (C) MongoDB, Inc. 2014-present. // // 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 // Package openssl implements connection to MongoDB over ssl. package openssl import ( "fmt" "net" "time" "github.com/mongodb/mongo-tools/common/db/kerberos" "github.com/mongodb/mongo-tools/common/log" "github.com/mongodb/mongo-tools/common/options" "github.com/mongodb/mongo-tools/common/util" "github.com/spacemonkeygo/openssl" "gopkg.in/mgo.v2" ) // For connecting to the database over ssl type SSLDBConnector struct { dialInfo *mgo.DialInfo ctx *openssl.Ctx } // Configure the connector to connect to the server over ssl. Parses the // connection string, and sets up the correct function to dial the server // based on the ssl options passed in. func (self *SSLDBConnector) Configure(opts options.ToolOptions) error { var err error self.ctx, err = setupCtx(opts) if err != nil { return fmt.Errorf("openssl configuration: %v", err) } var flags openssl.DialFlags flags = 0 if opts.SSLAllowInvalidCert || opts.SSLAllowInvalidHost { flags = openssl.InsecureSkipHostVerification } // create the dialer func that will be used to connect dialer := func(addr *mgo.ServerAddr) (net.Conn, error) { conn, err := openssl.Dial("tcp", addr.String(), self.ctx, flags) if err != nil { // mgo discards dialer errors so log it now log.Logvf(log.Always, "error dialing %v: %v", addr.String(), err) return nil, err } // enable TCP keepalive err = util.EnableTCPKeepAlive(conn.UnderlyingConn(), time.Duration(opts.TCPKeepAliveSeconds)*time.Second) if err != nil { // mgo discards dialer errors so log it now log.Logvf(log.Always, "error enabling TCP keepalive on connection to %v: %v", addr.String(), err) conn.Close() return nil, err } return conn, nil } timeout := time.Duration(opts.Timeout) * time.Second // set up the dial info self.dialInfo = &mgo.DialInfo{ Timeout: timeout, Direct: opts.Direct, ReplicaSetName: opts.ReplicaSetName, DialServer: dialer, Username: opts.Auth.Username, Password: opts.Auth.Password, Source: opts.GetAuthenticationDatabase(), Mechanism: opts.Auth.Mechanism, } // create or fetch the addresses to be used to connect if opts.URI != nil && opts.URI.ConnectionString != "" { self.dialInfo.Addrs = opts.URI.GetConnectionAddrs() } else { self.dialInfo.Addrs = util.CreateConnectionAddrs(opts.Host, opts.Port) } kerberos.AddKerberosOpts(opts, self.dialInfo) return nil } // Dial the server. func (self *SSLDBConnector) GetNewSession() (*mgo.Session, error) { return mgo.DialWithInfo(self.dialInfo) } // To be handed to mgo.DialInfo for connecting to the server. type dialerFunc func(addr *mgo.ServerAddr) (net.Conn, error) // Handle optionally compiled SSL initialization functions (fips mode set) type sslInitializationFunction func(options.ToolOptions) error var sslInitializationFunctions []sslInitializationFunction // Creates and configures an openssl.Ctx func setupCtx(opts options.ToolOptions) (*openssl.Ctx, error) { var ctx *openssl.Ctx var err error for _, sslInitFunc := range sslInitializationFunctions { sslInitFunc(opts) } if ctx, err = openssl.NewCtxWithVersion(openssl.AnyVersion); err != nil { return nil, fmt.Errorf("failure creating new openssl context with "+ "NewCtxWithVersion(AnyVersion): %v", err) } // OpAll - Activate all bug workaround options, to support buggy client SSL's. // NoSSLv2 - Disable SSL v2 support ctx.SetOptions(openssl.OpAll | openssl.NoSSLv2) // HIGH - Enable strong ciphers // !EXPORT - Disable export ciphers (40/56 bit) // !aNULL - Disable anonymous auth ciphers // @STRENGTH - Sort ciphers based on strength ctx.SetCipherList("HIGH:!EXPORT:!aNULL@STRENGTH") // add the PEM key file with the cert and private key, if specified if opts.SSLPEMKeyFile != "" { if err = ctx.UseCertificateChainFile(opts.SSLPEMKeyFile); err != nil { return nil, fmt.Errorf("UseCertificateChainFile: %v", err) } if opts.SSLPEMKeyPassword != "" { if err = ctx.UsePrivateKeyFileWithPassword( opts.SSLPEMKeyFile, openssl.FiletypePEM, opts.SSLPEMKeyPassword); err != nil { return nil, fmt.Errorf("UsePrivateKeyFile: %v", err) } } else { if err = ctx.UsePrivateKeyFile(opts.SSLPEMKeyFile, openssl.FiletypePEM); err != nil { return nil, fmt.Errorf("UsePrivateKeyFile: %v", err) } } // Verify that the certificate and the key go together. if err = ctx.CheckPrivateKey(); err != nil { return nil, fmt.Errorf("CheckPrivateKey: %v", err) } } // If renegotiation is needed, don't return from recv() or send() until it's successful. // Note: this is for blocking sockets only. ctx.SetMode(openssl.AutoRetry) // Disable session caching (see SERVER-10261) ctx.SetSessionCacheMode(openssl.SessionCacheOff) if opts.SSLCAFile != "" { calist, err := openssl.LoadClientCAFile(opts.SSLCAFile) if err != nil { return nil, fmt.Errorf("LoadClientCAFile: %v", err) } ctx.SetClientCAList(calist) if err = ctx.LoadVerifyLocations(opts.SSLCAFile, ""); err != nil { return nil, fmt.Errorf("LoadVerifyLocations: %v", err) } } else { err = ctx.SetupSystemCA() if err != nil { return nil, fmt.Errorf("Error setting up system certificate authority: %v", err) } } var verifyOption openssl.VerifyOptions if opts.SSLAllowInvalidCert { verifyOption = openssl.VerifyNone } else { verifyOption = openssl.VerifyPeer } ctx.SetVerify(verifyOption, nil) if opts.SSLCRLFile != "" { store := ctx.GetCertificateStore() store.SetFlags(openssl.CRLCheck) lookup, err := store.AddLookup(openssl.X509LookupFile()) if err != nil { return nil, fmt.Errorf("AddLookup(X509LookupFile()): %v", err) } lookup.LoadCRLFile(opts.SSLCRLFile) } return ctx, nil } mongo-tools-r3.6.3/common/db/openssl/openssl_fips.go000066400000000000000000000012301321131462300225450ustar00rootroot00000000000000// Copyright (C) MongoDB, Inc. 2014-present. // // 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 // +build ssl // +build -darwin package openssl import "github.com/spacemonkeygo/openssl" func init() { sslInitializationFunctions = append(sslInitializationFunctions, SetUpFIPSMode) } func SetUpFIPSMode(opts *ToolOptions) error { if err := openssl.FIPSModeSet(opts.SSLFipsMode); err != nil { return fmt.Errorf("couldn't set FIPS mode to %v: %v", opts.SSLFipsMode, err) } return nil } mongo-tools-r3.6.3/common/db/openssl/testdata/000077500000000000000000000000001321131462300213275ustar00rootroot00000000000000mongo-tools-r3.6.3/common/db/openssl/testdata/ca.pem000066400000000000000000000036621321131462300224240ustar00rootroot00000000000000-----BEGIN PRIVATE KEY----- MIICdgIBADANBgkqhkiG9w0BAQEFAASCAmAwggJcAgEAAoGBAMbN8D5Au+xWdY+s GpUuSFSbHGzYfHmw0yajA9J8PiwDePRMl71OMMsByNsykjzXEr0BBOn4PNO6KW7K HdDicRavuC/iFucVpILUiJoLOUCPKb/EyAHUk0r2fdr3Ypd2ZXkD1EXmM9WTQnyW PEWqr1T7MmM9PhsD0r8ZbQVu8R49AgMBAAECgYBbC+mguQjXfektOUabV6zsgnUM LEElgiPRqAqSFTBr+9MjHwjHO84Ayvpv2MM8dcsxIAxeEr/Yv4NGJ+5rwajESir6 /7UzqzhXmj6ylqTfbMRJCRsqnwvSfNwpsxtMSYieCxtdYqTLaJLAItBjuZPAYL8W 9Tf/NMc4AjLLHx7PyQJBAOyOcIS/i23td6ZX+QtppXL1fF/JMiKooE9m/npAT5K/ hQEaAatdLyQ669id181KY9F0JR1TEbzb0A1yo73soRsCQQDXJSG4ID8lfR9SXnEE y/RqYv0eKneER+V7e1Cy7bYHvJxZK0sWXYzIZhTl8PABh3PCoLdxjY0IM7UNWlwU dAuHAkAOUaTv9CQ9eDVY5VRW44M3TTLFHYmiXXCuvb5Dqibm7B7h7TASrmZPHB3w k8VfUNRv9kbU2pVlSCz0026j7XHnAkEAk/qZP8EGTe3K3mfRCsCSA57EhLwm6phd ElrWPcvc2WN0kqyBgAembqwwEZxwKE0XZTYQFw2KhKq0DFQrY3IR/wJAIAnLtabL aF819WI/VYlMmwb3GAO2w5KQilGhYl7tv1BghH+Qmg7HZEcIRmSwPKEQveT3YpCH nCu38jgPXhhqdg== -----END PRIVATE KEY----- -----BEGIN CERTIFICATE----- MIIC3DCCAkWgAwIBAgIJAKwksc/otf2iMA0GCSqGSIb3DQEBCwUAMIGGMQswCQYD VQQGEwJVUzERMA8GA1UECAwITmV3IFlvcmsxFjAUBgNVBAcMDU5ldyBZb3JrIENp dHkxHTAbBgNVBAoMFE1vbmdvREIgS2VybmVsIFRvb2xzMRkwFwYDVQQLDBBUb29s cyBUZXN0aW5nIENBMRIwEAYDVQQDDAlsb2NhbGhvc3QwHhcNMTUwNjA1MTU1MTQ1 WhcNMzUwNjA0MTU1MTQ1WjCBhjELMAkGA1UEBhMCVVMxETAPBgNVBAgMCE5ldyBZ b3JrMRYwFAYDVQQHDA1OZXcgWW9yayBDaXR5MR0wGwYDVQQKDBRNb25nb0RCIEtl cm5lbCBUb29sczEZMBcGA1UECwwQVG9vbHMgVGVzdGluZyBDQTESMBAGA1UEAwwJ bG9jYWxob3N0MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDGzfA+QLvsVnWP rBqVLkhUmxxs2Hx5sNMmowPSfD4sA3j0TJe9TjDLAcjbMpI81xK9AQTp+DzTuilu yh3Q4nEWr7gv4hbnFaSC1IiaCzlAjym/xMgB1JNK9n3a92KXdmV5A9RF5jPVk0J8 ljxFqq9U+zJjPT4bA9K/GW0FbvEePQIDAQABo1AwTjAdBgNVHQ4EFgQU+QOiCHTF 8At8aMOBvHF6wWZpcZUwHwYDVR0jBBgwFoAU+QOiCHTF8At8aMOBvHF6wWZpcZUw DAYDVR0TBAUwAwEB/zANBgkqhkiG9w0BAQsFAAOBgQCbbIAjdV+M8RR3ZF1WMBYD 8aMr55kgtnCWn4mTCDdombCYgtbaPq5sy8Hb/2wLQ9Zl4UuFL5wKWcx3kOLo3cw/ boj8jnUDnwrsBd2nN7sYdjF+M7FLp6U1AxrE5ejijtg2KCl+p4b7jJgJBSFIQD45 7CAJVjIrajY4LlJj3x+caQ== -----END CERTIFICATE----- mongo-tools-r3.6.3/common/db/openssl/testdata/server.pem000066400000000000000000000034341321131462300233440ustar00rootroot00000000000000-----BEGIN PRIVATE KEY----- MIICeAIBADANBgkqhkiG9w0BAQEFAASCAmIwggJeAgEAAoGBALOkdwU9Qx4FRn+z coBkeYYpVRg0pknPMDo4Q50TqZPfVhroTynx2Or+cjl5csd5hMKxWQpdzGq8JzH9 2BCLcDz/51vG3tPrpLIB50ABqa0wRGGDOO+XN0h+VkdqJvKReWOsNRoMT3s0Lh78 BqvRUomYXnbc1RBaxwWa+UoLCFgnAgMBAAECgYBd9XmjLeW6//tds5gB+4tsVpYB cRhAprOM3/zNXYlmpHu+2x78y1gvoSJRWWplVvPPeT8fIuxWL0844JJwJN5wyCwN nnrA28l6+Tcde+NlzCxwED+QDjAH20BRxCs0BLvnx3WAXRDmUbWAjOl/qPn9H6m1 nmUQ7H/f6dxZ0vVMQQJBAOl3xeVLyZZ828P/p3PvYkaeIxxVK1QDGOWi/3vC0DrY WK8xAoopjj0RHHZ1fL5bG31G3OR9Vc/rfk4a5XPIlRECQQDE+teCTiwV5Wwzdpg3 r440qOLCmpMXwJr/Jlh+C4c8ebnIQ9P5sSe4wQNHyeEZ2t7SGvPfjr7glpPhAkXy JTm3AkEAvNPgvVoUy6Bk5xuJRl2hMNiKMUo5ZxOyOVkiJeklHdMJt3h+Q1zk7ENA sBbKM/PgQezkj/FHTIl9eJKMbp8W4QJBAL4aXHyslw12wisUrKkpa7PUviwT5BvL TYsrZcIXvCeYTr1BAMX8vBopZNIWuoEqY1sgmfZKnFrB1+wTNpAQbxcCQQCHbtvQ 1U2p5Pz5XYyaoK2OEZhPMuLnOBMpzjSxRLxKyhb4k+ssIA0IeAiT4RIECtHJ8DJX 4aZK/qg9WmBH+zbO -----END PRIVATE KEY----- -----BEGIN CERTIFICATE----- MIICbzCCAdgCAQEwDQYJKoZIhvcNAQEFBQAwgYYxCzAJBgNVBAYTAlVTMREwDwYD VQQIDAhOZXcgWW9yazEWMBQGA1UEBwwNTmV3IFlvcmsgQ2l0eTEdMBsGA1UECgwU TW9uZ29EQiBLZXJuZWwgVG9vbHMxGTAXBgNVBAsMEFRvb2xzIFRlc3RpbmcgQ0Ex EjAQBgNVBAMMCWxvY2FsaG9zdDAeFw0xNTA2MDUxNTUxNDVaFw0zNTA2MDQxNTUx NDVaMHkxCzAJBgNVBAYTAlVTMREwDwYDVQQIDAhOZXcgWW9yazEWMBQGA1UEBwwN TmV3IFlvcmsgQ2l0eTEUMBIGA1UECgwLTW9uZ29EQiBJbmMxFTATBgNVBAsMDEtl cm5lbCBUb29sczESMBAGA1UEAwwJbG9jYWxob3N0MIGfMA0GCSqGSIb3DQEBAQUA A4GNADCBiQKBgQCzpHcFPUMeBUZ/s3KAZHmGKVUYNKZJzzA6OEOdE6mT31Ya6E8p 8djq/nI5eXLHeYTCsVkKXcxqvCcx/dgQi3A8/+dbxt7T66SyAedAAamtMERhgzjv lzdIflZHaibykXljrDUaDE97NC4e/Aar0VKJmF523NUQWscFmvlKCwhYJwIDAQAB MA0GCSqGSIb3DQEBBQUAA4GBACJiTnC3nksZsmMyD88+DuV8IA1DHSby4X/qtDYT eSuNbxRKnihXkm2KE+MGn7YeKg4a7FaYiH3ejk0ZBlY3TZXK3I1uh/zIhC9aMnSL z0z4OLcqp46F8PpYF7ARtXXWQuOEWe6k+VKy5XP1NX60sEJ0KwGBQjUw3Ys41JE8 iigw -----END CERTIFICATE----- mongo-tools-r3.6.3/common/db/read_preferences.go000066400000000000000000000025751321131462300216670ustar00rootroot00000000000000// Copyright (C) MongoDB, Inc. 2014-present. // // 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 package db import ( "fmt" "github.com/mongodb/mongo-tools/common/json" "gopkg.in/mgo.v2" "gopkg.in/mgo.v2/bson" ) type readPrefDoc struct { Mode string Tags bson.D } const ( WarningNonPrimaryMongosConnection = "Warning: using a non-primary readPreference with a " + "connection to mongos may produce inconsistent duplicates or miss some documents." ) func ParseReadPreference(rp string) (mgo.Mode, bson.D, error) { var mode string var tags bson.D if rp == "" { return mgo.Nearest, nil, nil } if rp[0] != '{' { mode = rp } else { var doc readPrefDoc err := json.Unmarshal([]byte(rp), &doc) if err != nil { return 0, nil, fmt.Errorf("invalid --ReadPreferences json object: %v", err) } tags = doc.Tags mode = doc.Mode } switch mode { case "primary": return mgo.Primary, tags, nil case "primaryPreferred": return mgo.PrimaryPreferred, tags, nil case "secondary": return mgo.Secondary, tags, nil case "secondaryPreferred": return mgo.SecondaryPreferred, tags, nil case "nearest": return mgo.Nearest, tags, nil } return 0, nil, fmt.Errorf("invalid readPreference mode '%v'", mode) } mongo-tools-r3.6.3/common/db/testdata/000077500000000000000000000000001321131462300176445ustar00rootroot00000000000000mongo-tools-r3.6.3/common/db/testdata/testdata.bson000066400000000000000000000034101321131462300223360ustar00rootroot00000000000000_id_idð?_id@_id@_id@_id@_id@_id@_id @_id"@_id$@_id&@_id(@_id*@_id,@_id.@_id0@_id1@_id2@_id3@_id4@_id5@_id6@_id7@_id8@_id9@_id:@_id;@_id<@_id=@_id>@_id?@_id@@_id€@@_idA@_id€A@_idB@_id€B@_idC@_id€C@_idD@_id€D@_idE@_id€E@_idF@_id€F@_idG@_id€G@_idH@_id€H@_idI@_id€I@_idJ@_id€J@_idK@_id€K@_idL@_id€L@_idM@_id€M@_idN@_id€N@_idO@_id€O@_idP@_id@P@_id€P@_idÀP@_idQ@_id@Q@_id€Q@_idÀQ@_idR@_id@R@_id€R@_idÀR@_idS@_id@S@_id€S@_idÀS@_idT@_id@T@_id€T@_idÀT@_idU@_id@U@_id€U@_idÀU@_idV@_id@V@_id€V@_idÀV@_idW@_id@W@_id€W@_idÀW@_idX@_id@X@_id€X@_idÀX@mongo-tools-r3.6.3/common/db/write_concern.go000066400000000000000000000122531321131462300212260ustar00rootroot00000000000000// Copyright (C) MongoDB, Inc. 2014-present. // // 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 package db import ( "github.com/mongodb/mongo-tools/common/connstring" "github.com/mongodb/mongo-tools/common/json" "github.com/mongodb/mongo-tools/common/log" "github.com/mongodb/mongo-tools/common/util" "gopkg.in/mgo.v2" "fmt" "strconv" "time" ) // write concern fields const ( j = "j" w = "w" fSync = "fsync" wTimeout = "wtimeout" ) // constructWCObject takes in a write concern and attempts to construct an // mgo.Safe object from it. It returns an error if it is unable to parse the // string or if a parsed write concern field value is invalid. func constructWCObject(writeConcern string) (sessionSafety *mgo.Safe, err error) { sessionSafety = &mgo.Safe{} defer func() { // If the user passes a w value of 0, we set the session to use the // unacknowledged write concern but only if journal commit acknowledgment, // is not required. If commit acknowledgment is required, it prevails, // and the server will require that mongod acknowledge the write operation if sessionSafety.WMode == "" && sessionSafety.W == 0 && !sessionSafety.J { sessionSafety = nil } }() jsonWriteConcern := map[string]interface{}{} if err = json.Unmarshal([]byte(writeConcern), &jsonWriteConcern); err != nil { // if the writeConcern string can not be unmarshaled into JSON, this // allows a default to the old behavior wherein the entire argument // passed in is assigned to the 'w' field - thus allowing users pass // a write concern that looks like: "majority", 0, "4", etc. wValue, err := strconv.Atoi(writeConcern) if err != nil { sessionSafety.WMode = writeConcern } else { sessionSafety.W = wValue if wValue < 0 { return sessionSafety, fmt.Errorf("invalid '%v' argument: %v", w, wValue) } } return sessionSafety, nil } if jVal, ok := jsonWriteConcern[j]; ok && util.IsTruthy(jVal) { sessionSafety.J = true } if fsyncVal, ok := jsonWriteConcern[fSync]; ok && util.IsTruthy(fsyncVal) { sessionSafety.FSync = true } if wtimeout, ok := jsonWriteConcern[wTimeout]; ok { wtimeoutValue, err := util.ToInt(wtimeout) if err != nil { return sessionSafety, fmt.Errorf("invalid '%v' argument: %v", wTimeout, wtimeout) } sessionSafety.WTimeout = wtimeoutValue } if wInterface, ok := jsonWriteConcern[w]; ok { wValue, err := util.ToInt(wInterface) if err != nil { // if the argument is neither a string nor int, error out wStrVal, ok := wInterface.(string) if !ok { return sessionSafety, fmt.Errorf("invalid '%v' argument: %v", w, wInterface) } sessionSafety.WMode = wStrVal } else { sessionSafety.W = wValue if wValue < 0 { return sessionSafety, fmt.Errorf("invalid '%v' argument: %v", w, wValue) } } } return sessionSafety, nil } // constructSafetyFromConnString takes in a parsed connection string and attempts // to construct an mgo.Safe object from it. It returns an error if it is unable // to parse the write concern value. func constructSafetyFromConnString(cs *connstring.ConnString) (*mgo.Safe, error) { safe := &mgo.Safe{} wValue, err := strconv.Atoi(cs.W) if err != nil { safe.WMode = cs.W } else { safe.W = wValue if wValue < 0 { return nil, fmt.Errorf("invalid '%v' argument: %v", w, wValue) } } safe.WTimeout = int(cs.WTimeout / time.Second) safe.FSync = cs.FSync safe.J = cs.Journal if safe.WMode == "" && safe.W == 0 && !safe.J { return nil, nil } return safe, nil } // BuildWriteConcern takes a string and a NodeType indicating the type of node the write concern // is intended to be used against, and converts the write concern string argument into an // mgo.Safe object that's usable on sessions for that node type. func BuildWriteConcern(writeConcern string, nodeType NodeType, cs *connstring.ConnString) (*mgo.Safe, error) { var sessionSafety *mgo.Safe var err error if cs != nil && writeConcern != "" { return nil, fmt.Errorf("cannot specify writeConcern string and connectionString object") } if cs != nil { if cs.W == "" { cs.W = "majority" } sessionSafety, err = constructSafetyFromConnString(cs) if err != nil { return nil, err } } else { if writeConcern == "" { writeConcern = "majority" } sessionSafety, err = constructWCObject(writeConcern) if err != nil { return nil, err } } if sessionSafety == nil { log.Logvf(log.DebugLow, "using unacknowledged write concern") return nil, nil } // for standalone mongods, set the default write concern to 1 if nodeType == Standalone { log.Logvf(log.DebugLow, "standalone server: setting write concern %v to 1", w) sessionSafety.W = 1 sessionSafety.WMode = "" } var writeConcernStr interface{} if sessionSafety.WMode != "" { writeConcernStr = sessionSafety.WMode } else { writeConcernStr = sessionSafety.W } log.Logvf(log.Info, "using write concern: %v='%v', %v=%v, %v=%v, %v=%v", w, writeConcernStr, j, sessionSafety.J, fSync, sessionSafety.FSync, wTimeout, sessionSafety.WTimeout, ) return sessionSafety, nil } mongo-tools-r3.6.3/common/db/write_concern_test.go000066400000000000000000000236271321131462300222740ustar00rootroot00000000000000// Copyright (C) MongoDB, Inc. 2014-present. // // 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 package db import ( "github.com/mongodb/mongo-tools/common/connstring" . "github.com/smartystreets/goconvey/convey" "fmt" "testing" "time" ) func TestBuildWriteConcern(t *testing.T) { Convey("When building write concern object", t, func() { Convey("and given a write concern string value, and a boolean indicating if the "+ "write concern is to be used on a replica set, on calling BuildWriteConcern...", func() { Convey("no error should be returned if the write concern is valid", func() { writeConcern, err := BuildWriteConcern(`{w:34}`, ReplSet, nil) So(err, ShouldBeNil) So(writeConcern.W, ShouldEqual, 34) writeConcern, err = BuildWriteConcern(`{w:"majority"}`, ReplSet, nil) So(err, ShouldBeNil) So(writeConcern.WMode, ShouldEqual, "majority") writeConcern, err = BuildWriteConcern(`majority`, ReplSet, nil) So(err, ShouldBeNil) So(writeConcern.WMode, ShouldEqual, "majority") writeConcern, err = BuildWriteConcern(`tagset`, ReplSet, nil) So(err, ShouldBeNil) So(writeConcern.WMode, ShouldEqual, "tagset") }) Convey("on replica sets, only a write concern of 1 or 0 should be returned", func() { writeConcern, err := BuildWriteConcern(`{w:34}`, Standalone, nil) So(err, ShouldBeNil) So(writeConcern.W, ShouldEqual, 1) writeConcern, err = BuildWriteConcern(`{w:"majority"}`, Standalone, nil) So(err, ShouldBeNil) So(writeConcern.W, ShouldEqual, 1) writeConcern, err = BuildWriteConcern(`tagset`, Standalone, nil) So(err, ShouldBeNil) So(writeConcern.W, ShouldEqual, 1) }) Convey("with a w value of 0, without j set, a nil write concern should be returned", func() { writeConcern, err := BuildWriteConcern(`{w:0}`, Standalone, nil) So(err, ShouldBeNil) So(writeConcern, ShouldBeNil) }) Convey("with a negative w value, an error should be returned", func() { _, err := BuildWriteConcern(`{w:-1}`, ReplSet, nil) So(err, ShouldNotBeNil) _, err = BuildWriteConcern(`{w:-2}`, ReplSet, nil) So(err, ShouldNotBeNil) }) Convey("with a w value of 0, with j set, a non-nil write concern should be returned", func() { writeConcern, err := BuildWriteConcern(`{w:0, j:true}`, Standalone, nil) So(err, ShouldBeNil) So(writeConcern.J, ShouldBeTrue) }) // Regression test for TOOLS-1741 Convey("When passing an empty writeConcern and empty URI"+ "then write concern should default to being majority", func() { writeConcern, err := BuildWriteConcern("", ReplSet, nil) So(err, ShouldBeNil) So(writeConcern.WMode, ShouldEqual, "majority") }) }) Convey("and given a connection string", func() { Convey("with a w value of 0, without j set, a nil write concern should be returned", func() { writeConcern, err := BuildWriteConcern(``, Standalone, &connstring.ConnString{W: "0"}) So(err, ShouldBeNil) So(writeConcern, ShouldBeNil) }) Convey("with a negative w value, an error should be returned", func() { _, err := BuildWriteConcern(``, ReplSet, &connstring.ConnString{W: "-1"}) So(err, ShouldNotBeNil) _, err = BuildWriteConcern(``, ReplSet, &connstring.ConnString{W: "-2"}) So(err, ShouldNotBeNil) }) Convey("on replica sets, only a write concern of 1 or 0 should be returned", func() { writeConcern, err := BuildWriteConcern(``, Standalone, &connstring.ConnString{W: "34"}) So(err, ShouldBeNil) So(writeConcern.W, ShouldEqual, 1) writeConcern, err = BuildWriteConcern(``, Standalone, &connstring.ConnString{W: "majority"}) So(err, ShouldBeNil) So(writeConcern.W, ShouldEqual, 1) writeConcern, err = BuildWriteConcern(``, Standalone, &connstring.ConnString{W: "tagset"}) So(err, ShouldBeNil) So(writeConcern.W, ShouldEqual, 1) }) }) Convey("and given both, should error", func() { _, err := BuildWriteConcern(`ab`, ReplSet, &connstring.ConnString{W: "-1"}) So(err, ShouldNotBeNil) }) }) } func TestConstructWCObject(t *testing.T) { Convey("Given a write concern string value, on calling constructWCObject...", t, func() { Convey("non-JSON string values should be assigned to the 'WMode' "+ "field in their entirety", func() { writeConcernString := "majority" writeConcern, err := constructWCObject(writeConcernString) So(err, ShouldBeNil) So(writeConcern.WMode, ShouldEqual, writeConcernString) }) Convey("non-JSON int values should be assigned to the 'w' field "+ "in their entirety", func() { writeConcernString := `{w: 4}` writeConcern, err := constructWCObject(writeConcernString) So(err, ShouldBeNil) So(writeConcern.W, ShouldEqual, 4) }) Convey("JSON strings with valid j, wtimeout, fsync and w, should be "+ "assigned accordingly", func() { writeConcernString := `{w: 3, j: true, fsync: false, wtimeout: 43}` expectedW := 3 expectedWTimeout := 43 writeConcern, err := constructWCObject(writeConcernString) So(err, ShouldBeNil) So(writeConcern.W, ShouldEqual, expectedW) So(writeConcern.J, ShouldBeTrue) So(writeConcern.FSync, ShouldBeFalse) So(writeConcern.WTimeout, ShouldEqual, expectedWTimeout) }) Convey("JSON strings with an argument for j that is not false should set j true", func() { writeConcernString := `{w: 3, j: "rue"}` writeConcern, err := constructWCObject(writeConcernString) So(err, ShouldBeNil) So(writeConcern.W, ShouldEqual, 3) So(writeConcern.J, ShouldBeTrue) }) Convey("JSON strings with an argument for fsync that is not false should set fsync true", func() { writeConcernString := `{w: 3, fsync: "rue"}` writeConcern, err := constructWCObject(writeConcernString) So(err, ShouldBeNil) So(writeConcern.W, ShouldEqual, 3) So(writeConcern.FSync, ShouldBeTrue) }) Convey("JSON strings with an invalid wtimeout argument should error out", func() { writeConcernString := `{w: 3, wtimeout: "rue"}` _, err := constructWCObject(writeConcernString) So(err, ShouldNotBeNil) writeConcernString = `{w: 3, wtimeout: "43"}` _, err = constructWCObject(writeConcernString) So(err, ShouldNotBeNil) }) Convey("JSON strings with any non-false j argument should not error out", func() { writeConcernString := `{w: 3, j: "t"}` writeConcern, err := constructWCObject(writeConcernString) So(err, ShouldBeNil) So(writeConcern.J, ShouldBeTrue) writeConcernString = `{w: 3, j: "f"}` writeConcern, err = constructWCObject(writeConcernString) So(err, ShouldBeNil) So(writeConcern.J, ShouldBeTrue) writeConcernString = `{w: 3, j: false}` writeConcern, err = constructWCObject(writeConcernString) So(err, ShouldBeNil) So(writeConcern.J, ShouldBeFalse) writeConcernString = `{w: 3, j: 0}` writeConcern, err = constructWCObject(writeConcernString) So(err, ShouldBeNil) So(writeConcern.J, ShouldBeFalse) }) Convey("JSON strings with a shorthand fsync argument should not error out", func() { writeConcernString := `{w: 3, fsync: "t"}` writeConcern, err := constructWCObject(writeConcernString) So(err, ShouldBeNil) So(writeConcern.FSync, ShouldBeTrue) writeConcernString = `{w: "3", fsync: "f"}` writeConcern, err = constructWCObject(writeConcernString) So(err, ShouldBeNil) So(writeConcern.FSync, ShouldBeTrue) writeConcernString = `{w: "3", fsync: false}` writeConcern, err = constructWCObject(writeConcernString) So(err, ShouldBeNil) So(writeConcern.FSync, ShouldBeFalse) writeConcernString = `{w: "3", fsync: 0}` writeConcern, err = constructWCObject(writeConcernString) So(err, ShouldBeNil) So(writeConcern.FSync, ShouldBeFalse) }) Convey("Unacknowledge write concern strings should return a nil object "+ "if journaling is not required", func() { writeConcernString := `{w: 0}` writeConcern, err := constructWCObject(writeConcernString) So(err, ShouldBeNil) So(writeConcern, ShouldBeNil) writeConcernString = `{w: 0}` writeConcern, err = constructWCObject(writeConcernString) So(err, ShouldBeNil) So(writeConcern, ShouldBeNil) writeConcernString = `0` writeConcern, err = constructWCObject(writeConcernString) So(err, ShouldBeNil) So(writeConcern, ShouldBeNil) }) }) } func TestConstructSafetyFromConnString(t *testing.T) { Convey("Given a parsed &connstring, on calling constructSafetyFromConnString...", t, func() { Convey("non string values should be assigned to the 'WMode' "+ "field in their entirety", func() { writeConcernString := "majority" cs := &connstring.ConnString{ W: writeConcernString, } writeConcern, err := constructSafetyFromConnString(cs) So(err, ShouldBeNil) So(writeConcern.WMode, ShouldEqual, writeConcernString) }) Convey("Int values should be assigned to the 'w' field ", func() { cs := &connstring.ConnString{ W: "4", } writeConcern, err := constructSafetyFromConnString(cs) So(err, ShouldBeNil) So(writeConcern.W, ShouldEqual, 4) }) Convey("&connstrings with valid j, wtimeout, fsync and w, should be "+ "assigned accordingly", func() { expectedW := 3 expectedWTimeout := 43 cs := &connstring.ConnString{ W: "3", Journal: true, FSync: false, WTimeout: time.Second * 43, } writeConcern, err := constructSafetyFromConnString(cs) So(err, ShouldBeNil) So(writeConcern.W, ShouldEqual, expectedW) So(writeConcern.J, ShouldBeTrue) So(writeConcern.FSync, ShouldBeFalse) So(writeConcern.WTimeout, ShouldEqual, expectedWTimeout) }) Convey("Unacknowledge write concern strings should return a nil object "+ "if journaling is not required", func() { cs := &connstring.ConnString{ W: "0", } writeConcern, err := constructSafetyFromConnString(cs) fmt.Println(writeConcern) So(err, ShouldBeNil) So(writeConcern, ShouldBeNil) }) }) } mongo-tools-r3.6.3/common/failpoint/000077500000000000000000000000001321131462300174335ustar00rootroot00000000000000mongo-tools-r3.6.3/common/failpoint/failpoint.go000066400000000000000000000021261321131462300217500ustar00rootroot00000000000000// Copyright (C) MongoDB, Inc. 2014-present. // // 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 // +build failpoints // Package failpoint implements triggers for custom debugging behavoir package failpoint import ( "strings" ) var values map[string]string func init() { values = make(map[string]string) } // ParseFailpoints registers a comma-separated list of failpoint=value pairs func ParseFailpoints(arg string) { args := strings.Split(arg, ",") for _, fp := range args { if sep := strings.Index(fp, "="); sep != -1 { key := fp[:sep] val := fp[sep+1:] values[key] = val continue } values[fp] = "" } } // Get returns the value of the given failpoint and true, if it exists, and // false otherwise func Get(fp string) (string, bool) { val, ok := values[fp] return val, ok } // Enabled returns true iff the given failpoint has been turned on func Enabled(fp string) bool { _, ok := Get(fp) return ok } mongo-tools-r3.6.3/common/failpoint/failpoint_disabled.go000066400000000000000000000007051321131462300236000ustar00rootroot00000000000000// Copyright (C) MongoDB, Inc. 2014-present. // // 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 // +build !failpoints package failpoint func ParseFailpoints(_ string) { } func Get(fp string) (string, bool) { return "", false } func Enabled(fp string) bool { return false } mongo-tools-r3.6.3/common/failpoint/failpoint_test.go000066400000000000000000000022231321131462300230050ustar00rootroot00000000000000// Copyright (C) MongoDB, Inc. 2014-present. // // 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 // +build failpoints package failpoint import ( "testing" "github.com/mongodb/mongo-tools/common/testutil" . "github.com/smartystreets/goconvey/convey" ) func TestFailpointParsing(t *testing.T) { testutil.VerifyTestType(t, testutil.UnitTestType) Convey("With test args", t, func() { args := "foo=bar,baz,biz=,=a" ParseFailpoints(args) So(Enabled("foo"), ShouldBeTrue) So(Enabled("baz"), ShouldBeTrue) So(Enabled("biz"), ShouldBeTrue) So(Enabled(""), ShouldBeTrue) So(Enabled("bar"), ShouldBeFalse) var val string var ok bool val, ok = Get("foo") So(val, ShouldEqual, "bar") So(ok, ShouldBeTrue) val, ok = Get("baz") So(val, ShouldEqual, "") So(ok, ShouldBeTrue) val, ok = Get("biz") So(val, ShouldEqual, "") So(ok, ShouldBeTrue) val, ok = Get("") So(val, ShouldEqual, "a") So(ok, ShouldBeTrue) val, ok = Get("bar") So(ok, ShouldBeFalse) }) } mongo-tools-r3.6.3/common/failpoint/failpoints.go000066400000000000000000000005631321131462300221360ustar00rootroot00000000000000// Copyright (C) MongoDB, Inc. 2014-present. // // 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 package failpoint // Supported failpoint names const ( PauseBeforeDumping = "PauseBeforeDumping" ) mongo-tools-r3.6.3/common/intents/000077500000000000000000000000001321131462300171325ustar00rootroot00000000000000mongo-tools-r3.6.3/common/intents/intent.go000066400000000000000000000347151321131462300207740ustar00rootroot00000000000000// Copyright (C) MongoDB, Inc. 2014-present. // // 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 // Package intents provides utilities for performing dump/restore operations. package intents import ( "fmt" "io" "github.com/mongodb/mongo-tools/common" "github.com/mongodb/mongo-tools/common/log" "github.com/mongodb/mongo-tools/common/util" "gopkg.in/mgo.v2/bson" ) type file interface { io.ReadWriteCloser Open() error Pos() int64 } // DestinationConflictError occurs when multiple namespaces map to the same // destination. type DestinationConflictError struct { Src, Dst string } func (e DestinationConflictError) Error() string { return fmt.Sprintf("destination conflict: %s (src) => %s (dst)", e.Src, e.Dst) } // FileNeedsIOBuffer is an interface that denotes that a struct needs // an IO buffer that is managed by an outside control. This interface // is used to both hand off a buffer to a struct and signal that it should // release its buffer. Added to reduce memory usage as outlined in TOOLS-1088. type FileNeedsIOBuffer interface { TakeIOBuffer([]byte) ReleaseIOBuffer() } // mongorestore first scans the directory to generate a list // of all files to restore and what they map to. TODO comments type Intent struct { // Destination namespace info DB string C string // File locations as absolute paths BSONFile file BSONSize int64 MetadataFile file // Indicates where the intent will be read from or written to Location string MetadataLocation string // Collection options Options *bson.D // UUID (for MongoDB 3.6+) as a big-endian hex string UUID string // File/collection size, for some prioritizer implementations. // Units don't matter as long as they are consistent for a given use case. Size int64 } func (it *Intent) Namespace() string { return it.DB + "." + it.C } func (it *Intent) IsOplog() bool { if it.DB == "" && it.C == "oplog" { return true } return it.DB == "local" && (it.C == "oplog.rs" || it.C == "oplog.$main") } func (it *Intent) IsUsers() bool { if it.C == "$admin.system.users" { return true } if it.DB == "admin" && it.C == "system.users" { return true } return false } func (it *Intent) IsRoles() bool { if it.C == "$admin.system.roles" { return true } if it.DB == "admin" && it.C == "system.roles" { return true } return false } func (it *Intent) IsAuthVersion() bool { if it.C == "$admin.system.version" { return true } if it.DB == "admin" && it.C == "system.version" { return true } return false } func (it *Intent) IsSystemIndexes() bool { return it.C == "system.indexes" } func (intent *Intent) IsSpecialCollection() bool { return intent.IsSystemIndexes() || intent.IsUsers() || intent.IsRoles() || intent.IsAuthVersion() } func (it *Intent) IsView() bool { if it.Options == nil { return false } _, isView := it.Options.Map()["viewOn"] return isView } func (existing *Intent) MergeIntent(intent *Intent) { // merge new intent into old intent if existing.BSONFile == nil { existing.BSONFile = intent.BSONFile } if existing.Size == 0 { existing.Size = intent.Size } if existing.Location == "" { existing.Location = intent.Location } if existing.MetadataFile == nil { existing.MetadataFile = intent.MetadataFile } if existing.MetadataLocation == "" { existing.MetadataLocation = intent.MetadataLocation } } type Manager struct { // intents are for all of the regular user created collections intents map[string]*Intent // special intents are for all of the collections that are created by mongod // and require special handling specialIntents map[string]*Intent // legacy mongorestore works in the order that paths are discovered, // so we need an ordered data structure to preserve this behavior. intentsByDiscoveryOrder []*Intent // we need different scheduling order depending on the target // mongod/mongos and whether or not we are multi threading; // the IntentPrioritizer interface encapsulates this. prioritizer IntentPrioritizer // special cases that should be saved but not be part of the queue. // used to deal with oplog and user/roles restoration, which are // handled outside of the basic logic of the tool oplogIntent *Intent usersIntent *Intent rolesIntent *Intent versionIntent *Intent indexIntents map[string]*Intent // Tells the manager if it should choose a single oplog when multiple are provided. smartPickOplog bool // Indicates if an the manager has seen two conflicting oplogs. oplogConflict bool // prevent conflicting destinations by checking which sources map to the // same namespace destinations map[string][]string } func NewIntentManager() *Manager { return &Manager{ intents: map[string]*Intent{}, specialIntents: map[string]*Intent{}, intentsByDiscoveryOrder: []*Intent{}, indexIntents: map[string]*Intent{}, smartPickOplog: false, oplogConflict: false, destinations: map[string][]string{}, } } func (mgr *Manager) SetSmartPickOplog(smartPick bool) { mgr.smartPickOplog = smartPick } // HasConfigDBIntent returns a bool indicating if any of the intents refer to the "config" database. // This can be used to check for possible unwanted conflicts before restoring to a sharded system. func (mgr *Manager) HasConfigDBIntent() bool { for _, intent := range mgr.intentsByDiscoveryOrder { if intent.DB == "config" { return true } } return false } // PutOplogIntent takes an intent for an oplog and stores it in the intent manager with the // provided key. If the manager has smartPickOplog enabled, then it uses a priority system // to determine which oplog intent to maintain as the actual oplog. func (manager *Manager) PutOplogIntent(intent *Intent, managerKey string) { if manager.smartPickOplog { if existing := manager.specialIntents[managerKey]; existing != nil { existing.MergeIntent(intent) return } if manager.oplogIntent == nil { // If there is no oplog intent, make this one the oplog. manager.oplogIntent = intent manager.specialIntents[managerKey] = intent } else if intent.DB == "" { // We already have an oplog and this is a top priority oplog. if manager.oplogIntent.DB == "" { // If the manager's current oplog is also top priority, we have a // conflict and ignore this oplog. manager.oplogConflict = true } else { // If the manager's current oplog is lower priority, replace it and // move that one to be a normal intent. manager.putNormalIntent(manager.oplogIntent) delete(manager.specialIntents, manager.oplogIntent.Namespace()) manager.oplogIntent = intent manager.specialIntents[managerKey] = intent } } else { // We already have an oplog and this is a low priority oplog. if manager.oplogIntent.DB != "" { // If the manager's current oplog is also low priority, set a conflict. manager.oplogConflict = true } // No matter what, set this lower priority oplog to be a normal intent. manager.putNormalIntent(intent) } } else { if intent.DB == "" && intent.C == "oplog" { // If this is a normal oplog, then add it as an oplog intent. if existing := manager.specialIntents[managerKey]; existing != nil { existing.MergeIntent(intent) return } manager.oplogIntent = intent manager.specialIntents[managerKey] = intent } else { manager.putNormalIntent(intent) } } } func (manager *Manager) putNormalIntent(intent *Intent) { manager.putNormalIntentWithNamespace(intent.Namespace(), intent) } func (manager *Manager) putNormalIntentWithNamespace(ns string, intent *Intent) { // BSON and metadata files for the same collection are merged // into the same intent. This is done to allow for simple // pairing of BSON + metadata without keeping track of the // state of the filepath walker if existing := manager.intents[ns]; existing != nil { if existing.Namespace() != intent.Namespace() { // remove old destination, add new one dst := existing.Namespace() dsts := manager.destinations[dst] i := util.StringSliceIndex(dsts, ns) manager.destinations[dst] = append(dsts[:i], dsts[i+1:]...) dsts = manager.destinations[intent.Namespace()] manager.destinations[intent.Namespace()] = append(dsts, ns) } existing.MergeIntent(intent) return } // if key doesn't already exist, add it to the manager manager.intents[ns] = intent manager.intentsByDiscoveryOrder = append(manager.intentsByDiscoveryOrder, intent) manager.destinations[intent.Namespace()] = append(manager.destinations[intent.Namespace()], ns) } // Put inserts an intent into the manager with the same source namespace as // its destinations. func (manager *Manager) Put(intent *Intent) { log.Logvf(log.DebugLow, "enqueued collection '%v'", intent.Namespace()) manager.PutWithNamespace(intent.Namespace(), intent) } // PutWithNamespace inserts an intent into the manager with the source set // to the provided namespace. Intents for the same collection are merged // together, so that BSON and metadata files for the same collection are // returned in the same intent. func (manager *Manager) PutWithNamespace(ns string, intent *Intent) { if intent == nil { panic("cannot insert nil *Intent into IntentManager") } db, _ := common.SplitNamespace(ns) // bucket special-case collections if intent.IsOplog() { manager.PutOplogIntent(intent, intent.Namespace()) return } if intent.IsSystemIndexes() { if intent.BSONFile != nil { manager.indexIntents[db] = intent manager.specialIntents[ns] = intent } return } if intent.IsUsers() { if intent.BSONFile != nil { manager.usersIntent = intent manager.specialIntents[ns] = intent } return } if intent.IsRoles() { if intent.BSONFile != nil { manager.rolesIntent = intent manager.specialIntents[ns] = intent } return } if intent.IsAuthVersion() { if intent.BSONFile != nil { manager.versionIntent = intent manager.specialIntents[ns] = intent } return } manager.putNormalIntentWithNamespace(ns, intent) } func (manager *Manager) GetOplogConflict() bool { return manager.oplogConflict } func (manager *Manager) GetDestinationConflicts() (errs []DestinationConflictError) { for dst, srcs := range manager.destinations { if len(srcs) <= 1 { continue } for _, src := range srcs { errs = append(errs, DestinationConflictError{Dst: dst, Src: src}) } } return } // Intents returns a slice containing all of the intents in the manager. // Intents is not thread safe func (manager *Manager) Intents() []*Intent { allIntents := []*Intent{} for _, intent := range manager.intents { allIntents = append(allIntents, intent) } for _, intent := range manager.indexIntents { allIntents = append(allIntents, intent) } if manager.oplogIntent != nil { allIntents = append(allIntents, manager.oplogIntent) } if manager.usersIntent != nil { allIntents = append(allIntents, manager.usersIntent) } if manager.rolesIntent != nil { allIntents = append(allIntents, manager.rolesIntent) } if manager.versionIntent != nil { allIntents = append(allIntents, manager.versionIntent) } return allIntents } func (manager *Manager) IntentForNamespace(ns string) *Intent { intent := manager.intents[ns] if intent != nil { return intent } intent = manager.specialIntents[ns] return intent } // Pop returns the next available intent from the manager. If the manager is // empty, it returns nil. Pop is thread safe. func (manager *Manager) Pop() *Intent { return manager.prioritizer.Get() } // Peek returns a copy of a stored intent from the manager without removing // the intent. This method is useful for edge cases that need to look ahead // at what collections are in the manager before they are scheduled. // // NOTE: There are no guarantees that peek will return a usable // intent after Finalize() is called. func (manager *Manager) Peek() *Intent { if len(manager.intentsByDiscoveryOrder) == 0 { return nil } intentCopy := *manager.intentsByDiscoveryOrder[0] return &intentCopy } // Finish tells the prioritizer that mongorestore is done restoring // the given collection intent. func (manager *Manager) Finish(intent *Intent) { manager.prioritizer.Finish(intent) } // Oplog returns the intent representing the oplog, which isn't // stored with the other intents, because it is dumped and restored in // a very different way from other collections. func (manager *Manager) Oplog() *Intent { return manager.oplogIntent } // SystemIndexes returns the system.indexes bson for a database func (manager *Manager) SystemIndexes(dbName string) *Intent { return manager.indexIntents[dbName] } // SystemIndexes returns the databases for which there are system.indexes func (manager *Manager) SystemIndexDBs() []string { databases := []string{} for dbname := range manager.indexIntents { databases = append(databases, dbname) } return databases } // Users returns the intent of the users collection to restore, a special case func (manager *Manager) Users() *Intent { return manager.usersIntent } // Roles returns the intent of the user roles collection to restore, a special case func (manager *Manager) Roles() *Intent { return manager.rolesIntent } // AuthVersion returns the intent of the version collection to restore, a special case func (manager *Manager) AuthVersion() *Intent { return manager.versionIntent } // Finalize processes the intents for prioritization. Currently only two // kinds of prioritizers are supported. No more "Put" operations may be done // after finalize is called. func (manager *Manager) Finalize(pType PriorityType) { switch pType { case Legacy: log.Logv(log.DebugHigh, "finalizing intent manager with legacy prioritizer") manager.prioritizer = NewLegacyPrioritizer(manager.intentsByDiscoveryOrder) case LongestTaskFirst: log.Logv(log.DebugHigh, "finalizing intent manager with longest task first prioritizer") manager.prioritizer = NewLongestTaskFirstPrioritizer(manager.intentsByDiscoveryOrder) case MultiDatabaseLTF: log.Logv(log.DebugHigh, "finalizing intent manager with multi-database longest task first prioritizer") manager.prioritizer = NewMultiDatabaseLTFPrioritizer(manager.intentsByDiscoveryOrder) default: panic("cannot initialize IntentPrioritizer with unknown type") } // release these for the garbage collector and to ensure code correctness manager.intents = nil manager.intentsByDiscoveryOrder = nil } func (manager *Manager) UsePrioritizer(prioritizer IntentPrioritizer) { manager.prioritizer = prioritizer } mongo-tools-r3.6.3/common/intents/intent_prioritizer.go000066400000000000000000000176501321131462300234350ustar00rootroot00000000000000// Copyright (C) MongoDB, Inc. 2014-present. // // 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 package intents import ( "container/heap" "sort" "sync" ) type PriorityType int const ( Legacy PriorityType = iota LongestTaskFirst MultiDatabaseLTF ) // IntentPrioritizer encapsulates the logic of scheduling intents // for restoration. It can know about which intents are in the // process of being restored through the "Finish" hook. // // Oplog entries and auth entries are not handled by the prioritizer, // as these are special cases handled by the regular mongorestore code. type IntentPrioritizer interface { Get() *Intent Finish(*Intent) } //===== Legacy ===== // legacyPrioritizer processes the intents in the order they were read off the // file system, keeping with legacy mongorestore behavior. type legacyPrioritizer struct { sync.Mutex queue []*Intent } func NewLegacyPrioritizer(intentList []*Intent) *legacyPrioritizer { return &legacyPrioritizer{queue: intentList} } func (legacy *legacyPrioritizer) Get() *Intent { legacy.Lock() defer legacy.Unlock() if len(legacy.queue) == 0 { return nil } var intent *Intent intent, legacy.queue = legacy.queue[0], legacy.queue[1:] return intent } func (legacy *legacyPrioritizer) Finish(*Intent) { // no-op return } //===== Longest Task First ===== // longestTaskFirstPrioritizer returns intents in the order of largest -> smallest, // with views at the front of the list, which is better at minimizing total // runtime in parallel environments than other simple orderings. type longestTaskFirstPrioritizer struct { sync.Mutex queue []*Intent } // NewLongestTaskFirstPrioritizer returns an initialized LTP prioritizer func NewLongestTaskFirstPrioritizer(intents []*Intent) *longestTaskFirstPrioritizer { sort.Sort(BySizeAndView(intents)) return &longestTaskFirstPrioritizer{ queue: intents, } } func (ltf *longestTaskFirstPrioritizer) Get() *Intent { ltf.Lock() defer ltf.Unlock() if len(ltf.queue) == 0 { return nil } var intent *Intent intent, ltf.queue = ltf.queue[0], ltf.queue[1:] return intent } func (ltf *longestTaskFirstPrioritizer) Finish(*Intent) { // no-op return } // BySizeAndView attaches the methods for sort.Interface for sorting intents // from largest to smallest size, taking into account if it's a view or not. type BySizeAndView []*Intent func (s BySizeAndView) Len() int { return len(s) } func (s BySizeAndView) Swap(i, j int) { s[i], s[j] = s[j], s[i] } func (s BySizeAndView) Less(i, j int) bool { if s[i].IsView() && !s[j].IsView() { return true } if !s[i].IsView() && s[j].IsView() { return false } return s[i].Size > s[j].Size } // For sorting intents from largest to smallest size type BySize []*Intent func (s BySize) Len() int { return len(s) } func (s BySize) Swap(i, j int) { s[i], s[j] = s[j], s[i] } func (s BySize) Less(i, j int) bool { return s[i].Size > s[j].Size } //===== Multi Database Longest Task First ===== // multiDatabaseLTF is designed to properly schedule intents with two constraints: // 1. it is optimized to run in a multi-processor environment // 2. it is optimized for parallelism against 2.6's db-level write lock // These goals result in a design that attempts to have as many different // database's intents being restored as possible and attempts to restore the // largest collections first. // // If we can have a minimum number of collections in flight for a given db, // we avoid lock contention in an optimal way on 2.6 systems. That is, // it is better to have two restore jobs where // job1 = "test.mycollection" // job2 = "mydb2.othercollection" // so that these collections do not compete for the db-level write lock. // // We also schedule the largest jobs first, in a greedy fashion, in order // to minimize total restoration time. Each database's intents are sorted // by decreasing file size at initialization, so that the largest jobs are // run first. Admittedly, .bson file size is not a direct predictor of restore // time, but there is certainly a strong correlation. Note that this attribute // is secondary to the multi-db scheduling laid out above, since multi-db will // get us bigger wins in terms of parallelism. type multiDatabaseLTFPrioritizer struct { sync.Mutex dbHeap heap.Interface counterMap map[string]*dbCounter } // NewMultiDatabaseLTFPrioritizer takes in a list of intents and returns an // initialized prioritizer. func NewMultiDatabaseLTFPrioritizer(intents []*Intent) *multiDatabaseLTFPrioritizer { prioritizer := &multiDatabaseLTFPrioritizer{ counterMap: map[string]*dbCounter{}, dbHeap: &DBHeap{}, } heap.Init(prioritizer.dbHeap) // first, create all database counters for _, intent := range intents { counter, exists := prioritizer.counterMap[intent.DB] if !exists { // initialize a new counter if one doesn't exist for DB counter = &dbCounter{} prioritizer.counterMap[intent.DB] = counter } counter.collections = append(counter.collections, intent) } // then ensure that all the dbCounters have sorted intents for _, counter := range prioritizer.counterMap { counter.SortCollectionsBySize() heap.Push(prioritizer.dbHeap, counter) } return prioritizer } // Get returns the next prioritized intent and updates the count of active // restores for the returned intent's DB. Get is not thread safe, and depends // on the implementation of the intent manager to lock around it. func (mdb *multiDatabaseLTFPrioritizer) Get() *Intent { mdb.Lock() defer mdb.Unlock() if mdb.dbHeap.Len() == 0 { // we're out of things to return return nil } optimalDB := heap.Pop(mdb.dbHeap).(*dbCounter) optimalDB.active++ nextIntent := optimalDB.PopIntent() // only release the db counter if it's out of collections if len(optimalDB.collections) > 0 { heap.Push(mdb.dbHeap, optimalDB) } return nextIntent } // Finish decreases the number of active restore jobs for the given intent's // database, and reshuffles the heap accordingly. Finish is not thread safe, // and depends on the implementation of the intent manager to lock around it. func (mdb *multiDatabaseLTFPrioritizer) Finish(intent *Intent) { mdb.Lock() defer mdb.Unlock() counter := mdb.counterMap[intent.DB] counter.active-- // only fix up the heap if the counter is still in the heap if len(counter.collections) > 0 { // This is an O(n) operation on the heap. We could make all heap // operations O(log(n)) if we set up dbCounters to track their own // position in the heap, but in practice this overhead is likely negligible. heap.Init(mdb.dbHeap) } } type dbCounter struct { active int collections []*Intent } func (dbc *dbCounter) SortCollectionsBySize() { sort.Sort(BySize(dbc.collections)) } // PopIntent returns the largest intent remaining for the database func (dbc *dbCounter) PopIntent() *Intent { var intent *Intent if len(dbc.collections) > 0 { intent, dbc.collections = dbc.collections[0], dbc.collections[1:] } return intent } // Returns the largest collection of the databases with the least active restores. // Implements the container/heap interface. None of its methods are meant to be // called directly. type DBHeap []*dbCounter func (dbh DBHeap) Len() int { return len(dbh) } func (dbh DBHeap) Swap(i, j int) { dbh[i], dbh[j] = dbh[j], dbh[i] } func (dbh DBHeap) Less(i, j int) bool { if dbh[i].active == dbh[j].active { // prioritize the largest bson file if dbs have the same number // of restorations in progress return dbh[i].collections[0].Size > dbh[j].collections[0].Size } return dbh[i].active < dbh[j].active } func (dbh *DBHeap) Push(x interface{}) { *dbh = append(*dbh, x.(*dbCounter)) } func (dbh *DBHeap) Pop() interface{} { // for container/heap package: removes the top entry and resizes the heap array old := *dbh n := len(old) toPop := old[n-1] *dbh = old[0 : n-1] return toPop } mongo-tools-r3.6.3/common/intents/intent_prioritizer_test.go000066400000000000000000000144741321131462300244750ustar00rootroot00000000000000// Copyright (C) MongoDB, Inc. 2014-present. // // 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 package intents import ( "container/heap" "testing" "github.com/mongodb/mongo-tools/common/testutil" . "github.com/smartystreets/goconvey/convey" "gopkg.in/mgo.v2/bson" ) func TestLegacyPrioritizer(t *testing.T) { testutil.VerifyTestType(t, testutil.UnitTestType) Convey("With a legacyPrioritizer initialized with an ordered intent list", t, func() { testList := []*Intent{ &Intent{DB: "1"}, &Intent{DB: "2"}, &Intent{DB: "3"}, } legacy := NewLegacyPrioritizer(testList) So(legacy, ShouldNotBeNil) Convey("the priority should be defined by 'first-in-first-out'", func() { it0 := legacy.Get() it1 := legacy.Get() it2 := legacy.Get() it3 := legacy.Get() So(it3, ShouldBeNil) So(it0.DB, ShouldBeLessThan, it1.DB) So(it1.DB, ShouldBeLessThan, it2.DB) }) }) } func TestBasicDBHeapBehavior(t *testing.T) { var dbheap heap.Interface testutil.VerifyTestType(t, testutil.UnitTestType) Convey("With an empty dbHeap", t, func() { dbheap = &DBHeap{} heap.Init(dbheap) Convey("when inserting unordered dbCounters with different active counts", func() { heap.Push(dbheap, &dbCounter{75, nil}) heap.Push(dbheap, &dbCounter{121, nil}) heap.Push(dbheap, &dbCounter{76, nil}) heap.Push(dbheap, &dbCounter{51, nil}) heap.Push(dbheap, &dbCounter{82, nil}) heap.Push(dbheap, &dbCounter{117, nil}) heap.Push(dbheap, &dbCounter{49, nil}) heap.Push(dbheap, &dbCounter{101, nil}) heap.Push(dbheap, &dbCounter{122, nil}) heap.Push(dbheap, &dbCounter{33, nil}) heap.Push(dbheap, &dbCounter{0, nil}) Convey("they should pop in active order, least to greatest", func() { prev := -1 for dbheap.Len() > 0 { popped := heap.Pop(dbheap).(*dbCounter) So(popped.active, ShouldBeGreaterThan, prev) prev = popped.active } }) }) Convey("when inserting unordered dbCounters with different bson sizes", func() { heap.Push(dbheap, &dbCounter{0, []*Intent{&Intent{Size: 70}}}) heap.Push(dbheap, &dbCounter{0, []*Intent{&Intent{Size: 1024}}}) heap.Push(dbheap, &dbCounter{0, []*Intent{&Intent{Size: 97}}}) heap.Push(dbheap, &dbCounter{0, []*Intent{&Intent{Size: 3}}}) heap.Push(dbheap, &dbCounter{0, []*Intent{&Intent{Size: 1024 * 1024}}}) Convey("they should pop in bson size order, greatest to least", func() { prev := int64(1024*1024 + 1) // Maximum for dbheap.Len() > 0 { popped := heap.Pop(dbheap).(*dbCounter) So(popped.collections[0].Size, ShouldBeLessThan, prev) prev = popped.collections[0].Size } }) }) }) } func TestDBCounterCollectionSorting(t *testing.T) { testutil.VerifyTestType(t, testutil.UnitTestType) Convey("With a dbCounter and an unordered collection of intents", t, func() { dbc := &dbCounter{ collections: []*Intent{ &Intent{Size: 100}, &Intent{Size: 1000}, &Intent{Size: 1}, &Intent{Size: 10}, }, } Convey("popping the sorted intents should return in decreasing BSONSize", func() { dbc.SortCollectionsBySize() So(dbc.PopIntent().Size, ShouldEqual, 1000) So(dbc.PopIntent().Size, ShouldEqual, 100) So(dbc.PopIntent().Size, ShouldEqual, 10) So(dbc.PopIntent().Size, ShouldEqual, 1) So(dbc.PopIntent(), ShouldBeNil) So(dbc.PopIntent(), ShouldBeNil) }) }) } func TestBySizeAndView(t *testing.T) { var prioritizer IntentPrioritizer testutil.VerifyTestType(t, testutil.UnitTestType) Convey("With a prioritizer initialized with on a set of intents", t, func() { intents := []*Intent{ &Intent{C: "non-view2", Size: 32}, &Intent{C: "view", Size: 0, Options: &bson.D{{"viewOn", true}}, }, &Intent{C: "non-view1", Size: 1024}, &Intent{C: "non-view3", Size: 2}, &Intent{C: "view", Size: 0, Options: &bson.D{{"viewOn", true}}, }, } prioritizer = NewLongestTaskFirstPrioritizer(intents) Convey("getting the sorted intents should produce views first, followed by largest to smallest", func() { So(prioritizer.Get().C, ShouldEqual, "view") So(prioritizer.Get().C, ShouldEqual, "view") So(prioritizer.Get().C, ShouldEqual, "non-view1") So(prioritizer.Get().C, ShouldEqual, "non-view2") So(prioritizer.Get().C, ShouldEqual, "non-view3") }) }) } func TestSimulatedMultiDBJob(t *testing.T) { var prioritizer IntentPrioritizer testutil.VerifyTestType(t, testutil.UnitTestType) Convey("With a prioritizer initialized with a set of intents", t, func() { intents := []*Intent{ &Intent{C: "small", DB: "db2", Size: 32}, &Intent{C: "medium", DB: "db2", Size: 128}, &Intent{C: "giant", DB: "db1", Size: 1024}, &Intent{C: "tiny", DB: "db1", Size: 2}, } prioritizer = NewMultiDatabaseLTFPrioritizer(intents) So(prioritizer, ShouldNotBeNil) Convey("and a running simulation of two jobs threads:", func() { Convey("the first two intents should be of different dbs", func() { i0 := prioritizer.Get() So(i0, ShouldNotBeNil) i1 := prioritizer.Get() So(i1, ShouldNotBeNil) Convey("the first intent should be the largest bson file", func() { So(i0.C, ShouldEqual, "giant") So(i0.DB, ShouldEqual, "db1") }) Convey("the second intent should be the largest bson file of db2", func() { So(i1.C, ShouldEqual, "medium") So(i1.DB, ShouldEqual, "db2") }) Convey("with the second job finishing the smaller intents", func() { prioritizer.Finish(i1) i2 := prioritizer.Get() So(i2, ShouldNotBeNil) prioritizer.Finish(i2) i3 := prioritizer.Get() So(i3, ShouldNotBeNil) Convey("the next job should be from db2", func() { So(i2.C, ShouldEqual, "small") So(i2.DB, ShouldEqual, "db2") }) Convey("the final job should be from db1", func() { So(i3.C, ShouldEqual, "tiny") So(i3.DB, ShouldEqual, "db1") Convey("which means that there should be two active db1 jobs", func() { counter := prioritizer.(*multiDatabaseLTFPrioritizer).counterMap["db1"] So(counter.active, ShouldEqual, 2) }) }) Convey("the heap should now be empty", func() { So(prioritizer.(*multiDatabaseLTFPrioritizer).dbHeap.Len(), ShouldEqual, 0) }) }) }) }) }) } mongo-tools-r3.6.3/common/intents/intent_test.go000066400000000000000000000060151321131462300220230ustar00rootroot00000000000000// Copyright (C) MongoDB, Inc. 2014-present. // // 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 package intents import ( "github.com/mongodb/mongo-tools/common/testutil" . "github.com/smartystreets/goconvey/convey" "testing" ) func TestIntentManager(t *testing.T) { var manager *Manager testutil.VerifyTestType(t, testutil.UnitTestType) Convey("With an empty IntentManager", t, func() { manager = NewIntentManager() So(manager, ShouldNotBeNil) Convey("putting a series of added bson intents", func() { manager.Put(&Intent{DB: "1", C: "1", Location: "/b1/"}) manager.Put(&Intent{DB: "1", C: "2", Location: "/b2/"}) manager.Put(&Intent{DB: "1", C: "3", Location: "/b3/"}) manager.Put(&Intent{DB: "2", C: "1", Location: "/b4/"}) So(len(manager.intentsByDiscoveryOrder), ShouldEqual, 4) So(len(manager.intents), ShouldEqual, 4) Convey("and then some matching metadata intents", func() { manager.Put(&Intent{DB: "2", C: "1", MetadataLocation: "/4m/"}) manager.Put(&Intent{DB: "1", C: "3", MetadataLocation: "/3m/"}) manager.Put(&Intent{DB: "1", C: "1", MetadataLocation: "/1m/"}) manager.Put(&Intent{DB: "1", C: "2", MetadataLocation: "/2m/"}) Convey("the size of the queue should be unchanged", func() { So(len(manager.intentsByDiscoveryOrder), ShouldEqual, 4) So(len(manager.intents), ShouldEqual, 4) }) Convey("popping them from the IntentManager", func() { manager.Finalize(Legacy) it0 := manager.Pop() it1 := manager.Pop() it2 := manager.Pop() it3 := manager.Pop() it4 := manager.Pop() So(it4, ShouldBeNil) Convey("should return them in insert order", func() { So(*it0, ShouldResemble, Intent{DB: "1", C: "1", Location: "/b1/", MetadataLocation: "/1m/"}) So(*it1, ShouldResemble, Intent{DB: "1", C: "2", Location: "/b2/", MetadataLocation: "/2m/"}) So(*it2, ShouldResemble, Intent{DB: "1", C: "3", Location: "/b3/", MetadataLocation: "/3m/"}) So(*it3, ShouldResemble, Intent{DB: "2", C: "1", Location: "/b4/", MetadataLocation: "/4m/"}) }) }) }) Convey("but adding non-matching intents", func() { manager.Put(&Intent{DB: "7", C: "49", MetadataLocation: "/5/"}) manager.Put(&Intent{DB: "27", C: "B", MetadataLocation: "/6/"}) Convey("should increase the size, because they are not merged in", func() { So(len(manager.intentsByDiscoveryOrder), ShouldEqual, 6) So(len(manager.intents), ShouldEqual, 6) }) }) Convey("using the Peek() method", func() { peeked := manager.Peek() So(peeked, ShouldNotBeNil) So(peeked, ShouldResemble, manager.intentsByDiscoveryOrder[0]) Convey("modifying the returned copy should not modify the original", func() { peeked.DB = "SHINY NEW VALUE" So(peeked, ShouldNotResemble, manager.intentsByDiscoveryOrder[0]) }) }) }) }) } mongo-tools-r3.6.3/common/json/000077500000000000000000000000001321131462300164175ustar00rootroot00000000000000mongo-tools-r3.6.3/common/json/bench_test.go000066400000000000000000000100221321131462300210570ustar00rootroot00000000000000// Copyright (C) MongoDB, Inc. 2014-present. // // 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 // // Based on github.com/golang/go by The Go Authors // See THIRD-PARTY-NOTICES for original license terms. // Large data benchmark. // The JSON data is a summary of agl's changes in the // go, webkit, and chromium open source projects. // We benchmark converting between the JSON form // and in-memory data structures. package json import ( "bytes" "compress/gzip" "io/ioutil" "os" "testing" ) type codeResponse struct { Tree *codeNode `json:"tree"` Username string `json:"username"` } type codeNode struct { Name string `json:"name"` Kids []*codeNode `json:"kids"` CLWeight float64 `json:"cl_weight"` Touches int `json:"touches"` MinT int64 `json:"min_t"` MaxT int64 `json:"max_t"` MeanT int64 `json:"mean_t"` } var codeJSON []byte var codeStruct codeResponse func codeInit() { f, err := os.Open("testdata/code.json.gz") if err != nil { panic(err) } defer f.Close() gz, err := gzip.NewReader(f) if err != nil { panic(err) } data, err := ioutil.ReadAll(gz) if err != nil { panic(err) } codeJSON = data if err := Unmarshal(codeJSON, &codeStruct); err != nil { panic("unmarshal code.json: " + err.Error()) } if data, err = Marshal(&codeStruct); err != nil { panic("marshal code.json: " + err.Error()) } if !bytes.Equal(data, codeJSON) { println("different lengths", len(data), len(codeJSON)) for i := 0; i < len(data) && i < len(codeJSON); i++ { if data[i] != codeJSON[i] { println("re-marshal: changed at byte", i) println("orig: ", string(codeJSON[i-10:i+10])) println("new: ", string(data[i-10:i+10])) break } } panic("re-marshal code.json: different result") } } func BenchmarkCodeEncoder(b *testing.B) { if codeJSON == nil { b.StopTimer() codeInit() b.StartTimer() } enc := NewEncoder(ioutil.Discard) for i := 0; i < b.N; i++ { if err := enc.Encode(&codeStruct); err != nil { b.Fatal("Encode:", err) } } b.SetBytes(int64(len(codeJSON))) } func BenchmarkCodeMarshal(b *testing.B) { if codeJSON == nil { b.StopTimer() codeInit() b.StartTimer() } for i := 0; i < b.N; i++ { if _, err := Marshal(&codeStruct); err != nil { b.Fatal("Marshal:", err) } } b.SetBytes(int64(len(codeJSON))) } func BenchmarkCodeDecoder(b *testing.B) { if codeJSON == nil { b.StopTimer() codeInit() b.StartTimer() } var buf bytes.Buffer dec := NewDecoder(&buf) var r codeResponse for i := 0; i < b.N; i++ { buf.Write(codeJSON) // hide EOF buf.WriteByte('\n') buf.WriteByte('\n') buf.WriteByte('\n') if err := dec.Decode(&r); err != nil { b.Fatal("Decode:", err) } } b.SetBytes(int64(len(codeJSON))) } func BenchmarkCodeUnmarshal(b *testing.B) { if codeJSON == nil { b.StopTimer() codeInit() b.StartTimer() } for i := 0; i < b.N; i++ { var r codeResponse if err := Unmarshal(codeJSON, &r); err != nil { b.Fatal("Unmmarshal:", err) } } b.SetBytes(int64(len(codeJSON))) } func BenchmarkCodeUnmarshalReuse(b *testing.B) { if codeJSON == nil { b.StopTimer() codeInit() b.StartTimer() } var r codeResponse for i := 0; i < b.N; i++ { if err := Unmarshal(codeJSON, &r); err != nil { b.Fatal("Unmmarshal:", err) } } } func BenchmarkUnmarshalString(b *testing.B) { data := []byte(`"hello, world"`) var s string for i := 0; i < b.N; i++ { if err := Unmarshal(data, &s); err != nil { b.Fatal("Unmarshal:", err) } } } func BenchmarkUnmarshalFloat64(b *testing.B) { var f float64 data := []byte(`3.14`) for i := 0; i < b.N; i++ { if err := Unmarshal(data, &f); err != nil { b.Fatal("Unmarshal:", err) } } } func BenchmarkUnmarshalInt64(b *testing.B) { var x int64 data := []byte(`3`) for i := 0; i < b.N; i++ { if err := Unmarshal(data, &x); err != nil { b.Fatal("Unmarshal:", err) } } } mongo-tools-r3.6.3/common/json/bindata.go000066400000000000000000000040101321131462300203430ustar00rootroot00000000000000// Copyright (C) MongoDB, Inc. 2014-present. // // 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 package json import ( "fmt" "reflect" ) // Transition functions for recognizing BinData. // Adapted from encoding/json/scanner.go. // stateBi is the state after reading `Bi`. func stateBi(s *scanner, c int) int { if c == 'n' { s.step = generateState("BinData", []byte("Data"), stateConstructor) return scanContinue } return s.error(c, "in literal BinData (expecting 'n')") } // Decodes a BinData literal stored in the underlying byte data into v. func (d *decodeState) storeBinData(v reflect.Value) { op := d.scanWhile(scanSkipSpace) if op != scanBeginCtor { d.error(fmt.Errorf("expected beginning of constructor")) } args, err := d.ctor("BinData", []reflect.Type{byteType, stringType}) if err != nil { d.error(err) } switch kind := v.Kind(); kind { case reflect.Interface: arg0 := byte(args[0].Uint()) arg1 := args[1].String() v.Set(reflect.ValueOf(BinData{arg0, arg1})) default: d.error(fmt.Errorf("cannot store %v value into %v type", binDataType, kind)) } } // Returns a BinData literal from the underlying byte data. func (d *decodeState) getBinData() interface{} { op := d.scanWhile(scanSkipSpace) if op != scanBeginCtor { d.error(fmt.Errorf("expected beginning of constructor")) } // Prevent d.convertNumber() from parsing the argument as a float64. useNumber := d.useNumber d.useNumber = true args := d.ctorInterface() if err := ctorNumArgsMismatch("BinData", 2, len(args)); err != nil { d.error(err) } arg0, err := args[0].(Number).Uint8() if err != nil { d.error(fmt.Errorf("expected byte for first argument of BinData constructor")) } arg1, ok := args[1].(string) if !ok { d.error(fmt.Errorf("expected string for second argument of BinData constructor")) } d.useNumber = useNumber return BinData{arg0, arg1} } mongo-tools-r3.6.3/common/json/bindata_test.go000066400000000000000000000047431321131462300214170ustar00rootroot00000000000000// Copyright (C) MongoDB, Inc. 2014-present. // // 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 package json import ( "fmt" . "github.com/smartystreets/goconvey/convey" "testing" ) func TestBinDataValue(t *testing.T) { Convey("When unmarshalling JSON with BinData values", t, func() { Convey("works for a single key", func() { var jsonMap map[string]interface{} key := "key" value := `BinData(1, "xyz")` data := fmt.Sprintf(`{"%v":%v}`, key, value) err := Unmarshal([]byte(data), &jsonMap) So(err, ShouldBeNil) jsonValue, ok := jsonMap[key].(BinData) So(ok, ShouldBeTrue) So(jsonValue, ShouldResemble, BinData{1, "xyz"}) }) Convey("works for multiple keys", func() { var jsonMap map[string]interface{} key1, key2, key3 := "key1", "key2", "key3" value1, value2, value3 := `BinData(1, "abc")`, `BinData(2, "def")`, `BinData(3, "ghi")` data := fmt.Sprintf(`{"%v":%v,"%v":%v,"%v":%v}`, key1, value1, key2, value2, key3, value3) err := Unmarshal([]byte(data), &jsonMap) So(err, ShouldBeNil) jsonValue1, ok := jsonMap[key1].(BinData) So(ok, ShouldBeTrue) So(jsonValue1, ShouldResemble, BinData{1, "abc"}) jsonValue2, ok := jsonMap[key2].(BinData) So(ok, ShouldBeTrue) So(jsonValue2, ShouldResemble, BinData{2, "def"}) jsonValue3, ok := jsonMap[key3].(BinData) So(ok, ShouldBeTrue) So(jsonValue3, ShouldResemble, BinData{3, "ghi"}) }) Convey("works in an array", func() { var jsonMap map[string]interface{} key := "key" value := `BinData(42, "10")` data := fmt.Sprintf(`{"%v":[%v,%v,%v]}`, key, value, value, value) err := Unmarshal([]byte(data), &jsonMap) So(err, ShouldBeNil) jsonArray, ok := jsonMap[key].([]interface{}) So(ok, ShouldBeTrue) for _, _jsonValue := range jsonArray { jsonValue, ok := _jsonValue.(BinData) So(ok, ShouldBeTrue) So(jsonValue, ShouldResemble, BinData{42, "10"}) } }) Convey("can specify type argument using hexadecimal", func() { var jsonMap map[string]interface{} key := "key" value := `BinData(0x5f, "xyz")` data := fmt.Sprintf(`{"%v":%v}`, key, value) err := Unmarshal([]byte(data), &jsonMap) So(err, ShouldBeNil) jsonValue, ok := jsonMap[key].(BinData) So(ok, ShouldBeTrue) So(jsonValue, ShouldResemble, BinData{0x5f, "xyz"}) }) }) } mongo-tools-r3.6.3/common/json/boolean.go000066400000000000000000000037411321131462300203720ustar00rootroot00000000000000// Copyright (C) MongoDB, Inc. 2014-present. // // 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 package json import ( "fmt" "reflect" ) // Transition functions for recognizing Boolean. // Adapted from encoding/json/scanner.go. // stateBo is the state after reading `Bo`. func stateBo(s *scanner, c int) int { if c == 'o' { s.step = generateState("Boolean", []byte("lean"), stateConstructor) return scanContinue } return s.error(c, "in literal Boolean (expecting 'o')") } // Decodes a Boolean literal stored in the underlying byte data into v. func (d *decodeState) storeBoolean(v reflect.Value) { res := d.getBoolean() switch kind := v.Kind(); kind { case reflect.Interface, reflect.Bool: v.Set(reflect.ValueOf(res)) default: d.error(fmt.Errorf("cannot store bool value into %v type", kind)) } } // Returns a Boolean literal from the underlying byte data. func (d *decodeState) getBoolean() interface{} { op := d.scanWhile(scanSkipSpace) if op != scanBeginCtor { d.error(fmt.Errorf("expected beginning of constructor")) } // Prevent d.convertNumber() from parsing the argument as a float64. useNumber := d.useNumber d.useNumber = true args := d.ctorInterface() if len(args) == 0 { return false } // Ignore all but the first argument. switch v := args[0].(type) { case bool: return v case Number: d.useNumber = useNumber // First try Int64 so hex numbers work, then if that fails try Float64. num, err := v.Int64() if err == nil { return (num != 0) } numF, err := v.Float64() if err != nil { d.error(fmt.Errorf("expected float64 for numeric argument of Boolean constructor, got err: %v", err)) } return (numF != 0) case string: return (v != "") case Undefined, nil: return false // Parameter values of any other types should yield true. default: return true } } mongo-tools-r3.6.3/common/json/boolean_test.go000066400000000000000000000216541321131462300214340ustar00rootroot00000000000000// Copyright (C) MongoDB, Inc. 2014-present. // // 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 package json import ( "fmt" . "github.com/smartystreets/goconvey/convey" "testing" ) func TestBooleanValue(t *testing.T) { Convey("When unmarshalling JSON with Boolean values", t, func() { Convey("works for a single key", func() { var jsonMap map[string]interface{} key := "key" value := "Boolean(123)" data := fmt.Sprintf(`{"%v":%v}`, key, value) err := Unmarshal([]byte(data), &jsonMap) So(err, ShouldBeNil) jsonValue, ok := jsonMap[key].(bool) So(ok, ShouldBeTrue) So(jsonValue, ShouldEqual, true) }) Convey("works for no args", func() { var jsonMap map[string]interface{} key := "key" value := "Boolean()" data := fmt.Sprintf(`{"%v":%v}`, key, value) err := Unmarshal([]byte(data), &jsonMap) So(err, ShouldBeNil) jsonValue, ok := jsonMap[key].(bool) So(ok, ShouldBeTrue) So(jsonValue, ShouldEqual, false) }) Convey("works for a struct of a specific type", func() { type TestStruct struct { A bool b int } var jsonStruct TestStruct key := "A" value := "Boolean(123)" data := fmt.Sprintf(`{"%v":%v}`, key, value) err := Unmarshal([]byte(data), &jsonStruct) So(err, ShouldBeNil) So(jsonStruct.A, ShouldEqual, true) key = "A" value = "Boolean(0)" data = fmt.Sprintf(`{"%v":%v}`, key, value) err = Unmarshal([]byte(data), &jsonStruct) So(err, ShouldBeNil) So(jsonStruct.A, ShouldEqual, false) }) Convey("works for bool", func() { var jsonMap map[string]interface{} key := "key" value := "Boolean(true)" data := fmt.Sprintf(`{"%v":%v}`, key, value) err := Unmarshal([]byte(data), &jsonMap) So(err, ShouldBeNil) jsonValue, ok := jsonMap[key].(bool) So(ok, ShouldBeTrue) So(jsonValue, ShouldEqual, true) value = "Boolean(false)" data = fmt.Sprintf(`{"%v":%v}`, key, value) err = Unmarshal([]byte(data), &jsonMap) So(err, ShouldBeNil) jsonValue, ok = jsonMap[key].(bool) So(ok, ShouldBeTrue) So(jsonValue, ShouldEqual, false) }) Convey("works for numbers", func() { var jsonMap map[string]interface{} key := "key" value := "Boolean(1)" data := fmt.Sprintf(`{"%v":%v}`, key, value) err := Unmarshal([]byte(data), &jsonMap) So(err, ShouldBeNil) jsonValue, ok := jsonMap[key].(bool) So(ok, ShouldBeTrue) So(jsonValue, ShouldEqual, true) value = "Boolean(0)" data = fmt.Sprintf(`{"%v":%v}`, key, value) err = Unmarshal([]byte(data), &jsonMap) So(err, ShouldBeNil) jsonValue, ok = jsonMap[key].(bool) So(ok, ShouldBeTrue) So(jsonValue, ShouldEqual, false) value = "Boolean(0.0)" data = fmt.Sprintf(`{"%v":%v}`, key, value) err = Unmarshal([]byte(data), &jsonMap) So(err, ShouldBeNil) jsonValue, ok = jsonMap[key].(bool) So(ok, ShouldBeTrue) So(jsonValue, ShouldEqual, false) value = "Boolean(2.0)" data = fmt.Sprintf(`{"%v":%v}`, key, value) err = Unmarshal([]byte(data), &jsonMap) So(err, ShouldBeNil) jsonValue, ok = jsonMap[key].(bool) So(ok, ShouldBeTrue) So(jsonValue, ShouldEqual, true) value = "Boolean(-15.4)" data = fmt.Sprintf(`{"%v":%v}`, key, value) err = Unmarshal([]byte(data), &jsonMap) So(err, ShouldBeNil) jsonValue, ok = jsonMap[key].(bool) So(ok, ShouldBeTrue) So(jsonValue, ShouldEqual, true) }) Convey("works for strings", func() { var jsonMap map[string]interface{} key := "key" value := "Boolean('hello')" data := fmt.Sprintf(`{"%v":%v}`, key, value) err := Unmarshal([]byte(data), &jsonMap) So(err, ShouldBeNil) jsonValue, ok := jsonMap[key].(bool) So(ok, ShouldBeTrue) So(jsonValue, ShouldEqual, true) value = "Boolean('')" data = fmt.Sprintf(`{"%v":%v}`, key, value) err = Unmarshal([]byte(data), &jsonMap) So(err, ShouldBeNil) jsonValue, ok = jsonMap[key].(bool) So(ok, ShouldBeTrue) So(jsonValue, ShouldEqual, false) }) Convey("works for undefined", func() { var jsonMap map[string]interface{} key := "key" value := "Boolean(undefined)" data := fmt.Sprintf(`{"%v":%v}`, key, value) err := Unmarshal([]byte(data), &jsonMap) So(err, ShouldBeNil) jsonValue, ok := jsonMap[key].(bool) So(ok, ShouldBeTrue) So(jsonValue, ShouldEqual, false) }) Convey("works for null", func() { var jsonMap map[string]interface{} key := "key" value := "Boolean(null)" data := fmt.Sprintf(`{"%v":%v}`, key, value) err := Unmarshal([]byte(data), &jsonMap) So(err, ShouldBeNil) jsonValue, ok := jsonMap[key].(bool) So(ok, ShouldBeTrue) So(jsonValue, ShouldEqual, false) }) Convey("works when given too many args", func() { var jsonMap map[string]interface{} key := "key" value := "Boolean(true, false)" data := fmt.Sprintf(`{"%v":%v}`, key, value) err := Unmarshal([]byte(data), &jsonMap) So(err, ShouldBeNil) jsonValue, ok := jsonMap[key].(bool) So(ok, ShouldBeTrue) So(jsonValue, ShouldEqual, true) key = "key" value = "Boolean(false, true)" data = fmt.Sprintf(`{"%v":%v}`, key, value) err = Unmarshal([]byte(data), &jsonMap) So(err, ShouldBeNil) jsonValue, ok = jsonMap[key].(bool) So(ok, ShouldBeTrue) So(jsonValue, ShouldEqual, false) }) Convey("works for multiple keys", func() { var jsonMap map[string]interface{} key1, key2, key3 := "key1", "key2", "key3" value1, value2, value3 := "Boolean(123)", "Boolean(0)", "Boolean(true)" data := fmt.Sprintf(`{"%v":%v,"%v":%v,"%v":%v}`, key1, value1, key2, value2, key3, value3) err := Unmarshal([]byte(data), &jsonMap) So(err, ShouldBeNil) jsonValue1, ok := jsonMap[key1].(bool) So(ok, ShouldBeTrue) So(jsonValue1, ShouldEqual, true) jsonValue2, ok := jsonMap[key2].(bool) So(ok, ShouldBeTrue) So(jsonValue2, ShouldEqual, false) jsonValue3, ok := jsonMap[key3].(bool) So(ok, ShouldBeTrue) So(jsonValue3, ShouldEqual, true) }) Convey("works for other types", func() { var jsonMap map[string]interface{} key := "key" value := "Boolean(new Date (0))" data := fmt.Sprintf(`{"%v":%v}`, key, value) err := Unmarshal([]byte(data), &jsonMap) So(err, ShouldBeNil) jsonValue, ok := jsonMap[key].(bool) So(ok, ShouldBeTrue) So(jsonValue, ShouldEqual, true) value = "Boolean(ObjectId('56609335028bd7dc5c36cb9f'))" data = fmt.Sprintf(`{"%v":%v}`, key, value) err = Unmarshal([]byte(data), &jsonMap) So(err, ShouldBeNil) jsonValue, ok = jsonMap[key].(bool) So(ok, ShouldBeTrue) So(jsonValue, ShouldEqual, true) value = "Boolean([])" data = fmt.Sprintf(`{"%v":%v}`, key, value) err = Unmarshal([]byte(data), &jsonMap) So(err, ShouldBeNil) jsonValue, ok = jsonMap[key].(bool) So(ok, ShouldBeTrue) So(jsonValue, ShouldEqual, true) }) Convey("works for nested booleans", func() { var jsonMap map[string]interface{} key := "key" value := "Boolean(Boolean(5))" data := fmt.Sprintf(`{"%v":%v}`, key, value) err := Unmarshal([]byte(data), &jsonMap) So(err, ShouldBeNil) jsonValue, ok := jsonMap[key].(bool) So(ok, ShouldBeTrue) So(jsonValue, ShouldEqual, true) value = "Boolean(Boolean(Boolean(0)))" data = fmt.Sprintf(`{"%v":%v}`, key, value) err = Unmarshal([]byte(data), &jsonMap) So(err, ShouldBeNil) jsonValue, ok = jsonMap[key].(bool) So(ok, ShouldBeTrue) So(jsonValue, ShouldEqual, false) }) Convey("works in an array", func() { var jsonMap map[string]interface{} key := "key" value1 := "Boolean(42)" value2 := "Boolean(0)" data := fmt.Sprintf(`{"%v":[%v,%v,%v]}`, key, value1, value2, value1) err := Unmarshal([]byte(data), &jsonMap) So(err, ShouldBeNil) jsonArray, ok := jsonMap[key].([]interface{}) So(ok, ShouldBeTrue) jsonValue, ok := jsonArray[0].(bool) So(ok, ShouldBeTrue) So(jsonValue, ShouldEqual, true) jsonValue, ok = jsonArray[1].(bool) So(ok, ShouldBeTrue) So(jsonValue, ShouldEqual, false) jsonValue, ok = jsonArray[2].(bool) So(ok, ShouldBeTrue) So(jsonValue, ShouldEqual, true) }) Convey("can specify argument in hexadecimal (true)", func() { var jsonMap map[string]interface{} key := "key" value := "Boolean(0x5f)" data := fmt.Sprintf(`{"%v":%v}`, key, value) err := Unmarshal([]byte(data), &jsonMap) So(err, ShouldBeNil) jsonValue, ok := jsonMap[key].(bool) So(ok, ShouldBeTrue) So(jsonValue, ShouldEqual, true) }) Convey("can specify argument in hexadecimal (false)", func() { var jsonMap map[string]interface{} key := "key" value := "Boolean(0x0)" data := fmt.Sprintf(`{"%v":%v}`, key, value) err := Unmarshal([]byte(data), &jsonMap) So(err, ShouldBeNil) jsonValue, ok := jsonMap[key].(bool) So(ok, ShouldBeTrue) So(jsonValue, ShouldEqual, false) }) }) } mongo-tools-r3.6.3/common/json/constructor.go000066400000000000000000000055211321131462300213360ustar00rootroot00000000000000// Copyright (C) MongoDB, Inc. 2014-present. // // 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 package json import ( "fmt" "reflect" ) const CtorNumArgsErrorf = "expected %v argument%v to %v constructor, but %v received" // Transition functions for recognizing object constructors. // Adapted from encoding/json/scanner.go. // stateConstructor is the state after reading a constructor name. func stateConstructor(s *scanner, c int) int { if c <= ' ' && isSpace(rune(c)) { return scanSkipSpace } if c == '(' { s.step = stateBeginCtorOrEmpty s.pushParseState(parseCtorArg) return scanBeginCtor } return s.error(c, "expected '('") } // stateBeginCtorOrEmpty is the state after reading `(`. func stateBeginCtorOrEmpty(s *scanner, c int) int { if c <= ' ' && isSpace(rune(c)) { return scanSkipSpace } if c == ')' { return stateEndValue(s, c) } return stateBeginValue(s, c) } // ctor consumes a constructor from d.data[d.off-1:], given a type specification t. // the first byte of the constructor ('(') has been read already. func (d *decodeState) ctor(name string, t []reflect.Type) ([]reflect.Value, error) { result := make([]reflect.Value, 0, len(t)) i := 0 for { // Look ahead for ) - can only happen on first iteration. op := d.scanWhile(scanSkipSpace) if op == scanEndCtor { break } // Back up so d.value can have the byte we just read. d.off-- d.scan.undo(op) if i < len(t) { v := reflect.New(t[i]).Elem() // Get argument of constructor d.value(v) result = append(result, v) i++ } // Next token must be , or ). op = d.scanWhile(scanSkipSpace) if op == scanEndCtor { break } if op != scanCtorArg { d.error(errPhase) } } return result, ctorNumArgsMismatch(name, len(t), i) } // ctorInterface is like ctor but returns []interface{}. func (d *decodeState) ctorInterface() []interface{} { var v = make([]interface{}, 0) for { // Look ahead for ) - can only happen on first iteration. op := d.scanWhile(scanSkipSpace) if op == scanEndCtor { break } // Back up so d.value can have the byte we just read. d.off-- d.scan.undo(op) v = append(v, d.valueInterface(false)) // Next token must be , or ). op = d.scanWhile(scanSkipSpace) if op == scanEndCtor { break } if op != scanCtorArg { d.error(errPhase) } } return v } // Returns a descriptive error message if the number of arguments given // to the constructor do not match what is expected. func ctorNumArgsMismatch(name string, expected, actual int) error { if expected == actual { return nil } quantifier := "" if expected > 1 { quantifier = "s" } return fmt.Errorf(CtorNumArgsErrorf, expected, quantifier, name, actual) } mongo-tools-r3.6.3/common/json/consts.go000066400000000000000000000005341321131462300202610ustar00rootroot00000000000000// Copyright (C) MongoDB, Inc. 2014-present. // // 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 package json const ( ArrayStart = '[' ArraySep = ',' ArrayEnd = ']' ) mongo-tools-r3.6.3/common/json/csv_format.go000066400000000000000000000037301321131462300211140ustar00rootroot00000000000000// Copyright (C) MongoDB, Inc. 2014-present. // // 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 package json import ( "encoding/base64" "fmt" "time" ) const CSV_DATE_FORMAT = "2006-01-02T15:04:05.000Z" func (b BinData) String() string { data, err := base64.StdEncoding.DecodeString(b.Base64) if err != nil { return "" // XXX: panic? } if b.Type == 0x02 { data = data[4:] // skip the first 4 bytes } return fmt.Sprintf("%X", data) // use uppercase hexadecimal } func (js JavaScript) String() string { return js.Code } func (d Date) String() string { if d.isFormatable() { n := int64(d) t := time.Unix(n/1e3, n%1e3*1e6) return t.UTC().Format(JSON_DATE_FORMAT) } // date.MarshalJSON always returns a nil err. data, _ := d.MarshalJSON() return string(data) } func (d DBRef) String() string { return fmt.Sprintf(`{ "$ref": "%v", "$id": %v, "$db": "%v" }`, d.Collection, d.Id, d.Database) } func (d DBPointer) String() string { return fmt.Sprintf(`{ "$ref": "%v", "$id": %v }`, d.Namespace, d.Id) } func (f Float) String() string { return fmt.Sprintf("%v", float64(f)) } func (_ MinKey) String() string { return "$MinKey" } func (_ MaxKey) String() string { return "$MaxKey" } func (n NumberInt) String() string { return fmt.Sprintf("%v", int32(n)) } func (n NumberLong) String() string { return fmt.Sprintf("%v", int64(n)) } // Assumes that o represents a valid ObjectId // (composed of 24 hexadecimal characters). func (o ObjectId) String() string { return fmt.Sprintf("ObjectId(%v)", string(o)) } func (r RegExp) String() string { return fmt.Sprintf("/%v/%v", r.Pattern, r.Options) } func (t Timestamp) String() string { return fmt.Sprintf(`{ "$timestamp": { "t": %v, "i": %v } }`, t.Seconds, t.Increment) } func (_ Undefined) String() string { return `{ "$undefined": true }` } mongo-tools-r3.6.3/common/json/date.go000066400000000000000000000043371321131462300176720ustar00rootroot00000000000000// Copyright (C) MongoDB, Inc. 2014-present. // // 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 package json import ( "fmt" "github.com/mongodb/mongo-tools/common/util" "reflect" ) // Transition functions for recognizing Date. // Adapted from encoding/json/scanner.go. // stateDa is the state after reading `Da`. func stateDa(s *scanner, c int) int { if c == 't' { s.step = stateDat return scanContinue } return s.error(c, "in literal Date (expecting 't')") } // stateDat is the state after reading `Dat`. func stateDat(s *scanner, c int) int { if c == 'e' { s.step = stateConstructor return scanContinue } return s.error(c, "in literal Date (expecting 'e')") } // Decodes a Date literal stored in the underlying byte data into v. func (d *decodeState) storeDate(v reflect.Value) { op := d.scanWhile(scanSkipSpace) if op != scanBeginCtor { d.error(fmt.Errorf("expected beginning of constructor")) } args, err := d.ctor("Date", []reflect.Type{dateType}) if err != nil { d.error(err) } switch kind := v.Kind(); kind { case reflect.Interface: v.Set(args[0]) default: d.error(fmt.Errorf("cannot store %v value into %v type", dateType, kind)) } } // Returns a Date literal from the underlying byte data. func (d *decodeState) getDate() interface{} { op := d.scanWhile(scanSkipSpace) if op != scanBeginCtor { d.error(fmt.Errorf("expected beginning of constructor")) } // Prevent d.convertNumber() from parsing the argument as a float64. useNumber := d.useNumber d.useNumber = true args := d.ctorInterface() if err := ctorNumArgsMismatch("Date", 1, len(args)); err != nil { d.error(err) } arg0num, isNumber := args[0].(Number) if !isNumber { // validate the date format of the string _, err := util.FormatDate(args[0].(string)) if err != nil { d.error(fmt.Errorf("unexpected ISODate format")) } d.useNumber = useNumber return ISODate(args[0].(string)) } arg0, err := arg0num.Int64() if err != nil { d.error(fmt.Errorf("expected int64 for first argument of Date constructor")) } d.useNumber = useNumber return Date(arg0) } mongo-tools-r3.6.3/common/json/date_test.go000066400000000000000000000051111321131462300207200ustar00rootroot00000000000000// Copyright (C) MongoDB, Inc. 2014-present. // // 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 package json import ( "fmt" . "github.com/smartystreets/goconvey/convey" "testing" ) func TestDateValue(t *testing.T) { Convey("When unmarshalling JSON with Date values", t, func() { Convey("works for a single key", func() { var jsonMap map[string]interface{} key := "key" value := "Date(123)" data := fmt.Sprintf(`{"%v":%v}`, key, value) err := Unmarshal([]byte(data), &jsonMap) So(err, ShouldBeNil) jsonValue, ok := jsonMap[key].(Date) So(ok, ShouldBeTrue) So(jsonValue, ShouldEqual, Date(123)) }) Convey("works for multiple keys", func() { var jsonMap map[string]interface{} key1, key2, key3 := "key1", "key2", "key3" value1, value2, value3 := "Date(123)", "Date(456)", "Date(789)" data := fmt.Sprintf(`{"%v":%v,"%v":%v,"%v":%v}`, key1, value1, key2, value2, key3, value3) err := Unmarshal([]byte(data), &jsonMap) So(err, ShouldBeNil) jsonValue1, ok := jsonMap[key1].(Date) So(ok, ShouldBeTrue) So(jsonValue1, ShouldEqual, Date(123)) jsonValue2, ok := jsonMap[key2].(Date) So(ok, ShouldBeTrue) So(jsonValue2, ShouldEqual, Date(456)) jsonValue3, ok := jsonMap[key3].(Date) So(ok, ShouldBeTrue) So(jsonValue3, ShouldEqual, Date(789)) }) Convey("works in an array", func() { var jsonMap map[string]interface{} key := "key" value := "Date(42)" data := fmt.Sprintf(`{"%v":[%v,%v,%v]}`, key, value, value, value) err := Unmarshal([]byte(data), &jsonMap) So(err, ShouldBeNil) jsonArray, ok := jsonMap[key].([]interface{}) So(ok, ShouldBeTrue) for _, _jsonValue := range jsonArray { jsonValue, ok := _jsonValue.(Date) So(ok, ShouldBeTrue) So(jsonValue, ShouldEqual, Date(42)) } }) Convey("cannot use string as argument", func() { var jsonMap map[string]interface{} key := "key" value := `Date("123")` data := fmt.Sprintf(`{"%v":%v}`, key, value) err := Unmarshal([]byte(data), &jsonMap) So(err, ShouldNotBeNil) }) Convey("can specify argument in hexadecimal", func() { var jsonMap map[string]interface{} key := "key" value := "Date(0x5f)" data := fmt.Sprintf(`{"%v":%v}`, key, value) err := Unmarshal([]byte(data), &jsonMap) So(err, ShouldBeNil) jsonValue, ok := jsonMap[key].(Date) So(ok, ShouldBeTrue) So(jsonValue, ShouldEqual, Date(0x5f)) }) }) } mongo-tools-r3.6.3/common/json/dbpointer.go000066400000000000000000000044011321131462300207330ustar00rootroot00000000000000// Copyright (C) MongoDB, Inc. 2014-present. // // 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 package json import ( "fmt" "gopkg.in/mgo.v2/bson" "reflect" ) // Transition functions for recognizing DBPointer. // Adapted from encoding/json/scanner.go. // stateDB is the state after reading `DB`. func stateDBP(s *scanner, c int) int { if c == 'o' { s.step = generateState("DBPointer", []byte("inter"), stateConstructor) return scanContinue } return s.error(c, "in literal DBPointer (expecting 'o')") } // Decodes a DBRef literal stored in the underlying byte data into v. func (d *decodeState) storeDBPointer(v reflect.Value) { op := d.scanWhile(scanSkipSpace) if op != scanBeginCtor { d.error(fmt.Errorf("expected beginning of constructor")) } args := d.ctorInterface() if len(args) != 2 { d.error(fmt.Errorf("expected 2 arguments to DBPointer constructor, but %v received", len(args))) } switch kind := v.Kind(); kind { case reflect.Interface: arg0, ok := args[0].(string) if !ok { d.error(fmt.Errorf("expected first argument to DBPointer to be of type string")) } arg1, ok := args[1].(ObjectId) if !ok { d.error(fmt.Errorf("expected second argument to DBPointer to be of type ObjectId, but ended up being %t", args[1])) } id := bson.ObjectIdHex(string(arg1)) v.Set(reflect.ValueOf(DBPointer{arg0, id})) default: d.error(fmt.Errorf("cannot store %v value into %v type", dbPointerType, kind)) } } // Returns a DBRef literal from the underlying byte data. func (d *decodeState) getDBPointer() interface{} { op := d.scanWhile(scanSkipSpace) if op != scanBeginCtor { d.error(fmt.Errorf("expected beginning of constructor")) } args := d.ctorInterface() if err := ctorNumArgsMismatch("DBPointer", 2, len(args)); err != nil { d.error(err) } arg0, ok := args[0].(string) if !ok { d.error(fmt.Errorf("expected string for first argument of DBPointer constructor")) } arg1, ok := args[1].(ObjectId) if !ok { d.error(fmt.Errorf("expected ObjectId for second argument of DBPointer constructor")) } id := bson.ObjectIdHex(string(arg1)) return DBPointer{arg0, id} } mongo-tools-r3.6.3/common/json/dbpointer_test.go000066400000000000000000000052101321131462300217710ustar00rootroot00000000000000// Copyright (C) MongoDB, Inc. 2014-present. // // 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 package json import ( "fmt" . "github.com/smartystreets/goconvey/convey" "gopkg.in/mgo.v2/bson" "testing" ) func TestDBPointerValue(t *testing.T) { Convey("Unmarshalling JSON with DBPointer values", t, func() { key := "key" value := `DBPointer("ref", ObjectId("552ffe9f5739878e73d116a9"))` Convey("works for a single key", func() { var jsonMap map[string]interface{} data := fmt.Sprintf(`{"%v":%v}`, key, value) err := Unmarshal([]byte(data), &jsonMap) So(err, ShouldBeNil) jsonValue, ok := jsonMap[key].(DBPointer) So(ok, ShouldBeTrue) So(jsonValue, ShouldResemble, DBPointer{"ref", bson.ObjectIdHex("552ffe9f5739878e73d116a9")}) }) Convey("works for multiple keys", func() { var jsonMap map[string]interface{} key1, key2, key3 := "key1", "key2", "key3" value2 := `DBPointer("ref2", ObjectId("552ffed95739878e73d116aa"))` value3 := `DBPointer("ref3", ObjectId("552fff215739878e73d116ab"))` data := fmt.Sprintf(`{"%v":%v,"%v":%v,"%v":%v}`, key1, value, key2, value2, key3, value3) err := Unmarshal([]byte(data), &jsonMap) So(err, ShouldBeNil) jsonValue1, ok := jsonMap[key1].(DBPointer) So(ok, ShouldBeTrue) So(jsonValue1, ShouldResemble, DBPointer{"ref", bson.ObjectIdHex("552ffe9f5739878e73d116a9")}) jsonValue2, ok := jsonMap[key2].(DBPointer) So(ok, ShouldBeTrue) So(jsonValue2, ShouldResemble, DBPointer{"ref2", bson.ObjectIdHex("552ffed95739878e73d116aa")}) jsonValue3, ok := jsonMap[key3].(DBPointer) So(ok, ShouldBeTrue) So(jsonValue3, ShouldResemble, DBPointer{"ref3", bson.ObjectIdHex("552fff215739878e73d116ab")}) }) Convey("works in an array", func() { var jsonMap map[string]interface{} data := fmt.Sprintf(`{"%v":[%v,%v,%v]}`, key, value, value, value) err := Unmarshal([]byte(data), &jsonMap) So(err, ShouldBeNil) jsonArray, ok := jsonMap[key].([]interface{}) So(ok, ShouldBeTrue) for _, _jsonValue := range jsonArray { jsonValue, ok := _jsonValue.(DBPointer) So(ok, ShouldBeTrue) So(jsonValue, ShouldResemble, DBPointer{"ref", bson.ObjectIdHex("552ffe9f5739878e73d116a9")}) } }) Convey("will not accept an $id type that is not an ObjectId", func() { value := `DBPointer("ref", 4)` var jsonMap map[string]interface{} data := fmt.Sprintf(`{"%v":%v}`, key, value) err := Unmarshal([]byte(data), &jsonMap) So(err, ShouldNotBeNil) }) }) } mongo-tools-r3.6.3/common/json/dbref.go000066400000000000000000000041341321131462300200320ustar00rootroot00000000000000// Copyright (C) MongoDB, Inc. 2014-present. // // 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 package json import ( "fmt" "reflect" ) // Transition functions for recognizing DBRef and Dbref. // Adapted from encoding/json/scanner.go. // stateDB is the state after reading `DB`. func stateDBR(s *scanner, c int) int { if c == 'e' { s.step = generateState("DBRef", []byte("f"), stateConstructor) return scanContinue } return s.error(c, "in literal DBRef (expecting 'e')") } // stateDb is the state after reading `Db`. func stateDb(s *scanner, c int) int { if c == 'r' { s.step = generateState("Dbref", []byte("ef"), stateConstructor) return scanContinue } return s.error(c, "in literal Dbref (expecting 'r')") } // Decodes a DBRef literal stored in the underlying byte data into v. func (d *decodeState) storeDBRef(v reflect.Value) { op := d.scanWhile(scanSkipSpace) if op != scanBeginCtor { d.error(fmt.Errorf("expected beginning of constructor")) } args := d.ctorInterface() if len(args) != 2 { d.error(fmt.Errorf("expected 2 arguments to DBRef constructor, but %v received", len(args))) } switch kind := v.Kind(); kind { case reflect.Interface: arg0, ok := args[0].(string) if !ok { d.error(fmt.Errorf("expected first argument to DBRef to be of type string")) } arg1 := args[1] v.Set(reflect.ValueOf(DBRef{arg0, arg1, ""})) default: d.error(fmt.Errorf("cannot store %v value into %v type", dbRefType, kind)) } } // Returns a DBRef literal from the underlying byte data. func (d *decodeState) getDBRef() interface{} { op := d.scanWhile(scanSkipSpace) if op != scanBeginCtor { d.error(fmt.Errorf("expected beginning of constructor")) } args := d.ctorInterface() if err := ctorNumArgsMismatch("DBRef", 2, len(args)); err != nil { d.error(err) } arg0, ok := args[0].(string) if !ok { d.error(fmt.Errorf("expected string for first argument of DBRef constructor")) } return DBRef{arg0, args[1], ""} } mongo-tools-r3.6.3/common/json/dbref_test.go000066400000000000000000000220241321131462300210670ustar00rootroot00000000000000// Copyright (C) MongoDB, Inc. 2014-present. // // 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 package json import ( "fmt" . "github.com/smartystreets/goconvey/convey" "math" "testing" ) func TestDBRefValue(t *testing.T) { Convey("When unmarshalling JSON with DBRef values", t, func() { Convey("works for a single key", func() { var jsonMap map[string]interface{} key := "key" value := `DBRef("ref", "123")` data := fmt.Sprintf(`{"%v":%v}`, key, value) err := Unmarshal([]byte(data), &jsonMap) So(err, ShouldBeNil) jsonValue, ok := jsonMap[key].(DBRef) So(ok, ShouldBeTrue) So(jsonValue, ShouldResemble, DBRef{"ref", "123", ""}) }) Convey("works for multiple keys", func() { var jsonMap map[string]interface{} key1, key2, key3 := "key1", "key2", "key3" value1, value2, value3 := `DBRef("ref1", "123")`, `DBRef("ref2", "456")`, `DBRef("ref3", "789")` data := fmt.Sprintf(`{"%v":%v,"%v":%v,"%v":%v}`, key1, value1, key2, value2, key3, value3) err := Unmarshal([]byte(data), &jsonMap) So(err, ShouldBeNil) jsonValue1, ok := jsonMap[key1].(DBRef) So(ok, ShouldBeTrue) So(jsonValue1, ShouldResemble, DBRef{"ref1", "123", ""}) jsonValue2, ok := jsonMap[key2].(DBRef) So(ok, ShouldBeTrue) So(jsonValue2, ShouldResemble, DBRef{"ref2", "456", ""}) jsonValue3, ok := jsonMap[key3].(DBRef) So(ok, ShouldBeTrue) So(jsonValue3, ShouldResemble, DBRef{"ref3", "789", ""}) }) Convey("works in an array", func() { var jsonMap map[string]interface{} key := "key" value := `DBRef("ref", "42")` data := fmt.Sprintf(`{"%v":[%v,%v,%v]}`, key, value, value, value) err := Unmarshal([]byte(data), &jsonMap) So(err, ShouldBeNil) jsonArray, ok := jsonMap[key].([]interface{}) So(ok, ShouldBeTrue) for _, _jsonValue := range jsonArray { jsonValue, ok := _jsonValue.(DBRef) So(ok, ShouldBeTrue) So(jsonValue, ShouldResemble, DBRef{"ref", "42", ""}) } }) Convey("can use alternative capitalization ('Dbref')", func() { var jsonMap map[string]interface{} key := "key" value := `Dbref("ref", "123")` data := fmt.Sprintf(`{"%v":%v}`, key, value) err := Unmarshal([]byte(data), &jsonMap) So(err, ShouldBeNil) jsonValue, ok := jsonMap[key].(DBRef) So(ok, ShouldBeTrue) So(jsonValue, ShouldResemble, DBRef{"ref", "123", ""}) }) Convey("can have any extended JSON value for id parameter", func() { Convey("a null literal", func() { var jsonMap map[string]interface{} key := "key" value := `DBRef("ref", null)` data := fmt.Sprintf(`{"%v":%v}`, key, value) err := Unmarshal([]byte(data), &jsonMap) So(err, ShouldBeNil) jsonValue, ok := jsonMap[key].(DBRef) So(ok, ShouldBeTrue) So(jsonValue, ShouldResemble, DBRef{"ref", nil, ""}) }) Convey("a true literal", func() { var jsonMap map[string]interface{} key := "key" value := `DBRef("ref", true)` data := fmt.Sprintf(`{"%v":%v}`, key, value) err := Unmarshal([]byte(data), &jsonMap) So(err, ShouldBeNil) jsonValue, ok := jsonMap[key].(DBRef) So(ok, ShouldBeTrue) So(jsonValue, ShouldResemble, DBRef{"ref", true, ""}) }) Convey("a false literal", func() { var jsonMap map[string]interface{} key := "key" value := `DBRef("ref", false)` data := fmt.Sprintf(`{"%v":%v}`, key, value) err := Unmarshal([]byte(data), &jsonMap) So(err, ShouldBeNil) jsonValue, ok := jsonMap[key].(DBRef) So(ok, ShouldBeTrue) So(jsonValue, ShouldResemble, DBRef{"ref", false, ""}) }) Convey("an undefined literal", func() { var jsonMap map[string]interface{} key := "key" value := `DBRef("ref", undefined)` data := fmt.Sprintf(`{"%v":%v}`, key, value) err := Unmarshal([]byte(data), &jsonMap) So(err, ShouldBeNil) jsonValue, ok := jsonMap[key].(DBRef) So(ok, ShouldBeTrue) So(jsonValue, ShouldResemble, DBRef{"ref", Undefined{}, ""}) }) Convey("a NaN literal", func() { var jsonMap map[string]interface{} key := "key" value := `DBRef("ref", NaN)` data := fmt.Sprintf(`{"%v":%v}`, key, value) err := Unmarshal([]byte(data), &jsonMap) So(err, ShouldBeNil) jsonValue, ok := jsonMap[key].(DBRef) So(ok, ShouldBeTrue) So(jsonValue.Collection, ShouldEqual, "ref") id, ok := jsonValue.Id.(float64) So(ok, ShouldBeTrue) So(math.IsNaN(id), ShouldBeTrue) }) Convey("an Infinity literal", func() { var jsonMap map[string]interface{} key := "key" value := `DBRef("ref", Infinity)` data := fmt.Sprintf(`{"%v":%v}`, key, value) err := Unmarshal([]byte(data), &jsonMap) So(err, ShouldBeNil) jsonValue, ok := jsonMap[key].(DBRef) So(ok, ShouldBeTrue) So(jsonValue.Collection, ShouldEqual, "ref") id, ok := jsonValue.Id.(float64) So(ok, ShouldBeTrue) So(math.IsInf(id, 1), ShouldBeTrue) }) Convey("a MinKey literal", func() { var jsonMap map[string]interface{} key := "key" value := `DBRef("ref", MinKey)` data := fmt.Sprintf(`{"%v":%v}`, key, value) err := Unmarshal([]byte(data), &jsonMap) So(err, ShouldBeNil) jsonValue, ok := jsonMap[key].(DBRef) So(ok, ShouldBeTrue) So(jsonValue, ShouldResemble, DBRef{"ref", MinKey{}, ""}) }) Convey("a MaxKey literal", func() { var jsonMap map[string]interface{} key := "key" value := `DBRef("ref", MaxKey)` data := fmt.Sprintf(`{"%v":%v}`, key, value) err := Unmarshal([]byte(data), &jsonMap) So(err, ShouldBeNil) jsonValue, ok := jsonMap[key].(DBRef) So(ok, ShouldBeTrue) So(jsonValue, ShouldResemble, DBRef{"ref", MaxKey{}, ""}) }) Convey("an ObjectId object", func() { var jsonMap map[string]interface{} key := "key" value := `DBRef("ref", ObjectId("123"))` data := fmt.Sprintf(`{"%v":%v}`, key, value) err := Unmarshal([]byte(data), &jsonMap) So(err, ShouldBeNil) jsonValue, ok := jsonMap[key].(DBRef) So(ok, ShouldBeTrue) So(jsonValue, ShouldResemble, DBRef{"ref", ObjectId("123"), ""}) }) Convey("a NumberInt object", func() { var jsonMap map[string]interface{} key := "key" value := `DBRef("ref", NumberInt(123))` data := fmt.Sprintf(`{"%v":%v}`, key, value) err := Unmarshal([]byte(data), &jsonMap) So(err, ShouldBeNil) jsonValue, ok := jsonMap[key].(DBRef) So(ok, ShouldBeTrue) So(jsonValue, ShouldResemble, DBRef{"ref", NumberInt(123), ""}) }) Convey("a NumberLong object", func() { var jsonMap map[string]interface{} key := "key" value := `DBRef("ref", NumberLong(123))` data := fmt.Sprintf(`{"%v":%v}`, key, value) err := Unmarshal([]byte(data), &jsonMap) So(err, ShouldBeNil) jsonValue, ok := jsonMap[key].(DBRef) So(ok, ShouldBeTrue) So(jsonValue, ShouldResemble, DBRef{"ref", NumberLong(123), ""}) }) Convey("a RegExp object", func() { var jsonMap map[string]interface{} key := "key" value := `DBRef("ref", RegExp("xyz", "i"))` data := fmt.Sprintf(`{"%v":%v}`, key, value) err := Unmarshal([]byte(data), &jsonMap) So(err, ShouldBeNil) jsonValue, ok := jsonMap[key].(DBRef) So(ok, ShouldBeTrue) So(jsonValue, ShouldResemble, DBRef{"ref", RegExp{"xyz", "i"}, ""}) }) Convey("a regular expression literal", func() { var jsonMap map[string]interface{} key := "key" value := `DBRef("ref", /xyz/i)` data := fmt.Sprintf(`{"%v":%v}`, key, value) err := Unmarshal([]byte(data), &jsonMap) So(err, ShouldBeNil) jsonValue, ok := jsonMap[key].(DBRef) So(ok, ShouldBeTrue) So(jsonValue, ShouldResemble, DBRef{"ref", RegExp{"xyz", "i"}, ""}) }) Convey("a Timestamp object", func() { var jsonMap map[string]interface{} key := "key" value := `DBRef("ref", Timestamp(123, 321))` data := fmt.Sprintf(`{"%v":%v}`, key, value) err := Unmarshal([]byte(data), &jsonMap) So(err, ShouldBeNil) jsonValue, ok := jsonMap[key].(DBRef) So(ok, ShouldBeTrue) So(jsonValue, ShouldResemble, DBRef{"ref", Timestamp{123, 321}, ""}) }) Convey("a string literal", func() { var jsonMap map[string]interface{} key := "key" value := `DBRef("ref", "xyz")` data := fmt.Sprintf(`{"%v":%v}`, key, value) err := Unmarshal([]byte(data), &jsonMap) So(err, ShouldBeNil) jsonValue, ok := jsonMap[key].(DBRef) So(ok, ShouldBeTrue) So(jsonValue, ShouldResemble, DBRef{"ref", "xyz", ""}) }) Convey("a numeric literal", func() { var jsonMap map[string]interface{} key := "key" value := `DBRef("ref", 123)` data := fmt.Sprintf(`{"%v":%v}`, key, value) err := Unmarshal([]byte(data), &jsonMap) So(err, ShouldBeNil) jsonValue, ok := jsonMap[key].(DBRef) So(ok, ShouldBeTrue) So(jsonValue.Collection, ShouldEqual, "ref") id, ok := jsonValue.Id.(int32) So(ok, ShouldBeTrue) So(id, ShouldAlmostEqual, 123) }) }) }) } mongo-tools-r3.6.3/common/json/decode.go000066400000000000000000000755431321131462300202070ustar00rootroot00000000000000// Copyright (C) MongoDB, Inc. 2014-present. // // 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 // // Based on github.com/golang/go by The Go Authors // See THIRD-PARTY-NOTICES for original license terms. // Represents JSON data structure using native Go types: booleans, floats, // strings, arrays, and maps. package json import ( "bytes" "encoding" "encoding/base64" "errors" "fmt" "gopkg.in/mgo.v2/bson" "math" "reflect" "runtime" "strconv" "unicode" "unicode/utf16" "unicode/utf8" ) // Unmarshal parses the JSON-encoded data and stores the result // in the value pointed to by v. // // Unmarshal uses the inverse of the encodings that // Marshal uses, allocating maps, slices, and pointers as necessary, // with the following additional rules: // // To unmarshal JSON into a pointer, Unmarshal first handles the case of // the JSON being the JSON literal null. In that case, Unmarshal sets // the pointer to nil. Otherwise, Unmarshal unmarshals the JSON into // the value pointed at by the pointer. If the pointer is nil, Unmarshal // allocates a new value for it to point to. // // To unmarshal JSON into a struct, Unmarshal matches incoming object // keys to the keys used by Marshal (either the struct field name or its tag), // preferring an exact match but also accepting a case-insensitive match. // // To unmarshal JSON into an interface value, // Unmarshal stores one of these in the interface value: // // bool, for JSON booleans // float64, for JSON numbers // string, for JSON strings // []interface{}, for JSON arrays // map[string]interface{}, for JSON objects // nil for JSON null // // If a JSON value is not appropriate for a given target type, // or if a JSON number overflows the target type, Unmarshal // skips that field and completes the unmarshalling as best it can. // If no more serious errors are encountered, Unmarshal returns // an UnmarshalTypeError describing the earliest such error. // // The JSON null value unmarshals into an interface, map, pointer, or slice // by setting that Go value to nil. Because null is often used in JSON to mean // ``not present,'' unmarshaling a JSON null into any other Go type has no effect // on the value and produces no error. // // When unmarshaling quoted strings, invalid UTF-8 or // invalid UTF-16 surrogate pairs are not treated as an error. // Instead, they are replaced by the Unicode replacement // character U+FFFD. // func Unmarshal(data []byte, v interface{}) error { // Check for well-formedness. // Avoids filling out half a data structure // before discovering a JSON syntax error. var d decodeState err := checkValid(data, &d.scan) if err != nil { return err } d.init(data) return d.unmarshal(v) } func UnmarshalMap(data []byte) (map[string]interface{}, error) { // Check for well-formedness. // Avoids filling out half a data structure // before discovering a JSON syntax error. var d decodeState err := checkValid(data, &d.scan) if err != nil { return nil, err } d.init(data) return d.unmarshalMap() } func UnmarshalBsonD(data []byte) (bson.D, error) { // Check for well-formedness. // Avoids filling out half a data structure // before discovering a JSON syntax error. var d decodeState err := checkValid(data, &d.scan) if err != nil { return nil, err } d.init(data) return d.unmarshalBsonD() } // Unmarshaler is the interface implemented by objects // that can unmarshal a JSON description of themselves. // The input can be assumed to be a valid encoding of // a JSON value. UnmarshalJSON must copy the JSON data // if it wishes to retain the data after returning. type Unmarshaler interface { UnmarshalJSON([]byte) error } // An UnmarshalTypeError describes a JSON value that was // not appropriate for a value of a specific Go type. type UnmarshalTypeError struct { Value string // description of JSON value - "bool", "array", "number -5" Type reflect.Type // type of Go value it could not be assigned to } func (e *UnmarshalTypeError) Error() string { return "json: cannot unmarshal " + e.Value + " into Go value of type " + e.Type.String() } // An UnmarshalFieldError describes a JSON object key that // led to an unexported (and therefore unwritable) struct field. // (No longer used; kept for compatibility.) type UnmarshalFieldError struct { Key string Type reflect.Type Field reflect.StructField } func (e *UnmarshalFieldError) Error() string { return "json: cannot unmarshal object key " + strconv.Quote(e.Key) + " into unexported field " + e.Field.Name + " of type " + e.Type.String() } // An InvalidUnmarshalError describes an invalid argument passed to Unmarshal. // (The argument to Unmarshal must be a non-nil pointer.) type InvalidUnmarshalError struct { Type reflect.Type } func (e *InvalidUnmarshalError) Error() string { if e.Type == nil { return "json: Unmarshal(nil)" } if e.Type.Kind() != reflect.Ptr { return "json: Unmarshal(non-pointer " + e.Type.String() + ")" } return "json: Unmarshal(nil " + e.Type.String() + ")" } func (d *decodeState) unmarshalMap() (out map[string]interface{}, err error) { defer func() { if r := recover(); r != nil { if _, ok := r.(runtime.Error); ok { panic(r) } err = r.(error) } }() d.scan.reset() // We decode rv not rv.Elem because the Unmarshaler interface // test must be applied at the top level of the value. out = d.document() return out, d.savedError } func (d *decodeState) unmarshalBsonD() (out bson.D, err error) { defer func() { if r := recover(); r != nil { if _, ok := r.(runtime.Error); ok { panic(r) } err = r.(error) } }() d.scan.reset() // We decode rv not rv.Elem because the Unmarshaler interface // test must be applied at the top level of the value. out = d.bsonDocument() return out, d.savedError } func (d *decodeState) unmarshal(v interface{}) (err error) { defer func() { if r := recover(); r != nil { if _, ok := r.(runtime.Error); ok { panic(r) } err = r.(error) } }() rv := reflect.ValueOf(v) if rv.Kind() != reflect.Ptr || rv.IsNil() { return &InvalidUnmarshalError{reflect.TypeOf(v)} } d.scan.reset() // We decode rv not rv.Elem because the Unmarshaler interface // test must be applied at the top level of the value. d.value(rv) return d.savedError } // A Number represents a JSON number literal. type Number string // String returns the literal text of the number. func (n Number) String() string { return string(n) } // Float64 returns the number as a float64. func (n Number) Float64() (float64, error) { return strconv.ParseFloat(string(n), 64) } // Int32 returns the number as an int32. func (n Number) Int32() (int32, error) { x, err := n.Int64() return int32(x), err } // Int64 returns the number as an int64. func (n Number) Int64() (int64, error) { base := 10 if isHexPrefix(string(n)) { base = 0 // strconv.ParseInt will infer base 16 } return strconv.ParseInt(string(n), base, 64) } // Uint8 returns the number as an uint8. func (n Number) Uint8() (uint8, error) { x, err := n.Uint64() return uint8(x), err } // Uint32 returns the number as an uint32. func (n Number) Uint32() (uint32, error) { x, err := n.Uint64() return uint32(x), err } // Uint64 returns the number as an uint64. func (n Number) Uint64() (uint64, error) { base := 10 if isHexPrefix(string(n)) { base = 0 // strconv.ParseUint will infer base 16 } return strconv.ParseUint(string(n), base, 64) } // decodeState represents the state while decoding a JSON value. type decodeState struct { data []byte off int // read offset in data scan scanner nextscan scanner // for calls to nextValue savedError error tempstr string // scratch space to avoid some allocations useNumber bool } // errPhase is used for errors that should not happen unless // there is a bug in the JSON decoder or something is editing // the data slice while the decoder executes. var errPhase = errors.New("JSON decoder out of sync - data changing underfoot?") func (d *decodeState) init(data []byte) *decodeState { d.data = data d.off = 0 d.savedError = nil return d } // error aborts the decoding by panicking with err. func (d *decodeState) error(err error) { panic(err) } // saveError saves the first err it is called with, // for reporting at the end of the unmarshal. func (d *decodeState) saveError(err error) { if d.savedError == nil { d.savedError = err } } // next cuts off and returns the next full JSON value in d.data[d.off:]. // The next value is known to be an object or array, not a literal. func (d *decodeState) next() []byte { c := d.data[d.off] item, rest, err := nextValue(d.data[d.off:], &d.nextscan) if err != nil { d.error(err) } d.off = len(d.data) - len(rest) // Our scanner has seen the opening brace/bracket // and thinks we're still in the middle of the object. // invent a closing brace/bracket to get it out. if c == '{' { d.scan.step(&d.scan, '}') } else { d.scan.step(&d.scan, ']') } return item } // scanWhile processes bytes in d.data[d.off:] until it // receives a scan code not equal to op. // It updates d.off and returns the new scan code. func (d *decodeState) scanWhile(op int) int { var newOp int for { if d.off >= len(d.data) { newOp = d.scan.eof() d.off = len(d.data) + 1 // mark processed EOF with len+1 } else { c := int(d.data[d.off]) d.off++ newOp = d.scan.step(&d.scan, c) } if newOp != op { break } } return newOp } func (d *decodeState) document() map[string]interface{} { switch op := d.scanWhile(scanSkipSpace); op { default: d.error(errPhase) return nil case scanBeginObject: return d.objectInterface() } } func (d *decodeState) bsonDocument() bson.D { switch op := d.scanWhile(scanSkipSpace); op { default: d.error(errPhase) return nil case scanBeginObject: return d.bsonDInterface() } } // value decodes a JSON value from d.data[d.off:] into the value. // it updates d.off to point past the decoded value. func (d *decodeState) value(v reflect.Value) { if !v.IsValid() { _, rest, err := nextValue(d.data[d.off:], &d.nextscan) if err != nil { d.error(err) } d.off = len(d.data) - len(rest) // d.scan thinks we're still at the beginning of the item. // Feed in an empty string - the shortest, simplest value - // so that it knows we got to the end of the value. if d.scan.redo { // rewind. d.scan.redo = false d.scan.step = stateBeginValue } d.scan.step(&d.scan, '"') d.scan.step(&d.scan, '"') n := len(d.scan.parseState) if n > 0 && d.scan.parseState[n-1] == parseObjectKey { // d.scan thinks we just read an object key; finish the object d.scan.step(&d.scan, ':') d.scan.step(&d.scan, '"') d.scan.step(&d.scan, '"') d.scan.step(&d.scan, '}') } return } switch op := d.scanWhile(scanSkipSpace); op { default: d.error(errPhase) case scanBeginArray: d.array(v) case scanBeginObject: d.object(v) case scanBeginLiteral: d.literal(v) } } // indirect walks down v allocating pointers as needed, // until it gets to a non-pointer. // if it encounters an Unmarshaler, indirect stops and returns that. // if decodingNull is true, indirect stops at the last pointer so it can be set to nil. func (d *decodeState) indirect(v reflect.Value, decodingNull bool) (Unmarshaler, encoding.TextUnmarshaler, reflect.Value) { // If v is a named type and is addressable, // start with its address, so that if the type has pointer methods, // we find them. if v.Kind() != reflect.Ptr && v.Type().Name() != "" && v.CanAddr() { v = v.Addr() } for { // Load value from interface, but only if the result will be // usefully addressable. if v.Kind() == reflect.Interface && !v.IsNil() { e := v.Elem() if e.Kind() == reflect.Ptr && !e.IsNil() && (!decodingNull || e.Elem().Kind() == reflect.Ptr) { v = e continue } } if v.Kind() != reflect.Ptr { break } if v.Elem().Kind() != reflect.Ptr && decodingNull && v.CanSet() { break } if v.IsNil() { v.Set(reflect.New(v.Type().Elem())) } if v.Type().NumMethod() > 0 { if u, ok := v.Interface().(Unmarshaler); ok { return u, nil, reflect.Value{} } if u, ok := v.Interface().(encoding.TextUnmarshaler); ok { return nil, u, reflect.Value{} } } v = v.Elem() } return nil, nil, v } // array consumes an array from d.data[d.off-1:], decoding into the value v. // the first byte of the array ('[') has been read already. func (d *decodeState) array(v reflect.Value) { // Check for unmarshaler. u, ut, pv := d.indirect(v, false) if u != nil { d.off-- err := u.UnmarshalJSON(d.next()) if err != nil { d.error(err) } return } if ut != nil { d.saveError(&UnmarshalTypeError{"array", v.Type()}) d.off-- d.next() return } v = pv // Check type of target. switch v.Kind() { case reflect.Interface: if v.NumMethod() == 0 { // Decoding into nil interface? Switch to non-reflect code. v.Set(reflect.ValueOf(d.arrayInterface(false))) return } // Otherwise it's invalid. fallthrough default: d.saveError(&UnmarshalTypeError{"array", v.Type()}) d.off-- d.next() return case reflect.Array: case reflect.Slice: break } i := 0 for { // Look ahead for ] - can only happen on first iteration. op := d.scanWhile(scanSkipSpace) if op == scanEndArray { break } // Back up so d.value can have the byte we just read. d.off-- d.scan.undo(op) // Get element of array, growing if necessary. if v.Kind() == reflect.Slice { // Grow slice if necessary if i >= v.Cap() { newcap := v.Cap() + v.Cap()/2 if newcap < 4 { newcap = 4 } newv := reflect.MakeSlice(v.Type(), v.Len(), newcap) reflect.Copy(newv, v) v.Set(newv) } if i >= v.Len() { v.SetLen(i + 1) } } if i < v.Len() { // Decode into element. d.value(v.Index(i)) } else { // Ran out of fixed array: skip. d.value(reflect.Value{}) } i++ // Next token must be , or ]. op = d.scanWhile(scanSkipSpace) if op == scanEndArray { break } if op != scanArrayValue { d.error(errPhase) } } if i < v.Len() { if v.Kind() == reflect.Array { // Array. Zero the rest. z := reflect.Zero(v.Type().Elem()) for ; i < v.Len(); i++ { v.Index(i).Set(z) } } else { v.SetLen(i) } } if i == 0 && v.Kind() == reflect.Slice { v.Set(reflect.MakeSlice(v.Type(), 0, 0)) } } // object consumes an object from d.data[d.off-1:], decoding into the value v. // the first byte of the object ('{') has been read already. func (d *decodeState) object(v reflect.Value) { // Check for unmarshaler. u, ut, pv := d.indirect(v, false) if u != nil { d.off-- err := u.UnmarshalJSON(d.next()) if err != nil { d.error(err) } return } if ut != nil { d.saveError(&UnmarshalTypeError{"object", v.Type()}) d.off-- d.next() // skip over { } in input return } v = pv // Decoding into nil interface? Switch to non-reflect code. if v.Kind() == reflect.Interface && v.NumMethod() == 0 { v.Set(reflect.ValueOf(d.objectInterface())) return } // Check type of target: struct or map[string]T switch v.Kind() { case reflect.Map: // map must have string kind t := v.Type() if t.Key().Kind() != reflect.String { d.saveError(&UnmarshalTypeError{"object", v.Type()}) break } if v.IsNil() { v.Set(reflect.MakeMap(t)) } case reflect.Struct: // do nothing case reflect.Slice: // this is only a valid case if the output type is a bson.D t := v.Type() if t == orderedBSONType { v.Set(reflect.ValueOf(d.bsonDInterface())) return } fallthrough // can't unmarshal into a regular slice, goto "default" error case default: d.saveError(&UnmarshalTypeError{"object", v.Type()}) d.off-- d.next() // skip over { } in input return } var mapElem reflect.Value for { // Read opening " of string key or closing }. op := d.scanWhile(scanSkipSpace) if op == scanEndObject { // closing } - can only happen on first iteration. break } if op != scanBeginLiteral { d.error(errPhase) } // Read key. start := d.off - 1 op = d.scanWhile(scanContinue) item := d.data[start : d.off-1] key, ok := maybeUnquoteBytes(item) if !ok { d.error(errPhase) } // Figure out field corresponding to key. var subv reflect.Value destring := false // whether the value is wrapped in a string to be decoded first if v.Kind() == reflect.Map { elemType := v.Type().Elem() if !mapElem.IsValid() { mapElem = reflect.New(elemType).Elem() } else { mapElem.Set(reflect.Zero(elemType)) } subv = mapElem } else { var f *field fields := cachedTypeFields(v.Type()) for i := range fields { ff := &fields[i] if bytes.Equal(ff.nameBytes, key) { f = ff break } if f == nil && ff.equalFold(ff.nameBytes, key) { f = ff } } if f != nil { subv = v destring = f.quoted for _, i := range f.index { if subv.Kind() == reflect.Ptr { if subv.IsNil() { subv.Set(reflect.New(subv.Type().Elem())) } subv = subv.Elem() } subv = subv.Field(i) } } } // Read : before value. if op == scanSkipSpace { op = d.scanWhile(scanSkipSpace) } if op != scanObjectKey { d.error(errPhase) } // Read value. if destring { d.value(reflect.ValueOf(&d.tempstr)) d.literalStore([]byte(d.tempstr), subv, true) d.tempstr = "" // Zero scratch space for successive values. } else { d.value(subv) } // Write value back to map; // if using struct, subv points into struct already. if v.Kind() == reflect.Map { kv := reflect.ValueOf(key).Convert(v.Type().Key()) v.SetMapIndex(kv, subv) } // Next token must be , or }. op = d.scanWhile(scanSkipSpace) if op == scanEndObject { break } if op != scanObjectValue { d.error(errPhase) } } } // literal consumes a literal from d.data[d.off-1:], decoding into the value v. // The first byte of the literal has been read already // (that's how the caller knows it's a literal). func (d *decodeState) literal(v reflect.Value) { // All bytes inside literal return scanContinue op code. start := d.off - 1 op := d.scanWhile(scanContinue) // Scan read one byte too far; back up. d.off-- d.scan.undo(op) d.literalStore(d.data[start:d.off], v, false) } // convertNumber converts the number literal s to an int32, int64, a float64, // or a Number depending on the setting of d.useNumber and whether the // string is specified in hexadecimal. It does this by parsing the string to see if it // can an integer, if not it is treated as a float. If the integer is within the bounds of an int32 it // is returned as an int32. func (d *decodeState) convertNumber(s string) (interface{}, error) { if d.useNumber { return Number(s), nil } parsedInteger, err := strconv.ParseInt(s, 0, 64) if err != nil { parsedFloat, err := strconv.ParseFloat(s, 64) if err != nil { return nil, &UnmarshalTypeError{"number " + s, reflect.TypeOf(0.0)} } return parsedFloat, nil } if parsedInteger <= math.MaxInt32 && parsedInteger >= math.MinInt32 { return int32(parsedInteger), nil } return int64(parsedInteger), nil } var numberType = reflect.TypeOf(Number("")) // literalStore decodes a literal stored in item into v. // // fromQuoted indicates whether this literal came from unwrapping a // string from the ",string" struct tag option. this is used only to // produce more helpful error messages. func (d *decodeState) literalStore(item []byte, v reflect.Value, fromQuoted bool) { // Check for unmarshaler. if len(item) == 0 { // Empty string given d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type())) return } wantptr := isNull(item) // null u, ut, pv := d.indirect(v, wantptr) if u != nil { err := u.UnmarshalJSON(item) if err != nil { d.error(err) } return } if ut != nil { if item[0] != '"' { if fromQuoted { d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type())) } else { d.saveError(&UnmarshalTypeError{"string", v.Type()}) } } s, ok := unquoteBytes(item) if !ok { if fromQuoted { d.error(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type())) } else { d.error(errPhase) } } err := ut.UnmarshalText(s) if err != nil { d.error(err) } return } v = pv switch c := item[0]; { case isNull(item): // null switch v.Kind() { case reflect.Interface, reflect.Ptr, reflect.Map, reflect.Slice: v.Set(reflect.Zero(v.Type())) // otherwise, ignore null for primitives/string } case c == 't', c == 'f': // true, false value := c == 't' switch v.Kind() { default: if fromQuoted { d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type())) } else { d.saveError(&UnmarshalTypeError{"bool", v.Type()}) } case reflect.Bool: v.SetBool(value) case reflect.Interface: if v.NumMethod() == 0 { v.Set(reflect.ValueOf(value)) } else { d.saveError(&UnmarshalTypeError{"bool", v.Type()}) } } case c == '"', c == '\'': // string s, ok := unquoteBytes(item) if !ok { if fromQuoted { d.error(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type())) } else { d.error(errPhase) } } switch v.Kind() { default: d.saveError(&UnmarshalTypeError{"string", v.Type()}) case reflect.Slice: if v.Type() != byteSliceType { d.saveError(&UnmarshalTypeError{"string", v.Type()}) break } b := make([]byte, base64.StdEncoding.DecodedLen(len(s))) n, err := base64.StdEncoding.Decode(b, s) if err != nil { d.saveError(err) break } v.Set(reflect.ValueOf(b[0:n])) case reflect.String: v.SetString(string(s)) case reflect.Interface: if v.NumMethod() == 0 { v.Set(reflect.ValueOf(string(s))) } else { d.saveError(&UnmarshalTypeError{"string", v.Type()}) } } case isNumber(item): s := string(item) switch v.Kind() { default: if v.Kind() == reflect.String && v.Type() == numberType { v.SetString(s) break } if fromQuoted { d.error(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type())) } else { d.error(&UnmarshalTypeError{"number", v.Type()}) } case reflect.Interface: n, err := d.convertNumber(s) if err != nil { d.saveError(err) break } if v.NumMethod() != 0 { d.saveError(&UnmarshalTypeError{"number", v.Type()}) break } v.Set(reflect.ValueOf(n)) case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: base := 10 if isHexPrefix(s) { base = 0 // strconv.ParseInt will infer base 16 } n, err := strconv.ParseInt(s, base, 64) if err != nil || v.OverflowInt(n) { d.saveError(&UnmarshalTypeError{"number " + s, v.Type()}) break } v.SetInt(n) case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: base := 10 if isHexPrefix(s) { base = 0 // strconv.ParseUint will infer base 16 } n, err := strconv.ParseUint(s, base, 64) if err != nil || v.OverflowUint(n) { d.saveError(&UnmarshalTypeError{"number " + s, v.Type()}) break } v.SetUint(n) case reflect.Float32, reflect.Float64: n, err := strconv.ParseFloat(s, v.Type().Bits()) if err != nil || v.OverflowFloat(n) { d.saveError(&UnmarshalTypeError{"number " + s, v.Type()}) break } v.SetFloat(n) } default: if ok := d.storeExtendedLiteral(item, v, fromQuoted); !ok { if fromQuoted { d.error(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type())) } else { d.error(errPhase) } } } } // The xxxInterface routines build up a value to be stored // in an empty interface. They are not strictly necessary, // but they avoid the weight of reflection in this common case. // valueInterface is like value but returns interface{}. It takes a boolean // parameter denoting whether or not the value is being unmarshalled within // a bson.D, so that bson.Ds can be the default object type when // they are inside other bson.D documents. func (d *decodeState) valueInterface(insideBSOND bool) interface{} { switch d.scanWhile(scanSkipSpace) { default: d.error(errPhase) panic("unreachable") case scanBeginArray: return d.arrayInterface(insideBSOND) case scanBeginObject: if insideBSOND { return d.bsonDInterface() } return d.objectInterface() case scanBeginLiteral: return d.literalInterface() } } // arrayInterface is like array but returns []interface{}. It takes a boolean // parameter denoting whether or not the value is being unmarshalled within // a bson.D, so that bson.Ds can be the default object type when // they are inside other bson.D documents. func (d *decodeState) arrayInterface(insideBSOND bool) []interface{} { var v = make([]interface{}, 0) for { // Look ahead for ] - can only happen on first iteration. op := d.scanWhile(scanSkipSpace) if op == scanEndArray { break } // Back up so d.value can have the byte we just read. d.off-- d.scan.undo(op) v = append(v, d.valueInterface(insideBSOND)) // Next token must be , or ]. op = d.scanWhile(scanSkipSpace) if op == scanEndArray { break } if op != scanArrayValue { d.error(errPhase) } } return v } // bsonDInterface is like object but returns bson.D{}. func (d *decodeState) bsonDInterface() bson.D { m := bson.D{} for { // Read opening " of string key or closing }. op := d.scanWhile(scanSkipSpace) if op == scanEndObject { // closing } - can only happen on first iteration. break } if op != scanBeginLiteral { d.error(errPhase) } // Read string key. start := d.off - 1 op = d.scanWhile(scanContinue) item := d.data[start : d.off-1] key, ok := maybeUnquote(item) if !ok { d.error(errPhase) } // Read : before value. if op == scanSkipSpace { op = d.scanWhile(scanSkipSpace) } if op != scanObjectKey { d.error(errPhase) } // Read value. m = append(m, bson.DocElem{Name: key, Value: d.valueInterface(true)}) // Next token must be , or }. op = d.scanWhile(scanSkipSpace) if op == scanEndObject { break } if op != scanObjectValue { d.error(errPhase) } } return m } // objectInterface is like object but returns map[string]interface{}. func (d *decodeState) objectInterface() map[string]interface{} { m := make(map[string]interface{}) for { // Read opening " of string key or closing }. op := d.scanWhile(scanSkipSpace) if op == scanEndObject { // closing } - can only happen on first iteration. break } if op != scanBeginLiteral { d.error(errPhase) } // Read string key. start := d.off - 1 op = d.scanWhile(scanContinue) item := d.data[start : d.off-1] key, ok := maybeUnquote(item) if !ok { d.error(errPhase) } // Read : before value. if op == scanSkipSpace { op = d.scanWhile(scanSkipSpace) } if op != scanObjectKey { d.error(errPhase) } // Read value. m[key] = d.valueInterface(false) // Next token must be , or }. op = d.scanWhile(scanSkipSpace) if op == scanEndObject { break } if op != scanObjectValue { d.error(errPhase) } } return m } // literalInterface is like literal but returns an interface value. func (d *decodeState) literalInterface() interface{} { // All bytes inside literal return scanContinue op code. start := d.off - 1 op := d.scanWhile(scanContinue) // Scan read one byte too far; back up. d.off-- d.scan.undo(op) item := d.data[start:d.off] switch c := item[0]; { case isNull(item): // null return nil case c == 't', c == 'f': // true, false return c == 't' case c == '"', c == '\'': // string s, ok := unquote(item) if !ok { d.error(errPhase) } return s case isNumber(item): // number n, err := d.convertNumber(string(item)) if err != nil { d.saveError(err) } return n default: if value, ok := d.getExtendedLiteral(item); ok { return value } d.error(errPhase) panic("unreachable") } } // getu4 decodes \uXXXX from the beginning of s, returning the hex value, // or it returns -1. func getu4(s []byte) rune { if len(s) < 6 || s[0] != '\\' || s[1] != 'u' { return -1 } r, err := strconv.ParseUint(string(s[2:6]), 16, 64) if err != nil { return -1 } return rune(r) } // unquote converts a quoted JSON string literal s into an actual string t. // The rules are different than for Go, so cannot use strconv.Unquote. func unquote(s []byte) (t string, ok bool) { s, ok = unquoteBytes(s) t = string(s) return } // unquote converts a quoted JSON string literal s into an actual string t. // The rules are different than for Go, so cannot use strconv.Unquote. func maybeUnquote(s []byte) (t string, ok bool) { s, ok = maybeUnquoteBytes(s) t = string(s) return } func unquoteBytes(s []byte) (t []byte, ok bool) { if len(s) < 2 || s[0] != '"' && s[0] != '\'' || s[len(s)-1] != '"' && s[len(s)-1] != '\'' { return } singleQuoted := s[0] == '\'' s = s[1 : len(s)-1] // Check for unusual characters. If there are none, // then no unquoting is needed, so return a slice of the // original bytes. r := 0 for r < len(s) { c := s[r] if c == '\\' || c == '"' || c == '\'' || c < ' ' { break } if c < utf8.RuneSelf { r++ continue } rr, size := utf8.DecodeRune(s[r:]) if rr == utf8.RuneError && size == 1 { break } r += size } if r == len(s) { return s, true } b := make([]byte, len(s)+2*utf8.UTFMax) w := copy(b, s[0:r]) for r < len(s) { // Out of room? Can only happen if s is full of // malformed UTF-8 and we're replacing each // byte with RuneError. if w >= len(b)-2*utf8.UTFMax { nb := make([]byte, (len(b)+utf8.UTFMax)*2) copy(nb, b[0:w]) b = nb } switch c := s[r]; { case c == '\\': r++ if r >= len(s) { return } switch s[r] { default: return case '"', '\\', '/', '\'': b[w] = s[r] r++ w++ case 'b': b[w] = '\b' r++ w++ case 'f': b[w] = '\f' r++ w++ case 'n': b[w] = '\n' r++ w++ case 'r': b[w] = '\r' r++ w++ case 't': b[w] = '\t' r++ w++ case 'u': r-- rr := getu4(s[r:]) if rr < 0 { return } r += 6 if utf16.IsSurrogate(rr) { rr1 := getu4(s[r:]) if dec := utf16.DecodeRune(rr, rr1); dec != unicode.ReplacementChar { // A valid pair; consume. r += 6 w += utf8.EncodeRune(b[w:], dec) break } // Invalid surrogate; fall back to replacement rune. rr = unicode.ReplacementChar } w += utf8.EncodeRune(b[w:], rr) } // Double quote, control characters are invalid. case !singleQuoted && c == '"', c < ' ': return // Single quote characters are invalid. case singleQuoted && c == '\'': return // ASCII case c < utf8.RuneSelf: b[w] = c r++ w++ // Coerce to well-formed UTF-8. default: rr, size := utf8.DecodeRune(s[r:]) r += size w += utf8.EncodeRune(b[w:], rr) } } return b[0:w], true } mongo-tools-r3.6.3/common/json/decode_d_test.go000066400000000000000000000100721321131462300215330ustar00rootroot00000000000000// Copyright (C) MongoDB, Inc. 2014-present. // // 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 package json import ( "fmt" . "github.com/smartystreets/goconvey/convey" "gopkg.in/mgo.v2/bson" "testing" ) func TestDecodeBsonD(t *testing.T) { Convey("When unmarshalling JSON into a bson.D", t, func() { Convey("a document should be stored with keys in the same order", func() { data := `{"a":1, "b":2, "c":3, "d":4, "e":5, "f":6}` out := bson.D{} err := Unmarshal([]byte(data), &out) So(err, ShouldBeNil) So(len(out), ShouldEqual, 6) So(out[0].Name, ShouldEqual, "a") So(out[1].Name, ShouldEqual, "b") So(out[2].Name, ShouldEqual, "c") So(out[3].Name, ShouldEqual, "d") So(out[4].Name, ShouldEqual, "e") So(out[5].Name, ShouldEqual, "f") }) Convey("a nested bson.D should be parsed", func() { data := `{"a": 17, "b":{"foo":"bar", "baz":"boo"}, c:"wow" }` out := struct { A int `json:"a"` B bson.D `json:"b"` C string `json:"c"` }{} err := Unmarshal([]byte(data), &out) So(err, ShouldBeNil) So(out.A, ShouldEqual, 17) So(out.C, ShouldEqual, "wow") So(len(out.B), ShouldEqual, 2) So(out.B[0].Name, ShouldEqual, "foo") So(out.B[0].Value, ShouldEqual, "bar") So(out.B[1].Name, ShouldEqual, "baz") So(out.B[1].Value, ShouldEqual, "boo") }) Convey("objects nested within DocElems should still be parsed", func() { data := `{"a":["x", "y","z"], "b":{"foo":"bar", "baz":"boo"}}` out := bson.D{} err := Unmarshal([]byte(data), &out) So(err, ShouldBeNil) So(len(out), ShouldEqual, 2) So(out[0].Name, ShouldEqual, "a") So(out[1].Name, ShouldEqual, "b") So(out[0].Value, ShouldResemble, []interface{}{"x", "y", "z"}) So(out[1].Value, ShouldResemble, bson.D{{"foo", "bar"}, {"baz", "boo"}}) }) Convey("only subdocuments inside a bson.D should be parsed into a bson.D", func() { data := `{subA: {a:{b:{c:9}}}, subB:{a:{b:{c:9}}}}` out := struct { A interface{} `json:"subA"` B bson.D `json:"subB"` }{} err := Unmarshal([]byte(data), &out) So(err, ShouldBeNil) aMap := out.A.(map[string]interface{}) So(len(aMap), ShouldEqual, 1) aMapSub := aMap["a"].(map[string]interface{}) So(len(aMapSub), ShouldEqual, 1) aMapSubSub := aMapSub["b"].(map[string]interface{}) So(aMapSubSub["c"], ShouldEqual, 9) So(len(out.B), ShouldEqual, 1) // using string comparison for simplicity c := bson.D{{Name: "c", Value: 9}} b := bson.D{{Name: "b", Value: c}} a := bson.D{{Name: "a", Value: b}} So(fmt.Sprintf("%v", out.B), ShouldEqual, fmt.Sprintf("%v", a)) }) Convey("subdocuments inside arrays inside bson.D should be parsed into a bson.D", func() { data := `{"a":[1,2,{b:"inner"}]}` out := bson.D{} err := Unmarshal([]byte(data), &out) So(err, ShouldBeNil) So(len(out), ShouldEqual, 1) So(out[0].Value, ShouldHaveSameTypeAs, []interface{}{}) innerArray := out[0].Value.([]interface{}) So(len(innerArray), ShouldEqual, 3) So(innerArray[0], ShouldEqual, 1) So(innerArray[1], ShouldEqual, 2) So(innerArray[2], ShouldHaveSameTypeAs, bson.D{}) innerD := innerArray[2].(bson.D) So(len(innerD), ShouldEqual, 1) So(innerD[0].Name, ShouldEqual, "b") So(innerD[0].Value, ShouldEqual, "inner") }) Convey("null should be a valid value", func() { data := `{"a":true, "b":null, "c": 5}` out := bson.D{} err := Unmarshal([]byte(data), &out) So(err, ShouldBeNil) So(len(out), ShouldEqual, 3) So(out[0].Name, ShouldEqual, "a") So(out[0].Value, ShouldEqual, true) So(out[1].Name, ShouldEqual, "b") So(out[1].Value, ShouldBeNil) So(out[2].Name, ShouldEqual, "c") So(out[2].Value, ShouldEqual, 5) }) }) Convey("Unmarshalling to a non-bson.D slice types should fail", t, func() { data := `{"a":["x", "y","z"], "b":{"foo":"bar", "baz":"boo"}}` out := []interface{}{} err := Unmarshal([]byte(data), &out) So(err, ShouldNotBeNil) }) } mongo-tools-r3.6.3/common/json/decode_test.go000066400000000000000000000751201321131462300212350ustar00rootroot00000000000000// Copyright (C) MongoDB, Inc. 2014-present. // // 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 // // Based on github.com/golang/go by The Go Authors // See THIRD-PARTY-NOTICES for original license terms. package json import ( "bytes" "encoding" "fmt" "image" "reflect" "strings" "testing" "time" ) type T struct { X string Y int Z int `json:"-"` } type U struct { Alphabet string `json:"alpha"` } type V struct { F1 interface{} F2 int32 F3 Number } // ifaceNumAsFloat64/ifaceNumAsNumber are used to test unmarshaling with and // without UseNumber var ifaceNumAsFloat64 = map[string]interface{}{ "k1": float64(1), "k2": "s", "k3": []interface{}{float64(1), float64(2.0), float64(3e-3)}, "k4": map[string]interface{}{"kk1": "s", "kk2": float64(2)}, } // ifaceNumAsMixedTypes is used to test unmarshalling with extended JSON var ifaceNumAsMixedTypes = map[string]interface{}{ "k1": int32(1), "k2": "s", "k3": []interface{}{int32(1), int32(2), float64(3e-3)}, "k4": map[string]interface{}{"kk1": "s", "kk2": int32(2)}, } var ifaceNumAsNumber = map[string]interface{}{ "k1": Number("1"), "k2": "s", "k3": []interface{}{Number("1"), Number("2.0"), Number("3e-3")}, "k4": map[string]interface{}{"kk1": "s", "kk2": Number("2")}, } type tx struct { x int } // A type that can unmarshal itself. type unmarshaler struct { T bool } func (u *unmarshaler) UnmarshalJSON(b []byte) error { *u = unmarshaler{true} // All we need to see that UnmarshalJSON is called. return nil } type ustruct struct { M unmarshaler } type unmarshalerText struct { T bool } // needed for re-marshaling tests func (u *unmarshalerText) MarshalText() ([]byte, error) { return []byte(""), nil } func (u *unmarshalerText) UnmarshalText(b []byte) error { *u = unmarshalerText{true} // All we need to see that UnmarshalText is called. return nil } var _ encoding.TextUnmarshaler = (*unmarshalerText)(nil) type ustructText struct { M unmarshalerText } var ( um0, um1 unmarshaler // target2 of unmarshaling ump = &um1 umtrue = unmarshaler{true} umslice = []unmarshaler{{true}} umslicep = new([]unmarshaler) umstruct = ustruct{unmarshaler{true}} um0T, um1T unmarshalerText // target2 of unmarshaling umpT = &um1T umtrueT = unmarshalerText{true} umsliceT = []unmarshalerText{{true}} umslicepT = new([]unmarshalerText) umstructT = ustructText{unmarshalerText{true}} ) // Test data structures for anonymous fields. type Point struct { Z int } type Top struct { Level0 int Embed0 *Embed0a *Embed0b `json:"e,omitempty"` // treated as named Embed0c `json:"-"` // ignored Loop Embed0p // has Point with X, Y, used Embed0q // has Point with Z, used } type Embed0 struct { Level1a int // overridden by Embed0a's Level1a with json tag Level1b int // used because Embed0a's Level1b is renamed Level1c int // used because Embed0a's Level1c is ignored Level1d int // annihilated by Embed0a's Level1d Level1e int `json:"x"` // annihilated by Embed0a.Level1e } type Embed0a struct { Level1a int `json:"Level1a,omitempty"` Level1b int `json:"LEVEL1B,omitempty"` Level1c int `json:"-"` Level1d int // annihilated by Embed0's Level1d Level1f int `json:"x"` // annihilated by Embed0's Level1e } type Embed0b Embed0 type Embed0c Embed0 type Embed0p struct { image.Point } type Embed0q struct { Point } type Loop struct { Loop1 int `json:",omitempty"` Loop2 int `json:",omitempty"` *Loop } // From reflect test: // The X in S6 and S7 annihilate, but they also block the X in S8.S9. type S5 struct { S6 S7 S8 } type S6 struct { X int } type S7 S6 type S8 struct { S9 } type S9 struct { X int Y int } // From reflect test: // The X in S11.S6 and S12.S6 annihilate, but they also block the X in S13.S8.S9. type S10 struct { S11 S12 S13 } type S11 struct { S6 } type S12 struct { S6 } type S13 struct { S8 } type unmarshalTest struct { in string ptr interface{} out interface{} err error useNumber bool } type Ambig struct { // Given "hello", the first match should win. First int `json:"HELLO"` Second int `json:"Hello"` } type XYZ struct { X interface{} Y interface{} Z interface{} } var unmarshalTests = []unmarshalTest{ // basic types {in: `true`, ptr: new(bool), out: true}, {in: `1`, ptr: new(int), out: 1}, {in: `1.2`, ptr: new(float64), out: 1.2}, {in: `-5`, ptr: new(int16), out: int16(-5)}, {in: `2`, ptr: new(Number), out: Number("2"), useNumber: true}, {in: `2`, ptr: new(Number), out: Number("2")}, {in: `2`, ptr: new(interface{}), out: int32(2)}, {in: `2`, ptr: new(interface{}), out: Number("2"), useNumber: true}, {in: `"a\u1234"`, ptr: new(string), out: "a\u1234"}, {in: `"http:\/\/"`, ptr: new(string), out: "http://"}, {in: `"g-clef: \uD834\uDD1E"`, ptr: new(string), out: "g-clef: \U0001D11E"}, {in: `"invalid: \uD834x\uDD1E"`, ptr: new(string), out: "invalid: \uFFFDx\uFFFD"}, {in: "null", ptr: new(interface{}), out: nil}, {in: `{"X": [1,2,3], "Y": 4}`, ptr: new(T), out: T{Y: 4}, err: &UnmarshalTypeError{"array", reflect.TypeOf("")}}, {in: `{"x": 1}`, ptr: new(tx), out: tx{}}, {in: `{"F1":1,"F2":2,"F3":3}`, ptr: new(V), out: V{F1: int32(1), F2: int32(2), F3: Number("3")}}, {in: `{"F1":1,"F2":2,"F3":3}`, ptr: new(V), out: V{F1: Number("1"), F2: int32(2), F3: Number("3")}, useNumber: true}, {in: `{"k1":1,"k2":"s","k3":[1,2,3e-3],"k4":{"kk1":"s","kk2":2}}`, ptr: new(interface{}), out: ifaceNumAsMixedTypes}, {in: `{"k1":1,"k2":"s","k3":[1,2.0,3e-3],"k4":{"kk1":"s","kk2":2}}`, ptr: new(interface{}), out: ifaceNumAsNumber, useNumber: true}, // raw values with whitespace {in: "\n true ", ptr: new(bool), out: true}, {in: "\t 1 ", ptr: new(int), out: 1}, {in: "\r 1.2 ", ptr: new(float64), out: 1.2}, {in: "\t -5 \n", ptr: new(int16), out: int16(-5)}, {in: "\t \"a\\u1234\" \n", ptr: new(string), out: "a\u1234"}, // Z has a "-" tag. {in: `{"Y": 1, "Z": 2}`, ptr: new(T), out: T{Y: 1}}, {in: `{"alpha": "abc", "alphabet": "xyz"}`, ptr: new(U), out: U{Alphabet: "abc"}}, {in: `{"alpha": "abc"}`, ptr: new(U), out: U{Alphabet: "abc"}}, {in: `{"alphabet": "xyz"}`, ptr: new(U), out: U{}}, // syntax errors {in: `{"X": "foo", "Y"}`, err: &SyntaxError{"invalid character '}' after object key", 17}}, {in: `[1, 2, 3+]`, err: &SyntaxError{"invalid character '+' after array element", 9}}, {in: `{"X":12x}`, err: &SyntaxError{"invalid character 'x' after object key:value pair", 8}, useNumber: true}, // raw value errors {in: "\x01 42", err: &SyntaxError{"invalid character '\\x01' looking for beginning of value", 1}}, {in: " 42 \x01", err: &SyntaxError{"invalid character '\\x01' after top-level value", 5}}, {in: "\x01 true", err: &SyntaxError{"invalid character '\\x01' looking for beginning of value", 1}}, {in: " false \x01", err: &SyntaxError{"invalid character '\\x01' after top-level value", 8}}, {in: "\x01 1.2", err: &SyntaxError{"invalid character '\\x01' looking for beginning of value", 1}}, {in: " 3.4 \x01", err: &SyntaxError{"invalid character '\\x01' after top-level value", 6}}, {in: "\x01 \"string\"", err: &SyntaxError{"invalid character '\\x01' looking for beginning of value", 1}}, {in: " \"string\" \x01", err: &SyntaxError{"invalid character '\\x01' after top-level value", 11}}, // array tests {in: `[1, 2, 3]`, ptr: new([3]int), out: [3]int{1, 2, 3}}, {in: `[1, 2, 3]`, ptr: new([1]int), out: [1]int{1}}, {in: `[1, 2, 3]`, ptr: new([5]int), out: [5]int{1, 2, 3, 0, 0}}, // empty array to interface test {in: `[]`, ptr: new([]interface{}), out: []interface{}{}}, {in: `null`, ptr: new([]interface{}), out: []interface{}(nil)}, {in: `{"T":[]}`, ptr: new(map[string]interface{}), out: map[string]interface{}{"T": []interface{}{}}}, {in: `{"T":null}`, ptr: new(map[string]interface{}), out: map[string]interface{}{"T": interface{}(nil)}}, // composite tests {in: allValueIndent, ptr: new(All), out: allValue}, {in: allValueCompact, ptr: new(All), out: allValue}, {in: allValueIndent, ptr: new(*All), out: &allValue}, {in: allValueCompact, ptr: new(*All), out: &allValue}, {in: pallValueIndent, ptr: new(All), out: pallValue}, {in: pallValueCompact, ptr: new(All), out: pallValue}, {in: pallValueIndent, ptr: new(*All), out: &pallValue}, {in: pallValueCompact, ptr: new(*All), out: &pallValue}, // unmarshal interface test {in: `{"T":false}`, ptr: &um0, out: umtrue}, // use "false" so test will fail if custom unmarshaler is not called {in: `{"T":false}`, ptr: &ump, out: &umtrue}, {in: `[{"T":false}]`, ptr: &umslice, out: umslice}, {in: `[{"T":false}]`, ptr: &umslicep, out: &umslice}, {in: `{"M":{"T":false}}`, ptr: &umstruct, out: umstruct}, // UnmarshalText interface test {in: `"X"`, ptr: &um0T, out: umtrueT}, // use "false" so test will fail if custom unmarshaler is not called {in: `"X"`, ptr: &umpT, out: &umtrueT}, {in: `["X"]`, ptr: &umsliceT, out: umsliceT}, {in: `["X"]`, ptr: &umslicepT, out: &umsliceT}, {in: `{"M":"X"}`, ptr: &umstructT, out: umstructT}, { in: `{ "Level0": 1, "Level1b": 2, "Level1c": 3, "x": 4, "Level1a": 5, "LEVEL1B": 6, "e": { "Level1a": 8, "Level1b": 9, "Level1c": 10, "Level1d": 11, "x": 12 }, "Loop1": 13, "Loop2": 14, "X": 15, "Y": 16, "Z": 17 }`, ptr: new(Top), out: Top{ Level0: 1, Embed0: Embed0{ Level1b: 2, Level1c: 3, }, Embed0a: &Embed0a{ Level1a: 5, Level1b: 6, }, Embed0b: &Embed0b{ Level1a: 8, Level1b: 9, Level1c: 10, Level1d: 11, Level1e: 12, }, Loop: Loop{ Loop1: 13, Loop2: 14, }, Embed0p: Embed0p{ Point: image.Point{X: 15, Y: 16}, }, Embed0q: Embed0q{ Point: Point{Z: 17}, }, }, }, { in: `{"hello": 1}`, ptr: new(Ambig), out: Ambig{First: 1}, }, { in: `{"X": 1,"Y":2}`, ptr: new(S5), out: S5{S8: S8{S9: S9{Y: 2}}}, }, { in: `{"X": 1,"Y":2}`, ptr: new(S10), out: S10{S13: S13{S8: S8{S9: S9{Y: 2}}}}, }, // invalid UTF-8 is coerced to valid UTF-8. { in: "\"hello\xffworld\"", ptr: new(string), out: "hello\ufffdworld", }, { in: "\"hello\xc2\xc2world\"", ptr: new(string), out: "hello\ufffd\ufffdworld", }, { in: "\"hello\xc2\xffworld\"", ptr: new(string), out: "hello\ufffd\ufffdworld", }, { in: "\"hello\\ud800world\"", ptr: new(string), out: "hello\ufffdworld", }, { in: "\"hello\\ud800\\ud800world\"", ptr: new(string), out: "hello\ufffd\ufffdworld", }, { in: "\"hello\\ud800\\ud800world\"", ptr: new(string), out: "hello\ufffd\ufffdworld", }, { in: "\"hello\xed\xa0\x80\xed\xb0\x80world\"", ptr: new(string), out: "hello\ufffd\ufffd\ufffd\ufffd\ufffd\ufffdworld", }, } func TestMarshal(t *testing.T) { b, err := Marshal(allValue) if err != nil { t.Fatalf("Marshal allValue: %v", err) } if string(b) != allValueCompact { t.Errorf("Marshal allValueCompact") diff(t, b, []byte(allValueCompact)) return } b, err = Marshal(pallValue) if err != nil { t.Fatalf("Marshal pallValue: %v", err) } if string(b) != pallValueCompact { t.Errorf("Marshal pallValueCompact") diff(t, b, []byte(pallValueCompact)) return } } var badUTF8 = []struct { in, out string }{ {"hello\xffworld", `"hello\ufffdworld"`}, {"", `""`}, {"\xff", `"\ufffd"`}, {"\xff\xff", `"\ufffd\ufffd"`}, {"a\xffb", `"a\ufffdb"`}, {"\xe6\x97\xa5\xe6\x9c\xac\xff\xaa\x9e", `"日本\ufffd\ufffd\ufffd"`}, } func TestMarshalBadUTF8(t *testing.T) { for _, tt := range badUTF8 { b, err := Marshal(tt.in) if string(b) != tt.out || err != nil { t.Errorf("Marshal(%q) = %#q, %v, want %#q, nil", tt.in, b, err, tt.out) } } } func TestMarshalNumberZeroVal(t *testing.T) { var n Number out, err := Marshal(n) if err != nil { t.Fatal(err) } outStr := string(out) if outStr != "0" { t.Fatalf("Invalid zero val for Number: %q", outStr) } } func TestMarshalEmbeds(t *testing.T) { top := &Top{ Level0: 1, Embed0: Embed0{ Level1b: 2, Level1c: 3, }, Embed0a: &Embed0a{ Level1a: 5, Level1b: 6, }, Embed0b: &Embed0b{ Level1a: 8, Level1b: 9, Level1c: 10, Level1d: 11, Level1e: 12, }, Loop: Loop{ Loop1: 13, Loop2: 14, }, Embed0p: Embed0p{ Point: image.Point{X: 15, Y: 16}, }, Embed0q: Embed0q{ Point: Point{Z: 17}, }, } b, err := Marshal(top) if err != nil { t.Fatal(err) } want := "{\"Level0\":1,\"Level1b\":2,\"Level1c\":3,\"Level1a\":5,\"LEVEL1B\":6,\"e\":{\"Level1a\":8,\"Level1b\":9,\"Level1c\":10,\"Level1d\":11,\"x\":12},\"Loop1\":13,\"Loop2\":14,\"X\":15,\"Y\":16,\"Z\":17}" if string(b) != want { t.Errorf("Wrong marshal result.\n got: %q\nwant: %q", b, want) } } func TestUnmarshal(t *testing.T) { for i, tt := range unmarshalTests { var scan scanner in := []byte(tt.in) if err := checkValid(in, &scan); err != nil { if !reflect.DeepEqual(err, tt.err) { t.Errorf("#%d: checkValid: %#v", i, err) continue } } if tt.ptr == nil { continue } // v = new(right-type) v := reflect.New(reflect.TypeOf(tt.ptr).Elem()) dec := NewDecoder(bytes.NewReader(in)) if tt.useNumber { dec.UseNumber() } if err := dec.Decode(v.Interface()); !reflect.DeepEqual(err, tt.err) { t.Errorf("#%d: %v want %v", i, err, tt.err) continue } if !reflect.DeepEqual(v.Elem().Interface(), tt.out) { t.Errorf("#%d: mismatch\nhave: %#+v\nwant: %#+v", i, v.Elem().Interface(), tt.out) data, _ := Marshal(v.Elem().Interface()) println(string(data)) data, _ = Marshal(tt.out) println(string(data)) continue } // Check round trip. if tt.err == nil { enc, err := Marshal(v.Interface()) if err != nil { t.Errorf("#%d: error re-marshaling: %v", i, err) continue } vv := reflect.New(reflect.TypeOf(tt.ptr).Elem()) dec = NewDecoder(bytes.NewReader(enc)) if tt.useNumber { dec.UseNumber() } if err := dec.Decode(vv.Interface()); err != nil { t.Errorf("#%d: error re-unmarshaling %#q: %v", i, enc, err) continue } if !reflect.DeepEqual(v.Elem().Interface(), vv.Elem().Interface()) { t.Errorf("#%d: mismatch\nhave: %#+v\nwant: %#+v", i, v.Elem().Interface(), vv.Elem().Interface()) t.Errorf(" In: %q", strings.Map(noSpace, string(in))) t.Errorf("Marshal: %q", strings.Map(noSpace, string(enc))) continue } } } } func TestUnmarshalMarshal(t *testing.T) { initBig() var v interface{} if err := Unmarshal(jsonBig, &v); err != nil { t.Fatalf("Unmarshal: %v", err) } b, err := Marshal(v) if err != nil { t.Fatalf("Marshal: %v", err) } if !bytes.Equal(jsonBig, b) { t.Errorf("Marshal jsonBig") diff(t, b, jsonBig) return } } var numberTests = []struct { in string i int64 intErr string f float64 floatErr string }{ {in: "-1.23e1", intErr: "strconv.ParseInt: parsing \"-1.23e1\": invalid syntax", f: -1.23e1}, {in: "-12", i: -12, f: -12.0}, {in: "1e1000", intErr: "strconv.ParseInt: parsing \"1e1000\": invalid syntax", floatErr: "strconv.ParseFloat: parsing \"1e1000\": value out of range"}, } // Independent of Decode, basic coverage of the accessors in Number func TestNumberAccessors(t *testing.T) { for _, tt := range numberTests { n := Number(tt.in) if s := n.String(); s != tt.in { t.Errorf("Number(%q).String() is %q", tt.in, s) } if i, err := n.Int64(); err == nil && tt.intErr == "" && i != tt.i { t.Errorf("Number(%q).Int64() is %d", tt.in, i) } else if (err == nil && tt.intErr != "") || (err != nil && err.Error() != tt.intErr) { t.Errorf("Number(%q).Int64() wanted error %q but got: %v", tt.in, tt.intErr, err) } if f, err := n.Float64(); err == nil && tt.floatErr == "" && f != tt.f { t.Errorf("Number(%q).Float64() is %g", tt.in, f) } else if (err == nil && tt.floatErr != "") || (err != nil && err.Error() != tt.floatErr) { t.Errorf("Number(%q).Float64() wanted error %q but got: %v", tt.in, tt.floatErr, err) } } } func TestLargeByteSlice(t *testing.T) { s0 := make([]byte, 2000) for i := range s0 { s0[i] = byte(i) } b, err := Marshal(s0) if err != nil { t.Fatalf("Marshal: %v", err) } var s1 []byte if err := Unmarshal(b, &s1); err != nil { t.Fatalf("Unmarshal: %v", err) } if !bytes.Equal(s0, s1) { t.Errorf("Marshal large byte slice") diff(t, s0, s1) } } type Xint struct { X int } func TestUnmarshalInterface(t *testing.T) { var xint Xint var i interface{} = &xint if err := Unmarshal([]byte(`{"X":1}`), &i); err != nil { t.Fatalf("Unmarshal: %v", err) } if xint.X != 1 { t.Fatalf("Did not write to xint") } } func TestUnmarshalPtrPtr(t *testing.T) { var xint Xint pxint := &xint if err := Unmarshal([]byte(`{"X":1}`), &pxint); err != nil { t.Fatalf("Unmarshal: %v", err) } if xint.X != 1 { t.Fatalf("Did not write to xint") } } func TestEscape(t *testing.T) { const input = `"foobar"` + " [\u2028 \u2029]" const expected = `"\"foobar\"\u003chtml\u003e [\u2028 \u2029]"` b, err := Marshal(input) if err != nil { t.Fatalf("Marshal error: %v", err) } if s := string(b); s != expected { t.Errorf("Encoding of [%s]:\n got [%s]\nwant [%s]", input, s, expected) } } // WrongString is a struct that's misusing the ,string modifier. type WrongString struct { Message string `json:"result,string"` } type wrongStringTest struct { in, err string } var wrongStringTests = []wrongStringTest{ {`{"result":"x"}`, `json: invalid use of ,string struct tag, trying to unmarshal "x" into string`}, {`{"result":"foo"}`, `json: invalid use of ,string struct tag, trying to unmarshal "foo" into string`}, {`{"result":"123"}`, `json: invalid use of ,string struct tag, trying to unmarshal "123" into string`}, } // If people misuse the ,string modifier, the error message should be // helpful, telling the user that they're doing it wrong. func TestErrorMessageFromMisusedString(t *testing.T) { for n, tt := range wrongStringTests { r := strings.NewReader(tt.in) var s WrongString err := NewDecoder(r).Decode(&s) got := fmt.Sprintf("%v", err) if got != tt.err { t.Errorf("%d. got err = %q, want %q", n, got, tt.err) } } } func noSpace(c rune) rune { if isSpace(c) { return -1 } return c } type All struct { Bool bool Int int Int8 int8 Int16 int16 Int32 int32 Int64 int64 Uint uint Uint8 uint8 Uint16 uint16 Uint32 uint32 Uint64 uint64 Uintptr uintptr Float32 float32 Float64 float64 Foo string `json:"bar"` Foo2 string `json:"bar2,dummyopt"` IntStr int64 `json:",string"` PBool *bool PInt *int PInt8 *int8 PInt16 *int16 PInt32 *int32 PInt64 *int64 PUint *uint PUint8 *uint8 PUint16 *uint16 PUint32 *uint32 PUint64 *uint64 PUintptr *uintptr PFloat32 *float32 PFloat64 *float64 String string PString *string Map map[string]Small MapP map[string]*Small PMap *map[string]Small PMapP *map[string]*Small EmptyMap map[string]Small NilMap map[string]Small Slice []Small SliceP []*Small PSlice *[]Small PSliceP *[]*Small EmptySlice []Small NilSlice []Small StringSlice []string ByteSlice []byte Small Small PSmall *Small PPSmall **Small Interface interface{} PInterface *interface{} unexported int } type Small struct { Tag string } var allValue = All{ Bool: true, Int: 2, Int8: 3, Int16: 4, Int32: 5, Int64: 6, Uint: 7, Uint8: 8, Uint16: 9, Uint32: 10, Uint64: 11, Uintptr: 12, Float32: 14.1, Float64: 15.1, Foo: "foo", Foo2: "foo2", IntStr: 42, String: "16", Map: map[string]Small{ "17": {Tag: "tag17"}, "18": {Tag: "tag18"}, }, MapP: map[string]*Small{ "19": {Tag: "tag19"}, "20": nil, }, EmptyMap: map[string]Small{}, Slice: []Small{{Tag: "tag20"}, {Tag: "tag21"}}, SliceP: []*Small{{Tag: "tag22"}, nil, {Tag: "tag23"}}, EmptySlice: []Small{}, StringSlice: []string{"str24", "str25", "str26"}, ByteSlice: []byte{27, 28, 29}, Small: Small{Tag: "tag30"}, PSmall: &Small{Tag: "tag31"}, Interface: 5.2, } var pallValue = All{ PBool: &allValue.Bool, PInt: &allValue.Int, PInt8: &allValue.Int8, PInt16: &allValue.Int16, PInt32: &allValue.Int32, PInt64: &allValue.Int64, PUint: &allValue.Uint, PUint8: &allValue.Uint8, PUint16: &allValue.Uint16, PUint32: &allValue.Uint32, PUint64: &allValue.Uint64, PUintptr: &allValue.Uintptr, PFloat32: &allValue.Float32, PFloat64: &allValue.Float64, PString: &allValue.String, PMap: &allValue.Map, PMapP: &allValue.MapP, PSlice: &allValue.Slice, PSliceP: &allValue.SliceP, PPSmall: &allValue.PSmall, PInterface: &allValue.Interface, } var allValueIndent = `{ "Bool": true, "Int": 2, "Int8": 3, "Int16": 4, "Int32": 5, "Int64": 6, "Uint": 7, "Uint8": 8, "Uint16": 9, "Uint32": 10, "Uint64": 11, "Uintptr": 12, "Float32": 14.1, "Float64": 15.1, "bar": "foo", "bar2": "foo2", "IntStr": "42", "PBool": null, "PInt": null, "PInt8": null, "PInt16": null, "PInt32": null, "PInt64": null, "PUint": null, "PUint8": null, "PUint16": null, "PUint32": null, "PUint64": null, "PUintptr": null, "PFloat32": null, "PFloat64": null, "String": "16", "PString": null, "Map": { "17": { "Tag": "tag17" }, "18": { "Tag": "tag18" } }, "MapP": { "19": { "Tag": "tag19" }, "20": null }, "PMap": null, "PMapP": null, "EmptyMap": {}, "NilMap": null, "Slice": [ { "Tag": "tag20" }, { "Tag": "tag21" } ], "SliceP": [ { "Tag": "tag22" }, null, { "Tag": "tag23" } ], "PSlice": null, "PSliceP": null, "EmptySlice": [], "NilSlice": null, "StringSlice": [ "str24", "str25", "str26" ], "ByteSlice": "Gxwd", "Small": { "Tag": "tag30" }, "PSmall": { "Tag": "tag31" }, "PPSmall": null, "Interface": 5.2, "PInterface": null }` var allValueCompact = strings.Map(noSpace, allValueIndent) var pallValueIndent = `{ "Bool": false, "Int": 0, "Int8": 0, "Int16": 0, "Int32": 0, "Int64": 0, "Uint": 0, "Uint8": 0, "Uint16": 0, "Uint32": 0, "Uint64": 0, "Uintptr": 0, "Float32": 0, "Float64": 0, "bar": "", "bar2": "", "IntStr": "0", "PBool": true, "PInt": 2, "PInt8": 3, "PInt16": 4, "PInt32": 5, "PInt64": 6, "PUint": 7, "PUint8": 8, "PUint16": 9, "PUint32": 10, "PUint64": 11, "PUintptr": 12, "PFloat32": 14.1, "PFloat64": 15.1, "String": "", "PString": "16", "Map": null, "MapP": null, "PMap": { "17": { "Tag": "tag17" }, "18": { "Tag": "tag18" } }, "PMapP": { "19": { "Tag": "tag19" }, "20": null }, "EmptyMap": null, "NilMap": null, "Slice": null, "SliceP": null, "PSlice": [ { "Tag": "tag20" }, { "Tag": "tag21" } ], "PSliceP": [ { "Tag": "tag22" }, null, { "Tag": "tag23" } ], "EmptySlice": null, "NilSlice": null, "StringSlice": null, "ByteSlice": null, "Small": { "Tag": "" }, "PSmall": null, "PPSmall": { "Tag": "tag31" }, "Interface": null, "PInterface": 5.2 }` var pallValueCompact = strings.Map(noSpace, pallValueIndent) func TestRefUnmarshal(t *testing.T) { type S struct { // Ref is defined in encode_test.go. R0 Ref R1 *Ref R2 RefText R3 *RefText } want := S{ R0: 12, R1: new(Ref), R2: 13, R3: new(RefText), } *want.R1 = 12 *want.R3 = 13 var got S if err := Unmarshal([]byte(`{"R0":"ref","R1":"ref","R2":"ref","R3":"ref"}`), &got); err != nil { t.Fatalf("Unmarshal: %v", err) } if !reflect.DeepEqual(got, want) { t.Errorf("got %+v, want %+v", got, want) } } // Test that the empty string doesn't panic decoding when ,string is specified // Issue 3450 func TestEmptyString(t *testing.T) { type T2 struct { Number1 int `json:",string"` Number2 int `json:",string"` } data := `{"Number1":"1", "Number2":""}` dec := NewDecoder(strings.NewReader(data)) var t2 T2 err := dec.Decode(&t2) if err == nil { t.Fatal("Decode: did not return error") } if t2.Number1 != 1 { t.Fatal("Decode: did not set Number1") } } // Test that the returned error is non-nil when trying to unmarshal null string into int, for successive ,string option // Issue 7046 func TestNullString(t *testing.T) { type T struct { A int `json:",string"` B int `json:",string"` } data := []byte(`{"A": "1", "B": null}`) var s T err := Unmarshal(data, &s) if err == nil { t.Fatalf("expected error; got %v", s) } } func intp(x int) *int { p := new(int) *p = x return p } func intpp(x *int) **int { pp := new(*int) *pp = x return pp } var interfaceSetTests = []struct { pre interface{} json string post interface{} }{ {"foo", `"bar"`, "bar"}, {"foo", `2`, int32(2)}, {"foo", `true`, true}, {"foo", `null`, nil}, {nil, `null`, nil}, {new(int), `null`, nil}, {(*int)(nil), `null`, nil}, {new(*int), `null`, new(*int)}, {(**int)(nil), `null`, nil}, {intp(1), `null`, nil}, {intpp(nil), `null`, intpp(nil)}, {intpp(intp(1)), `null`, intpp(nil)}, } func TestInterfaceSet(t *testing.T) { for _, tt := range interfaceSetTests { b := struct{ X interface{} }{tt.pre} blob := `{"X":` + tt.json + `}` if err := Unmarshal([]byte(blob), &b); err != nil { t.Errorf("Unmarshal %#q: %v", blob, err) continue } if !reflect.DeepEqual(b.X, tt.post) { t.Errorf("Unmarshal %#q into %#v: X=%#v, want %#v", blob, tt.pre, b.X, tt.post) } } } // JSON null values should be ignored for primitives and string values instead of resulting in an error. // Issue 2540 func TestUnmarshalNulls(t *testing.T) { jsonData := []byte(`{ "Bool" : null, "Int" : null, "Int8" : null, "Int16" : null, "Int32" : null, "Int64" : null, "Uint" : null, "Uint8" : null, "Uint16" : null, "Uint32" : null, "Uint64" : null, "Float32" : null, "Float64" : null, "String" : null}`) nulls := All{ Bool: true, Int: 2, Int8: 3, Int16: 4, Int32: 5, Int64: 6, Uint: 7, Uint8: 8, Uint16: 9, Uint32: 10, Uint64: 11, Float32: 12.1, Float64: 13.1, String: "14"} err := Unmarshal(jsonData, &nulls) if err != nil { t.Errorf("Unmarshal of null values failed: %v", err) } if !nulls.Bool || nulls.Int != 2 || nulls.Int8 != 3 || nulls.Int16 != 4 || nulls.Int32 != 5 || nulls.Int64 != 6 || nulls.Uint != 7 || nulls.Uint8 != 8 || nulls.Uint16 != 9 || nulls.Uint32 != 10 || nulls.Uint64 != 11 || nulls.Float32 != 12.1 || nulls.Float64 != 13.1 || nulls.String != "14" { t.Errorf("Unmarshal of null values affected primitives") } } func TestStringKind(t *testing.T) { type stringKind string var m1, m2 map[stringKind]int m1 = map[stringKind]int{ "foo": 42, } data, err := Marshal(m1) if err != nil { t.Errorf("Unexpected error marshalling: %v", err) } err = Unmarshal(data, &m2) if err != nil { t.Errorf("Unexpected error unmarshalling: %v", err) } if !reflect.DeepEqual(m1, m2) { t.Error("Items should be equal after encoding and then decoding") } } var decodeTypeErrorTests = []struct { dest interface{} src string }{ {new(string), `{"user": "name"}`}, // issue 4628. {new(error), `{}`}, // issue 4222 {new(error), `[]`}, {new(error), `""`}, {new(error), `123`}, {new(error), `true`}, } func TestUnmarshalTypeError(t *testing.T) { for _, item := range decodeTypeErrorTests { err := Unmarshal([]byte(item.src), item.dest) if _, ok := err.(*UnmarshalTypeError); !ok { t.Errorf("expected type error for Unmarshal(%q, type %T): got %T", item.src, item.dest, err) } } } var unmarshalSyntaxTests = []string{ "tru", "fals", "nul", "123e", `"hello`, `[1,2,3`, `{"key":1`, `{"key":1,`, } func TestUnmarshalSyntax(t *testing.T) { var x interface{} for _, src := range unmarshalSyntaxTests { err := Unmarshal([]byte(src), &x) if _, ok := err.(*SyntaxError); !ok { t.Errorf("expected syntax error for Unmarshal(%q): got %T", src, err) } } } // Test handling of unexported fields that should be ignored. // Issue 4660 type unexportedFields struct { Name string m map[string]interface{} m2 map[string]interface{} } func TestUnmarshalUnexported(t *testing.T) { input := `{"Name": "Bob", "m": {"x": 123}, "m2": {"y": 456}, "abcd": {"z": 789}}` want := &unexportedFields{Name: "Bob"} out := &unexportedFields{} err := Unmarshal([]byte(input), out) if err != nil { t.Errorf("got error %v, expected nil", err) } if !reflect.DeepEqual(out, want) { t.Errorf("got %q, want %q", out, want) } } // Time3339 is a time.Time which encodes to and from JSON // as an RFC 3339 time in UTC. type Time3339 time.Time func (t *Time3339) UnmarshalJSON(b []byte) error { if len(b) < 2 || b[0] != '"' || b[len(b)-1] != '"' { return fmt.Errorf("types: failed to unmarshal non-string value %q as an RFC 3339 time", b) } tm, err := time.Parse(time.RFC3339, string(b[1:len(b)-1])) if err != nil { return err } *t = Time3339(tm) return nil } func TestUnmarshalJSONLiteralError(t *testing.T) { var t3 Time3339 err := Unmarshal([]byte(`"0000-00-00T00:00:00Z"`), &t3) if err == nil { t.Fatalf("expected error; got time %v", time.Time(t3)) } if !strings.Contains(err.Error(), "range") { t.Errorf("got err = %v; want out of range error", err) } } // Test that extra object elements in an array do not result in a // "data changing underfoot" error. // Issue 3717 func TestSkipArrayObjects(t *testing.T) { json := `[{}]` var dest [0]interface{} err := Unmarshal([]byte(json), &dest) if err != nil { t.Errorf("got error %q, want nil", err) } } // Test semantics of pre-filled struct fields and pre-filled map fields. // Issue 4900. func TestPrefilled(t *testing.T) { ptrToMap := func(m map[string]interface{}) *map[string]interface{} { return &m } // Values here change, cannot reuse table across runs. var prefillTests = []struct { in string ptr interface{} out interface{} }{ { in: `{"X": 1, "Y": 2}`, ptr: &XYZ{X: float32(3), Y: int16(4), Z: 1.5}, out: &XYZ{X: int32(1), Y: int32(2), Z: 1.5}, }, { in: `{"X": 1, "Y": 2}`, ptr: ptrToMap(map[string]interface{}{"X": float32(3), "Y": int16(4), "Z": 1.5}), out: ptrToMap(map[string]interface{}{"X": int32(1), "Y": int32(2), "Z": 1.5}), }, } for _, tt := range prefillTests { ptrstr := fmt.Sprintf("%v", tt.ptr) err := Unmarshal([]byte(tt.in), tt.ptr) // tt.ptr edited here if err != nil { t.Errorf("Unmarshal: %v", err) } if !reflect.DeepEqual(tt.ptr, tt.out) { t.Errorf("Unmarshal(%#q, %s): have %v, want %v", tt.in, ptrstr, tt.ptr, tt.out) } } } var invalidUnmarshalTests = []struct { v interface{} want string }{ {nil, "json: Unmarshal(nil)"}, {struct{}{}, "json: Unmarshal(non-pointer struct {})"}, {(*int)(nil), "json: Unmarshal(nil *int)"}, } func TestInvalidUnmarshal(t *testing.T) { buf := []byte(`{"a":"1"}`) for _, tt := range invalidUnmarshalTests { err := Unmarshal(buf, tt.v) if err == nil { t.Errorf("Unmarshal expecting error, got nil") continue } if got := err.Error(); got != tt.want { t.Errorf("Unmarshal = %q; want %q", got, tt.want) } } } mongo-tools-r3.6.3/common/json/encode.go000066400000000000000000000745101321131462300202120ustar00rootroot00000000000000// Copyright (C) MongoDB, Inc. 2014-present. // // 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 // // Based on github.com/golang/go by The Go Authors // See THIRD-PARTY-NOTICES for original license terms. // Package json implements encoding and decoding of JSON objects as defined in // RFC 4627. The mapping between JSON objects and Go values is described // in the documentation for the Marshal and Unmarshal functions. // // See "JSON and Go" for an introduction to this package: // http://golang.org/doc/articles/json_and_go.html package json import ( "bytes" "encoding" "encoding/base64" "math" "reflect" "runtime" "sort" "strconv" "strings" "sync" "unicode" "unicode/utf8" ) // Marshal returns the JSON encoding of v. // // Marshal traverses the value v recursively. // If an encountered value implements the Marshaler interface // and is not a nil pointer, Marshal calls its MarshalJSON method // to produce JSON. The nil pointer exception is not strictly necessary // but mimics a similar, necessary exception in the behavior of // UnmarshalJSON. // // Otherwise, Marshal uses the following type-dependent default encodings: // // Boolean values encode as JSON booleans. // // Floating point, integer, and Number values encode as JSON numbers. // // String values encode as JSON strings. InvalidUTF8Error will be returned // if an invalid UTF-8 sequence is encountered. // The angle brackets "<" and ">" are escaped to "\u003c" and "\u003e" // to keep some browsers from misinterpreting JSON output as HTML. // Ampersand "&" is also escaped to "\u0026" for the same reason. // // Array and slice values encode as JSON arrays, except that // []byte encodes as a base64-encoded string, and a nil slice // encodes as the null JSON object. // // Struct values encode as JSON objects. Each exported struct field // becomes a member of the object unless // - the field's tag is "-", or // - the field is empty and its tag specifies the "omitempty" option. // The empty values are false, 0, any // nil pointer or interface value, and any array, slice, map, or string of // length zero. The object's default key string is the struct field name // but can be specified in the struct field's tag value. The "json" key in // the struct field's tag value is the key name, followed by an optional comma // and options. Examples: // // // Field is ignored by this package. // Field int `json:"-"` // // // Field appears in JSON as key "myName". // Field int `json:"myName"` // // // Field appears in JSON as key "myName" and // // the field is omitted from the object if its value is empty, // // as defined above. // Field int `json:"myName,omitempty"` // // // Field appears in JSON as key "Field" (the default), but // // the field is skipped if empty. // // Note the leading comma. // Field int `json:",omitempty"` // // The "string" option signals that a field is stored as JSON inside a // JSON-encoded string. It applies only to fields of string, floating point, // or integer types. This extra level of encoding is sometimes used when // communicating with JavaScript programs: // // Int64String int64 `json:",string"` // // The key name will be used if it's a non-empty string consisting of // only Unicode letters, digits, dollar signs, percent signs, hyphens, // underscores and slashes. // // Anonymous struct fields are usually marshaled as if their inner exported fields // were fields in the outer struct, subject to the usual Go visibility rules amended // as described in the next paragraph. // An anonymous struct field with a name given in its JSON tag is treated as // having that name, rather than being anonymous. // // The Go visibility rules for struct fields are amended for JSON when // deciding which field to marshal or unmarshal. If there are // multiple fields at the same level, and that level is the least // nested (and would therefore be the nesting level selected by the // usual Go rules), the following extra rules apply: // // 1) Of those fields, if any are JSON-tagged, only tagged fields are considered, // even if there are multiple untagged fields that would otherwise conflict. // 2) If there is exactly one field (tagged or not according to the first rule), that is selected. // 3) Otherwise there are multiple fields, and all are ignored; no error occurs. // // Handling of anonymous struct fields is new in Go 1.1. // Prior to Go 1.1, anonymous struct fields were ignored. To force ignoring of // an anonymous struct field in both current and earlier versions, give the field // a JSON tag of "-". // // Map values encode as JSON objects. // The map's key type must be string; the object keys are used directly // as map keys. // // Pointer values encode as the value pointed to. // A nil pointer encodes as the null JSON object. // // Interface values encode as the value contained in the interface. // A nil interface value encodes as the null JSON object. // // Channel, complex, and function values cannot be encoded in JSON. // Attempting to encode such a value causes Marshal to return // an UnsupportedTypeError. // // JSON cannot represent cyclic data structures and Marshal does not // handle them. Passing cyclic structures to Marshal will result in // an infinite recursion. // func Marshal(v interface{}) ([]byte, error) { e := &encodeState{} err := e.marshal(v) if err != nil { return nil, err } return e.Bytes(), nil } // MarshalIndent is like Marshal but applies Indent to format the output. func MarshalIndent(v interface{}, prefix, indent string) ([]byte, error) { b, err := Marshal(v) if err != nil { return nil, err } var buf bytes.Buffer err = Indent(&buf, b, prefix, indent) if err != nil { return nil, err } return buf.Bytes(), nil } // HTMLEscape appends to dst the JSON-encoded src with <, >, &, U+2028 and U+2029 // characters inside string literals changed to \u003c, \u003e, \u0026, \u2028, \u2029 // so that the JSON will be safe to embed inside HTML RSS Feed - Atom Feed

Warning: this comic occasionally contains strong language (which may be unsuitable for children), unusual humor (which may be unsuitable for adults), and advanced mathematics (which may be unsuitable for liberal-arts majors).

We did not invent the algorithm. The algorithm consistently finds Jesus. The algorithm killed Jeeves.
The algorithm is banned in China. The algorithm is from Jersey. The algorithm constantly finds Jesus.
This is not the algorithm. This is close.
@3p%kjRÀ¨tPÀñ´#ÆÉmý€6™Œ W£ëÜg> This work is licensed under a Creative Commons Attribution-NonCommercial 2.5 License.

This means you're free to copy and share these comics (but not to sell them). More details.

6ÔéP+ BBÀÁÀFº X°5|cWE4#µ@@šÀ¨tkjRÀPÆÉmýñµ € ² ëÜ«W£6ÔéP, BBÀÁÀFº X°5|cWE4 @@š¯À¨tkjRÀPÆÉmýñµ €  > ëÜ«W£6ÔéPN BBX°5|cWÀÁÀFº E 4>Ž@3q¡kjRÀ¨tPÀñµ ÆÉmþ€6¿õ W£0ëÜ«6ÔéPŽN BBÀÁÀFº X°5|cWE4Bû@@`TÀ¨tkjRÀPÆÉmþñµ¡€ Ÿá ëÜõW£0mongo-tools-r3.6.3/vendor/src/github.com/google/gopacket/pcap/test_loopback.pcap000066400000000000000000001623331321131462300300030ustar00rootroot00000000000000Ôò¡ÿÿزéP±200`@寗f efï€(é  ÀŒüÀ8ŒGET /pkg/github.com/gconnell/gopacket/ HTTP/1.1 Host: localhost:8080 Connection: keep-alive Cache-Control: max-age=0 User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_8_2) AppleWebKit/537.11 (KHTML, like Gecko) Chrome/23.0.1271.101 Safari/537.11 Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8 Referer: http://localhost:8080/pkg/ Accept-Encoding: gzip,deflate,sdch Accept-Language: en-US,en;q=0.8 Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.3 زéPê2LL`ˆ‘ @å¯ efï—J€#( ÀŒüÀŒüزéP^ LL`ˆ‘ @å¯ efï—J€#( À¶ÀŒüHTTP/1.1 200 OK Date: Sun, 06 Jan 2013 17:22:32 GMT Transfer-Encoding: chunked Content-Type: text/html; charset=utf-8 200 gopacket - The Go Programming Language
58

10 Package gopacket 6

1 2 17 1 ce94
import "github.com/gconnell/gopacket"
Overview
Index
Subdirectories

Overview â–¾

Package gopacket provides packet decoding for the Go language.

gopacket contains 3 sub-packages with additional functionality you may find useful: 

* layers: You'll probably use this every time.  This contains of the logic
    built into gopacket for decoding packet protocols.  Note that all example
    code below assumes that you have imported both gopacket and
    gopacket/layers.
* pcap: C bindings to use libpcap to pull packets off the wire.
* pfring: C bindings to use PF_RING to pull packets off the wire.

Basic Usage

gopacket takes in packet data as a []byte and decodes it into a packet with a non-zero number of "layers". Each layer corresponds to a protocol within the bytes. Once a packet has been decoded, the layers of the packet can be requested from the packet. 

// Decode a packet
packet := gopacket.NewPacket(myPacketData, layers.LayerTypeEthernet, gopacket.Default)
// Get the TCP layer from this packet
if tcpLayer := packet.Layer(layers.LayerTypeTCP); tcpLayer != nil {
  fmt.Println("This is a TCP packet!")
  // Get actual TCP data from this layer
  tcp, _ := tcpLayer.(*layers.TCP)
  fmt.Printf("From src port %d to dst port %d\n", tcp.SrcPort, tcp.DstPort)
}
// Iterate over all layers, printing out each layer type
for layer := range packet.Layers() {
  fmt.Println("PACKET LAYER:", layer.LayerType())
}

Packets can be decoded from a number of starting points. Many of our base types implement Decoder, which allow us to decode packets for which we don't have full data. 

// Decode an ethernet packet
ethP := gopacket.NewPacket(p1, layers.LayerTypeEthernet, gopacket.Default)
// Decode an IPv6 header and everything it contains
ipP := gopacket.NewPacket(p2, layers.LayerTypeIPv6, gopacket.Default)
// Decode a TCP header and its payload
tcpP := gopacket.NewPacket(p3, layers.LayerTypeTCP, gopacketزéP€@@`ˆ‘?Ø@å¯
evï—J€#?à
À¶ÀŒü.Default)

Reading Packets From A Source

Most of the time, you won't just have a []byte of packet data lying around. Instead, you'll want to read packets in from somewhere (file, interface, etc) and process them. To do that, you'll want to build a PacketSource.

First, you'll need to construct an object that implements the PacketDataSource interface. There are implementations of this interface bundled with gopacket in the gopacket/pcap and gopacket/pfring subpackages... see their documentation for more information on their usage. Once you have a PacketDataSource, you can pass it into NewPacketSource, along with a Decoder of your choice, to create a PacketSource.

Once you have a PacketSource, you can read packets from it in multiple ways. See the docs for PacketSource for more details. The easiest method is the Packets function, which returns a channel, then asynchronously writes new packets into that channel, closing the channel if the packetSource hits an end-of-file. 

packetSource := ...  // construct using pcap or pfring
for packet := range packetSource.Packets() {
  handlePacket(packet)  // do something with each packet
}

You can change the decoding options of the packetSource by setting fields in packetSource.DecodeOptions... see the following sections for more details.

Lazy Decoding

gopacket optionally decodes packet data lazily, meaning it only decodes a packet layer when it needs to to handle a function call. 

// Create a packet, but don't actually decode anything yet
packet := gopacket.NewPacket(myPacketData, layers.LayerTypeEthernet, gopacket.Lazy)
// Now, decode the packet up to the first IPv4 layer found but no further.
// If no IPv4 layer was found, the whole packet will be decoded looking for
// it.
ip4 := packet.Layer(layers.LayerTypeIPv4)
// Decode all layers and return them.  The layers up to the first IPv4 layer
// are already decoded, and will not require decoding a second time.
layers := packet.Layers()

Lazily-decoded packets are not concurrency-safe. Since layers have not all been decoded, each call to Layer() or Layers() has the potential to mutate the packet in order to decode the next layer. If a packet is used in multiple goroutines concurrently, don't use gopacket.Lazy. Then gopacket will decode the packet fully, and all future function calls won't mutate the object.

NoCopy Decoding

By default, gopacket will copy the slice passed to NewPacket and store the copy within the packet, so future mutations to the bytes underlying the slice don't affect the packet and its layers. If you can guarantee that the underlying slice bytes won't be changed, you can use NoCopy to tell gopacket.NewPacket, and it'll use the passed-in slice itself. 

// This channel returns new byte slices, each of which points to a new
// memory location that's guaranteed immutable for the duration of the
// packet.
for data := range myByteSliceChannel {
  p := gopacket.NewPacket(data, layers.LayerTypeEthernet, gopacket.NoCopy)
  doSomethingWithPacket(p)
}

The fastest method of decoding is to use both Lazy and NoCopy, but note from the many caveats above that for some implementations they may be dangerous either or both may be dangerous.

Pointers To Known Layers

During decoding, certain layers are stored in the packet as well-known layer types. For example, IPv4 and IPv6 are both considered NetworkLayer layers, while TCP and UDP are both TransportLayer layers. We support 4 layers, corresponding to the 4 layers of the TCP/IP layering scheme (roughly anagalous to layers 2, 3, 4, and 7 of the OSI model). To access these, you can use the packet.LinkLayer, packet.NetworkLayer, packet.TransportLayer, and packet.ApplicationLayer functions. Each of these functions returns a corresponding interface (gopacket.{Link,Network,Transport,Application}Layer). The first three provide methods for getting src/dst addresses for that particular layer, while the final layer provides a Payload function to get payload data. This is helpful, for example, to get payloads for all packets regardless of their underlying data type: 

// Get packets from some source
for packet := range someSource {
  if app := packet.ApplicationLayer(); app != nil {
    if strings.Contains(string(app.Payload()), "magic string") {
      fmt.Println("Found magic string in a packet!")
    }
  }
}

A particularly useful layer is ErrorLayer, which is set whenever there's an error parsing part of the packet. 

packet := gopacket.NewPacket(myPacketData, layers.LayerTypeEthernet, gopacket.Default)
if err := packet.ErrorLayer(); err != nil {
  fmt.Println("Error decoding some part of the packet:", err)
}

Note that we don't return an error from NewPacket because we may have decoded a number of layers successfully before running into our erroneous layer. You may still be able to get your Ethernet and IPv4 layers correctly, even if your TCP layer is malformed.

Flow And Endpoint

gopacket has two useful objects, Flow and Endpoint, for communicating in a protocol independent manner the fact that a packet is coming from A and going to B. The general layer types LinkLayer, NetworkLayer, and TransportLayer all provide methods for extracting their flow information, without worrying about the type of the underlying Layer.

A Flow is a simple object made up of a set of two Endpoints, one source and one destination. It details the sender and receiver of the Layer of the Packet.

An Endpoint is a hashable representation of a source or destination. For example, for LayerTypeIPv4, an Endpoint contains the IP address bytes for a v4 IP packet. A Flow can be broken into Endpoints, and Endpoints can be combined into Flows: 

packet := gopacket.NewPacket(myPacketData, layers.LayerTypeEthernet, gopacket.Lazy)
netFlow := packet.NetworkLayer().NetworkFlow()
src, dst := netFlow.Endpoints()
reverseFlow := gopacket.NewFlow(dst, src)

Both Endpoint and Flow objects can be used as map keys, and the equality operator can compare them, so you can easily group together all packets based on endpoint criteria: 

flows := map[gopacket.Endpoint]chan gopacket.Packet
packet := gopacket.NewPacket(myPacketData, layers.LayerTypeEthernet, gopacket.Lazy)
// Send all TCP packets to channels based on their destination port.
if tcp := packet.Layer(layers.LayerTypeTCP); tcp != nil {
  flows[tcp.TransportFlow().Dst()] <- packet
}
// Look for all packets with the same source and destination network address
if net := packet.NetworkLayer(); net != nil {
  src, dst := net.NetworkFlow().Endpoints()
  if src == dst {
    fmt.Println("Fishy packet has same network source and dst: %s", src)
  }
}
// Find all packets coming from UDP port 1000 to UDP port 500
interestingFlow := gopacket.NewFlow(layers.NewUDPPortEndpoint(1000), layers.NewUDPPortEndpoint(500))
if t := packet.NetworkLayer(); t != nil && t.TransportFlow() == interestingFlow {
  fmt.Println("Found that UDP flow I was looking for!")
}

Implementing Your Own Decoder

If your network has some strange encapsulation, you can implement your own decoder. In this example, we handle Ethernet packets which are encapsulated in a 4-byte header. 

// Create a layer type, should be unique and high, so it doesn't conflict,
// giving it a name and a decoder to use.
var MyLayerType = gopacket.RegisterLayerType(12345, "MyLayerType", gopacket.DecodeFunc(decodeMyLayer))

// Implement my layer
type MyLayer struct {
  StrangeHeader []byte
  payload []byte
}
func (m MyLayer) LayerType() LayerType { return MyLayerType }
func (m MyLayer) LayerContents() []byte { return m.StrangeHeader }
func (m MyLayer) LayerPayload() []byte { return m.payload }

// Now implement a decoder... this one strips off the first 4 bytes of the
// packet.
func decodeMyLayer(data []byte, p gopacket.PacketBuilder) error {
  // Create my layer
  p.AddLayer(&MyLayer{data[:4], data[4:]})
  // Determine how to handle the rest of the packet
  return p.NextDecoder(layers.LayerTypeEthernet)
}

// Finally, decode your packets:
p := gopacket.NewPacket(data, MyLayerType, gopacket.Lazy)

See the docs for Decoder and PacketBuilder for more details on how coding decoders works, or look at RegisterLayerType and RegisterEndpointType to see how to add layer/endpoint types to gopacket.

Index

Variables
type ApplicationLayer
type CaptureInfo
type DecodeFailure
    func (d *DecodeFailure) Error() error
    func (d *DecodeFailure) LayerContents() []byte
    func (d *DecodeFailure) LayerPayload() []byte
    func (d *DecodeFailure) LayerType() LayerType
    func (d *DecodeFailure) String() string
type DecodeFunc
    func (d DecodeFunc) Decode(data []byte, p PacketBuilder) error
type DecodeOptions
type Decoder
type Endpoint
    func NewEndpoint(typ EndpointType, raw []byte) Endpoint
    func (e Endpoint) EndpointType() EndpointType
    func (a Endpoint) LessThan(b Endpoint) bool
    func (e Endpoint) Raw() []byte
    func (e Endpoint) String() string
type EndpointType
    func RegisterEndpointType(num int, meta EndpointTypeMetadata) EndpointType
    func (e EndpointType) String() string
type EndpointTypeMetadata
type ErrorLayer
type Flow
    func FlowFromEndpoints(src, dst Endpoint) (_ Flow, err error)
    func NewFlow(t EndpointType, src, dst []byte) Flow
    func (f Flow) Dst() (dst Endpoint)
    func (f Flow) EndpointType() EndpointType
    func (f Flow) Endpoints() (src, dst Endpoint)
    func (f Flow) Reverse() Flow
    func (f Flow) Src() (src Endpoint)
    func (f Flow) String() string
type Layer
type LayerClass
    func NewLayerClass(types []LayerType) LayerClass
type LayerClassMap
    func NewLayerClassMap(types []LayerType) LayerClassMap
    func (m LayerClassMap) Contains(t LayerType) bool
type LayerClassSlice
    func NewLayerClassSlice(types []LayerType) LayerClassSlice
    func (s LayerClassSlice) Contains(t LayerType) bool
type LayerType
    func RegisterLayerType(num int, meta LayerTypeMetadata) LayerType
    func (t LayerType) Decode(data []byte, c PacketBuilder) error
    func (t LayerType) String() (s string)
type LayerTypeMetadata
type LinkLayer
type NetworkLayer
type Packet
    func NewPacket(data []byte, firstLayerDecoder Decoder, options DecodeOptions) Packet
type PacketBuilder
type PacketDataSource
type PacketSource
    func NewPacketSource(source PacketDataSource, decoder Decoder) *PacketSource
    func (p *PacketSource) NextPacket() (Packet, error)
    func (p *PacketSource) Packets() chan Packet
type Payload
    func (p *Payload) LayerContents() []byte
    func (p *Payload) LayerPayload() []byte
    func (p *Payload) LayerType() LayerType
    func (p *Payload) Payload() []byte
    func (p *Payload) String() string
type TransportLayer

Package files

base.go decode.go doc.go flows.go layerclass.go layertype.go packet.go valid_mac_prefixes.go

Variables

var ValidMACPrefixMap = validMACPrefixMap

ValidMACPrefixMap maps a valid MAC address prefix to the name of the organization that owns the rights to use it. We map it to a hidden variable so it won't show up in godoc, since it's a very large map.

type ApplicationLayer

type ApplicationLayer interface {
    Layer
    Payload() []byte
}

ApplicationLayer is the packet layer corresponding to the TCP/IP layer 4 (OSI layer 7), also known as the packet payload.

type CaptureInfo

type CaptureInfo struct {
    // Populated is set to true if the rest of the CaptureInfo has been populated
    // with actual information.  If Populated is false, there's no point in
    // reading any of the other fields.
    Populated             bool
    Timestamp             time.Time
    CaptureLength, Length int
}

CaptureInfo contains capture metadata for a packet. If a packet was captured off the wire or read from a pcap file (see the 'pcap' subdirectory), this information will be attached to the packet.

type DecodeFailure

type DecodeFailure struct {
    // contains filtered or unexported fields
}

DecodeFailure is a packet layer created if decoding of the packet data failed for some reason. It implements ErrorLayer. LayerContents will be the entire set of bytes that failed to parse, and Error will return the reason parsing failed.

func (*DecodeFailure) Error

func (d *DecodeFailure) Error() error

Error returns the error encountered during decoding.

func (*DecodeFailure) LayerContents

func (d *DecodeFailure) LayerContents() []byte

func (*DecodeFailure) LayerPayload

func (d *DecodeFailure) LayerPayload() []byte

func (*DecodeFailure) LayerType

func (d *DecodeFailure) LayerType() LayerType

LayerType returns LayerTypeDecodeFailure

func (*DecodeFailure) String

func (d *DecodeFailure) String() string

type DecodeFunc

type DecodeFunc func([]byte, PacketBuilder) error

DecodeFunc wraps a function to make it a Decoder.

func (DecodeFunc) Decode

func (d DecodeFunc) Decode(data []byte, p PacketBuilder) error

type DecodeOptions

type DecodeOptions struct {
    // Lazy decoding decodes the minimum number of layers needed to return data
    // for a packet at each function call.  Be careful using this with concurrent
    // packet processors, as each call to packet.* could mutate the packet, and
    // two concurrent function calls could interact poorly.
    Lazy bool
    // NoCopy decoding doesn't copy its input buffer into storage that's owned by
    // the packet.  If you can guarantee that the bytes underlying the slice
    // passed into NewPacket aren't going to be modified, this can be faster.  If
    // there's any chance that those bytes WILL be changed, this will invalidate
    // your packets.
    NoCopy bool
}

DecodeOptions tells gopacket how to decode a packet. 

var Default DecodeOptions = DecodeOptions{}

Default decoding provides the safest (but slowest) method for decoding packets. It eagerly processes all layers (so it's concurrency-safe) and it copies its input buffer upon creation of the packet (so the packet remains valid if the underlying slice is modified. Both of these take time, though, so beware. If you can guarantee that the packet will only be used by one goroutine at a time, set Lazy decoding. If you can guarantee that the underlying slice won't change, set NoCopy decoding. 

var Lazy DecodeOptions = DecodeOptions{Lazy: true}

Lazy is a DecodeOptions with just Lazy set. 

var NoCopy DecodeOptions = DecodeOptions{NoCopy: true}

NoCopy is a DecodeOptions with just NoCopy set.

type Decoder

type Decoder interface {
    // Decode decodes the bytes of a packet, sending decoded values and other
    // information to PacketBuilder, and returning an error if unsuccessful.  See
    // the PacketBuilder documentation for more details.
    Decode([]byte, PacketBuilder) error
}

Decoder is an interface for logic to decode a packet layer. Users may implement a Decoder to handle their own strange packet types, or may use one of the many decoders available in the 'layers' subpackage to decode things for them. 

var DecodePayload Decoder = DecodeFunc(decodePayload)

DecodePayload is a Decoder that returns a Payload layer containing all remaining bytes. 

var DecodeUnknown Decoder = DecodeFunc(decodeUnknown)

DecodeUnknown is a Decoder that returns a DecodeFailure layer containing all remaining bytes, useful if you run up against a layer that you're unable to decode yet.

type Endpoint

type Endpoint struct {
    // contains filtered or unexported fields
}

Endpoint is the set of bytes used to address packets at various layers. See LinkLayer, NetworkLayer, and TransportLayer specifications. Endpoints are usable as map keys.

func NewEndpoint

func NewEndpoint(typ EndpointType, raw []byte) Endpoint

NewEndpoint creates a new Endpoint object.

func (Endpoint) EndpointType

func (e Endpoint) EndpointType() EndpointType

EndpointType returns the endpoint type associated with this endpoint.

func (Endpoint) LessThan

func (a Endpoint) LessThan(b Endpoint) bool

LessThan provides a stable ordering for all endpoints. It sorts first based on the EndpointType of an endpoint, then based on the raw bytes of that endpoint. For some endpoints, the actual comparison may not make sense, however this ordering does provide useful information for most Endpoint types.

func (Endpoint) Raw

func (e Endpoint) Raw() []byte

Raw returns the raw bytes of this endpoint. These aren't human-readable most of the time, but they are faster than calling String.

func (Endpoint) String

func (e Endpoint) String() string

type EndpointType

type EndpointType int64

EndpointType is the type of a gopacket Endpoint. This type determines how the bytes stored in the endpoint should be interpreted.

func RegisterEndpointType

func RegisterEndpointType(num int, meta EndpointTypeMetadata) EndpointType

RegisterEndpointType creates a new EndpointType and registers it globally. It MUST be passed a unique number, or it will panic. Numbers 0-999 are reserved for gopacket's use.

func (EndpointType) String

func (e EndpointType) String() string

type EndpointTypeMetadata

type EndpointTypeMetadata struct {
    // Name is the string returned by an EndpointType's String function.
    Name string
    // Formatter is called from an Endpoint's String function to format the raw
    // bytes in an Endpoint into a human-readable string.
    Formatter func([]byte) string
}

EndpointTypeMetadata is used to register a new endpoint type.

type ErrorLayer

type ErrorLayer interface {
    Layer
    Error() error
}

ErrorLayer is a packet layer created when decoding of the packet has failed. Its payload is all the bytes that we were unable to decode, and the returned error details why the decoding failed.

type Flow

type Flow struct {
    // contains filtered or unexported fields
}

Flow represents the direction of traffic for a packet layer, as a source and destination Endpoint. Flows are usable as map keys.

func FlowFromEndpoints

func FlowFromEndpoints(src, dst Endpoint) (_ Flow, err error)

FlowFromEndpoints creates a new flow by pasting together two endpoints. The endpoints must have the same EndpointType, or this function will return an error.

func NewFlow

func NewFlow(t EndpointType, src, dst []byte) Flow

NewFlow creates a new flow.

func (Flow) Dst

func (f Flow) Dst() (dst Endpoint)

Dst returns the destination Endpoint for this flow.

func (Flow) EndpointType

func (f Flow) EndpointType() EndpointType

EndpointType returns the EndpointType for this Flow.

func (Flow) Endpoints

func (f Flow) Endpoints() (src, dst Endpoint)

Endpoints returns the two Endpoints for this flow.

func (Flow) Reverse

func (f Flow) Reverse() Flow

Reverse returns a new flow with endpoints reversed.

func (Flow) Src

func (f Flow) Src() (src Endpoint)

Src returns the source Endpoint for this flow.

func (Flow) String

func (f Flow) String() string

String returns a human-readable representation of this flow, in the form "Src->Dst"

type Layer

type Layer interface {
    fmt.Stringer
    // LayerType is the gopacket type for this layer.
    LayerType() LayerType
    // LayerContents returns the set of bytes that make up this layer.
    LayerContents() []byte
    // LayerPayload returns the set of bytes contained within this layer, not
    // including the layer itself.
    LayerPayload() []byte
}

Layer represents a single decoded packet layer (using either the OSI or TCP/IP definition of a layer). When decoding, a packet's data is broken up into a number of layers. The caller may call LayerType() to figure out which type of layer he's received from the packet. Optionally, he may then use a type assertion to get the actual layer type for deep inspection of the data.

type LayerClass

type LayerClass interface {
    // Contains returns true if the given layer type should be considered part
    // of this layer class.
    Contains(LayerType) bool
}

LayerClass is a set of LayerTypes, used for grabbing one of a number of different types from a packet.

func NewLayerClass

func NewLayerClass(types []LayerType) LayerClass

NewLayerClass creates a LayerClass, attempting to be smart about which type it creates based on which types are passed in.

type LayerClassMap

type LayerClassMap map[LayerType]bool

LayerClassMap implements a LayerClass with a map.

func NewLayerClassMap

<زéP @@`ˆ‘?Ø@å¯ eö_—J€#?à À¶ÀŒüpre>func NewLayerClassMap(types []LayerType) LayerClassMap

NewLayerClassMap creates a LayerClassMap and sets map[t] to true for each type in types.

func (LayerClassMap) Contains

func (m LayerClassMap) Contains(t LayerType) bool

Contains returns true if the given layer type should be considered part of this layer class.

type LayerClassSlice

type LayerClassSlice []bool

LayerClassSlice implements a LayerClass with a slice.

func NewLayerClassSlice

func NewLayerClassSlice(types []LayerType) LayerClassSlice

NewLayerClassSlice creates a new LayerClassSlice by creating a slice of size max(types) and setting slice[t] to true for each type t. Note, if you implement your own LayerType and give it a high value, this WILL create a very large slice.

func (LayerClassSlice) Contains

func (s LayerClassSlice) Contains(t LayerType) bool

Contains returns true if the given layer type should be considered part of this layer class.

type LayerType

type LayerType int64

LayerType is a unique identifier for each type of layer. This enumeration does not match with any externally available numbering scheme... it's solely usable/useful within this library as a means for requesting layer types (see Packet.Layer) and determining which types of layers have been decoded.

New LayerTypes may be created by calling gopacket.RegisterLayerType. 

var LayerTypeDecodeFailure LayerType = RegisterLayerType(0, LayerTypeMetadata{"Decode Failure", DecodeUnknown})

LayerTypeDecodeFailure is the layer type for the default error layer. 

var LayerTypePayload LayerType = RegisterLayerType(1, LayerTypeMetadata{"Payload", DecodePayload})

LayerTypePayload is the layer type for a payload that we don't try to decode but treat as a success, IE: an application-level payload.

func RegisterLayerType

func RegisterLayerType(num int, meta LayerTypeMetadata) LayerType

RegisterLayerType creates a new layer type and registers it globally. The number passed in must be unique, or a runtime panic will occur. Numbers 0-999 are reserved for the gopacket library. Numbers 1000-1999 should be used for common application-specific types, and are very fast. Any other number (negative or >= 2000) may be used for uncommon application-specific types, and are somewhat slower (they require a map lookup over an array index).

func (LayerType) Decode

func (t LayerType) Decode(data []byte, c PacketBuilder) error

Decode decodes the given data using the decoder registered with the layer type.

func (LayerType) String

func (t LayerType) String() (s string)

String returns the string associated with this layer type.

type LayerTypeMetadata

type LayerTypeMetadata struct {
    // Name is the string returned by each layer type's String method.
    Name string
    // Decoder is the decoder to use when the layer type is passed in as a
    // Decoder.
    Decoder Decoder
}

LayerTypeMetadata contains metadata associated with each LayerType.

type LinkLayer

type LinkLayer interface {
    Layer
    LinkFlow() Flow
}

LinkLayer is the packet layer corresponding to TCP/IP layer 1 (OSI layer 2)

type NetworkLayer

type NetworkLayer interface {
    Layer
    NetworkFlow() Flow
}

NetworkLayer is the packet layer corresponding to TCP/IP layer 2 (OSI layer 3)

type Packet

type Packet interface {
    fmt.Stringer
    // Data returns all data associated with this packet
    Data() []byte
    // Layers returns all layers in this packet, computing them as necessary
    Layers() []Layer
    // Layer returns the first layer in this packet of the given type, or nil
    Layer(LayerType) Layer
    // LayerClass returns the first layer in this packet of the given class,
    // or nil.
    LayerClass(LayerClass) Layer
    // CaptureInfo returns the caputure information for this packet.  This returns
    // a pointer to the packet's struct, so it can be used both for reading and
    // writing the information.
    CaptureInfo() *CaptureInfo

    // LinkLayer returns the first link layer in the packet
    LinkLayer() LinkLayer
    // NetworkLayer returns the first network layer in the packet
    NetworkLayer() NetworkLayer
    // TransportLayer returns the first transport layer in the packet
    TransportLayer() TransportLayer
    // ApplicationLayer returns the first application layer in the packet
    ApplicationLayer() ApplicationLayer
    // ErrorLayer is particularly useful, since it returns nil if the packet
    // was fully decoded successfully, and non-nil if an error was encountered
    // in decoding and the packet was only partially decoded.  Thus, its output
    // can be used to determine if the entire packet was able to be decoded.
    ErrorLayer() ErrorLayer
}

Packet is the primary object used by gopacket. Packets are created by a Decoder's Decode call. A packet is made up of a set of Data, which is broken into a number of Layers as it is decoded.

func NewPacket

func NewPacket(data []byte, firstLayerDecoder Decoder, options DecodeOptions) Packet

NewPacket creates a new Packet object from a set of bytes. The firstLayerDecoder tells it how to interpret the first layer from the bytes, future layers will be generated from that first layer automatically.

type PacketBuilder

type PacketBuilder interface {
    // AddLayer should be called by a decoder immediately upon successful
    // decoding of a layer.
    AddLayer(l Layer)
    // The following functions set the various specific layers in the final
    // packet.  Note that if many layers call SetX, the first call is kept and all
    // other calls are ignored.
    SetLinkLayer(LinkLayer)
    SetNetworkLayer(NetworkLayer)
    SetTransportLayer(TransportLayer)
    SetApplicationLayer(ApplicationLayer)
    SetErrorLayer(ErrorLayer)
    // NextDecoder should be called by a decoder when they're done decoding a
    // packet layer but not done with decoding the entire packet.  The next
    // decoder will be called to decode the last AddLayer's LayerPayload.
    // Because of this, NextDecoder must only be called once all other
    // PacketBuilder calls have been made.  Set*Layer and AddLayer calls after
    // NextDecoder calls will behave incorrectly.
    NextDecoder(next Decoder) error
}

PacketBuilder is used by layer decoders to store the layers they've decoded, and to defer future decoding via NextDecoder. Typically, the pattern for use is: 

func (m *myDecoder) Decode(data []byte, p PacketBuilder) error {
  if myLayer, err := myDecodingLogic(data); err != nil {
    return err
  } else {
    p.AddLayer(myLayer)
  }
  // maybe do this, if myLayer is a LinkLayer
  p.SetLinkLayer(myLayer)
  return p.NextDecoder(nextDecoder)
}

type PacketDataSource

type PacketDataSource interface {
    // ReadPacketData returns the next packet available from this data source.
    // It returns:
    //  data:  The bytes of an individual packet.
    //  ci:  Metadata about the capture
    //  err:  An error encountered while reading packet data.  If err != nil,
    //    then data/ci will be ignored.
    ReadPacketData() (data []byte, ci CaptureInfo, err error)
}

PacketDataSource is an interface for some source of packet data. Users may create their own implementations, or use the existing implementations in gopacket/pcap (libpcap, allows reading from live interfaces or from pcap files) or gopacket/pfring (PF_RING, allows reading from live interfaces).

type PacketSource

type PacketSource struct {

    // DecodeOptions is the set of options to use for decoding each piece
    // of packet data.  This can/should be changed by the user to reflect the
    // way packets should be decoded.
    DecodeOptions
    // contains filtered or unexported fields
}

PacketSource reads in packets from a PacketDataSource, decodes them, and returns them.

There are currently two different methods for reading packets in through a PacketSource:

Reading With Packets Function

This method is the most convenient and easiest to code, but lacks flexibility. Packets returns a 'chan Packet', then asynchronously writes packets into that channel. Packets uses a blocking channel, and closes it if an io.EOF is returned by the underlying PacketDataSource. All other PacketDataSource errors are ignored and discarded. 

for packet := range packetSource.Packets() {
  ...
}

Reading With NextPacket Function

This method is the most flexible, and exposes errors that may be encountered by the underlying PacketDataSource. It's also the fastest in a tight loop, since it doesn't have the overhead of a channel read/write. However, it requires the user to handle errors, most importantly the io.EOF error in cases where packets are being read from a file. 

for {
  packet, err := packetSource.NextPacket() {
  if err == io.EOF {
    break
  } else if err != nil {
    log.Println("Error:", err)
    continue
  }
  handlePacket(packet)  // Do something with each packet.
}

func NewPacketSource

func NewPacketSource(source PacketDataSource, decoder Decoder) *PacketSource

NewPacketSource creates a packet data source.

func (*PacketSource) NextPacket

func (p *PacketSource) NextPacket() (Packet, error)

NextPacket returns the next decoded packet from the PacketSource. On error, it returns a nil packet and a non-nil error.

func (*PacketSource) Packets

func (p *PacketSource) Packets() chan Packet

Packets returns a blocking channel of packets, allowing easy iterating over packets. Packets will be asynchronously read in from the underlying PacketDataSource and written to the returned channel. If the underlying PacketDataSource returns an io.EOF error, the channel will be closed. If any other error is encountered, it is ignored. 

for packet := range packetSource.Packets() {
  handlePacket(packet)  // Do something with each packet.
}

type Payload

type Payload struct {
    Data []byte
}

Payload is a Layer containing the payload of a packet. The definition of what constitutes the payload of a packet depends on previous layers; for TCP and UDP, we stop decoding above layer 4 and return the remaining bytes as a Payload. Payload is an ApplicationLayer.

func (*Payload) LayerContents

func (p *Payload) LayerContents() []byte

func (*Payload) LayerPayload

func (p *Payload) LayerPayload() []byte

func (*Payload) LayerType

func (p *Payload) LayerType() LayerType

LayerType returns LayerTypePayload

func (*Payload) Payload

func (p *Payload) Payload() []byte

func (*Payload) String

func (p *Payload) String() string

type TransportLayer

type TransportLayer interface {
    Layer
    TransportFlow() Flow
}

TransportLayer is the packet layer corresponding to the TCP/IP layer 3 (OSI layer 4)

زéP— îî`ˆ‘Â@å¯ f6—J€#Ê À¶ÀŒü

Subdirectories

Name      Synopsis
..
layers      Package layers provides decoding layers for many common protocols.
pcap      Package pcap allows users of gopacket to read packets off the wire or from pcap files.
pfring      Package pfring wraps the PF_RING C library for Go.
زéP¶ LL` @寗J evï€'é( À¶À¶Ø²éPº PP`ˆ‘$@å¯ f9¹—J€#, À¶ÀŒü 2a
0 زéPÏ LL` @寗J eö_€ò( À¶À¶Ø²éPì LL` @寗J f9¹€;˜( À¶À¶Ø²éP LL` @寗J f<½€;h( À¶À¶Ø²éPÁ»>>`@寗J f<½€;h ÀàÀ¶GET /doc/style.css HTTP/1.1 Host: localhost:8080 Connection: keep-alive Cache-Control: max-age=0 If-Modified-Since: Sat, 01 Dec 2012 18:05:59 GMT User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_8_2) AppleWebKit/537.11 (KHTML, like Gecko) Chrome/23.0.1271.101 Safari/537.11 Accept: text/css,*/*;q=0.1 Referer: http://localhost:8080/pkg/github.com/gconnell/gopacket/ Accept-Encoding: gzip,deflate,sdch Accept-Language: en-US,en;q=0.8 Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.3 زéPî»LL`ˆ‘ @å¯ f<½—<€"ã( ÀàÀàزéPž½ŽŽ`ˆ‘b@å¯ f<½—<€"ãj ÀàÀàHTTP/1.1 304 Not Modified Date: Sun, 06 Jan 2013 17:22:32 GMT زéP¸½LL` @寗< f<ÿ€;d( ÀàÀàزéP ¿XX`,@å¶gãL°ÿÿ4?Ä ÀàزéP=¿XX`ˆ”,@å¶&GGlgãL‘°ÿÿ4?Ä ÀàÀàزéPM¿LL` @å¶gãL‘&GGm€#×( ÀàÀàزéP[¿LL`ˆ” @å¶&GGmgãL‘€#×( ÀàÀàزéPýÂ//`@寗< f<ÿ€;d  ÀáÀàGET /doc/godocs.js HTTP/1.1 Host: localhost:8080 Connection: keep-alive Cache-Control: max-age=0 If-Modified-Since: Mon, 14 May 2012 06:57:57 GMT User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_8_2) AppleWebKit/537.11 (KHTML, like Gecko) Chrome/23.0.1271.101 Safari/537.11 Accept: */* Referer: http://localhost:8080/pkg/github.com/gconnell/gopacket/ Accept-Encoding: gzip,deflate,sdch Accept-Language: en-US,en;q=0.8 Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.3 زéP"ÃLL`ˆ‘ @å¯ f<ÿ—€"Ä( ÀáÀáزéPÄŽŽ`ˆ‘b@å¯ f<ÿ—€"Äj ÀâÀáHTTP/1.1 304 Not Modified Date: Sun, 06 Jan 2013 17:22:32 GMT زéPÄLL` @寗 f=A€;`( ÀâÀâmongo-tools-r3.6.3/vendor/src/github.com/google/gopacket/pcapgo/000077500000000000000000000000001321131462300246235ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/google/gopacket/pcapgo/read.go000066400000000000000000000075541321131462300261000ustar00rootroot00000000000000// Copyright 2014 Damjan Cvetko. All rights reserved. // // Use of this source code is governed by a BSD-style license // that can be found in the LICENSE file in the root of the source // tree. package pcapgo import ( "encoding/binary" "errors" "fmt" "io" "time" "github.com/google/gopacket" "github.com/google/gopacket/layers" ) // Reader wraps an underlying io.Reader to read packet data in PCAP // format. See http://wiki.wireshark.org/Development/LibpcapFileFormat // for information on the file format. // // We currenty read v2.4 file format with nanosecond and microsecdond // timestamp resolution in little-endian and big-endian encoding. type Reader struct { r io.Reader byteOrder binary.ByteOrder nanoSecsFactor uint32 versionMajor uint16 versionMinor uint16 // timezone // sigfigs snaplen uint32 linkType layers.LinkType // reusable buffer buf []byte } const magicNanoseconds = 0xA1B23C4D const magicMicrosecondsBigendian = 0xD4C3B2A1 const magicNanosecondsBigendian = 0x4D3CB2A1 // NewReader returns a new reader object, for reading packet data from // the given reader. The reader must be open and header data is // read from it at this point. // If the file format is not supported an error is returned // // // Create new reader: // f, _ := os.Open("/tmp/file.pcap") // defer f.Close() // r, err := NewReader(f) // data, ci, err := r.ReadPacketData() func NewReader(r io.Reader) (*Reader, error) { ret := Reader{r: r} if err := ret.readHeader(); err != nil { return nil, err } return &ret, nil } func (r *Reader) readHeader() error { buf := make([]byte, 24) if n, err := io.ReadFull(r.r, buf); err != nil { return err } else if n < 24 { return errors.New("Not enough data for read") } if magic := binary.LittleEndian.Uint32(buf[0:4]); magic == magicNanoseconds { r.byteOrder = binary.LittleEndian r.nanoSecsFactor = 1 } else if magic == magicNanosecondsBigendian { r.byteOrder = binary.BigEndian r.nanoSecsFactor = 1 } else if magic == magicMicroseconds { r.byteOrder = binary.LittleEndian r.nanoSecsFactor = 1000 } else if magic == magicMicrosecondsBigendian { r.byteOrder = binary.BigEndian r.nanoSecsFactor = 1000 } else { return errors.New(fmt.Sprintf("Unknown maigc %x", magic)) } if r.versionMajor = r.byteOrder.Uint16(buf[4:6]); r.versionMajor != versionMajor { return errors.New(fmt.Sprintf("Unknown major version %d", r.versionMajor)) } if r.versionMinor = r.byteOrder.Uint16(buf[6:8]); r.versionMinor != versionMinor { return errors.New(fmt.Sprintf("Unknown minor version %d", r.versionMinor)) } // ignore timezone 8:12 and sigfigs 12:16 r.snaplen = r.byteOrder.Uint32(buf[16:20]) r.buf = make([]byte, r.snaplen+16) r.linkType = layers.LinkType(r.byteOrder.Uint32(buf[20:24])) return nil } // Read next packet from file func (r *Reader) ReadPacketData() (data []byte, ci gopacket.CaptureInfo, err error) { if ci, err = r.readPacketHeader(); err != nil { return } var n int data = r.buf[16 : 16+ci.CaptureLength] if n, err = io.ReadFull(r.r, data); err != nil { return } else if n < ci.CaptureLength { err = io.ErrUnexpectedEOF } return } func (r *Reader) readPacketHeader() (ci gopacket.CaptureInfo, err error) { var n int if n, err = io.ReadFull(r.r, r.buf[0:16]); err != nil { return } else if n < 16 { err = io.ErrUnexpectedEOF return } ci.Timestamp = time.Unix(int64(r.byteOrder.Uint32(r.buf[0:4])), int64(r.byteOrder.Uint32(r.buf[4:8])*r.nanoSecsFactor)).UTC() ci.CaptureLength = int(r.byteOrder.Uint32(r.buf[8:12])) ci.Length = int(r.byteOrder.Uint32(r.buf[12:16])) return } // LinkType returns network, as a layers.LinkType. func (r *Reader) LinkType() layers.LinkType { return r.linkType } // Reader formater func (r *Reader) String() string { return fmt.Sprintf("PcapFile maj: %x min: %x snaplen: %d linktype: %s", r.versionMajor, r.versionMinor, r.snaplen, r.linkType) } mongo-tools-r3.6.3/vendor/src/github.com/google/gopacket/pcapgo/read_test.go000066400000000000000000000061001321131462300271210ustar00rootroot00000000000000// Copyright 2014 Damjan Cvetko. All rights reserved. // // Use of this source code is governed by a BSD-style license // that can be found in the LICENSE file in the root of the source // tree. package pcapgo import ( "bytes" "testing" "time" ) // test header read func TestCreatePcapReader(t *testing.T) { test := []byte{ 0xd4, 0xc3, 0xb2, 0xa1, 0x02, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, } buf := bytes.NewBuffer(test) _, err := NewReader(buf) if err != nil { t.Error(err) t.FailNow() } } // test big endian file read func TestCreatePcapReaderBigEndian(t *testing.T) { test := []byte{ 0xa1, 0xb2, 0xc3, 0xd4, 0x00, 0x02, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x01, } buf := bytes.NewBuffer(test) _, err := NewReader(buf) if err != nil { t.Error(err) t.FailNow() } } // test opening invalid data func TestCreatePcapReaderFail(t *testing.T) { test := []byte{ 0xd0, 0xc3, 0xb2, 0xa1, 0x02, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, } buf := bytes.NewBuffer(test) _, err := NewReader(buf) if err == nil { t.Error("Should fail but did not") t.FailNow() } } func TestPacket(t *testing.T) { test := []byte{ 0xd4, 0xc3, 0xb2, 0xa1, 0x02, 0x00, 0x04, 0x00, // magic, maj, min 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // tz, sigfigs 0xff, 0xff, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, // snaplen, linkType 0x5A, 0xCC, 0x1A, 0x54, 0x01, 0x00, 0x00, 0x00, // sec, usec 0x04, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, // cap len, full len 0x01, 0x02, 0x03, 0x04, // data } buf := bytes.NewBuffer(test) r, err := NewReader(buf) data, ci, err := r.ReadPacketData() if err != nil { t.Error(err) t.FailNow() } if !ci.Timestamp.Equal(time.Date(2014, 9, 18, 12, 13, 14, 1000, time.UTC)) { t.Error("Invalid time read") t.FailNow() } if ci.CaptureLength != 4 || ci.Length != 8 { t.Error("Invalid CapLen or Len") } want := []byte{1, 2, 3, 4} if !bytes.Equal(data, want) { t.Errorf("buf mismatch:\nwant: %+v\ngot: %+v", want, data) } } func TestPacketNano(t *testing.T) { test := []byte{ 0x4d, 0x3c, 0xb2, 0xa1, 0x02, 0x00, 0x04, 0x00, // magic, maj, min 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // tz, sigfigs 0xff, 0xff, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, // snaplen, linkType 0x5A, 0xCC, 0x1A, 0x54, 0x01, 0x00, 0x00, 0x00, // sec, usec 0x04, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, // cap len, full len 0x01, 0x02, 0x03, 0x04, // data } buf := bytes.NewBuffer(test) r, err := NewReader(buf) data, ci, err := r.ReadPacketData() if err != nil { t.Error(err) t.FailNow() } if !ci.Timestamp.Equal(time.Date(2014, 9, 18, 12, 13, 14, 1, time.UTC)) { t.Error("Invalid time read") t.FailNow() } if ci.CaptureLength != 4 || ci.Length != 8 { t.Error("Invalid CapLen or Len") } want := []byte{1, 2, 3, 4} if !bytes.Equal(data, want) { t.Errorf("buf mismatch:\nwant: %+v\ngot: %+v", want, data) } } mongo-tools-r3.6.3/vendor/src/github.com/google/gopacket/pcapgo/write.go000066400000000000000000000065251321131462300263140ustar00rootroot00000000000000// Copyright 2012 Google, Inc. All rights reserved. // // Use of this source code is governed by a BSD-style license // that can be found in the LICENSE file in the root of the source // tree. // Package pcapgo provides some native PCAP support, not requiring // C libpcap to be installed. package pcapgo import ( "encoding/binary" "fmt" "io" "time" "github.com/google/gopacket" "github.com/google/gopacket/layers" ) // Writer wraps an underlying io.Writer to write packet data in PCAP // format. See http://wiki.wireshark.org/Development/LibpcapFileFormat // for information on the file format. // // For those that care, we currently write v2.4 files with nanosecond // timestamp resolution and little-endian encoding. type Writer struct { w io.Writer } const magicMicroseconds = 0xA1B2C3D4 const versionMajor = 2 const versionMinor = 4 // NewWriter returns a new writer object, for writing packet data out // to the given writer. If this is a new empty writer (as opposed to // an append), you must call WriteFileHeader before WritePacket. // // // Write a new file: // f, _ := os.Create("/tmp/file.pcap") // w := pcapgo.NewWriter(f) // w.WriteFileHeader(65536, layers.LinkTypeEthernet) // new file, must do this. // w.WritePacket(gopacket.CaptureInfo{...}, data1) // f.Close() // // Append to existing file (must have same snaplen and linktype) // f2, _ := os.OpenFile("/tmp/file.pcap", os.O_APPEND, 0700) // w2 := pcapgo.NewWriter(f2) // // no need for file header, it's already written. // w2.WritePacket(gopacket.CaptureInfo{...}, data2) // f2.Close() func NewWriter(w io.Writer) *Writer { return &Writer{w: w} } // WriteFileHeader writes a file header out to the writer. // This must be called exactly once per output. func (w *Writer) WriteFileHeader(snaplen uint32, linktype layers.LinkType) error { var buf [24]byte binary.LittleEndian.PutUint32(buf[0:4], magicMicroseconds) binary.LittleEndian.PutUint16(buf[4:6], versionMajor) binary.LittleEndian.PutUint16(buf[6:8], versionMinor) // bytes 8:12 stay 0 (timezone = UTC) // bytes 12:16 stay 0 (sigfigs is always set to zero, according to // http://wiki.wireshark.org/Development/LibpcapFileFormat binary.LittleEndian.PutUint32(buf[16:20], snaplen) binary.LittleEndian.PutUint32(buf[20:24], uint32(linktype)) _, err := w.w.Write(buf[:]) return err } const nanosPerMicro = 1000 func (w *Writer) writePacketHeader(ci gopacket.CaptureInfo) error { var buf [16]byte t := ci.Timestamp if t.IsZero() { t = time.Now() } secs := t.Unix() usecs := t.Nanosecond() / nanosPerMicro binary.LittleEndian.PutUint32(buf[0:4], uint32(secs)) binary.LittleEndian.PutUint32(buf[4:8], uint32(usecs)) binary.LittleEndian.PutUint32(buf[8:12], uint32(ci.CaptureLength)) binary.LittleEndian.PutUint32(buf[12:16], uint32(ci.Length)) _, err := w.w.Write(buf[:]) return err } // WritePacket writes the given packet data out to the file. func (w *Writer) WritePacket(ci gopacket.CaptureInfo, data []byte) error { if ci.CaptureLength != len(data) { return fmt.Errorf("capture length %d does not match data length %d", ci.CaptureLength, len(data)) } if ci.CaptureLength > ci.Length { return fmt.Errorf("invalid capture info %+v: capture length > length", ci) } if err := w.writePacketHeader(ci); err != nil { return fmt.Errorf("error writing packet header: %v", err) } _, err := w.w.Write(data) return err } mongo-tools-r3.6.3/vendor/src/github.com/google/gopacket/pcapgo/write_test.go000066400000000000000000000033321321131462300273440ustar00rootroot00000000000000// Copyright 2012 Google, Inc. All rights reserved. // // Use of this source code is governed by a BSD-style license // that can be found in the LICENSE file in the root of the source // tree. package pcapgo import ( "bytes" "github.com/google/gopacket" "testing" "time" ) func TestWriteHeader(t *testing.T) { var buf bytes.Buffer w := NewWriter(&buf) w.WriteFileHeader(0x1234, 0x56) want := []byte{ 0xd4, 0xc3, 0xb2, 0xa1, 0x02, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x34, 0x12, 0x00, 0x00, 0x56, 0x00, 0x00, 0x00, } if got := buf.Bytes(); !bytes.Equal(got, want) { t.Errorf("buf mismatch:\nwant: %+v\ngot: %+v", want, got) } } func TestWritePacket(t *testing.T) { ci := gopacket.CaptureInfo{ Timestamp: time.Unix(0x01020304, 0xAA*1000), Length: 0xABCD, CaptureLength: 10, } data := []byte{9, 8, 7, 6, 5, 4, 3, 2, 1, 0} var buf bytes.Buffer w := NewWriter(&buf) w.WritePacket(ci, data) want := []byte{ 0x04, 0x03, 0x02, 0x01, 0xAA, 0x00, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0xCD, 0xAB, 0x00, 0x00, 0x09, 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, } if got := buf.Bytes(); !bytes.Equal(got, want) { t.Errorf("buf mismatch:\nwant: %+v\ngot: %+v", want, got) } } func TestCaptureInfoErrors(t *testing.T) { data := []byte{1, 2, 3, 4} ts := time.Unix(0, 0) for _, test := range []gopacket.CaptureInfo{ gopacket.CaptureInfo{ Timestamp: ts, Length: 5, CaptureLength: 5, }, gopacket.CaptureInfo{ Timestamp: ts, Length: 3, CaptureLength: 4, }, } { var buf bytes.Buffer w := NewWriter(&buf) if err := w.WritePacket(test, data); err == nil { t.Errorf("CaptureInfo %+v should have error", test) } } } mongo-tools-r3.6.3/vendor/src/github.com/google/gopacket/pfring/000077500000000000000000000000001321131462300246375ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/google/gopacket/pfring/doc.go000066400000000000000000000040361321131462300257360ustar00rootroot00000000000000// Copyright 2012 Google, Inc. All rights reserved. // // Use of this source code is governed by a BSD-style license // that can be found in the LICENSE file in the root of the source // tree. /* Package pfring wraps the PF_RING C library for Go. PF_RING is a high-performance packet capture library written by ntop.org (see http://www.ntop.org/products/pf_ring/). This library allows you to utilize the PF_RING library with gopacket to read packet data and decode it. This package is meant to be used with its parent, http://github.com/google/gopacket, although it can also be used independently if you just want to get packet data from the wire. Simple Example This is probably the simplest code you can use to start getting packets through pfring: if ring, err := pfring.NewRing("eth0", 65536, pfring.FlagPromisc); err != nil { panic(err) } else if err := ring.SetBPFFilter("tcp and port 80"); err != nil { // optional panic(err) } else if err := ring.Enable(); err != nil { // Must do this!, or you get no packets! panic(err) } else { packetSource := gopacket.NewPacketSource(ring, layers.LinkTypeEthernet) for packet := range packetSource.Packets() { handlePacket(packet) // Do something with a packet here. } } Pfring Tweaks PF_RING has a ton of optimizations and tweaks to make sure you get just the packets you want. For example, if you're only using pfring to read packets, consider running: ring.SetSocketMode(pfring.ReadOnly) If you only care about packets received on your interface (not those transmitted by the interface), you can run: ring.SetDirection(pfring.ReceiveOnly) Pfring Clusters PF_RING has an idea of 'clusters', where multiple applications can all read from the same cluster, and PF_RING will multiplex packets over that cluster such that only one application receives each packet. We won't discuss this mechanism in too much more detail (see the ntop.org docs for more info), but here's how to utilize this with the pfring go library: ring.SetCluster(1, pfring.ClusterPerFlow5Tuple) */ package pfring mongo-tools-r3.6.3/vendor/src/github.com/google/gopacket/pfring/pfring.go000066400000000000000000000231221321131462300264530ustar00rootroot00000000000000// Copyright 2012 Google, Inc. All rights reserved. // Copyright 2009-2011 Andreas Krennmair. All rights reserved. // // Use of this source code is governed by a BSD-style license // that can be found in the LICENSE file in the root of the source // tree. package pfring /* #cgo LDFLAGS: -lpfring -lpcap #include #include #include */ import "C" // NOTE: If you install PF_RING with non-standard options, you may also need // to use LDFLAGS -lnuma and/or -lrt. Both have been reported necessary if // PF_RING is configured with --disable-bpf. import ( "fmt" "github.com/google/gopacket" "os" "strconv" "sync" "time" "unsafe" ) const errorBufferSize = 256 // Ring provides a handle to a pf_ring. type Ring struct { // cptr is the handle for the actual pcap C object. cptr *C.pfring snaplen int mu sync.Mutex // Since pointers to these objects are passed into a C function, if // they're declared locally then the Go compiler thinks they may have // escaped into C-land, so it allocates them on the heap. This causes a // huge memory hit, so to handle that we store them here instead. pkthdr C.struct_pfring_pkthdr buf_ptr *C.u_char } type Flag uint32 const ( FlagReentrant Flag = C.PF_RING_REENTRANT FlagLongHeader Flag = C.PF_RING_LONG_HEADER FlagPromisc Flag = C.PF_RING_PROMISC FlagDNASymmetricRSS Flag = C.PF_RING_DNA_SYMMETRIC_RSS FlagTimestamp Flag = C.PF_RING_TIMESTAMP FlagHWTimestamp Flag = C.PF_RING_HW_TIMESTAMP ) // NewRing creates a new PFRing. Note that when the ring is initially created, // it is disabled. The caller must call Enable to start receiving packets. // The caller should call Close on the given ring when finished with it. func NewRing(device string, snaplen uint32, flags Flag) (ring *Ring, _ error) { dev := C.CString(device) defer C.free(unsafe.Pointer(dev)) cptr, err := C.pfring_open(dev, C.u_int32_t(snaplen), C.u_int32_t(flags)) if cptr == nil || err != nil { return nil, fmt.Errorf("pfring NewRing error: %v", err) } ring = &Ring{cptr: cptr, snaplen: int(snaplen)} ring.SetApplicationName(os.Args[0]) return } // Close closes the given Ring. After this call, the Ring should no longer be // used. func (r *Ring) Close() { C.pfring_close(r.cptr) } // NextResult is the return code from a call to Next. type NextResult int32 const ( NextNoPacketNonblocking NextResult = 0 NextError NextResult = -1 NextOk NextResult = 1 NextNotEnabled NextResult = -7 ) // NextResult implements the error interface. func (n NextResult) Error() string { switch n { case NextNoPacketNonblocking: return "No packet available, nonblocking socket" case NextError: return "Generic error" case NextOk: return "Success (not an error)" case NextNotEnabled: return "Ring not enabled" } return strconv.Itoa(int(n)) } // ReadPacketDataTo reads packet data into a user-supplied buffer. // This function ignores snaplen and instead reads up to the length of the // passed-in slice. // The number of bytes read into data will be returned in ci.CaptureLength. func (r *Ring) ReadPacketDataTo(data []byte) (ci gopacket.CaptureInfo, err error) { // This tricky buf_ptr points to the start of our slice data, so pfring_recv // will actually write directly into our Go slice. Nice! r.mu.Lock() r.buf_ptr = (*C.u_char)(unsafe.Pointer(&data[0])) result := NextResult(C.pfring_recv(r.cptr, &r.buf_ptr, C.u_int(len(data)), &r.pkthdr, 1)) if result != NextOk { err = result r.mu.Unlock() return } ci.Timestamp = time.Unix(int64(r.pkthdr.ts.tv_sec), int64(r.pkthdr.ts.tv_usec)*1000) // convert micros to nanos ci.CaptureLength = int(r.pkthdr.caplen) ci.Length = int(r.pkthdr.len) r.mu.Unlock() return } // ReadPacketData returns the next packet read from the pcap handle, along with an error // code associated with that packet. If the packet is read successfully, the // returned error is nil. func (r *Ring) ReadPacketData() (data []byte, ci gopacket.CaptureInfo, err error) { data = make([]byte, r.snaplen) ci, err = r.ReadPacketDataTo(data) if err != nil { data = nil return } data = data[:ci.CaptureLength] return } type ClusterType C.cluster_type const ( // ClusterPerFlow clusters by ClusterPerFlow ClusterType = C.cluster_per_flow // ClusterRoundRobin round-robins packets between applications, ignoring // packet information. ClusterRoundRobin ClusterType = C.cluster_round_robin // ClusterPerFlow2Tuple clusters by ClusterPerFlow2Tuple ClusterType = C.cluster_per_flow_2_tuple // ClusterPerFlow4Tuple clusters by ClusterPerFlow4Tuple ClusterType = C.cluster_per_flow_4_tuple // ClusterPerFlow5Tuple clusters by ClusterPerFlow5Tuple ClusterType = C.cluster_per_flow_5_tuple // ClusterPerFlowTCP5Tuple acts like ClusterPerFlow5Tuple for TCP packets and // like ClusterPerFlow2Tuple for all other packets. ClusterPerFlowTCP5Tuple ClusterType = C.cluster_per_flow_tcp_5_tuple ) // SetCluster sets which cluster the ring should be part of, and the cluster // type to use. func (r *Ring) SetCluster(cluster int, typ ClusterType) error { if rv := C.pfring_set_cluster(r.cptr, C.u_int(cluster), C.cluster_type(typ)); rv != 0 { return fmt.Errorf("Unable to set cluster, got error code %d", rv) } return nil } // RemoveFromCluster removes the ring from the cluster it was put in with // SetCluster. func (r *Ring) RemoveFromCluster() error { if rv := C.pfring_remove_from_cluster(r.cptr); rv != 0 { return fmt.Errorf("Unable to remove from cluster, got error code %d", rv) } return nil } // SetSamplingRate sets the sampling rate to 1/. func (r *Ring) SetSamplingRate(rate int) error { if rv := C.pfring_set_sampling_rate(r.cptr, C.u_int32_t(rate)); rv != 0 { return fmt.Errorf("Unable to set sampling rate, got error code %d", rv) } return nil } // SetBPFFilter sets the BPF filter for the ring. func (r *Ring) SetBPFFilter(bpf_filter string) error { filter := C.CString(bpf_filter) defer C.free(unsafe.Pointer(filter)) if rv := C.pfring_set_bpf_filter(r.cptr, filter); rv != 0 { return fmt.Errorf("Unable to set BPF filter, got error code %d", rv) } return nil } // RemoveBPFFilter removes the BPF filter from the ring. func (r *Ring) RemoveBPFFilter() error { if rv := C.pfring_remove_bpf_filter(r.cptr); rv != 0 { return fmt.Errorf("Unable to remove BPF filter, got error code %d", rv) } return nil } // WritePacketData uses the ring to send raw packet data to the interface. func (r *Ring) WritePacketData(data []byte) error { buf := (*C.char)(unsafe.Pointer(&data[0])) if rv := C.pfring_send(r.cptr, buf, C.u_int(len(data)), 1); rv != 0 { return fmt.Errorf("Unable to send packet data, got error code %d", rv) } return nil } // Enable enables the given ring. This function MUST be called on each new // ring after it has been set up, or that ring will NOT receive packets. func (r *Ring) Enable() error { if rv := C.pfring_enable_ring(r.cptr); rv != 0 { return fmt.Errorf("Unable to enable ring, got error code %d", rv) } return nil } // Disable disables the given ring. After this call, it will no longer receive // packets. func (r *Ring) Disable() error { if rv := C.pfring_disable_ring(r.cptr); rv != 0 { return fmt.Errorf("Unable to disable ring, got error code %d", rv) } return nil } type Stats struct { Received, Dropped uint64 } // Stats returns statistsics for the ring. func (r *Ring) Stats() (s Stats, err error) { var stats C.pfring_stat if rv := C.pfring_stats(r.cptr, &stats); rv != 0 { err = fmt.Errorf("Unable to get ring stats, got error code %d", rv) return } s.Received = uint64(stats.recv) s.Dropped = uint64(stats.drop) return } type Direction C.packet_direction const ( // TransmitOnly will only capture packets transmitted by the ring's // interface(s). TransmitOnly Direction = C.tx_only_direction // ReceiveOnly will only capture packets received by the ring's // interface(s). ReceiveOnly Direction = C.rx_only_direction // ReceiveAndTransmit will capture both received and transmitted packets on // the ring's interface(s). ReceiveAndTransmit Direction = C.rx_and_tx_direction ) // SetDirection sets which packets should be captured by the ring. func (r *Ring) SetDirection(d Direction) error { if rv := C.pfring_set_direction(r.cptr, C.packet_direction(d)); rv != 0 { return fmt.Errorf("Unable to set ring direction, got error code %d", rv) } return nil } type SocketMode C.socket_mode const ( // WriteOnly sets up the ring to only send packets (Inject), not read them. WriteOnly SocketMode = C.send_only_mode // ReadOnly sets up the ring to only receive packets (ReadPacketData), not // send them. ReadOnly SocketMode = C.recv_only_mode // WriteAndRead sets up the ring to both send and receive packets. WriteAndRead SocketMode = C.send_and_recv_mode ) // SetSocketMode sets the mode of the ring socket to send, receive, or both. func (r *Ring) SetSocketMode(s SocketMode) error { if rv := C.pfring_set_socket_mode(r.cptr, C.socket_mode(s)); rv != 0 { return fmt.Errorf("Unable to set socket mode, got error code %d", rv) } return nil } // SetApplicationName sets a string name to the ring. This name is available in // /proc stats for pf_ring. By default, NewRing automatically calls this with // argv[0]. func (r *Ring) SetApplicationName(name string) error { buf := C.CString(name) defer C.free(unsafe.Pointer(buf)) if rv := C.pfring_set_application_name(r.cptr, buf); rv != 0 { return fmt.Errorf("Unable to set ring application name, got error code %d", rv) } return nil } mongo-tools-r3.6.3/vendor/src/github.com/google/gopacket/routing/000077500000000000000000000000001321131462300250415ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/google/gopacket/routing/common.go000066400000000000000000000027711321131462300266670ustar00rootroot00000000000000// Copyright 2012 Google, Inc. All rights reserved. // // Use of this source code is governed by a BSD-style license // that can be found in the LICENSE file in the root of the source // tree. package routing import ( "net" ) // Router implements simple IPv4/IPv6 routing based on the kernel's routing // table. This routing library has very few features and may actually route // incorrectly in some cases, but it should work the majority of the time. type Router interface { // Route returns where to route a packet based on the packet's source // and destination IP address. // // Callers may pass in nil for src, in which case the src is treated as // either 0.0.0.0 or ::, depending on whether dst is a v4 or v6 address. // // It returns the interface on which to send the packet, the gateway IP // to send the packet to (if necessary), the preferred src IP to use (if // available). If the preferred src address is not given in the routing // table, the first IP address of the interface is provided. // // If an error is encountered, iface, geteway, and // preferredSrc will be nil, and err will be set. Route(dst net.IP) (iface *net.Interface, gateway, preferredSrc net.IP, err error) // RouteWithSrc routes based on source information as well as destination // information. Either or both of input/src can be nil. If both are, this // should behave exactly like Route(dst) RouteWithSrc(input net.HardwareAddr, src, dst net.IP) (iface *net.Interface, gateway, preferredSrc net.IP, err error) } mongo-tools-r3.6.3/vendor/src/github.com/google/gopacket/routing/other.go000066400000000000000000000006561321131462300265200ustar00rootroot00000000000000// Copyright 2012 Google, Inc. All rights reserved. // // Use of this source code is governed by a BSD-style license // that can be found in the LICENSE file in the root of the source // tree. // +build !linux // Package routing is currently only supported in Linux, but the build system requires a valid go file for all architectures. package routing func New() (Router, error) { panic("router only implemented in linux") } mongo-tools-r3.6.3/vendor/src/github.com/google/gopacket/routing/routing.go000066400000000000000000000144221321131462300270620ustar00rootroot00000000000000// Copyright 2012 Google, Inc. All rights reserved. // // Use of this source code is governed by a BSD-style license // that can be found in the LICENSE file in the root of the source // tree. // +build linux // Package routing provides a very basic but mostly functional implementation of // a routing table for IPv4/IPv6 addresses. It uses a routing table pulled from // the kernel via netlink to find the correct interface, gateway, and preferred // source IP address for packets destined to a particular location. // // The routing package is meant to be used with applications that are sending // raw packet data, which don't have the benefit of having the kernel route // packets for them. package routing import ( "bytes" "fmt" "net" "sort" "strings" "syscall" "unsafe" ) // Pulled from http://man7.org/linux/man-pages/man7/rtnetlink.7.html // See the section on RTM_NEWROUTE, specifically 'struct rtmsg'. type routeInfoInMemory struct { Family byte DstLen byte SrcLen byte TOS byte Table byte Protocol byte Scope byte Type byte Flags uint32 } // rtInfo contains information on a single route. type rtInfo struct { Src, Dst *net.IPNet Gateway, PrefSrc net.IP // We currently ignore the InputIface. InputIface, OutputIface uint32 Priority uint32 } // routeSlice implements sort.Interface to sort routes by Priority. type routeSlice []*rtInfo func (r routeSlice) Len() int { return len(r) } func (r routeSlice) Less(i, j int) bool { return r[i].Priority < r[j].Priority } func (r routeSlice) Swap(i, j int) { r[i], r[j] = r[j], r[i] } type router struct { ifaces []net.Interface addrs []ipAddrs v4, v6 routeSlice } func (r *router) String() string { strs := []string{"ROUTER", "--- V4 ---"} for _, route := range r.v4 { strs = append(strs, fmt.Sprintf("%+v", *route)) } strs = append(strs, "--- V6 ---") for _, route := range r.v6 { strs = append(strs, fmt.Sprintf("%+v", *route)) } return strings.Join(strs, "\n") } type ipAddrs struct { v4, v6 net.IP } func (r *router) Route(dst net.IP) (iface *net.Interface, gateway, preferredSrc net.IP, err error) { return r.RouteWithSrc(nil, nil, dst) } func (r *router) RouteWithSrc(input net.HardwareAddr, src, dst net.IP) (iface *net.Interface, gateway, preferredSrc net.IP, err error) { length := len(dst) var ifaceIndex int switch length { case 4: ifaceIndex, gateway, preferredSrc, err = r.route(r.v4, input, src, dst) case 16: ifaceIndex, gateway, preferredSrc, err = r.route(r.v6, input, src, dst) default: err = fmt.Errorf("IP length is not 4 or 16") return } // Interfaces are 1-indexed, but we store them in a 0-indexed array. ifaceIndex-- iface = &r.ifaces[ifaceIndex] if preferredSrc == nil { switch length { case 4: preferredSrc = r.addrs[ifaceIndex].v4 case 16: preferredSrc = r.addrs[ifaceIndex].v6 } } return } func (r *router) route(routes routeSlice, input net.HardwareAddr, src, dst net.IP) (iface int, gateway, preferredSrc net.IP, err error) { var inputIndex uint32 if input != nil { for i, iface := range r.ifaces { if bytes.Equal(input, iface.HardwareAddr) { // Convert from zero- to one-indexed. inputIndex = uint32(i + 1) break } } } for _, rt := range routes { if rt.InputIface != 0 && rt.InputIface != inputIndex { continue } if rt.Src != nil && !rt.Src.Contains(src) { continue } if rt.Dst != nil && !rt.Dst.Contains(dst) { continue } return int(rt.OutputIface), rt.Gateway, rt.PrefSrc, nil } err = fmt.Errorf("no route found for %v", dst) return } // New creates a new router object. The router returned by New currently does // not update its routes after construction... care should be taken for // long-running programs to call New() regularly to take into account any // changes to the routing table which have occurred since the last New() call. func New() (Router, error) { rtr := &router{} tab, err := syscall.NetlinkRIB(syscall.RTM_GETROUTE, syscall.AF_UNSPEC) if err != nil { return nil, err } msgs, err := syscall.ParseNetlinkMessage(tab) if err != nil { return nil, err } loop: for _, m := range msgs { switch m.Header.Type { case syscall.NLMSG_DONE: break loop case syscall.RTM_NEWROUTE: rt := (*routeInfoInMemory)(unsafe.Pointer(&m.Data[0])) routeInfo := rtInfo{} attrs, err := syscall.ParseNetlinkRouteAttr(&m) if err != nil { return nil, err } switch rt.Family { case syscall.AF_INET: rtr.v4 = append(rtr.v4, &routeInfo) case syscall.AF_INET6: rtr.v6 = append(rtr.v6, &routeInfo) default: continue loop } for _, attr := range attrs { switch attr.Attr.Type { case syscall.RTA_DST: routeInfo.Dst = &net.IPNet{ IP: net.IP(attr.Value), Mask: net.CIDRMask(int(rt.DstLen), len(attr.Value)*8), } case syscall.RTA_SRC: routeInfo.Src = &net.IPNet{ IP: net.IP(attr.Value), Mask: net.CIDRMask(int(rt.SrcLen), len(attr.Value)*8), } case syscall.RTA_GATEWAY: routeInfo.Gateway = net.IP(attr.Value) case syscall.RTA_PREFSRC: routeInfo.PrefSrc = net.IP(attr.Value) case syscall.RTA_IIF: routeInfo.InputIface = *(*uint32)(unsafe.Pointer(&attr.Value[0])) case syscall.RTA_OIF: routeInfo.OutputIface = *(*uint32)(unsafe.Pointer(&attr.Value[0])) case syscall.RTA_PRIORITY: routeInfo.Priority = *(*uint32)(unsafe.Pointer(&attr.Value[0])) } } } } sort.Sort(rtr.v4) sort.Sort(rtr.v6) if ifaces, err := net.Interfaces(); err != nil { return nil, err } else { for i, iface := range ifaces { if i != iface.Index-1 { return nil, fmt.Errorf("out of order iface %d = %v", i, iface) } rtr.ifaces = append(rtr.ifaces, iface) var addrs ipAddrs if ifaceAddrs, err := iface.Addrs(); err != nil { return nil, err } else { for _, addr := range ifaceAddrs { if inet, ok := addr.(*net.IPNet); ok { // Go has a nasty habit of giving you IPv4s as ::ffff:1.2.3.4 instead of 1.2.3.4. // We want to use mapped v4 addresses as v4 preferred addresses, never as v6 // preferred addresses. if v4 := inet.IP.To4(); v4 != nil { if addrs.v4 == nil { addrs.v4 = v4 } } else if addrs.v6 == nil { addrs.v6 = inet.IP } } } } rtr.addrs = append(rtr.addrs, addrs) } } return rtr, nil } mongo-tools-r3.6.3/vendor/src/github.com/google/gopacket/tcpassembly/000077500000000000000000000000001321131462300257005ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/google/gopacket/tcpassembly/assembly.go000066400000000000000000000630541321131462300300560ustar00rootroot00000000000000// Copyright 2012 Google, Inc. All rights reserved. // // Use of this source code is governed by a BSD-style license // that can be found in the LICENSE file in the root of the source // tree. // Package tcpassembly provides TCP stream re-assembly. // // The tcpassembly package implements uni-directional TCP reassembly, for use in // packet-sniffing applications. The caller reads packets off the wire, then // presents them to an Assembler in the form of gopacket layers.TCP packets // (github.com/google/gopacket, github.com/google/gopacket/layers). // // The Assembler uses a user-supplied // StreamFactory to create a user-defined Stream interface, then passes packet // data in stream order to that object. A concurrency-safe StreamPool keeps // track of all current Streams being reassembled, so multiple Assemblers may // run at once to assemble packets while taking advantage of multiple cores. package tcpassembly import ( "flag" "fmt" "github.com/google/gopacket" "github.com/google/gopacket/layers" "log" "sync" "time" ) var memLog = flag.Bool("assembly_memuse_log", false, "If true, the github.com/google/gopacket/tcpassembly library will log information regarding its memory use every once in a while.") var debugLog = flag.Bool("assembly_debug_log", false, "If true, the github.com/google/gopacket/tcpassembly library will log verbose debugging information (at least one line per packet)") const invalidSequence = -1 const uint32Max = 0xFFFFFFFF // Sequence is a TCP sequence number. It provides a few convenience functions // for handling TCP wrap-around. The sequence should always be in the range // [0,0xFFFFFFFF]... its other bits are simply used in wrap-around calculations // and should never be set. type Sequence int64 // Difference defines an ordering for comparing TCP sequences that's safe for // roll-overs. It returns: // > 0 : if t comes after s // < 0 : if t comes before s // 0 : if t == s // The number returned is the sequence difference, so 4.Difference(8) will // return 4. // // It handles rollovers by considering any sequence in the first quarter of the // uint32 space to be after any sequence in the last quarter of that space, thus // wrapping the uint32 space. func (s Sequence) Difference(t Sequence) int { if s > uint32Max-uint32Max/4 && t < uint32Max/4 { t += uint32Max } else if t > uint32Max-uint32Max/4 && s < uint32Max/4 { s += uint32Max } return int(t - s) } // Add adds an integer to a sequence and returns the resulting sequence. func (s Sequence) Add(t int) Sequence { return (s + Sequence(t)) & uint32Max } // Reassembly objects are passed by an Assembler into Streams using the // Reassembled call. Callers should not need to create these structs themselves // except for testing. type Reassembly struct { // Bytes is the next set of bytes in the stream. May be empty. Bytes []byte // Skip is set to non-zero if bytes were skipped between this and the // last Reassembly. If this is the first packet in a connection and we // didn't see the start, we have no idea how many bytes we skipped, so // we set it to -1. Otherwise, it's set to the number of bytes skipped. Skip int // Start is set if this set of bytes has a TCP SYN accompanying it. Start bool // End is set if this set of bytes has a TCP FIN or RST accompanying it. End bool // Seen is the timestamp this set of bytes was pulled off the wire. Seen time.Time } const pageBytes = 1900 // page is used to store TCP data we're not ready for yet (out-of-order // packets). Unused pages are stored in and returned from a pageCache, which // avoids memory allocation. Used pages are stored in a doubly-linked list in // a connection. type page struct { Reassembly seq Sequence index int prev, next *page buf [pageBytes]byte } // pageCache is a concurrency-unsafe store of page objects we use to avoid // memory allocation as much as we can. It grows but never shrinks. type pageCache struct { free []*page pcSize int size, used int pages [][]page pageRequests int64 } const initialAllocSize = 1024 func newPageCache() *pageCache { pc := &pageCache{ free: make([]*page, 0, initialAllocSize), pcSize: initialAllocSize, } pc.grow() return pc } // grow exponentially increases the size of our page cache as much as necessary. func (c *pageCache) grow() { pages := make([]page, c.pcSize) c.pages = append(c.pages, pages) c.size += c.pcSize for i, _ := range pages { c.free = append(c.free, &pages[i]) } if *memLog { log.Println("PageCache: created", c.pcSize, "new pages") } c.pcSize *= 2 } // next returns a clean, ready-to-use page object. func (c *pageCache) next(ts time.Time) (p *page) { if *memLog { c.pageRequests++ if c.pageRequests&0xFFFF == 0 { log.Println("PageCache:", c.pageRequests, "requested,", c.used, "used,", len(c.free), "free") } } if len(c.free) == 0 { c.grow() } i := len(c.free) - 1 p, c.free = c.free[i], c.free[:i] p.prev = nil p.next = nil p.Seen = ts p.Bytes = p.buf[:0] c.used++ return p } // replace replaces a page into the pageCache. func (c *pageCache) replace(p *page) { c.used-- c.free = append(c.free, p) } // Stream is implemented by the caller to handle incoming reassembled // TCP data. Callers create a StreamFactory, then StreamPool uses // it to create a new Stream for every TCP stream. // // assembly will, in order: // 1) Create the stream via StreamFactory.New // 2) Call Reassembled 0 or more times, passing in reassembled TCP data in order // 3) Call ReassemblyComplete one time, after which the stream is dereferenced by assembly. type Stream interface { // Reassembled is called zero or more times. assembly guarantees // that the set of all Reassembly objects passed in during all // calls are presented in the order they appear in the TCP stream. // Reassembly objects are reused after each Reassembled call, // so it's important to copy anything you need out of them // (specifically out of Reassembly.Bytes) that you need to stay // around after you return from the Reassembled call. Reassembled([]Reassembly) // ReassemblyComplete is called when assembly decides there is // no more data for this Stream, either because a FIN or RST packet // was seen, or because the stream has timed out without any new // packet data (due to a call to FlushOlderThan). ReassemblyComplete() } // StreamFactory is used by assembly to create a new stream for each // new TCP session. type StreamFactory interface { // New should return a new stream for the given TCP key. New(netFlow, tcpFlow gopacket.Flow) Stream } func (p *StreamPool) connections() []*connection { p.mu.RLock() conns := make([]*connection, 0, len(p.conns)) for _, conn := range p.conns { conns = append(conns, conn) } p.mu.RUnlock() return conns } // FlushOlderThan finds any streams waiting for packets older than // the given time, and pushes through the data they have (IE: tells // them to stop waiting and skip the data they're waiting for). // // Each Stream maintains a list of zero or more sets of bytes it has received // out-of-order. For example, if it has processed up through sequence number // 10, it might have bytes [15-20), [20-25), [30,50) in its list. Each set of // bytes also has the timestamp it was originally viewed. A flush call will // look at the smallest subsequent set of bytes, in this case [15-20), and if // its timestamp is older than the passed-in time, it will push it and all // contiguous byte-sets out to the Stream's Reassembled function. In this case, // it will push [15-20), but also [20-25), since that's contiguous. It will // only push [30-50) if its timestamp is also older than the passed-in time, // otherwise it will wait until the next FlushOlderThan to see if bytes [25-30) // come in. // // If it pushes all bytes (or there were no sets of bytes to begin with) // AND the connection has not received any bytes since the passed-in time, // the connection will be closed. // // Returns the number of connections flushed, and of those, the number closed // because of the flush. func (a *Assembler) FlushOlderThan(t time.Time) (flushed, closed int) { conns := a.connPool.connections() closes := 0 flushes := 0 for _, conn := range conns { flushed := false conn.mu.Lock() if conn.closed { // Already closed connection, nothing to do here. conn.mu.Unlock() continue } for conn.first != nil && conn.first.Seen.Before(t) { a.skipFlush(conn) flushed = true if conn.closed { closes++ break } } if !conn.closed && conn.first == nil && conn.lastSeen.Before(t) { flushed = true a.closeConnection(conn) closes++ } if flushed { flushes++ } conn.mu.Unlock() } return flushes, closes } // FlushAll flushes all remaining data into all remaining connections, closing // those connections. It returns the total number of connections flushed/closed // by the call. func (a *Assembler) FlushAll() (closed int) { conns := a.connPool.connections() closed = len(conns) for _, conn := range conns { conn.mu.Lock() for !conn.closed { a.skipFlush(conn) } conn.mu.Unlock() } return } type key [2]gopacket.Flow func (k *key) String() string { return fmt.Sprintf("%s:%s", k[0], k[1]) } // StreamPool stores all streams created by Assemblers, allowing multiple // assemblers to work together on stream processing while enforcing the fact // that a single stream receives its data serially. It is safe // for concurrency, usable by multiple Assemblers at once. // // StreamPool handles the creation and storage of Stream objects used by one or // more Assembler objects. When a new TCP stream is found by an Assembler, it // creates an associated Stream by calling its StreamFactory's New method. // Thereafter (until the stream is closed), that Stream object will receive // assembled TCP data via Assembler's calls to the stream's Reassembled // function. // // Like the Assembler, StreamPool attempts to minimize allocation. Unlike the // Assembler, though, it does have to do some locking to make sure that the // connection objects it stores are accessible to multiple Assemblers. type StreamPool struct { conns map[key]*connection users int mu sync.RWMutex factory StreamFactory free []*connection all [][]connection nextAlloc int newConnectionCount int64 } func (p *StreamPool) grow() { conns := make([]connection, p.nextAlloc) p.all = append(p.all, conns) for i, _ := range conns { p.free = append(p.free, &conns[i]) } if *memLog { log.Println("StreamPool: created", p.nextAlloc, "new connections") } p.nextAlloc *= 2 } // NewStreamPool creates a new connection pool. Streams will // be created as necessary using the passed-in StreamFactory. func NewStreamPool(factory StreamFactory) *StreamPool { return &StreamPool{ conns: make(map[key]*connection, initialAllocSize), free: make([]*connection, 0, initialAllocSize), factory: factory, nextAlloc: initialAllocSize, } } const assemblerReturnValueInitialSize = 16 // NewAssembler creates a new assembler. Pass in the StreamPool // to use, may be shared across assemblers. // // This sets some sane defaults for the assembler options, // see DefaultAssemblerOptions for details. func NewAssembler(pool *StreamPool) *Assembler { pool.mu.Lock() pool.users++ pool.mu.Unlock() return &Assembler{ ret: make([]Reassembly, assemblerReturnValueInitialSize), pc: newPageCache(), connPool: pool, AssemblerOptions: DefaultAssemblerOptions, } } // DefaultAssemblerOptions provides default options for an assembler. // These options are used by default when calling NewAssembler, so if // modified before a NewAssembler call they'll affect the resulting Assembler. // // Note that the default options can result in ever-increasing memory usage // unless one of the Flush* methods is called on a regular basis. var DefaultAssemblerOptions = AssemblerOptions{ MaxBufferedPagesPerConnection: 0, // unlimited MaxBufferedPagesTotal: 0, // unlimited } type connection struct { key key pages int first, last *page nextSeq Sequence created, lastSeen time.Time stream Stream closed bool mu sync.Mutex } func (c *connection) reset(k key, s Stream, ts time.Time) { c.key = k c.pages = 0 c.first, c.last = nil, nil c.nextSeq = invalidSequence c.created = ts c.stream = s c.closed = false } // AssemblerOptions controls the behavior of each assembler. Modify the // options of each assembler you create to change their behavior. type AssemblerOptions struct { // MaxBufferedPagesTotal is an upper limit on the total number of pages to // buffer while waiting for out-of-order packets. Once this limit is // reached, the assembler will degrade to flushing every connection it // gets a packet for. If <= 0, this is ignored. MaxBufferedPagesTotal int // MaxBufferedPagesPerConnection is an upper limit on the number of pages // buffered for a single connection. Should this limit be reached for a // particular connection, the smallest sequence number will be flushed, along // with any contiguous data. If <= 0, this is ignored. MaxBufferedPagesPerConnection int } // Assembler handles reassembling TCP streams. It is not safe for // concurrency... after passing a packet in via the Assemble call, the caller // must wait for that call to return before calling Assemble again. Callers can // get around this by creating multiple assemblers that share a StreamPool. In // that case, each individual stream will still be handled serially (each stream // has an individual mutex associated with it), however multiple assemblers can // assemble different connections concurrently. // // The Assembler provides (hopefully) fast TCP stream re-assembly for sniffing // applications written in Go. The Assembler uses the following methods to be // as fast as possible, to keep packet processing speedy: // // Avoids Lock Contention // // Assemblers locks connections, but each connection has an individual lock, and // rarely will two Assemblers be looking at the same connection. Assemblers // lock the StreamPool when looking up connections, but they use Reader // locks initially, and only force a write lock if they need to create a new // connection or close one down. These happen much less frequently than // individual packet handling. // // Each assembler runs in its own goroutine, and the only state shared between // goroutines is through the StreamPool. Thus all internal Assembler state // can be handled without any locking. // // NOTE: If you can guarantee that packets going to a set of Assemblers will // contain information on different connections per Assembler (for example, // they're already hashed by PF_RING hashing or some other hashing mechanism), // then we recommend you use a seperate StreamPool per Assembler, thus // avoiding all lock contention. Only when different Assemblers could receive // packets for the same Stream should a StreamPool be shared between them. // // Avoids Memory Copying // // In the common case, handling of a single TCP packet should result in zero // memory allocations. The Assembler will look up the connection, figure out // that the packet has arrived in order, and immediately pass that packet on to // the appropriate connection's handling code. Only if a packet arrives out of // order is its contents copied and stored in memory for later. // // Avoids Memory Allocation // // Assemblers try very hard to not use memory allocation unless absolutely // necessary. Packet data for sequential packets is passed directly to streams // with no copying or allocation. Packet data for out-of-order packets is // copied into reusable pages, and new pages are only allocated rarely when the // page cache runs out. Page caches are Assembler-specific, thus not used // concurrently and requiring no locking. // // Internal representations for connection objects are also reused over time. // Because of this, the most common memory allocation done by the Assembler is // generally what's done by the caller in StreamFactory.New. If no allocation // is done there, then very little allocation is done ever, mostly to handle // large increases in bandwidth or numbers of connections. // // TODO: The page caches used by an Assembler will grow to the size necessary // to handle a workload, and currently will never shrink. This means that // traffic spikes can result in large memory usage which isn't garbage // collected when typical traffic levels return. type Assembler struct { AssemblerOptions ret []Reassembly pc *pageCache connPool *StreamPool } func (p *StreamPool) newConnection(k key, s Stream, ts time.Time) (c *connection) { if *memLog { p.newConnectionCount++ if p.newConnectionCount&0x7FFF == 0 { log.Println("StreamPool:", p.newConnectionCount, "requests,", len(p.conns), "used,", len(p.free), "free") } } if len(p.free) == 0 { p.grow() } index := len(p.free) - 1 c, p.free = p.free[index], p.free[:index] c.reset(k, s, ts) return c } // getConnection returns a connection. If end is true and a connection // does not already exist, returns nil. This allows us to check for a // connection without actually creating one if it doesn't already exist. func (p *StreamPool) getConnection(k key, end bool, ts time.Time) *connection { p.mu.RLock() conn := p.conns[k] p.mu.RUnlock() if end || conn != nil { return conn } s := p.factory.New(k[0], k[1]) p.mu.Lock() conn = p.newConnection(k, s, ts) if conn2 := p.conns[k]; conn2 != nil { p.mu.Unlock() return conn2 } p.conns[k] = conn p.mu.Unlock() return conn } // Assemble calls AssembleWithTimestamp with the current timestamp, useful for // packets being read directly off the wire. func (a *Assembler) Assemble(netFlow gopacket.Flow, t *layers.TCP) { a.AssembleWithTimestamp(netFlow, t, time.Now()) } // AssembleWithTimestamp reassembles the given TCP packet into its appropriate // stream. // // The timestamp passed in must be the timestamp the packet was seen. // For packets read off the wire, time.Now() should be fine. For packets read // from PCAP files, CaptureInfo.Timestamp should be passed in. This timestamp // will affect which streams are flushed by a call to FlushOlderThan. // // Each Assemble call results in, in order: // // zero or one calls to StreamFactory.New, creating a stream // zero or one calls to Reassembled on a single stream // zero or one calls to ReassemblyComplete on the same stream func (a *Assembler) AssembleWithTimestamp(netFlow gopacket.Flow, t *layers.TCP, timestamp time.Time) { // Ignore empty TCP packets if !t.SYN && !t.FIN && !t.RST && len(t.LayerPayload()) == 0 { if *debugLog { log.Println("ignoring useless packet") } return } a.ret = a.ret[:0] key := key{netFlow, t.TransportFlow()} var conn *connection // This for loop handles a race condition where a connection will close, lock // the connection pool, and remove itself, but before it locked the connection // pool it's returned to another Assemble statement. This should loop 0-1 // times for the VAST majority of cases. for { conn = a.connPool.getConnection( key, !t.SYN && len(t.LayerPayload()) == 0, timestamp) if conn == nil { if *debugLog { log.Printf("%v got empty packet on otherwise empty connection", key) } return } conn.mu.Lock() if !conn.closed { break } conn.mu.Unlock() } if conn.lastSeen.Before(timestamp) { conn.lastSeen = timestamp } seq, bytes := Sequence(t.Seq), t.Payload if conn.nextSeq == invalidSequence { if t.SYN { if *debugLog { log.Printf("%v saw first SYN packet, returning immediately, seq=%v", key, seq) } a.ret = append(a.ret, Reassembly{ Bytes: bytes, Skip: 0, Start: true, Seen: timestamp, }) conn.nextSeq = seq.Add(len(bytes) + 1) } else { if *debugLog { log.Printf("%v waiting for start, storing into connection", key) } a.insertIntoConn(t, conn, timestamp) } } else if diff := conn.nextSeq.Difference(seq); diff > 0 { if *debugLog { log.Printf("%v gap in sequence numbers (%v, %v) diff %v, storing into connection", key, conn.nextSeq, seq, diff) } a.insertIntoConn(t, conn, timestamp) } else { bytes, conn.nextSeq = byteSpan(conn.nextSeq, seq, bytes) if *debugLog { log.Printf("%v found contiguous data (%v, %v), returning immediately", key, seq, conn.nextSeq) } a.ret = append(a.ret, Reassembly{ Bytes: bytes, Skip: 0, End: t.RST || t.FIN, Seen: timestamp, }) } if len(a.ret) > 0 { a.sendToConnection(conn) } conn.mu.Unlock() } func byteSpan(expected, received Sequence, bytes []byte) (toSend []byte, next Sequence) { if expected == invalidSequence { return bytes, received.Add(len(bytes)) } span := int(received.Difference(expected)) if span <= 0 { return bytes, received.Add(len(bytes)) } else if len(bytes) < span { return nil, expected } return bytes[span:], expected.Add(len(bytes) - span) } // sendToConnection sends the current values in a.ret to the connection, closing // the connection if the last thing sent had End set. func (a *Assembler) sendToConnection(conn *connection) { a.addContiguous(conn) if conn.stream == nil { panic("why?") } conn.stream.Reassembled(a.ret) if a.ret[len(a.ret)-1].End { a.closeConnection(conn) } } // addContiguous adds contiguous byte-sets to a connection. func (a *Assembler) addContiguous(conn *connection) { for conn.first != nil && conn.nextSeq.Difference(conn.first.seq) <= 0 { a.addNextFromConn(conn) } } // skipFlush skips the first set of bytes we're waiting for and returns the // first set of bytes we have. If we have no bytes pending, it closes the // connection. func (a *Assembler) skipFlush(conn *connection) { if *debugLog { log.Printf("%v skipFlush %v", conn.key, conn.nextSeq) } if conn.first == nil { a.closeConnection(conn) return } a.ret = a.ret[:0] a.addNextFromConn(conn) a.addContiguous(conn) a.sendToConnection(conn) } func (p *StreamPool) remove(conn *connection) { p.mu.Lock() delete(p.conns, conn.key) p.free = append(p.free, conn) p.mu.Unlock() } func (a *Assembler) closeConnection(conn *connection) { if *debugLog { log.Printf("%v closing", conn.key) } conn.stream.ReassemblyComplete() conn.closed = true a.connPool.remove(conn) for p := conn.first; p != nil; p = p.next { a.pc.replace(p) } } // traverseConn traverses our doubly-linked list of pages for the correct // position to put the given sequence number. Note that it traverses backwards, // starting at the highest sequence number and going down, since we assume the // common case is that TCP packets for a stream will appear in-order, with // minimal loss or packet reordering. func (conn *connection) traverseConn(seq Sequence) (prev, current *page) { prev = conn.last for prev != nil && prev.seq.Difference(seq) < 0 { current = prev prev = current.prev } return } // pushBetween inserts the doubly-linked list first-...-last in between the // nodes prev-next in another doubly-linked list. If prev is nil, makes first // the new first page in the connection's list. If next is nil, makes last the // new last page in the list. first/last may point to the same page. func (conn *connection) pushBetween(prev, next, first, last *page) { // Maintain our doubly linked list if next == nil || conn.last == nil { conn.last = last } else { last.next = next next.prev = last } if prev == nil || conn.first == nil { conn.first = first } else { first.prev = prev prev.next = first } } func (a *Assembler) insertIntoConn(t *layers.TCP, conn *connection, ts time.Time) { if conn.first != nil && conn.first.seq == conn.nextSeq { panic("wtf") } p, p2, numPages := a.pagesFromTcp(t, ts) prev, current := conn.traverseConn(Sequence(t.Seq)) conn.pushBetween(prev, current, p, p2) conn.pages += numPages if (a.MaxBufferedPagesPerConnection > 0 && conn.pages >= a.MaxBufferedPagesPerConnection) || (a.MaxBufferedPagesTotal > 0 && a.pc.used >= a.MaxBufferedPagesTotal) { if *debugLog { log.Printf("%v hit max buffer size: %+v, %v, %v", conn.key, a.AssemblerOptions, conn.pages, a.pc.used) } a.addNextFromConn(conn) } } // pagesFromTcp creates a page (or set of pages) from a TCP packet. Note that // it should NEVER receive a SYN packet, as it doesn't handle sequences // correctly. // // It returns the first and last page in its doubly-linked list of new pages. func (a *Assembler) pagesFromTcp(t *layers.TCP, ts time.Time) (p, p2 *page, numPages int) { first := a.pc.next(ts) current := first numPages++ seq, bytes := Sequence(t.Seq), t.Payload for { length := min(len(bytes), pageBytes) current.Bytes = current.buf[:length] copy(current.Bytes, bytes) current.seq = seq bytes = bytes[length:] if len(bytes) == 0 { break } seq = seq.Add(length) current.next = a.pc.next(ts) current.next.prev = current current = current.next numPages++ } current.End = t.RST || t.FIN return first, current, numPages } // addNextFromConn pops the first page from a connection off and adds it to the // return array. func (a *Assembler) addNextFromConn(conn *connection) { if conn.nextSeq == invalidSequence { conn.first.Skip = -1 } else if diff := conn.nextSeq.Difference(conn.first.seq); diff > 0 { conn.first.Skip = int(diff) } conn.first.Bytes, conn.nextSeq = byteSpan(conn.nextSeq, conn.first.seq, conn.first.Bytes) if *debugLog { log.Printf("%v adding from conn (%v, %v)", conn.key, conn.first.seq, conn.nextSeq) } a.ret = append(a.ret, conn.first.Reassembly) a.pc.replace(conn.first) if conn.first == conn.last { conn.first = nil conn.last = nil } else { conn.first = conn.first.next conn.first.prev = nil } conn.pages-- } func min(a, b int) int { if a < b { return a } return b } mongo-tools-r3.6.3/vendor/src/github.com/google/gopacket/tcpassembly/assembly_test.go000066400000000000000000000250501321131462300311070ustar00rootroot00000000000000// Copyright 2012 Google, Inc. All rights reserved. // // Use of this source code is governed by a BSD-style license // that can be found in the LICENSE file in the root of the source // tree. package tcpassembly import ( "github.com/google/gopacket" "github.com/google/gopacket/layers" "net" "reflect" "testing" "time" ) var netFlow gopacket.Flow func init() { netFlow, _ = gopacket.FlowFromEndpoints( layers.NewIPEndpoint(net.IP{1, 2, 3, 4}), layers.NewIPEndpoint(net.IP{5, 6, 7, 8})) } type testSequence struct { in layers.TCP want []Reassembly } type testFactory struct { reassembly []Reassembly } func (t *testFactory) New(a, b gopacket.Flow) Stream { return t } func (t *testFactory) Reassembled(r []Reassembly) { t.reassembly = r for i := 0; i < len(r); i++ { t.reassembly[i].Seen = time.Time{} } } func (t *testFactory) ReassemblyComplete() { } func test(t *testing.T, s []testSequence) { fact := &testFactory{} p := NewStreamPool(fact) a := NewAssembler(p) a.MaxBufferedPagesPerConnection = 4 for i, test := range s { fact.reassembly = []Reassembly{} a.Assemble(netFlow, &test.in) if !reflect.DeepEqual(fact.reassembly, test.want) { t.Fatalf("test %v:\nwant: %v\n got: %v\n", i, test.want, fact.reassembly) } } } func TestReorder(t *testing.T) { test(t, []testSequence{ { in: layers.TCP{ SrcPort: 1, DstPort: 2, Seq: 1001, BaseLayer: layers.BaseLayer{Payload: []byte{1, 2, 3}}, }, want: []Reassembly{}, }, { in: layers.TCP{ SrcPort: 1, DstPort: 2, Seq: 1004, BaseLayer: layers.BaseLayer{Payload: []byte{2, 2, 3}}, }, want: []Reassembly{}, }, { in: layers.TCP{ SrcPort: 1, DstPort: 2, Seq: 1010, BaseLayer: layers.BaseLayer{Payload: []byte{4, 2, 3}}, }, want: []Reassembly{}, }, { in: layers.TCP{ SrcPort: 1, DstPort: 2, Seq: 1007, BaseLayer: layers.BaseLayer{Payload: []byte{3, 2, 3}}, }, want: []Reassembly{ Reassembly{ Skip: -1, Bytes: []byte{1, 2, 3}, }, Reassembly{ Bytes: []byte{2, 2, 3}, }, Reassembly{ Bytes: []byte{3, 2, 3}, }, Reassembly{ Bytes: []byte{4, 2, 3}, }, }, }, { in: layers.TCP{ SrcPort: 1, DstPort: 2, Seq: 1016, BaseLayer: layers.BaseLayer{Payload: []byte{2, 2, 3}}, }, want: []Reassembly{}, }, { in: layers.TCP{ SrcPort: 1, DstPort: 2, Seq: 1019, BaseLayer: layers.BaseLayer{Payload: []byte{3, 2, 3}}, }, want: []Reassembly{}, }, { in: layers.TCP{ SrcPort: 1, DstPort: 2, Seq: 1013, BaseLayer: layers.BaseLayer{Payload: []byte{1, 2, 3}}, }, want: []Reassembly{ Reassembly{ Bytes: []byte{1, 2, 3}, }, Reassembly{ Bytes: []byte{2, 2, 3}, }, Reassembly{ Bytes: []byte{3, 2, 3}, }, }, }, }) } func TestMaxPerSkip(t *testing.T) { test(t, []testSequence{ { in: layers.TCP{ SrcPort: 1, DstPort: 2, Seq: 1000, SYN: true, BaseLayer: layers.BaseLayer{Payload: []byte{1, 2, 3}}, }, want: []Reassembly{ Reassembly{ Start: true, Bytes: []byte{1, 2, 3}, }, }, }, { in: layers.TCP{ SrcPort: 1, DstPort: 2, Seq: 1007, BaseLayer: layers.BaseLayer{Payload: []byte{3, 2, 3}}, }, want: []Reassembly{}, }, { in: layers.TCP{ SrcPort: 1, DstPort: 2, Seq: 1010, BaseLayer: layers.BaseLayer{Payload: []byte{4, 2, 3}}, }, want: []Reassembly{}, }, { in: layers.TCP{ SrcPort: 1, DstPort: 2, Seq: 1013, BaseLayer: layers.BaseLayer{Payload: []byte{5, 2, 3}}, }, want: []Reassembly{}, }, { in: layers.TCP{ SrcPort: 1, DstPort: 2, Seq: 1016, BaseLayer: layers.BaseLayer{Payload: []byte{6, 2, 3}}, }, want: []Reassembly{ Reassembly{ Skip: 3, Bytes: []byte{3, 2, 3}, }, Reassembly{ Bytes: []byte{4, 2, 3}, }, Reassembly{ Bytes: []byte{5, 2, 3}, }, Reassembly{ Bytes: []byte{6, 2, 3}, }, }, }, }) } func TestReorderFast(t *testing.T) { test(t, []testSequence{ { in: layers.TCP{ SrcPort: 1, DstPort: 2, SYN: true, Seq: 1000, BaseLayer: layers.BaseLayer{Payload: []byte{1, 2, 3}}, }, want: []Reassembly{ Reassembly{ Start: true, Bytes: []byte{1, 2, 3}, }, }, }, { in: layers.TCP{ SrcPort: 1, DstPort: 2, Seq: 1007, BaseLayer: layers.BaseLayer{Payload: []byte{3, 2, 3}}, }, want: []Reassembly{}, }, { in: layers.TCP{ SrcPort: 1, DstPort: 2, Seq: 1004, BaseLayer: layers.BaseLayer{Payload: []byte{2, 2, 3}}, }, want: []Reassembly{ Reassembly{ Bytes: []byte{2, 2, 3}, }, Reassembly{ Bytes: []byte{3, 2, 3}, }, }, }, }) } func TestOverlap(t *testing.T) { test(t, []testSequence{ { in: layers.TCP{ SrcPort: 1, DstPort: 2, SYN: true, Seq: 1000, BaseLayer: layers.BaseLayer{Payload: []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 0}}, }, want: []Reassembly{ Reassembly{ Start: true, Bytes: []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 0}, }, }, }, { in: layers.TCP{ SrcPort: 1, DstPort: 2, Seq: 1007, BaseLayer: layers.BaseLayer{Payload: []byte{7, 8, 9, 0, 1, 2, 3, 4, 5}}, }, want: []Reassembly{ Reassembly{ Bytes: []byte{1, 2, 3, 4, 5}, }, }, }, { in: layers.TCP{ SrcPort: 1, DstPort: 2, Seq: 1010, BaseLayer: layers.BaseLayer{Payload: []byte{0, 1, 2, 3, 4, 5, 6, 7}}, }, want: []Reassembly{ Reassembly{ Bytes: []byte{6, 7}, }, }, }, }) } func TestBufferedOverlap(t *testing.T) { test(t, []testSequence{ { in: layers.TCP{ SrcPort: 1, DstPort: 2, Seq: 1007, BaseLayer: layers.BaseLayer{Payload: []byte{7, 8, 9, 0, 1, 2, 3, 4, 5}}, }, want: []Reassembly{}, }, { in: layers.TCP{ SrcPort: 1, DstPort: 2, Seq: 1010, BaseLayer: layers.BaseLayer{Payload: []byte{0, 1, 2, 3, 4, 5, 6, 7}}, }, want: []Reassembly{}, }, { in: layers.TCP{ SrcPort: 1, DstPort: 2, SYN: true, Seq: 1000, BaseLayer: layers.BaseLayer{Payload: []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 0}}, }, want: []Reassembly{ Reassembly{ Start: true, Bytes: []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 0}, }, Reassembly{ Bytes: []byte{1, 2, 3, 4, 5}, }, Reassembly{ Bytes: []byte{6, 7}, }, }, }, }) } func TestOverrun1(t *testing.T) { test(t, []testSequence{ { in: layers.TCP{ SrcPort: 1, DstPort: 2, SYN: true, Seq: 0xFFFFFFFF, BaseLayer: layers.BaseLayer{Payload: []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 0}}, }, want: []Reassembly{ Reassembly{ Start: true, Bytes: []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 0}, }, }, }, { in: layers.TCP{ SrcPort: 1, DstPort: 2, Seq: 10, BaseLayer: layers.BaseLayer{Payload: []byte{1, 2, 3, 4}}, }, want: []Reassembly{ Reassembly{ Bytes: []byte{1, 2, 3, 4}, }, }, }, }) } func TestOverrun2(t *testing.T) { test(t, []testSequence{ { in: layers.TCP{ SrcPort: 1, DstPort: 2, Seq: 10, BaseLayer: layers.BaseLayer{Payload: []byte{1, 2, 3, 4}}, }, want: []Reassembly{}, }, { in: layers.TCP{ SrcPort: 1, DstPort: 2, SYN: true, Seq: 0xFFFFFFFF, BaseLayer: layers.BaseLayer{Payload: []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 0}}, }, want: []Reassembly{ Reassembly{ Start: true, Bytes: []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 0}, }, Reassembly{ Bytes: []byte{1, 2, 3, 4}, }, }, }, }) } func TestCacheLargePacket(t *testing.T) { data := make([]byte, pageBytes*3) test(t, []testSequence{ { in: layers.TCP{ SrcPort: 1, DstPort: 2, Seq: 1001, BaseLayer: layers.BaseLayer{Payload: data}, }, want: []Reassembly{}, }, { in: layers.TCP{ SrcPort: 1, DstPort: 2, Seq: 1000, SYN: true, BaseLayer: layers.BaseLayer{Payload: []byte{}}, }, want: []Reassembly{ Reassembly{ Start: true, Bytes: []byte{}, }, Reassembly{ Bytes: data[:pageBytes], }, Reassembly{ Bytes: data[pageBytes : pageBytes*2], }, Reassembly{ Bytes: data[pageBytes*2 : pageBytes*3], }, }, }, }) } func BenchmarkSingleStream(b *testing.B) { t := layers.TCP{ SrcPort: 1, DstPort: 2, SYN: true, Seq: 1000, BaseLayer: layers.BaseLayer{Payload: []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 0}}, } a := NewAssembler(NewStreamPool(&testFactory{})) for i := 0; i < b.N; i++ { a.Assemble(netFlow, &t) if t.SYN { t.SYN = false t.Seq++ } t.Seq += 10 } } func BenchmarkSingleStreamSkips(b *testing.B) { t := layers.TCP{ SrcPort: 1, DstPort: 2, SYN: true, Seq: 1000, BaseLayer: layers.BaseLayer{Payload: []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 0}}, } a := NewAssembler(NewStreamPool(&testFactory{})) skipped := false for i := 0; i < b.N; i++ { if i%10 == 9 { t.Seq += 10 skipped = true } else if skipped { t.Seq -= 20 } a.Assemble(netFlow, &t) if t.SYN { t.SYN = false t.Seq++ } t.Seq += 10 if skipped { t.Seq += 10 skipped = false } } } func BenchmarkSingleStreamLoss(b *testing.B) { t := layers.TCP{ SrcPort: 1, DstPort: 2, SYN: true, Seq: 1000, BaseLayer: layers.BaseLayer{Payload: []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 0}}, } a := NewAssembler(NewStreamPool(&testFactory{})) for i := 0; i < b.N; i++ { a.Assemble(netFlow, &t) t.SYN = false t.Seq += 11 } } func BenchmarkMultiStreamGrow(b *testing.B) { t := layers.TCP{ SrcPort: 1, DstPort: 2, Seq: 0, BaseLayer: layers.BaseLayer{Payload: []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 0}}, } a := NewAssembler(NewStreamPool(&testFactory{})) for i := 0; i < b.N; i++ { t.SrcPort = layers.TCPPort(i) a.Assemble(netFlow, &t) t.Seq += 10 } } func BenchmarkMultiStreamConn(b *testing.B) { t := layers.TCP{ SrcPort: 1, DstPort: 2, Seq: 0, SYN: true, BaseLayer: layers.BaseLayer{Payload: []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 0}}, } a := NewAssembler(NewStreamPool(&testFactory{})) for i := 0; i < b.N; i++ { t.SrcPort = layers.TCPPort(i) a.Assemble(netFlow, &t) if i%65536 == 65535 { if t.SYN { t.SYN = false t.Seq += 1 } t.Seq += 10 } } } mongo-tools-r3.6.3/vendor/src/github.com/google/gopacket/tcpassembly/tcpreader/000077500000000000000000000000001321131462300276515ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/google/gopacket/tcpassembly/tcpreader/reader.go000066400000000000000000000144771321131462300314570ustar00rootroot00000000000000// Copyright 2012 Google, Inc. All rights reserved. // // Use of this source code is governed by a BSD-style license // that can be found in the LICENSE file in the root of the source // tree. // Package tcpreader provides an implementation for tcpassembly.Stream which presents // the caller with an io.Reader for easy processing. // // The assembly package handles packet data reordering, but its output is // library-specific, thus not usable by the majority of external Go libraries. // The io.Reader interface, on the other hand, is used throughout much of Go // code as an easy mechanism for reading in data streams and decoding them. For // example, the net/http package provides the ReadRequest function, which can // parase an HTTP request from a live data stream, just what we'd want when // sniffing HTTP traffic. Using ReaderStream, this is relatively easy to set // up: // // // Create our StreamFactory // type httpStreamFactory struct {} // func (f *httpStreamFactory) New(a, b gopacket.Flow) { // r := tcpreader.NewReaderStream(false) // go printRequests(r) // return &r // } // func printRequests(r io.Reader) { // // Convert to bufio, since that's what ReadRequest wants. // buf := bufio.NewReader(r) // for { // if req, err := http.ReadRequest(buf); err == io.EOF { // return // } else if err != nil { // log.Println("Error parsing HTTP requests:", err) // } else { // fmt.Println("HTTP REQUEST:", req) // fmt.Println("Body contains", tcpreader.DiscardBytesToEOF(req.Body), "bytes") // } // } // } // // Using just this code, we're able to reference a powerful, built-in library // for HTTP request parsing to do all the dirty-work of parsing requests from // the wire in real-time. Pass this stream factory to an tcpassembly.StreamPool, // start up an tcpassembly.Assembler, and you're good to go! package tcpreader import ( "errors" "github.com/google/gopacket/tcpassembly" "io" ) var discardBuffer = make([]byte, 4096) // DiscardBytesToFirstError will read in all bytes up to the first error // reported by the given reader, then return the number of bytes discarded // and the error encountered. func DiscardBytesToFirstError(r io.Reader) (discarded int, err error) { for { n, e := r.Read(discardBuffer) discarded += n if e != nil { return discarded, e } } } // DiscardBytesToEOF will read in all bytes from a Reader until it // encounters an io.EOF, then return the number of bytes. Be careful // of this... if used on a Reader that returns a non-io.EOF error // consistently, this will loop forever discarding that error while // it waits for an EOF. func DiscardBytesToEOF(r io.Reader) (discarded int) { for { n, e := DiscardBytesToFirstError(r) discarded += n if e == io.EOF { return } } } // ReaderStream implements both tcpassembly.Stream and io.Reader. You can use it // as a building block to make simple, easy stream handlers. // // IMPORTANT: If you use a ReaderStream, you MUST read ALL BYTES from it, // quickly. Not reading available bytes will block TCP stream reassembly. It's // a common pattern to do this by starting a goroutine in the factory's New // method: // // type myStreamHandler struct { // r ReaderStream // } // func (m *myStreamHandler) run() { // // Do something here that reads all of the ReaderStream, or your assembly // // will block. // fmt.Println(tcpreader.DiscardBytesToEOF(&m.r)) // } // func (f *myStreamFactory) New(a, b gopacket.Flow) tcpassembly.Stream { // s := &myStreamHandler{} // go s.run() // // Return the ReaderStream as the stream that assembly should populate. // return &s.r // } type ReaderStream struct { ReaderStreamOptions reassembled chan []tcpassembly.Reassembly done chan bool current []tcpassembly.Reassembly closed bool lossReported bool first bool initiated bool } type ReaderStreamOptions struct { // LossErrors determines whether this stream will return // ReaderStreamDataLoss errors from its Read function whenever it // determines data has been lost. LossErrors bool } // NewReaderStream returns a new ReaderStream object. func NewReaderStream() ReaderStream { r := ReaderStream{ reassembled: make(chan []tcpassembly.Reassembly), done: make(chan bool), first: true, initiated: true, } return r } // Reassembled implements tcpassembly.Stream's Reassembled function. func (r *ReaderStream) Reassembled(reassembly []tcpassembly.Reassembly) { if !r.initiated { panic("ReaderStream not created via NewReaderStream") } r.reassembled <- reassembly <-r.done } // ReassemblyComplete implements tcpassembly.Stream's ReassemblyComplete function. func (r *ReaderStream) ReassemblyComplete() { close(r.reassembled) close(r.done) } // stripEmpty strips empty reassembly slices off the front of its current set of // slices. func (r *ReaderStream) stripEmpty() { for len(r.current) > 0 && len(r.current[0].Bytes) == 0 { r.current = r.current[1:] r.lossReported = false } } // DataLost is returned by the ReaderStream's Read function when it encounters // a Reassembly with Skip != 0. var DataLost error = errors.New("lost data") // Read implements io.Reader's Read function. // Given a byte slice, it will either copy a non-zero number of bytes into // that slice and return the number of bytes and a nil error, or it will // leave slice p as is and return 0, io.EOF. func (r *ReaderStream) Read(p []byte) (int, error) { if !r.initiated { panic("ReaderStream not created via NewReaderStream") } var ok bool r.stripEmpty() for !r.closed && len(r.current) == 0 { if r.first { r.first = false } else { r.done <- true } if r.current, ok = <-r.reassembled; ok { r.stripEmpty() } else { r.closed = true } } if len(r.current) > 0 { current := &r.current[0] if r.LossErrors && !r.lossReported && current.Skip != 0 { r.lossReported = true return 0, DataLost } length := copy(p, current.Bytes) current.Bytes = current.Bytes[length:] return length, nil } return 0, io.EOF } // Close implements io.Closer's Close function, making ReaderStream a // io.ReadCloser. It discards all remaining bytes in the reassembly in a // manner that's safe for the assembler (IE: it doesn't block). func (r *ReaderStream) Close() error { r.current = nil r.closed = true for { if _, ok := <-r.reassembled; !ok { return nil } r.done <- true } } mongo-tools-r3.6.3/vendor/src/github.com/google/gopacket/tcpassembly/tcpreader/reader_test.go000066400000000000000000000053071321131462300325060ustar00rootroot00000000000000// Copyright 2012 Google, Inc. All rights reserved. // // Use of this source code is governed by a BSD-style license // that can be found in the LICENSE file in the root of the source // tree. package tcpreader import ( "bytes" "fmt" "github.com/google/gopacket" "github.com/google/gopacket/layers" "github.com/google/gopacket/tcpassembly" "io" "net" "testing" ) var netFlow gopacket.Flow func init() { netFlow, _ = gopacket.FlowFromEndpoints( layers.NewIPEndpoint(net.IP{1, 2, 3, 4}), layers.NewIPEndpoint(net.IP{5, 6, 7, 8})) } type readReturn struct { data []byte err error } type readSequence struct { in []layers.TCP want []readReturn } type testReaderFactory struct { lossErrors bool readSize int ReaderStream output chan []byte } func (t *testReaderFactory) New(a, b gopacket.Flow) tcpassembly.Stream { return &t.ReaderStream } func testReadSequence(t *testing.T, lossErrors bool, readSize int, seq readSequence) { f := &testReaderFactory{ReaderStream: NewReaderStream()} f.ReaderStream.LossErrors = lossErrors p := tcpassembly.NewStreamPool(f) a := tcpassembly.NewAssembler(p) buf := make([]byte, readSize) go func() { for i, test := range seq.in { fmt.Println("Assembling", i) a.Assemble(netFlow, &test) fmt.Println("Assembly done") } }() for i, test := range seq.want { fmt.Println("Waiting for read", i) n, err := f.Read(buf[:]) fmt.Println("Got read") if n != len(test.data) { t.Errorf("test %d want %d bytes, got %d bytes", i, len(test.data), n) } else if err != test.err { t.Errorf("test %d want err %v, got err %v", i, test.err, err) } else if !bytes.Equal(buf[:n], test.data) { t.Errorf("test %d\nwant: %v\n got: %v\n", i, test.data, buf[:n]) } } fmt.Println("All done reads") } func TestRead(t *testing.T) { testReadSequence(t, false, 10, readSequence{ in: []layers.TCP{ { SYN: true, SrcPort: 1, DstPort: 2, Seq: 1000, BaseLayer: layers.BaseLayer{Payload: []byte{1, 2, 3}}, }, { FIN: true, SrcPort: 1, DstPort: 2, Seq: 1004, }, }, want: []readReturn{ {data: []byte{1, 2, 3}}, {err: io.EOF}, }, }) } func TestReadSmallChunks(t *testing.T) { testReadSequence(t, false, 2, readSequence{ in: []layers.TCP{ { SYN: true, SrcPort: 1, DstPort: 2, Seq: 1000, BaseLayer: layers.BaseLayer{Payload: []byte{1, 2, 3}}, }, { FIN: true, SrcPort: 1, DstPort: 2, Seq: 1004, }, }, want: []readReturn{ {data: []byte{1, 2}}, {data: []byte{3}}, {err: io.EOF}, }, }) } func ExampleDiscardBytesToEOF() { b := bytes.NewBuffer([]byte{1, 2, 3, 4, 5}) fmt.Println(DiscardBytesToEOF(b)) // Output: // 5 } mongo-tools-r3.6.3/vendor/src/github.com/google/gopacket/writer.go000066400000000000000000000173241321131462300252240ustar00rootroot00000000000000// Copyright 2012 Google, Inc. All rights reserved. // // Use of this source code is governed by a BSD-style license // that can be found in the LICENSE file in the root of the source // tree. package gopacket import () // SerializableLayer allows its implementations to be written out as a set of bytes, // so those bytes may be sent on the wire or otherwise used by the caller. // SerializableLayer is implemented by certain Layer types, and can be encoded to // bytes using the LayerWriter object. type SerializableLayer interface { // SerializeTo writes this layer to a slice, growing that slice if necessary // to make it fit the layer's data. // Args: // b: SerializeBuffer to write this layer on to. When called, b.Bytes() // is the payload this layer should wrap, if any. Note that this // layer can either prepend itself (common), append itself // (uncommon), or both (sometimes padding or footers are required at // the end of packet data). It's also possible (though probably very // rarely needed) to overwrite any bytes in the current payload. // After this call, b.Bytes() should return the byte encoding of // this layer wrapping the original b.Bytes() payload. // opts: options to use while writing out data. // Returns: // error if a problem was encountered during encoding. If an error is // returned, the bytes in data should be considered invalidated, and // not used. // // SerializeTo calls SHOULD entirely ignore LayerContents and // LayerPayload. It just serializes based on struct fields, neither // modifying nor using contents/payload. SerializeTo(b SerializeBuffer, opts SerializeOptions) error } // SerializeOptions provides options for behaviors that SerializableLayers may want to // implement. type SerializeOptions struct { // FixLengths determines whether, during serialization, layers should fix // the values for any length field that depends on the payload. FixLengths bool // ComputeChecksums determines whether, during serialization, layers // should recompute checksums based on their payloads. ComputeChecksums bool } // SerializeBuffer is a helper used by gopacket for writing out packet layers. // SerializeBuffer starts off as an empty []byte. Subsequent calls to PrependBytes // return byte slices before the current Bytes(), AppendBytes returns byte // slices after. // // Byte slices returned by PrependBytes/AppendBytes are NOT zero'd out, so if // you want to make sure they're all zeros, set them as such. // // SerializeBuffer is specifically designed to handle packet writing, where unlike // with normal writes it's easier to start writing at the inner-most layer and // work out, meaning that we often need to prepend bytes. This runs counter to // typical writes to byte slices using append(), where we only write at the end // of the buffer. // // It can be reused via Clear. Note, however, that a Clear call will invalidate the // byte slices returned by any previous Bytes() call (the same buffer is // reused). // // 1) Reusing a write buffer is generally much faster than creating a new one, // and with the default implementation it avoids additional memory allocations. // 2) If a byte slice from a previous Bytes() call will continue to be used, // it's better to create a new SerializeBuffer. // // The Clear method is specifically designed to minimize memory allocations for // similar later workloads on the SerializeBuffer. IE: if you make a set of // Prepend/Append calls, then clear, then make the same calls with the same // sizes, the second round (and all future similar rounds) shouldn't allocate // any new memory. type SerializeBuffer interface { // Bytes returns the contiguous set of bytes collected so far by Prepend/Append // calls. The slice returned by Bytes will be modified by future Clear calls, // so if you're planning on clearing this SerializeBuffer, you may want to copy // Bytes somewhere safe first. Bytes() []byte // PrependBytes returns a set of bytes which prepends the current bytes in this // buffer. These bytes start in an indeterminate state, so they should be // overwritten by the caller. The caller must only call PrependBytes if they // know they're going to immediately overwrite all bytes returned. PrependBytes(num int) ([]byte, error) // AppendBytes returns a set of bytes which prepends the current bytes in this // buffer. These bytes start in an indeterminate state, so they should be // overwritten by the caller. The caller must only call AppendBytes if they // know they're going to immediately overwrite all bytes returned. AppendBytes(num int) ([]byte, error) // Clear resets the SerializeBuffer to a new, empty buffer. After a call to clear, // the byte slice returned by any previous call to Bytes() for this buffer // should be considered invalidated. Clear() error } type serializeBuffer struct { data []byte start int prepended, appended int } // NewSerializeBuffer creates a new instance of the default implementation of // the SerializeBuffer interface. func NewSerializeBuffer() SerializeBuffer { return &serializeBuffer{} } // NewSerializeBufferExpectedSize creates a new buffer for serialization, optimized for an // expected number of bytes prepended/appended. This tends to decrease the // number of memory allocations made by the buffer during writes. func NewSerializeBufferExpectedSize(expectedPrependLength, expectedAppendLength int) SerializeBuffer { return &serializeBuffer{ data: make([]byte, expectedPrependLength, expectedPrependLength+expectedAppendLength), start: expectedPrependLength, prepended: expectedPrependLength, appended: expectedAppendLength, } } func (w *serializeBuffer) Bytes() []byte { return w.data[w.start:] } func (w *serializeBuffer) PrependBytes(num int) ([]byte, error) { if num < 0 { panic("num < 0") } if w.start < num { toPrepend := w.prepended if toPrepend < num { toPrepend = num } w.prepended += toPrepend length := cap(w.data) + toPrepend newData := make([]byte, length) newStart := w.start + toPrepend copy(newData[newStart:], w.data[w.start:]) w.start = newStart w.data = newData[:toPrepend+len(w.data)] } w.start -= num return w.data[w.start : w.start+num], nil } func (w *serializeBuffer) AppendBytes(num int) ([]byte, error) { if num < 0 { panic("num < 0") } initialLength := len(w.data) if cap(w.data)-initialLength < num { toAppend := w.appended if toAppend < num { toAppend = num } w.appended += toAppend newData := make([]byte, cap(w.data)+toAppend) copy(newData[w.start:], w.data[w.start:]) w.data = newData[:initialLength] } // Grow the buffer. We know it'll be under capacity given above. w.data = w.data[:initialLength+num] return w.data[initialLength:], nil } func (w *serializeBuffer) Clear() error { w.start = w.prepended w.data = w.data[:w.start] return nil } // SerializeLayers clears the given write buffer, then writes all layers into it so // they correctly wrap each other. Note that by clearing the buffer, it // invalidates all slices previously returned by w.Bytes() // // Example: // buf := gopacket.NewSerializeBuffer() // opts := gopacket.SerializeOptions{} // gopacket.SerializeLayers(buf, opts, a, b, c) // firstPayload := buf.Bytes() // contains byte representation of a(b(c)) // gopacket.SerializeLayers(buf, opts, d, e, f) // secondPayload := buf.Bytes() // contains byte representation of d(e(f)). firstPayload is now invalidated, since the SerializeLayers call Clears buf. func SerializeLayers(w SerializeBuffer, opts SerializeOptions, layers ...SerializableLayer) error { w.Clear() for i := len(layers) - 1; i >= 0; i-- { layer := layers[i] err := layer.SerializeTo(w, opts) if err != nil { return err } } return nil } mongo-tools-r3.6.3/vendor/src/github.com/google/gopacket/writer_test.go000066400000000000000000000033531321131462300262600ustar00rootroot00000000000000// Copyright 2012 Google, Inc. All rights reserved. // // Use of this source code is governed by a BSD-style license // that can be found in the LICENSE file in the root of the source // tree. package gopacket import ( "fmt" "testing" ) func TestExponentialSizeIncreasePrepend(t *testing.T) { var b serializeBuffer for i, test := range []struct { prepend, size int }{ {2, 2}, {2, 4}, {2, 8}, {2, 8}, {2, 16}, {2, 16}, {2, 16}, {2, 16}, {2, 32}, } { b.PrependBytes(test.prepend) if test.size != cap(b.data) { t.Error(i, "size want", test.size, "got", cap(b.data)) } } b.Clear() if b.start != 32 { t.Error(b.start) } } func TestExponentialSizeIncreaseAppend(t *testing.T) { var b serializeBuffer for i, test := range []struct { appnd, size int }{ {2, 2}, {2, 4}, {2, 8}, {2, 8}, {2, 16}, {2, 16}, {2, 16}, {2, 16}, {2, 32}, } { b.AppendBytes(test.appnd) if test.size != cap(b.data) { t.Error(i, "size want", test.size, "got", cap(b.data)) } } b.Clear() if b.start != 0 { t.Error(b.start) } } func ExampleSerializeBuffer() { b := NewSerializeBuffer() fmt.Println("1:", b.Bytes()) bytes, _ := b.PrependBytes(3) copy(bytes, []byte{1, 2, 3}) fmt.Println("2:", b.Bytes()) bytes, _ = b.AppendBytes(2) copy(bytes, []byte{4, 5}) fmt.Println("3:", b.Bytes()) bytes, _ = b.PrependBytes(1) copy(bytes, []byte{0}) fmt.Println("4:", b.Bytes()) bytes, _ = b.AppendBytes(3) copy(bytes, []byte{6, 7, 8}) fmt.Println("5:", b.Bytes()) b.Clear() fmt.Println("6:", b.Bytes()) bytes, _ = b.PrependBytes(2) copy(bytes, []byte{9, 9}) fmt.Println("7:", b.Bytes()) // Output: // 1: [] // 2: [1 2 3] // 3: [1 2 3 4 5] // 4: [0 1 2 3 4 5] // 5: [0 1 2 3 4 5 6 7 8] // 6: [] // 7: [9 9] } mongo-tools-r3.6.3/vendor/src/github.com/howeyc/000077500000000000000000000000001321131462300215775ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/howeyc/gopass/000077500000000000000000000000001321131462300230735ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/howeyc/gopass/LICENSE.txt000066400000000000000000000013261321131462300247200ustar00rootroot00000000000000Copyright (c) 2012 Chris Howey Permission to use, copy, modify, and distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies. THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. mongo-tools-r3.6.3/vendor/src/github.com/howeyc/gopass/README.md000066400000000000000000000007641321131462300243610ustar00rootroot00000000000000# getpasswd in Go [![GoDoc](https://godoc.org/github.com/howeyc/gopass?status.svg)](https://godoc.org/github.com/howeyc/gopass) Retrieve password from user terminal input without echo Verified on BSD, Linux, and Windows. Example: ```go package main import "fmt" import "github.com/howeyc/gopass" func main() { fmt.Printf("Password: ") pass := gopass.GetPasswd() // Silent, for *'s use gopass.GetPasswdMasked() // Do something with pass } ``` Caution: Multi-byte characters not supported! mongo-tools-r3.6.3/vendor/src/github.com/howeyc/gopass/nix.go000066400000000000000000000007241321131462300242230ustar00rootroot00000000000000// +build linux darwin freebsd netbsd openbsd package gopass import ( "io" "syscall" "golang.org/x/crypto/ssh/terminal" ) const lineEnding = "\n" func getch() (byte, error) { if oldState, err := terminal.MakeRaw(0); err != nil { return 0, err } else { defer terminal.Restore(0, oldState) } var buf [1]byte if n, err := syscall.Read(0, buf[:]); n == 0 || err != nil { if err != nil { return 0, err } return 0, io.EOF } return buf[0], nil } mongo-tools-r3.6.3/vendor/src/github.com/howeyc/gopass/pass.go000066400000000000000000000023341321131462300243720ustar00rootroot00000000000000package gopass import ( "errors" "os" ) var ( ErrInterrupted = errors.New("Interrupted") ) // getPasswd returns the input read from terminal. // If masked is true, typing will be matched by asterisks on the screen. // Otherwise, typing will echo nothing. func getPasswd(masked bool) ([]byte, error) { var err error var pass, bs, mask []byte if masked { bs = []byte("\b \b") mask = []byte("*") } for { if v, e := getch(); v == 127 || v == 8 { if l := len(pass); l > 0 { pass = pass[:l-1] os.Stdout.Write(bs) } } else if v == 13 || v == 10 { break } else if v == 3 { err = ErrInterrupted break } else if v != 0 { pass = append(pass, v) os.Stdout.Write(mask) } else if e != nil { err = e break } } os.Stdout.WriteString(lineEnding) return pass, err } // GetPasswd returns the password read from the terminal without echoing input. // The returned byte array does not include end-of-line characters. func GetPasswd() ([]byte, error) { return getPasswd(false) } // GetPasswdMasked returns the password read from the terminal, echoing asterisks. // The returned byte array does not include end-of-line characters. func GetPasswdMasked() ([]byte, error) { return getPasswd(true) } mongo-tools-r3.6.3/vendor/src/github.com/howeyc/gopass/win.go000066400000000000000000000021721321131462300242210ustar00rootroot00000000000000// +build windows package gopass import "errors" import "syscall" import "unsafe" import "unicode/utf16" const lineEnding = "\r\n" func getch() (byte, error) { modkernel32 := syscall.NewLazyDLL("kernel32.dll") procReadConsole := modkernel32.NewProc("ReadConsoleW") procGetConsoleMode := modkernel32.NewProc("GetConsoleMode") procSetConsoleMode := modkernel32.NewProc("SetConsoleMode") var mode uint32 pMode := &mode procGetConsoleMode.Call(uintptr(syscall.Stdin), uintptr(unsafe.Pointer(pMode))) var echoMode, lineMode uint32 echoMode = 4 lineMode = 2 var newMode uint32 newMode = mode &^ (echoMode | lineMode) procSetConsoleMode.Call(uintptr(syscall.Stdin), uintptr(newMode)) defer procSetConsoleMode.Call(uintptr(syscall.Stdin), uintptr(mode)) line := make([]uint16, 1) pLine := &line[0] var n uint16 procReadConsole.Call(uintptr(syscall.Stdin), uintptr(unsafe.Pointer(pLine)), uintptr(len(line)), uintptr(unsafe.Pointer(&n))) b := []byte(string(utf16.Decode(line))) // Not sure how this could happen, but it did for someone if len(b) > 0 { return b[0], nil } else { return 13, errors.New("Read error") } } mongo-tools-r3.6.3/vendor/src/github.com/jacobsa/000077500000000000000000000000001321131462300217035ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/jacobsa/oglematchers/000077500000000000000000000000001321131462300243605ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/jacobsa/oglematchers/.gitignore000066400000000000000000000000441321131462300263460ustar00rootroot00000000000000*.6 6.out _obj/ _test/ _testmain.go mongo-tools-r3.6.3/vendor/src/github.com/jacobsa/oglematchers/LICENSE000066400000000000000000000261361321131462300253750ustar00rootroot00000000000000 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. mongo-tools-r3.6.3/vendor/src/github.com/jacobsa/oglematchers/README.md000066400000000000000000000034651321131462300256470ustar00rootroot00000000000000[![GoDoc](https://godoc.org/github.com/jacobsa/oglematchers?status.svg)](https://godoc.org/github.com/jacobsa/oglematchers) `oglematchers` is a package for the Go programming language containing a set of matchers, useful in a testing or mocking framework, inspired by and mostly compatible with [Google Test][googletest] for C++ and [Google JS Test][google-js-test]. The package is used by the [ogletest][ogletest] testing framework and [oglemock][oglemock] mocking framework, which may be more directly useful to you, but can be generically used elsewhere as well. A "matcher" is simply an object with a `Matches` method defining a set of golang values matched by the matcher, and a `Description` method describing that set. For example, here are some matchers: ```go // Numbers Equals(17.13) LessThan(19) // Strings Equals("taco") HasSubstr("burrito") MatchesRegex("t.*o") // Combining matchers AnyOf(LessThan(17), GreaterThan(19)) ``` There are lots more; see [here][reference] for a reference. You can also add your own simply by implementing the `oglematchers.Matcher` interface. Installation ------------ First, make sure you have installed Go 1.0.2 or newer. See [here][golang-install] for instructions. Use the following command to install `oglematchers` and keep it up to date: go get -u github.com/jacobsa/oglematchers Documentation ------------- See [here][reference] for documentation. Alternatively, you can install the package and then use `godoc`: godoc github.com/jacobsa/oglematchers [reference]: http://godoc.org/github.com/jacobsa/oglematchers [golang-install]: http://golang.org/doc/install.html [googletest]: http://code.google.com/p/googletest/ [google-js-test]: http://code.google.com/p/google-js-test/ [ogletest]: http://github.com/jacobsa/ogletest [oglemock]: http://github.com/jacobsa/oglemock mongo-tools-r3.6.3/vendor/src/github.com/jacobsa/oglematchers/all_of.go000066400000000000000000000040011321131462300261360ustar00rootroot00000000000000// Copyright 2011 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers import ( "strings" ) // AllOf accepts a set of matchers S and returns a matcher that follows the // algorithm below when considering a candidate c: // // 1. Return true if for every Matcher m in S, m matches c. // // 2. Otherwise, if there is a matcher m in S such that m returns a fatal // error for c, return that matcher's error message. // // 3. Otherwise, return false with the error from some wrapped matcher. // // This is akin to a logical AND operation for matchers. func AllOf(matchers ...Matcher) Matcher { return &allOfMatcher{matchers} } type allOfMatcher struct { wrappedMatchers []Matcher } func (m *allOfMatcher) Description() string { // Special case: the empty set. if len(m.wrappedMatchers) == 0 { return "is anything" } // Join the descriptions for the wrapped matchers. wrappedDescs := make([]string, len(m.wrappedMatchers)) for i, wrappedMatcher := range m.wrappedMatchers { wrappedDescs[i] = wrappedMatcher.Description() } return strings.Join(wrappedDescs, ", and ") } func (m *allOfMatcher) Matches(c interface{}) (err error) { for _, wrappedMatcher := range m.wrappedMatchers { if wrappedErr := wrappedMatcher.Matches(c); wrappedErr != nil { err = wrappedErr // If the error is fatal, return immediately with this error. _, ok := wrappedErr.(*FatalError) if ok { return } } } return } mongo-tools-r3.6.3/vendor/src/github.com/jacobsa/oglematchers/all_of_test.go000066400000000000000000000053571321131462300272140ustar00rootroot00000000000000// Copyright 2011 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers_test import ( . "github.com/jacobsa/oglematchers" . "github.com/jacobsa/ogletest" "errors" ) //////////////////////////////////////////////////////////////////////// // Helpers //////////////////////////////////////////////////////////////////////// type allOfFakeMatcher struct { desc string err error } func (m *allOfFakeMatcher) Matches(c interface{}) error { return m.err } func (m *allOfFakeMatcher) Description() string { return m.desc } type AllOfTest struct { } func init() { RegisterTestSuite(&AllOfTest{}) } //////////////////////////////////////////////////////////////////////// // Tests //////////////////////////////////////////////////////////////////////// func (t *AllOfTest) DescriptionWithEmptySet() { m := AllOf() ExpectEq("is anything", m.Description()) } func (t *AllOfTest) DescriptionWithOneMatcher() { m := AllOf(&allOfFakeMatcher{"taco", errors.New("")}) ExpectEq("taco", m.Description()) } func (t *AllOfTest) DescriptionWithMultipleMatchers() { m := AllOf( &allOfFakeMatcher{"taco", errors.New("")}, &allOfFakeMatcher{"burrito", errors.New("")}, &allOfFakeMatcher{"enchilada", errors.New("")}) ExpectEq("taco, and burrito, and enchilada", m.Description()) } func (t *AllOfTest) EmptySet() { m := AllOf() err := m.Matches(17) ExpectEq(nil, err) } func (t *AllOfTest) OneMatcherReturnsFatalErrorAndSomeOthersFail() { m := AllOf( &allOfFakeMatcher{"", errors.New("")}, &allOfFakeMatcher{"", NewFatalError("taco")}, &allOfFakeMatcher{"", errors.New("")}, &allOfFakeMatcher{"", nil}) err := m.Matches(17) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("taco"))) } func (t *AllOfTest) OneMatcherReturnsNonFatalAndOthersSayTrue() { m := AllOf( &allOfFakeMatcher{"", nil}, &allOfFakeMatcher{"", errors.New("taco")}, &allOfFakeMatcher{"", nil}) err := m.Matches(17) ExpectFalse(isFatal(err)) ExpectThat(err, Error(Equals("taco"))) } func (t *AllOfTest) AllMatchersSayTrue() { m := AllOf( &allOfFakeMatcher{"", nil}, &allOfFakeMatcher{"", nil}, &allOfFakeMatcher{"", nil}) err := m.Matches(17) ExpectEq(nil, err) } mongo-tools-r3.6.3/vendor/src/github.com/jacobsa/oglematchers/any.go000066400000000000000000000016551321131462300255050ustar00rootroot00000000000000// Copyright 2011 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers // Any returns a matcher that matches any value. func Any() Matcher { return &anyMatcher{} } type anyMatcher struct { } func (m *anyMatcher) Description() string { return "is anything" } func (m *anyMatcher) Matches(c interface{}) error { return nil } mongo-tools-r3.6.3/vendor/src/github.com/jacobsa/oglematchers/any_of.go000066400000000000000000000051371321131462300261700ustar00rootroot00000000000000// Copyright 2011 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers import ( "errors" "fmt" "reflect" "strings" ) // AnyOf accepts a set of values S and returns a matcher that follows the // algorithm below when considering a candidate c: // // 1. If there exists a value m in S such that m implements the Matcher // interface and m matches c, return true. // // 2. Otherwise, if there exists a value v in S such that v does not implement // the Matcher interface and the matcher Equals(v) matches c, return true. // // 3. Otherwise, if there is a value m in S such that m implements the Matcher // interface and m returns a fatal error for c, return that fatal error. // // 4. Otherwise, return false. // // This is akin to a logical OR operation for matchers, with non-matchers x // being treated as Equals(x). func AnyOf(vals ...interface{}) Matcher { // Get ahold of a type variable for the Matcher interface. var dummy *Matcher matcherType := reflect.TypeOf(dummy).Elem() // Create a matcher for each value, or use the value itself if it's already a // matcher. wrapped := make([]Matcher, len(vals)) for i, v := range vals { t := reflect.TypeOf(v) if t != nil && t.Implements(matcherType) { wrapped[i] = v.(Matcher) } else { wrapped[i] = Equals(v) } } return &anyOfMatcher{wrapped} } type anyOfMatcher struct { wrapped []Matcher } func (m *anyOfMatcher) Description() string { wrappedDescs := make([]string, len(m.wrapped)) for i, matcher := range m.wrapped { wrappedDescs[i] = matcher.Description() } return fmt.Sprintf("or(%s)", strings.Join(wrappedDescs, ", ")) } func (m *anyOfMatcher) Matches(c interface{}) (err error) { err = errors.New("") // Try each matcher in turn. for _, matcher := range m.wrapped { wrappedErr := matcher.Matches(c) // Return immediately if there's a match. if wrappedErr == nil { err = nil return } // Note the fatal error, if any. if _, isFatal := wrappedErr.(*FatalError); isFatal { err = wrappedErr } } return } mongo-tools-r3.6.3/vendor/src/github.com/jacobsa/oglematchers/any_of_test.go000066400000000000000000000060151321131462300272230ustar00rootroot00000000000000// Copyright 2011 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers_test import ( "errors" . "github.com/jacobsa/oglematchers" . "github.com/jacobsa/ogletest" ) //////////////////////////////////////////////////////////////////////// // Helpers //////////////////////////////////////////////////////////////////////// type fakeAnyOfMatcher struct { desc string err error } func (m *fakeAnyOfMatcher) Matches(c interface{}) error { return m.err } func (m *fakeAnyOfMatcher) Description() string { return m.desc } type AnyOfTest struct { } func init() { RegisterTestSuite(&AnyOfTest{}) } //////////////////////////////////////////////////////////////////////// // Tests //////////////////////////////////////////////////////////////////////// func (t *AnyOfTest) EmptySet() { matcher := AnyOf() err := matcher.Matches(0) ExpectThat(err, Error(Equals(""))) } func (t *AnyOfTest) OneTrue() { matcher := AnyOf( &fakeAnyOfMatcher{"", NewFatalError("foo")}, 17, &fakeAnyOfMatcher{"", errors.New("foo")}, &fakeAnyOfMatcher{"", nil}, &fakeAnyOfMatcher{"", errors.New("foo")}, ) err := matcher.Matches(0) ExpectEq(nil, err) } func (t *AnyOfTest) OneEqual() { matcher := AnyOf( &fakeAnyOfMatcher{"", NewFatalError("foo")}, &fakeAnyOfMatcher{"", errors.New("foo")}, 13, "taco", 19, &fakeAnyOfMatcher{"", errors.New("foo")}, ) err := matcher.Matches("taco") ExpectEq(nil, err) } func (t *AnyOfTest) OneFatal() { matcher := AnyOf( &fakeAnyOfMatcher{"", errors.New("foo")}, 17, &fakeAnyOfMatcher{"", NewFatalError("taco")}, &fakeAnyOfMatcher{"", errors.New("foo")}, ) err := matcher.Matches(0) ExpectThat(err, Error(Equals("taco"))) } func (t *AnyOfTest) OneNil() { var err error matcher := AnyOf( 13, nil, 19, ) // No match err = matcher.Matches(14) ExpectNe(nil, err) // Match err = matcher.Matches(nil) ExpectEq(nil, err) } func (t *AnyOfTest) AllFalseAndNotEqual() { matcher := AnyOf( &fakeAnyOfMatcher{"", errors.New("foo")}, 17, &fakeAnyOfMatcher{"", errors.New("foo")}, 19, ) err := matcher.Matches(0) ExpectThat(err, Error(Equals(""))) } func (t *AnyOfTest) DescriptionForEmptySet() { matcher := AnyOf() ExpectEq("or()", matcher.Description()) } func (t *AnyOfTest) DescriptionForNonEmptySet() { matcher := AnyOf( &fakeAnyOfMatcher{"taco", nil}, "burrito", &fakeAnyOfMatcher{"enchilada", nil}, ) ExpectEq("or(taco, burrito, enchilada)", matcher.Description()) } mongo-tools-r3.6.3/vendor/src/github.com/jacobsa/oglematchers/any_test.go000066400000000000000000000026351321131462300265430ustar00rootroot00000000000000// Copyright 2011 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers_test import ( . "github.com/jacobsa/oglematchers" . "github.com/jacobsa/ogletest" ) //////////////////////////////////////////////////////////////////////// // Helpers //////////////////////////////////////////////////////////////////////// type AnyTest struct { } func init() { RegisterTestSuite(&AnyTest{}) } //////////////////////////////////////////////////////////////////////// // Tests //////////////////////////////////////////////////////////////////////// func (t *AnyTest) Description() { m := Any() ExpectEq("is anything", m.Description()) } func (t *AnyTest) Matches() { var err error m := Any() err = m.Matches(nil) ExpectEq(nil, err) err = m.Matches(17) ExpectEq(nil, err) err = m.Matches("taco") ExpectEq(nil, err) } mongo-tools-r3.6.3/vendor/src/github.com/jacobsa/oglematchers/contains.go000066400000000000000000000033271321131462300265320ustar00rootroot00000000000000// Copyright 2012 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers import ( "fmt" "reflect" ) // Return a matcher that matches arrays slices with at least one element that // matches the supplied argument. If the argument x is not itself a Matcher, // this is equivalent to Contains(Equals(x)). func Contains(x interface{}) Matcher { var result containsMatcher var ok bool if result.elementMatcher, ok = x.(Matcher); !ok { result.elementMatcher = Equals(x) } return &result } type containsMatcher struct { elementMatcher Matcher } func (m *containsMatcher) Description() string { return fmt.Sprintf("contains: %s", m.elementMatcher.Description()) } func (m *containsMatcher) Matches(candidate interface{}) error { // The candidate must be a slice or an array. v := reflect.ValueOf(candidate) if v.Kind() != reflect.Slice && v.Kind() != reflect.Array { return NewFatalError("which is not a slice or array") } // Check each element. for i := 0; i < v.Len(); i++ { elem := v.Index(i) if matchErr := m.elementMatcher.Matches(elem.Interface()); matchErr == nil { return nil } } return fmt.Errorf("") } mongo-tools-r3.6.3/vendor/src/github.com/jacobsa/oglematchers/contains_test.go000066400000000000000000000133521321131462300275700ustar00rootroot00000000000000// Copyright 2012 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers_test import ( . "github.com/jacobsa/oglematchers" . "github.com/jacobsa/ogletest" ) //////////////////////////////////////////////////////////////////////// // Helpers //////////////////////////////////////////////////////////////////////// type ContainsTest struct {} func init() { RegisterTestSuite(&ContainsTest{}) } //////////////////////////////////////////////////////////////////////// // Tests //////////////////////////////////////////////////////////////////////// func (t *ContainsTest) WrongTypeCandidates() { m := Contains("") ExpectEq("contains: ", m.Description()) var err error // Nil candidate err = m.Matches(nil) ExpectTrue(isFatal(err)) ExpectThat(err, Error(HasSubstr("array"))) ExpectThat(err, Error(HasSubstr("slice"))) // String candidate err = m.Matches("") ExpectTrue(isFatal(err)) ExpectThat(err, Error(HasSubstr("array"))) ExpectThat(err, Error(HasSubstr("slice"))) // Map candidate err = m.Matches(make(map[string]string)) ExpectTrue(isFatal(err)) ExpectThat(err, Error(HasSubstr("array"))) ExpectThat(err, Error(HasSubstr("slice"))) } func (t *ContainsTest) NilArgument() { m := Contains(nil) ExpectEq("contains: is nil", m.Description()) var c interface{} var err error // Empty array of pointers c = [...]*int{} err = m.Matches(c) ExpectThat(err, Error(Equals(""))) // Empty slice of pointers c = []*int{} err = m.Matches(c) ExpectThat(err, Error(Equals(""))) // Non-empty array of integers c = [...]int{17, 0, 19} err = m.Matches(c) ExpectThat(err, Error(Equals(""))) // Non-empty slice of integers c = []int{17, 0, 19} err = m.Matches(c) ExpectThat(err, Error(Equals(""))) // Non-matching array of pointers c = [...]*int{new(int), new(int)} err = m.Matches(c) ExpectThat(err, Error(Equals(""))) // Non-matching slice of pointers c = []*int{new(int), new(int)} err = m.Matches(c) ExpectThat(err, Error(Equals(""))) // Matching array of pointers c = [...]*int{new(int), nil, new(int)} err = m.Matches(c) ExpectEq(nil, err) // Matching slice of pointers c = []*int{new(int), nil, new(int)} err = m.Matches(c) ExpectEq(nil, err) // Non-matching slice of pointers from matching array someArray := [...]*int{new(int), nil, new(int)} c = someArray[0:1] err = m.Matches(c) ExpectThat(err, Error(Equals(""))) } func (t *ContainsTest) StringArgument() { m := Contains("taco") ExpectEq("contains: taco", m.Description()) var c interface{} var err error // Non-matching array of strings c = [...]string{"burrito", "enchilada"} err = m.Matches(c) ExpectThat(err, Error(Equals(""))) // Non-matching slice of strings c = []string{"burrito", "enchilada"} err = m.Matches(c) ExpectThat(err, Error(Equals(""))) // Matching array of strings c = [...]string{"burrito", "taco", "enchilada"} err = m.Matches(c) ExpectEq(nil, err) // Matching slice of strings c = []string{"burrito", "taco", "enchilada"} err = m.Matches(c) ExpectEq(nil, err) // Non-matching slice of strings from matching array someArray := [...]string{"burrito", "taco", "enchilada"} c = someArray[0:1] err = m.Matches(c) ExpectThat(err, Error(Equals(""))) } func (t *ContainsTest) IntegerArgument() { m := Contains(int(17)) ExpectEq("contains: 17", m.Description()) var c interface{} var err error // Non-matching array of integers c = [...]int{13, 19} err = m.Matches(c) ExpectThat(err, Error(Equals(""))) // Non-matching slice of integers c = []int{13, 19} err = m.Matches(c) ExpectThat(err, Error(Equals(""))) // Matching array of integers c = [...]int{13, 17, 19} err = m.Matches(c) ExpectEq(nil, err) // Matching slice of integers c = []int{13, 17, 19} err = m.Matches(c) ExpectEq(nil, err) // Non-matching slice of integers from matching array someArray := [...]int{13, 17, 19} c = someArray[0:1] err = m.Matches(c) ExpectThat(err, Error(Equals(""))) // Non-matching array of floats c = [...]float32{13, 17.5, 19} err = m.Matches(c) ExpectThat(err, Error(Equals(""))) // Non-matching slice of floats c = []float32{13, 17.5, 19} err = m.Matches(c) ExpectThat(err, Error(Equals(""))) // Matching array of floats c = [...]float32{13, 17, 19} err = m.Matches(c) ExpectEq(nil, err) // Matching slice of floats c = []float32{13, 17, 19} err = m.Matches(c) ExpectEq(nil, err) } func (t *ContainsTest) MatcherArgument() { m := Contains(HasSubstr("ac")) ExpectEq("contains: has substring \"ac\"", m.Description()) var c interface{} var err error // Non-matching array of strings c = [...]string{"burrito", "enchilada"} err = m.Matches(c) ExpectThat(err, Error(Equals(""))) // Non-matching slice of strings c = []string{"burrito", "enchilada"} err = m.Matches(c) ExpectThat(err, Error(Equals(""))) // Matching array of strings c = [...]string{"burrito", "taco", "enchilada"} err = m.Matches(c) ExpectEq(nil, err) // Matching slice of strings c = []string{"burrito", "taco", "enchilada"} err = m.Matches(c) ExpectEq(nil, err) // Non-matching slice of strings from matching array someArray := [...]string{"burrito", "taco", "enchilada"} c = someArray[0:1] err = m.Matches(c) ExpectThat(err, Error(Equals(""))) } mongo-tools-r3.6.3/vendor/src/github.com/jacobsa/oglematchers/deep_equals.go000066400000000000000000000045201321131462300271770ustar00rootroot00000000000000// Copyright 2012 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers import ( "bytes" "errors" "fmt" "reflect" ) var byteSliceType reflect.Type = reflect.TypeOf([]byte{}) // DeepEquals returns a matcher that matches based on 'deep equality', as // defined by the reflect package. This matcher requires that values have // identical types to x. func DeepEquals(x interface{}) Matcher { return &deepEqualsMatcher{x} } type deepEqualsMatcher struct { x interface{} } func (m *deepEqualsMatcher) Description() string { xDesc := fmt.Sprintf("%v", m.x) xValue := reflect.ValueOf(m.x) // Special case: fmt.Sprintf presents nil slices as "[]", but // reflect.DeepEqual makes a distinction between nil and empty slices. Make // this less confusing. if xValue.Kind() == reflect.Slice && xValue.IsNil() { xDesc = "" } return fmt.Sprintf("deep equals: %s", xDesc) } func (m *deepEqualsMatcher) Matches(c interface{}) error { // Make sure the types match. ct := reflect.TypeOf(c) xt := reflect.TypeOf(m.x) if ct != xt { return NewFatalError(fmt.Sprintf("which is of type %v", ct)) } // Special case: handle byte slices more efficiently. cValue := reflect.ValueOf(c) xValue := reflect.ValueOf(m.x) if ct == byteSliceType && !cValue.IsNil() && !xValue.IsNil() { xBytes := m.x.([]byte) cBytes := c.([]byte) if bytes.Equal(cBytes, xBytes) { return nil } return errors.New("") } // Defer to the reflect package. if reflect.DeepEqual(m.x, c) { return nil } // Special case: if the comparison failed because c is the nil slice, given // an indication of this (since its value is printed as "[]"). if cValue.Kind() == reflect.Slice && cValue.IsNil() { return errors.New("which is nil") } return errors.New("") } mongo-tools-r3.6.3/vendor/src/github.com/jacobsa/oglematchers/deep_equals_test.go000066400000000000000000000173111321131462300302400ustar00rootroot00000000000000// Copyright 2012 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers_test import ( . "github.com/jacobsa/oglematchers" . "github.com/jacobsa/ogletest" "bytes" "testing" ) //////////////////////////////////////////////////////////////////////// // Helpers //////////////////////////////////////////////////////////////////////// type DeepEqualsTest struct {} func init() { RegisterTestSuite(&DeepEqualsTest{}) } //////////////////////////////////////////////////////////////////////// // Tests //////////////////////////////////////////////////////////////////////// func (t *DeepEqualsTest) WrongTypeCandidateWithScalarValue() { var x int = 17 m := DeepEquals(x) var err error // Nil candidate. err = m.Matches(nil) AssertNe(nil, err) ExpectTrue(isFatal(err)) ExpectThat(err, Error(HasSubstr("type"))) ExpectThat(err, Error(HasSubstr(""))) // Int alias candidate. type intAlias int err = m.Matches(intAlias(x)) AssertNe(nil, err) ExpectTrue(isFatal(err)) ExpectThat(err, Error(HasSubstr("type"))) ExpectThat(err, Error(HasSubstr("intAlias"))) // String candidate. err = m.Matches("taco") AssertNe(nil, err) ExpectTrue(isFatal(err)) ExpectThat(err, Error(HasSubstr("type"))) ExpectThat(err, Error(HasSubstr("string"))) // Byte slice candidate. err = m.Matches([]byte{}) AssertNe(nil, err) ExpectTrue(isFatal(err)) ExpectThat(err, Error(HasSubstr("type"))) ExpectThat(err, Error(HasSubstr("[]uint8"))) // Other slice candidate. err = m.Matches([]uint16{}) AssertNe(nil, err) ExpectTrue(isFatal(err)) ExpectThat(err, Error(HasSubstr("type"))) ExpectThat(err, Error(HasSubstr("[]uint16"))) // Unsigned int candidate. err = m.Matches(uint(17)) AssertNe(nil, err) ExpectTrue(isFatal(err)) ExpectThat(err, Error(HasSubstr("type"))) ExpectThat(err, Error(HasSubstr("uint"))) } func (t *DeepEqualsTest) WrongTypeCandidateWithByteSliceValue() { x := []byte{} m := DeepEquals(x) var err error // Nil candidate. err = m.Matches(nil) AssertNe(nil, err) ExpectTrue(isFatal(err)) ExpectThat(err, Error(HasSubstr("type"))) ExpectThat(err, Error(HasSubstr(""))) // String candidate. err = m.Matches("taco") AssertNe(nil, err) ExpectTrue(isFatal(err)) ExpectThat(err, Error(HasSubstr("type"))) ExpectThat(err, Error(HasSubstr("string"))) // Slice candidate with wrong value type. err = m.Matches([]uint16{}) AssertNe(nil, err) ExpectTrue(isFatal(err)) ExpectThat(err, Error(HasSubstr("type"))) ExpectThat(err, Error(HasSubstr("[]uint16"))) } func (t *DeepEqualsTest) WrongTypeCandidateWithOtherSliceValue() { x := []uint16{} m := DeepEquals(x) var err error // Nil candidate. err = m.Matches(nil) AssertNe(nil, err) ExpectTrue(isFatal(err)) ExpectThat(err, Error(HasSubstr("type"))) ExpectThat(err, Error(HasSubstr(""))) // String candidate. err = m.Matches("taco") AssertNe(nil, err) ExpectTrue(isFatal(err)) ExpectThat(err, Error(HasSubstr("type"))) ExpectThat(err, Error(HasSubstr("string"))) // Byte slice candidate with wrong value type. err = m.Matches([]byte{}) AssertNe(nil, err) ExpectTrue(isFatal(err)) ExpectThat(err, Error(HasSubstr("type"))) ExpectThat(err, Error(HasSubstr("[]uint8"))) // Other slice candidate with wrong value type. err = m.Matches([]uint32{}) AssertNe(nil, err) ExpectTrue(isFatal(err)) ExpectThat(err, Error(HasSubstr("type"))) ExpectThat(err, Error(HasSubstr("[]uint32"))) } func (t *DeepEqualsTest) WrongTypeCandidateWithNilLiteralValue() { m := DeepEquals(nil) var err error // String candidate. err = m.Matches("taco") AssertNe(nil, err) ExpectTrue(isFatal(err)) ExpectThat(err, Error(HasSubstr("type"))) ExpectThat(err, Error(HasSubstr("string"))) // Nil byte slice candidate. err = m.Matches([]byte(nil)) AssertNe(nil, err) ExpectTrue(isFatal(err)) ExpectThat(err, Error(HasSubstr("type"))) ExpectThat(err, Error(HasSubstr("[]uint8"))) // Nil other slice candidate. err = m.Matches([]uint16(nil)) AssertNe(nil, err) ExpectTrue(isFatal(err)) ExpectThat(err, Error(HasSubstr("type"))) ExpectThat(err, Error(HasSubstr("[]uint16"))) } func (t *DeepEqualsTest) NilLiteralValue() { m := DeepEquals(nil) ExpectEq("deep equals: ", m.Description()) var c interface{} var err error // Nil literal candidate. c = nil err = m.Matches(c) ExpectEq(nil, err) } func (t *DeepEqualsTest) IntValue() { m := DeepEquals(int(17)) ExpectEq("deep equals: 17", m.Description()) var c interface{} var err error // Matching int. c = int(17) err = m.Matches(c) ExpectEq(nil, err) // Non-matching int. c = int(18) err = m.Matches(c) ExpectThat(err, Error(Equals(""))) } func (t *DeepEqualsTest) ByteSliceValue() { x := []byte{17, 19} m := DeepEquals(x) ExpectEq("deep equals: [17 19]", m.Description()) var c []byte var err error // Matching. c = make([]byte, len(x)) AssertEq(len(x), copy(c, x)) err = m.Matches(c) ExpectEq(nil, err) // Nil slice. c = []byte(nil) err = m.Matches(c) ExpectThat(err, Error(Equals("which is nil"))) // Prefix. AssertGt(len(x), 1) c = make([]byte, len(x)-1) AssertEq(len(x)-1, copy(c, x)) err = m.Matches(c) ExpectThat(err, Error(Equals(""))) // Suffix. c = make([]byte, len(x)+1) AssertEq(len(x), copy(c, x)) err = m.Matches(c) ExpectThat(err, Error(Equals(""))) } func (t *DeepEqualsTest) OtherSliceValue() { x := []uint16{17, 19} m := DeepEquals(x) ExpectEq("deep equals: [17 19]", m.Description()) var c []uint16 var err error // Matching. c = make([]uint16, len(x)) AssertEq(len(x), copy(c, x)) err = m.Matches(c) ExpectEq(nil, err) // Nil slice. c = []uint16(nil) err = m.Matches(c) ExpectThat(err, Error(Equals("which is nil"))) // Prefix. AssertGt(len(x), 1) c = make([]uint16, len(x)-1) AssertEq(len(x)-1, copy(c, x)) err = m.Matches(c) ExpectThat(err, Error(Equals(""))) // Suffix. c = make([]uint16, len(x)+1) AssertEq(len(x), copy(c, x)) err = m.Matches(c) ExpectThat(err, Error(Equals(""))) } func (t *DeepEqualsTest) NilByteSliceValue() { x := []byte(nil) m := DeepEquals(x) ExpectEq("deep equals: ", m.Description()) var c []byte var err error // Nil slice. c = []byte(nil) err = m.Matches(c) ExpectEq(nil, err) // Non-nil slice. c = []byte{} err = m.Matches(c) ExpectThat(err, Error(Equals(""))) } func (t *DeepEqualsTest) NilOtherSliceValue() { x := []uint16(nil) m := DeepEquals(x) ExpectEq("deep equals: ", m.Description()) var c []uint16 var err error // Nil slice. c = []uint16(nil) err = m.Matches(c) ExpectEq(nil, err) // Non-nil slice. c = []uint16{} err = m.Matches(c) ExpectThat(err, Error(Equals(""))) } //////////////////////////////////////////////////////////////////////// // Benchmarks //////////////////////////////////////////////////////////////////////// func benchmarkWithSize(b *testing.B, size int) { b.StopTimer() buf := bytes.Repeat([]byte{0x01}, size) bufCopy := make([]byte, size) copy(bufCopy, buf) matcher := DeepEquals(buf) b.StartTimer() for i := 0; i < b.N; i++ { matcher.Matches(bufCopy) } b.SetBytes(int64(size)) } func BenchmarkShortByteSlice(b *testing.B) { benchmarkWithSize(b, 256) } func BenchmarkLongByteSlice(b *testing.B) { benchmarkWithSize(b, 1<<24) } mongo-tools-r3.6.3/vendor/src/github.com/jacobsa/oglematchers/elements_are.go000066400000000000000000000050621321131462300273550ustar00rootroot00000000000000// Copyright 2012 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers import ( "errors" "fmt" "reflect" "strings" ) // Given a list of arguments M, ElementsAre returns a matcher that matches // arrays and slices A where all of the following hold: // // * A is the same length as M. // // * For each i < len(A) where M[i] is a matcher, A[i] matches M[i]. // // * For each i < len(A) where M[i] is not a matcher, A[i] matches // Equals(M[i]). // func ElementsAre(M ...interface{}) Matcher { // Copy over matchers, or convert to Equals(x) for non-matcher x. subMatchers := make([]Matcher, len(M)) for i, x := range M { if matcher, ok := x.(Matcher); ok { subMatchers[i] = matcher continue } subMatchers[i] = Equals(x) } return &elementsAreMatcher{subMatchers} } type elementsAreMatcher struct { subMatchers []Matcher } func (m *elementsAreMatcher) Description() string { subDescs := make([]string, len(m.subMatchers)) for i, sm := range m.subMatchers { subDescs[i] = sm.Description() } return fmt.Sprintf("elements are: [%s]", strings.Join(subDescs, ", ")) } func (m *elementsAreMatcher) Matches(candidates interface{}) error { // The candidate must be a slice or an array. v := reflect.ValueOf(candidates) if v.Kind() != reflect.Slice && v.Kind() != reflect.Array { return NewFatalError("which is not a slice or array") } // The length must be correct. if v.Len() != len(m.subMatchers) { return errors.New(fmt.Sprintf("which is of length %d", v.Len())) } // Check each element. for i, subMatcher := range m.subMatchers { c := v.Index(i) if matchErr := subMatcher.Matches(c.Interface()); matchErr != nil { // Return an errors indicating which element doesn't match. If the // matcher error was fatal, make this one fatal too. err := errors.New(fmt.Sprintf("whose element %d doesn't match", i)) if _, isFatal := matchErr.(*FatalError); isFatal { err = NewFatalError(err.Error()) } return err } } return nil } mongo-tools-r3.6.3/vendor/src/github.com/jacobsa/oglematchers/elements_are_test.go000066400000000000000000000115571321131462300304220ustar00rootroot00000000000000// Copyright 2012 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers_test import ( . "github.com/jacobsa/oglematchers" . "github.com/jacobsa/ogletest" ) //////////////////////////////////////////////////////////////////////// // Helpers //////////////////////////////////////////////////////////////////////// type ElementsAreTest struct { } func init() { RegisterTestSuite(&ElementsAreTest{}) } //////////////////////////////////////////////////////////////////////// // Tests //////////////////////////////////////////////////////////////////////// func (t *ElementsAreTest) EmptySet() { m := ElementsAre() ExpectEq("elements are: []", m.Description()) var c []interface{} var err error // No candidates. c = []interface{}{} err = m.Matches(c) ExpectEq(nil, err) // One candidate. c = []interface{}{17} err = m.Matches(c) ExpectThat(err, Error(HasSubstr("length 1"))) } func (t *ElementsAreTest) OneMatcher() { m := ElementsAre(LessThan(17)) ExpectEq("elements are: [less than 17]", m.Description()) var c []interface{} var err error // No candidates. c = []interface{}{} err = m.Matches(c) ExpectThat(err, Error(HasSubstr("length 0"))) // Matching candidate. c = []interface{}{16} err = m.Matches(c) ExpectEq(nil, err) // Non-matching candidate. c = []interface{}{19} err = m.Matches(c) ExpectNe(nil, err) // Two candidates. c = []interface{}{17, 19} err = m.Matches(c) ExpectThat(err, Error(HasSubstr("length 2"))) } func (t *ElementsAreTest) OneValue() { m := ElementsAre(17) ExpectEq("elements are: [17]", m.Description()) var c []interface{} var err error // No candidates. c = []interface{}{} err = m.Matches(c) ExpectThat(err, Error(HasSubstr("length 0"))) // Matching int. c = []interface{}{int(17)} err = m.Matches(c) ExpectEq(nil, err) // Matching float. c = []interface{}{float32(17)} err = m.Matches(c) ExpectEq(nil, err) // Non-matching candidate. c = []interface{}{19} err = m.Matches(c) ExpectNe(nil, err) // Two candidates. c = []interface{}{17, 19} err = m.Matches(c) ExpectThat(err, Error(HasSubstr("length 2"))) } func (t *ElementsAreTest) MultipleElements() { m := ElementsAre("taco", LessThan(17)) ExpectEq("elements are: [taco, less than 17]", m.Description()) var c []interface{} var err error // One candidate. c = []interface{}{17} err = m.Matches(c) ExpectThat(err, Error(HasSubstr("length 1"))) // Both matching. c = []interface{}{"taco", 16} err = m.Matches(c) ExpectEq(nil, err) // First non-matching. c = []interface{}{"burrito", 16} err = m.Matches(c) ExpectThat(err, Error(Equals("whose element 0 doesn't match"))) // Second non-matching. c = []interface{}{"taco", 17} err = m.Matches(c) ExpectThat(err, Error(Equals("whose element 1 doesn't match"))) // Three candidates. c = []interface{}{"taco", 17, 19} err = m.Matches(c) ExpectThat(err, Error(HasSubstr("length 3"))) } func (t *ElementsAreTest) ArrayCandidates() { m := ElementsAre("taco", LessThan(17)) var err error // One candidate. err = m.Matches([1]interface{}{"taco"}) ExpectThat(err, Error(HasSubstr("length 1"))) // Both matching. err = m.Matches([2]interface{}{"taco", 16}) ExpectEq(nil, err) // First non-matching. err = m.Matches([2]interface{}{"burrito", 16}) ExpectThat(err, Error(Equals("whose element 0 doesn't match"))) } func (t *ElementsAreTest) WrongTypeCandidate() { m := ElementsAre("taco") var err error // String candidate. err = m.Matches("taco") ExpectTrue(isFatal(err)) ExpectThat(err, Error(HasSubstr("array"))) ExpectThat(err, Error(HasSubstr("slice"))) // Map candidate. err = m.Matches(map[string]string{}) ExpectTrue(isFatal(err)) ExpectThat(err, Error(HasSubstr("array"))) ExpectThat(err, Error(HasSubstr("slice"))) // Nil candidate. err = m.Matches(nil) ExpectTrue(isFatal(err)) ExpectThat(err, Error(HasSubstr("array"))) ExpectThat(err, Error(HasSubstr("slice"))) } func (t *ElementsAreTest) PropagatesFatality() { m := ElementsAre(LessThan(17)) ExpectEq("elements are: [less than 17]", m.Description()) var c []interface{} var err error // Non-fatal error. c = []interface{}{19} err = m.Matches(c) AssertNe(nil, err) ExpectFalse(isFatal(err)) // Fatal error. c = []interface{}{"taco"} err = m.Matches(c) AssertNe(nil, err) ExpectTrue(isFatal(err)) } mongo-tools-r3.6.3/vendor/src/github.com/jacobsa/oglematchers/equals.go000066400000000000000000000314161321131462300262060ustar00rootroot00000000000000// Copyright 2011 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers import ( "errors" "fmt" "math" "reflect" ) // Equals(x) returns a matcher that matches values v such that v and x are // equivalent. This includes the case when the comparison v == x using Go's // built-in comparison operator is legal (except for structs, which this // matcher does not support), but for convenience the following rules also // apply: // // * Type checking is done based on underlying types rather than actual // types, so that e.g. two aliases for string can be compared: // // type stringAlias1 string // type stringAlias2 string // // a := "taco" // b := stringAlias1("taco") // c := stringAlias2("taco") // // ExpectTrue(a == b) // Legal, passes // ExpectTrue(b == c) // Illegal, doesn't compile // // ExpectThat(a, Equals(b)) // Passes // ExpectThat(b, Equals(c)) // Passes // // * Values of numeric type are treated as if they were abstract numbers, and // compared accordingly. Therefore Equals(17) will match int(17), // int16(17), uint(17), float32(17), complex64(17), and so on. // // If you want a stricter matcher that contains no such cleverness, see // IdenticalTo instead. // // Arrays are supported by this matcher, but do not participate in the // exceptions above. Two arrays compared with this matcher must have identical // types, and their element type must itself be comparable according to Go's == // operator. func Equals(x interface{}) Matcher { v := reflect.ValueOf(x) // This matcher doesn't support structs. if v.Kind() == reflect.Struct { panic(fmt.Sprintf("oglematchers.Equals: unsupported kind %v", v.Kind())) } // The == operator is not defined for non-nil slices. if v.Kind() == reflect.Slice && v.Pointer() != uintptr(0) { panic(fmt.Sprintf("oglematchers.Equals: non-nil slice")) } return &equalsMatcher{v} } type equalsMatcher struct { expectedValue reflect.Value } //////////////////////////////////////////////////////////////////////// // Numeric types //////////////////////////////////////////////////////////////////////// func isSignedInteger(v reflect.Value) bool { k := v.Kind() return k >= reflect.Int && k <= reflect.Int64 } func isUnsignedInteger(v reflect.Value) bool { k := v.Kind() return k >= reflect.Uint && k <= reflect.Uint64 } func isInteger(v reflect.Value) bool { return isSignedInteger(v) || isUnsignedInteger(v) } func isFloat(v reflect.Value) bool { k := v.Kind() return k == reflect.Float32 || k == reflect.Float64 } func isComplex(v reflect.Value) bool { k := v.Kind() return k == reflect.Complex64 || k == reflect.Complex128 } func checkAgainstInt64(e int64, c reflect.Value) (err error) { err = errors.New("") switch { case isSignedInteger(c): if c.Int() == e { err = nil } case isUnsignedInteger(c): u := c.Uint() if u <= math.MaxInt64 && int64(u) == e { err = nil } // Turn around the various floating point types so that the checkAgainst* // functions for them can deal with precision issues. case isFloat(c), isComplex(c): return Equals(c.Interface()).Matches(e) default: err = NewFatalError("which is not numeric") } return } func checkAgainstUint64(e uint64, c reflect.Value) (err error) { err = errors.New("") switch { case isSignedInteger(c): i := c.Int() if i >= 0 && uint64(i) == e { err = nil } case isUnsignedInteger(c): if c.Uint() == e { err = nil } // Turn around the various floating point types so that the checkAgainst* // functions for them can deal with precision issues. case isFloat(c), isComplex(c): return Equals(c.Interface()).Matches(e) default: err = NewFatalError("which is not numeric") } return } func checkAgainstFloat32(e float32, c reflect.Value) (err error) { err = errors.New("") switch { case isSignedInteger(c): if float32(c.Int()) == e { err = nil } case isUnsignedInteger(c): if float32(c.Uint()) == e { err = nil } case isFloat(c): // Compare using float32 to avoid a false sense of precision; otherwise // e.g. Equals(float32(0.1)) won't match float32(0.1). if float32(c.Float()) == e { err = nil } case isComplex(c): comp := c.Complex() rl := real(comp) im := imag(comp) // Compare using float32 to avoid a false sense of precision; otherwise // e.g. Equals(float32(0.1)) won't match (0.1 + 0i). if im == 0 && float32(rl) == e { err = nil } default: err = NewFatalError("which is not numeric") } return } func checkAgainstFloat64(e float64, c reflect.Value) (err error) { err = errors.New("") ck := c.Kind() switch { case isSignedInteger(c): if float64(c.Int()) == e { err = nil } case isUnsignedInteger(c): if float64(c.Uint()) == e { err = nil } // If the actual value is lower precision, turn the comparison around so we // apply the low-precision rules. Otherwise, e.g. Equals(0.1) may not match // float32(0.1). case ck == reflect.Float32 || ck == reflect.Complex64: return Equals(c.Interface()).Matches(e) // Otherwise, compare with double precision. case isFloat(c): if c.Float() == e { err = nil } case isComplex(c): comp := c.Complex() rl := real(comp) im := imag(comp) if im == 0 && rl == e { err = nil } default: err = NewFatalError("which is not numeric") } return } func checkAgainstComplex64(e complex64, c reflect.Value) (err error) { err = errors.New("") realPart := real(e) imaginaryPart := imag(e) switch { case isInteger(c) || isFloat(c): // If we have no imaginary part, then we should just compare against the // real part. Otherwise, we can't be equal. if imaginaryPart != 0 { return } return checkAgainstFloat32(realPart, c) case isComplex(c): // Compare using complex64 to avoid a false sense of precision; otherwise // e.g. Equals(0.1 + 0i) won't match float32(0.1). if complex64(c.Complex()) == e { err = nil } default: err = NewFatalError("which is not numeric") } return } func checkAgainstComplex128(e complex128, c reflect.Value) (err error) { err = errors.New("") realPart := real(e) imaginaryPart := imag(e) switch { case isInteger(c) || isFloat(c): // If we have no imaginary part, then we should just compare against the // real part. Otherwise, we can't be equal. if imaginaryPart != 0 { return } return checkAgainstFloat64(realPart, c) case isComplex(c): if c.Complex() == e { err = nil } default: err = NewFatalError("which is not numeric") } return } //////////////////////////////////////////////////////////////////////// // Other types //////////////////////////////////////////////////////////////////////// func checkAgainstBool(e bool, c reflect.Value) (err error) { if c.Kind() != reflect.Bool { err = NewFatalError("which is not a bool") return } err = errors.New("") if c.Bool() == e { err = nil } return } func checkAgainstUintptr(e uintptr, c reflect.Value) (err error) { if c.Kind() != reflect.Uintptr { err = NewFatalError("which is not a uintptr") return } err = errors.New("") if uintptr(c.Uint()) == e { err = nil } return } func checkAgainstChan(e reflect.Value, c reflect.Value) (err error) { // Create a description of e's type, e.g. "chan int". typeStr := fmt.Sprintf("%s %s", e.Type().ChanDir(), e.Type().Elem()) // Make sure c is a chan of the correct type. if c.Kind() != reflect.Chan || c.Type().ChanDir() != e.Type().ChanDir() || c.Type().Elem() != e.Type().Elem() { err = NewFatalError(fmt.Sprintf("which is not a %s", typeStr)) return } err = errors.New("") if c.Pointer() == e.Pointer() { err = nil } return } func checkAgainstFunc(e reflect.Value, c reflect.Value) (err error) { // Make sure c is a function. if c.Kind() != reflect.Func { err = NewFatalError("which is not a function") return } err = errors.New("") if c.Pointer() == e.Pointer() { err = nil } return } func checkAgainstMap(e reflect.Value, c reflect.Value) (err error) { // Make sure c is a map. if c.Kind() != reflect.Map { err = NewFatalError("which is not a map") return } err = errors.New("") if c.Pointer() == e.Pointer() { err = nil } return } func checkAgainstPtr(e reflect.Value, c reflect.Value) (err error) { // Create a description of e's type, e.g. "*int". typeStr := fmt.Sprintf("*%v", e.Type().Elem()) // Make sure c is a pointer of the correct type. if c.Kind() != reflect.Ptr || c.Type().Elem() != e.Type().Elem() { err = NewFatalError(fmt.Sprintf("which is not a %s", typeStr)) return } err = errors.New("") if c.Pointer() == e.Pointer() { err = nil } return } func checkAgainstSlice(e reflect.Value, c reflect.Value) (err error) { // Create a description of e's type, e.g. "[]int". typeStr := fmt.Sprintf("[]%v", e.Type().Elem()) // Make sure c is a slice of the correct type. if c.Kind() != reflect.Slice || c.Type().Elem() != e.Type().Elem() { err = NewFatalError(fmt.Sprintf("which is not a %s", typeStr)) return } err = errors.New("") if c.Pointer() == e.Pointer() { err = nil } return } func checkAgainstString(e reflect.Value, c reflect.Value) (err error) { // Make sure c is a string. if c.Kind() != reflect.String { err = NewFatalError("which is not a string") return } err = errors.New("") if c.String() == e.String() { err = nil } return } func checkAgainstArray(e reflect.Value, c reflect.Value) (err error) { // Create a description of e's type, e.g. "[2]int". typeStr := fmt.Sprintf("%v", e.Type()) // Make sure c is the correct type. if c.Type() != e.Type() { err = NewFatalError(fmt.Sprintf("which is not %s", typeStr)) return } // Check for equality. if e.Interface() != c.Interface() { err = errors.New("") return } return } func checkAgainstUnsafePointer(e reflect.Value, c reflect.Value) (err error) { // Make sure c is a pointer. if c.Kind() != reflect.UnsafePointer { err = NewFatalError("which is not a unsafe.Pointer") return } err = errors.New("") if c.Pointer() == e.Pointer() { err = nil } return } func checkForNil(c reflect.Value) (err error) { err = errors.New("") // Make sure it is legal to call IsNil. switch c.Kind() { case reflect.Invalid: case reflect.Chan: case reflect.Func: case reflect.Interface: case reflect.Map: case reflect.Ptr: case reflect.Slice: default: err = NewFatalError("which cannot be compared to nil") return } // Ask whether the value is nil. Handle a nil literal (kind Invalid) // specially, since it's not legal to call IsNil there. if c.Kind() == reflect.Invalid || c.IsNil() { err = nil } return } //////////////////////////////////////////////////////////////////////// // Public implementation //////////////////////////////////////////////////////////////////////// func (m *equalsMatcher) Matches(candidate interface{}) error { e := m.expectedValue c := reflect.ValueOf(candidate) ek := e.Kind() switch { case ek == reflect.Bool: return checkAgainstBool(e.Bool(), c) case isSignedInteger(e): return checkAgainstInt64(e.Int(), c) case isUnsignedInteger(e): return checkAgainstUint64(e.Uint(), c) case ek == reflect.Uintptr: return checkAgainstUintptr(uintptr(e.Uint()), c) case ek == reflect.Float32: return checkAgainstFloat32(float32(e.Float()), c) case ek == reflect.Float64: return checkAgainstFloat64(e.Float(), c) case ek == reflect.Complex64: return checkAgainstComplex64(complex64(e.Complex()), c) case ek == reflect.Complex128: return checkAgainstComplex128(complex128(e.Complex()), c) case ek == reflect.Chan: return checkAgainstChan(e, c) case ek == reflect.Func: return checkAgainstFunc(e, c) case ek == reflect.Map: return checkAgainstMap(e, c) case ek == reflect.Ptr: return checkAgainstPtr(e, c) case ek == reflect.Slice: return checkAgainstSlice(e, c) case ek == reflect.String: return checkAgainstString(e, c) case ek == reflect.Array: return checkAgainstArray(e, c) case ek == reflect.UnsafePointer: return checkAgainstUnsafePointer(e, c) case ek == reflect.Invalid: return checkForNil(c) } panic(fmt.Sprintf("equalsMatcher.Matches: unexpected kind: %v", ek)) } func (m *equalsMatcher) Description() string { // Special case: handle nil. if !m.expectedValue.IsValid() { return "is nil" } return fmt.Sprintf("%v", m.expectedValue.Interface()) } mongo-tools-r3.6.3/vendor/src/github.com/jacobsa/oglematchers/equals_test.go000066400000000000000000005037631321131462300272560ustar00rootroot00000000000000// Copyright 2011 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers_test import ( "fmt" . "github.com/jacobsa/oglematchers" . "github.com/jacobsa/ogletest" "math" "unsafe" ) var someInt int = -17 //////////////////////////////////////////////////////////////////////// // Helpers //////////////////////////////////////////////////////////////////////// type EqualsTest struct { } func init() { RegisterTestSuite(&EqualsTest{}) } type equalsTestCase struct { candidate interface{} expectedResult bool shouldBeFatal bool expectedError string } func (t *EqualsTest) checkTestCases(matcher Matcher, cases []equalsTestCase) { for i, c := range cases { err := matcher.Matches(c.candidate) ExpectEq( c.expectedResult, (err == nil), "Result for case %d: %v (Error: %v)", i, c, err) if err == nil { continue } _, isFatal := err.(*FatalError) ExpectEq(c.shouldBeFatal, isFatal, "Fatality for case %d: %v", i, c) ExpectThat(err, Error(Equals(c.expectedError)), "Case %d: %v", i, c) } } //////////////////////////////////////////////////////////////////////// // nil //////////////////////////////////////////////////////////////////////// func (t *EqualsTest) EqualsNil() { matcher := Equals(nil) ExpectEq("is nil", matcher.Description()) cases := []equalsTestCase{ // Legal types equalsTestCase{nil, true, false, ""}, equalsTestCase{chan int(nil), true, false, ""}, equalsTestCase{(func())(nil), true, false, ""}, equalsTestCase{interface{}(nil), true, false, ""}, equalsTestCase{map[int]int(nil), true, false, ""}, equalsTestCase{(*int)(nil), true, false, ""}, equalsTestCase{[]int(nil), true, false, ""}, equalsTestCase{make(chan int), false, false, ""}, equalsTestCase{func() {}, false, false, ""}, equalsTestCase{map[int]int{}, false, false, ""}, equalsTestCase{&someInt, false, false, ""}, equalsTestCase{[]int{}, false, false, ""}, // Illegal types equalsTestCase{17, false, true, "which cannot be compared to nil"}, equalsTestCase{int8(17), false, true, "which cannot be compared to nil"}, equalsTestCase{uintptr(17), false, true, "which cannot be compared to nil"}, equalsTestCase{[...]int{}, false, true, "which cannot be compared to nil"}, equalsTestCase{"taco", false, true, "which cannot be compared to nil"}, equalsTestCase{equalsTestCase{}, false, true, "which cannot be compared to nil"}, equalsTestCase{unsafe.Pointer(&someInt), false, true, "which cannot be compared to nil"}, } t.checkTestCases(matcher, cases) } //////////////////////////////////////////////////////////////////////// // Integer literals //////////////////////////////////////////////////////////////////////// func (t *EqualsTest) NegativeIntegerLiteral() { // -2^30 matcher := Equals(-1073741824) ExpectEq("-1073741824", matcher.Description()) cases := []equalsTestCase{ // Various types of -1073741824. equalsTestCase{-1073741824, true, false, ""}, equalsTestCase{-1073741824.0, true, false, ""}, equalsTestCase{-1073741824 + 0i, true, false, ""}, equalsTestCase{int(-1073741824), true, false, ""}, equalsTestCase{int32(-1073741824), true, false, ""}, equalsTestCase{int64(-1073741824), true, false, ""}, equalsTestCase{float32(-1073741824), true, false, ""}, equalsTestCase{float64(-1073741824), true, false, ""}, equalsTestCase{complex64(-1073741824), true, false, ""}, equalsTestCase{complex128(-1073741824), true, false, ""}, equalsTestCase{interface{}(int(-1073741824)), true, false, ""}, // Values that would be -1073741824 in two's complement. equalsTestCase{uint((1 << 32) - 1073741824), false, false, ""}, equalsTestCase{uint32((1 << 32) - 1073741824), false, false, ""}, equalsTestCase{uint64((1 << 64) - 1073741824), false, false, ""}, // Non-equal values of signed integer type. equalsTestCase{int(-1073741823), false, false, ""}, equalsTestCase{int32(-1073741823), false, false, ""}, equalsTestCase{int64(-1073741823), false, false, ""}, // Non-equal values of other numeric types. equalsTestCase{float64(-1073741824.1), false, false, ""}, equalsTestCase{float64(-1073741823.9), false, false, ""}, equalsTestCase{complex128(-1073741823), false, false, ""}, equalsTestCase{complex128(-1073741824 + 2i), false, false, ""}, // Non-numeric types. equalsTestCase{uintptr(0), false, true, "which is not numeric"}, equalsTestCase{true, false, true, "which is not numeric"}, equalsTestCase{[...]int{}, false, true, "which is not numeric"}, equalsTestCase{make(chan int), false, true, "which is not numeric"}, equalsTestCase{func() {}, false, true, "which is not numeric"}, equalsTestCase{map[int]int{}, false, true, "which is not numeric"}, equalsTestCase{&someInt, false, true, "which is not numeric"}, equalsTestCase{[]int{}, false, true, "which is not numeric"}, equalsTestCase{"taco", false, true, "which is not numeric"}, equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) PositiveIntegerLiteral() { // 2^30 matcher := Equals(1073741824) ExpectEq("1073741824", matcher.Description()) cases := []equalsTestCase{ // Various types of 1073741824. equalsTestCase{1073741824, true, false, ""}, equalsTestCase{1073741824.0, true, false, ""}, equalsTestCase{1073741824 + 0i, true, false, ""}, equalsTestCase{int(1073741824), true, false, ""}, equalsTestCase{uint(1073741824), true, false, ""}, equalsTestCase{int32(1073741824), true, false, ""}, equalsTestCase{int64(1073741824), true, false, ""}, equalsTestCase{uint32(1073741824), true, false, ""}, equalsTestCase{uint64(1073741824), true, false, ""}, equalsTestCase{float32(1073741824), true, false, ""}, equalsTestCase{float64(1073741824), true, false, ""}, equalsTestCase{complex64(1073741824), true, false, ""}, equalsTestCase{complex128(1073741824), true, false, ""}, equalsTestCase{interface{}(int(1073741824)), true, false, ""}, equalsTestCase{interface{}(uint(1073741824)), true, false, ""}, // Non-equal values of numeric type. equalsTestCase{int(1073741823), false, false, ""}, equalsTestCase{int32(1073741823), false, false, ""}, equalsTestCase{int64(1073741823), false, false, ""}, equalsTestCase{float64(1073741824.1), false, false, ""}, equalsTestCase{float64(1073741823.9), false, false, ""}, equalsTestCase{complex128(1073741823), false, false, ""}, equalsTestCase{complex128(1073741824 + 2i), false, false, ""}, // Non-numeric types. equalsTestCase{uintptr(0), false, true, "which is not numeric"}, equalsTestCase{true, false, true, "which is not numeric"}, equalsTestCase{[...]int{}, false, true, "which is not numeric"}, equalsTestCase{make(chan int), false, true, "which is not numeric"}, equalsTestCase{func() {}, false, true, "which is not numeric"}, equalsTestCase{map[int]int{}, false, true, "which is not numeric"}, equalsTestCase{&someInt, false, true, "which is not numeric"}, equalsTestCase{[]int{}, false, true, "which is not numeric"}, equalsTestCase{"taco", false, true, "which is not numeric"}, equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"}, } t.checkTestCases(matcher, cases) } //////////////////////////////////////////////////////////////////////// // Floating point literals //////////////////////////////////////////////////////////////////////// func (t *EqualsTest) NegativeIntegralFloatingPointLiteral() { // -2^30 matcher := Equals(-1073741824.0) ExpectEq("-1.073741824e+09", matcher.Description()) cases := []equalsTestCase{ // Various types of -1073741824. equalsTestCase{-1073741824, true, false, ""}, equalsTestCase{-1073741824.0, true, false, ""}, equalsTestCase{-1073741824 + 0i, true, false, ""}, equalsTestCase{int(-1073741824), true, false, ""}, equalsTestCase{int32(-1073741824), true, false, ""}, equalsTestCase{int64(-1073741824), true, false, ""}, equalsTestCase{float32(-1073741824), true, false, ""}, equalsTestCase{float64(-1073741824), true, false, ""}, equalsTestCase{complex64(-1073741824), true, false, ""}, equalsTestCase{complex128(-1073741824), true, false, ""}, equalsTestCase{interface{}(int(-1073741824)), true, false, ""}, equalsTestCase{interface{}(float64(-1073741824)), true, false, ""}, // Values that would be -1073741824 in two's complement. equalsTestCase{uint((1 << 32) - 1073741824), false, false, ""}, equalsTestCase{uint32((1 << 32) - 1073741824), false, false, ""}, equalsTestCase{uint64((1 << 64) - 1073741824), false, false, ""}, // Non-equal values of signed integer type. equalsTestCase{int(-1073741823), false, false, ""}, equalsTestCase{int32(-1073741823), false, false, ""}, equalsTestCase{int64(-1073741823), false, false, ""}, // Non-equal values of other numeric types. equalsTestCase{float64(-1073741824.1), false, false, ""}, equalsTestCase{float64(-1073741823.9), false, false, ""}, equalsTestCase{complex128(-1073741823), false, false, ""}, equalsTestCase{complex128(-1073741824 + 2i), false, false, ""}, // Non-numeric types. equalsTestCase{uintptr(0), false, true, "which is not numeric"}, equalsTestCase{true, false, true, "which is not numeric"}, equalsTestCase{[...]int{}, false, true, "which is not numeric"}, equalsTestCase{make(chan int), false, true, "which is not numeric"}, equalsTestCase{func() {}, false, true, "which is not numeric"}, equalsTestCase{map[int]int{}, false, true, "which is not numeric"}, equalsTestCase{&someInt, false, true, "which is not numeric"}, equalsTestCase{[]int{}, false, true, "which is not numeric"}, equalsTestCase{"taco", false, true, "which is not numeric"}, equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) PositiveIntegralFloatingPointLiteral() { // 2^30 matcher := Equals(1073741824.0) ExpectEq("1.073741824e+09", matcher.Description()) cases := []equalsTestCase{ // Various types of 1073741824. equalsTestCase{1073741824, true, false, ""}, equalsTestCase{1073741824.0, true, false, ""}, equalsTestCase{1073741824 + 0i, true, false, ""}, equalsTestCase{int(1073741824), true, false, ""}, equalsTestCase{int32(1073741824), true, false, ""}, equalsTestCase{int64(1073741824), true, false, ""}, equalsTestCase{uint(1073741824), true, false, ""}, equalsTestCase{uint32(1073741824), true, false, ""}, equalsTestCase{uint64(1073741824), true, false, ""}, equalsTestCase{float32(1073741824), true, false, ""}, equalsTestCase{float64(1073741824), true, false, ""}, equalsTestCase{complex64(1073741824), true, false, ""}, equalsTestCase{complex128(1073741824), true, false, ""}, equalsTestCase{interface{}(int(1073741824)), true, false, ""}, equalsTestCase{interface{}(float64(1073741824)), true, false, ""}, // Values that would be 1073741824 in two's complement. equalsTestCase{uint((1 << 32) - 1073741824), false, false, ""}, equalsTestCase{uint32((1 << 32) - 1073741824), false, false, ""}, equalsTestCase{uint64((1 << 64) - 1073741824), false, false, ""}, // Non-equal values of numeric type. equalsTestCase{int(1073741823), false, false, ""}, equalsTestCase{int32(1073741823), false, false, ""}, equalsTestCase{int64(1073741823), false, false, ""}, equalsTestCase{uint(1073741823), false, false, ""}, equalsTestCase{uint32(1073741823), false, false, ""}, equalsTestCase{uint64(1073741823), false, false, ""}, equalsTestCase{float64(1073741824.1), false, false, ""}, equalsTestCase{float64(1073741823.9), false, false, ""}, equalsTestCase{complex128(1073741823), false, false, ""}, equalsTestCase{complex128(1073741824 + 2i), false, false, ""}, // Non-numeric types. equalsTestCase{uintptr(0), false, true, "which is not numeric"}, equalsTestCase{true, false, true, "which is not numeric"}, equalsTestCase{[...]int{}, false, true, "which is not numeric"}, equalsTestCase{make(chan int), false, true, "which is not numeric"}, equalsTestCase{func() {}, false, true, "which is not numeric"}, equalsTestCase{map[int]int{}, false, true, "which is not numeric"}, equalsTestCase{&someInt, false, true, "which is not numeric"}, equalsTestCase{[]int{}, false, true, "which is not numeric"}, equalsTestCase{"taco", false, true, "which is not numeric"}, equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) NonIntegralFloatingPointLiteral() { matcher := Equals(17.1) ExpectEq("17.1", matcher.Description()) cases := []equalsTestCase{ // Various types of 17.1. equalsTestCase{17.1, true, false, ""}, equalsTestCase{17.1, true, false, ""}, equalsTestCase{17.1 + 0i, true, false, ""}, equalsTestCase{float32(17.1), true, false, ""}, equalsTestCase{float64(17.1), true, false, ""}, equalsTestCase{complex64(17.1), true, false, ""}, equalsTestCase{complex128(17.1), true, false, ""}, // Non-equal values of numeric type. equalsTestCase{17, false, false, ""}, equalsTestCase{17.2, false, false, ""}, equalsTestCase{18, false, false, ""}, equalsTestCase{int(17), false, false, ""}, equalsTestCase{int(18), false, false, ""}, equalsTestCase{int32(17), false, false, ""}, equalsTestCase{int64(17), false, false, ""}, equalsTestCase{uint(17), false, false, ""}, equalsTestCase{uint32(17), false, false, ""}, equalsTestCase{uint64(17), false, false, ""}, equalsTestCase{complex128(17.1 + 2i), false, false, ""}, // Non-numeric types. equalsTestCase{uintptr(0), false, true, "which is not numeric"}, equalsTestCase{true, false, true, "which is not numeric"}, equalsTestCase{[...]int{}, false, true, "which is not numeric"}, equalsTestCase{make(chan int), false, true, "which is not numeric"}, equalsTestCase{func() {}, false, true, "which is not numeric"}, equalsTestCase{map[int]int{}, false, true, "which is not numeric"}, equalsTestCase{&someInt, false, true, "which is not numeric"}, equalsTestCase{[]int{}, false, true, "which is not numeric"}, equalsTestCase{"taco", false, true, "which is not numeric"}, equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"}, } t.checkTestCases(matcher, cases) } //////////////////////////////////////////////////////////////////////// // bool //////////////////////////////////////////////////////////////////////// func (t *EqualsTest) False() { matcher := Equals(false) ExpectEq("false", matcher.Description()) cases := []equalsTestCase{ // bools equalsTestCase{false, true, false, ""}, equalsTestCase{bool(false), true, false, ""}, equalsTestCase{true, false, false, ""}, equalsTestCase{bool(true), false, false, ""}, // Other types. equalsTestCase{int(0), false, true, "which is not a bool"}, equalsTestCase{int8(0), false, true, "which is not a bool"}, equalsTestCase{int16(0), false, true, "which is not a bool"}, equalsTestCase{int32(0), false, true, "which is not a bool"}, equalsTestCase{int64(0), false, true, "which is not a bool"}, equalsTestCase{uint(0), false, true, "which is not a bool"}, equalsTestCase{uint8(0), false, true, "which is not a bool"}, equalsTestCase{uint16(0), false, true, "which is not a bool"}, equalsTestCase{uint32(0), false, true, "which is not a bool"}, equalsTestCase{uint64(0), false, true, "which is not a bool"}, equalsTestCase{uintptr(0), false, true, "which is not a bool"}, equalsTestCase{[...]int{}, false, true, "which is not a bool"}, equalsTestCase{make(chan int), false, true, "which is not a bool"}, equalsTestCase{func() {}, false, true, "which is not a bool"}, equalsTestCase{map[int]int{}, false, true, "which is not a bool"}, equalsTestCase{&someInt, false, true, "which is not a bool"}, equalsTestCase{[]int{}, false, true, "which is not a bool"}, equalsTestCase{"taco", false, true, "which is not a bool"}, equalsTestCase{equalsTestCase{}, false, true, "which is not a bool"}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) True() { matcher := Equals(true) ExpectEq("true", matcher.Description()) cases := []equalsTestCase{ // bools equalsTestCase{true, true, false, ""}, equalsTestCase{bool(true), true, false, ""}, equalsTestCase{false, false, false, ""}, equalsTestCase{bool(false), false, false, ""}, // Other types. equalsTestCase{int(1), false, true, "which is not a bool"}, equalsTestCase{int8(1), false, true, "which is not a bool"}, equalsTestCase{int16(1), false, true, "which is not a bool"}, equalsTestCase{int32(1), false, true, "which is not a bool"}, equalsTestCase{int64(1), false, true, "which is not a bool"}, equalsTestCase{uint(1), false, true, "which is not a bool"}, equalsTestCase{uint8(1), false, true, "which is not a bool"}, equalsTestCase{uint16(1), false, true, "which is not a bool"}, equalsTestCase{uint32(1), false, true, "which is not a bool"}, equalsTestCase{uint64(1), false, true, "which is not a bool"}, equalsTestCase{uintptr(1), false, true, "which is not a bool"}, equalsTestCase{[...]int{}, false, true, "which is not a bool"}, equalsTestCase{make(chan int), false, true, "which is not a bool"}, equalsTestCase{func() {}, false, true, "which is not a bool"}, equalsTestCase{map[int]int{}, false, true, "which is not a bool"}, equalsTestCase{&someInt, false, true, "which is not a bool"}, equalsTestCase{[]int{}, false, true, "which is not a bool"}, equalsTestCase{"taco", false, true, "which is not a bool"}, equalsTestCase{equalsTestCase{}, false, true, "which is not a bool"}, } t.checkTestCases(matcher, cases) } //////////////////////////////////////////////////////////////////////// // int //////////////////////////////////////////////////////////////////////// func (t *EqualsTest) NegativeInt() { // -2^30 matcher := Equals(int(-1073741824)) ExpectEq("-1073741824", matcher.Description()) cases := []equalsTestCase{ // Various types of -1073741824. equalsTestCase{-1073741824, true, false, ""}, equalsTestCase{-1073741824.0, true, false, ""}, equalsTestCase{-1073741824 + 0i, true, false, ""}, equalsTestCase{int(-1073741824), true, false, ""}, equalsTestCase{int32(-1073741824), true, false, ""}, equalsTestCase{int64(-1073741824), true, false, ""}, equalsTestCase{float32(-1073741824), true, false, ""}, equalsTestCase{float64(-1073741824), true, false, ""}, equalsTestCase{complex64(-1073741824), true, false, ""}, equalsTestCase{complex128(-1073741824), true, false, ""}, equalsTestCase{interface{}(int(-1073741824)), true, false, ""}, // Values that would be -1073741824 in two's complement. equalsTestCase{uint((1 << 32) - 1073741824), false, false, ""}, equalsTestCase{uint32((1 << 32) - 1073741824), false, false, ""}, equalsTestCase{uint64((1 << 64) - 1073741824), false, false, ""}, // Non-equal values of signed integer type. equalsTestCase{int(-1073741823), false, false, ""}, equalsTestCase{int32(-1073741823), false, false, ""}, equalsTestCase{int64(-1073741823), false, false, ""}, // Non-equal values of other numeric types. equalsTestCase{float64(-1073741824.1), false, false, ""}, equalsTestCase{float64(-1073741823.9), false, false, ""}, equalsTestCase{complex128(-1073741823), false, false, ""}, equalsTestCase{complex128(-1073741824 + 2i), false, false, ""}, // Non-numeric types. equalsTestCase{uintptr(0), false, true, "which is not numeric"}, equalsTestCase{true, false, true, "which is not numeric"}, equalsTestCase{[...]int{}, false, true, "which is not numeric"}, equalsTestCase{make(chan int), false, true, "which is not numeric"}, equalsTestCase{func() {}, false, true, "which is not numeric"}, equalsTestCase{map[int]int{}, false, true, "which is not numeric"}, equalsTestCase{&someInt, false, true, "which is not numeric"}, equalsTestCase{[]int{}, false, true, "which is not numeric"}, equalsTestCase{"taco", false, true, "which is not numeric"}, equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) PositiveInt() { // 2^30 matcher := Equals(int(1073741824)) ExpectEq("1073741824", matcher.Description()) cases := []equalsTestCase{ // Various types of 1073741824. equalsTestCase{1073741824, true, false, ""}, equalsTestCase{1073741824.0, true, false, ""}, equalsTestCase{1073741824 + 0i, true, false, ""}, equalsTestCase{int(1073741824), true, false, ""}, equalsTestCase{uint(1073741824), true, false, ""}, equalsTestCase{int32(1073741824), true, false, ""}, equalsTestCase{int64(1073741824), true, false, ""}, equalsTestCase{uint32(1073741824), true, false, ""}, equalsTestCase{uint64(1073741824), true, false, ""}, equalsTestCase{float32(1073741824), true, false, ""}, equalsTestCase{float64(1073741824), true, false, ""}, equalsTestCase{complex64(1073741824), true, false, ""}, equalsTestCase{complex128(1073741824), true, false, ""}, equalsTestCase{interface{}(int(1073741824)), true, false, ""}, equalsTestCase{interface{}(uint(1073741824)), true, false, ""}, // Non-equal values of numeric type. equalsTestCase{int(1073741823), false, false, ""}, equalsTestCase{int32(1073741823), false, false, ""}, equalsTestCase{int64(1073741823), false, false, ""}, equalsTestCase{float64(1073741824.1), false, false, ""}, equalsTestCase{float64(1073741823.9), false, false, ""}, equalsTestCase{complex128(1073741823), false, false, ""}, equalsTestCase{complex128(1073741824 + 2i), false, false, ""}, // Non-numeric types. equalsTestCase{uintptr(0), false, true, "which is not numeric"}, equalsTestCase{true, false, true, "which is not numeric"}, equalsTestCase{[...]int{}, false, true, "which is not numeric"}, equalsTestCase{make(chan int), false, true, "which is not numeric"}, equalsTestCase{func() {}, false, true, "which is not numeric"}, equalsTestCase{map[int]int{}, false, true, "which is not numeric"}, equalsTestCase{&someInt, false, true, "which is not numeric"}, equalsTestCase{[]int{}, false, true, "which is not numeric"}, equalsTestCase{"taco", false, true, "which is not numeric"}, equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"}, } t.checkTestCases(matcher, cases) } //////////////////////////////////////////////////////////////////////// // int8 //////////////////////////////////////////////////////////////////////// func (t *EqualsTest) NegativeInt8() { matcher := Equals(int8(-17)) ExpectEq("-17", matcher.Description()) cases := []equalsTestCase{ // Various types of -17. equalsTestCase{-17, true, false, ""}, equalsTestCase{-17.0, true, false, ""}, equalsTestCase{-17 + 0i, true, false, ""}, equalsTestCase{int(-17), true, false, ""}, equalsTestCase{int8(-17), true, false, ""}, equalsTestCase{int16(-17), true, false, ""}, equalsTestCase{int32(-17), true, false, ""}, equalsTestCase{int64(-17), true, false, ""}, equalsTestCase{float32(-17), true, false, ""}, equalsTestCase{float64(-17), true, false, ""}, equalsTestCase{complex64(-17), true, false, ""}, equalsTestCase{complex128(-17), true, false, ""}, equalsTestCase{interface{}(int(-17)), true, false, ""}, // Values that would be -17 in two's complement. equalsTestCase{uint((1 << 32) - 17), false, false, ""}, equalsTestCase{uint8((1 << 8) - 17), false, false, ""}, equalsTestCase{uint16((1 << 16) - 17), false, false, ""}, equalsTestCase{uint32((1 << 32) - 17), false, false, ""}, equalsTestCase{uint64((1 << 64) - 17), false, false, ""}, // Non-equal values of signed integer type. equalsTestCase{int(-16), false, false, ""}, equalsTestCase{int8(-16), false, false, ""}, equalsTestCase{int16(-16), false, false, ""}, equalsTestCase{int32(-16), false, false, ""}, equalsTestCase{int64(-16), false, false, ""}, // Non-equal values of other numeric types. equalsTestCase{float32(-17.1), false, false, ""}, equalsTestCase{float32(-16.9), false, false, ""}, equalsTestCase{complex64(-16), false, false, ""}, equalsTestCase{complex64(-17 + 2i), false, false, ""}, // Non-numeric types. equalsTestCase{uintptr((1 << 32) - 17), false, true, "which is not numeric"}, equalsTestCase{true, false, true, "which is not numeric"}, equalsTestCase{[...]int{-17}, false, true, "which is not numeric"}, equalsTestCase{make(chan int), false, true, "which is not numeric"}, equalsTestCase{func() {}, false, true, "which is not numeric"}, equalsTestCase{map[int]int{}, false, true, "which is not numeric"}, equalsTestCase{&someInt, false, true, "which is not numeric"}, equalsTestCase{[]int{-17}, false, true, "which is not numeric"}, equalsTestCase{"-17", false, true, "which is not numeric"}, equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) ZeroInt8() { matcher := Equals(int8(0)) ExpectEq("0", matcher.Description()) cases := []equalsTestCase{ // Various types of 0. equalsTestCase{0, true, false, ""}, equalsTestCase{0.0, true, false, ""}, equalsTestCase{0 + 0i, true, false, ""}, equalsTestCase{int(0), true, false, ""}, equalsTestCase{int8(0), true, false, ""}, equalsTestCase{int16(0), true, false, ""}, equalsTestCase{int32(0), true, false, ""}, equalsTestCase{int64(0), true, false, ""}, equalsTestCase{float32(0), true, false, ""}, equalsTestCase{float64(0), true, false, ""}, equalsTestCase{complex64(0), true, false, ""}, equalsTestCase{complex128(0), true, false, ""}, equalsTestCase{interface{}(int(0)), true, false, ""}, equalsTestCase{uint(0), true, false, ""}, equalsTestCase{uint8(0), true, false, ""}, equalsTestCase{uint16(0), true, false, ""}, equalsTestCase{uint32(0), true, false, ""}, equalsTestCase{uint64(0), true, false, ""}, // Non-equal values of numeric type. equalsTestCase{int(1), false, false, ""}, equalsTestCase{int8(1), false, false, ""}, equalsTestCase{int16(1), false, false, ""}, equalsTestCase{int32(1), false, false, ""}, equalsTestCase{int64(1), false, false, ""}, equalsTestCase{float32(-0.1), false, false, ""}, equalsTestCase{float32(0.1), false, false, ""}, equalsTestCase{complex64(1), false, false, ""}, equalsTestCase{complex64(0 + 2i), false, false, ""}, // Non-numeric types. equalsTestCase{uintptr(0), false, true, "which is not numeric"}, equalsTestCase{true, false, true, "which is not numeric"}, equalsTestCase{[...]int{0}, false, true, "which is not numeric"}, equalsTestCase{make(chan int), false, true, "which is not numeric"}, equalsTestCase{func() {}, false, true, "which is not numeric"}, equalsTestCase{map[int]int{}, false, true, "which is not numeric"}, equalsTestCase{&someInt, false, true, "which is not numeric"}, equalsTestCase{[]int{0}, false, true, "which is not numeric"}, equalsTestCase{"0", false, true, "which is not numeric"}, equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) PositiveInt8() { matcher := Equals(int8(17)) ExpectEq("17", matcher.Description()) cases := []equalsTestCase{ // Various types of 17. equalsTestCase{17, true, false, ""}, equalsTestCase{17.0, true, false, ""}, equalsTestCase{17 + 0i, true, false, ""}, equalsTestCase{int(17), true, false, ""}, equalsTestCase{int8(17), true, false, ""}, equalsTestCase{int16(17), true, false, ""}, equalsTestCase{int32(17), true, false, ""}, equalsTestCase{int64(17), true, false, ""}, equalsTestCase{float32(17), true, false, ""}, equalsTestCase{float64(17), true, false, ""}, equalsTestCase{complex64(17), true, false, ""}, equalsTestCase{complex128(17), true, false, ""}, equalsTestCase{interface{}(int(17)), true, false, ""}, equalsTestCase{uint(17), true, false, ""}, equalsTestCase{uint8(17), true, false, ""}, equalsTestCase{uint16(17), true, false, ""}, equalsTestCase{uint32(17), true, false, ""}, equalsTestCase{uint64(17), true, false, ""}, // Non-equal values of numeric type. equalsTestCase{int(16), false, false, ""}, equalsTestCase{int8(16), false, false, ""}, equalsTestCase{int16(16), false, false, ""}, equalsTestCase{int32(16), false, false, ""}, equalsTestCase{int64(16), false, false, ""}, equalsTestCase{float32(16.9), false, false, ""}, equalsTestCase{float32(17.1), false, false, ""}, equalsTestCase{complex64(16), false, false, ""}, equalsTestCase{complex64(17 + 2i), false, false, ""}, // Non-numeric types. equalsTestCase{uintptr(17), false, true, "which is not numeric"}, equalsTestCase{true, false, true, "which is not numeric"}, equalsTestCase{[...]int{17}, false, true, "which is not numeric"}, equalsTestCase{make(chan int), false, true, "which is not numeric"}, equalsTestCase{func() {}, false, true, "which is not numeric"}, equalsTestCase{map[int]int{}, false, true, "which is not numeric"}, equalsTestCase{&someInt, false, true, "which is not numeric"}, equalsTestCase{[]int{17}, false, true, "which is not numeric"}, equalsTestCase{"17", false, true, "which is not numeric"}, equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"}, } t.checkTestCases(matcher, cases) } //////////////////////////////////////////////////////////////////////// // int16 //////////////////////////////////////////////////////////////////////// func (t *EqualsTest) NegativeInt16() { matcher := Equals(int16(-32766)) ExpectEq("-32766", matcher.Description()) cases := []equalsTestCase{ // Various types of -32766. equalsTestCase{-32766, true, false, ""}, equalsTestCase{-32766.0, true, false, ""}, equalsTestCase{-32766 + 0i, true, false, ""}, equalsTestCase{int(-32766), true, false, ""}, equalsTestCase{int16(-32766), true, false, ""}, equalsTestCase{int32(-32766), true, false, ""}, equalsTestCase{int64(-32766), true, false, ""}, equalsTestCase{float32(-32766), true, false, ""}, equalsTestCase{float64(-32766), true, false, ""}, equalsTestCase{complex64(-32766), true, false, ""}, equalsTestCase{complex128(-32766), true, false, ""}, equalsTestCase{interface{}(int(-32766)), true, false, ""}, // Values that would be -32766 in two's complement. equalsTestCase{uint((1 << 32) - 32766), false, false, ""}, equalsTestCase{uint16((1 << 16) - 32766), false, false, ""}, equalsTestCase{uint32((1 << 32) - 32766), false, false, ""}, equalsTestCase{uint64((1 << 64) - 32766), false, false, ""}, // Non-equal values of signed integer type. equalsTestCase{int(-16), false, false, ""}, equalsTestCase{int8(-16), false, false, ""}, equalsTestCase{int16(-16), false, false, ""}, equalsTestCase{int32(-16), false, false, ""}, equalsTestCase{int64(-16), false, false, ""}, // Non-equal values of other numeric types. equalsTestCase{float32(-32766.1), false, false, ""}, equalsTestCase{float32(-32765.9), false, false, ""}, equalsTestCase{complex64(-32766.1), false, false, ""}, equalsTestCase{complex64(-32766 + 2i), false, false, ""}, // Non-numeric types. equalsTestCase{uintptr((1 << 32) - 32766), false, true, "which is not numeric"}, equalsTestCase{true, false, true, "which is not numeric"}, equalsTestCase{[...]int{-32766}, false, true, "which is not numeric"}, equalsTestCase{make(chan int), false, true, "which is not numeric"}, equalsTestCase{func() {}, false, true, "which is not numeric"}, equalsTestCase{map[int]int{}, false, true, "which is not numeric"}, equalsTestCase{&someInt, false, true, "which is not numeric"}, equalsTestCase{[]int{-32766}, false, true, "which is not numeric"}, equalsTestCase{"-32766", false, true, "which is not numeric"}, equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) ZeroInt16() { matcher := Equals(int16(0)) ExpectEq("0", matcher.Description()) cases := []equalsTestCase{ // Various types of 0. equalsTestCase{0, true, false, ""}, equalsTestCase{0.0, true, false, ""}, equalsTestCase{0 + 0i, true, false, ""}, equalsTestCase{int(0), true, false, ""}, equalsTestCase{int8(0), true, false, ""}, equalsTestCase{int16(0), true, false, ""}, equalsTestCase{int32(0), true, false, ""}, equalsTestCase{int64(0), true, false, ""}, equalsTestCase{float32(0), true, false, ""}, equalsTestCase{float64(0), true, false, ""}, equalsTestCase{complex64(0), true, false, ""}, equalsTestCase{complex128(0), true, false, ""}, equalsTestCase{interface{}(int(0)), true, false, ""}, equalsTestCase{uint(0), true, false, ""}, equalsTestCase{uint8(0), true, false, ""}, equalsTestCase{uint16(0), true, false, ""}, equalsTestCase{uint32(0), true, false, ""}, equalsTestCase{uint64(0), true, false, ""}, // Non-equal values of numeric type. equalsTestCase{int(1), false, false, ""}, equalsTestCase{int8(1), false, false, ""}, equalsTestCase{int16(1), false, false, ""}, equalsTestCase{int32(1), false, false, ""}, equalsTestCase{int64(1), false, false, ""}, equalsTestCase{float32(-0.1), false, false, ""}, equalsTestCase{float32(0.1), false, false, ""}, equalsTestCase{complex64(1), false, false, ""}, equalsTestCase{complex64(0 + 2i), false, false, ""}, // Non-numeric types. equalsTestCase{uintptr(0), false, true, "which is not numeric"}, equalsTestCase{true, false, true, "which is not numeric"}, equalsTestCase{[...]int{0}, false, true, "which is not numeric"}, equalsTestCase{make(chan int), false, true, "which is not numeric"}, equalsTestCase{func() {}, false, true, "which is not numeric"}, equalsTestCase{map[int]int{}, false, true, "which is not numeric"}, equalsTestCase{&someInt, false, true, "which is not numeric"}, equalsTestCase{[]int{0}, false, true, "which is not numeric"}, equalsTestCase{"0", false, true, "which is not numeric"}, equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) PositiveInt16() { matcher := Equals(int16(32765)) ExpectEq("32765", matcher.Description()) cases := []equalsTestCase{ // Various types of 32765. equalsTestCase{32765, true, false, ""}, equalsTestCase{32765.0, true, false, ""}, equalsTestCase{32765 + 0i, true, false, ""}, equalsTestCase{int(32765), true, false, ""}, equalsTestCase{int16(32765), true, false, ""}, equalsTestCase{int32(32765), true, false, ""}, equalsTestCase{int64(32765), true, false, ""}, equalsTestCase{float32(32765), true, false, ""}, equalsTestCase{float64(32765), true, false, ""}, equalsTestCase{complex64(32765), true, false, ""}, equalsTestCase{complex128(32765), true, false, ""}, equalsTestCase{interface{}(int(32765)), true, false, ""}, equalsTestCase{uint(32765), true, false, ""}, equalsTestCase{uint16(32765), true, false, ""}, equalsTestCase{uint32(32765), true, false, ""}, equalsTestCase{uint64(32765), true, false, ""}, // Non-equal values of numeric type. equalsTestCase{int(32764), false, false, ""}, equalsTestCase{int16(32764), false, false, ""}, equalsTestCase{int32(32764), false, false, ""}, equalsTestCase{int64(32764), false, false, ""}, equalsTestCase{float32(32764.9), false, false, ""}, equalsTestCase{float32(32765.1), false, false, ""}, equalsTestCase{complex64(32765.9), false, false, ""}, equalsTestCase{complex64(32765 + 2i), false, false, ""}, // Non-numeric types. equalsTestCase{uintptr(32765), false, true, "which is not numeric"}, equalsTestCase{true, false, true, "which is not numeric"}, equalsTestCase{[...]int{32765}, false, true, "which is not numeric"}, equalsTestCase{make(chan int), false, true, "which is not numeric"}, equalsTestCase{func() {}, false, true, "which is not numeric"}, equalsTestCase{map[int]int{}, false, true, "which is not numeric"}, equalsTestCase{&someInt, false, true, "which is not numeric"}, equalsTestCase{[]int{32765}, false, true, "which is not numeric"}, equalsTestCase{"32765", false, true, "which is not numeric"}, equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"}, } t.checkTestCases(matcher, cases) } //////////////////////////////////////////////////////////////////////// // int32 //////////////////////////////////////////////////////////////////////// func (t *EqualsTest) NegativeInt32() { // -2^30 matcher := Equals(int32(-1073741824)) ExpectEq("-1073741824", matcher.Description()) cases := []equalsTestCase{ // Various types of -1073741824. equalsTestCase{-1073741824, true, false, ""}, equalsTestCase{-1073741824.0, true, false, ""}, equalsTestCase{-1073741824 + 0i, true, false, ""}, equalsTestCase{int(-1073741824), true, false, ""}, equalsTestCase{int32(-1073741824), true, false, ""}, equalsTestCase{int64(-1073741824), true, false, ""}, equalsTestCase{float32(-1073741824), true, false, ""}, equalsTestCase{float64(-1073741824), true, false, ""}, equalsTestCase{complex64(-1073741824), true, false, ""}, equalsTestCase{complex128(-1073741824), true, false, ""}, equalsTestCase{interface{}(int(-1073741824)), true, false, ""}, // Values that would be -1073741824 in two's complement. equalsTestCase{uint((1 << 32) - 1073741824), false, false, ""}, equalsTestCase{uint32((1 << 32) - 1073741824), false, false, ""}, equalsTestCase{uint64((1 << 64) - 1073741824), false, false, ""}, // Non-equal values of signed integer type. equalsTestCase{int(-1073741823), false, false, ""}, equalsTestCase{int32(-1073741823), false, false, ""}, equalsTestCase{int64(-1073741823), false, false, ""}, // Non-equal values of other numeric types. equalsTestCase{float64(-1073741824.1), false, false, ""}, equalsTestCase{float64(-1073741823.9), false, false, ""}, equalsTestCase{complex128(-1073741823), false, false, ""}, equalsTestCase{complex128(-1073741824 + 2i), false, false, ""}, // Non-numeric types. equalsTestCase{uintptr(0), false, true, "which is not numeric"}, equalsTestCase{true, false, true, "which is not numeric"}, equalsTestCase{[...]int{}, false, true, "which is not numeric"}, equalsTestCase{make(chan int), false, true, "which is not numeric"}, equalsTestCase{func() {}, false, true, "which is not numeric"}, equalsTestCase{map[int]int{}, false, true, "which is not numeric"}, equalsTestCase{&someInt, false, true, "which is not numeric"}, equalsTestCase{[]int{}, false, true, "which is not numeric"}, equalsTestCase{"taco", false, true, "which is not numeric"}, equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) PositiveInt32() { // 2^30 matcher := Equals(int32(1073741824)) ExpectEq("1073741824", matcher.Description()) cases := []equalsTestCase{ // Various types of 1073741824. equalsTestCase{1073741824, true, false, ""}, equalsTestCase{1073741824.0, true, false, ""}, equalsTestCase{1073741824 + 0i, true, false, ""}, equalsTestCase{int(1073741824), true, false, ""}, equalsTestCase{uint(1073741824), true, false, ""}, equalsTestCase{int32(1073741824), true, false, ""}, equalsTestCase{int64(1073741824), true, false, ""}, equalsTestCase{uint32(1073741824), true, false, ""}, equalsTestCase{uint64(1073741824), true, false, ""}, equalsTestCase{float32(1073741824), true, false, ""}, equalsTestCase{float64(1073741824), true, false, ""}, equalsTestCase{complex64(1073741824), true, false, ""}, equalsTestCase{complex128(1073741824), true, false, ""}, equalsTestCase{interface{}(int(1073741824)), true, false, ""}, equalsTestCase{interface{}(uint(1073741824)), true, false, ""}, // Non-equal values of numeric type. equalsTestCase{int(1073741823), false, false, ""}, equalsTestCase{int32(1073741823), false, false, ""}, equalsTestCase{int64(1073741823), false, false, ""}, equalsTestCase{float64(1073741824.1), false, false, ""}, equalsTestCase{float64(1073741823.9), false, false, ""}, equalsTestCase{complex128(1073741823), false, false, ""}, equalsTestCase{complex128(1073741824 + 2i), false, false, ""}, // Non-numeric types. equalsTestCase{uintptr(0), false, true, "which is not numeric"}, equalsTestCase{true, false, true, "which is not numeric"}, equalsTestCase{[...]int{}, false, true, "which is not numeric"}, equalsTestCase{make(chan int), false, true, "which is not numeric"}, equalsTestCase{func() {}, false, true, "which is not numeric"}, equalsTestCase{map[int]int{}, false, true, "which is not numeric"}, equalsTestCase{&someInt, false, true, "which is not numeric"}, equalsTestCase{[]int{}, false, true, "which is not numeric"}, equalsTestCase{"taco", false, true, "which is not numeric"}, equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"}, } t.checkTestCases(matcher, cases) } //////////////////////////////////////////////////////////////////////// // int64 //////////////////////////////////////////////////////////////////////// func (t *EqualsTest) NegativeInt64() { // -2^40 matcher := Equals(int64(-1099511627776)) ExpectEq("-1099511627776", matcher.Description()) cases := []equalsTestCase{ // Various types of -1099511627776. equalsTestCase{-1099511627776.0, true, false, ""}, equalsTestCase{-1099511627776 + 0i, true, false, ""}, equalsTestCase{int64(-1099511627776), true, false, ""}, equalsTestCase{float32(-1099511627776), true, false, ""}, equalsTestCase{float64(-1099511627776), true, false, ""}, equalsTestCase{complex64(-1099511627776), true, false, ""}, equalsTestCase{complex128(-1099511627776), true, false, ""}, equalsTestCase{interface{}(int64(-1099511627776)), true, false, ""}, // Values that would be -1099511627776 in two's complement. equalsTestCase{uint64((1 << 64) - 1099511627776), false, false, ""}, // Non-equal values of signed integer type. equalsTestCase{int64(-1099511627775), false, false, ""}, // Non-equal values of other numeric types. equalsTestCase{float64(-1099511627776.1), false, false, ""}, equalsTestCase{float64(-1099511627775.9), false, false, ""}, equalsTestCase{complex128(-1099511627775), false, false, ""}, equalsTestCase{complex128(-1099511627776 + 2i), false, false, ""}, // Non-numeric types. equalsTestCase{uintptr(0), false, true, "which is not numeric"}, equalsTestCase{true, false, true, "which is not numeric"}, equalsTestCase{[...]int{}, false, true, "which is not numeric"}, equalsTestCase{make(chan int), false, true, "which is not numeric"}, equalsTestCase{func() {}, false, true, "which is not numeric"}, equalsTestCase{map[int]int{}, false, true, "which is not numeric"}, equalsTestCase{&someInt, false, true, "which is not numeric"}, equalsTestCase{[]int{}, false, true, "which is not numeric"}, equalsTestCase{"taco", false, true, "which is not numeric"}, equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) PositiveInt64() { // 2^40 matcher := Equals(int64(1099511627776)) ExpectEq("1099511627776", matcher.Description()) cases := []equalsTestCase{ // Various types of 1099511627776. equalsTestCase{1099511627776.0, true, false, ""}, equalsTestCase{1099511627776 + 0i, true, false, ""}, equalsTestCase{int64(1099511627776), true, false, ""}, equalsTestCase{uint64(1099511627776), true, false, ""}, equalsTestCase{float32(1099511627776), true, false, ""}, equalsTestCase{float64(1099511627776), true, false, ""}, equalsTestCase{complex64(1099511627776), true, false, ""}, equalsTestCase{complex128(1099511627776), true, false, ""}, equalsTestCase{interface{}(int64(1099511627776)), true, false, ""}, equalsTestCase{interface{}(uint64(1099511627776)), true, false, ""}, // Non-equal values of numeric type. equalsTestCase{int64(1099511627775), false, false, ""}, equalsTestCase{uint64(1099511627775), false, false, ""}, equalsTestCase{float64(1099511627776.1), false, false, ""}, equalsTestCase{float64(1099511627775.9), false, false, ""}, equalsTestCase{complex128(1099511627775), false, false, ""}, equalsTestCase{complex128(1099511627776 + 2i), false, false, ""}, // Non-numeric types. equalsTestCase{uintptr(0), false, true, "which is not numeric"}, equalsTestCase{true, false, true, "which is not numeric"}, equalsTestCase{[...]int{}, false, true, "which is not numeric"}, equalsTestCase{make(chan int), false, true, "which is not numeric"}, equalsTestCase{func() {}, false, true, "which is not numeric"}, equalsTestCase{map[int]int{}, false, true, "which is not numeric"}, equalsTestCase{&someInt, false, true, "which is not numeric"}, equalsTestCase{[]int{}, false, true, "which is not numeric"}, equalsTestCase{"taco", false, true, "which is not numeric"}, equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) Int64NotExactlyRepresentableBySinglePrecision() { // Single-precision floats don't have enough bits to represent the integers // near this one distinctly, so [2^25-1, 2^25+2] all receive the same value // and should be treated as equivalent when floats are in the mix. const kTwoTo25 = 1 << 25 matcher := Equals(int64(kTwoTo25 + 1)) ExpectEq("33554433", matcher.Description()) cases := []equalsTestCase{ // Integers. equalsTestCase{int64(kTwoTo25 + 0), false, false, ""}, equalsTestCase{int64(kTwoTo25 + 1), true, false, ""}, equalsTestCase{int64(kTwoTo25 + 2), false, false, ""}, equalsTestCase{uint64(kTwoTo25 + 0), false, false, ""}, equalsTestCase{uint64(kTwoTo25 + 1), true, false, ""}, equalsTestCase{uint64(kTwoTo25 + 2), false, false, ""}, // Single-precision floating point. equalsTestCase{float32(kTwoTo25 - 2), false, false, ""}, equalsTestCase{float32(kTwoTo25 - 1), true, false, ""}, equalsTestCase{float32(kTwoTo25 + 0), true, false, ""}, equalsTestCase{float32(kTwoTo25 + 1), true, false, ""}, equalsTestCase{float32(kTwoTo25 + 2), true, false, ""}, equalsTestCase{float32(kTwoTo25 + 3), false, false, ""}, equalsTestCase{complex64(kTwoTo25 - 2), false, false, ""}, equalsTestCase{complex64(kTwoTo25 - 1), true, false, ""}, equalsTestCase{complex64(kTwoTo25 + 0), true, false, ""}, equalsTestCase{complex64(kTwoTo25 + 1), true, false, ""}, equalsTestCase{complex64(kTwoTo25 + 2), true, false, ""}, equalsTestCase{complex64(kTwoTo25 + 3), false, false, ""}, // Double-precision floating point. equalsTestCase{float64(kTwoTo25 + 0), false, false, ""}, equalsTestCase{float64(kTwoTo25 + 1), true, false, ""}, equalsTestCase{float64(kTwoTo25 + 2), false, false, ""}, equalsTestCase{complex128(kTwoTo25 + 0), false, false, ""}, equalsTestCase{complex128(kTwoTo25 + 1), true, false, ""}, equalsTestCase{complex128(kTwoTo25 + 2), false, false, ""}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) Int64NotExactlyRepresentableByDoublePrecision() { // Double-precision floats don't have enough bits to represent the integers // near this one distinctly, so [2^54-1, 2^54+2] all receive the same value // and should be treated as equivalent when floats are in the mix. const kTwoTo54 = 1 << 54 matcher := Equals(int64(kTwoTo54 + 1)) ExpectEq("18014398509481985", matcher.Description()) cases := []equalsTestCase{ // Integers. equalsTestCase{int64(kTwoTo54 + 0), false, false, ""}, equalsTestCase{int64(kTwoTo54 + 1), true, false, ""}, equalsTestCase{int64(kTwoTo54 + 2), false, false, ""}, equalsTestCase{uint64(kTwoTo54 + 0), false, false, ""}, equalsTestCase{uint64(kTwoTo54 + 1), true, false, ""}, equalsTestCase{uint64(kTwoTo54 + 2), false, false, ""}, // Double-precision floating point. equalsTestCase{float64(kTwoTo54 - 2), false, false, ""}, equalsTestCase{float64(kTwoTo54 - 1), true, false, ""}, equalsTestCase{float64(kTwoTo54 + 0), true, false, ""}, equalsTestCase{float64(kTwoTo54 + 1), true, false, ""}, equalsTestCase{float64(kTwoTo54 + 2), true, false, ""}, equalsTestCase{float64(kTwoTo54 + 3), false, false, ""}, equalsTestCase{complex128(kTwoTo54 - 2), false, false, ""}, equalsTestCase{complex128(kTwoTo54 - 1), true, false, ""}, equalsTestCase{complex128(kTwoTo54 + 0), true, false, ""}, equalsTestCase{complex128(kTwoTo54 + 1), true, false, ""}, equalsTestCase{complex128(kTwoTo54 + 2), true, false, ""}, equalsTestCase{complex128(kTwoTo54 + 3), false, false, ""}, } t.checkTestCases(matcher, cases) } //////////////////////////////////////////////////////////////////////// // uint //////////////////////////////////////////////////////////////////////// func (t *EqualsTest) SmallUint() { const kExpected = 17 matcher := Equals(uint(kExpected)) ExpectEq("17", matcher.Description()) cases := []equalsTestCase{ // Various types of the expected value. equalsTestCase{17, true, false, ""}, equalsTestCase{17.0, true, false, ""}, equalsTestCase{17 + 0i, true, false, ""}, equalsTestCase{int(kExpected), true, false, ""}, equalsTestCase{int8(kExpected), true, false, ""}, equalsTestCase{int16(kExpected), true, false, ""}, equalsTestCase{int32(kExpected), true, false, ""}, equalsTestCase{int64(kExpected), true, false, ""}, equalsTestCase{uint(kExpected), true, false, ""}, equalsTestCase{uint8(kExpected), true, false, ""}, equalsTestCase{uint16(kExpected), true, false, ""}, equalsTestCase{uint32(kExpected), true, false, ""}, equalsTestCase{uint64(kExpected), true, false, ""}, equalsTestCase{float32(kExpected), true, false, ""}, equalsTestCase{float64(kExpected), true, false, ""}, equalsTestCase{complex64(kExpected), true, false, ""}, equalsTestCase{complex128(kExpected), true, false, ""}, // Non-equal values of numeric types. equalsTestCase{kExpected + 1, false, false, ""}, equalsTestCase{int(kExpected + 1), false, false, ""}, equalsTestCase{int8(kExpected + 1), false, false, ""}, equalsTestCase{int16(kExpected + 1), false, false, ""}, equalsTestCase{int32(kExpected + 1), false, false, ""}, equalsTestCase{int64(kExpected + 1), false, false, ""}, equalsTestCase{uint(kExpected + 1), false, false, ""}, equalsTestCase{uint8(kExpected + 1), false, false, ""}, equalsTestCase{uint16(kExpected + 1), false, false, ""}, equalsTestCase{uint32(kExpected + 1), false, false, ""}, equalsTestCase{uint64(kExpected + 1), false, false, ""}, equalsTestCase{float32(kExpected + 1), false, false, ""}, equalsTestCase{float64(kExpected + 1), false, false, ""}, equalsTestCase{complex64(kExpected + 2i), false, false, ""}, equalsTestCase{complex64(kExpected + 1), false, false, ""}, equalsTestCase{complex128(kExpected + 2i), false, false, ""}, equalsTestCase{complex128(kExpected + 1), false, false, ""}, // Non-numeric types. equalsTestCase{uintptr(0), false, true, "which is not numeric"}, equalsTestCase{true, false, true, "which is not numeric"}, equalsTestCase{[...]int{}, false, true, "which is not numeric"}, equalsTestCase{make(chan int), false, true, "which is not numeric"}, equalsTestCase{func() {}, false, true, "which is not numeric"}, equalsTestCase{map[int]int{}, false, true, "which is not numeric"}, equalsTestCase{&someInt, false, true, "which is not numeric"}, equalsTestCase{[]int{}, false, true, "which is not numeric"}, equalsTestCase{"taco", false, true, "which is not numeric"}, equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) LargeUint() { const kExpected = (1 << 16) + 17 matcher := Equals(uint(kExpected)) ExpectEq("65553", matcher.Description()) cases := []equalsTestCase{ // Various types of the expected value. equalsTestCase{65553, true, false, ""}, equalsTestCase{65553.0, true, false, ""}, equalsTestCase{65553 + 0i, true, false, ""}, equalsTestCase{int32(kExpected), true, false, ""}, equalsTestCase{int64(kExpected), true, false, ""}, equalsTestCase{uint32(kExpected), true, false, ""}, equalsTestCase{uint64(kExpected), true, false, ""}, equalsTestCase{float32(kExpected), true, false, ""}, equalsTestCase{float64(kExpected), true, false, ""}, equalsTestCase{complex64(kExpected), true, false, ""}, equalsTestCase{complex128(kExpected), true, false, ""}, // Non-equal values of numeric types. equalsTestCase{int16(17), false, false, ""}, equalsTestCase{int32(kExpected + 1), false, false, ""}, equalsTestCase{int64(kExpected + 1), false, false, ""}, equalsTestCase{uint16(17), false, false, ""}, equalsTestCase{uint32(kExpected + 1), false, false, ""}, equalsTestCase{uint64(kExpected + 1), false, false, ""}, equalsTestCase{float64(kExpected + 1), false, false, ""}, equalsTestCase{complex128(kExpected + 2i), false, false, ""}, equalsTestCase{complex128(kExpected + 1), false, false, ""}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) UintNotExactlyRepresentableBySinglePrecision() { // Single-precision floats don't have enough bits to represent the integers // near this one distinctly, so [2^25-1, 2^25+2] all receive the same value // and should be treated as equivalent when floats are in the mix. const kTwoTo25 = 1 << 25 matcher := Equals(uint(kTwoTo25 + 1)) ExpectEq("33554433", matcher.Description()) cases := []equalsTestCase{ // Integers. equalsTestCase{int64(kTwoTo25 + 0), false, false, ""}, equalsTestCase{int64(kTwoTo25 + 1), true, false, ""}, equalsTestCase{int64(kTwoTo25 + 2), false, false, ""}, equalsTestCase{uint64(kTwoTo25 + 0), false, false, ""}, equalsTestCase{uint64(kTwoTo25 + 1), true, false, ""}, equalsTestCase{uint64(kTwoTo25 + 2), false, false, ""}, // Single-precision floating point. equalsTestCase{float32(kTwoTo25 - 2), false, false, ""}, equalsTestCase{float32(kTwoTo25 - 1), true, false, ""}, equalsTestCase{float32(kTwoTo25 + 0), true, false, ""}, equalsTestCase{float32(kTwoTo25 + 1), true, false, ""}, equalsTestCase{float32(kTwoTo25 + 2), true, false, ""}, equalsTestCase{float32(kTwoTo25 + 3), false, false, ""}, equalsTestCase{complex64(kTwoTo25 - 2), false, false, ""}, equalsTestCase{complex64(kTwoTo25 - 1), true, false, ""}, equalsTestCase{complex64(kTwoTo25 + 0), true, false, ""}, equalsTestCase{complex64(kTwoTo25 + 1), true, false, ""}, equalsTestCase{complex64(kTwoTo25 + 2), true, false, ""}, equalsTestCase{complex64(kTwoTo25 + 3), false, false, ""}, // Double-precision floating point. equalsTestCase{float64(kTwoTo25 + 0), false, false, ""}, equalsTestCase{float64(kTwoTo25 + 1), true, false, ""}, equalsTestCase{float64(kTwoTo25 + 2), false, false, ""}, equalsTestCase{complex128(kTwoTo25 + 0), false, false, ""}, equalsTestCase{complex128(kTwoTo25 + 1), true, false, ""}, equalsTestCase{complex128(kTwoTo25 + 2), false, false, ""}, } t.checkTestCases(matcher, cases) } //////////////////////////////////////////////////////////////////////// // uint8 //////////////////////////////////////////////////////////////////////// func (t *EqualsTest) SmallUint8() { const kExpected = 17 matcher := Equals(uint8(kExpected)) ExpectEq("17", matcher.Description()) cases := []equalsTestCase{ // Various types of the expected value. equalsTestCase{17, true, false, ""}, equalsTestCase{17.0, true, false, ""}, equalsTestCase{17 + 0i, true, false, ""}, equalsTestCase{int(kExpected), true, false, ""}, equalsTestCase{int8(kExpected), true, false, ""}, equalsTestCase{int16(kExpected), true, false, ""}, equalsTestCase{int32(kExpected), true, false, ""}, equalsTestCase{int64(kExpected), true, false, ""}, equalsTestCase{uint(kExpected), true, false, ""}, equalsTestCase{uint8(kExpected), true, false, ""}, equalsTestCase{uint16(kExpected), true, false, ""}, equalsTestCase{uint32(kExpected), true, false, ""}, equalsTestCase{uint64(kExpected), true, false, ""}, equalsTestCase{float32(kExpected), true, false, ""}, equalsTestCase{float64(kExpected), true, false, ""}, equalsTestCase{complex64(kExpected), true, false, ""}, equalsTestCase{complex128(kExpected), true, false, ""}, // Non-equal values of numeric types. equalsTestCase{kExpected + 1, false, false, ""}, equalsTestCase{int(kExpected + 1), false, false, ""}, equalsTestCase{int8(kExpected + 1), false, false, ""}, equalsTestCase{int16(kExpected + 1), false, false, ""}, equalsTestCase{int32(kExpected + 1), false, false, ""}, equalsTestCase{int64(kExpected + 1), false, false, ""}, equalsTestCase{uint(kExpected + 1), false, false, ""}, equalsTestCase{uint8(kExpected + 1), false, false, ""}, equalsTestCase{uint16(kExpected + 1), false, false, ""}, equalsTestCase{uint32(kExpected + 1), false, false, ""}, equalsTestCase{uint64(kExpected + 1), false, false, ""}, equalsTestCase{float32(kExpected + 1), false, false, ""}, equalsTestCase{float64(kExpected + 1), false, false, ""}, equalsTestCase{complex64(kExpected + 2i), false, false, ""}, equalsTestCase{complex64(kExpected + 1), false, false, ""}, equalsTestCase{complex128(kExpected + 2i), false, false, ""}, equalsTestCase{complex128(kExpected + 1), false, false, ""}, // Non-numeric types. equalsTestCase{uintptr(0), false, true, "which is not numeric"}, equalsTestCase{true, false, true, "which is not numeric"}, equalsTestCase{[...]int{}, false, true, "which is not numeric"}, equalsTestCase{make(chan int), false, true, "which is not numeric"}, equalsTestCase{func() {}, false, true, "which is not numeric"}, equalsTestCase{map[int]int{}, false, true, "which is not numeric"}, equalsTestCase{&someInt, false, true, "which is not numeric"}, equalsTestCase{[]int{}, false, true, "which is not numeric"}, equalsTestCase{"taco", false, true, "which is not numeric"}, equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"}, } t.checkTestCases(matcher, cases) } //////////////////////////////////////////////////////////////////////// // uint16 //////////////////////////////////////////////////////////////////////// func (t *EqualsTest) SmallUint16() { const kExpected = 17 matcher := Equals(uint16(kExpected)) ExpectEq("17", matcher.Description()) cases := []equalsTestCase{ // Various types of the expected value. equalsTestCase{17, true, false, ""}, equalsTestCase{17.0, true, false, ""}, equalsTestCase{17 + 0i, true, false, ""}, equalsTestCase{int(kExpected), true, false, ""}, equalsTestCase{int8(kExpected), true, false, ""}, equalsTestCase{int16(kExpected), true, false, ""}, equalsTestCase{int32(kExpected), true, false, ""}, equalsTestCase{int64(kExpected), true, false, ""}, equalsTestCase{uint(kExpected), true, false, ""}, equalsTestCase{uint8(kExpected), true, false, ""}, equalsTestCase{uint16(kExpected), true, false, ""}, equalsTestCase{uint32(kExpected), true, false, ""}, equalsTestCase{uint64(kExpected), true, false, ""}, equalsTestCase{float32(kExpected), true, false, ""}, equalsTestCase{float64(kExpected), true, false, ""}, equalsTestCase{complex64(kExpected), true, false, ""}, equalsTestCase{complex128(kExpected), true, false, ""}, // Non-equal values of numeric types. equalsTestCase{kExpected + 1, false, false, ""}, equalsTestCase{int(kExpected + 1), false, false, ""}, equalsTestCase{int8(kExpected + 1), false, false, ""}, equalsTestCase{int16(kExpected + 1), false, false, ""}, equalsTestCase{int32(kExpected + 1), false, false, ""}, equalsTestCase{int64(kExpected + 1), false, false, ""}, equalsTestCase{uint(kExpected + 1), false, false, ""}, equalsTestCase{uint8(kExpected + 1), false, false, ""}, equalsTestCase{uint16(kExpected + 1), false, false, ""}, equalsTestCase{uint32(kExpected + 1), false, false, ""}, equalsTestCase{uint64(kExpected + 1), false, false, ""}, equalsTestCase{float32(kExpected + 1), false, false, ""}, equalsTestCase{float64(kExpected + 1), false, false, ""}, equalsTestCase{complex64(kExpected + 2i), false, false, ""}, equalsTestCase{complex64(kExpected + 1), false, false, ""}, equalsTestCase{complex128(kExpected + 2i), false, false, ""}, equalsTestCase{complex128(kExpected + 1), false, false, ""}, // Non-numeric types. equalsTestCase{uintptr(0), false, true, "which is not numeric"}, equalsTestCase{true, false, true, "which is not numeric"}, equalsTestCase{[...]int{}, false, true, "which is not numeric"}, equalsTestCase{make(chan int), false, true, "which is not numeric"}, equalsTestCase{func() {}, false, true, "which is not numeric"}, equalsTestCase{map[int]int{}, false, true, "which is not numeric"}, equalsTestCase{&someInt, false, true, "which is not numeric"}, equalsTestCase{[]int{}, false, true, "which is not numeric"}, equalsTestCase{"taco", false, true, "which is not numeric"}, equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) LargeUint16() { const kExpected = (1 << 8) + 17 matcher := Equals(uint16(kExpected)) ExpectEq("273", matcher.Description()) cases := []equalsTestCase{ // Various types of the expected value. equalsTestCase{273, true, false, ""}, equalsTestCase{273.0, true, false, ""}, equalsTestCase{273 + 0i, true, false, ""}, equalsTestCase{int16(kExpected), true, false, ""}, equalsTestCase{int32(kExpected), true, false, ""}, equalsTestCase{int64(kExpected), true, false, ""}, equalsTestCase{uint16(kExpected), true, false, ""}, equalsTestCase{uint32(kExpected), true, false, ""}, equalsTestCase{uint64(kExpected), true, false, ""}, equalsTestCase{float32(kExpected), true, false, ""}, equalsTestCase{float64(kExpected), true, false, ""}, equalsTestCase{complex64(kExpected), true, false, ""}, equalsTestCase{complex128(kExpected), true, false, ""}, // Non-equal values of numeric types. equalsTestCase{int8(17), false, false, ""}, equalsTestCase{int16(kExpected + 1), false, false, ""}, equalsTestCase{int32(kExpected + 1), false, false, ""}, equalsTestCase{int64(kExpected + 1), false, false, ""}, equalsTestCase{uint8(17), false, false, ""}, equalsTestCase{uint16(kExpected + 1), false, false, ""}, equalsTestCase{uint32(kExpected + 1), false, false, ""}, equalsTestCase{uint64(kExpected + 1), false, false, ""}, equalsTestCase{float64(kExpected + 1), false, false, ""}, equalsTestCase{complex128(kExpected + 2i), false, false, ""}, equalsTestCase{complex128(kExpected + 1), false, false, ""}, } t.checkTestCases(matcher, cases) } //////////////////////////////////////////////////////////////////////// // uint32 //////////////////////////////////////////////////////////////////////// func (t *EqualsTest) SmallUint32() { const kExpected = 17 matcher := Equals(uint32(kExpected)) ExpectEq("17", matcher.Description()) cases := []equalsTestCase{ // Various types of the expected value. equalsTestCase{17, true, false, ""}, equalsTestCase{17.0, true, false, ""}, equalsTestCase{17 + 0i, true, false, ""}, equalsTestCase{int(kExpected), true, false, ""}, equalsTestCase{int8(kExpected), true, false, ""}, equalsTestCase{int16(kExpected), true, false, ""}, equalsTestCase{int32(kExpected), true, false, ""}, equalsTestCase{int64(kExpected), true, false, ""}, equalsTestCase{uint(kExpected), true, false, ""}, equalsTestCase{uint8(kExpected), true, false, ""}, equalsTestCase{uint16(kExpected), true, false, ""}, equalsTestCase{uint32(kExpected), true, false, ""}, equalsTestCase{uint64(kExpected), true, false, ""}, equalsTestCase{float32(kExpected), true, false, ""}, equalsTestCase{float64(kExpected), true, false, ""}, equalsTestCase{complex64(kExpected), true, false, ""}, equalsTestCase{complex128(kExpected), true, false, ""}, // Non-equal values of numeric types. equalsTestCase{kExpected + 1, false, false, ""}, equalsTestCase{int(kExpected + 1), false, false, ""}, equalsTestCase{int8(kExpected + 1), false, false, ""}, equalsTestCase{int16(kExpected + 1), false, false, ""}, equalsTestCase{int32(kExpected + 1), false, false, ""}, equalsTestCase{int64(kExpected + 1), false, false, ""}, equalsTestCase{uint(kExpected + 1), false, false, ""}, equalsTestCase{uint8(kExpected + 1), false, false, ""}, equalsTestCase{uint16(kExpected + 1), false, false, ""}, equalsTestCase{uint32(kExpected + 1), false, false, ""}, equalsTestCase{uint64(kExpected + 1), false, false, ""}, equalsTestCase{float32(kExpected + 1), false, false, ""}, equalsTestCase{float64(kExpected + 1), false, false, ""}, equalsTestCase{complex64(kExpected + 2i), false, false, ""}, equalsTestCase{complex64(kExpected + 1), false, false, ""}, equalsTestCase{complex128(kExpected + 2i), false, false, ""}, equalsTestCase{complex128(kExpected + 1), false, false, ""}, // Non-numeric types. equalsTestCase{uintptr(0), false, true, "which is not numeric"}, equalsTestCase{true, false, true, "which is not numeric"}, equalsTestCase{[...]int{}, false, true, "which is not numeric"}, equalsTestCase{make(chan int), false, true, "which is not numeric"}, equalsTestCase{func() {}, false, true, "which is not numeric"}, equalsTestCase{map[int]int{}, false, true, "which is not numeric"}, equalsTestCase{&someInt, false, true, "which is not numeric"}, equalsTestCase{[]int{}, false, true, "which is not numeric"}, equalsTestCase{"taco", false, true, "which is not numeric"}, equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) LargeUint32() { const kExpected = (1 << 16) + 17 matcher := Equals(uint32(kExpected)) ExpectEq("65553", matcher.Description()) cases := []equalsTestCase{ // Various types of the expected value. equalsTestCase{65553, true, false, ""}, equalsTestCase{65553.0, true, false, ""}, equalsTestCase{65553 + 0i, true, false, ""}, equalsTestCase{int32(kExpected), true, false, ""}, equalsTestCase{int64(kExpected), true, false, ""}, equalsTestCase{uint32(kExpected), true, false, ""}, equalsTestCase{uint64(kExpected), true, false, ""}, equalsTestCase{float32(kExpected), true, false, ""}, equalsTestCase{float64(kExpected), true, false, ""}, equalsTestCase{complex64(kExpected), true, false, ""}, equalsTestCase{complex128(kExpected), true, false, ""}, // Non-equal values of numeric types. equalsTestCase{int16(17), false, false, ""}, equalsTestCase{int32(kExpected + 1), false, false, ""}, equalsTestCase{int64(kExpected + 1), false, false, ""}, equalsTestCase{uint16(17), false, false, ""}, equalsTestCase{uint32(kExpected + 1), false, false, ""}, equalsTestCase{uint64(kExpected + 1), false, false, ""}, equalsTestCase{float64(kExpected + 1), false, false, ""}, equalsTestCase{complex128(kExpected + 2i), false, false, ""}, equalsTestCase{complex128(kExpected + 1), false, false, ""}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) Uint32NotExactlyRepresentableBySinglePrecision() { // Single-precision floats don't have enough bits to represent the integers // near this one distinctly, so [2^25-1, 2^25+2] all receive the same value // and should be treated as equivalent when floats are in the mix. const kTwoTo25 = 1 << 25 matcher := Equals(uint32(kTwoTo25 + 1)) ExpectEq("33554433", matcher.Description()) cases := []equalsTestCase{ // Integers. equalsTestCase{int64(kTwoTo25 + 0), false, false, ""}, equalsTestCase{int64(kTwoTo25 + 1), true, false, ""}, equalsTestCase{int64(kTwoTo25 + 2), false, false, ""}, equalsTestCase{uint64(kTwoTo25 + 0), false, false, ""}, equalsTestCase{uint64(kTwoTo25 + 1), true, false, ""}, equalsTestCase{uint64(kTwoTo25 + 2), false, false, ""}, // Single-precision floating point. equalsTestCase{float32(kTwoTo25 - 2), false, false, ""}, equalsTestCase{float32(kTwoTo25 - 1), true, false, ""}, equalsTestCase{float32(kTwoTo25 + 0), true, false, ""}, equalsTestCase{float32(kTwoTo25 + 1), true, false, ""}, equalsTestCase{float32(kTwoTo25 + 2), true, false, ""}, equalsTestCase{float32(kTwoTo25 + 3), false, false, ""}, equalsTestCase{complex64(kTwoTo25 - 2), false, false, ""}, equalsTestCase{complex64(kTwoTo25 - 1), true, false, ""}, equalsTestCase{complex64(kTwoTo25 + 0), true, false, ""}, equalsTestCase{complex64(kTwoTo25 + 1), true, false, ""}, equalsTestCase{complex64(kTwoTo25 + 2), true, false, ""}, equalsTestCase{complex64(kTwoTo25 + 3), false, false, ""}, // Double-precision floating point. equalsTestCase{float64(kTwoTo25 + 0), false, false, ""}, equalsTestCase{float64(kTwoTo25 + 1), true, false, ""}, equalsTestCase{float64(kTwoTo25 + 2), false, false, ""}, equalsTestCase{complex128(kTwoTo25 + 0), false, false, ""}, equalsTestCase{complex128(kTwoTo25 + 1), true, false, ""}, equalsTestCase{complex128(kTwoTo25 + 2), false, false, ""}, } t.checkTestCases(matcher, cases) } //////////////////////////////////////////////////////////////////////// // uint64 //////////////////////////////////////////////////////////////////////// func (t *EqualsTest) SmallUint64() { const kExpected = 17 matcher := Equals(uint64(kExpected)) ExpectEq("17", matcher.Description()) cases := []equalsTestCase{ // Various types of the expected value. equalsTestCase{17, true, false, ""}, equalsTestCase{17.0, true, false, ""}, equalsTestCase{17 + 0i, true, false, ""}, equalsTestCase{int(kExpected), true, false, ""}, equalsTestCase{int8(kExpected), true, false, ""}, equalsTestCase{int16(kExpected), true, false, ""}, equalsTestCase{int32(kExpected), true, false, ""}, equalsTestCase{int64(kExpected), true, false, ""}, equalsTestCase{uint(kExpected), true, false, ""}, equalsTestCase{uint8(kExpected), true, false, ""}, equalsTestCase{uint16(kExpected), true, false, ""}, equalsTestCase{uint32(kExpected), true, false, ""}, equalsTestCase{uint64(kExpected), true, false, ""}, equalsTestCase{float32(kExpected), true, false, ""}, equalsTestCase{float64(kExpected), true, false, ""}, equalsTestCase{complex64(kExpected), true, false, ""}, equalsTestCase{complex128(kExpected), true, false, ""}, // Non-equal values of numeric types. equalsTestCase{kExpected + 1, false, false, ""}, equalsTestCase{int(kExpected + 1), false, false, ""}, equalsTestCase{int8(kExpected + 1), false, false, ""}, equalsTestCase{int16(kExpected + 1), false, false, ""}, equalsTestCase{int32(kExpected + 1), false, false, ""}, equalsTestCase{int64(kExpected + 1), false, false, ""}, equalsTestCase{uint(kExpected + 1), false, false, ""}, equalsTestCase{uint8(kExpected + 1), false, false, ""}, equalsTestCase{uint16(kExpected + 1), false, false, ""}, equalsTestCase{uint32(kExpected + 1), false, false, ""}, equalsTestCase{uint64(kExpected + 1), false, false, ""}, equalsTestCase{float32(kExpected + 1), false, false, ""}, equalsTestCase{float64(kExpected + 1), false, false, ""}, equalsTestCase{complex64(kExpected + 2i), false, false, ""}, equalsTestCase{complex64(kExpected + 1), false, false, ""}, equalsTestCase{complex128(kExpected + 2i), false, false, ""}, equalsTestCase{complex128(kExpected + 1), false, false, ""}, // Non-numeric types. equalsTestCase{uintptr(0), false, true, "which is not numeric"}, equalsTestCase{true, false, true, "which is not numeric"}, equalsTestCase{[...]int{}, false, true, "which is not numeric"}, equalsTestCase{make(chan int), false, true, "which is not numeric"}, equalsTestCase{func() {}, false, true, "which is not numeric"}, equalsTestCase{map[int]int{}, false, true, "which is not numeric"}, equalsTestCase{&someInt, false, true, "which is not numeric"}, equalsTestCase{[]int{}, false, true, "which is not numeric"}, equalsTestCase{"taco", false, true, "which is not numeric"}, equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) LargeUint64() { const kExpected = (1 << 32) + 17 matcher := Equals(uint64(kExpected)) ExpectEq("4294967313", matcher.Description()) cases := []equalsTestCase{ // Various types of the expected value. equalsTestCase{4294967313.0, true, false, ""}, equalsTestCase{4294967313 + 0i, true, false, ""}, equalsTestCase{int64(kExpected), true, false, ""}, equalsTestCase{uint64(kExpected), true, false, ""}, equalsTestCase{float32(kExpected), true, false, ""}, equalsTestCase{float64(kExpected), true, false, ""}, equalsTestCase{complex64(kExpected), true, false, ""}, equalsTestCase{complex128(kExpected), true, false, ""}, // Non-equal values of numeric types. equalsTestCase{int(17), false, false, ""}, equalsTestCase{int32(17), false, false, ""}, equalsTestCase{int64(kExpected + 1), false, false, ""}, equalsTestCase{uint(17), false, false, ""}, equalsTestCase{uint32(17), false, false, ""}, equalsTestCase{uint64(kExpected + 1), false, false, ""}, equalsTestCase{float64(kExpected + 1), false, false, ""}, equalsTestCase{complex128(kExpected + 2i), false, false, ""}, equalsTestCase{complex128(kExpected + 1), false, false, ""}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) Uint64NotExactlyRepresentableBySinglePrecision() { // Single-precision floats don't have enough bits to represent the integers // near this one distinctly, so [2^25-1, 2^25+2] all receive the same value // and should be treated as equivalent when floats are in the mix. const kTwoTo25 = 1 << 25 matcher := Equals(uint64(kTwoTo25 + 1)) ExpectEq("33554433", matcher.Description()) cases := []equalsTestCase{ // Integers. equalsTestCase{int64(kTwoTo25 + 0), false, false, ""}, equalsTestCase{int64(kTwoTo25 + 1), true, false, ""}, equalsTestCase{int64(kTwoTo25 + 2), false, false, ""}, equalsTestCase{uint64(kTwoTo25 + 0), false, false, ""}, equalsTestCase{uint64(kTwoTo25 + 1), true, false, ""}, equalsTestCase{uint64(kTwoTo25 + 2), false, false, ""}, // Single-precision floating point. equalsTestCase{float32(kTwoTo25 - 2), false, false, ""}, equalsTestCase{float32(kTwoTo25 - 1), true, false, ""}, equalsTestCase{float32(kTwoTo25 + 0), true, false, ""}, equalsTestCase{float32(kTwoTo25 + 1), true, false, ""}, equalsTestCase{float32(kTwoTo25 + 2), true, false, ""}, equalsTestCase{float32(kTwoTo25 + 3), false, false, ""}, equalsTestCase{complex64(kTwoTo25 - 2), false, false, ""}, equalsTestCase{complex64(kTwoTo25 - 1), true, false, ""}, equalsTestCase{complex64(kTwoTo25 + 0), true, false, ""}, equalsTestCase{complex64(kTwoTo25 + 1), true, false, ""}, equalsTestCase{complex64(kTwoTo25 + 2), true, false, ""}, equalsTestCase{complex64(kTwoTo25 + 3), false, false, ""}, // Double-precision floating point. equalsTestCase{float64(kTwoTo25 + 0), false, false, ""}, equalsTestCase{float64(kTwoTo25 + 1), true, false, ""}, equalsTestCase{float64(kTwoTo25 + 2), false, false, ""}, equalsTestCase{complex128(kTwoTo25 + 0), false, false, ""}, equalsTestCase{complex128(kTwoTo25 + 1), true, false, ""}, equalsTestCase{complex128(kTwoTo25 + 2), false, false, ""}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) Uint64NotExactlyRepresentableByDoublePrecision() { // Double-precision floats don't have enough bits to represent the integers // near this one distinctly, so [2^54-1, 2^54+2] all receive the same value // and should be treated as equivalent when floats are in the mix. const kTwoTo54 = 1 << 54 matcher := Equals(uint64(kTwoTo54 + 1)) ExpectEq("18014398509481985", matcher.Description()) cases := []equalsTestCase{ // Integers. equalsTestCase{int64(kTwoTo54 + 0), false, false, ""}, equalsTestCase{int64(kTwoTo54 + 1), true, false, ""}, equalsTestCase{int64(kTwoTo54 + 2), false, false, ""}, equalsTestCase{uint64(kTwoTo54 + 0), false, false, ""}, equalsTestCase{uint64(kTwoTo54 + 1), true, false, ""}, equalsTestCase{uint64(kTwoTo54 + 2), false, false, ""}, // Double-precision floating point. equalsTestCase{float64(kTwoTo54 - 2), false, false, ""}, equalsTestCase{float64(kTwoTo54 - 1), true, false, ""}, equalsTestCase{float64(kTwoTo54 + 0), true, false, ""}, equalsTestCase{float64(kTwoTo54 + 1), true, false, ""}, equalsTestCase{float64(kTwoTo54 + 2), true, false, ""}, equalsTestCase{float64(kTwoTo54 + 3), false, false, ""}, equalsTestCase{complex128(kTwoTo54 - 2), false, false, ""}, equalsTestCase{complex128(kTwoTo54 - 1), true, false, ""}, equalsTestCase{complex128(kTwoTo54 + 0), true, false, ""}, equalsTestCase{complex128(kTwoTo54 + 1), true, false, ""}, equalsTestCase{complex128(kTwoTo54 + 2), true, false, ""}, equalsTestCase{complex128(kTwoTo54 + 3), false, false, ""}, } t.checkTestCases(matcher, cases) } //////////////////////////////////////////////////////////////////////// // uintptr //////////////////////////////////////////////////////////////////////// func (t *EqualsTest) NilUintptr() { var ptr1 uintptr var ptr2 uintptr matcher := Equals(ptr1) ExpectEq("0", matcher.Description()) cases := []equalsTestCase{ // uintptrs equalsTestCase{ptr1, true, false, ""}, equalsTestCase{ptr2, true, false, ""}, equalsTestCase{uintptr(0), true, false, ""}, equalsTestCase{uintptr(17), false, false, ""}, // Other types. equalsTestCase{0, false, true, "which is not a uintptr"}, equalsTestCase{bool(false), false, true, "which is not a uintptr"}, equalsTestCase{int(0), false, true, "which is not a uintptr"}, equalsTestCase{int8(0), false, true, "which is not a uintptr"}, equalsTestCase{int16(0), false, true, "which is not a uintptr"}, equalsTestCase{int32(0), false, true, "which is not a uintptr"}, equalsTestCase{int64(0), false, true, "which is not a uintptr"}, equalsTestCase{uint(0), false, true, "which is not a uintptr"}, equalsTestCase{uint8(0), false, true, "which is not a uintptr"}, equalsTestCase{uint16(0), false, true, "which is not a uintptr"}, equalsTestCase{uint32(0), false, true, "which is not a uintptr"}, equalsTestCase{uint64(0), false, true, "which is not a uintptr"}, equalsTestCase{true, false, true, "which is not a uintptr"}, equalsTestCase{[...]int{}, false, true, "which is not a uintptr"}, equalsTestCase{make(chan int), false, true, "which is not a uintptr"}, equalsTestCase{func() {}, false, true, "which is not a uintptr"}, equalsTestCase{map[int]int{}, false, true, "which is not a uintptr"}, equalsTestCase{&someInt, false, true, "which is not a uintptr"}, equalsTestCase{[]int{}, false, true, "which is not a uintptr"}, equalsTestCase{"taco", false, true, "which is not a uintptr"}, equalsTestCase{equalsTestCase{}, false, true, "which is not a uintptr"}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) NonNilUintptr() { matcher := Equals(uintptr(17)) ExpectEq("17", matcher.Description()) cases := []equalsTestCase{ // uintptrs equalsTestCase{uintptr(17), true, false, ""}, equalsTestCase{uintptr(16), false, false, ""}, equalsTestCase{uintptr(0), false, false, ""}, // Other types. equalsTestCase{0, false, true, "which is not a uintptr"}, equalsTestCase{bool(false), false, true, "which is not a uintptr"}, equalsTestCase{int(0), false, true, "which is not a uintptr"}, equalsTestCase{int8(0), false, true, "which is not a uintptr"}, equalsTestCase{int16(0), false, true, "which is not a uintptr"}, equalsTestCase{int32(0), false, true, "which is not a uintptr"}, equalsTestCase{int64(0), false, true, "which is not a uintptr"}, equalsTestCase{uint(0), false, true, "which is not a uintptr"}, equalsTestCase{uint8(0), false, true, "which is not a uintptr"}, equalsTestCase{uint16(0), false, true, "which is not a uintptr"}, equalsTestCase{uint32(0), false, true, "which is not a uintptr"}, equalsTestCase{uint64(0), false, true, "which is not a uintptr"}, equalsTestCase{true, false, true, "which is not a uintptr"}, equalsTestCase{[...]int{}, false, true, "which is not a uintptr"}, equalsTestCase{make(chan int), false, true, "which is not a uintptr"}, equalsTestCase{func() {}, false, true, "which is not a uintptr"}, equalsTestCase{map[int]int{}, false, true, "which is not a uintptr"}, equalsTestCase{&someInt, false, true, "which is not a uintptr"}, equalsTestCase{[]int{}, false, true, "which is not a uintptr"}, equalsTestCase{"taco", false, true, "which is not a uintptr"}, equalsTestCase{equalsTestCase{}, false, true, "which is not a uintptr"}, } t.checkTestCases(matcher, cases) } //////////////////////////////////////////////////////////////////////// // float32 //////////////////////////////////////////////////////////////////////// func (t *EqualsTest) NegativeIntegralFloat32() { matcher := Equals(float32(-32769)) ExpectEq("-32769", matcher.Description()) cases := []equalsTestCase{ // Various types of -32769. equalsTestCase{-32769.0, true, false, ""}, equalsTestCase{-32769 + 0i, true, false, ""}, equalsTestCase{int32(-32769), true, false, ""}, equalsTestCase{int64(-32769), true, false, ""}, equalsTestCase{float32(-32769), true, false, ""}, equalsTestCase{float64(-32769), true, false, ""}, equalsTestCase{complex64(-32769), true, false, ""}, equalsTestCase{complex128(-32769), true, false, ""}, equalsTestCase{interface{}(float32(-32769)), true, false, ""}, equalsTestCase{interface{}(int64(-32769)), true, false, ""}, // Values that would be -32769 in two's complement. equalsTestCase{uint64((1 << 64) - 32769), false, false, ""}, // Non-equal values of numeric type. equalsTestCase{int64(-32770), false, false, ""}, equalsTestCase{float32(-32769.1), false, false, ""}, equalsTestCase{float32(-32768.9), false, false, ""}, equalsTestCase{float64(-32769.1), false, false, ""}, equalsTestCase{float64(-32768.9), false, false, ""}, equalsTestCase{complex128(-32768), false, false, ""}, equalsTestCase{complex128(-32769 + 2i), false, false, ""}, // Non-numeric types. equalsTestCase{uintptr(0), false, true, "which is not numeric"}, equalsTestCase{true, false, true, "which is not numeric"}, equalsTestCase{[...]int{}, false, true, "which is not numeric"}, equalsTestCase{make(chan int), false, true, "which is not numeric"}, equalsTestCase{func() {}, false, true, "which is not numeric"}, equalsTestCase{map[int]int{}, false, true, "which is not numeric"}, equalsTestCase{&someInt, false, true, "which is not numeric"}, equalsTestCase{[]int{}, false, true, "which is not numeric"}, equalsTestCase{"taco", false, true, "which is not numeric"}, equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) NegativeNonIntegralFloat32() { matcher := Equals(float32(-32769.1)) ExpectEq("-32769.1", matcher.Description()) cases := []equalsTestCase{ // Various types of -32769.1. equalsTestCase{-32769.1, true, false, ""}, equalsTestCase{-32769.1 + 0i, true, false, ""}, equalsTestCase{float32(-32769.1), true, false, ""}, equalsTestCase{float64(-32769.1), true, false, ""}, equalsTestCase{complex64(-32769.1), true, false, ""}, equalsTestCase{complex128(-32769.1), true, false, ""}, // Non-equal values of numeric type. equalsTestCase{int32(-32769), false, false, ""}, equalsTestCase{int32(-32770), false, false, ""}, equalsTestCase{int64(-32769), false, false, ""}, equalsTestCase{int64(-32770), false, false, ""}, equalsTestCase{float32(-32769.2), false, false, ""}, equalsTestCase{float32(-32769.0), false, false, ""}, equalsTestCase{float64(-32769.2), false, false, ""}, equalsTestCase{complex128(-32769.1 + 2i), false, false, ""}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) LargeNegativeFloat32() { const kExpected = -1 * (1 << 65) matcher := Equals(float32(kExpected)) ExpectEq("-3.689349e+19", matcher.Description()) floatExpected := float32(kExpected) castedInt := int64(floatExpected) cases := []equalsTestCase{ // Equal values of numeric type. equalsTestCase{kExpected + 0i, true, false, ""}, equalsTestCase{float32(kExpected), true, false, ""}, equalsTestCase{float64(kExpected), true, false, ""}, equalsTestCase{complex64(kExpected), true, false, ""}, equalsTestCase{complex128(kExpected), true, false, ""}, // Non-equal values of numeric type. equalsTestCase{castedInt, false, false, ""}, equalsTestCase{int64(0), false, false, ""}, equalsTestCase{int64(math.MinInt64), false, false, ""}, equalsTestCase{int64(math.MaxInt64), false, false, ""}, equalsTestCase{float32(kExpected / 2), false, false, ""}, equalsTestCase{float64(kExpected / 2), false, false, ""}, equalsTestCase{complex128(kExpected + 2i), false, false, ""}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) ZeroFloat32() { matcher := Equals(float32(0)) ExpectEq("0", matcher.Description()) cases := []equalsTestCase{ // Various types of zero. equalsTestCase{0.0, true, false, ""}, equalsTestCase{0 + 0i, true, false, ""}, equalsTestCase{int(0), true, false, ""}, equalsTestCase{int8(0), true, false, ""}, equalsTestCase{int16(0), true, false, ""}, equalsTestCase{int32(0), true, false, ""}, equalsTestCase{int64(0), true, false, ""}, equalsTestCase{uint(0), true, false, ""}, equalsTestCase{uint8(0), true, false, ""}, equalsTestCase{uint16(0), true, false, ""}, equalsTestCase{uint32(0), true, false, ""}, equalsTestCase{uint64(0), true, false, ""}, equalsTestCase{float32(0), true, false, ""}, equalsTestCase{float64(0), true, false, ""}, equalsTestCase{complex64(0), true, false, ""}, equalsTestCase{complex128(0), true, false, ""}, equalsTestCase{interface{}(float32(0)), true, false, ""}, // Non-equal values of numeric type. equalsTestCase{int64(1), false, false, ""}, equalsTestCase{int64(-1), false, false, ""}, equalsTestCase{float32(1), false, false, ""}, equalsTestCase{float32(-1), false, false, ""}, equalsTestCase{complex128(0 + 2i), false, false, ""}, // Non-numeric types. equalsTestCase{uintptr(0), false, true, "which is not numeric"}, equalsTestCase{true, false, true, "which is not numeric"}, equalsTestCase{[...]int{}, false, true, "which is not numeric"}, equalsTestCase{make(chan int), false, true, "which is not numeric"}, equalsTestCase{func() {}, false, true, "which is not numeric"}, equalsTestCase{map[int]int{}, false, true, "which is not numeric"}, equalsTestCase{&someInt, false, true, "which is not numeric"}, equalsTestCase{[]int{}, false, true, "which is not numeric"}, equalsTestCase{"taco", false, true, "which is not numeric"}, equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) PositiveIntegralFloat32() { matcher := Equals(float32(32769)) ExpectEq("32769", matcher.Description()) cases := []equalsTestCase{ // Various types of 32769. equalsTestCase{32769.0, true, false, ""}, equalsTestCase{32769 + 0i, true, false, ""}, equalsTestCase{int(32769), true, false, ""}, equalsTestCase{int32(32769), true, false, ""}, equalsTestCase{int64(32769), true, false, ""}, equalsTestCase{uint(32769), true, false, ""}, equalsTestCase{uint32(32769), true, false, ""}, equalsTestCase{uint64(32769), true, false, ""}, equalsTestCase{float32(32769), true, false, ""}, equalsTestCase{float64(32769), true, false, ""}, equalsTestCase{complex64(32769), true, false, ""}, equalsTestCase{complex128(32769), true, false, ""}, equalsTestCase{interface{}(float32(32769)), true, false, ""}, // Non-equal values of numeric type. equalsTestCase{int64(32770), false, false, ""}, equalsTestCase{uint64(32770), false, false, ""}, equalsTestCase{float32(32769.1), false, false, ""}, equalsTestCase{float32(32768.9), false, false, ""}, equalsTestCase{float64(32769.1), false, false, ""}, equalsTestCase{float64(32768.9), false, false, ""}, equalsTestCase{complex128(32768), false, false, ""}, equalsTestCase{complex128(32769 + 2i), false, false, ""}, // Non-numeric types. equalsTestCase{uintptr(0), false, true, "which is not numeric"}, equalsTestCase{true, false, true, "which is not numeric"}, equalsTestCase{[...]int{}, false, true, "which is not numeric"}, equalsTestCase{make(chan int), false, true, "which is not numeric"}, equalsTestCase{func() {}, false, true, "which is not numeric"}, equalsTestCase{map[int]int{}, false, true, "which is not numeric"}, equalsTestCase{&someInt, false, true, "which is not numeric"}, equalsTestCase{[]int{}, false, true, "which is not numeric"}, equalsTestCase{"taco", false, true, "which is not numeric"}, equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) PositiveNonIntegralFloat32() { matcher := Equals(float32(32769.1)) ExpectEq("32769.1", matcher.Description()) cases := []equalsTestCase{ // Various types of 32769.1. equalsTestCase{32769.1, true, false, ""}, equalsTestCase{32769.1 + 0i, true, false, ""}, equalsTestCase{float32(32769.1), true, false, ""}, equalsTestCase{float64(32769.1), true, false, ""}, equalsTestCase{complex64(32769.1), true, false, ""}, equalsTestCase{complex128(32769.1), true, false, ""}, // Non-equal values of numeric type. equalsTestCase{int32(32769), false, false, ""}, equalsTestCase{int32(32770), false, false, ""}, equalsTestCase{uint64(32769), false, false, ""}, equalsTestCase{uint64(32770), false, false, ""}, equalsTestCase{float32(32769.2), false, false, ""}, equalsTestCase{float32(32769.0), false, false, ""}, equalsTestCase{float64(32769.2), false, false, ""}, equalsTestCase{complex128(32769.1 + 2i), false, false, ""}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) LargePositiveFloat32() { const kExpected = 1 << 65 matcher := Equals(float32(kExpected)) ExpectEq("3.689349e+19", matcher.Description()) floatExpected := float32(kExpected) castedInt := uint64(floatExpected) cases := []equalsTestCase{ // Equal values of numeric type. equalsTestCase{kExpected + 0i, true, false, ""}, equalsTestCase{float32(kExpected), true, false, ""}, equalsTestCase{float64(kExpected), true, false, ""}, equalsTestCase{complex64(kExpected), true, false, ""}, equalsTestCase{complex128(kExpected), true, false, ""}, // Non-equal values of numeric type. equalsTestCase{castedInt, false, false, ""}, equalsTestCase{int64(0), false, false, ""}, equalsTestCase{int64(math.MinInt64), false, false, ""}, equalsTestCase{int64(math.MaxInt64), false, false, ""}, equalsTestCase{uint64(0), false, false, ""}, equalsTestCase{uint64(math.MaxUint64), false, false, ""}, equalsTestCase{float32(kExpected / 2), false, false, ""}, equalsTestCase{float64(kExpected / 2), false, false, ""}, equalsTestCase{complex128(kExpected + 2i), false, false, ""}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) Float32AboveExactIntegerRange() { // Single-precision floats don't have enough bits to represent the integers // near this one distinctly, so [2^25-1, 2^25+2] all receive the same value // and should be treated as equivalent when floats are in the mix. const kTwoTo25 = 1 << 25 matcher := Equals(float32(kTwoTo25 + 1)) ExpectEq("3.3554432e+07", matcher.Description()) cases := []equalsTestCase{ // Integers. equalsTestCase{int64(kTwoTo25 - 2), false, false, ""}, equalsTestCase{int64(kTwoTo25 - 1), true, false, ""}, equalsTestCase{int64(kTwoTo25 + 0), true, false, ""}, equalsTestCase{int64(kTwoTo25 + 1), true, false, ""}, equalsTestCase{int64(kTwoTo25 + 2), true, false, ""}, equalsTestCase{int64(kTwoTo25 + 3), false, false, ""}, equalsTestCase{uint64(kTwoTo25 - 2), false, false, ""}, equalsTestCase{uint64(kTwoTo25 - 1), true, false, ""}, equalsTestCase{uint64(kTwoTo25 + 0), true, false, ""}, equalsTestCase{uint64(kTwoTo25 + 1), true, false, ""}, equalsTestCase{uint64(kTwoTo25 + 2), true, false, ""}, equalsTestCase{uint64(kTwoTo25 + 3), false, false, ""}, // Single-precision floating point. equalsTestCase{float32(kTwoTo25 - 2), false, false, ""}, equalsTestCase{float32(kTwoTo25 - 1), true, false, ""}, equalsTestCase{float32(kTwoTo25 + 0), true, false, ""}, equalsTestCase{float32(kTwoTo25 + 1), true, false, ""}, equalsTestCase{float32(kTwoTo25 + 2), true, false, ""}, equalsTestCase{float32(kTwoTo25 + 3), false, false, ""}, equalsTestCase{complex64(kTwoTo25 - 2), false, false, ""}, equalsTestCase{complex64(kTwoTo25 - 1), true, false, ""}, equalsTestCase{complex64(kTwoTo25 + 0), true, false, ""}, equalsTestCase{complex64(kTwoTo25 + 1), true, false, ""}, equalsTestCase{complex64(kTwoTo25 + 2), true, false, ""}, equalsTestCase{complex64(kTwoTo25 + 3), false, false, ""}, // Double-precision floating point. equalsTestCase{float64(kTwoTo25 - 2), false, false, ""}, equalsTestCase{float64(kTwoTo25 - 1), true, false, ""}, equalsTestCase{float64(kTwoTo25 + 0), true, false, ""}, equalsTestCase{float64(kTwoTo25 + 1), true, false, ""}, equalsTestCase{float64(kTwoTo25 + 2), true, false, ""}, equalsTestCase{float64(kTwoTo25 + 3), false, false, ""}, equalsTestCase{complex128(kTwoTo25 - 2), false, false, ""}, equalsTestCase{complex128(kTwoTo25 - 1), true, false, ""}, equalsTestCase{complex128(kTwoTo25 + 0), true, false, ""}, equalsTestCase{complex128(kTwoTo25 + 1), true, false, ""}, equalsTestCase{complex128(kTwoTo25 + 2), true, false, ""}, equalsTestCase{complex128(kTwoTo25 + 3), false, false, ""}, } t.checkTestCases(matcher, cases) } //////////////////////////////////////////////////////////////////////// // float64 //////////////////////////////////////////////////////////////////////// func (t *EqualsTest) NegativeIntegralFloat64() { const kExpected = -(1 << 50) matcher := Equals(float64(kExpected)) ExpectEq("-1.125899906842624e+15", matcher.Description()) cases := []equalsTestCase{ // Various types of the expected value. equalsTestCase{-1125899906842624.0, true, false, ""}, equalsTestCase{-1125899906842624.0 + 0i, true, false, ""}, equalsTestCase{int64(kExpected), true, false, ""}, equalsTestCase{float32(kExpected), true, false, ""}, equalsTestCase{float64(kExpected), true, false, ""}, equalsTestCase{complex64(kExpected), true, false, ""}, equalsTestCase{complex128(kExpected), true, false, ""}, equalsTestCase{interface{}(float64(kExpected)), true, false, ""}, // Values that would be kExpected in two's complement. equalsTestCase{uint64((1 << 64) + kExpected), false, false, ""}, // Non-equal values of numeric type. equalsTestCase{int64(kExpected + 1), false, false, ""}, equalsTestCase{float32(kExpected - (1 << 30)), false, false, ""}, equalsTestCase{float32(kExpected + (1 << 30)), false, false, ""}, equalsTestCase{float64(kExpected - 0.5), false, false, ""}, equalsTestCase{float64(kExpected + 0.5), false, false, ""}, equalsTestCase{complex128(kExpected - 1), false, false, ""}, equalsTestCase{complex128(kExpected + 2i), false, false, ""}, // Non-numeric types. equalsTestCase{uintptr(0), false, true, "which is not numeric"}, equalsTestCase{true, false, true, "which is not numeric"}, equalsTestCase{[...]int{}, false, true, "which is not numeric"}, equalsTestCase{make(chan int), false, true, "which is not numeric"}, equalsTestCase{func() {}, false, true, "which is not numeric"}, equalsTestCase{map[int]int{}, false, true, "which is not numeric"}, equalsTestCase{&someInt, false, true, "which is not numeric"}, equalsTestCase{[]int{}, false, true, "which is not numeric"}, equalsTestCase{"taco", false, true, "which is not numeric"}, equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) NegativeNonIntegralFloat64() { const kTwoTo50 = 1 << 50 const kExpected = -kTwoTo50 - 0.25 matcher := Equals(float64(kExpected)) ExpectEq("-1.1258999068426242e+15", matcher.Description()) cases := []equalsTestCase{ // Various types of the expected value. equalsTestCase{kExpected, true, false, ""}, equalsTestCase{kExpected + 0i, true, false, ""}, equalsTestCase{float32(kExpected), true, false, ""}, equalsTestCase{float64(kExpected), true, false, ""}, equalsTestCase{complex64(kExpected), true, false, ""}, equalsTestCase{complex128(kExpected), true, false, ""}, // Non-equal values of numeric type. equalsTestCase{int64(-kTwoTo50), false, false, ""}, equalsTestCase{int64(-kTwoTo50 - 1), false, false, ""}, equalsTestCase{float32(kExpected - (1 << 30)), false, false, ""}, equalsTestCase{float64(kExpected - 0.25), false, false, ""}, equalsTestCase{float64(kExpected + 0.25), false, false, ""}, equalsTestCase{complex128(kExpected + 2i), false, false, ""}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) LargeNegativeFloat64() { const kExpected = -1 * (1 << 65) matcher := Equals(float64(kExpected)) ExpectEq("-3.6893488147419103e+19", matcher.Description()) floatExpected := float64(kExpected) castedInt := int64(floatExpected) cases := []equalsTestCase{ // Equal values of numeric type. equalsTestCase{kExpected + 0i, true, false, ""}, equalsTestCase{float32(kExpected), true, false, ""}, equalsTestCase{float64(kExpected), true, false, ""}, equalsTestCase{complex64(kExpected), true, false, ""}, equalsTestCase{complex128(kExpected), true, false, ""}, // Non-equal values of numeric type. equalsTestCase{castedInt, false, false, ""}, equalsTestCase{int64(0), false, false, ""}, equalsTestCase{int64(math.MinInt64), false, false, ""}, equalsTestCase{int64(math.MaxInt64), false, false, ""}, equalsTestCase{float32(kExpected / 2), false, false, ""}, equalsTestCase{float64(kExpected / 2), false, false, ""}, equalsTestCase{complex128(kExpected + 2i), false, false, ""}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) ZeroFloat64() { matcher := Equals(float64(0)) ExpectEq("0", matcher.Description()) cases := []equalsTestCase{ // Various types of zero. equalsTestCase{0.0, true, false, ""}, equalsTestCase{0 + 0i, true, false, ""}, equalsTestCase{int(0), true, false, ""}, equalsTestCase{int8(0), true, false, ""}, equalsTestCase{int16(0), true, false, ""}, equalsTestCase{int32(0), true, false, ""}, equalsTestCase{int64(0), true, false, ""}, equalsTestCase{uint(0), true, false, ""}, equalsTestCase{uint8(0), true, false, ""}, equalsTestCase{uint16(0), true, false, ""}, equalsTestCase{uint32(0), true, false, ""}, equalsTestCase{uint64(0), true, false, ""}, equalsTestCase{float32(0), true, false, ""}, equalsTestCase{float64(0), true, false, ""}, equalsTestCase{complex64(0), true, false, ""}, equalsTestCase{complex128(0), true, false, ""}, equalsTestCase{interface{}(float32(0)), true, false, ""}, // Non-equal values of numeric type. equalsTestCase{int64(1), false, false, ""}, equalsTestCase{int64(-1), false, false, ""}, equalsTestCase{float32(1), false, false, ""}, equalsTestCase{float32(-1), false, false, ""}, equalsTestCase{complex128(0 + 2i), false, false, ""}, // Non-numeric types. equalsTestCase{uintptr(0), false, true, "which is not numeric"}, equalsTestCase{true, false, true, "which is not numeric"}, equalsTestCase{[...]int{}, false, true, "which is not numeric"}, equalsTestCase{make(chan int), false, true, "which is not numeric"}, equalsTestCase{func() {}, false, true, "which is not numeric"}, equalsTestCase{map[int]int{}, false, true, "which is not numeric"}, equalsTestCase{&someInt, false, true, "which is not numeric"}, equalsTestCase{[]int{}, false, true, "which is not numeric"}, equalsTestCase{"taco", false, true, "which is not numeric"}, equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) PositiveIntegralFloat64() { const kExpected = 1 << 50 matcher := Equals(float64(kExpected)) ExpectEq("1.125899906842624e+15", matcher.Description()) cases := []equalsTestCase{ // Various types of 32769. equalsTestCase{1125899906842624.0, true, false, ""}, equalsTestCase{1125899906842624.0 + 0i, true, false, ""}, equalsTestCase{int64(kExpected), true, false, ""}, equalsTestCase{uint64(kExpected), true, false, ""}, equalsTestCase{float32(kExpected), true, false, ""}, equalsTestCase{float64(kExpected), true, false, ""}, equalsTestCase{complex64(kExpected), true, false, ""}, equalsTestCase{complex128(kExpected), true, false, ""}, equalsTestCase{interface{}(float64(kExpected)), true, false, ""}, // Non-equal values of numeric type. equalsTestCase{int64(kExpected + 1), false, false, ""}, equalsTestCase{uint64(kExpected + 1), false, false, ""}, equalsTestCase{float32(kExpected - (1 << 30)), false, false, ""}, equalsTestCase{float32(kExpected + (1 << 30)), false, false, ""}, equalsTestCase{float64(kExpected - 0.5), false, false, ""}, equalsTestCase{float64(kExpected + 0.5), false, false, ""}, equalsTestCase{complex128(kExpected - 1), false, false, ""}, equalsTestCase{complex128(kExpected + 2i), false, false, ""}, // Non-numeric types. equalsTestCase{uintptr(0), false, true, "which is not numeric"}, equalsTestCase{true, false, true, "which is not numeric"}, equalsTestCase{[...]int{}, false, true, "which is not numeric"}, equalsTestCase{make(chan int), false, true, "which is not numeric"}, equalsTestCase{func() {}, false, true, "which is not numeric"}, equalsTestCase{map[int]int{}, false, true, "which is not numeric"}, equalsTestCase{&someInt, false, true, "which is not numeric"}, equalsTestCase{[]int{}, false, true, "which is not numeric"}, equalsTestCase{"taco", false, true, "which is not numeric"}, equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) PositiveNonIntegralFloat64() { const kTwoTo50 = 1 << 50 const kExpected = kTwoTo50 + 0.25 matcher := Equals(float64(kExpected)) ExpectEq("1.1258999068426242e+15", matcher.Description()) cases := []equalsTestCase{ // Various types of the expected value. equalsTestCase{kExpected, true, false, ""}, equalsTestCase{kExpected + 0i, true, false, ""}, equalsTestCase{float32(kExpected), true, false, ""}, equalsTestCase{float64(kExpected), true, false, ""}, equalsTestCase{complex64(kExpected), true, false, ""}, equalsTestCase{complex128(kExpected), true, false, ""}, // Non-equal values of numeric type. equalsTestCase{int64(kTwoTo50), false, false, ""}, equalsTestCase{int64(kTwoTo50 - 1), false, false, ""}, equalsTestCase{float64(kExpected - 0.25), false, false, ""}, equalsTestCase{float64(kExpected + 0.25), false, false, ""}, equalsTestCase{complex128(kExpected + 2i), false, false, ""}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) LargePositiveFloat64() { const kExpected = 1 << 65 matcher := Equals(float64(kExpected)) ExpectEq("3.6893488147419103e+19", matcher.Description()) floatExpected := float64(kExpected) castedInt := uint64(floatExpected) cases := []equalsTestCase{ // Equal values of numeric type. equalsTestCase{kExpected + 0i, true, false, ""}, equalsTestCase{float32(kExpected), true, false, ""}, equalsTestCase{float64(kExpected), true, false, ""}, equalsTestCase{complex64(kExpected), true, false, ""}, equalsTestCase{complex128(kExpected), true, false, ""}, // Non-equal values of numeric type. equalsTestCase{castedInt, false, false, ""}, equalsTestCase{int64(0), false, false, ""}, equalsTestCase{int64(math.MinInt64), false, false, ""}, equalsTestCase{int64(math.MaxInt64), false, false, ""}, equalsTestCase{uint64(0), false, false, ""}, equalsTestCase{uint64(math.MaxUint64), false, false, ""}, equalsTestCase{float32(kExpected / 2), false, false, ""}, equalsTestCase{float64(kExpected / 2), false, false, ""}, equalsTestCase{complex128(kExpected + 2i), false, false, ""}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) Float64AboveExactIntegerRange() { // Double-precision floats don't have enough bits to represent the integers // near this one distinctly, so [2^54-1, 2^54+2] all receive the same value // and should be treated as equivalent when floats are in the mix. const kTwoTo54 = 1 << 54 matcher := Equals(float64(kTwoTo54 + 1)) ExpectEq("1.8014398509481984e+16", matcher.Description()) cases := []equalsTestCase{ // Integers. equalsTestCase{int64(kTwoTo54 - 2), false, false, ""}, equalsTestCase{int64(kTwoTo54 - 1), true, false, ""}, equalsTestCase{int64(kTwoTo54 + 0), true, false, ""}, equalsTestCase{int64(kTwoTo54 + 1), true, false, ""}, equalsTestCase{int64(kTwoTo54 + 2), true, false, ""}, equalsTestCase{int64(kTwoTo54 + 3), false, false, ""}, equalsTestCase{uint64(kTwoTo54 - 2), false, false, ""}, equalsTestCase{uint64(kTwoTo54 - 1), true, false, ""}, equalsTestCase{uint64(kTwoTo54 + 0), true, false, ""}, equalsTestCase{uint64(kTwoTo54 + 1), true, false, ""}, equalsTestCase{uint64(kTwoTo54 + 2), true, false, ""}, equalsTestCase{uint64(kTwoTo54 + 3), false, false, ""}, // Double-precision floating point. equalsTestCase{float64(kTwoTo54 - 2), false, false, ""}, equalsTestCase{float64(kTwoTo54 - 1), true, false, ""}, equalsTestCase{float64(kTwoTo54 + 0), true, false, ""}, equalsTestCase{float64(kTwoTo54 + 1), true, false, ""}, equalsTestCase{float64(kTwoTo54 + 2), true, false, ""}, equalsTestCase{float64(kTwoTo54 + 3), false, false, ""}, equalsTestCase{complex128(kTwoTo54 - 2), false, false, ""}, equalsTestCase{complex128(kTwoTo54 - 1), true, false, ""}, equalsTestCase{complex128(kTwoTo54 + 0), true, false, ""}, equalsTestCase{complex128(kTwoTo54 + 1), true, false, ""}, equalsTestCase{complex128(kTwoTo54 + 2), true, false, ""}, equalsTestCase{complex128(kTwoTo54 + 3), false, false, ""}, } t.checkTestCases(matcher, cases) } //////////////////////////////////////////////////////////////////////// // complex64 //////////////////////////////////////////////////////////////////////// func (t *EqualsTest) NegativeIntegralComplex64() { const kExpected = -32769 matcher := Equals(complex64(kExpected)) ExpectEq("(-32769+0i)", matcher.Description()) cases := []equalsTestCase{ // Various types of the expected value. equalsTestCase{-32769.0, true, false, ""}, equalsTestCase{-32769.0 + 0i, true, false, ""}, equalsTestCase{int(kExpected), true, false, ""}, equalsTestCase{int32(kExpected), true, false, ""}, equalsTestCase{int64(kExpected), true, false, ""}, equalsTestCase{float32(kExpected), true, false, ""}, equalsTestCase{float64(kExpected), true, false, ""}, equalsTestCase{complex64(kExpected), true, false, ""}, equalsTestCase{complex128(kExpected), true, false, ""}, equalsTestCase{interface{}(float64(kExpected)), true, false, ""}, // Values that would be kExpected in two's complement. equalsTestCase{uint32((1 << 32) + kExpected), false, false, ""}, equalsTestCase{uint64((1 << 64) + kExpected), false, false, ""}, // Non-equal values of numeric type. equalsTestCase{int64(kExpected + 1), false, false, ""}, equalsTestCase{float32(kExpected - (1 << 30)), false, false, ""}, equalsTestCase{float32(kExpected + (1 << 30)), false, false, ""}, equalsTestCase{float64(kExpected - 0.5), false, false, ""}, equalsTestCase{float64(kExpected + 0.5), false, false, ""}, equalsTestCase{complex64(kExpected - 1), false, false, ""}, equalsTestCase{complex64(kExpected + 2i), false, false, ""}, equalsTestCase{complex128(kExpected - 1), false, false, ""}, equalsTestCase{complex128(kExpected + 2i), false, false, ""}, // Non-numeric types. equalsTestCase{uintptr(0), false, true, "which is not numeric"}, equalsTestCase{true, false, true, "which is not numeric"}, equalsTestCase{[...]int{}, false, true, "which is not numeric"}, equalsTestCase{make(chan int), false, true, "which is not numeric"}, equalsTestCase{func() {}, false, true, "which is not numeric"}, equalsTestCase{map[int]int{}, false, true, "which is not numeric"}, equalsTestCase{&someInt, false, true, "which is not numeric"}, equalsTestCase{[]int{}, false, true, "which is not numeric"}, equalsTestCase{"taco", false, true, "which is not numeric"}, equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) NegativeNonIntegralComplex64() { const kTwoTo20 = 1 << 20 const kExpected = -kTwoTo20 - 0.25 matcher := Equals(complex64(kExpected)) ExpectEq("(-1.0485762e+06+0i)", matcher.Description()) cases := []equalsTestCase{ // Various types of the expected value. equalsTestCase{kExpected, true, false, ""}, equalsTestCase{kExpected + 0i, true, false, ""}, equalsTestCase{float32(kExpected), true, false, ""}, equalsTestCase{float64(kExpected), true, false, ""}, equalsTestCase{complex64(kExpected), true, false, ""}, equalsTestCase{complex128(kExpected), true, false, ""}, // Non-equal values of numeric type. equalsTestCase{int(-kTwoTo20), false, false, ""}, equalsTestCase{int(-kTwoTo20 - 1), false, false, ""}, equalsTestCase{int32(-kTwoTo20), false, false, ""}, equalsTestCase{int32(-kTwoTo20 - 1), false, false, ""}, equalsTestCase{int64(-kTwoTo20), false, false, ""}, equalsTestCase{int64(-kTwoTo20 - 1), false, false, ""}, equalsTestCase{float32(kExpected - (1 << 30)), false, false, ""}, equalsTestCase{float64(kExpected - 0.25), false, false, ""}, equalsTestCase{float64(kExpected + 0.25), false, false, ""}, equalsTestCase{complex64(kExpected - 0.75), false, false, ""}, equalsTestCase{complex64(kExpected + 2i), false, false, ""}, equalsTestCase{complex128(kExpected - 0.75), false, false, ""}, equalsTestCase{complex128(kExpected + 2i), false, false, ""}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) LargeNegativeComplex64() { const kExpected = -1 * (1 << 65) matcher := Equals(complex64(kExpected)) ExpectEq("(-3.689349e+19+0i)", matcher.Description()) floatExpected := float64(kExpected) castedInt := int64(floatExpected) cases := []equalsTestCase{ // Equal values of numeric type. equalsTestCase{kExpected + 0i, true, false, ""}, equalsTestCase{float32(kExpected), true, false, ""}, equalsTestCase{float64(kExpected), true, false, ""}, equalsTestCase{complex64(kExpected), true, false, ""}, equalsTestCase{complex128(kExpected), true, false, ""}, // Non-equal values of numeric type. equalsTestCase{castedInt, false, false, ""}, equalsTestCase{int64(0), false, false, ""}, equalsTestCase{int64(math.MinInt64), false, false, ""}, equalsTestCase{int64(math.MaxInt64), false, false, ""}, equalsTestCase{float32(kExpected / 2), false, false, ""}, equalsTestCase{float64(kExpected / 2), false, false, ""}, equalsTestCase{complex64(kExpected + 2i), false, false, ""}, equalsTestCase{complex128(kExpected + 2i), false, false, ""}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) ZeroComplex64() { matcher := Equals(complex64(0)) ExpectEq("(0+0i)", matcher.Description()) cases := []equalsTestCase{ // Various types of zero. equalsTestCase{0.0, true, false, ""}, equalsTestCase{0 + 0i, true, false, ""}, equalsTestCase{int(0), true, false, ""}, equalsTestCase{int8(0), true, false, ""}, equalsTestCase{int16(0), true, false, ""}, equalsTestCase{int32(0), true, false, ""}, equalsTestCase{int64(0), true, false, ""}, equalsTestCase{uint(0), true, false, ""}, equalsTestCase{uint8(0), true, false, ""}, equalsTestCase{uint16(0), true, false, ""}, equalsTestCase{uint32(0), true, false, ""}, equalsTestCase{uint64(0), true, false, ""}, equalsTestCase{float32(0), true, false, ""}, equalsTestCase{float64(0), true, false, ""}, equalsTestCase{complex64(0), true, false, ""}, equalsTestCase{complex128(0), true, false, ""}, equalsTestCase{interface{}(float32(0)), true, false, ""}, // Non-equal values of numeric type. equalsTestCase{int64(1), false, false, ""}, equalsTestCase{int64(-1), false, false, ""}, equalsTestCase{float32(1), false, false, ""}, equalsTestCase{float32(-1), false, false, ""}, equalsTestCase{float64(1), false, false, ""}, equalsTestCase{float64(-1), false, false, ""}, equalsTestCase{complex64(0 + 2i), false, false, ""}, equalsTestCase{complex128(0 + 2i), false, false, ""}, // Non-numeric types. equalsTestCase{uintptr(0), false, true, "which is not numeric"}, equalsTestCase{true, false, true, "which is not numeric"}, equalsTestCase{[...]int{}, false, true, "which is not numeric"}, equalsTestCase{make(chan int), false, true, "which is not numeric"}, equalsTestCase{func() {}, false, true, "which is not numeric"}, equalsTestCase{map[int]int{}, false, true, "which is not numeric"}, equalsTestCase{&someInt, false, true, "which is not numeric"}, equalsTestCase{[]int{}, false, true, "which is not numeric"}, equalsTestCase{"taco", false, true, "which is not numeric"}, equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) PositiveIntegralComplex64() { const kExpected = 1 << 20 matcher := Equals(complex64(kExpected)) ExpectEq("(1.048576e+06+0i)", matcher.Description()) cases := []equalsTestCase{ // Various types of 32769. equalsTestCase{1048576.0, true, false, ""}, equalsTestCase{1048576.0 + 0i, true, false, ""}, equalsTestCase{int(kExpected), true, false, ""}, equalsTestCase{int32(kExpected), true, false, ""}, equalsTestCase{int64(kExpected), true, false, ""}, equalsTestCase{uint(kExpected), true, false, ""}, equalsTestCase{uint32(kExpected), true, false, ""}, equalsTestCase{uint64(kExpected), true, false, ""}, equalsTestCase{float32(kExpected), true, false, ""}, equalsTestCase{float64(kExpected), true, false, ""}, equalsTestCase{complex64(kExpected), true, false, ""}, equalsTestCase{complex128(kExpected), true, false, ""}, equalsTestCase{interface{}(float64(kExpected)), true, false, ""}, // Non-equal values of numeric type. equalsTestCase{int(kExpected + 1), false, false, ""}, equalsTestCase{int32(kExpected + 1), false, false, ""}, equalsTestCase{int64(kExpected + 1), false, false, ""}, equalsTestCase{uint(kExpected + 1), false, false, ""}, equalsTestCase{uint32(kExpected + 1), false, false, ""}, equalsTestCase{uint64(kExpected + 1), false, false, ""}, equalsTestCase{float32(kExpected - (1 << 30)), false, false, ""}, equalsTestCase{float32(kExpected + (1 << 30)), false, false, ""}, equalsTestCase{float64(kExpected - 0.5), false, false, ""}, equalsTestCase{float64(kExpected + 0.5), false, false, ""}, equalsTestCase{complex128(kExpected - 1), false, false, ""}, equalsTestCase{complex128(kExpected + 2i), false, false, ""}, // Non-numeric types. equalsTestCase{uintptr(0), false, true, "which is not numeric"}, equalsTestCase{true, false, true, "which is not numeric"}, equalsTestCase{[...]int{}, false, true, "which is not numeric"}, equalsTestCase{make(chan int), false, true, "which is not numeric"}, equalsTestCase{func() {}, false, true, "which is not numeric"}, equalsTestCase{map[int]int{}, false, true, "which is not numeric"}, equalsTestCase{&someInt, false, true, "which is not numeric"}, equalsTestCase{[]int{}, false, true, "which is not numeric"}, equalsTestCase{"taco", false, true, "which is not numeric"}, equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) PositiveNonIntegralComplex64() { const kTwoTo20 = 1 << 20 const kExpected = kTwoTo20 + 0.25 matcher := Equals(complex64(kExpected)) ExpectEq("(1.0485762e+06+0i)", matcher.Description()) cases := []equalsTestCase{ // Various types of the expected value. equalsTestCase{kExpected, true, false, ""}, equalsTestCase{kExpected + 0i, true, false, ""}, equalsTestCase{float32(kExpected), true, false, ""}, equalsTestCase{float64(kExpected), true, false, ""}, equalsTestCase{complex64(kExpected), true, false, ""}, equalsTestCase{complex128(kExpected), true, false, ""}, // Non-equal values of numeric type. equalsTestCase{int64(kTwoTo20), false, false, ""}, equalsTestCase{int64(kTwoTo20 - 1), false, false, ""}, equalsTestCase{uint64(kTwoTo20), false, false, ""}, equalsTestCase{uint64(kTwoTo20 - 1), false, false, ""}, equalsTestCase{float32(kExpected - 1), false, false, ""}, equalsTestCase{float32(kExpected + 1), false, false, ""}, equalsTestCase{float64(kExpected - 0.25), false, false, ""}, equalsTestCase{float64(kExpected + 0.25), false, false, ""}, equalsTestCase{complex64(kExpected - 1), false, false, ""}, equalsTestCase{complex64(kExpected - 1i), false, false, ""}, equalsTestCase{complex128(kExpected - 1), false, false, ""}, equalsTestCase{complex128(kExpected - 1i), false, false, ""}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) LargePositiveComplex64() { const kExpected = 1 << 65 matcher := Equals(complex64(kExpected)) ExpectEq("(3.689349e+19+0i)", matcher.Description()) floatExpected := float64(kExpected) castedInt := uint64(floatExpected) cases := []equalsTestCase{ // Equal values of numeric type. equalsTestCase{kExpected + 0i, true, false, ""}, equalsTestCase{float32(kExpected), true, false, ""}, equalsTestCase{float64(kExpected), true, false, ""}, equalsTestCase{complex64(kExpected), true, false, ""}, equalsTestCase{complex128(kExpected), true, false, ""}, // Non-equal values of numeric type. equalsTestCase{castedInt, false, false, ""}, equalsTestCase{int64(0), false, false, ""}, equalsTestCase{int64(math.MinInt64), false, false, ""}, equalsTestCase{int64(math.MaxInt64), false, false, ""}, equalsTestCase{uint64(0), false, false, ""}, equalsTestCase{uint64(math.MaxUint64), false, false, ""}, equalsTestCase{float32(kExpected / 2), false, false, ""}, equalsTestCase{float64(kExpected / 2), false, false, ""}, equalsTestCase{complex128(kExpected + 2i), false, false, ""}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) Complex64AboveExactIntegerRange() { // Single-precision floats don't have enough bits to represent the integers // near this one distinctly, so [2^25-1, 2^25+2] all receive the same value // and should be treated as equivalent when floats are in the mix. const kTwoTo25 = 1 << 25 matcher := Equals(complex64(kTwoTo25 + 1)) ExpectEq("(3.3554432e+07+0i)", matcher.Description()) cases := []equalsTestCase{ // Integers. equalsTestCase{int64(kTwoTo25 - 2), false, false, ""}, equalsTestCase{int64(kTwoTo25 - 1), true, false, ""}, equalsTestCase{int64(kTwoTo25 + 0), true, false, ""}, equalsTestCase{int64(kTwoTo25 + 1), true, false, ""}, equalsTestCase{int64(kTwoTo25 + 2), true, false, ""}, equalsTestCase{int64(kTwoTo25 + 3), false, false, ""}, equalsTestCase{uint64(kTwoTo25 - 2), false, false, ""}, equalsTestCase{uint64(kTwoTo25 - 1), true, false, ""}, equalsTestCase{uint64(kTwoTo25 + 0), true, false, ""}, equalsTestCase{uint64(kTwoTo25 + 1), true, false, ""}, equalsTestCase{uint64(kTwoTo25 + 2), true, false, ""}, equalsTestCase{uint64(kTwoTo25 + 3), false, false, ""}, // Single-precision floating point. equalsTestCase{float32(kTwoTo25 - 2), false, false, ""}, equalsTestCase{float32(kTwoTo25 - 1), true, false, ""}, equalsTestCase{float32(kTwoTo25 + 0), true, false, ""}, equalsTestCase{float32(kTwoTo25 + 1), true, false, ""}, equalsTestCase{float32(kTwoTo25 + 2), true, false, ""}, equalsTestCase{float32(kTwoTo25 + 3), false, false, ""}, equalsTestCase{complex64(kTwoTo25 - 2), false, false, ""}, equalsTestCase{complex64(kTwoTo25 - 1), true, false, ""}, equalsTestCase{complex64(kTwoTo25 + 0), true, false, ""}, equalsTestCase{complex64(kTwoTo25 + 1), true, false, ""}, equalsTestCase{complex64(kTwoTo25 + 2), true, false, ""}, equalsTestCase{complex64(kTwoTo25 + 3), false, false, ""}, // Double-precision floating point. equalsTestCase{float64(kTwoTo25 - 2), false, false, ""}, equalsTestCase{float64(kTwoTo25 - 1), true, false, ""}, equalsTestCase{float64(kTwoTo25 + 0), true, false, ""}, equalsTestCase{float64(kTwoTo25 + 1), true, false, ""}, equalsTestCase{float64(kTwoTo25 + 2), true, false, ""}, equalsTestCase{float64(kTwoTo25 + 3), false, false, ""}, equalsTestCase{complex128(kTwoTo25 - 2), false, false, ""}, equalsTestCase{complex128(kTwoTo25 - 1), true, false, ""}, equalsTestCase{complex128(kTwoTo25 + 0), true, false, ""}, equalsTestCase{complex128(kTwoTo25 + 1), true, false, ""}, equalsTestCase{complex128(kTwoTo25 + 2), true, false, ""}, equalsTestCase{complex128(kTwoTo25 + 3), false, false, ""}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) Complex64WithNonZeroImaginaryPart() { const kRealPart = 17 const kImagPart = 0.25i const kExpected = kRealPart + kImagPart matcher := Equals(complex64(kExpected)) ExpectEq("(17+0.25i)", matcher.Description()) cases := []equalsTestCase{ // Various types of the expected value. equalsTestCase{kExpected, true, false, ""}, equalsTestCase{kRealPart + kImagPart, true, false, ""}, equalsTestCase{complex64(kExpected), true, false, ""}, equalsTestCase{complex128(kExpected), true, false, ""}, // Non-equal values of numeric type. equalsTestCase{int(kRealPart), false, false, ""}, equalsTestCase{int8(kRealPart), false, false, ""}, equalsTestCase{int16(kRealPart), false, false, ""}, equalsTestCase{int32(kRealPart), false, false, ""}, equalsTestCase{int64(kRealPart), false, false, ""}, equalsTestCase{uint(kRealPart), false, false, ""}, equalsTestCase{uint8(kRealPart), false, false, ""}, equalsTestCase{uint16(kRealPart), false, false, ""}, equalsTestCase{uint32(kRealPart), false, false, ""}, equalsTestCase{uint64(kRealPart), false, false, ""}, equalsTestCase{float32(kRealPart), false, false, ""}, equalsTestCase{float64(kRealPart), false, false, ""}, equalsTestCase{complex64(kRealPart), false, false, ""}, equalsTestCase{complex64(kRealPart + kImagPart + 0.5), false, false, ""}, equalsTestCase{complex64(kRealPart + kImagPart + 0.5i), false, false, ""}, equalsTestCase{complex128(kRealPart), false, false, ""}, equalsTestCase{complex128(kRealPart + kImagPart + 0.5), false, false, ""}, equalsTestCase{complex128(kRealPart + kImagPart + 0.5i), false, false, ""}, } t.checkTestCases(matcher, cases) } //////////////////////////////////////////////////////////////////////// // complex128 //////////////////////////////////////////////////////////////////////// func (t *EqualsTest) NegativeIntegralComplex128() { const kExpected = -32769 matcher := Equals(complex128(kExpected)) ExpectEq("(-32769+0i)", matcher.Description()) cases := []equalsTestCase{ // Various types of the expected value. equalsTestCase{-32769.0, true, false, ""}, equalsTestCase{-32769.0 + 0i, true, false, ""}, equalsTestCase{int(kExpected), true, false, ""}, equalsTestCase{int32(kExpected), true, false, ""}, equalsTestCase{int64(kExpected), true, false, ""}, equalsTestCase{float32(kExpected), true, false, ""}, equalsTestCase{float64(kExpected), true, false, ""}, equalsTestCase{complex64(kExpected), true, false, ""}, equalsTestCase{complex128(kExpected), true, false, ""}, equalsTestCase{interface{}(float64(kExpected)), true, false, ""}, // Values that would be kExpected in two's complement. equalsTestCase{uint32((1 << 32) + kExpected), false, false, ""}, equalsTestCase{uint64((1 << 64) + kExpected), false, false, ""}, // Non-equal values of numeric type. equalsTestCase{int64(kExpected + 1), false, false, ""}, equalsTestCase{float32(kExpected - (1 << 30)), false, false, ""}, equalsTestCase{float32(kExpected + (1 << 30)), false, false, ""}, equalsTestCase{float64(kExpected - 0.5), false, false, ""}, equalsTestCase{float64(kExpected + 0.5), false, false, ""}, equalsTestCase{complex64(kExpected - 1), false, false, ""}, equalsTestCase{complex64(kExpected + 2i), false, false, ""}, equalsTestCase{complex128(kExpected - 1), false, false, ""}, equalsTestCase{complex128(kExpected + 2i), false, false, ""}, // Non-numeric types. equalsTestCase{uintptr(0), false, true, "which is not numeric"}, equalsTestCase{true, false, true, "which is not numeric"}, equalsTestCase{[...]int{}, false, true, "which is not numeric"}, equalsTestCase{make(chan int), false, true, "which is not numeric"}, equalsTestCase{func() {}, false, true, "which is not numeric"}, equalsTestCase{map[int]int{}, false, true, "which is not numeric"}, equalsTestCase{&someInt, false, true, "which is not numeric"}, equalsTestCase{[]int{}, false, true, "which is not numeric"}, equalsTestCase{"taco", false, true, "which is not numeric"}, equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) NegativeNonIntegralComplex128() { const kTwoTo20 = 1 << 20 const kExpected = -kTwoTo20 - 0.25 matcher := Equals(complex128(kExpected)) ExpectEq("(-1.04857625e+06+0i)", matcher.Description()) cases := []equalsTestCase{ // Various types of the expected value. equalsTestCase{kExpected, true, false, ""}, equalsTestCase{kExpected + 0i, true, false, ""}, equalsTestCase{float32(kExpected), true, false, ""}, equalsTestCase{float64(kExpected), true, false, ""}, equalsTestCase{complex64(kExpected), true, false, ""}, equalsTestCase{complex128(kExpected), true, false, ""}, // Non-equal values of numeric type. equalsTestCase{int(-kTwoTo20), false, false, ""}, equalsTestCase{int(-kTwoTo20 - 1), false, false, ""}, equalsTestCase{int32(-kTwoTo20), false, false, ""}, equalsTestCase{int32(-kTwoTo20 - 1), false, false, ""}, equalsTestCase{int64(-kTwoTo20), false, false, ""}, equalsTestCase{int64(-kTwoTo20 - 1), false, false, ""}, equalsTestCase{float32(kExpected - (1 << 30)), false, false, ""}, equalsTestCase{float64(kExpected - 0.25), false, false, ""}, equalsTestCase{float64(kExpected + 0.25), false, false, ""}, equalsTestCase{complex64(kExpected - 0.75), false, false, ""}, equalsTestCase{complex64(kExpected + 2i), false, false, ""}, equalsTestCase{complex128(kExpected - 0.75), false, false, ""}, equalsTestCase{complex128(kExpected + 2i), false, false, ""}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) LargeNegativeComplex128() { const kExpected = -1 * (1 << 65) matcher := Equals(complex128(kExpected)) ExpectEq("(-3.6893488147419103e+19+0i)", matcher.Description()) floatExpected := float64(kExpected) castedInt := int64(floatExpected) cases := []equalsTestCase{ // Equal values of numeric type. equalsTestCase{kExpected + 0i, true, false, ""}, equalsTestCase{float32(kExpected), true, false, ""}, equalsTestCase{float64(kExpected), true, false, ""}, equalsTestCase{complex64(kExpected), true, false, ""}, equalsTestCase{complex128(kExpected), true, false, ""}, // Non-equal values of numeric type. equalsTestCase{castedInt, false, false, ""}, equalsTestCase{int64(0), false, false, ""}, equalsTestCase{int64(math.MinInt64), false, false, ""}, equalsTestCase{int64(math.MaxInt64), false, false, ""}, equalsTestCase{float32(kExpected / 2), false, false, ""}, equalsTestCase{float64(kExpected / 2), false, false, ""}, equalsTestCase{complex64(kExpected + 2i), false, false, ""}, equalsTestCase{complex128(kExpected + 2i), false, false, ""}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) ZeroComplex128() { matcher := Equals(complex128(0)) ExpectEq("(0+0i)", matcher.Description()) cases := []equalsTestCase{ // Various types of zero. equalsTestCase{0.0, true, false, ""}, equalsTestCase{0 + 0i, true, false, ""}, equalsTestCase{int(0), true, false, ""}, equalsTestCase{int8(0), true, false, ""}, equalsTestCase{int16(0), true, false, ""}, equalsTestCase{int32(0), true, false, ""}, equalsTestCase{int64(0), true, false, ""}, equalsTestCase{uint(0), true, false, ""}, equalsTestCase{uint8(0), true, false, ""}, equalsTestCase{uint16(0), true, false, ""}, equalsTestCase{uint32(0), true, false, ""}, equalsTestCase{uint64(0), true, false, ""}, equalsTestCase{float32(0), true, false, ""}, equalsTestCase{float64(0), true, false, ""}, equalsTestCase{complex64(0), true, false, ""}, equalsTestCase{complex128(0), true, false, ""}, equalsTestCase{interface{}(float32(0)), true, false, ""}, // Non-equal values of numeric type. equalsTestCase{int64(1), false, false, ""}, equalsTestCase{int64(-1), false, false, ""}, equalsTestCase{float32(1), false, false, ""}, equalsTestCase{float32(-1), false, false, ""}, equalsTestCase{float64(1), false, false, ""}, equalsTestCase{float64(-1), false, false, ""}, equalsTestCase{complex64(0 + 2i), false, false, ""}, equalsTestCase{complex128(0 + 2i), false, false, ""}, // Non-numeric types. equalsTestCase{uintptr(0), false, true, "which is not numeric"}, equalsTestCase{true, false, true, "which is not numeric"}, equalsTestCase{[...]int{}, false, true, "which is not numeric"}, equalsTestCase{make(chan int), false, true, "which is not numeric"}, equalsTestCase{func() {}, false, true, "which is not numeric"}, equalsTestCase{map[int]int{}, false, true, "which is not numeric"}, equalsTestCase{&someInt, false, true, "which is not numeric"}, equalsTestCase{[]int{}, false, true, "which is not numeric"}, equalsTestCase{"taco", false, true, "which is not numeric"}, equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) PositiveIntegralComplex128() { const kExpected = 1 << 20 matcher := Equals(complex128(kExpected)) ExpectEq("(1.048576e+06+0i)", matcher.Description()) cases := []equalsTestCase{ // Various types of 32769. equalsTestCase{1048576.0, true, false, ""}, equalsTestCase{1048576.0 + 0i, true, false, ""}, equalsTestCase{int(kExpected), true, false, ""}, equalsTestCase{int32(kExpected), true, false, ""}, equalsTestCase{int64(kExpected), true, false, ""}, equalsTestCase{uint(kExpected), true, false, ""}, equalsTestCase{uint32(kExpected), true, false, ""}, equalsTestCase{uint64(kExpected), true, false, ""}, equalsTestCase{float32(kExpected), true, false, ""}, equalsTestCase{float64(kExpected), true, false, ""}, equalsTestCase{complex64(kExpected), true, false, ""}, equalsTestCase{complex128(kExpected), true, false, ""}, equalsTestCase{interface{}(float64(kExpected)), true, false, ""}, // Non-equal values of numeric type. equalsTestCase{int(kExpected + 1), false, false, ""}, equalsTestCase{int32(kExpected + 1), false, false, ""}, equalsTestCase{int64(kExpected + 1), false, false, ""}, equalsTestCase{uint(kExpected + 1), false, false, ""}, equalsTestCase{uint32(kExpected + 1), false, false, ""}, equalsTestCase{uint64(kExpected + 1), false, false, ""}, equalsTestCase{float32(kExpected - (1 << 30)), false, false, ""}, equalsTestCase{float32(kExpected + (1 << 30)), false, false, ""}, equalsTestCase{float64(kExpected - 0.5), false, false, ""}, equalsTestCase{float64(kExpected + 0.5), false, false, ""}, equalsTestCase{complex128(kExpected - 1), false, false, ""}, equalsTestCase{complex128(kExpected + 2i), false, false, ""}, // Non-numeric types. equalsTestCase{uintptr(0), false, true, "which is not numeric"}, equalsTestCase{true, false, true, "which is not numeric"}, equalsTestCase{[...]int{}, false, true, "which is not numeric"}, equalsTestCase{make(chan int), false, true, "which is not numeric"}, equalsTestCase{func() {}, false, true, "which is not numeric"}, equalsTestCase{map[int]int{}, false, true, "which is not numeric"}, equalsTestCase{&someInt, false, true, "which is not numeric"}, equalsTestCase{[]int{}, false, true, "which is not numeric"}, equalsTestCase{"taco", false, true, "which is not numeric"}, equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) PositiveNonIntegralComplex128() { const kTwoTo20 = 1 << 20 const kExpected = kTwoTo20 + 0.25 matcher := Equals(complex128(kExpected)) ExpectEq("(1.04857625e+06+0i)", matcher.Description()) cases := []equalsTestCase{ // Various types of the expected value. equalsTestCase{kExpected, true, false, ""}, equalsTestCase{kExpected + 0i, true, false, ""}, equalsTestCase{float32(kExpected), true, false, ""}, equalsTestCase{float64(kExpected), true, false, ""}, equalsTestCase{complex64(kExpected), true, false, ""}, equalsTestCase{complex128(kExpected), true, false, ""}, // Non-equal values of numeric type. equalsTestCase{int64(kTwoTo20), false, false, ""}, equalsTestCase{int64(kTwoTo20 - 1), false, false, ""}, equalsTestCase{uint64(kTwoTo20), false, false, ""}, equalsTestCase{uint64(kTwoTo20 - 1), false, false, ""}, equalsTestCase{float32(kExpected - 1), false, false, ""}, equalsTestCase{float32(kExpected + 1), false, false, ""}, equalsTestCase{float64(kExpected - 0.25), false, false, ""}, equalsTestCase{float64(kExpected + 0.25), false, false, ""}, equalsTestCase{complex64(kExpected - 1), false, false, ""}, equalsTestCase{complex64(kExpected - 1i), false, false, ""}, equalsTestCase{complex128(kExpected - 1), false, false, ""}, equalsTestCase{complex128(kExpected - 1i), false, false, ""}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) LargePositiveComplex128() { const kExpected = 1 << 65 matcher := Equals(complex128(kExpected)) ExpectEq("(3.6893488147419103e+19+0i)", matcher.Description()) floatExpected := float64(kExpected) castedInt := uint64(floatExpected) cases := []equalsTestCase{ // Equal values of numeric type. equalsTestCase{kExpected + 0i, true, false, ""}, equalsTestCase{float32(kExpected), true, false, ""}, equalsTestCase{float64(kExpected), true, false, ""}, equalsTestCase{complex64(kExpected), true, false, ""}, equalsTestCase{complex128(kExpected), true, false, ""}, // Non-equal values of numeric type. equalsTestCase{castedInt, false, false, ""}, equalsTestCase{int64(0), false, false, ""}, equalsTestCase{int64(math.MinInt64), false, false, ""}, equalsTestCase{int64(math.MaxInt64), false, false, ""}, equalsTestCase{uint64(0), false, false, ""}, equalsTestCase{uint64(math.MaxUint64), false, false, ""}, equalsTestCase{float32(kExpected / 2), false, false, ""}, equalsTestCase{float64(kExpected / 2), false, false, ""}, equalsTestCase{complex128(kExpected + 2i), false, false, ""}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) Complex128AboveExactIntegerRange() { // Double-precision floats don't have enough bits to represent the integers // near this one distinctly, so [2^54-1, 2^54+2] all receive the same value // and should be treated as equivalent when floats are in the mix. const kTwoTo54 = 1 << 54 matcher := Equals(complex128(kTwoTo54 + 1)) ExpectEq("(1.8014398509481984e+16+0i)", matcher.Description()) cases := []equalsTestCase{ // Integers. equalsTestCase{int64(kTwoTo54 - 2), false, false, ""}, equalsTestCase{int64(kTwoTo54 - 1), true, false, ""}, equalsTestCase{int64(kTwoTo54 + 0), true, false, ""}, equalsTestCase{int64(kTwoTo54 + 1), true, false, ""}, equalsTestCase{int64(kTwoTo54 + 2), true, false, ""}, equalsTestCase{int64(kTwoTo54 + 3), false, false, ""}, equalsTestCase{uint64(kTwoTo54 - 2), false, false, ""}, equalsTestCase{uint64(kTwoTo54 - 1), true, false, ""}, equalsTestCase{uint64(kTwoTo54 + 0), true, false, ""}, equalsTestCase{uint64(kTwoTo54 + 1), true, false, ""}, equalsTestCase{uint64(kTwoTo54 + 2), true, false, ""}, equalsTestCase{uint64(kTwoTo54 + 3), false, false, ""}, // Double-precision floating point. equalsTestCase{float64(kTwoTo54 - 2), false, false, ""}, equalsTestCase{float64(kTwoTo54 - 1), true, false, ""}, equalsTestCase{float64(kTwoTo54 + 0), true, false, ""}, equalsTestCase{float64(kTwoTo54 + 1), true, false, ""}, equalsTestCase{float64(kTwoTo54 + 2), true, false, ""}, equalsTestCase{float64(kTwoTo54 + 3), false, false, ""}, equalsTestCase{complex128(kTwoTo54 - 2), false, false, ""}, equalsTestCase{complex128(kTwoTo54 - 1), true, false, ""}, equalsTestCase{complex128(kTwoTo54 + 0), true, false, ""}, equalsTestCase{complex128(kTwoTo54 + 1), true, false, ""}, equalsTestCase{complex128(kTwoTo54 + 2), true, false, ""}, equalsTestCase{complex128(kTwoTo54 + 3), false, false, ""}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) Complex128WithNonZeroImaginaryPart() { const kRealPart = 17 const kImagPart = 0.25i const kExpected = kRealPart + kImagPart matcher := Equals(complex128(kExpected)) ExpectEq("(17+0.25i)", matcher.Description()) cases := []equalsTestCase{ // Various types of the expected value. equalsTestCase{kExpected, true, false, ""}, equalsTestCase{kRealPart + kImagPart, true, false, ""}, equalsTestCase{complex64(kExpected), true, false, ""}, equalsTestCase{complex128(kExpected), true, false, ""}, // Non-equal values of numeric type. equalsTestCase{int(kRealPart), false, false, ""}, equalsTestCase{int8(kRealPart), false, false, ""}, equalsTestCase{int16(kRealPart), false, false, ""}, equalsTestCase{int32(kRealPart), false, false, ""}, equalsTestCase{int64(kRealPart), false, false, ""}, equalsTestCase{uint(kRealPart), false, false, ""}, equalsTestCase{uint8(kRealPart), false, false, ""}, equalsTestCase{uint16(kRealPart), false, false, ""}, equalsTestCase{uint32(kRealPart), false, false, ""}, equalsTestCase{uint64(kRealPart), false, false, ""}, equalsTestCase{float32(kRealPart), false, false, ""}, equalsTestCase{float64(kRealPart), false, false, ""}, equalsTestCase{complex64(kRealPart), false, false, ""}, equalsTestCase{complex64(kRealPart + kImagPart + 0.5), false, false, ""}, equalsTestCase{complex64(kRealPart + kImagPart + 0.5i), false, false, ""}, equalsTestCase{complex128(kRealPart), false, false, ""}, equalsTestCase{complex128(kRealPart + kImagPart + 0.5), false, false, ""}, equalsTestCase{complex128(kRealPart + kImagPart + 0.5i), false, false, ""}, } t.checkTestCases(matcher, cases) } //////////////////////////////////////////////////////////////////////// // Arrays //////////////////////////////////////////////////////////////////////// func (t *EqualsTest) ArrayOfComparableType() { expected := [3]uint{17, 19, 23} matcher := Equals(expected) ExpectEq("[17 19 23]", matcher.Description()) // To defeat constant de-duping by the compiler. makeArray := func(i, j, k uint) [3]uint { return [3]uint{ i, j, k} } type arrayAlias [3]uint type uintAlias uint cases := []equalsTestCase{ // Correct types, equal. equalsTestCase{expected, true, false, ""}, equalsTestCase{[3]uint{17, 19, 23}, true, false, ""}, equalsTestCase{makeArray(17, 19, 23), true, false, ""}, // Correct types, not equal. equalsTestCase{[3]uint{0, 0, 0}, false, false, ""}, equalsTestCase{[3]uint{18, 19, 23}, false, false, ""}, equalsTestCase{[3]uint{17, 20, 23}, false, false, ""}, equalsTestCase{[3]uint{17, 19, 22}, false, false, ""}, // Other types. equalsTestCase{0, false, true, "which is not [3]uint"}, equalsTestCase{bool(false), false, true, "which is not [3]uint"}, equalsTestCase{int(0), false, true, "which is not [3]uint"}, equalsTestCase{int8(0), false, true, "which is not [3]uint"}, equalsTestCase{int16(0), false, true, "which is not [3]uint"}, equalsTestCase{int32(0), false, true, "which is not [3]uint"}, equalsTestCase{int64(0), false, true, "which is not [3]uint"}, equalsTestCase{uint(0), false, true, "which is not [3]uint"}, equalsTestCase{uint8(0), false, true, "which is not [3]uint"}, equalsTestCase{uint16(0), false, true, "which is not [3]uint"}, equalsTestCase{uint32(0), false, true, "which is not [3]uint"}, equalsTestCase{uint64(0), false, true, "which is not [3]uint"}, equalsTestCase{true, false, true, "which is not [3]uint"}, equalsTestCase{[...]int{}, false, true, "which is not [3]uint"}, equalsTestCase{func() {}, false, true, "which is not [3]uint"}, equalsTestCase{map[int]int{}, false, true, "which is not [3]uint"}, equalsTestCase{equalsTestCase{}, false, true, "which is not [3]uint"}, equalsTestCase{[2]uint{17, 19}, false, true, "which is not [3]uint"}, equalsTestCase{[4]uint{17, 19, 23, 0}, false, true, "which is not [3]uint"}, equalsTestCase{arrayAlias{17, 19, 23}, false, true, "which is not [3]uint"}, equalsTestCase{[3]uintAlias{17, 19, 23}, false, true, "which is not [3]uint"}, equalsTestCase{[3]int32{17, 19, 23}, false, true, "which is not [3]uint"}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) ArrayOfNonComparableType() { type nonComparableArray [2]map[string]string f := func() { ExpectEq(nonComparableArray{}, nonComparableArray{}) } ExpectThat(f, Panics(MatchesRegexp("uncomparable.*nonComparableArray"))) } //////////////////////////////////////////////////////////////////////// // chan //////////////////////////////////////////////////////////////////////// func (t *EqualsTest) NilChan() { var nilChan1 chan int var nilChan2 chan int var nilChan3 chan uint var nonNilChan1 chan int = make(chan int) var nonNilChan2 chan uint = make(chan uint) matcher := Equals(nilChan1) ExpectEq("", matcher.Description()) cases := []equalsTestCase{ // int channels equalsTestCase{nilChan1, true, false, ""}, equalsTestCase{nilChan2, true, false, ""}, equalsTestCase{nonNilChan1, false, false, ""}, // uint channels equalsTestCase{nilChan3, false, true, "which is not a chan int"}, equalsTestCase{nonNilChan2, false, true, "which is not a chan int"}, // Other types. equalsTestCase{0, false, true, "which is not a chan int"}, equalsTestCase{bool(false), false, true, "which is not a chan int"}, equalsTestCase{int(0), false, true, "which is not a chan int"}, equalsTestCase{int8(0), false, true, "which is not a chan int"}, equalsTestCase{int16(0), false, true, "which is not a chan int"}, equalsTestCase{int32(0), false, true, "which is not a chan int"}, equalsTestCase{int64(0), false, true, "which is not a chan int"}, equalsTestCase{uint(0), false, true, "which is not a chan int"}, equalsTestCase{uint8(0), false, true, "which is not a chan int"}, equalsTestCase{uint16(0), false, true, "which is not a chan int"}, equalsTestCase{uint32(0), false, true, "which is not a chan int"}, equalsTestCase{uint64(0), false, true, "which is not a chan int"}, equalsTestCase{true, false, true, "which is not a chan int"}, equalsTestCase{[...]int{}, false, true, "which is not a chan int"}, equalsTestCase{func() {}, false, true, "which is not a chan int"}, equalsTestCase{map[int]int{}, false, true, "which is not a chan int"}, equalsTestCase{&someInt, false, true, "which is not a chan int"}, equalsTestCase{[]int{}, false, true, "which is not a chan int"}, equalsTestCase{"taco", false, true, "which is not a chan int"}, equalsTestCase{equalsTestCase{}, false, true, "which is not a chan int"}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) NonNilChan() { var nilChan1 chan int var nilChan2 chan uint var nonNilChan1 chan int = make(chan int) var nonNilChan2 chan int = make(chan int) var nonNilChan3 chan uint = make(chan uint) matcher := Equals(nonNilChan1) ExpectEq(fmt.Sprintf("%v", nonNilChan1), matcher.Description()) cases := []equalsTestCase{ // int channels equalsTestCase{nonNilChan1, true, false, ""}, equalsTestCase{nonNilChan2, false, false, ""}, equalsTestCase{nilChan1, false, false, ""}, // uint channels equalsTestCase{nilChan2, false, true, "which is not a chan int"}, equalsTestCase{nonNilChan3, false, true, "which is not a chan int"}, // Other types. equalsTestCase{0, false, true, "which is not a chan int"}, equalsTestCase{bool(false), false, true, "which is not a chan int"}, equalsTestCase{int(0), false, true, "which is not a chan int"}, equalsTestCase{int8(0), false, true, "which is not a chan int"}, equalsTestCase{int16(0), false, true, "which is not a chan int"}, equalsTestCase{int32(0), false, true, "which is not a chan int"}, equalsTestCase{int64(0), false, true, "which is not a chan int"}, equalsTestCase{uint(0), false, true, "which is not a chan int"}, equalsTestCase{uint8(0), false, true, "which is not a chan int"}, equalsTestCase{uint16(0), false, true, "which is not a chan int"}, equalsTestCase{uint32(0), false, true, "which is not a chan int"}, equalsTestCase{uint64(0), false, true, "which is not a chan int"}, equalsTestCase{true, false, true, "which is not a chan int"}, equalsTestCase{[...]int{}, false, true, "which is not a chan int"}, equalsTestCase{func() {}, false, true, "which is not a chan int"}, equalsTestCase{map[int]int{}, false, true, "which is not a chan int"}, equalsTestCase{&someInt, false, true, "which is not a chan int"}, equalsTestCase{[]int{}, false, true, "which is not a chan int"}, equalsTestCase{"taco", false, true, "which is not a chan int"}, equalsTestCase{equalsTestCase{}, false, true, "which is not a chan int"}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) ChanDirection() { var chan1 chan<- int var chan2 <-chan int var chan3 chan int matcher := Equals(chan1) ExpectEq(fmt.Sprintf("%v", chan1), matcher.Description()) cases := []equalsTestCase{ equalsTestCase{chan1, true, false, ""}, equalsTestCase{chan2, false, true, "which is not a chan<- int"}, equalsTestCase{chan3, false, true, "which is not a chan<- int"}, } t.checkTestCases(matcher, cases) } //////////////////////////////////////////////////////////////////////// // func //////////////////////////////////////////////////////////////////////// func (t *EqualsTest) Functions() { func1 := func() {} func2 := func() {} func3 := func(x int) {} matcher := Equals(func1) ExpectEq(fmt.Sprintf("%v", func1), matcher.Description()) cases := []equalsTestCase{ // Functions. equalsTestCase{func1, true, false, ""}, equalsTestCase{func2, false, false, ""}, equalsTestCase{func3, false, false, ""}, // Other types. equalsTestCase{0, false, true, "which is not a function"}, equalsTestCase{bool(false), false, true, "which is not a function"}, equalsTestCase{int(0), false, true, "which is not a function"}, equalsTestCase{int8(0), false, true, "which is not a function"}, equalsTestCase{int16(0), false, true, "which is not a function"}, equalsTestCase{int32(0), false, true, "which is not a function"}, equalsTestCase{int64(0), false, true, "which is not a function"}, equalsTestCase{uint(0), false, true, "which is not a function"}, equalsTestCase{uint8(0), false, true, "which is not a function"}, equalsTestCase{uint16(0), false, true, "which is not a function"}, equalsTestCase{uint32(0), false, true, "which is not a function"}, equalsTestCase{uint64(0), false, true, "which is not a function"}, equalsTestCase{true, false, true, "which is not a function"}, equalsTestCase{[...]int{}, false, true, "which is not a function"}, equalsTestCase{map[int]int{}, false, true, "which is not a function"}, equalsTestCase{&someInt, false, true, "which is not a function"}, equalsTestCase{[]int{}, false, true, "which is not a function"}, equalsTestCase{"taco", false, true, "which is not a function"}, equalsTestCase{equalsTestCase{}, false, true, "which is not a function"}, } t.checkTestCases(matcher, cases) } //////////////////////////////////////////////////////////////////////// // map //////////////////////////////////////////////////////////////////////// func (t *EqualsTest) NilMap() { var nilMap1 map[int]int var nilMap2 map[int]int var nilMap3 map[int]uint var nonNilMap1 map[int]int = make(map[int]int) var nonNilMap2 map[int]uint = make(map[int]uint) matcher := Equals(nilMap1) ExpectEq("map[]", matcher.Description()) cases := []equalsTestCase{ // Correct type. equalsTestCase{nilMap1, true, false, ""}, equalsTestCase{nilMap2, true, false, ""}, equalsTestCase{nilMap3, true, false, ""}, equalsTestCase{nonNilMap1, false, false, ""}, equalsTestCase{nonNilMap2, false, false, ""}, // Other types. equalsTestCase{0, false, true, "which is not a map"}, equalsTestCase{bool(false), false, true, "which is not a map"}, equalsTestCase{int(0), false, true, "which is not a map"}, equalsTestCase{int8(0), false, true, "which is not a map"}, equalsTestCase{int16(0), false, true, "which is not a map"}, equalsTestCase{int32(0), false, true, "which is not a map"}, equalsTestCase{int64(0), false, true, "which is not a map"}, equalsTestCase{uint(0), false, true, "which is not a map"}, equalsTestCase{uint8(0), false, true, "which is not a map"}, equalsTestCase{uint16(0), false, true, "which is not a map"}, equalsTestCase{uint32(0), false, true, "which is not a map"}, equalsTestCase{uint64(0), false, true, "which is not a map"}, equalsTestCase{true, false, true, "which is not a map"}, equalsTestCase{[...]int{}, false, true, "which is not a map"}, equalsTestCase{func() {}, false, true, "which is not a map"}, equalsTestCase{&someInt, false, true, "which is not a map"}, equalsTestCase{[]int{}, false, true, "which is not a map"}, equalsTestCase{"taco", false, true, "which is not a map"}, equalsTestCase{equalsTestCase{}, false, true, "which is not a map"}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) NonNilMap() { var nilMap1 map[int]int var nilMap2 map[int]uint var nonNilMap1 map[int]int = make(map[int]int) var nonNilMap2 map[int]int = make(map[int]int) var nonNilMap3 map[int]uint = make(map[int]uint) matcher := Equals(nonNilMap1) ExpectEq("map[]", matcher.Description()) cases := []equalsTestCase{ // Correct type. equalsTestCase{nonNilMap1, true, false, ""}, equalsTestCase{nonNilMap2, false, false, ""}, equalsTestCase{nonNilMap3, false, false, ""}, equalsTestCase{nilMap1, false, false, ""}, equalsTestCase{nilMap2, false, false, ""}, // Other types. equalsTestCase{0, false, true, "which is not a map"}, equalsTestCase{bool(false), false, true, "which is not a map"}, equalsTestCase{int(0), false, true, "which is not a map"}, equalsTestCase{int8(0), false, true, "which is not a map"}, equalsTestCase{int16(0), false, true, "which is not a map"}, equalsTestCase{int32(0), false, true, "which is not a map"}, equalsTestCase{int64(0), false, true, "which is not a map"}, equalsTestCase{uint(0), false, true, "which is not a map"}, equalsTestCase{uint8(0), false, true, "which is not a map"}, equalsTestCase{uint16(0), false, true, "which is not a map"}, equalsTestCase{uint32(0), false, true, "which is not a map"}, equalsTestCase{uint64(0), false, true, "which is not a map"}, equalsTestCase{true, false, true, "which is not a map"}, equalsTestCase{[...]int{}, false, true, "which is not a map"}, equalsTestCase{func() {}, false, true, "which is not a map"}, equalsTestCase{&someInt, false, true, "which is not a map"}, equalsTestCase{[]int{}, false, true, "which is not a map"}, equalsTestCase{"taco", false, true, "which is not a map"}, equalsTestCase{equalsTestCase{}, false, true, "which is not a map"}, } t.checkTestCases(matcher, cases) } //////////////////////////////////////////////////////////////////////// // Pointers //////////////////////////////////////////////////////////////////////// func (t *EqualsTest) NilPointer() { var someInt int = 17 var someUint uint = 17 var nilInt1 *int var nilInt2 *int var nilUint *uint var nonNilInt *int = &someInt var nonNilUint *uint = &someUint matcher := Equals(nilInt1) ExpectEq("", matcher.Description()) cases := []equalsTestCase{ // Correct type. equalsTestCase{nilInt1, true, false, ""}, equalsTestCase{nilInt2, true, false, ""}, equalsTestCase{nonNilInt, false, false, ""}, // Incorrect type. equalsTestCase{nilUint, false, true, "which is not a *int"}, equalsTestCase{nonNilUint, false, true, "which is not a *int"}, // Other types. equalsTestCase{0, false, true, "which is not a *int"}, equalsTestCase{bool(false), false, true, "which is not a *int"}, equalsTestCase{int(0), false, true, "which is not a *int"}, equalsTestCase{int8(0), false, true, "which is not a *int"}, equalsTestCase{int16(0), false, true, "which is not a *int"}, equalsTestCase{int32(0), false, true, "which is not a *int"}, equalsTestCase{int64(0), false, true, "which is not a *int"}, equalsTestCase{uint(0), false, true, "which is not a *int"}, equalsTestCase{uint8(0), false, true, "which is not a *int"}, equalsTestCase{uint16(0), false, true, "which is not a *int"}, equalsTestCase{uint32(0), false, true, "which is not a *int"}, equalsTestCase{uint64(0), false, true, "which is not a *int"}, equalsTestCase{true, false, true, "which is not a *int"}, equalsTestCase{[...]int{}, false, true, "which is not a *int"}, equalsTestCase{func() {}, false, true, "which is not a *int"}, equalsTestCase{map[int]int{}, false, true, "which is not a *int"}, equalsTestCase{[]int{}, false, true, "which is not a *int"}, equalsTestCase{"taco", false, true, "which is not a *int"}, equalsTestCase{equalsTestCase{}, false, true, "which is not a *int"}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) NonNilPointer() { var someInt int = 17 var someOtherInt int = 17 var someUint uint = 17 var nilInt *int var nilUint *uint var nonNilInt1 *int = &someInt var nonNilInt2 *int = &someOtherInt var nonNilUint *uint = &someUint matcher := Equals(nonNilInt1) ExpectEq(fmt.Sprintf("%v", nonNilInt1), matcher.Description()) cases := []equalsTestCase{ // Correct type. equalsTestCase{nonNilInt1, true, false, ""}, equalsTestCase{nonNilInt2, false, false, ""}, equalsTestCase{nilInt, false, false, ""}, // Incorrect type. equalsTestCase{nilUint, false, true, "which is not a *int"}, equalsTestCase{nonNilUint, false, true, "which is not a *int"}, // Other types. equalsTestCase{0, false, true, "which is not a *int"}, equalsTestCase{bool(false), false, true, "which is not a *int"}, equalsTestCase{int(0), false, true, "which is not a *int"}, equalsTestCase{int8(0), false, true, "which is not a *int"}, equalsTestCase{int16(0), false, true, "which is not a *int"}, equalsTestCase{int32(0), false, true, "which is not a *int"}, equalsTestCase{int64(0), false, true, "which is not a *int"}, equalsTestCase{uint(0), false, true, "which is not a *int"}, equalsTestCase{uint8(0), false, true, "which is not a *int"}, equalsTestCase{uint16(0), false, true, "which is not a *int"}, equalsTestCase{uint32(0), false, true, "which is not a *int"}, equalsTestCase{uint64(0), false, true, "which is not a *int"}, equalsTestCase{true, false, true, "which is not a *int"}, equalsTestCase{[...]int{}, false, true, "which is not a *int"}, equalsTestCase{func() {}, false, true, "which is not a *int"}, equalsTestCase{map[int]int{}, false, true, "which is not a *int"}, equalsTestCase{[]int{}, false, true, "which is not a *int"}, equalsTestCase{"taco", false, true, "which is not a *int"}, equalsTestCase{equalsTestCase{}, false, true, "which is not a *int"}, } t.checkTestCases(matcher, cases) } //////////////////////////////////////////////////////////////////////// // Slices //////////////////////////////////////////////////////////////////////// func (t *EqualsTest) NilSlice() { var nilInt1 []int var nilInt2 []int var nilUint []uint var nonNilInt []int = make([]int, 0) var nonNilUint []uint = make([]uint, 0) matcher := Equals(nilInt1) ExpectEq("[]", matcher.Description()) cases := []equalsTestCase{ // Correct type. equalsTestCase{nilInt1, true, false, ""}, equalsTestCase{nilInt2, true, false, ""}, equalsTestCase{nonNilInt, false, false, ""}, // Incorrect type. equalsTestCase{nilUint, false, true, "which is not a []int"}, equalsTestCase{nonNilUint, false, true, "which is not a []int"}, // Other types. equalsTestCase{0, false, true, "which is not a []int"}, equalsTestCase{bool(false), false, true, "which is not a []int"}, equalsTestCase{int(0), false, true, "which is not a []int"}, equalsTestCase{int8(0), false, true, "which is not a []int"}, equalsTestCase{int16(0), false, true, "which is not a []int"}, equalsTestCase{int32(0), false, true, "which is not a []int"}, equalsTestCase{int64(0), false, true, "which is not a []int"}, equalsTestCase{uint(0), false, true, "which is not a []int"}, equalsTestCase{uint8(0), false, true, "which is not a []int"}, equalsTestCase{uint16(0), false, true, "which is not a []int"}, equalsTestCase{uint32(0), false, true, "which is not a []int"}, equalsTestCase{uint64(0), false, true, "which is not a []int"}, equalsTestCase{true, false, true, "which is not a []int"}, equalsTestCase{[...]int{}, false, true, "which is not a []int"}, equalsTestCase{func() {}, false, true, "which is not a []int"}, equalsTestCase{map[int]int{}, false, true, "which is not a []int"}, equalsTestCase{"taco", false, true, "which is not a []int"}, equalsTestCase{equalsTestCase{}, false, true, "which is not a []int"}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) NonNilSlice() { nonNil := make([]int, 0) f := func() { Equals(nonNil) } ExpectThat(f, Panics(HasSubstr("non-nil slice"))) } //////////////////////////////////////////////////////////////////////// // string //////////////////////////////////////////////////////////////////////// func (t *EqualsTest) String() { partial := "taco" expected := fmt.Sprintf("%s%d", partial, 1) matcher := Equals(expected) ExpectEq("taco1", matcher.Description()) type stringAlias string cases := []equalsTestCase{ // Correct types. equalsTestCase{"taco1", true, false, ""}, equalsTestCase{"taco" + "1", true, false, ""}, equalsTestCase{expected, true, false, ""}, equalsTestCase{stringAlias("taco1"), true, false, ""}, equalsTestCase{"", false, false, ""}, equalsTestCase{"taco", false, false, ""}, equalsTestCase{"taco1\x00", false, false, ""}, equalsTestCase{"taco2", false, false, ""}, equalsTestCase{stringAlias("taco2"), false, false, ""}, // Other types. equalsTestCase{0, false, true, "which is not a string"}, equalsTestCase{bool(false), false, true, "which is not a string"}, equalsTestCase{int(0), false, true, "which is not a string"}, equalsTestCase{int8(0), false, true, "which is not a string"}, equalsTestCase{int16(0), false, true, "which is not a string"}, equalsTestCase{int32(0), false, true, "which is not a string"}, equalsTestCase{int64(0), false, true, "which is not a string"}, equalsTestCase{uint(0), false, true, "which is not a string"}, equalsTestCase{uint8(0), false, true, "which is not a string"}, equalsTestCase{uint16(0), false, true, "which is not a string"}, equalsTestCase{uint32(0), false, true, "which is not a string"}, equalsTestCase{uint64(0), false, true, "which is not a string"}, equalsTestCase{true, false, true, "which is not a string"}, equalsTestCase{[...]int{}, false, true, "which is not a string"}, equalsTestCase{func() {}, false, true, "which is not a string"}, equalsTestCase{map[int]int{}, false, true, "which is not a string"}, equalsTestCase{equalsTestCase{}, false, true, "which is not a string"}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) StringAlias() { type stringAlias string matcher := Equals(stringAlias("taco")) ExpectEq("taco", matcher.Description()) cases := []equalsTestCase{ // Correct types. equalsTestCase{stringAlias("taco"), true, false, ""}, equalsTestCase{"taco", true, false, ""}, equalsTestCase{"burrito", false, false, ""}, equalsTestCase{stringAlias("burrito"), false, false, ""}, // Other types. equalsTestCase{0, false, true, "which is not a string"}, equalsTestCase{bool(false), false, true, "which is not a string"}, } t.checkTestCases(matcher, cases) } //////////////////////////////////////////////////////////////////////// // struct //////////////////////////////////////////////////////////////////////// func (t *EqualsTest) Struct() { type someStruct struct{ foo uint } f := func() { Equals(someStruct{17}) } ExpectThat(f, Panics(HasSubstr("unsupported kind struct"))) } //////////////////////////////////////////////////////////////////////// // unsafe.Pointer //////////////////////////////////////////////////////////////////////// func (t *EqualsTest) NilUnsafePointer() { someInt := int(17) var nilPtr1 unsafe.Pointer var nilPtr2 unsafe.Pointer var nonNilPtr unsafe.Pointer = unsafe.Pointer(&someInt) matcher := Equals(nilPtr1) ExpectEq("", matcher.Description()) cases := []equalsTestCase{ // Correct type. equalsTestCase{nilPtr1, true, false, ""}, equalsTestCase{nilPtr2, true, false, ""}, equalsTestCase{nonNilPtr, false, false, ""}, // Other types. equalsTestCase{0, false, true, "which is not a unsafe.Pointer"}, equalsTestCase{bool(false), false, true, "which is not a unsafe.Pointer"}, equalsTestCase{int(0), false, true, "which is not a unsafe.Pointer"}, equalsTestCase{int8(0), false, true, "which is not a unsafe.Pointer"}, equalsTestCase{int16(0), false, true, "which is not a unsafe.Pointer"}, equalsTestCase{int32(0), false, true, "which is not a unsafe.Pointer"}, equalsTestCase{int64(0), false, true, "which is not a unsafe.Pointer"}, equalsTestCase{uint(0), false, true, "which is not a unsafe.Pointer"}, equalsTestCase{uint8(0), false, true, "which is not a unsafe.Pointer"}, equalsTestCase{uint16(0), false, true, "which is not a unsafe.Pointer"}, equalsTestCase{uint32(0), false, true, "which is not a unsafe.Pointer"}, equalsTestCase{uint64(0), false, true, "which is not a unsafe.Pointer"}, equalsTestCase{uintptr(0), false, true, "which is not a unsafe.Pointer"}, equalsTestCase{true, false, true, "which is not a unsafe.Pointer"}, equalsTestCase{[...]int{}, false, true, "which is not a unsafe.Pointer"}, equalsTestCase{make(chan int), false, true, "which is not a unsafe.Pointer"}, equalsTestCase{func() {}, false, true, "which is not a unsafe.Pointer"}, equalsTestCase{map[int]int{}, false, true, "which is not a unsafe.Pointer"}, equalsTestCase{&someInt, false, true, "which is not a unsafe.Pointer"}, equalsTestCase{[]int{}, false, true, "which is not a unsafe.Pointer"}, equalsTestCase{"taco", false, true, "which is not a unsafe.Pointer"}, equalsTestCase{equalsTestCase{}, false, true, "which is not a unsafe.Pointer"}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) NonNilUnsafePointer() { someInt := int(17) someOtherInt := int(17) var nilPtr unsafe.Pointer var nonNilPtr1 unsafe.Pointer = unsafe.Pointer(&someInt) var nonNilPtr2 unsafe.Pointer = unsafe.Pointer(&someOtherInt) matcher := Equals(nonNilPtr1) ExpectEq(fmt.Sprintf("%v", nonNilPtr1), matcher.Description()) cases := []equalsTestCase{ // Correct type. equalsTestCase{nonNilPtr1, true, false, ""}, equalsTestCase{nonNilPtr2, false, false, ""}, equalsTestCase{nilPtr, false, false, ""}, // Other types. equalsTestCase{0, false, true, "which is not a unsafe.Pointer"}, equalsTestCase{bool(false), false, true, "which is not a unsafe.Pointer"}, equalsTestCase{int(0), false, true, "which is not a unsafe.Pointer"}, equalsTestCase{int8(0), false, true, "which is not a unsafe.Pointer"}, equalsTestCase{int16(0), false, true, "which is not a unsafe.Pointer"}, equalsTestCase{int32(0), false, true, "which is not a unsafe.Pointer"}, equalsTestCase{int64(0), false, true, "which is not a unsafe.Pointer"}, equalsTestCase{uint(0), false, true, "which is not a unsafe.Pointer"}, equalsTestCase{uint8(0), false, true, "which is not a unsafe.Pointer"}, equalsTestCase{uint16(0), false, true, "which is not a unsafe.Pointer"}, equalsTestCase{uint32(0), false, true, "which is not a unsafe.Pointer"}, equalsTestCase{uint64(0), false, true, "which is not a unsafe.Pointer"}, equalsTestCase{uintptr(0), false, true, "which is not a unsafe.Pointer"}, equalsTestCase{true, false, true, "which is not a unsafe.Pointer"}, equalsTestCase{[...]int{}, false, true, "which is not a unsafe.Pointer"}, equalsTestCase{make(chan int), false, true, "which is not a unsafe.Pointer"}, equalsTestCase{func() {}, false, true, "which is not a unsafe.Pointer"}, equalsTestCase{map[int]int{}, false, true, "which is not a unsafe.Pointer"}, equalsTestCase{&someInt, false, true, "which is not a unsafe.Pointer"}, equalsTestCase{[]int{}, false, true, "which is not a unsafe.Pointer"}, equalsTestCase{"taco", false, true, "which is not a unsafe.Pointer"}, equalsTestCase{equalsTestCase{}, false, true, "which is not a unsafe.Pointer"}, } t.checkTestCases(matcher, cases) } mongo-tools-r3.6.3/vendor/src/github.com/jacobsa/oglematchers/error.go000066400000000000000000000030371321131462300260430ustar00rootroot00000000000000// Copyright 2011 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers // Error returns a matcher that matches non-nil values implementing the // built-in error interface for whom the return value of Error() matches the // supplied matcher. // // For example: // // err := errors.New("taco burrito") // // Error(Equals("taco burrito")) // matches err // Error(HasSubstr("taco")) // matches err // Error(HasSubstr("enchilada")) // doesn't match err // func Error(m Matcher) Matcher { return &errorMatcher{m} } type errorMatcher struct { wrappedMatcher Matcher } func (m *errorMatcher) Description() string { return "error " + m.wrappedMatcher.Description() } func (m *errorMatcher) Matches(c interface{}) error { // Make sure that c is an error. e, ok := c.(error) if !ok { return NewFatalError("which is not an error") } // Pass on the error text to the wrapped matcher. return m.wrappedMatcher.Matches(e.Error()) } mongo-tools-r3.6.3/vendor/src/github.com/jacobsa/oglematchers/error_test.go000066400000000000000000000046331321131462300271050ustar00rootroot00000000000000// Copyright 2011 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers_test import ( "errors" . "github.com/jacobsa/oglematchers" . "github.com/jacobsa/ogletest" ) //////////////////////////////////////////////////////////////////////// // Helpers //////////////////////////////////////////////////////////////////////// type ErrorTest struct { matcherCalled bool suppliedCandidate interface{} wrappedError error matcher Matcher } func init() { RegisterTestSuite(&ErrorTest{}) } func (t *ErrorTest) SetUp(i *TestInfo) { wrapped := &fakeMatcher{ func(c interface{}) error { t.matcherCalled = true t.suppliedCandidate = c return t.wrappedError }, "is foo", } t.matcher = Error(wrapped) } func isFatal(err error) bool { _, isFatal := err.(*FatalError) return isFatal } //////////////////////////////////////////////////////////////////////// // Tests //////////////////////////////////////////////////////////////////////// func (t *ErrorTest) Description() { ExpectThat(t.matcher.Description(), Equals("error is foo")) } func (t *ErrorTest) CandidateIsNil() { err := t.matcher.Matches(nil) ExpectThat(t.matcherCalled, Equals(false)) ExpectThat(err.Error(), Equals("which is not an error")) ExpectTrue(isFatal(err)) } func (t *ErrorTest) CandidateIsString() { err := t.matcher.Matches("taco") ExpectThat(t.matcherCalled, Equals(false)) ExpectThat(err.Error(), Equals("which is not an error")) ExpectTrue(isFatal(err)) } func (t *ErrorTest) CallsWrappedMatcher() { candidate := errors.New("taco") t.matcher.Matches(candidate) ExpectThat(t.matcherCalled, Equals(true)) ExpectThat(t.suppliedCandidate, Equals("taco")) } func (t *ErrorTest) ReturnsWrappedMatcherResult() { t.wrappedError = errors.New("burrito") err := t.matcher.Matches(errors.New("")) ExpectThat(err, Equals(t.wrappedError)) } mongo-tools-r3.6.3/vendor/src/github.com/jacobsa/oglematchers/greater_or_equal.go000066400000000000000000000025551321131462300302360ustar00rootroot00000000000000// Copyright 2011 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers import ( "fmt" "reflect" ) // GreaterOrEqual returns a matcher that matches integer, floating point, or // strings values v such that v >= x. Comparison is not defined between numeric // and string types, but is defined between all integer and floating point // types. // // x must itself be an integer, floating point, or string type; otherwise, // GreaterOrEqual will panic. func GreaterOrEqual(x interface{}) Matcher { desc := fmt.Sprintf("greater than or equal to %v", x) // Special case: make it clear that strings are strings. if reflect.TypeOf(x).Kind() == reflect.String { desc = fmt.Sprintf("greater than or equal to \"%s\"", x) } return transformDescription(Not(LessThan(x)), desc) } mongo-tools-r3.6.3/vendor/src/github.com/jacobsa/oglematchers/greater_or_equal_test.go000066400000000000000000001100471321131462300312710ustar00rootroot00000000000000// Copyright 2011 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers_test import ( . "github.com/jacobsa/oglematchers" . "github.com/jacobsa/ogletest" "math" ) //////////////////////////////////////////////////////////////////////// // Helpers //////////////////////////////////////////////////////////////////////// type GreaterOrEqualTest struct { } func init() { RegisterTestSuite(&GreaterOrEqualTest{}) } type geTestCase struct { candidate interface{} expectedResult bool shouldBeFatal bool expectedError string } func (t *GreaterOrEqualTest) checkTestCases(matcher Matcher, cases []geTestCase) { for i, c := range cases { err := matcher.Matches(c.candidate) ExpectThat( (err == nil), Equals(c.expectedResult), "Case %d (candidate %v)", i, c.candidate) if err == nil { continue } _, isFatal := err.(*FatalError) ExpectEq( c.shouldBeFatal, isFatal, "Case %d (candidate %v)", i, c.candidate) ExpectThat( err, Error(Equals(c.expectedError)), "Case %d (candidate %v)", i, c.candidate) } } //////////////////////////////////////////////////////////////////////// // Integer literals //////////////////////////////////////////////////////////////////////// func (t *GreaterOrEqualTest) IntegerCandidateBadTypes() { matcher := GreaterOrEqual(int(-150)) cases := []geTestCase{ geTestCase{true, false, true, "which is not comparable"}, geTestCase{uintptr(17), false, true, "which is not comparable"}, geTestCase{complex64(-151), false, true, "which is not comparable"}, geTestCase{complex128(-151), false, true, "which is not comparable"}, geTestCase{[...]int{-151}, false, true, "which is not comparable"}, geTestCase{make(chan int), false, true, "which is not comparable"}, geTestCase{func() {}, false, true, "which is not comparable"}, geTestCase{map[int]int{}, false, true, "which is not comparable"}, geTestCase{&geTestCase{}, false, true, "which is not comparable"}, geTestCase{make([]int, 0), false, true, "which is not comparable"}, geTestCase{"-151", false, true, "which is not comparable"}, geTestCase{geTestCase{}, false, true, "which is not comparable"}, } t.checkTestCases(matcher, cases) } func (t *GreaterOrEqualTest) FloatCandidateBadTypes() { matcher := GreaterOrEqual(float32(-150)) cases := []geTestCase{ geTestCase{true, false, true, "which is not comparable"}, geTestCase{uintptr(17), false, true, "which is not comparable"}, geTestCase{complex64(-151), false, true, "which is not comparable"}, geTestCase{complex128(-151), false, true, "which is not comparable"}, geTestCase{[...]int{-151}, false, true, "which is not comparable"}, geTestCase{make(chan int), false, true, "which is not comparable"}, geTestCase{func() {}, false, true, "which is not comparable"}, geTestCase{map[int]int{}, false, true, "which is not comparable"}, geTestCase{&geTestCase{}, false, true, "which is not comparable"}, geTestCase{make([]int, 0), false, true, "which is not comparable"}, geTestCase{"-151", false, true, "which is not comparable"}, geTestCase{geTestCase{}, false, true, "which is not comparable"}, } t.checkTestCases(matcher, cases) } func (t *GreaterOrEqualTest) StringCandidateBadTypes() { matcher := GreaterOrEqual("17") cases := []geTestCase{ geTestCase{true, false, true, "which is not comparable"}, geTestCase{int(0), false, true, "which is not comparable"}, geTestCase{int8(0), false, true, "which is not comparable"}, geTestCase{int16(0), false, true, "which is not comparable"}, geTestCase{int32(0), false, true, "which is not comparable"}, geTestCase{int64(0), false, true, "which is not comparable"}, geTestCase{uint(0), false, true, "which is not comparable"}, geTestCase{uint8(0), false, true, "which is not comparable"}, geTestCase{uint16(0), false, true, "which is not comparable"}, geTestCase{uint32(0), false, true, "which is not comparable"}, geTestCase{uint64(0), false, true, "which is not comparable"}, geTestCase{uintptr(17), false, true, "which is not comparable"}, geTestCase{float32(0), false, true, "which is not comparable"}, geTestCase{float64(0), false, true, "which is not comparable"}, geTestCase{complex64(-151), false, true, "which is not comparable"}, geTestCase{complex128(-151), false, true, "which is not comparable"}, geTestCase{[...]int{-151}, false, true, "which is not comparable"}, geTestCase{make(chan int), false, true, "which is not comparable"}, geTestCase{func() {}, false, true, "which is not comparable"}, geTestCase{map[int]int{}, false, true, "which is not comparable"}, geTestCase{&geTestCase{}, false, true, "which is not comparable"}, geTestCase{make([]int, 0), false, true, "which is not comparable"}, geTestCase{geTestCase{}, false, true, "which is not comparable"}, } t.checkTestCases(matcher, cases) } func (t *GreaterOrEqualTest) BadArgument() { panicked := false defer func() { ExpectThat(panicked, Equals(true)) }() defer func() { if r := recover(); r != nil { panicked = true } }() GreaterOrEqual(complex128(0)) } //////////////////////////////////////////////////////////////////////// // Integer literals //////////////////////////////////////////////////////////////////////// func (t *GreaterOrEqualTest) NegativeIntegerLiteral() { matcher := GreaterOrEqual(-150) desc := matcher.Description() expectedDesc := "greater than or equal to -150" ExpectThat(desc, Equals(expectedDesc)) cases := []geTestCase{ // Signed integers. geTestCase{-(1 << 30), false, false, ""}, geTestCase{-151, false, false, ""}, geTestCase{-150, true, false, ""}, geTestCase{0, true, false, ""}, geTestCase{17, true, false, ""}, geTestCase{int(-(1 << 30)), false, false, ""}, geTestCase{int(-151), false, false, ""}, geTestCase{int(-150), true, false, ""}, geTestCase{int(0), true, false, ""}, geTestCase{int(17), true, false, ""}, geTestCase{int8(-127), true, false, ""}, geTestCase{int8(0), true, false, ""}, geTestCase{int8(17), true, false, ""}, geTestCase{int16(-(1 << 14)), false, false, ""}, geTestCase{int16(-151), false, false, ""}, geTestCase{int16(-150), true, false, ""}, geTestCase{int16(0), true, false, ""}, geTestCase{int16(17), true, false, ""}, geTestCase{int32(-(1 << 30)), false, false, ""}, geTestCase{int32(-151), false, false, ""}, geTestCase{int32(-150), true, false, ""}, geTestCase{int32(0), true, false, ""}, geTestCase{int32(17), true, false, ""}, geTestCase{int64(-(1 << 30)), false, false, ""}, geTestCase{int64(-151), false, false, ""}, geTestCase{int64(-150), true, false, ""}, geTestCase{int64(0), true, false, ""}, geTestCase{int64(17), true, false, ""}, // Unsigned integers. geTestCase{uint((1 << 32) - 151), true, false, ""}, geTestCase{uint(0), true, false, ""}, geTestCase{uint(17), true, false, ""}, geTestCase{uint8(0), true, false, ""}, geTestCase{uint8(17), true, false, ""}, geTestCase{uint8(253), true, false, ""}, geTestCase{uint16((1 << 16) - 151), true, false, ""}, geTestCase{uint16(0), true, false, ""}, geTestCase{uint16(17), true, false, ""}, geTestCase{uint32((1 << 32) - 151), true, false, ""}, geTestCase{uint32(0), true, false, ""}, geTestCase{uint32(17), true, false, ""}, geTestCase{uint64((1 << 64) - 151), true, false, ""}, geTestCase{uint64(0), true, false, ""}, geTestCase{uint64(17), true, false, ""}, // Floating point. geTestCase{float32(-(1 << 30)), false, false, ""}, geTestCase{float32(-151), false, false, ""}, geTestCase{float32(-150.1), false, false, ""}, geTestCase{float32(-150), true, false, ""}, geTestCase{float32(-149.9), true, false, ""}, geTestCase{float32(0), true, false, ""}, geTestCase{float32(17), true, false, ""}, geTestCase{float32(160), true, false, ""}, geTestCase{float64(-(1 << 30)), false, false, ""}, geTestCase{float64(-151), false, false, ""}, geTestCase{float64(-150.1), false, false, ""}, geTestCase{float64(-150), true, false, ""}, geTestCase{float64(-149.9), true, false, ""}, geTestCase{float64(0), true, false, ""}, geTestCase{float64(17), true, false, ""}, geTestCase{float64(160), true, false, ""}, } t.checkTestCases(matcher, cases) } func (t *GreaterOrEqualTest) ZeroIntegerLiteral() { matcher := GreaterOrEqual(0) desc := matcher.Description() expectedDesc := "greater than or equal to 0" ExpectThat(desc, Equals(expectedDesc)) cases := []geTestCase{ // Signed integers. geTestCase{-(1 << 30), false, false, ""}, geTestCase{-1, false, false, ""}, geTestCase{0, true, false, ""}, geTestCase{1, true, false, ""}, geTestCase{17, true, false, ""}, geTestCase{(1 << 30), true, false, ""}, geTestCase{int(-(1 << 30)), false, false, ""}, geTestCase{int(-1), false, false, ""}, geTestCase{int(0), true, false, ""}, geTestCase{int(1), true, false, ""}, geTestCase{int(17), true, false, ""}, geTestCase{int8(-1), false, false, ""}, geTestCase{int8(0), true, false, ""}, geTestCase{int8(1), true, false, ""}, geTestCase{int16(-(1 << 14)), false, false, ""}, geTestCase{int16(-1), false, false, ""}, geTestCase{int16(0), true, false, ""}, geTestCase{int16(1), true, false, ""}, geTestCase{int16(17), true, false, ""}, geTestCase{int32(-(1 << 30)), false, false, ""}, geTestCase{int32(-1), false, false, ""}, geTestCase{int32(0), true, false, ""}, geTestCase{int32(1), true, false, ""}, geTestCase{int32(17), true, false, ""}, geTestCase{int64(-(1 << 30)), false, false, ""}, geTestCase{int64(-1), false, false, ""}, geTestCase{int64(0), true, false, ""}, geTestCase{int64(1), true, false, ""}, geTestCase{int64(17), true, false, ""}, // Unsigned integers. geTestCase{uint((1 << 32) - 1), true, false, ""}, geTestCase{uint(0), true, false, ""}, geTestCase{uint(17), true, false, ""}, geTestCase{uint8(0), true, false, ""}, geTestCase{uint8(17), true, false, ""}, geTestCase{uint8(253), true, false, ""}, geTestCase{uint16((1 << 16) - 1), true, false, ""}, geTestCase{uint16(0), true, false, ""}, geTestCase{uint16(17), true, false, ""}, geTestCase{uint32((1 << 32) - 1), true, false, ""}, geTestCase{uint32(0), true, false, ""}, geTestCase{uint32(17), true, false, ""}, geTestCase{uint64((1 << 64) - 1), true, false, ""}, geTestCase{uint64(0), true, false, ""}, geTestCase{uint64(17), true, false, ""}, // Floating point. geTestCase{float32(-(1 << 30)), false, false, ""}, geTestCase{float32(-1), false, false, ""}, geTestCase{float32(-0.1), false, false, ""}, geTestCase{float32(-0.0), true, false, ""}, geTestCase{float32(0), true, false, ""}, geTestCase{float32(0.1), true, false, ""}, geTestCase{float32(17), true, false, ""}, geTestCase{float32(160), true, false, ""}, geTestCase{float64(-(1 << 30)), false, false, ""}, geTestCase{float64(-1), false, false, ""}, geTestCase{float64(-0.1), false, false, ""}, geTestCase{float64(-0), true, false, ""}, geTestCase{float64(0), true, false, ""}, geTestCase{float64(17), true, false, ""}, geTestCase{float64(160), true, false, ""}, } t.checkTestCases(matcher, cases) } func (t *GreaterOrEqualTest) PositiveIntegerLiteral() { matcher := GreaterOrEqual(150) desc := matcher.Description() expectedDesc := "greater than or equal to 150" ExpectThat(desc, Equals(expectedDesc)) cases := []geTestCase{ // Signed integers. geTestCase{-1, false, false, ""}, geTestCase{149, false, false, ""}, geTestCase{150, true, false, ""}, geTestCase{151, true, false, ""}, geTestCase{int(-1), false, false, ""}, geTestCase{int(149), false, false, ""}, geTestCase{int(150), true, false, ""}, geTestCase{int(151), true, false, ""}, geTestCase{int8(-1), false, false, ""}, geTestCase{int8(0), false, false, ""}, geTestCase{int8(17), false, false, ""}, geTestCase{int8(127), false, false, ""}, geTestCase{int16(-1), false, false, ""}, geTestCase{int16(149), false, false, ""}, geTestCase{int16(150), true, false, ""}, geTestCase{int16(151), true, false, ""}, geTestCase{int32(-1), false, false, ""}, geTestCase{int32(149), false, false, ""}, geTestCase{int32(150), true, false, ""}, geTestCase{int32(151), true, false, ""}, geTestCase{int64(-1), false, false, ""}, geTestCase{int64(149), false, false, ""}, geTestCase{int64(150), true, false, ""}, geTestCase{int64(151), true, false, ""}, // Unsigned integers. geTestCase{uint(0), false, false, ""}, geTestCase{uint(149), false, false, ""}, geTestCase{uint(150), true, false, ""}, geTestCase{uint(151), true, false, ""}, geTestCase{uint8(0), false, false, ""}, geTestCase{uint8(127), false, false, ""}, geTestCase{uint16(0), false, false, ""}, geTestCase{uint16(149), false, false, ""}, geTestCase{uint16(150), true, false, ""}, geTestCase{uint16(151), true, false, ""}, geTestCase{uint32(0), false, false, ""}, geTestCase{uint32(149), false, false, ""}, geTestCase{uint32(150), true, false, ""}, geTestCase{uint32(151), true, false, ""}, geTestCase{uint64(0), false, false, ""}, geTestCase{uint64(149), false, false, ""}, geTestCase{uint64(150), true, false, ""}, geTestCase{uint64(151), true, false, ""}, // Floating point. geTestCase{float32(-1), false, false, ""}, geTestCase{float32(149), false, false, ""}, geTestCase{float32(149.9), false, false, ""}, geTestCase{float32(150), true, false, ""}, geTestCase{float32(150.1), true, false, ""}, geTestCase{float32(151), true, false, ""}, geTestCase{float64(-1), false, false, ""}, geTestCase{float64(149), false, false, ""}, geTestCase{float64(149.9), false, false, ""}, geTestCase{float64(150), true, false, ""}, geTestCase{float64(150.1), true, false, ""}, geTestCase{float64(151), true, false, ""}, } t.checkTestCases(matcher, cases) } //////////////////////////////////////////////////////////////////////// // Float literals //////////////////////////////////////////////////////////////////////// func (t *GreaterOrEqualTest) NegativeFloatLiteral() { matcher := GreaterOrEqual(-150.1) desc := matcher.Description() expectedDesc := "greater than or equal to -150.1" ExpectThat(desc, Equals(expectedDesc)) cases := []geTestCase{ // Signed integers. geTestCase{-(1 << 30), false, false, ""}, geTestCase{-151, false, false, ""}, geTestCase{-150, true, false, ""}, geTestCase{0, true, false, ""}, geTestCase{17, true, false, ""}, geTestCase{int(-(1 << 30)), false, false, ""}, geTestCase{int(-151), false, false, ""}, geTestCase{int(-150), true, false, ""}, geTestCase{int(0), true, false, ""}, geTestCase{int(17), true, false, ""}, geTestCase{int8(-127), true, false, ""}, geTestCase{int8(0), true, false, ""}, geTestCase{int8(17), true, false, ""}, geTestCase{int16(-(1 << 14)), false, false, ""}, geTestCase{int16(-151), false, false, ""}, geTestCase{int16(-150), true, false, ""}, geTestCase{int16(0), true, false, ""}, geTestCase{int16(17), true, false, ""}, geTestCase{int32(-(1 << 30)), false, false, ""}, geTestCase{int32(-151), false, false, ""}, geTestCase{int32(-150), true, false, ""}, geTestCase{int32(0), true, false, ""}, geTestCase{int32(17), true, false, ""}, geTestCase{int64(-(1 << 30)), false, false, ""}, geTestCase{int64(-151), false, false, ""}, geTestCase{int64(-150), true, false, ""}, geTestCase{int64(0), true, false, ""}, geTestCase{int64(17), true, false, ""}, // Unsigned integers. geTestCase{uint((1 << 32) - 151), true, false, ""}, geTestCase{uint(0), true, false, ""}, geTestCase{uint(17), true, false, ""}, geTestCase{uint8(0), true, false, ""}, geTestCase{uint8(17), true, false, ""}, geTestCase{uint8(253), true, false, ""}, geTestCase{uint16((1 << 16) - 151), true, false, ""}, geTestCase{uint16(0), true, false, ""}, geTestCase{uint16(17), true, false, ""}, geTestCase{uint32((1 << 32) - 151), true, false, ""}, geTestCase{uint32(0), true, false, ""}, geTestCase{uint32(17), true, false, ""}, geTestCase{uint64((1 << 64) - 151), true, false, ""}, geTestCase{uint64(0), true, false, ""}, geTestCase{uint64(17), true, false, ""}, // Floating point. geTestCase{float32(-(1 << 30)), false, false, ""}, geTestCase{float32(-151), false, false, ""}, geTestCase{float32(-150.2), false, false, ""}, geTestCase{float32(-150.1), true, false, ""}, geTestCase{float32(-150), true, false, ""}, geTestCase{float32(0), true, false, ""}, geTestCase{float32(17), true, false, ""}, geTestCase{float32(160), true, false, ""}, geTestCase{float64(-(1 << 30)), false, false, ""}, geTestCase{float64(-151), false, false, ""}, geTestCase{float64(-150.2), false, false, ""}, geTestCase{float64(-150.1), true, false, ""}, geTestCase{float64(-150), true, false, ""}, geTestCase{float64(0), true, false, ""}, geTestCase{float64(17), true, false, ""}, geTestCase{float64(160), true, false, ""}, } t.checkTestCases(matcher, cases) } func (t *GreaterOrEqualTest) PositiveFloatLiteral() { matcher := GreaterOrEqual(149.9) desc := matcher.Description() expectedDesc := "greater than or equal to 149.9" ExpectThat(desc, Equals(expectedDesc)) cases := []geTestCase{ // Signed integers. geTestCase{-1, false, false, ""}, geTestCase{149, false, false, ""}, geTestCase{150, true, false, ""}, geTestCase{151, true, false, ""}, geTestCase{int(-1), false, false, ""}, geTestCase{int(149), false, false, ""}, geTestCase{int(150), true, false, ""}, geTestCase{int(151), true, false, ""}, geTestCase{int8(-1), false, false, ""}, geTestCase{int8(0), false, false, ""}, geTestCase{int8(17), false, false, ""}, geTestCase{int8(127), false, false, ""}, geTestCase{int16(-1), false, false, ""}, geTestCase{int16(149), false, false, ""}, geTestCase{int16(150), true, false, ""}, geTestCase{int16(151), true, false, ""}, geTestCase{int32(-1), false, false, ""}, geTestCase{int32(149), false, false, ""}, geTestCase{int32(150), true, false, ""}, geTestCase{int32(151), true, false, ""}, geTestCase{int64(-1), false, false, ""}, geTestCase{int64(149), false, false, ""}, geTestCase{int64(150), true, false, ""}, geTestCase{int64(151), true, false, ""}, // Unsigned integers. geTestCase{uint(0), false, false, ""}, geTestCase{uint(149), false, false, ""}, geTestCase{uint(150), true, false, ""}, geTestCase{uint(151), true, false, ""}, geTestCase{uint8(0), false, false, ""}, geTestCase{uint8(127), false, false, ""}, geTestCase{uint16(0), false, false, ""}, geTestCase{uint16(149), false, false, ""}, geTestCase{uint16(150), true, false, ""}, geTestCase{uint16(151), true, false, ""}, geTestCase{uint32(0), false, false, ""}, geTestCase{uint32(149), false, false, ""}, geTestCase{uint32(150), true, false, ""}, geTestCase{uint32(151), true, false, ""}, geTestCase{uint64(0), false, false, ""}, geTestCase{uint64(149), false, false, ""}, geTestCase{uint64(150), true, false, ""}, geTestCase{uint64(151), true, false, ""}, // Floating point. geTestCase{float32(-1), false, false, ""}, geTestCase{float32(149), false, false, ""}, geTestCase{float32(149.8), false, false, ""}, geTestCase{float32(149.9), true, false, ""}, geTestCase{float32(150), true, false, ""}, geTestCase{float32(151), true, false, ""}, geTestCase{float64(-1), false, false, ""}, geTestCase{float64(149), false, false, ""}, geTestCase{float64(149.8), false, false, ""}, geTestCase{float64(149.9), true, false, ""}, geTestCase{float64(150), true, false, ""}, geTestCase{float64(151), true, false, ""}, } t.checkTestCases(matcher, cases) } //////////////////////////////////////////////////////////////////////// // Subtle cases //////////////////////////////////////////////////////////////////////// func (t *GreaterOrEqualTest) Int64NotExactlyRepresentableBySinglePrecision() { // Single-precision floats don't have enough bits to represent the integers // near this one distinctly, so [2^25-1, 2^25+2] all receive the same value // and should be treated as equivalent when floats are in the mix. const kTwoTo25 = 1 << 25 matcher := GreaterOrEqual(int64(kTwoTo25 + 1)) desc := matcher.Description() expectedDesc := "greater than or equal to 33554433" ExpectThat(desc, Equals(expectedDesc)) cases := []geTestCase{ // Signed integers. geTestCase{-1, false, false, ""}, geTestCase{kTwoTo25 + 0, false, false, ""}, geTestCase{kTwoTo25 + 1, true, false, ""}, geTestCase{kTwoTo25 + 2, true, false, ""}, geTestCase{int(-1), false, false, ""}, geTestCase{int(kTwoTo25 + 0), false, false, ""}, geTestCase{int(kTwoTo25 + 1), true, false, ""}, geTestCase{int(kTwoTo25 + 2), true, false, ""}, geTestCase{int8(-1), false, false, ""}, geTestCase{int8(127), false, false, ""}, geTestCase{int16(-1), false, false, ""}, geTestCase{int16(0), false, false, ""}, geTestCase{int16(32767), false, false, ""}, geTestCase{int32(-1), false, false, ""}, geTestCase{int32(kTwoTo25 + 0), false, false, ""}, geTestCase{int32(kTwoTo25 + 1), true, false, ""}, geTestCase{int32(kTwoTo25 + 2), true, false, ""}, geTestCase{int64(-1), false, false, ""}, geTestCase{int64(kTwoTo25 + 0), false, false, ""}, geTestCase{int64(kTwoTo25 + 1), true, false, ""}, geTestCase{int64(kTwoTo25 + 2), true, false, ""}, // Unsigned integers. geTestCase{uint(0), false, false, ""}, geTestCase{uint(kTwoTo25 + 0), false, false, ""}, geTestCase{uint(kTwoTo25 + 1), true, false, ""}, geTestCase{uint(kTwoTo25 + 2), true, false, ""}, geTestCase{uint8(0), false, false, ""}, geTestCase{uint8(255), false, false, ""}, geTestCase{uint16(0), false, false, ""}, geTestCase{uint16(65535), false, false, ""}, geTestCase{uint32(0), false, false, ""}, geTestCase{uint32(kTwoTo25 + 0), false, false, ""}, geTestCase{uint32(kTwoTo25 + 1), true, false, ""}, geTestCase{uint32(kTwoTo25 + 2), true, false, ""}, geTestCase{uint64(0), false, false, ""}, geTestCase{uint64(kTwoTo25 + 0), false, false, ""}, geTestCase{uint64(kTwoTo25 + 1), true, false, ""}, geTestCase{uint64(kTwoTo25 + 2), true, false, ""}, // Floating point. geTestCase{float32(-1), false, false, ""}, geTestCase{float32(kTwoTo25 - 2), false, false, ""}, geTestCase{float32(kTwoTo25 - 1), true, false, ""}, geTestCase{float32(kTwoTo25 + 0), true, false, ""}, geTestCase{float32(kTwoTo25 + 1), true, false, ""}, geTestCase{float32(kTwoTo25 + 2), true, false, ""}, geTestCase{float32(kTwoTo25 + 3), true, false, ""}, geTestCase{float64(-1), false, false, ""}, geTestCase{float64(kTwoTo25 - 2), false, false, ""}, geTestCase{float64(kTwoTo25 - 1), false, false, ""}, geTestCase{float64(kTwoTo25 + 0), false, false, ""}, geTestCase{float64(kTwoTo25 + 1), true, false, ""}, geTestCase{float64(kTwoTo25 + 2), true, false, ""}, geTestCase{float64(kTwoTo25 + 3), true, false, ""}, } t.checkTestCases(matcher, cases) } func (t *GreaterOrEqualTest) Int64NotExactlyRepresentableByDoublePrecision() { // Double-precision floats don't have enough bits to represent the integers // near this one distinctly, so [2^54-1, 2^54+2] all receive the same value // and should be treated as equivalent when floats are in the mix. const kTwoTo54 = 1 << 54 matcher := GreaterOrEqual(int64(kTwoTo54 + 1)) desc := matcher.Description() expectedDesc := "greater than or equal to 18014398509481985" ExpectThat(desc, Equals(expectedDesc)) cases := []geTestCase{ // Signed integers. geTestCase{-1, false, false, ""}, geTestCase{1 << 30, false, false, ""}, geTestCase{int(-1), false, false, ""}, geTestCase{int(math.MaxInt32), false, false, ""}, geTestCase{int8(-1), false, false, ""}, geTestCase{int8(127), false, false, ""}, geTestCase{int16(-1), false, false, ""}, geTestCase{int16(0), false, false, ""}, geTestCase{int16(32767), false, false, ""}, geTestCase{int32(-1), false, false, ""}, geTestCase{int32(math.MaxInt32), false, false, ""}, geTestCase{int64(-1), false, false, ""}, geTestCase{int64(kTwoTo54 - 1), false, false, ""}, geTestCase{int64(kTwoTo54 + 0), false, false, ""}, geTestCase{int64(kTwoTo54 + 1), true, false, ""}, geTestCase{int64(kTwoTo54 + 2), true, false, ""}, // Unsigned integers. geTestCase{uint(0), false, false, ""}, geTestCase{uint(math.MaxUint32), false, false, ""}, geTestCase{uint8(0), false, false, ""}, geTestCase{uint8(255), false, false, ""}, geTestCase{uint16(0), false, false, ""}, geTestCase{uint16(65535), false, false, ""}, geTestCase{uint32(0), false, false, ""}, geTestCase{uint32(math.MaxUint32), false, false, ""}, geTestCase{uint64(0), false, false, ""}, geTestCase{uint64(kTwoTo54 - 1), false, false, ""}, geTestCase{uint64(kTwoTo54 + 0), false, false, ""}, geTestCase{uint64(kTwoTo54 + 1), true, false, ""}, geTestCase{uint64(kTwoTo54 + 2), true, false, ""}, // Floating point. geTestCase{float64(-1), false, false, ""}, geTestCase{float64(kTwoTo54 - 2), false, false, ""}, geTestCase{float64(kTwoTo54 - 1), true, false, ""}, geTestCase{float64(kTwoTo54 + 0), true, false, ""}, geTestCase{float64(kTwoTo54 + 1), true, false, ""}, geTestCase{float64(kTwoTo54 + 2), true, false, ""}, geTestCase{float64(kTwoTo54 + 3), true, false, ""}, } t.checkTestCases(matcher, cases) } func (t *GreaterOrEqualTest) Uint64NotExactlyRepresentableBySinglePrecision() { // Single-precision floats don't have enough bits to represent the integers // near this one distinctly, so [2^25-1, 2^25+2] all receive the same value // and should be treated as equivalent when floats are in the mix. const kTwoTo25 = 1 << 25 matcher := GreaterOrEqual(uint64(kTwoTo25 + 1)) desc := matcher.Description() expectedDesc := "greater than or equal to 33554433" ExpectThat(desc, Equals(expectedDesc)) cases := []geTestCase{ // Signed integers. geTestCase{-1, false, false, ""}, geTestCase{kTwoTo25 + 0, false, false, ""}, geTestCase{kTwoTo25 + 1, true, false, ""}, geTestCase{kTwoTo25 + 2, true, false, ""}, geTestCase{int(-1), false, false, ""}, geTestCase{int(kTwoTo25 + 0), false, false, ""}, geTestCase{int(kTwoTo25 + 1), true, false, ""}, geTestCase{int(kTwoTo25 + 2), true, false, ""}, geTestCase{int8(-1), false, false, ""}, geTestCase{int8(127), false, false, ""}, geTestCase{int16(-1), false, false, ""}, geTestCase{int16(0), false, false, ""}, geTestCase{int16(32767), false, false, ""}, geTestCase{int32(-1), false, false, ""}, geTestCase{int32(kTwoTo25 + 0), false, false, ""}, geTestCase{int32(kTwoTo25 + 1), true, false, ""}, geTestCase{int32(kTwoTo25 + 2), true, false, ""}, geTestCase{int64(-1), false, false, ""}, geTestCase{int64(kTwoTo25 + 0), false, false, ""}, geTestCase{int64(kTwoTo25 + 1), true, false, ""}, geTestCase{int64(kTwoTo25 + 2), true, false, ""}, // Unsigned integers. geTestCase{uint(0), false, false, ""}, geTestCase{uint(kTwoTo25 + 0), false, false, ""}, geTestCase{uint(kTwoTo25 + 1), true, false, ""}, geTestCase{uint(kTwoTo25 + 2), true, false, ""}, geTestCase{uint8(0), false, false, ""}, geTestCase{uint8(255), false, false, ""}, geTestCase{uint16(0), false, false, ""}, geTestCase{uint16(65535), false, false, ""}, geTestCase{uint32(0), false, false, ""}, geTestCase{uint32(kTwoTo25 + 0), false, false, ""}, geTestCase{uint32(kTwoTo25 + 1), true, false, ""}, geTestCase{uint32(kTwoTo25 + 2), true, false, ""}, geTestCase{uint64(0), false, false, ""}, geTestCase{uint64(kTwoTo25 + 0), false, false, ""}, geTestCase{uint64(kTwoTo25 + 1), true, false, ""}, geTestCase{uint64(kTwoTo25 + 2), true, false, ""}, // Floating point. geTestCase{float32(-1), false, false, ""}, geTestCase{float32(kTwoTo25 - 2), false, false, ""}, geTestCase{float32(kTwoTo25 - 1), true, false, ""}, geTestCase{float32(kTwoTo25 + 0), true, false, ""}, geTestCase{float32(kTwoTo25 + 1), true, false, ""}, geTestCase{float32(kTwoTo25 + 2), true, false, ""}, geTestCase{float32(kTwoTo25 + 3), true, false, ""}, geTestCase{float64(-1), false, false, ""}, geTestCase{float64(kTwoTo25 - 2), false, false, ""}, geTestCase{float64(kTwoTo25 - 1), false, false, ""}, geTestCase{float64(kTwoTo25 + 0), false, false, ""}, geTestCase{float64(kTwoTo25 + 1), true, false, ""}, geTestCase{float64(kTwoTo25 + 2), true, false, ""}, geTestCase{float64(kTwoTo25 + 3), true, false, ""}, } t.checkTestCases(matcher, cases) } func (t *GreaterOrEqualTest) Uint64NotExactlyRepresentableByDoublePrecision() { // Double-precision floats don't have enough bits to represent the integers // near this one distinctly, so [2^54-1, 2^54+2] all receive the same value // and should be treated as equivalent when floats are in the mix. const kTwoTo54 = 1 << 54 matcher := GreaterOrEqual(uint64(kTwoTo54 + 1)) desc := matcher.Description() expectedDesc := "greater than or equal to 18014398509481985" ExpectThat(desc, Equals(expectedDesc)) cases := []geTestCase{ // Signed integers. geTestCase{-1, false, false, ""}, geTestCase{1 << 30, false, false, ""}, geTestCase{int(-1), false, false, ""}, geTestCase{int(math.MaxInt32), false, false, ""}, geTestCase{int8(-1), false, false, ""}, geTestCase{int8(127), false, false, ""}, geTestCase{int16(-1), false, false, ""}, geTestCase{int16(0), false, false, ""}, geTestCase{int16(32767), false, false, ""}, geTestCase{int32(-1), false, false, ""}, geTestCase{int32(math.MaxInt32), false, false, ""}, geTestCase{int64(-1), false, false, ""}, geTestCase{int64(kTwoTo54 - 1), false, false, ""}, geTestCase{int64(kTwoTo54 + 0), false, false, ""}, geTestCase{int64(kTwoTo54 + 1), true, false, ""}, geTestCase{int64(kTwoTo54 + 2), true, false, ""}, // Unsigned integers. geTestCase{uint(0), false, false, ""}, geTestCase{uint(math.MaxUint32), false, false, ""}, geTestCase{uint8(0), false, false, ""}, geTestCase{uint8(255), false, false, ""}, geTestCase{uint16(0), false, false, ""}, geTestCase{uint16(65535), false, false, ""}, geTestCase{uint32(0), false, false, ""}, geTestCase{uint32(math.MaxUint32), false, false, ""}, geTestCase{uint64(0), false, false, ""}, geTestCase{uint64(kTwoTo54 - 1), false, false, ""}, geTestCase{uint64(kTwoTo54 + 0), false, false, ""}, geTestCase{uint64(kTwoTo54 + 1), true, false, ""}, geTestCase{uint64(kTwoTo54 + 2), true, false, ""}, // Floating point. geTestCase{float64(-1), false, false, ""}, geTestCase{float64(kTwoTo54 - 2), false, false, ""}, geTestCase{float64(kTwoTo54 - 1), true, false, ""}, geTestCase{float64(kTwoTo54 + 0), true, false, ""}, geTestCase{float64(kTwoTo54 + 1), true, false, ""}, geTestCase{float64(kTwoTo54 + 2), true, false, ""}, geTestCase{float64(kTwoTo54 + 3), true, false, ""}, } t.checkTestCases(matcher, cases) } func (t *GreaterOrEqualTest) Float32AboveExactIntegerRange() { // Single-precision floats don't have enough bits to represent the integers // near this one distinctly, so [2^25-1, 2^25+2] all receive the same value // and should be treated as equivalent when floats are in the mix. const kTwoTo25 = 1 << 25 matcher := GreaterOrEqual(float32(kTwoTo25 + 1)) desc := matcher.Description() expectedDesc := "greater than or equal to 3.3554432e+07" ExpectThat(desc, Equals(expectedDesc)) cases := []geTestCase{ // Signed integers. geTestCase{int64(-1), false, false, ""}, geTestCase{int64(kTwoTo25 - 2), false, false, ""}, geTestCase{int64(kTwoTo25 - 1), true, false, ""}, geTestCase{int64(kTwoTo25 + 0), true, false, ""}, geTestCase{int64(kTwoTo25 + 1), true, false, ""}, geTestCase{int64(kTwoTo25 + 2), true, false, ""}, geTestCase{int64(kTwoTo25 + 3), true, false, ""}, // Unsigned integers. geTestCase{uint64(0), false, false, ""}, geTestCase{uint64(kTwoTo25 - 2), false, false, ""}, geTestCase{uint64(kTwoTo25 - 1), true, false, ""}, geTestCase{uint64(kTwoTo25 + 0), true, false, ""}, geTestCase{uint64(kTwoTo25 + 1), true, false, ""}, geTestCase{uint64(kTwoTo25 + 2), true, false, ""}, geTestCase{uint64(kTwoTo25 + 3), true, false, ""}, // Floating point. geTestCase{float32(-1), false, false, ""}, geTestCase{float32(kTwoTo25 - 2), false, false, ""}, geTestCase{float32(kTwoTo25 - 1), true, false, ""}, geTestCase{float32(kTwoTo25 + 0), true, false, ""}, geTestCase{float32(kTwoTo25 + 1), true, false, ""}, geTestCase{float32(kTwoTo25 + 2), true, false, ""}, geTestCase{float32(kTwoTo25 + 3), true, false, ""}, geTestCase{float64(-1), false, false, ""}, geTestCase{float64(kTwoTo25 - 2), false, false, ""}, geTestCase{float64(kTwoTo25 - 1), true, false, ""}, geTestCase{float64(kTwoTo25 + 0), true, false, ""}, geTestCase{float64(kTwoTo25 + 1), true, false, ""}, geTestCase{float64(kTwoTo25 + 2), true, false, ""}, geTestCase{float64(kTwoTo25 + 3), true, false, ""}, } t.checkTestCases(matcher, cases) } func (t *GreaterOrEqualTest) Float64AboveExactIntegerRange() { // Double-precision floats don't have enough bits to represent the integers // near this one distinctly, so [2^54-1, 2^54+2] all receive the same value // and should be treated as equivalent when floats are in the mix. const kTwoTo54 = 1 << 54 matcher := GreaterOrEqual(float64(kTwoTo54 + 1)) desc := matcher.Description() expectedDesc := "greater than or equal to 1.8014398509481984e+16" ExpectThat(desc, Equals(expectedDesc)) cases := []geTestCase{ // Signed integers. geTestCase{int64(-1), false, false, ""}, geTestCase{int64(kTwoTo54 - 2), false, false, ""}, geTestCase{int64(kTwoTo54 - 1), true, false, ""}, geTestCase{int64(kTwoTo54 + 0), true, false, ""}, geTestCase{int64(kTwoTo54 + 1), true, false, ""}, geTestCase{int64(kTwoTo54 + 2), true, false, ""}, geTestCase{int64(kTwoTo54 + 3), true, false, ""}, // Unsigned integers. geTestCase{uint64(0), false, false, ""}, geTestCase{uint64(kTwoTo54 - 2), false, false, ""}, geTestCase{uint64(kTwoTo54 - 1), true, false, ""}, geTestCase{uint64(kTwoTo54 + 0), true, false, ""}, geTestCase{uint64(kTwoTo54 + 1), true, false, ""}, geTestCase{uint64(kTwoTo54 + 2), true, false, ""}, geTestCase{uint64(kTwoTo54 + 3), true, false, ""}, // Floating point. geTestCase{float64(-1), false, false, ""}, geTestCase{float64(kTwoTo54 - 2), false, false, ""}, geTestCase{float64(kTwoTo54 - 1), true, false, ""}, geTestCase{float64(kTwoTo54 + 0), true, false, ""}, geTestCase{float64(kTwoTo54 + 1), true, false, ""}, geTestCase{float64(kTwoTo54 + 2), true, false, ""}, geTestCase{float64(kTwoTo54 + 3), true, false, ""}, } t.checkTestCases(matcher, cases) } //////////////////////////////////////////////////////////////////////// // String literals //////////////////////////////////////////////////////////////////////// func (t *GreaterOrEqualTest) EmptyString() { matcher := GreaterOrEqual("") desc := matcher.Description() expectedDesc := "greater than or equal to \"\"" ExpectThat(desc, Equals(expectedDesc)) cases := []geTestCase{ geTestCase{"", true, false, ""}, geTestCase{"\x00", true, false, ""}, geTestCase{"a", true, false, ""}, geTestCase{"foo", true, false, ""}, } t.checkTestCases(matcher, cases) } func (t *GreaterOrEqualTest) SingleNullByte() { matcher := GreaterOrEqual("\x00") desc := matcher.Description() expectedDesc := "greater than or equal to \"\x00\"" ExpectThat(desc, Equals(expectedDesc)) cases := []geTestCase{ geTestCase{"", false, false, ""}, geTestCase{"\x00", true, false, ""}, geTestCase{"a", true, false, ""}, geTestCase{"foo", true, false, ""}, } t.checkTestCases(matcher, cases) } func (t *GreaterOrEqualTest) LongerString() { matcher := GreaterOrEqual("foo\x00") desc := matcher.Description() expectedDesc := "greater than or equal to \"foo\x00\"" ExpectThat(desc, Equals(expectedDesc)) cases := []geTestCase{ geTestCase{"", false, false, ""}, geTestCase{"\x00", false, false, ""}, geTestCase{"bar", false, false, ""}, geTestCase{"foo", false, false, ""}, geTestCase{"foo\x00", true, false, ""}, geTestCase{"fooa", true, false, ""}, geTestCase{"qux", true, false, ""}, } t.checkTestCases(matcher, cases) } mongo-tools-r3.6.3/vendor/src/github.com/jacobsa/oglematchers/greater_than.go000066400000000000000000000025161321131462300273560ustar00rootroot00000000000000// Copyright 2011 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers import ( "fmt" "reflect" ) // GreaterThan returns a matcher that matches integer, floating point, or // strings values v such that v > x. Comparison is not defined between numeric // and string types, but is defined between all integer and floating point // types. // // x must itself be an integer, floating point, or string type; otherwise, // GreaterThan will panic. func GreaterThan(x interface{}) Matcher { desc := fmt.Sprintf("greater than %v", x) // Special case: make it clear that strings are strings. if reflect.TypeOf(x).Kind() == reflect.String { desc = fmt.Sprintf("greater than \"%s\"", x) } return transformDescription(Not(LessOrEqual(x)), desc) } mongo-tools-r3.6.3/vendor/src/github.com/jacobsa/oglematchers/greater_than_test.go000066400000000000000000001112741321131462300304170ustar00rootroot00000000000000// Copyright 2011 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers_test import ( . "github.com/jacobsa/oglematchers" . "github.com/jacobsa/ogletest" "math" ) //////////////////////////////////////////////////////////////////////// // Helpers //////////////////////////////////////////////////////////////////////// type GreaterThanTest struct { } func init() { RegisterTestSuite(&GreaterThanTest{}) } type gtTestCase struct { candidate interface{} expectedResult bool shouldBeFatal bool expectedError string } func (t *GreaterThanTest) checkTestCases(matcher Matcher, cases []gtTestCase) { for i, c := range cases { err := matcher.Matches(c.candidate) ExpectThat( (err == nil), Equals(c.expectedResult), "Case %d (candidate %v)", i, c.candidate) if err == nil { continue } _, isFatal := err.(*FatalError) ExpectEq( c.shouldBeFatal, isFatal, "Case %d (candidate %v)", i, c.candidate) ExpectThat( err, Error(Equals(c.expectedError)), "Case %d (candidate %v)", i, c.candidate) } } //////////////////////////////////////////////////////////////////////// // Integer literals //////////////////////////////////////////////////////////////////////// func (t *GreaterThanTest) IntegerCandidateBadTypes() { matcher := GreaterThan(int(-150)) cases := []gtTestCase{ gtTestCase{true, false, true, "which is not comparable"}, gtTestCase{uintptr(17), false, true, "which is not comparable"}, gtTestCase{complex64(-151), false, true, "which is not comparable"}, gtTestCase{complex128(-151), false, true, "which is not comparable"}, gtTestCase{[...]int{-151}, false, true, "which is not comparable"}, gtTestCase{make(chan int), false, true, "which is not comparable"}, gtTestCase{func() {}, false, true, "which is not comparable"}, gtTestCase{map[int]int{}, false, true, "which is not comparable"}, gtTestCase{>TestCase{}, false, true, "which is not comparable"}, gtTestCase{make([]int, 0), false, true, "which is not comparable"}, gtTestCase{"-151", false, true, "which is not comparable"}, gtTestCase{gtTestCase{}, false, true, "which is not comparable"}, } t.checkTestCases(matcher, cases) } func (t *GreaterThanTest) FloatCandidateBadTypes() { matcher := GreaterThan(float32(-150)) cases := []gtTestCase{ gtTestCase{true, false, true, "which is not comparable"}, gtTestCase{uintptr(17), false, true, "which is not comparable"}, gtTestCase{complex64(-151), false, true, "which is not comparable"}, gtTestCase{complex128(-151), false, true, "which is not comparable"}, gtTestCase{[...]int{-151}, false, true, "which is not comparable"}, gtTestCase{make(chan int), false, true, "which is not comparable"}, gtTestCase{func() {}, false, true, "which is not comparable"}, gtTestCase{map[int]int{}, false, true, "which is not comparable"}, gtTestCase{>TestCase{}, false, true, "which is not comparable"}, gtTestCase{make([]int, 0), false, true, "which is not comparable"}, gtTestCase{"-151", false, true, "which is not comparable"}, gtTestCase{gtTestCase{}, false, true, "which is not comparable"}, } t.checkTestCases(matcher, cases) } func (t *GreaterThanTest) StringCandidateBadTypes() { matcher := GreaterThan("17") cases := []gtTestCase{ gtTestCase{true, false, true, "which is not comparable"}, gtTestCase{int(0), false, true, "which is not comparable"}, gtTestCase{int8(0), false, true, "which is not comparable"}, gtTestCase{int16(0), false, true, "which is not comparable"}, gtTestCase{int32(0), false, true, "which is not comparable"}, gtTestCase{int64(0), false, true, "which is not comparable"}, gtTestCase{uint(0), false, true, "which is not comparable"}, gtTestCase{uint8(0), false, true, "which is not comparable"}, gtTestCase{uint16(0), false, true, "which is not comparable"}, gtTestCase{uint32(0), false, true, "which is not comparable"}, gtTestCase{uint64(0), false, true, "which is not comparable"}, gtTestCase{uintptr(17), false, true, "which is not comparable"}, gtTestCase{float32(0), false, true, "which is not comparable"}, gtTestCase{float64(0), false, true, "which is not comparable"}, gtTestCase{complex64(-151), false, true, "which is not comparable"}, gtTestCase{complex128(-151), false, true, "which is not comparable"}, gtTestCase{[...]int{-151}, false, true, "which is not comparable"}, gtTestCase{make(chan int), false, true, "which is not comparable"}, gtTestCase{func() {}, false, true, "which is not comparable"}, gtTestCase{map[int]int{}, false, true, "which is not comparable"}, gtTestCase{>TestCase{}, false, true, "which is not comparable"}, gtTestCase{make([]int, 0), false, true, "which is not comparable"}, gtTestCase{gtTestCase{}, false, true, "which is not comparable"}, } t.checkTestCases(matcher, cases) } func (t *GreaterThanTest) BadArgument() { panicked := false defer func() { ExpectThat(panicked, Equals(true)) }() defer func() { if r := recover(); r != nil { panicked = true } }() GreaterThan(complex128(0)) } //////////////////////////////////////////////////////////////////////// // Integer literals //////////////////////////////////////////////////////////////////////// func (t *GreaterThanTest) NegativeIntegerLiteral() { matcher := GreaterThan(-150) desc := matcher.Description() expectedDesc := "greater than -150" ExpectThat(desc, Equals(expectedDesc)) cases := []gtTestCase{ // Signed integers. gtTestCase{-(1 << 30), false, false, ""}, gtTestCase{-151, false, false, ""}, gtTestCase{-150, false, false, ""}, gtTestCase{-149, true, false, ""}, gtTestCase{0, true, false, ""}, gtTestCase{17, true, false, ""}, gtTestCase{int(-(1 << 30)), false, false, ""}, gtTestCase{int(-151), false, false, ""}, gtTestCase{int(-150), false, false, ""}, gtTestCase{int(-149), true, false, ""}, gtTestCase{int(0), true, false, ""}, gtTestCase{int(17), true, false, ""}, gtTestCase{int8(-127), true, false, ""}, gtTestCase{int8(0), true, false, ""}, gtTestCase{int8(17), true, false, ""}, gtTestCase{int16(-(1 << 14)), false, false, ""}, gtTestCase{int16(-151), false, false, ""}, gtTestCase{int16(-150), false, false, ""}, gtTestCase{int16(-149), true, false, ""}, gtTestCase{int16(0), true, false, ""}, gtTestCase{int16(17), true, false, ""}, gtTestCase{int32(-(1 << 30)), false, false, ""}, gtTestCase{int32(-151), false, false, ""}, gtTestCase{int32(-150), false, false, ""}, gtTestCase{int32(-149), true, false, ""}, gtTestCase{int32(0), true, false, ""}, gtTestCase{int32(17), true, false, ""}, gtTestCase{int64(-(1 << 30)), false, false, ""}, gtTestCase{int64(-151), false, false, ""}, gtTestCase{int64(-150), false, false, ""}, gtTestCase{int64(-149), true, false, ""}, gtTestCase{int64(0), true, false, ""}, gtTestCase{int64(17), true, false, ""}, // Unsigned integers. gtTestCase{uint((1 << 32) - 151), true, false, ""}, gtTestCase{uint(0), true, false, ""}, gtTestCase{uint(17), true, false, ""}, gtTestCase{uint8(0), true, false, ""}, gtTestCase{uint8(17), true, false, ""}, gtTestCase{uint8(253), true, false, ""}, gtTestCase{uint16((1 << 16) - 151), true, false, ""}, gtTestCase{uint16(0), true, false, ""}, gtTestCase{uint16(17), true, false, ""}, gtTestCase{uint32((1 << 32) - 151), true, false, ""}, gtTestCase{uint32(0), true, false, ""}, gtTestCase{uint32(17), true, false, ""}, gtTestCase{uint64((1 << 64) - 151), true, false, ""}, gtTestCase{uint64(0), true, false, ""}, gtTestCase{uint64(17), true, false, ""}, // Floating point. gtTestCase{float32(-(1 << 30)), false, false, ""}, gtTestCase{float32(-151), false, false, ""}, gtTestCase{float32(-150.1), false, false, ""}, gtTestCase{float32(-150), false, false, ""}, gtTestCase{float32(-149.9), true, false, ""}, gtTestCase{float32(0), true, false, ""}, gtTestCase{float32(17), true, false, ""}, gtTestCase{float32(160), true, false, ""}, gtTestCase{float64(-(1 << 30)), false, false, ""}, gtTestCase{float64(-151), false, false, ""}, gtTestCase{float64(-150.1), false, false, ""}, gtTestCase{float64(-150), false, false, ""}, gtTestCase{float64(-149.9), true, false, ""}, gtTestCase{float64(0), true, false, ""}, gtTestCase{float64(17), true, false, ""}, gtTestCase{float64(160), true, false, ""}, } t.checkTestCases(matcher, cases) } func (t *GreaterThanTest) ZeroIntegerLiteral() { matcher := GreaterThan(0) desc := matcher.Description() expectedDesc := "greater than 0" ExpectThat(desc, Equals(expectedDesc)) cases := []gtTestCase{ // Signed integers. gtTestCase{-(1 << 30), false, false, ""}, gtTestCase{-1, false, false, ""}, gtTestCase{0, false, false, ""}, gtTestCase{1, true, false, ""}, gtTestCase{17, true, false, ""}, gtTestCase{(1 << 30), true, false, ""}, gtTestCase{int(-(1 << 30)), false, false, ""}, gtTestCase{int(-1), false, false, ""}, gtTestCase{int(0), false, false, ""}, gtTestCase{int(1), true, false, ""}, gtTestCase{int(17), true, false, ""}, gtTestCase{int8(-1), false, false, ""}, gtTestCase{int8(0), false, false, ""}, gtTestCase{int8(1), true, false, ""}, gtTestCase{int16(-(1 << 14)), false, false, ""}, gtTestCase{int16(-1), false, false, ""}, gtTestCase{int16(0), false, false, ""}, gtTestCase{int16(1), true, false, ""}, gtTestCase{int16(17), true, false, ""}, gtTestCase{int32(-(1 << 30)), false, false, ""}, gtTestCase{int32(-1), false, false, ""}, gtTestCase{int32(0), false, false, ""}, gtTestCase{int32(1), true, false, ""}, gtTestCase{int32(17), true, false, ""}, gtTestCase{int64(-(1 << 30)), false, false, ""}, gtTestCase{int64(-1), false, false, ""}, gtTestCase{int64(0), false, false, ""}, gtTestCase{int64(1), true, false, ""}, gtTestCase{int64(17), true, false, ""}, // Unsigned integers. gtTestCase{uint((1 << 32) - 1), true, false, ""}, gtTestCase{uint(0), false, false, ""}, gtTestCase{uint(1), true, false, ""}, gtTestCase{uint(17), true, false, ""}, gtTestCase{uint8(0), false, false, ""}, gtTestCase{uint8(1), true, false, ""}, gtTestCase{uint8(17), true, false, ""}, gtTestCase{uint8(253), true, false, ""}, gtTestCase{uint16((1 << 16) - 1), true, false, ""}, gtTestCase{uint16(0), false, false, ""}, gtTestCase{uint16(1), true, false, ""}, gtTestCase{uint16(17), true, false, ""}, gtTestCase{uint32((1 << 32) - 1), true, false, ""}, gtTestCase{uint32(0), false, false, ""}, gtTestCase{uint32(1), true, false, ""}, gtTestCase{uint32(17), true, false, ""}, gtTestCase{uint64((1 << 64) - 1), true, false, ""}, gtTestCase{uint64(0), false, false, ""}, gtTestCase{uint64(1), true, false, ""}, gtTestCase{uint64(17), true, false, ""}, // Floating point. gtTestCase{float32(-(1 << 30)), false, false, ""}, gtTestCase{float32(-1), false, false, ""}, gtTestCase{float32(-0.1), false, false, ""}, gtTestCase{float32(-0.0), false, false, ""}, gtTestCase{float32(0), false, false, ""}, gtTestCase{float32(0.1), true, false, ""}, gtTestCase{float32(17), true, false, ""}, gtTestCase{float32(160), true, false, ""}, gtTestCase{float64(-(1 << 30)), false, false, ""}, gtTestCase{float64(-1), false, false, ""}, gtTestCase{float64(-0.1), false, false, ""}, gtTestCase{float64(-0), false, false, ""}, gtTestCase{float64(0), false, false, ""}, gtTestCase{float64(0.1), true, false, ""}, gtTestCase{float64(17), true, false, ""}, gtTestCase{float64(160), true, false, ""}, } t.checkTestCases(matcher, cases) } func (t *GreaterThanTest) PositiveIntegerLiteral() { matcher := GreaterThan(150) desc := matcher.Description() expectedDesc := "greater than 150" ExpectThat(desc, Equals(expectedDesc)) cases := []gtTestCase{ // Signed integers. gtTestCase{-1, false, false, ""}, gtTestCase{149, false, false, ""}, gtTestCase{150, false, false, ""}, gtTestCase{151, true, false, ""}, gtTestCase{int(-1), false, false, ""}, gtTestCase{int(149), false, false, ""}, gtTestCase{int(150), false, false, ""}, gtTestCase{int(151), true, false, ""}, gtTestCase{int8(-1), false, false, ""}, gtTestCase{int8(0), false, false, ""}, gtTestCase{int8(17), false, false, ""}, gtTestCase{int8(127), false, false, ""}, gtTestCase{int16(-1), false, false, ""}, gtTestCase{int16(149), false, false, ""}, gtTestCase{int16(150), false, false, ""}, gtTestCase{int16(151), true, false, ""}, gtTestCase{int32(-1), false, false, ""}, gtTestCase{int32(149), false, false, ""}, gtTestCase{int32(150), false, false, ""}, gtTestCase{int32(151), true, false, ""}, gtTestCase{int64(-1), false, false, ""}, gtTestCase{int64(149), false, false, ""}, gtTestCase{int64(150), false, false, ""}, gtTestCase{int64(151), true, false, ""}, // Unsigned integers. gtTestCase{uint(0), false, false, ""}, gtTestCase{uint(149), false, false, ""}, gtTestCase{uint(150), false, false, ""}, gtTestCase{uint(151), true, false, ""}, gtTestCase{uint8(0), false, false, ""}, gtTestCase{uint8(127), false, false, ""}, gtTestCase{uint16(0), false, false, ""}, gtTestCase{uint16(149), false, false, ""}, gtTestCase{uint16(150), false, false, ""}, gtTestCase{uint16(151), true, false, ""}, gtTestCase{uint32(0), false, false, ""}, gtTestCase{uint32(149), false, false, ""}, gtTestCase{uint32(150), false, false, ""}, gtTestCase{uint32(151), true, false, ""}, gtTestCase{uint64(0), false, false, ""}, gtTestCase{uint64(149), false, false, ""}, gtTestCase{uint64(150), false, false, ""}, gtTestCase{uint64(151), true, false, ""}, // Floating point. gtTestCase{float32(-1), false, false, ""}, gtTestCase{float32(149), false, false, ""}, gtTestCase{float32(149.9), false, false, ""}, gtTestCase{float32(150), false, false, ""}, gtTestCase{float32(150.1), true, false, ""}, gtTestCase{float32(151), true, false, ""}, gtTestCase{float64(-1), false, false, ""}, gtTestCase{float64(149), false, false, ""}, gtTestCase{float64(149.9), false, false, ""}, gtTestCase{float64(150), false, false, ""}, gtTestCase{float64(150.1), true, false, ""}, gtTestCase{float64(151), true, false, ""}, } t.checkTestCases(matcher, cases) } //////////////////////////////////////////////////////////////////////// // Float literals //////////////////////////////////////////////////////////////////////// func (t *GreaterThanTest) NegativeFloatLiteral() { matcher := GreaterThan(-150.1) desc := matcher.Description() expectedDesc := "greater than -150.1" ExpectThat(desc, Equals(expectedDesc)) cases := []gtTestCase{ // Signed integers. gtTestCase{-(1 << 30), false, false, ""}, gtTestCase{-151, false, false, ""}, gtTestCase{-150.1, false, false, ""}, gtTestCase{-150, true, false, ""}, gtTestCase{-149, true, false, ""}, gtTestCase{0, true, false, ""}, gtTestCase{17, true, false, ""}, gtTestCase{int(-(1 << 30)), false, false, ""}, gtTestCase{int(-151), false, false, ""}, gtTestCase{int(-150), true, false, ""}, gtTestCase{int(-149), true, false, ""}, gtTestCase{int(0), true, false, ""}, gtTestCase{int(17), true, false, ""}, gtTestCase{int8(-127), true, false, ""}, gtTestCase{int8(0), true, false, ""}, gtTestCase{int8(17), true, false, ""}, gtTestCase{int16(-(1 << 14)), false, false, ""}, gtTestCase{int16(-151), false, false, ""}, gtTestCase{int16(-150), true, false, ""}, gtTestCase{int16(-149), true, false, ""}, gtTestCase{int16(0), true, false, ""}, gtTestCase{int16(17), true, false, ""}, gtTestCase{int32(-(1 << 30)), false, false, ""}, gtTestCase{int32(-151), false, false, ""}, gtTestCase{int32(-150), true, false, ""}, gtTestCase{int32(-149), true, false, ""}, gtTestCase{int32(0), true, false, ""}, gtTestCase{int32(17), true, false, ""}, gtTestCase{int64(-(1 << 30)), false, false, ""}, gtTestCase{int64(-151), false, false, ""}, gtTestCase{int64(-150), true, false, ""}, gtTestCase{int64(-149), true, false, ""}, gtTestCase{int64(0), true, false, ""}, gtTestCase{int64(17), true, false, ""}, // Unsigned integers. gtTestCase{uint((1 << 32) - 151), true, false, ""}, gtTestCase{uint(0), true, false, ""}, gtTestCase{uint(17), true, false, ""}, gtTestCase{uint8(0), true, false, ""}, gtTestCase{uint8(17), true, false, ""}, gtTestCase{uint8(253), true, false, ""}, gtTestCase{uint16((1 << 16) - 151), true, false, ""}, gtTestCase{uint16(0), true, false, ""}, gtTestCase{uint16(17), true, false, ""}, gtTestCase{uint32((1 << 32) - 151), true, false, ""}, gtTestCase{uint32(0), true, false, ""}, gtTestCase{uint32(17), true, false, ""}, gtTestCase{uint64((1 << 64) - 151), true, false, ""}, gtTestCase{uint64(0), true, false, ""}, gtTestCase{uint64(17), true, false, ""}, // Floating point. gtTestCase{float32(-(1 << 30)), false, false, ""}, gtTestCase{float32(-151), false, false, ""}, gtTestCase{float32(-150.2), false, false, ""}, gtTestCase{float32(-150.1), false, false, ""}, gtTestCase{float32(-150), true, false, ""}, gtTestCase{float32(0), true, false, ""}, gtTestCase{float32(17), true, false, ""}, gtTestCase{float32(160), true, false, ""}, gtTestCase{float64(-(1 << 30)), false, false, ""}, gtTestCase{float64(-151), false, false, ""}, gtTestCase{float64(-150.2), false, false, ""}, gtTestCase{float64(-150.1), false, false, ""}, gtTestCase{float64(-150), true, false, ""}, gtTestCase{float64(0), true, false, ""}, gtTestCase{float64(17), true, false, ""}, gtTestCase{float64(160), true, false, ""}, } t.checkTestCases(matcher, cases) } func (t *GreaterThanTest) PositiveFloatLiteral() { matcher := GreaterThan(149.9) desc := matcher.Description() expectedDesc := "greater than 149.9" ExpectThat(desc, Equals(expectedDesc)) cases := []gtTestCase{ // Signed integers. gtTestCase{-1, false, false, ""}, gtTestCase{149, false, false, ""}, gtTestCase{149.9, false, false, ""}, gtTestCase{150, true, false, ""}, gtTestCase{151, true, false, ""}, gtTestCase{int(-1), false, false, ""}, gtTestCase{int(149), false, false, ""}, gtTestCase{int(150), true, false, ""}, gtTestCase{int(151), true, false, ""}, gtTestCase{int8(-1), false, false, ""}, gtTestCase{int8(0), false, false, ""}, gtTestCase{int8(17), false, false, ""}, gtTestCase{int8(127), false, false, ""}, gtTestCase{int16(-1), false, false, ""}, gtTestCase{int16(149), false, false, ""}, gtTestCase{int16(150), true, false, ""}, gtTestCase{int16(151), true, false, ""}, gtTestCase{int32(-1), false, false, ""}, gtTestCase{int32(149), false, false, ""}, gtTestCase{int32(150), true, false, ""}, gtTestCase{int32(151), true, false, ""}, gtTestCase{int64(-1), false, false, ""}, gtTestCase{int64(149), false, false, ""}, gtTestCase{int64(150), true, false, ""}, gtTestCase{int64(151), true, false, ""}, // Unsigned integers. gtTestCase{uint(0), false, false, ""}, gtTestCase{uint(149), false, false, ""}, gtTestCase{uint(150), true, false, ""}, gtTestCase{uint(151), true, false, ""}, gtTestCase{uint8(0), false, false, ""}, gtTestCase{uint8(127), false, false, ""}, gtTestCase{uint16(0), false, false, ""}, gtTestCase{uint16(149), false, false, ""}, gtTestCase{uint16(150), true, false, ""}, gtTestCase{uint16(151), true, false, ""}, gtTestCase{uint32(0), false, false, ""}, gtTestCase{uint32(149), false, false, ""}, gtTestCase{uint32(150), true, false, ""}, gtTestCase{uint32(151), true, false, ""}, gtTestCase{uint64(0), false, false, ""}, gtTestCase{uint64(149), false, false, ""}, gtTestCase{uint64(150), true, false, ""}, gtTestCase{uint64(151), true, false, ""}, // Floating point. gtTestCase{float32(-1), false, false, ""}, gtTestCase{float32(149), false, false, ""}, gtTestCase{float32(149.8), false, false, ""}, gtTestCase{float32(149.9), false, false, ""}, gtTestCase{float32(150), true, false, ""}, gtTestCase{float32(151), true, false, ""}, gtTestCase{float64(-1), false, false, ""}, gtTestCase{float64(149), false, false, ""}, gtTestCase{float64(149.8), false, false, ""}, gtTestCase{float64(149.9), false, false, ""}, gtTestCase{float64(150), true, false, ""}, gtTestCase{float64(151), true, false, ""}, } t.checkTestCases(matcher, cases) } //////////////////////////////////////////////////////////////////////// // Subtle cases //////////////////////////////////////////////////////////////////////// func (t *GreaterThanTest) Int64NotExactlyRepresentableBySinglePrecision() { // Single-precision floats don't have enough bits to represent the integers // near this one distinctly, so [2^25-1, 2^25+2] all receive the same value // and should be treated as equivalent when floats are in the mix. const kTwoTo25 = 1 << 25 matcher := GreaterThan(int64(kTwoTo25 + 1)) desc := matcher.Description() expectedDesc := "greater than 33554433" ExpectThat(desc, Equals(expectedDesc)) cases := []gtTestCase{ // Signed integers. gtTestCase{-1, false, false, ""}, gtTestCase{kTwoTo25 + 0, false, false, ""}, gtTestCase{kTwoTo25 + 1, false, false, ""}, gtTestCase{kTwoTo25 + 2, true, false, ""}, gtTestCase{int(-1), false, false, ""}, gtTestCase{int(kTwoTo25 + 0), false, false, ""}, gtTestCase{int(kTwoTo25 + 1), false, false, ""}, gtTestCase{int(kTwoTo25 + 2), true, false, ""}, gtTestCase{int8(-1), false, false, ""}, gtTestCase{int8(127), false, false, ""}, gtTestCase{int16(-1), false, false, ""}, gtTestCase{int16(0), false, false, ""}, gtTestCase{int16(32767), false, false, ""}, gtTestCase{int32(-1), false, false, ""}, gtTestCase{int32(kTwoTo25 + 0), false, false, ""}, gtTestCase{int32(kTwoTo25 + 1), false, false, ""}, gtTestCase{int32(kTwoTo25 + 2), true, false, ""}, gtTestCase{int64(-1), false, false, ""}, gtTestCase{int64(kTwoTo25 + 0), false, false, ""}, gtTestCase{int64(kTwoTo25 + 1), false, false, ""}, gtTestCase{int64(kTwoTo25 + 2), true, false, ""}, // Unsigned integers. gtTestCase{uint(0), false, false, ""}, gtTestCase{uint(kTwoTo25 + 0), false, false, ""}, gtTestCase{uint(kTwoTo25 + 1), false, false, ""}, gtTestCase{uint(kTwoTo25 + 2), true, false, ""}, gtTestCase{uint8(0), false, false, ""}, gtTestCase{uint8(255), false, false, ""}, gtTestCase{uint16(0), false, false, ""}, gtTestCase{uint16(65535), false, false, ""}, gtTestCase{uint32(0), false, false, ""}, gtTestCase{uint32(kTwoTo25 + 0), false, false, ""}, gtTestCase{uint32(kTwoTo25 + 1), false, false, ""}, gtTestCase{uint32(kTwoTo25 + 2), true, false, ""}, gtTestCase{uint64(0), false, false, ""}, gtTestCase{uint64(kTwoTo25 + 0), false, false, ""}, gtTestCase{uint64(kTwoTo25 + 1), false, false, ""}, gtTestCase{uint64(kTwoTo25 + 2), true, false, ""}, // Floating point. gtTestCase{float32(-1), false, false, ""}, gtTestCase{float32(kTwoTo25 - 2), false, false, ""}, gtTestCase{float32(kTwoTo25 - 1), false, false, ""}, gtTestCase{float32(kTwoTo25 + 0), false, false, ""}, gtTestCase{float32(kTwoTo25 + 1), false, false, ""}, gtTestCase{float32(kTwoTo25 + 2), false, false, ""}, gtTestCase{float32(kTwoTo25 + 3), true, false, ""}, gtTestCase{float64(-1), false, false, ""}, gtTestCase{float64(kTwoTo25 - 2), false, false, ""}, gtTestCase{float64(kTwoTo25 - 1), false, false, ""}, gtTestCase{float64(kTwoTo25 + 0), false, false, ""}, gtTestCase{float64(kTwoTo25 + 1), false, false, ""}, gtTestCase{float64(kTwoTo25 + 2), true, false, ""}, gtTestCase{float64(kTwoTo25 + 3), true, false, ""}, } t.checkTestCases(matcher, cases) } func (t *GreaterThanTest) Int64NotExactlyRepresentableByDoublePrecision() { // Double-precision floats don't have enough bits to represent the integers // near this one distinctly, so [2^54-1, 2^54+2] all receive the same value // and should be treated as equivalent when floats are in the mix. const kTwoTo54 = 1 << 54 matcher := GreaterThan(int64(kTwoTo54 + 1)) desc := matcher.Description() expectedDesc := "greater than 18014398509481985" ExpectThat(desc, Equals(expectedDesc)) cases := []gtTestCase{ // Signed integers. gtTestCase{-1, false, false, ""}, gtTestCase{1 << 30, false, false, ""}, gtTestCase{int(-1), false, false, ""}, gtTestCase{int(math.MaxInt32), false, false, ""}, gtTestCase{int8(-1), false, false, ""}, gtTestCase{int8(127), false, false, ""}, gtTestCase{int16(-1), false, false, ""}, gtTestCase{int16(0), false, false, ""}, gtTestCase{int16(32767), false, false, ""}, gtTestCase{int32(-1), false, false, ""}, gtTestCase{int32(math.MaxInt32), false, false, ""}, gtTestCase{int64(-1), false, false, ""}, gtTestCase{int64(kTwoTo54 - 1), false, false, ""}, gtTestCase{int64(kTwoTo54 + 0), false, false, ""}, gtTestCase{int64(kTwoTo54 + 1), false, false, ""}, gtTestCase{int64(kTwoTo54 + 2), true, false, ""}, // Unsigned integers. gtTestCase{uint(0), false, false, ""}, gtTestCase{uint(math.MaxUint32), false, false, ""}, gtTestCase{uint8(0), false, false, ""}, gtTestCase{uint8(255), false, false, ""}, gtTestCase{uint16(0), false, false, ""}, gtTestCase{uint16(65535), false, false, ""}, gtTestCase{uint32(0), false, false, ""}, gtTestCase{uint32(math.MaxUint32), false, false, ""}, gtTestCase{uint64(0), false, false, ""}, gtTestCase{uint64(kTwoTo54 - 1), false, false, ""}, gtTestCase{uint64(kTwoTo54 + 0), false, false, ""}, gtTestCase{uint64(kTwoTo54 + 1), false, false, ""}, gtTestCase{uint64(kTwoTo54 + 2), true, false, ""}, // Floating point. gtTestCase{float64(-1), false, false, ""}, gtTestCase{float64(kTwoTo54 - 2), false, false, ""}, gtTestCase{float64(kTwoTo54 - 1), false, false, ""}, gtTestCase{float64(kTwoTo54 + 0), false, false, ""}, gtTestCase{float64(kTwoTo54 + 1), false, false, ""}, gtTestCase{float64(kTwoTo54 + 2), false, false, ""}, gtTestCase{float64(kTwoTo54 + 3), true, false, ""}, } t.checkTestCases(matcher, cases) } func (t *GreaterThanTest) Uint64NotExactlyRepresentableBySinglePrecision() { // Single-precision floats don't have enough bits to represent the integers // near this one distinctly, so [2^25-1, 2^25+2] all receive the same value // and should be treated as equivalent when floats are in the mix. const kTwoTo25 = 1 << 25 matcher := GreaterThan(uint64(kTwoTo25 + 1)) desc := matcher.Description() expectedDesc := "greater than 33554433" ExpectThat(desc, Equals(expectedDesc)) cases := []gtTestCase{ // Signed integers. gtTestCase{-1, false, false, ""}, gtTestCase{kTwoTo25 + 0, false, false, ""}, gtTestCase{kTwoTo25 + 1, false, false, ""}, gtTestCase{kTwoTo25 + 2, true, false, ""}, gtTestCase{int(-1), false, false, ""}, gtTestCase{int(kTwoTo25 + 0), false, false, ""}, gtTestCase{int(kTwoTo25 + 1), false, false, ""}, gtTestCase{int(kTwoTo25 + 2), true, false, ""}, gtTestCase{int8(-1), false, false, ""}, gtTestCase{int8(127), false, false, ""}, gtTestCase{int16(-1), false, false, ""}, gtTestCase{int16(0), false, false, ""}, gtTestCase{int16(32767), false, false, ""}, gtTestCase{int32(-1), false, false, ""}, gtTestCase{int32(kTwoTo25 + 0), false, false, ""}, gtTestCase{int32(kTwoTo25 + 1), false, false, ""}, gtTestCase{int32(kTwoTo25 + 2), true, false, ""}, gtTestCase{int64(-1), false, false, ""}, gtTestCase{int64(kTwoTo25 + 0), false, false, ""}, gtTestCase{int64(kTwoTo25 + 1), false, false, ""}, gtTestCase{int64(kTwoTo25 + 2), true, false, ""}, // Unsigned integers. gtTestCase{uint(0), false, false, ""}, gtTestCase{uint(kTwoTo25 + 0), false, false, ""}, gtTestCase{uint(kTwoTo25 + 1), false, false, ""}, gtTestCase{uint(kTwoTo25 + 2), true, false, ""}, gtTestCase{uint8(0), false, false, ""}, gtTestCase{uint8(255), false, false, ""}, gtTestCase{uint16(0), false, false, ""}, gtTestCase{uint16(65535), false, false, ""}, gtTestCase{uint32(0), false, false, ""}, gtTestCase{uint32(kTwoTo25 + 0), false, false, ""}, gtTestCase{uint32(kTwoTo25 + 1), false, false, ""}, gtTestCase{uint32(kTwoTo25 + 2), true, false, ""}, gtTestCase{uint64(0), false, false, ""}, gtTestCase{uint64(kTwoTo25 + 0), false, false, ""}, gtTestCase{uint64(kTwoTo25 + 1), false, false, ""}, gtTestCase{uint64(kTwoTo25 + 2), true, false, ""}, // Floating point. gtTestCase{float32(-1), false, false, ""}, gtTestCase{float32(kTwoTo25 - 2), false, false, ""}, gtTestCase{float32(kTwoTo25 - 1), false, false, ""}, gtTestCase{float32(kTwoTo25 + 0), false, false, ""}, gtTestCase{float32(kTwoTo25 + 1), false, false, ""}, gtTestCase{float32(kTwoTo25 + 2), false, false, ""}, gtTestCase{float32(kTwoTo25 + 3), true, false, ""}, gtTestCase{float64(-1), false, false, ""}, gtTestCase{float64(kTwoTo25 - 2), false, false, ""}, gtTestCase{float64(kTwoTo25 - 1), false, false, ""}, gtTestCase{float64(kTwoTo25 + 0), false, false, ""}, gtTestCase{float64(kTwoTo25 + 1), false, false, ""}, gtTestCase{float64(kTwoTo25 + 2), true, false, ""}, gtTestCase{float64(kTwoTo25 + 3), true, false, ""}, } t.checkTestCases(matcher, cases) } func (t *GreaterThanTest) Uint64NotExactlyRepresentableByDoublePrecision() { // Double-precision floats don't have enough bits to represent the integers // near this one distinctly, so [2^54-1, 2^54+2] all receive the same value // and should be treated as equivalent when floats are in the mix. const kTwoTo54 = 1 << 54 matcher := GreaterThan(uint64(kTwoTo54 + 1)) desc := matcher.Description() expectedDesc := "greater than 18014398509481985" ExpectThat(desc, Equals(expectedDesc)) cases := []gtTestCase{ // Signed integers. gtTestCase{-1, false, false, ""}, gtTestCase{1 << 30, false, false, ""}, gtTestCase{int(-1), false, false, ""}, gtTestCase{int(math.MaxInt32), false, false, ""}, gtTestCase{int8(-1), false, false, ""}, gtTestCase{int8(127), false, false, ""}, gtTestCase{int16(-1), false, false, ""}, gtTestCase{int16(0), false, false, ""}, gtTestCase{int16(32767), false, false, ""}, gtTestCase{int32(-1), false, false, ""}, gtTestCase{int32(math.MaxInt32), false, false, ""}, gtTestCase{int64(-1), false, false, ""}, gtTestCase{int64(kTwoTo54 - 1), false, false, ""}, gtTestCase{int64(kTwoTo54 + 0), false, false, ""}, gtTestCase{int64(kTwoTo54 + 1), false, false, ""}, gtTestCase{int64(kTwoTo54 + 2), true, false, ""}, // Unsigned integers. gtTestCase{uint(0), false, false, ""}, gtTestCase{uint(math.MaxUint32), false, false, ""}, gtTestCase{uint8(0), false, false, ""}, gtTestCase{uint8(255), false, false, ""}, gtTestCase{uint16(0), false, false, ""}, gtTestCase{uint16(65535), false, false, ""}, gtTestCase{uint32(0), false, false, ""}, gtTestCase{uint32(math.MaxUint32), false, false, ""}, gtTestCase{uint64(0), false, false, ""}, gtTestCase{uint64(kTwoTo54 - 1), false, false, ""}, gtTestCase{uint64(kTwoTo54 + 0), false, false, ""}, gtTestCase{uint64(kTwoTo54 + 1), false, false, ""}, gtTestCase{uint64(kTwoTo54 + 2), true, false, ""}, // Floating point. gtTestCase{float64(-1), false, false, ""}, gtTestCase{float64(kTwoTo54 - 2), false, false, ""}, gtTestCase{float64(kTwoTo54 - 1), false, false, ""}, gtTestCase{float64(kTwoTo54 + 0), false, false, ""}, gtTestCase{float64(kTwoTo54 + 1), false, false, ""}, gtTestCase{float64(kTwoTo54 + 2), false, false, ""}, gtTestCase{float64(kTwoTo54 + 3), true, false, ""}, } t.checkTestCases(matcher, cases) } func (t *GreaterThanTest) Float32AboveExactIntegerRange() { // Single-precision floats don't have enough bits to represent the integers // near this one distinctly, so [2^25-1, 2^25+2] all receive the same value // and should be treated as equivalent when floats are in the mix. const kTwoTo25 = 1 << 25 matcher := GreaterThan(float32(kTwoTo25 + 1)) desc := matcher.Description() expectedDesc := "greater than 3.3554432e+07" ExpectThat(desc, Equals(expectedDesc)) cases := []gtTestCase{ // Signed integers. gtTestCase{int64(-1), false, false, ""}, gtTestCase{int64(kTwoTo25 - 2), false, false, ""}, gtTestCase{int64(kTwoTo25 - 1), false, false, ""}, gtTestCase{int64(kTwoTo25 + 0), false, false, ""}, gtTestCase{int64(kTwoTo25 + 1), false, false, ""}, gtTestCase{int64(kTwoTo25 + 2), false, false, ""}, gtTestCase{int64(kTwoTo25 + 3), true, false, ""}, // Unsigned integers. gtTestCase{uint64(0), false, false, ""}, gtTestCase{uint64(kTwoTo25 - 2), false, false, ""}, gtTestCase{uint64(kTwoTo25 - 1), false, false, ""}, gtTestCase{uint64(kTwoTo25 + 0), false, false, ""}, gtTestCase{uint64(kTwoTo25 + 1), false, false, ""}, gtTestCase{uint64(kTwoTo25 + 2), false, false, ""}, gtTestCase{uint64(kTwoTo25 + 3), true, false, ""}, // Floating point. gtTestCase{float32(-1), false, false, ""}, gtTestCase{float32(kTwoTo25 - 2), false, false, ""}, gtTestCase{float32(kTwoTo25 - 1), false, false, ""}, gtTestCase{float32(kTwoTo25 + 0), false, false, ""}, gtTestCase{float32(kTwoTo25 + 1), false, false, ""}, gtTestCase{float32(kTwoTo25 + 2), false, false, ""}, gtTestCase{float32(kTwoTo25 + 3), true, false, ""}, gtTestCase{float64(-1), false, false, ""}, gtTestCase{float64(kTwoTo25 - 2), false, false, ""}, gtTestCase{float64(kTwoTo25 - 1), false, false, ""}, gtTestCase{float64(kTwoTo25 + 0), false, false, ""}, gtTestCase{float64(kTwoTo25 + 1), false, false, ""}, gtTestCase{float64(kTwoTo25 + 2), false, false, ""}, gtTestCase{float64(kTwoTo25 + 3), true, false, ""}, } t.checkTestCases(matcher, cases) } func (t *GreaterThanTest) Float64AboveExactIntegerRange() { // Double-precision floats don't have enough bits to represent the integers // near this one distinctly, so [2^54-1, 2^54+2] all receive the same value // and should be treated as equivalent when floats are in the mix. const kTwoTo54 = 1 << 54 matcher := GreaterThan(float64(kTwoTo54 + 1)) desc := matcher.Description() expectedDesc := "greater than 1.8014398509481984e+16" ExpectThat(desc, Equals(expectedDesc)) cases := []gtTestCase{ // Signed integers. gtTestCase{int64(-1), false, false, ""}, gtTestCase{int64(kTwoTo54 - 2), false, false, ""}, gtTestCase{int64(kTwoTo54 - 1), false, false, ""}, gtTestCase{int64(kTwoTo54 + 0), false, false, ""}, gtTestCase{int64(kTwoTo54 + 1), false, false, ""}, gtTestCase{int64(kTwoTo54 + 2), false, false, ""}, gtTestCase{int64(kTwoTo54 + 3), true, false, ""}, // Unsigned integers. gtTestCase{uint64(0), false, false, ""}, gtTestCase{uint64(kTwoTo54 - 2), false, false, ""}, gtTestCase{uint64(kTwoTo54 - 1), false, false, ""}, gtTestCase{uint64(kTwoTo54 + 0), false, false, ""}, gtTestCase{uint64(kTwoTo54 + 1), false, false, ""}, gtTestCase{uint64(kTwoTo54 + 2), false, false, ""}, gtTestCase{uint64(kTwoTo54 + 3), true, false, ""}, // Floating point. gtTestCase{float64(-1), false, false, ""}, gtTestCase{float64(kTwoTo54 - 2), false, false, ""}, gtTestCase{float64(kTwoTo54 - 1), false, false, ""}, gtTestCase{float64(kTwoTo54 + 0), false, false, ""}, gtTestCase{float64(kTwoTo54 + 1), false, false, ""}, gtTestCase{float64(kTwoTo54 + 2), false, false, ""}, gtTestCase{float64(kTwoTo54 + 3), true, false, ""}, } t.checkTestCases(matcher, cases) } //////////////////////////////////////////////////////////////////////// // String literals //////////////////////////////////////////////////////////////////////// func (t *GreaterThanTest) EmptyString() { matcher := GreaterThan("") desc := matcher.Description() expectedDesc := "greater than \"\"" ExpectThat(desc, Equals(expectedDesc)) cases := []gtTestCase{ gtTestCase{"", false, false, ""}, gtTestCase{"\x00", true, false, ""}, gtTestCase{"a", true, false, ""}, gtTestCase{"foo", true, false, ""}, } t.checkTestCases(matcher, cases) } func (t *GreaterThanTest) SingleNullByte() { matcher := GreaterThan("\x00") desc := matcher.Description() expectedDesc := "greater than \"\x00\"" ExpectThat(desc, Equals(expectedDesc)) cases := []gtTestCase{ gtTestCase{"", false, false, ""}, gtTestCase{"\x00", false, false, ""}, gtTestCase{"\x00\x00", true, false, ""}, gtTestCase{"a", true, false, ""}, gtTestCase{"foo", true, false, ""}, } t.checkTestCases(matcher, cases) } func (t *GreaterThanTest) LongerString() { matcher := GreaterThan("foo\x00") desc := matcher.Description() expectedDesc := "greater than \"foo\x00\"" ExpectThat(desc, Equals(expectedDesc)) cases := []gtTestCase{ gtTestCase{"", false, false, ""}, gtTestCase{"\x00", false, false, ""}, gtTestCase{"bar", false, false, ""}, gtTestCase{"foo", false, false, ""}, gtTestCase{"foo\x00", false, false, ""}, gtTestCase{"foo\x00\x00", true, false, ""}, gtTestCase{"fooa", true, false, ""}, gtTestCase{"qux", true, false, ""}, } t.checkTestCases(matcher, cases) } mongo-tools-r3.6.3/vendor/src/github.com/jacobsa/oglematchers/has_same_type_as.go000066400000000000000000000021521321131462300302130ustar00rootroot00000000000000// Copyright 2015 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers import ( "fmt" "reflect" ) // HasSameTypeAs returns a matcher that matches values with exactly the same // type as the supplied prototype. func HasSameTypeAs(p interface{}) Matcher { expected := reflect.TypeOf(p) pred := func(c interface{}) error { actual := reflect.TypeOf(c) if actual != expected { return fmt.Errorf("which has type %v", actual) } return nil } return NewMatcher(pred, fmt.Sprintf("has type %v", expected)) } mongo-tools-r3.6.3/vendor/src/github.com/jacobsa/oglematchers/has_same_type_as_test.go000066400000000000000000000102541321131462300312540ustar00rootroot00000000000000// Copyright 2015 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers_test import ( "io" "testing" . "github.com/jacobsa/oglematchers" . "github.com/jacobsa/ogletest" ) func TestHasSameTypeAs(t *testing.T) { RunTests(t) } //////////////////////////////////////////////////////////////////////// // Boilerplate //////////////////////////////////////////////////////////////////////// type HasSameTypeAsTest struct { } func init() { RegisterTestSuite(&HasSameTypeAsTest{}) } //////////////////////////////////////////////////////////////////////// // Tests //////////////////////////////////////////////////////////////////////// func (t *HasSameTypeAsTest) CandidateIsLiteralNil() { matcher := HasSameTypeAs(nil) var err error // Description ExpectEq("has type ", matcher.Description()) // Literal nil err = matcher.Matches(nil) ExpectEq(nil, err) // nil in interface variable var r io.Reader err = matcher.Matches(r) ExpectEq(nil, err) // int err = matcher.Matches(17) AssertNe(nil, err) ExpectThat(err, Error(Equals("which has type int"))) // string err = matcher.Matches("") AssertNe(nil, err) ExpectThat(err, Error(Equals("which has type string"))) // nil map var m map[string]string err = matcher.Matches(m) AssertNe(nil, err) ExpectThat(err, Error(Equals("which has type map[string]string"))) // Non-nil map m = make(map[string]string) err = matcher.Matches(m) AssertNe(nil, err) ExpectThat(err, Error(Equals("which has type map[string]string"))) } func (t *HasSameTypeAsTest) CandidateIsNilMap() { var m map[string]string matcher := HasSameTypeAs(m) var err error // Description ExpectEq("has type map[string]string", matcher.Description()) // nil map m = nil err = matcher.Matches(m) ExpectEq(nil, err) // Non-nil map m = make(map[string]string) err = matcher.Matches(m) ExpectEq(nil, err) // Literal nil err = matcher.Matches(nil) AssertNe(nil, err) ExpectThat(err, Error(Equals("which has type "))) // int err = matcher.Matches(17) AssertNe(nil, err) ExpectThat(err, Error(Equals("which has type int"))) // string err = matcher.Matches("") AssertNe(nil, err) ExpectThat(err, Error(Equals("which has type string"))) } func (t *HasSameTypeAsTest) CandidateIsNilInInterfaceVariable() { var r io.Reader matcher := HasSameTypeAs(r) var err error // Description ExpectEq("has type ", matcher.Description()) // nil in interface variable r = nil err = matcher.Matches(r) ExpectEq(nil, err) // Literal nil err = matcher.Matches(nil) ExpectEq(nil, err) // int err = matcher.Matches(17) AssertNe(nil, err) ExpectThat(err, Error(Equals("which has type int"))) } func (t *HasSameTypeAsTest) CandidateIsString() { matcher := HasSameTypeAs("") var err error // Description ExpectEq("has type string", matcher.Description()) // string err = matcher.Matches("taco") ExpectEq(nil, err) // string alias type Foo string err = matcher.Matches(Foo("taco")) ExpectThat(err, Error(MatchesRegexp("which has type .*Foo"))) // Literal nil err = matcher.Matches(nil) AssertNe(nil, err) ExpectThat(err, Error(Equals("which has type "))) // int err = matcher.Matches(17) AssertNe(nil, err) ExpectThat(err, Error(Equals("which has type int"))) } func (t *HasSameTypeAsTest) CandidateIsStringAlias() { type Foo string matcher := HasSameTypeAs(Foo("")) var err error // Description ExpectThat(matcher.Description(), MatchesRegexp("has type .*Foo")) // string alias err = matcher.Matches(Foo("taco")) ExpectEq(nil, err) // string err = matcher.Matches("taco") ExpectThat(err, Error(Equals("which has type string"))) } mongo-tools-r3.6.3/vendor/src/github.com/jacobsa/oglematchers/has_substr.go000066400000000000000000000023761321131462300270740ustar00rootroot00000000000000// Copyright 2011 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers import ( "errors" "fmt" "reflect" "strings" ) // HasSubstr returns a matcher that matches strings containing s as a // substring. func HasSubstr(s string) Matcher { return NewMatcher( func(c interface{}) error { return hasSubstr(s, c) }, fmt.Sprintf("has substring \"%s\"", s)) } func hasSubstr(needle string, c interface{}) error { v := reflect.ValueOf(c) if v.Kind() != reflect.String { return NewFatalError("which is not a string") } // Perform the substring search. haystack := v.String() if strings.Contains(haystack, needle) { return nil } return errors.New("") } mongo-tools-r3.6.3/vendor/src/github.com/jacobsa/oglematchers/has_substr_test.go000066400000000000000000000047341321131462300301330ustar00rootroot00000000000000// Copyright 2011 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers_test import ( . "github.com/jacobsa/oglematchers" . "github.com/jacobsa/ogletest" ) //////////////////////////////////////////////////////////////////////// // Helpers //////////////////////////////////////////////////////////////////////// type HasSubstrTest struct { } func init() { RegisterTestSuite(&HasSubstrTest{}) } //////////////////////////////////////////////////////////////////////// // Tests //////////////////////////////////////////////////////////////////////// func (t *HasSubstrTest) Description() { matcher := HasSubstr("taco") ExpectThat(matcher.Description(), Equals("has substring \"taco\"")) } func (t *HasSubstrTest) CandidateIsNil() { matcher := HasSubstr("") err := matcher.Matches(nil) ExpectThat(err, Error(Equals("which is not a string"))) ExpectTrue(isFatal(err)) } func (t *HasSubstrTest) CandidateIsInteger() { matcher := HasSubstr("") err := matcher.Matches(17) ExpectThat(err, Error(Equals("which is not a string"))) ExpectTrue(isFatal(err)) } func (t *HasSubstrTest) CandidateIsByteSlice() { matcher := HasSubstr("") err := matcher.Matches([]byte{17}) ExpectThat(err, Error(Equals("which is not a string"))) ExpectTrue(isFatal(err)) } func (t *HasSubstrTest) CandidateDoesntHaveSubstring() { matcher := HasSubstr("taco") err := matcher.Matches("tac") ExpectThat(err, Error(Equals(""))) ExpectFalse(isFatal(err)) } func (t *HasSubstrTest) CandidateEqualsArg() { matcher := HasSubstr("taco") err := matcher.Matches("taco") ExpectThat(err, Equals(nil)) } func (t *HasSubstrTest) CandidateHasProperSubstring() { matcher := HasSubstr("taco") err := matcher.Matches("burritos and tacos") ExpectThat(err, Equals(nil)) } func (t *HasSubstrTest) EmptyStringIsAlwaysSubString() { matcher := HasSubstr("") err := matcher.Matches("asdf") ExpectThat(err, Equals(nil)) } mongo-tools-r3.6.3/vendor/src/github.com/jacobsa/oglematchers/identical_to.go000066400000000000000000000066031321131462300273520ustar00rootroot00000000000000// Copyright 2012 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers import ( "errors" "fmt" "reflect" ) // Is the type comparable according to the definition here? // // http://weekly.golang.org/doc/go_spec.html#Comparison_operators // func isComparable(t reflect.Type) bool { switch t.Kind() { case reflect.Array: return isComparable(t.Elem()) case reflect.Struct: for i := 0; i < t.NumField(); i++ { if !isComparable(t.Field(i).Type) { return false } } return true case reflect.Slice, reflect.Map, reflect.Func: return false } return true } // Should the supplied type be allowed as an argument to IdenticalTo? func isLegalForIdenticalTo(t reflect.Type) (bool, error) { // Allow the zero type. if t == nil { return true, nil } // Reference types are always okay; we compare pointers. switch t.Kind() { case reflect.Slice, reflect.Map, reflect.Func, reflect.Chan: return true, nil } // Reject other non-comparable types. if !isComparable(t) { return false, errors.New(fmt.Sprintf("%v is not comparable", t)) } return true, nil } // IdenticalTo(x) returns a matcher that matches values v with type identical // to x such that: // // 1. If v and x are of a reference type (slice, map, function, channel), then // they are either both nil or are references to the same object. // // 2. Otherwise, if v and x are not of a reference type but have a valid type, // then v == x. // // If v and x are both the invalid type (which results from the predeclared nil // value, or from nil interface variables), then the matcher is satisfied. // // This function will panic if x is of a value type that is not comparable. For // example, x cannot be an array of functions. func IdenticalTo(x interface{}) Matcher { t := reflect.TypeOf(x) // Reject illegal arguments. if ok, err := isLegalForIdenticalTo(t); !ok { panic("IdenticalTo: " + err.Error()) } return &identicalToMatcher{x} } type identicalToMatcher struct { x interface{} } func (m *identicalToMatcher) Description() string { t := reflect.TypeOf(m.x) return fmt.Sprintf("identical to <%v> %v", t, m.x) } func (m *identicalToMatcher) Matches(c interface{}) error { // Make sure the candidate's type is correct. t := reflect.TypeOf(m.x) if ct := reflect.TypeOf(c); t != ct { return NewFatalError(fmt.Sprintf("which is of type %v", ct)) } // Special case: two values of the invalid type are always identical. if t == nil { return nil } // Handle reference types. switch t.Kind() { case reflect.Slice, reflect.Map, reflect.Func, reflect.Chan: xv := reflect.ValueOf(m.x) cv := reflect.ValueOf(c) if xv.Pointer() == cv.Pointer() { return nil } return errors.New("which is not an identical reference") } // Are the values equal? if m.x == c { return nil } return errors.New("") } mongo-tools-r3.6.3/vendor/src/github.com/jacobsa/oglematchers/identical_to_test.go000066400000000000000000000476031321131462300304160ustar00rootroot00000000000000// Copyright 2012 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers_test import ( . "github.com/jacobsa/oglematchers" . "github.com/jacobsa/ogletest" "fmt" "io" "unsafe" ) //////////////////////////////////////////////////////////////////////// // Helpers //////////////////////////////////////////////////////////////////////// type IdenticalToTest struct { } func init() { RegisterTestSuite(&IdenticalToTest{}) } //////////////////////////////////////////////////////////////////////// // Tests //////////////////////////////////////////////////////////////////////// func (t *IdenticalToTest) TypesNotIdentical() { var m Matcher var err error type intAlias int // Type alias expected value m = IdenticalTo(intAlias(17)) err = m.Matches(int(17)) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type int"))) // Type alias candidate m = IdenticalTo(int(17)) err = m.Matches(intAlias(17)) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type oglematchers_test.intAlias"))) // int and uint m = IdenticalTo(int(17)) err = m.Matches(uint(17)) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type uint"))) } func (t *IdenticalToTest) PredeclaredNilIdentifier() { var m Matcher var err error // Nil literal m = IdenticalTo(nil) err = m.Matches(nil) ExpectEq(nil, err) // Zero interface var (which is the same as above since IdenticalTo takes an // interface{} as an arg) var nilReader io.Reader var nilWriter io.Writer m = IdenticalTo(nilReader) err = m.Matches(nilWriter) ExpectEq(nil, err) // Typed nil value. m = IdenticalTo(nil) err = m.Matches((chan int)(nil)) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type chan int"))) // Non-nil value. m = IdenticalTo(nil) err = m.Matches("taco") ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type string"))) } func (t *IdenticalToTest) Slices() { var m Matcher var err error // Nil expected value m = IdenticalTo(([]int)(nil)) ExpectEq("identical to <[]int> []", m.Description()) err = m.Matches(([]int)(nil)) ExpectEq(nil, err) err = m.Matches([]int{}) ExpectThat(err, Error(Equals("which is not an identical reference"))) // Non-nil expected value o1 := make([]int, 1) o2 := make([]int, 1) m = IdenticalTo(o1) ExpectEq(fmt.Sprintf("identical to <[]int> %v", o1), m.Description()) err = m.Matches(o1) ExpectEq(nil, err) err = m.Matches(o2) ExpectThat(err, Error(Equals("which is not an identical reference"))) } func (t *IdenticalToTest) Maps() { var m Matcher var err error // Nil expected value m = IdenticalTo((map[int]int)(nil)) ExpectEq("identical to map[]", m.Description()) err = m.Matches((map[int]int)(nil)) ExpectEq(nil, err) err = m.Matches(map[int]int{}) ExpectThat(err, Error(Equals("which is not an identical reference"))) // Non-nil expected value o1 := map[int]int{} o2 := map[int]int{} m = IdenticalTo(o1) ExpectEq(fmt.Sprintf("identical to %v", o1), m.Description()) err = m.Matches(o1) ExpectEq(nil, err) err = m.Matches(o2) ExpectThat(err, Error(Equals("which is not an identical reference"))) } func (t *IdenticalToTest) Functions() { var m Matcher var err error // Nil expected value m = IdenticalTo((func())(nil)) ExpectEq("identical to ", m.Description()) err = m.Matches((func())(nil)) ExpectEq(nil, err) err = m.Matches(func(){}) ExpectThat(err, Error(Equals("which is not an identical reference"))) // Non-nil expected value o1 := func() {} o2 := func() {} m = IdenticalTo(o1) ExpectEq(fmt.Sprintf("identical to %v", o1), m.Description()) err = m.Matches(o1) ExpectEq(nil, err) err = m.Matches(o2) ExpectThat(err, Error(Equals("which is not an identical reference"))) } func (t *IdenticalToTest) Channels() { var m Matcher var err error // Nil expected value m = IdenticalTo((chan int)(nil)) ExpectEq("identical to ", m.Description()) err = m.Matches((chan int)(nil)) ExpectEq(nil, err) err = m.Matches(make(chan int)) ExpectThat(err, Error(Equals("which is not an identical reference"))) // Non-nil expected value o1 := make(chan int) o2 := make(chan int) m = IdenticalTo(o1) ExpectEq(fmt.Sprintf("identical to %v", o1), m.Description()) err = m.Matches(o1) ExpectEq(nil, err) err = m.Matches(o2) ExpectThat(err, Error(Equals("which is not an identical reference"))) } func (t *IdenticalToTest) Bools() { var m Matcher var err error // false m = IdenticalTo(false) ExpectEq("identical to false", m.Description()) err = m.Matches(false) ExpectEq(nil, err) err = m.Matches(true) ExpectThat(err, Error(Equals(""))) // true m = IdenticalTo(true) ExpectEq("identical to true", m.Description()) err = m.Matches(false) ExpectThat(err, Error(Equals(""))) err = m.Matches(true) ExpectEq(nil, err) } func (t *IdenticalToTest) Ints() { var m Matcher var err error m = IdenticalTo(int(17)) ExpectEq("identical to 17", m.Description()) // Identical value err = m.Matches(int(17)) ExpectEq(nil, err) // Type alias type myType int err = m.Matches(myType(17)) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type oglematchers_test.myType"))) // Completely wrong type err = m.Matches(int32(17)) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type int32"))) } func (t *IdenticalToTest) Int8s() { var m Matcher var err error m = IdenticalTo(int8(17)) ExpectEq("identical to 17", m.Description()) // Identical value err = m.Matches(int8(17)) ExpectEq(nil, err) // Type alias type myType int8 err = m.Matches(myType(17)) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type oglematchers_test.myType"))) // Completely wrong type err = m.Matches(int32(17)) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type int32"))) } func (t *IdenticalToTest) Int16s() { var m Matcher var err error m = IdenticalTo(int16(17)) ExpectEq("identical to 17", m.Description()) // Identical value err = m.Matches(int16(17)) ExpectEq(nil, err) // Type alias type myType int16 err = m.Matches(myType(17)) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type oglematchers_test.myType"))) // Completely wrong type err = m.Matches(int32(17)) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type int32"))) } func (t *IdenticalToTest) Int32s() { var m Matcher var err error m = IdenticalTo(int32(17)) ExpectEq("identical to 17", m.Description()) // Identical value err = m.Matches(int32(17)) ExpectEq(nil, err) // Type alias type myType int32 err = m.Matches(myType(17)) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type oglematchers_test.myType"))) // Completely wrong type err = m.Matches(int16(17)) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type int16"))) } func (t *IdenticalToTest) Int64s() { var m Matcher var err error m = IdenticalTo(int64(17)) ExpectEq("identical to 17", m.Description()) // Identical value err = m.Matches(int64(17)) ExpectEq(nil, err) // Type alias type myType int64 err = m.Matches(myType(17)) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type oglematchers_test.myType"))) // Completely wrong type err = m.Matches(int32(17)) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type int32"))) } func (t *IdenticalToTest) Uints() { var m Matcher var err error m = IdenticalTo(uint(17)) ExpectEq("identical to 17", m.Description()) // Identical value err = m.Matches(uint(17)) ExpectEq(nil, err) // Type alias type myType uint err = m.Matches(myType(17)) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type oglematchers_test.myType"))) // Completely wrong type err = m.Matches(int32(17)) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type int32"))) } func (t *IdenticalToTest) Uint8s() { var m Matcher var err error m = IdenticalTo(uint8(17)) ExpectEq("identical to 17", m.Description()) // Identical value err = m.Matches(uint8(17)) ExpectEq(nil, err) // Type alias type myType uint8 err = m.Matches(myType(17)) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type oglematchers_test.myType"))) // Completely wrong type err = m.Matches(int32(17)) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type int32"))) } func (t *IdenticalToTest) Uint16s() { var m Matcher var err error m = IdenticalTo(uint16(17)) ExpectEq("identical to 17", m.Description()) // Identical value err = m.Matches(uint16(17)) ExpectEq(nil, err) // Type alias type myType uint16 err = m.Matches(myType(17)) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type oglematchers_test.myType"))) // Completely wrong type err = m.Matches(int32(17)) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type int32"))) } func (t *IdenticalToTest) Uint32s() { var m Matcher var err error m = IdenticalTo(uint32(17)) ExpectEq("identical to 17", m.Description()) // Identical value err = m.Matches(uint32(17)) ExpectEq(nil, err) // Type alias type myType uint32 err = m.Matches(myType(17)) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type oglematchers_test.myType"))) // Completely wrong type err = m.Matches(int32(17)) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type int32"))) } func (t *IdenticalToTest) Uint64s() { var m Matcher var err error m = IdenticalTo(uint64(17)) ExpectEq("identical to 17", m.Description()) // Identical value err = m.Matches(uint64(17)) ExpectEq(nil, err) // Type alias type myType uint64 err = m.Matches(myType(17)) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type oglematchers_test.myType"))) // Completely wrong type err = m.Matches(int32(17)) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type int32"))) } func (t *IdenticalToTest) Uintptrs() { var m Matcher var err error m = IdenticalTo(uintptr(17)) ExpectEq("identical to 17", m.Description()) // Identical value err = m.Matches(uintptr(17)) ExpectEq(nil, err) // Type alias type myType uintptr err = m.Matches(myType(17)) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type oglematchers_test.myType"))) // Completely wrong type err = m.Matches(int32(17)) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type int32"))) } func (t *IdenticalToTest) Float32s() { var m Matcher var err error m = IdenticalTo(float32(17)) ExpectEq("identical to 17", m.Description()) // Identical value err = m.Matches(float32(17)) ExpectEq(nil, err) // Type alias type myType float32 err = m.Matches(myType(17)) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type oglematchers_test.myType"))) // Completely wrong type err = m.Matches(int32(17)) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type int32"))) } func (t *IdenticalToTest) Float64s() { var m Matcher var err error m = IdenticalTo(float64(17)) ExpectEq("identical to 17", m.Description()) // Identical value err = m.Matches(float64(17)) ExpectEq(nil, err) // Type alias type myType float64 err = m.Matches(myType(17)) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type oglematchers_test.myType"))) // Completely wrong type err = m.Matches(int32(17)) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type int32"))) } func (t *IdenticalToTest) Complex64s() { var m Matcher var err error m = IdenticalTo(complex64(17)) ExpectEq("identical to (17+0i)", m.Description()) // Identical value err = m.Matches(complex64(17)) ExpectEq(nil, err) // Type alias type myType complex64 err = m.Matches(myType(17)) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type oglematchers_test.myType"))) // Completely wrong type err = m.Matches(int32(17)) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type int32"))) } func (t *IdenticalToTest) Complex128s() { var m Matcher var err error m = IdenticalTo(complex128(17)) ExpectEq("identical to (17+0i)", m.Description()) // Identical value err = m.Matches(complex128(17)) ExpectEq(nil, err) // Type alias type myType complex128 err = m.Matches(myType(17)) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type oglematchers_test.myType"))) // Completely wrong type err = m.Matches(int32(17)) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type int32"))) } func (t *IdenticalToTest) EmptyComparableArrays() { var m Matcher var err error m = IdenticalTo([0]int{}) ExpectEq("identical to <[0]int> []", m.Description()) // Identical value err = m.Matches([0]int{}) ExpectEq(nil, err) // Length too long err = m.Matches([1]int{17}) ExpectThat(err, Error(Equals("which is of type [1]int"))) // Element type alias type myType int err = m.Matches([0]myType{}) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type [0]oglematchers_test.myType"))) // Completely wrong element type err = m.Matches([0]int32{}) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type [0]int32"))) } func (t *IdenticalToTest) NonEmptyComparableArrays() { var m Matcher var err error m = IdenticalTo([2]int{17, 19}) ExpectEq("identical to <[2]int> [17 19]", m.Description()) // Identical value err = m.Matches([2]int{17, 19}) ExpectEq(nil, err) // Length too short err = m.Matches([1]int{17}) ExpectThat(err, Error(Equals("which is of type [1]int"))) // Length too long err = m.Matches([3]int{17, 19, 23}) ExpectThat(err, Error(Equals("which is of type [3]int"))) // First element different err = m.Matches([2]int{13, 19}) ExpectThat(err, Error(Equals(""))) // Second element different err = m.Matches([2]int{17, 23}) ExpectThat(err, Error(Equals(""))) // Element type alias type myType int err = m.Matches([2]myType{17, 19}) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type [2]oglematchers_test.myType"))) // Completely wrong element type err = m.Matches([2]int32{17, 19}) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type [2]int32"))) } func (t *IdenticalToTest) NonEmptyArraysOfComparableArrays() { var m Matcher var err error x := [2][2]int{ [2]int{17, 19}, [2]int{23, 29}, } m = IdenticalTo(x) ExpectEq("identical to <[2][2]int> [[17 19] [23 29]]", m.Description()) // Identical value err = m.Matches([2][2]int{[2]int{17, 19}, [2]int{23, 29}}) ExpectEq(nil, err) // Outer length too short err = m.Matches([1][2]int{[2]int{17, 19}}) ExpectThat(err, Error(Equals("which is of type [1][2]int"))) // Inner length too short err = m.Matches([2][1]int{[1]int{17}, [1]int{23}}) ExpectThat(err, Error(Equals("which is of type [2][1]int"))) // First element different err = m.Matches([2][2]int{[2]int{13, 19}, [2]int{23, 29}}) ExpectThat(err, Error(Equals(""))) // Element type alias type myType int err = m.Matches([2][2]myType{[2]myType{17, 19}, [2]myType{23, 29}}) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type [2][2]oglematchers_test.myType"))) } func (t *IdenticalToTest) NonComparableArrays() { x := [0]func(){} f := func() { IdenticalTo(x) } ExpectThat(f, Panics(HasSubstr("is not comparable"))) } func (t *IdenticalToTest) ArraysOfNonComparableArrays() { x := [0][0]func(){} f := func() { IdenticalTo(x) } ExpectThat(f, Panics(HasSubstr("is not comparable"))) } func (t *IdenticalToTest) Strings() { var m Matcher var err error m = IdenticalTo("taco") ExpectEq("identical to taco", m.Description()) // Identical value err = m.Matches("ta" + "co") ExpectEq(nil, err) // Type alias type myType string err = m.Matches(myType("taco")) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type oglematchers_test.myType"))) // Completely wrong type err = m.Matches(int32(17)) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type int32"))) } func (t *IdenticalToTest) ComparableStructs() { var m Matcher var err error type subStruct struct { i int } type myStruct struct { u uint s subStruct } x := myStruct{17, subStruct{19}} m = IdenticalTo(x) ExpectEq("identical to {17 {19}}", m.Description()) // Identical value err = m.Matches(myStruct{17, subStruct{19}}) ExpectEq(nil, err) // Wrong outer field err = m.Matches(myStruct{13, subStruct{19}}) ExpectThat(err, Error(Equals(""))) // Wrong inner field err = m.Matches(myStruct{17, subStruct{23}}) ExpectThat(err, Error(Equals(""))) // Type alias type myType myStruct err = m.Matches(myType{17, subStruct{19}}) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type oglematchers_test.myType"))) // Completely wrong type err = m.Matches(int32(17)) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type int32"))) } func (t *IdenticalToTest) NonComparableStructs() { type subStruct struct { s []int } type myStruct struct { u uint s subStruct } x := myStruct{17, subStruct{[]int{19}}} f := func() { IdenticalTo(x) } ExpectThat(f, Panics(AllOf(HasSubstr("IdenticalTo"), HasSubstr("comparable")))) } func (t *IdenticalToTest) NilUnsafePointer() { var m Matcher var err error x := unsafe.Pointer(nil) m = IdenticalTo(x) ExpectEq(fmt.Sprintf("identical to %v", x), m.Description()) // Identical value err = m.Matches(unsafe.Pointer(nil)) ExpectEq(nil, err) // Wrong value j := 17 err = m.Matches(unsafe.Pointer(&j)) ExpectThat(err, Error(Equals(""))) // Type alias type myType unsafe.Pointer err = m.Matches(myType(unsafe.Pointer(nil))) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type oglematchers_test.myType"))) // Completely wrong type err = m.Matches(int32(17)) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type int32"))) } func (t *IdenticalToTest) NonNilUnsafePointer() { var m Matcher var err error i := 17 x := unsafe.Pointer(&i) m = IdenticalTo(x) ExpectEq(fmt.Sprintf("identical to %v", x), m.Description()) // Identical value err = m.Matches(unsafe.Pointer(&i)) ExpectEq(nil, err) // Nil value err = m.Matches(unsafe.Pointer(nil)) ExpectThat(err, Error(Equals(""))) // Wrong value j := 17 err = m.Matches(unsafe.Pointer(&j)) ExpectThat(err, Error(Equals(""))) // Type alias type myType unsafe.Pointer err = m.Matches(myType(unsafe.Pointer(&i))) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type oglematchers_test.myType"))) // Completely wrong type err = m.Matches(int32(17)) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type int32"))) } func (t *IdenticalToTest) IntAlias() { var m Matcher var err error type intAlias int m = IdenticalTo(intAlias(17)) ExpectEq("identical to 17", m.Description()) // Identical value err = m.Matches(intAlias(17)) ExpectEq(nil, err) // Int err = m.Matches(int(17)) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type int"))) // Completely wrong type err = m.Matches(int32(17)) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type int32"))) } mongo-tools-r3.6.3/vendor/src/github.com/jacobsa/oglematchers/less_or_equal.go000066400000000000000000000027061321131462300275510ustar00rootroot00000000000000// Copyright 2011 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers import ( "fmt" "reflect" ) // LessOrEqual returns a matcher that matches integer, floating point, or // strings values v such that v <= x. Comparison is not defined between numeric // and string types, but is defined between all integer and floating point // types. // // x must itself be an integer, floating point, or string type; otherwise, // LessOrEqual will panic. func LessOrEqual(x interface{}) Matcher { desc := fmt.Sprintf("less than or equal to %v", x) // Special case: make it clear that strings are strings. if reflect.TypeOf(x).Kind() == reflect.String { desc = fmt.Sprintf("less than or equal to \"%s\"", x) } // Put LessThan last so that its error messages will be used in the event of // failure. return transformDescription(AnyOf(Equals(x), LessThan(x)), desc) } mongo-tools-r3.6.3/vendor/src/github.com/jacobsa/oglematchers/less_or_equal_test.go000066400000000000000000001112451321131462300306070ustar00rootroot00000000000000// Copyright 2011 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers_test import ( . "github.com/jacobsa/oglematchers" . "github.com/jacobsa/ogletest" "math" ) //////////////////////////////////////////////////////////////////////// // Helpers //////////////////////////////////////////////////////////////////////// type LessOrEqualTest struct { } func init() { RegisterTestSuite(&LessOrEqualTest{}) } type leTestCase struct { candidate interface{} expectedResult bool shouldBeFatal bool expectedError string } func (t *LessOrEqualTest) checkTestCases(matcher Matcher, cases []leTestCase) { for i, c := range cases { err := matcher.Matches(c.candidate) ExpectThat( (err == nil), Equals(c.expectedResult), "Case %d (candidate %v)", i, c.candidate) if err == nil { continue } _, isFatal := err.(*FatalError) ExpectEq( c.shouldBeFatal, isFatal, "Case %d (candidate %v)", i, c.candidate) ExpectThat( err, Error(Equals(c.expectedError)), "Case %d (candidate %v)", i, c.candidate) } } //////////////////////////////////////////////////////////////////////// // Integer literals //////////////////////////////////////////////////////////////////////// func (t *LessOrEqualTest) IntegerCandidateBadTypes() { matcher := LessOrEqual(int(-150)) cases := []leTestCase{ leTestCase{true, false, true, "which is not comparable"}, leTestCase{uintptr(17), false, true, "which is not comparable"}, leTestCase{complex64(-151), false, true, "which is not comparable"}, leTestCase{complex128(-151), false, true, "which is not comparable"}, leTestCase{[...]int{-151}, false, true, "which is not comparable"}, leTestCase{make(chan int), false, true, "which is not comparable"}, leTestCase{func() {}, false, true, "which is not comparable"}, leTestCase{map[int]int{}, false, true, "which is not comparable"}, leTestCase{&leTestCase{}, false, true, "which is not comparable"}, leTestCase{make([]int, 0), false, true, "which is not comparable"}, leTestCase{"-151", false, true, "which is not comparable"}, leTestCase{leTestCase{}, false, true, "which is not comparable"}, } t.checkTestCases(matcher, cases) } func (t *LessOrEqualTest) FloatCandidateBadTypes() { matcher := LessOrEqual(float32(-150)) cases := []leTestCase{ leTestCase{true, false, true, "which is not comparable"}, leTestCase{uintptr(17), false, true, "which is not comparable"}, leTestCase{complex64(-151), false, true, "which is not comparable"}, leTestCase{complex128(-151), false, true, "which is not comparable"}, leTestCase{[...]int{-151}, false, true, "which is not comparable"}, leTestCase{make(chan int), false, true, "which is not comparable"}, leTestCase{func() {}, false, true, "which is not comparable"}, leTestCase{map[int]int{}, false, true, "which is not comparable"}, leTestCase{&leTestCase{}, false, true, "which is not comparable"}, leTestCase{make([]int, 0), false, true, "which is not comparable"}, leTestCase{"-151", false, true, "which is not comparable"}, leTestCase{leTestCase{}, false, true, "which is not comparable"}, } t.checkTestCases(matcher, cases) } func (t *LessOrEqualTest) StringCandidateBadTypes() { matcher := LessOrEqual("17") cases := []leTestCase{ leTestCase{true, false, true, "which is not comparable"}, leTestCase{int(0), false, true, "which is not comparable"}, leTestCase{int8(0), false, true, "which is not comparable"}, leTestCase{int16(0), false, true, "which is not comparable"}, leTestCase{int32(0), false, true, "which is not comparable"}, leTestCase{int64(0), false, true, "which is not comparable"}, leTestCase{uint(0), false, true, "which is not comparable"}, leTestCase{uint8(0), false, true, "which is not comparable"}, leTestCase{uint16(0), false, true, "which is not comparable"}, leTestCase{uint32(0), false, true, "which is not comparable"}, leTestCase{uint64(0), false, true, "which is not comparable"}, leTestCase{uintptr(17), false, true, "which is not comparable"}, leTestCase{float32(0), false, true, "which is not comparable"}, leTestCase{float64(0), false, true, "which is not comparable"}, leTestCase{complex64(-151), false, true, "which is not comparable"}, leTestCase{complex128(-151), false, true, "which is not comparable"}, leTestCase{[...]int{-151}, false, true, "which is not comparable"}, leTestCase{make(chan int), false, true, "which is not comparable"}, leTestCase{func() {}, false, true, "which is not comparable"}, leTestCase{map[int]int{}, false, true, "which is not comparable"}, leTestCase{&leTestCase{}, false, true, "which is not comparable"}, leTestCase{make([]int, 0), false, true, "which is not comparable"}, leTestCase{leTestCase{}, false, true, "which is not comparable"}, } t.checkTestCases(matcher, cases) } func (t *LessOrEqualTest) BadArgument() { panicked := false defer func() { ExpectThat(panicked, Equals(true)) }() defer func() { if r := recover(); r != nil { panicked = true } }() LessOrEqual(complex128(0)) } //////////////////////////////////////////////////////////////////////// // Integer literals //////////////////////////////////////////////////////////////////////// func (t *LessOrEqualTest) NegativeIntegerLiteral() { matcher := LessOrEqual(-150) desc := matcher.Description() expectedDesc := "less than or equal to -150" ExpectThat(desc, Equals(expectedDesc)) cases := []leTestCase{ // Signed integers. leTestCase{-(1 << 30), true, false, ""}, leTestCase{-151, true, false, ""}, leTestCase{-150, true, false, ""}, leTestCase{-149, false, false, ""}, leTestCase{0, false, false, ""}, leTestCase{17, false, false, ""}, leTestCase{int(-(1 << 30)), true, false, ""}, leTestCase{int(-151), true, false, ""}, leTestCase{int(-150), true, false, ""}, leTestCase{int(-149), false, false, ""}, leTestCase{int(0), false, false, ""}, leTestCase{int(17), false, false, ""}, leTestCase{int8(-127), false, false, ""}, leTestCase{int8(0), false, false, ""}, leTestCase{int8(17), false, false, ""}, leTestCase{int16(-(1 << 14)), true, false, ""}, leTestCase{int16(-151), true, false, ""}, leTestCase{int16(-150), true, false, ""}, leTestCase{int16(-149), false, false, ""}, leTestCase{int16(0), false, false, ""}, leTestCase{int16(17), false, false, ""}, leTestCase{int32(-(1 << 30)), true, false, ""}, leTestCase{int32(-151), true, false, ""}, leTestCase{int32(-150), true, false, ""}, leTestCase{int32(-149), false, false, ""}, leTestCase{int32(0), false, false, ""}, leTestCase{int32(17), false, false, ""}, leTestCase{int64(-(1 << 30)), true, false, ""}, leTestCase{int64(-151), true, false, ""}, leTestCase{int64(-150), true, false, ""}, leTestCase{int64(-149), false, false, ""}, leTestCase{int64(0), false, false, ""}, leTestCase{int64(17), false, false, ""}, // Unsigned integers. leTestCase{uint((1 << 32) - 151), false, false, ""}, leTestCase{uint(0), false, false, ""}, leTestCase{uint(17), false, false, ""}, leTestCase{uint8(0), false, false, ""}, leTestCase{uint8(17), false, false, ""}, leTestCase{uint8(253), false, false, ""}, leTestCase{uint16((1 << 16) - 151), false, false, ""}, leTestCase{uint16(0), false, false, ""}, leTestCase{uint16(17), false, false, ""}, leTestCase{uint32((1 << 32) - 151), false, false, ""}, leTestCase{uint32(0), false, false, ""}, leTestCase{uint32(17), false, false, ""}, leTestCase{uint64((1 << 64) - 151), false, false, ""}, leTestCase{uint64(0), false, false, ""}, leTestCase{uint64(17), false, false, ""}, // Floating point. leTestCase{float32(-(1 << 30)), true, false, ""}, leTestCase{float32(-151), true, false, ""}, leTestCase{float32(-150.1), true, false, ""}, leTestCase{float32(-150), true, false, ""}, leTestCase{float32(-149.9), false, false, ""}, leTestCase{float32(0), false, false, ""}, leTestCase{float32(17), false, false, ""}, leTestCase{float32(160), false, false, ""}, leTestCase{float64(-(1 << 30)), true, false, ""}, leTestCase{float64(-151), true, false, ""}, leTestCase{float64(-150.1), true, false, ""}, leTestCase{float64(-150), true, false, ""}, leTestCase{float64(-149.9), false, false, ""}, leTestCase{float64(0), false, false, ""}, leTestCase{float64(17), false, false, ""}, leTestCase{float64(160), false, false, ""}, } t.checkTestCases(matcher, cases) } func (t *LessOrEqualTest) ZeroIntegerLiteral() { matcher := LessOrEqual(0) desc := matcher.Description() expectedDesc := "less than or equal to 0" ExpectThat(desc, Equals(expectedDesc)) cases := []leTestCase{ // Signed integers. leTestCase{-(1 << 30), true, false, ""}, leTestCase{-1, true, false, ""}, leTestCase{0, true, false, ""}, leTestCase{1, false, false, ""}, leTestCase{17, false, false, ""}, leTestCase{(1 << 30), false, false, ""}, leTestCase{int(-(1 << 30)), true, false, ""}, leTestCase{int(-1), true, false, ""}, leTestCase{int(0), true, false, ""}, leTestCase{int(1), false, false, ""}, leTestCase{int(17), false, false, ""}, leTestCase{int8(-1), true, false, ""}, leTestCase{int8(0), true, false, ""}, leTestCase{int8(1), false, false, ""}, leTestCase{int16(-(1 << 14)), true, false, ""}, leTestCase{int16(-1), true, false, ""}, leTestCase{int16(0), true, false, ""}, leTestCase{int16(1), false, false, ""}, leTestCase{int16(17), false, false, ""}, leTestCase{int32(-(1 << 30)), true, false, ""}, leTestCase{int32(-1), true, false, ""}, leTestCase{int32(0), true, false, ""}, leTestCase{int32(1), false, false, ""}, leTestCase{int32(17), false, false, ""}, leTestCase{int64(-(1 << 30)), true, false, ""}, leTestCase{int64(-1), true, false, ""}, leTestCase{int64(0), true, false, ""}, leTestCase{int64(1), false, false, ""}, leTestCase{int64(17), false, false, ""}, // Unsigned integers. leTestCase{uint((1 << 32) - 1), false, false, ""}, leTestCase{uint(0), true, false, ""}, leTestCase{uint(1), false, false, ""}, leTestCase{uint(17), false, false, ""}, leTestCase{uint8(0), true, false, ""}, leTestCase{uint8(1), false, false, ""}, leTestCase{uint8(17), false, false, ""}, leTestCase{uint8(253), false, false, ""}, leTestCase{uint16((1 << 16) - 1), false, false, ""}, leTestCase{uint16(0), true, false, ""}, leTestCase{uint16(1), false, false, ""}, leTestCase{uint16(17), false, false, ""}, leTestCase{uint32((1 << 32) - 1), false, false, ""}, leTestCase{uint32(0), true, false, ""}, leTestCase{uint32(1), false, false, ""}, leTestCase{uint32(17), false, false, ""}, leTestCase{uint64((1 << 64) - 1), false, false, ""}, leTestCase{uint64(0), true, false, ""}, leTestCase{uint64(1), false, false, ""}, leTestCase{uint64(17), false, false, ""}, // Floating point. leTestCase{float32(-(1 << 30)), true, false, ""}, leTestCase{float32(-1), true, false, ""}, leTestCase{float32(-0.1), true, false, ""}, leTestCase{float32(-0.0), true, false, ""}, leTestCase{float32(0), true, false, ""}, leTestCase{float32(0.1), false, false, ""}, leTestCase{float32(17), false, false, ""}, leTestCase{float32(160), false, false, ""}, leTestCase{float64(-(1 << 30)), true, false, ""}, leTestCase{float64(-1), true, false, ""}, leTestCase{float64(-0.1), true, false, ""}, leTestCase{float64(-0), true, false, ""}, leTestCase{float64(0), true, false, ""}, leTestCase{float64(0.1), false, false, ""}, leTestCase{float64(17), false, false, ""}, leTestCase{float64(160), false, false, ""}, } t.checkTestCases(matcher, cases) } func (t *LessOrEqualTest) PositiveIntegerLiteral() { matcher := LessOrEqual(150) desc := matcher.Description() expectedDesc := "less than or equal to 150" ExpectThat(desc, Equals(expectedDesc)) cases := []leTestCase{ // Signed integers. leTestCase{-1, true, false, ""}, leTestCase{149, true, false, ""}, leTestCase{150, true, false, ""}, leTestCase{151, false, false, ""}, leTestCase{int(-1), true, false, ""}, leTestCase{int(149), true, false, ""}, leTestCase{int(150), true, false, ""}, leTestCase{int(151), false, false, ""}, leTestCase{int8(-1), true, false, ""}, leTestCase{int8(0), true, false, ""}, leTestCase{int8(17), true, false, ""}, leTestCase{int8(127), true, false, ""}, leTestCase{int16(-1), true, false, ""}, leTestCase{int16(149), true, false, ""}, leTestCase{int16(150), true, false, ""}, leTestCase{int16(151), false, false, ""}, leTestCase{int32(-1), true, false, ""}, leTestCase{int32(149), true, false, ""}, leTestCase{int32(150), true, false, ""}, leTestCase{int32(151), false, false, ""}, leTestCase{int64(-1), true, false, ""}, leTestCase{int64(149), true, false, ""}, leTestCase{int64(150), true, false, ""}, leTestCase{int64(151), false, false, ""}, // Unsigned integers. leTestCase{uint(0), true, false, ""}, leTestCase{uint(149), true, false, ""}, leTestCase{uint(150), true, false, ""}, leTestCase{uint(151), false, false, ""}, leTestCase{uint8(0), true, false, ""}, leTestCase{uint8(127), true, false, ""}, leTestCase{uint16(0), true, false, ""}, leTestCase{uint16(149), true, false, ""}, leTestCase{uint16(150), true, false, ""}, leTestCase{uint16(151), false, false, ""}, leTestCase{uint32(0), true, false, ""}, leTestCase{uint32(149), true, false, ""}, leTestCase{uint32(150), true, false, ""}, leTestCase{uint32(151), false, false, ""}, leTestCase{uint64(0), true, false, ""}, leTestCase{uint64(149), true, false, ""}, leTestCase{uint64(150), true, false, ""}, leTestCase{uint64(151), false, false, ""}, // Floating point. leTestCase{float32(-1), true, false, ""}, leTestCase{float32(149), true, false, ""}, leTestCase{float32(149.9), true, false, ""}, leTestCase{float32(150), true, false, ""}, leTestCase{float32(150.1), false, false, ""}, leTestCase{float32(151), false, false, ""}, leTestCase{float64(-1), true, false, ""}, leTestCase{float64(149), true, false, ""}, leTestCase{float64(149.9), true, false, ""}, leTestCase{float64(150), true, false, ""}, leTestCase{float64(150.1), false, false, ""}, leTestCase{float64(151), false, false, ""}, } t.checkTestCases(matcher, cases) } //////////////////////////////////////////////////////////////////////// // Float literals //////////////////////////////////////////////////////////////////////// func (t *LessOrEqualTest) NegativeFloatLiteral() { matcher := LessOrEqual(-150.1) desc := matcher.Description() expectedDesc := "less than or equal to -150.1" ExpectThat(desc, Equals(expectedDesc)) cases := []leTestCase{ // Signed integers. leTestCase{-(1 << 30), true, false, ""}, leTestCase{-151, true, false, ""}, leTestCase{-150.1, true, false, ""}, leTestCase{-150, false, false, ""}, leTestCase{-149, false, false, ""}, leTestCase{0, false, false, ""}, leTestCase{17, false, false, ""}, leTestCase{int(-(1 << 30)), true, false, ""}, leTestCase{int(-151), true, false, ""}, leTestCase{int(-150), false, false, ""}, leTestCase{int(-149), false, false, ""}, leTestCase{int(0), false, false, ""}, leTestCase{int(17), false, false, ""}, leTestCase{int8(-127), false, false, ""}, leTestCase{int8(0), false, false, ""}, leTestCase{int8(17), false, false, ""}, leTestCase{int16(-(1 << 14)), true, false, ""}, leTestCase{int16(-151), true, false, ""}, leTestCase{int16(-150), false, false, ""}, leTestCase{int16(-149), false, false, ""}, leTestCase{int16(0), false, false, ""}, leTestCase{int16(17), false, false, ""}, leTestCase{int32(-(1 << 30)), true, false, ""}, leTestCase{int32(-151), true, false, ""}, leTestCase{int32(-150), false, false, ""}, leTestCase{int32(-149), false, false, ""}, leTestCase{int32(0), false, false, ""}, leTestCase{int32(17), false, false, ""}, leTestCase{int64(-(1 << 30)), true, false, ""}, leTestCase{int64(-151), true, false, ""}, leTestCase{int64(-150), false, false, ""}, leTestCase{int64(-149), false, false, ""}, leTestCase{int64(0), false, false, ""}, leTestCase{int64(17), false, false, ""}, // Unsigned integers. leTestCase{uint((1 << 32) - 151), false, false, ""}, leTestCase{uint(0), false, false, ""}, leTestCase{uint(17), false, false, ""}, leTestCase{uint8(0), false, false, ""}, leTestCase{uint8(17), false, false, ""}, leTestCase{uint8(253), false, false, ""}, leTestCase{uint16((1 << 16) - 151), false, false, ""}, leTestCase{uint16(0), false, false, ""}, leTestCase{uint16(17), false, false, ""}, leTestCase{uint32((1 << 32) - 151), false, false, ""}, leTestCase{uint32(0), false, false, ""}, leTestCase{uint32(17), false, false, ""}, leTestCase{uint64((1 << 64) - 151), false, false, ""}, leTestCase{uint64(0), false, false, ""}, leTestCase{uint64(17), false, false, ""}, // Floating point. leTestCase{float32(-(1 << 30)), true, false, ""}, leTestCase{float32(-151), true, false, ""}, leTestCase{float32(-150.2), true, false, ""}, leTestCase{float32(-150.1), true, false, ""}, leTestCase{float32(-150), false, false, ""}, leTestCase{float32(0), false, false, ""}, leTestCase{float32(17), false, false, ""}, leTestCase{float32(160), false, false, ""}, leTestCase{float64(-(1 << 30)), true, false, ""}, leTestCase{float64(-151), true, false, ""}, leTestCase{float64(-150.2), true, false, ""}, leTestCase{float64(-150.1), true, false, ""}, leTestCase{float64(-150), false, false, ""}, leTestCase{float64(0), false, false, ""}, leTestCase{float64(17), false, false, ""}, leTestCase{float64(160), false, false, ""}, } t.checkTestCases(matcher, cases) } func (t *LessOrEqualTest) PositiveFloatLiteral() { matcher := LessOrEqual(149.9) desc := matcher.Description() expectedDesc := "less than or equal to 149.9" ExpectThat(desc, Equals(expectedDesc)) cases := []leTestCase{ // Signed integers. leTestCase{-1, true, false, ""}, leTestCase{149, true, false, ""}, leTestCase{149.9, true, false, ""}, leTestCase{150, false, false, ""}, leTestCase{151, false, false, ""}, leTestCase{int(-1), true, false, ""}, leTestCase{int(149), true, false, ""}, leTestCase{int(150), false, false, ""}, leTestCase{int(151), false, false, ""}, leTestCase{int8(-1), true, false, ""}, leTestCase{int8(0), true, false, ""}, leTestCase{int8(17), true, false, ""}, leTestCase{int8(127), true, false, ""}, leTestCase{int16(-1), true, false, ""}, leTestCase{int16(149), true, false, ""}, leTestCase{int16(150), false, false, ""}, leTestCase{int16(151), false, false, ""}, leTestCase{int32(-1), true, false, ""}, leTestCase{int32(149), true, false, ""}, leTestCase{int32(150), false, false, ""}, leTestCase{int32(151), false, false, ""}, leTestCase{int64(-1), true, false, ""}, leTestCase{int64(149), true, false, ""}, leTestCase{int64(150), false, false, ""}, leTestCase{int64(151), false, false, ""}, // Unsigned integers. leTestCase{uint(0), true, false, ""}, leTestCase{uint(149), true, false, ""}, leTestCase{uint(150), false, false, ""}, leTestCase{uint(151), false, false, ""}, leTestCase{uint8(0), true, false, ""}, leTestCase{uint8(127), true, false, ""}, leTestCase{uint16(0), true, false, ""}, leTestCase{uint16(149), true, false, ""}, leTestCase{uint16(150), false, false, ""}, leTestCase{uint16(151), false, false, ""}, leTestCase{uint32(0), true, false, ""}, leTestCase{uint32(149), true, false, ""}, leTestCase{uint32(150), false, false, ""}, leTestCase{uint32(151), false, false, ""}, leTestCase{uint64(0), true, false, ""}, leTestCase{uint64(149), true, false, ""}, leTestCase{uint64(150), false, false, ""}, leTestCase{uint64(151), false, false, ""}, // Floating point. leTestCase{float32(-1), true, false, ""}, leTestCase{float32(149), true, false, ""}, leTestCase{float32(149.8), true, false, ""}, leTestCase{float32(149.9), true, false, ""}, leTestCase{float32(150), false, false, ""}, leTestCase{float32(151), false, false, ""}, leTestCase{float64(-1), true, false, ""}, leTestCase{float64(149), true, false, ""}, leTestCase{float64(149.8), true, false, ""}, leTestCase{float64(149.9), true, false, ""}, leTestCase{float64(150), false, false, ""}, leTestCase{float64(151), false, false, ""}, } t.checkTestCases(matcher, cases) } //////////////////////////////////////////////////////////////////////// // Subtle cases //////////////////////////////////////////////////////////////////////// func (t *LessOrEqualTest) Int64NotExactlyRepresentableBySinglePrecision() { // Single-precision floats don't have enough bits to represent the integers // near this one distinctly, so [2^25-1, 2^25+2] all receive the same value // and should be treated as equivalent when floats are in the mix. const kTwoTo25 = 1 << 25 matcher := LessOrEqual(int64(kTwoTo25 + 1)) desc := matcher.Description() expectedDesc := "less than or equal to 33554433" ExpectThat(desc, Equals(expectedDesc)) cases := []leTestCase{ // Signed integers. leTestCase{-1, true, false, ""}, leTestCase{kTwoTo25 + 0, true, false, ""}, leTestCase{kTwoTo25 + 1, true, false, ""}, leTestCase{kTwoTo25 + 2, false, false, ""}, leTestCase{int(-1), true, false, ""}, leTestCase{int(kTwoTo25 + 0), true, false, ""}, leTestCase{int(kTwoTo25 + 1), true, false, ""}, leTestCase{int(kTwoTo25 + 2), false, false, ""}, leTestCase{int8(-1), true, false, ""}, leTestCase{int8(127), true, false, ""}, leTestCase{int16(-1), true, false, ""}, leTestCase{int16(0), true, false, ""}, leTestCase{int16(32767), true, false, ""}, leTestCase{int32(-1), true, false, ""}, leTestCase{int32(kTwoTo25 + 0), true, false, ""}, leTestCase{int32(kTwoTo25 + 1), true, false, ""}, leTestCase{int32(kTwoTo25 + 2), false, false, ""}, leTestCase{int64(-1), true, false, ""}, leTestCase{int64(kTwoTo25 + 0), true, false, ""}, leTestCase{int64(kTwoTo25 + 1), true, false, ""}, leTestCase{int64(kTwoTo25 + 2), false, false, ""}, // Unsigned integers. leTestCase{uint(0), true, false, ""}, leTestCase{uint(kTwoTo25 + 0), true, false, ""}, leTestCase{uint(kTwoTo25 + 1), true, false, ""}, leTestCase{uint(kTwoTo25 + 2), false, false, ""}, leTestCase{uint8(0), true, false, ""}, leTestCase{uint8(255), true, false, ""}, leTestCase{uint16(0), true, false, ""}, leTestCase{uint16(65535), true, false, ""}, leTestCase{uint32(0), true, false, ""}, leTestCase{uint32(kTwoTo25 + 0), true, false, ""}, leTestCase{uint32(kTwoTo25 + 1), true, false, ""}, leTestCase{uint32(kTwoTo25 + 2), false, false, ""}, leTestCase{uint64(0), true, false, ""}, leTestCase{uint64(kTwoTo25 + 0), true, false, ""}, leTestCase{uint64(kTwoTo25 + 1), true, false, ""}, leTestCase{uint64(kTwoTo25 + 2), false, false, ""}, // Floating point. leTestCase{float32(-1), true, false, ""}, leTestCase{float32(kTwoTo25 - 2), true, false, ""}, leTestCase{float32(kTwoTo25 - 1), true, false, ""}, leTestCase{float32(kTwoTo25 + 0), true, false, ""}, leTestCase{float32(kTwoTo25 + 1), true, false, ""}, leTestCase{float32(kTwoTo25 + 2), true, false, ""}, leTestCase{float32(kTwoTo25 + 3), false, false, ""}, leTestCase{float64(-1), true, false, ""}, leTestCase{float64(kTwoTo25 - 2), true, false, ""}, leTestCase{float64(kTwoTo25 - 1), true, false, ""}, leTestCase{float64(kTwoTo25 + 0), true, false, ""}, leTestCase{float64(kTwoTo25 + 1), true, false, ""}, leTestCase{float64(kTwoTo25 + 2), false, false, ""}, leTestCase{float64(kTwoTo25 + 3), false, false, ""}, } t.checkTestCases(matcher, cases) } func (t *LessOrEqualTest) Int64NotExactlyRepresentableByDoublePrecision() { // Double-precision floats don't have enough bits to represent the integers // near this one distinctly, so [2^54-1, 2^54+2] all receive the same value // and should be treated as equivalent when floats are in the mix. const kTwoTo54 = 1 << 54 matcher := LessOrEqual(int64(kTwoTo54 + 1)) desc := matcher.Description() expectedDesc := "less than or equal to 18014398509481985" ExpectThat(desc, Equals(expectedDesc)) cases := []leTestCase{ // Signed integers. leTestCase{-1, true, false, ""}, leTestCase{1 << 30, true, false, ""}, leTestCase{int(-1), true, false, ""}, leTestCase{int(math.MaxInt32), true, false, ""}, leTestCase{int8(-1), true, false, ""}, leTestCase{int8(127), true, false, ""}, leTestCase{int16(-1), true, false, ""}, leTestCase{int16(0), true, false, ""}, leTestCase{int16(32767), true, false, ""}, leTestCase{int32(-1), true, false, ""}, leTestCase{int32(math.MaxInt32), true, false, ""}, leTestCase{int64(-1), true, false, ""}, leTestCase{int64(kTwoTo54 - 1), true, false, ""}, leTestCase{int64(kTwoTo54 + 0), true, false, ""}, leTestCase{int64(kTwoTo54 + 1), true, false, ""}, leTestCase{int64(kTwoTo54 + 2), false, false, ""}, // Unsigned integers. leTestCase{uint(0), true, false, ""}, leTestCase{uint(math.MaxUint32), true, false, ""}, leTestCase{uint8(0), true, false, ""}, leTestCase{uint8(255), true, false, ""}, leTestCase{uint16(0), true, false, ""}, leTestCase{uint16(65535), true, false, ""}, leTestCase{uint32(0), true, false, ""}, leTestCase{uint32(math.MaxUint32), true, false, ""}, leTestCase{uint64(0), true, false, ""}, leTestCase{uint64(kTwoTo54 - 1), true, false, ""}, leTestCase{uint64(kTwoTo54 + 0), true, false, ""}, leTestCase{uint64(kTwoTo54 + 1), true, false, ""}, leTestCase{uint64(kTwoTo54 + 2), false, false, ""}, // Floating point. leTestCase{float64(-1), true, false, ""}, leTestCase{float64(kTwoTo54 - 2), true, false, ""}, leTestCase{float64(kTwoTo54 - 1), true, false, ""}, leTestCase{float64(kTwoTo54 + 0), true, false, ""}, leTestCase{float64(kTwoTo54 + 1), true, false, ""}, leTestCase{float64(kTwoTo54 + 2), true, false, ""}, leTestCase{float64(kTwoTo54 + 3), false, false, ""}, } t.checkTestCases(matcher, cases) } func (t *LessOrEqualTest) Uint64NotExactlyRepresentableBySinglePrecision() { // Single-precision floats don't have enough bits to represent the integers // near this one distinctly, so [2^25-1, 2^25+2] all receive the same value // and should be treated as equivalent when floats are in the mix. const kTwoTo25 = 1 << 25 matcher := LessOrEqual(uint64(kTwoTo25 + 1)) desc := matcher.Description() expectedDesc := "less than or equal to 33554433" ExpectThat(desc, Equals(expectedDesc)) cases := []leTestCase{ // Signed integers. leTestCase{-1, true, false, ""}, leTestCase{kTwoTo25 + 0, true, false, ""}, leTestCase{kTwoTo25 + 1, true, false, ""}, leTestCase{kTwoTo25 + 2, false, false, ""}, leTestCase{int(-1), true, false, ""}, leTestCase{int(kTwoTo25 + 0), true, false, ""}, leTestCase{int(kTwoTo25 + 1), true, false, ""}, leTestCase{int(kTwoTo25 + 2), false, false, ""}, leTestCase{int8(-1), true, false, ""}, leTestCase{int8(127), true, false, ""}, leTestCase{int16(-1), true, false, ""}, leTestCase{int16(0), true, false, ""}, leTestCase{int16(32767), true, false, ""}, leTestCase{int32(-1), true, false, ""}, leTestCase{int32(kTwoTo25 + 0), true, false, ""}, leTestCase{int32(kTwoTo25 + 1), true, false, ""}, leTestCase{int32(kTwoTo25 + 2), false, false, ""}, leTestCase{int64(-1), true, false, ""}, leTestCase{int64(kTwoTo25 + 0), true, false, ""}, leTestCase{int64(kTwoTo25 + 1), true, false, ""}, leTestCase{int64(kTwoTo25 + 2), false, false, ""}, // Unsigned integers. leTestCase{uint(0), true, false, ""}, leTestCase{uint(kTwoTo25 + 0), true, false, ""}, leTestCase{uint(kTwoTo25 + 1), true, false, ""}, leTestCase{uint(kTwoTo25 + 2), false, false, ""}, leTestCase{uint8(0), true, false, ""}, leTestCase{uint8(255), true, false, ""}, leTestCase{uint16(0), true, false, ""}, leTestCase{uint16(65535), true, false, ""}, leTestCase{uint32(0), true, false, ""}, leTestCase{uint32(kTwoTo25 + 0), true, false, ""}, leTestCase{uint32(kTwoTo25 + 1), true, false, ""}, leTestCase{uint32(kTwoTo25 + 2), false, false, ""}, leTestCase{uint64(0), true, false, ""}, leTestCase{uint64(kTwoTo25 + 0), true, false, ""}, leTestCase{uint64(kTwoTo25 + 1), true, false, ""}, leTestCase{uint64(kTwoTo25 + 2), false, false, ""}, // Floating point. leTestCase{float32(-1), true, false, ""}, leTestCase{float32(kTwoTo25 - 2), true, false, ""}, leTestCase{float32(kTwoTo25 - 1), true, false, ""}, leTestCase{float32(kTwoTo25 + 0), true, false, ""}, leTestCase{float32(kTwoTo25 + 1), true, false, ""}, leTestCase{float32(kTwoTo25 + 2), true, false, ""}, leTestCase{float32(kTwoTo25 + 3), false, false, ""}, leTestCase{float64(-1), true, false, ""}, leTestCase{float64(kTwoTo25 - 2), true, false, ""}, leTestCase{float64(kTwoTo25 - 1), true, false, ""}, leTestCase{float64(kTwoTo25 + 0), true, false, ""}, leTestCase{float64(kTwoTo25 + 1), true, false, ""}, leTestCase{float64(kTwoTo25 + 2), false, false, ""}, leTestCase{float64(kTwoTo25 + 3), false, false, ""}, } t.checkTestCases(matcher, cases) } func (t *LessOrEqualTest) Uint64NotExactlyRepresentableByDoublePrecision() { // Double-precision floats don't have enough bits to represent the integers // near this one distinctly, so [2^54-1, 2^54+2] all receive the same value // and should be treated as equivalent when floats are in the mix. const kTwoTo54 = 1 << 54 matcher := LessOrEqual(uint64(kTwoTo54 + 1)) desc := matcher.Description() expectedDesc := "less than or equal to 18014398509481985" ExpectThat(desc, Equals(expectedDesc)) cases := []leTestCase{ // Signed integers. leTestCase{-1, true, false, ""}, leTestCase{1 << 30, true, false, ""}, leTestCase{int(-1), true, false, ""}, leTestCase{int(math.MaxInt32), true, false, ""}, leTestCase{int8(-1), true, false, ""}, leTestCase{int8(127), true, false, ""}, leTestCase{int16(-1), true, false, ""}, leTestCase{int16(0), true, false, ""}, leTestCase{int16(32767), true, false, ""}, leTestCase{int32(-1), true, false, ""}, leTestCase{int32(math.MaxInt32), true, false, ""}, leTestCase{int64(-1), true, false, ""}, leTestCase{int64(kTwoTo54 - 1), true, false, ""}, leTestCase{int64(kTwoTo54 + 0), true, false, ""}, leTestCase{int64(kTwoTo54 + 1), true, false, ""}, leTestCase{int64(kTwoTo54 + 2), false, false, ""}, // Unsigned integers. leTestCase{uint(0), true, false, ""}, leTestCase{uint(math.MaxUint32), true, false, ""}, leTestCase{uint8(0), true, false, ""}, leTestCase{uint8(255), true, false, ""}, leTestCase{uint16(0), true, false, ""}, leTestCase{uint16(65535), true, false, ""}, leTestCase{uint32(0), true, false, ""}, leTestCase{uint32(math.MaxUint32), true, false, ""}, leTestCase{uint64(0), true, false, ""}, leTestCase{uint64(kTwoTo54 - 1), true, false, ""}, leTestCase{uint64(kTwoTo54 + 0), true, false, ""}, leTestCase{uint64(kTwoTo54 + 1), true, false, ""}, leTestCase{uint64(kTwoTo54 + 2), false, false, ""}, // Floating point. leTestCase{float64(-1), true, false, ""}, leTestCase{float64(kTwoTo54 - 2), true, false, ""}, leTestCase{float64(kTwoTo54 - 1), true, false, ""}, leTestCase{float64(kTwoTo54 + 0), true, false, ""}, leTestCase{float64(kTwoTo54 + 1), true, false, ""}, leTestCase{float64(kTwoTo54 + 2), true, false, ""}, leTestCase{float64(kTwoTo54 + 3), false, false, ""}, } t.checkTestCases(matcher, cases) } func (t *LessOrEqualTest) Float32AboveExactIntegerRange() { // Single-precision floats don't have enough bits to represent the integers // near this one distinctly, so [2^25-1, 2^25+2] all receive the same value // and should be treated as equivalent when floats are in the mix. const kTwoTo25 = 1 << 25 matcher := LessOrEqual(float32(kTwoTo25 + 1)) desc := matcher.Description() expectedDesc := "less than or equal to 3.3554432e+07" ExpectThat(desc, Equals(expectedDesc)) cases := []leTestCase{ // Signed integers. leTestCase{int64(-1), true, false, ""}, leTestCase{int64(kTwoTo25 - 2), true, false, ""}, leTestCase{int64(kTwoTo25 - 1), true, false, ""}, leTestCase{int64(kTwoTo25 + 0), true, false, ""}, leTestCase{int64(kTwoTo25 + 1), true, false, ""}, leTestCase{int64(kTwoTo25 + 2), true, false, ""}, leTestCase{int64(kTwoTo25 + 3), false, false, ""}, // Unsigned integers. leTestCase{uint64(0), true, false, ""}, leTestCase{uint64(kTwoTo25 - 2), true, false, ""}, leTestCase{uint64(kTwoTo25 - 1), true, false, ""}, leTestCase{uint64(kTwoTo25 + 0), true, false, ""}, leTestCase{uint64(kTwoTo25 + 1), true, false, ""}, leTestCase{uint64(kTwoTo25 + 2), true, false, ""}, leTestCase{uint64(kTwoTo25 + 3), false, false, ""}, // Floating point. leTestCase{float32(-1), true, false, ""}, leTestCase{float32(kTwoTo25 - 2), true, false, ""}, leTestCase{float32(kTwoTo25 - 1), true, false, ""}, leTestCase{float32(kTwoTo25 + 0), true, false, ""}, leTestCase{float32(kTwoTo25 + 1), true, false, ""}, leTestCase{float32(kTwoTo25 + 2), true, false, ""}, leTestCase{float32(kTwoTo25 + 3), false, false, ""}, leTestCase{float64(-1), true, false, ""}, leTestCase{float64(kTwoTo25 - 2), true, false, ""}, leTestCase{float64(kTwoTo25 - 1), true, false, ""}, leTestCase{float64(kTwoTo25 + 0), true, false, ""}, leTestCase{float64(kTwoTo25 + 1), true, false, ""}, leTestCase{float64(kTwoTo25 + 2), true, false, ""}, leTestCase{float64(kTwoTo25 + 3), false, false, ""}, } t.checkTestCases(matcher, cases) } func (t *LessOrEqualTest) Float64AboveExactIntegerRange() { // Double-precision floats don't have enough bits to represent the integers // near this one distinctly, so [2^54-1, 2^54+2] all receive the same value // and should be treated as equivalent when floats are in the mix. const kTwoTo54 = 1 << 54 matcher := LessOrEqual(float64(kTwoTo54 + 1)) desc := matcher.Description() expectedDesc := "less than or equal to 1.8014398509481984e+16" ExpectThat(desc, Equals(expectedDesc)) cases := []leTestCase{ // Signed integers. leTestCase{int64(-1), true, false, ""}, leTestCase{int64(kTwoTo54 - 2), true, false, ""}, leTestCase{int64(kTwoTo54 - 1), true, false, ""}, leTestCase{int64(kTwoTo54 + 0), true, false, ""}, leTestCase{int64(kTwoTo54 + 1), true, false, ""}, leTestCase{int64(kTwoTo54 + 2), true, false, ""}, leTestCase{int64(kTwoTo54 + 3), false, false, ""}, // Unsigned integers. leTestCase{uint64(0), true, false, ""}, leTestCase{uint64(kTwoTo54 - 2), true, false, ""}, leTestCase{uint64(kTwoTo54 - 1), true, false, ""}, leTestCase{uint64(kTwoTo54 + 0), true, false, ""}, leTestCase{uint64(kTwoTo54 + 1), true, false, ""}, leTestCase{uint64(kTwoTo54 + 2), true, false, ""}, leTestCase{uint64(kTwoTo54 + 3), false, false, ""}, // Floating point. leTestCase{float64(-1), true, false, ""}, leTestCase{float64(kTwoTo54 - 2), true, false, ""}, leTestCase{float64(kTwoTo54 - 1), true, false, ""}, leTestCase{float64(kTwoTo54 + 0), true, false, ""}, leTestCase{float64(kTwoTo54 + 1), true, false, ""}, leTestCase{float64(kTwoTo54 + 2), true, false, ""}, leTestCase{float64(kTwoTo54 + 3), false, false, ""}, } t.checkTestCases(matcher, cases) } //////////////////////////////////////////////////////////////////////// // String literals //////////////////////////////////////////////////////////////////////// func (t *LessOrEqualTest) EmptyString() { matcher := LessOrEqual("") desc := matcher.Description() expectedDesc := "less than or equal to \"\"" ExpectThat(desc, Equals(expectedDesc)) cases := []leTestCase{ leTestCase{"", true, false, ""}, leTestCase{"\x00", false, false, ""}, leTestCase{"a", false, false, ""}, leTestCase{"foo", false, false, ""}, } t.checkTestCases(matcher, cases) } func (t *LessOrEqualTest) SingleNullByte() { matcher := LessOrEqual("\x00") desc := matcher.Description() expectedDesc := "less than or equal to \"\x00\"" ExpectThat(desc, Equals(expectedDesc)) cases := []leTestCase{ leTestCase{"", true, false, ""}, leTestCase{"\x00", true, false, ""}, leTestCase{"\x00\x00", false, false, ""}, leTestCase{"a", false, false, ""}, leTestCase{"foo", false, false, ""}, } t.checkTestCases(matcher, cases) } func (t *LessOrEqualTest) LongerString() { matcher := LessOrEqual("foo\x00") desc := matcher.Description() expectedDesc := "less than or equal to \"foo\x00\"" ExpectThat(desc, Equals(expectedDesc)) cases := []leTestCase{ leTestCase{"", true, false, ""}, leTestCase{"\x00", true, false, ""}, leTestCase{"bar", true, false, ""}, leTestCase{"foo", true, false, ""}, leTestCase{"foo\x00", true, false, ""}, leTestCase{"foo\x00\x00", false, false, ""}, leTestCase{"fooa", false, false, ""}, leTestCase{"qux", false, false, ""}, } t.checkTestCases(matcher, cases) } mongo-tools-r3.6.3/vendor/src/github.com/jacobsa/oglematchers/less_than.go000066400000000000000000000071141321131462300266720ustar00rootroot00000000000000// Copyright 2011 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers import ( "errors" "fmt" "math" "reflect" ) // LessThan returns a matcher that matches integer, floating point, or strings // values v such that v < x. Comparison is not defined between numeric and // string types, but is defined between all integer and floating point types. // // x must itself be an integer, floating point, or string type; otherwise, // LessThan will panic. func LessThan(x interface{}) Matcher { v := reflect.ValueOf(x) kind := v.Kind() switch { case isInteger(v): case isFloat(v): case kind == reflect.String: default: panic(fmt.Sprintf("LessThan: unexpected kind %v", kind)) } return &lessThanMatcher{v} } type lessThanMatcher struct { limit reflect.Value } func (m *lessThanMatcher) Description() string { // Special case: make it clear that strings are strings. if m.limit.Kind() == reflect.String { return fmt.Sprintf("less than \"%s\"", m.limit.String()) } return fmt.Sprintf("less than %v", m.limit.Interface()) } func compareIntegers(v1, v2 reflect.Value) (err error) { err = errors.New("") switch { case isSignedInteger(v1) && isSignedInteger(v2): if v1.Int() < v2.Int() { err = nil } return case isSignedInteger(v1) && isUnsignedInteger(v2): if v1.Int() < 0 || uint64(v1.Int()) < v2.Uint() { err = nil } return case isUnsignedInteger(v1) && isSignedInteger(v2): if v1.Uint() <= math.MaxInt64 && int64(v1.Uint()) < v2.Int() { err = nil } return case isUnsignedInteger(v1) && isUnsignedInteger(v2): if v1.Uint() < v2.Uint() { err = nil } return } panic(fmt.Sprintf("compareIntegers: %v %v", v1, v2)) } func getFloat(v reflect.Value) float64 { switch { case isSignedInteger(v): return float64(v.Int()) case isUnsignedInteger(v): return float64(v.Uint()) case isFloat(v): return v.Float() } panic(fmt.Sprintf("getFloat: %v", v)) } func (m *lessThanMatcher) Matches(c interface{}) (err error) { v1 := reflect.ValueOf(c) v2 := m.limit err = errors.New("") // Handle strings as a special case. if v1.Kind() == reflect.String && v2.Kind() == reflect.String { if v1.String() < v2.String() { err = nil } return } // If we get here, we require that we are dealing with integers or floats. v1Legal := isInteger(v1) || isFloat(v1) v2Legal := isInteger(v2) || isFloat(v2) if !v1Legal || !v2Legal { err = NewFatalError("which is not comparable") return } // Handle the various comparison cases. switch { // Both integers case isInteger(v1) && isInteger(v2): return compareIntegers(v1, v2) // At least one float32 case v1.Kind() == reflect.Float32 || v2.Kind() == reflect.Float32: if float32(getFloat(v1)) < float32(getFloat(v2)) { err = nil } return // At least one float64 case v1.Kind() == reflect.Float64 || v2.Kind() == reflect.Float64: if getFloat(v1) < getFloat(v2) { err = nil } return } // We shouldn't get here. panic(fmt.Sprintf("lessThanMatcher.Matches: Shouldn't get here: %v %v", v1, v2)) } mongo-tools-r3.6.3/vendor/src/github.com/jacobsa/oglematchers/less_than_test.go000066400000000000000000001072261321131462300277360ustar00rootroot00000000000000// Copyright 2011 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers_test import ( . "github.com/jacobsa/oglematchers" . "github.com/jacobsa/ogletest" "math" ) //////////////////////////////////////////////////////////////////////// // Helpers //////////////////////////////////////////////////////////////////////// type LessThanTest struct { } func init() { RegisterTestSuite(&LessThanTest{}) } type ltTestCase struct { candidate interface{} expectedResult bool shouldBeFatal bool expectedError string } func (t *LessThanTest) checkTestCases(matcher Matcher, cases []ltTestCase) { for i, c := range cases { err := matcher.Matches(c.candidate) ExpectThat( (err == nil), Equals(c.expectedResult), "Case %d (candidate %v)", i, c.candidate) if err == nil { continue } _, isFatal := err.(*FatalError) ExpectEq( c.shouldBeFatal, isFatal, "Case %d (candidate %v)", i, c.candidate) ExpectThat( err, Error(Equals(c.expectedError)), "Case %d (candidate %v)", i, c.candidate) } } //////////////////////////////////////////////////////////////////////// // Integer literals //////////////////////////////////////////////////////////////////////// func (t *LessThanTest) IntegerCandidateBadTypes() { matcher := LessThan(int(-150)) cases := []ltTestCase{ ltTestCase{true, false, true, "which is not comparable"}, ltTestCase{uintptr(17), false, true, "which is not comparable"}, ltTestCase{complex64(-151), false, true, "which is not comparable"}, ltTestCase{complex128(-151), false, true, "which is not comparable"}, ltTestCase{[...]int{-151}, false, true, "which is not comparable"}, ltTestCase{make(chan int), false, true, "which is not comparable"}, ltTestCase{func() {}, false, true, "which is not comparable"}, ltTestCase{map[int]int{}, false, true, "which is not comparable"}, ltTestCase{<TestCase{}, false, true, "which is not comparable"}, ltTestCase{make([]int, 0), false, true, "which is not comparable"}, ltTestCase{"-151", false, true, "which is not comparable"}, ltTestCase{ltTestCase{}, false, true, "which is not comparable"}, } t.checkTestCases(matcher, cases) } func (t *LessThanTest) FloatCandidateBadTypes() { matcher := LessThan(float32(-150)) cases := []ltTestCase{ ltTestCase{true, false, true, "which is not comparable"}, ltTestCase{uintptr(17), false, true, "which is not comparable"}, ltTestCase{complex64(-151), false, true, "which is not comparable"}, ltTestCase{complex128(-151), false, true, "which is not comparable"}, ltTestCase{[...]int{-151}, false, true, "which is not comparable"}, ltTestCase{make(chan int), false, true, "which is not comparable"}, ltTestCase{func() {}, false, true, "which is not comparable"}, ltTestCase{map[int]int{}, false, true, "which is not comparable"}, ltTestCase{<TestCase{}, false, true, "which is not comparable"}, ltTestCase{make([]int, 0), false, true, "which is not comparable"}, ltTestCase{"-151", false, true, "which is not comparable"}, ltTestCase{ltTestCase{}, false, true, "which is not comparable"}, } t.checkTestCases(matcher, cases) } func (t *LessThanTest) StringCandidateBadTypes() { matcher := LessThan("17") cases := []ltTestCase{ ltTestCase{true, false, true, "which is not comparable"}, ltTestCase{int(0), false, true, "which is not comparable"}, ltTestCase{int8(0), false, true, "which is not comparable"}, ltTestCase{int16(0), false, true, "which is not comparable"}, ltTestCase{int32(0), false, true, "which is not comparable"}, ltTestCase{int64(0), false, true, "which is not comparable"}, ltTestCase{uint(0), false, true, "which is not comparable"}, ltTestCase{uint8(0), false, true, "which is not comparable"}, ltTestCase{uint16(0), false, true, "which is not comparable"}, ltTestCase{uint32(0), false, true, "which is not comparable"}, ltTestCase{uint64(0), false, true, "which is not comparable"}, ltTestCase{uintptr(17), false, true, "which is not comparable"}, ltTestCase{float32(0), false, true, "which is not comparable"}, ltTestCase{float64(0), false, true, "which is not comparable"}, ltTestCase{complex64(-151), false, true, "which is not comparable"}, ltTestCase{complex128(-151), false, true, "which is not comparable"}, ltTestCase{[...]int{-151}, false, true, "which is not comparable"}, ltTestCase{make(chan int), false, true, "which is not comparable"}, ltTestCase{func() {}, false, true, "which is not comparable"}, ltTestCase{map[int]int{}, false, true, "which is not comparable"}, ltTestCase{<TestCase{}, false, true, "which is not comparable"}, ltTestCase{make([]int, 0), false, true, "which is not comparable"}, ltTestCase{ltTestCase{}, false, true, "which is not comparable"}, } t.checkTestCases(matcher, cases) } func (t *LessThanTest) BadArgument() { panicked := false defer func() { ExpectThat(panicked, Equals(true)) }() defer func() { if r := recover(); r != nil { panicked = true } }() LessThan(complex128(0)) } //////////////////////////////////////////////////////////////////////// // Integer literals //////////////////////////////////////////////////////////////////////// func (t *LessThanTest) NegativeIntegerLiteral() { matcher := LessThan(-150) desc := matcher.Description() expectedDesc := "less than -150" ExpectThat(desc, Equals(expectedDesc)) cases := []ltTestCase{ // Signed integers. ltTestCase{-(1 << 30), true, false, ""}, ltTestCase{-151, true, false, ""}, ltTestCase{-150, false, false, ""}, ltTestCase{0, false, false, ""}, ltTestCase{17, false, false, ""}, ltTestCase{int(-(1 << 30)), true, false, ""}, ltTestCase{int(-151), true, false, ""}, ltTestCase{int(-150), false, false, ""}, ltTestCase{int(0), false, false, ""}, ltTestCase{int(17), false, false, ""}, ltTestCase{int8(-127), false, false, ""}, ltTestCase{int8(0), false, false, ""}, ltTestCase{int8(17), false, false, ""}, ltTestCase{int16(-(1 << 14)), true, false, ""}, ltTestCase{int16(-151), true, false, ""}, ltTestCase{int16(-150), false, false, ""}, ltTestCase{int16(0), false, false, ""}, ltTestCase{int16(17), false, false, ""}, ltTestCase{int32(-(1 << 30)), true, false, ""}, ltTestCase{int32(-151), true, false, ""}, ltTestCase{int32(-150), false, false, ""}, ltTestCase{int32(0), false, false, ""}, ltTestCase{int32(17), false, false, ""}, ltTestCase{int64(-(1 << 30)), true, false, ""}, ltTestCase{int64(-151), true, false, ""}, ltTestCase{int64(-150), false, false, ""}, ltTestCase{int64(0), false, false, ""}, ltTestCase{int64(17), false, false, ""}, // Unsigned integers. ltTestCase{uint((1 << 32) - 151), false, false, ""}, ltTestCase{uint(0), false, false, ""}, ltTestCase{uint(17), false, false, ""}, ltTestCase{uint8(0), false, false, ""}, ltTestCase{uint8(17), false, false, ""}, ltTestCase{uint8(253), false, false, ""}, ltTestCase{uint16((1 << 16) - 151), false, false, ""}, ltTestCase{uint16(0), false, false, ""}, ltTestCase{uint16(17), false, false, ""}, ltTestCase{uint32((1 << 32) - 151), false, false, ""}, ltTestCase{uint32(0), false, false, ""}, ltTestCase{uint32(17), false, false, ""}, ltTestCase{uint64((1 << 64) - 151), false, false, ""}, ltTestCase{uint64(0), false, false, ""}, ltTestCase{uint64(17), false, false, ""}, // Floating point. ltTestCase{float32(-(1 << 30)), true, false, ""}, ltTestCase{float32(-151), true, false, ""}, ltTestCase{float32(-150.1), true, false, ""}, ltTestCase{float32(-150), false, false, ""}, ltTestCase{float32(-149.9), false, false, ""}, ltTestCase{float32(0), false, false, ""}, ltTestCase{float32(17), false, false, ""}, ltTestCase{float32(160), false, false, ""}, ltTestCase{float64(-(1 << 30)), true, false, ""}, ltTestCase{float64(-151), true, false, ""}, ltTestCase{float64(-150.1), true, false, ""}, ltTestCase{float64(-150), false, false, ""}, ltTestCase{float64(-149.9), false, false, ""}, ltTestCase{float64(0), false, false, ""}, ltTestCase{float64(17), false, false, ""}, ltTestCase{float64(160), false, false, ""}, } t.checkTestCases(matcher, cases) } func (t *LessThanTest) ZeroIntegerLiteral() { matcher := LessThan(0) desc := matcher.Description() expectedDesc := "less than 0" ExpectThat(desc, Equals(expectedDesc)) cases := []ltTestCase{ // Signed integers. ltTestCase{-(1 << 30), true, false, ""}, ltTestCase{-1, true, false, ""}, ltTestCase{0, false, false, ""}, ltTestCase{1, false, false, ""}, ltTestCase{17, false, false, ""}, ltTestCase{(1 << 30), false, false, ""}, ltTestCase{int(-(1 << 30)), true, false, ""}, ltTestCase{int(-1), true, false, ""}, ltTestCase{int(0), false, false, ""}, ltTestCase{int(1), false, false, ""}, ltTestCase{int(17), false, false, ""}, ltTestCase{int8(-1), true, false, ""}, ltTestCase{int8(0), false, false, ""}, ltTestCase{int8(1), false, false, ""}, ltTestCase{int16(-(1 << 14)), true, false, ""}, ltTestCase{int16(-1), true, false, ""}, ltTestCase{int16(0), false, false, ""}, ltTestCase{int16(1), false, false, ""}, ltTestCase{int16(17), false, false, ""}, ltTestCase{int32(-(1 << 30)), true, false, ""}, ltTestCase{int32(-1), true, false, ""}, ltTestCase{int32(0), false, false, ""}, ltTestCase{int32(1), false, false, ""}, ltTestCase{int32(17), false, false, ""}, ltTestCase{int64(-(1 << 30)), true, false, ""}, ltTestCase{int64(-1), true, false, ""}, ltTestCase{int64(0), false, false, ""}, ltTestCase{int64(1), false, false, ""}, ltTestCase{int64(17), false, false, ""}, // Unsigned integers. ltTestCase{uint((1 << 32) - 1), false, false, ""}, ltTestCase{uint(0), false, false, ""}, ltTestCase{uint(17), false, false, ""}, ltTestCase{uint8(0), false, false, ""}, ltTestCase{uint8(17), false, false, ""}, ltTestCase{uint8(253), false, false, ""}, ltTestCase{uint16((1 << 16) - 1), false, false, ""}, ltTestCase{uint16(0), false, false, ""}, ltTestCase{uint16(17), false, false, ""}, ltTestCase{uint32((1 << 32) - 1), false, false, ""}, ltTestCase{uint32(0), false, false, ""}, ltTestCase{uint32(17), false, false, ""}, ltTestCase{uint64((1 << 64) - 1), false, false, ""}, ltTestCase{uint64(0), false, false, ""}, ltTestCase{uint64(17), false, false, ""}, // Floating point. ltTestCase{float32(-(1 << 30)), true, false, ""}, ltTestCase{float32(-1), true, false, ""}, ltTestCase{float32(-0.1), true, false, ""}, ltTestCase{float32(-0.0), false, false, ""}, ltTestCase{float32(0), false, false, ""}, ltTestCase{float32(0.1), false, false, ""}, ltTestCase{float32(17), false, false, ""}, ltTestCase{float32(160), false, false, ""}, ltTestCase{float64(-(1 << 30)), true, false, ""}, ltTestCase{float64(-1), true, false, ""}, ltTestCase{float64(-0.1), true, false, ""}, ltTestCase{float64(-0), false, false, ""}, ltTestCase{float64(0), false, false, ""}, ltTestCase{float64(17), false, false, ""}, ltTestCase{float64(160), false, false, ""}, } t.checkTestCases(matcher, cases) } func (t *LessThanTest) PositiveIntegerLiteral() { matcher := LessThan(150) desc := matcher.Description() expectedDesc := "less than 150" ExpectThat(desc, Equals(expectedDesc)) cases := []ltTestCase{ // Signed integers. ltTestCase{-1, true, false, ""}, ltTestCase{149, true, false, ""}, ltTestCase{150, false, false, ""}, ltTestCase{151, false, false, ""}, ltTestCase{int(-1), true, false, ""}, ltTestCase{int(149), true, false, ""}, ltTestCase{int(150), false, false, ""}, ltTestCase{int(151), false, false, ""}, ltTestCase{int8(-1), true, false, ""}, ltTestCase{int8(0), true, false, ""}, ltTestCase{int8(17), true, false, ""}, ltTestCase{int8(127), true, false, ""}, ltTestCase{int16(-1), true, false, ""}, ltTestCase{int16(149), true, false, ""}, ltTestCase{int16(150), false, false, ""}, ltTestCase{int16(151), false, false, ""}, ltTestCase{int32(-1), true, false, ""}, ltTestCase{int32(149), true, false, ""}, ltTestCase{int32(150), false, false, ""}, ltTestCase{int32(151), false, false, ""}, ltTestCase{int64(-1), true, false, ""}, ltTestCase{int64(149), true, false, ""}, ltTestCase{int64(150), false, false, ""}, ltTestCase{int64(151), false, false, ""}, // Unsigned integers. ltTestCase{uint(0), true, false, ""}, ltTestCase{uint(149), true, false, ""}, ltTestCase{uint(150), false, false, ""}, ltTestCase{uint(151), false, false, ""}, ltTestCase{uint8(0), true, false, ""}, ltTestCase{uint8(127), true, false, ""}, ltTestCase{uint16(0), true, false, ""}, ltTestCase{uint16(149), true, false, ""}, ltTestCase{uint16(150), false, false, ""}, ltTestCase{uint16(151), false, false, ""}, ltTestCase{uint32(0), true, false, ""}, ltTestCase{uint32(149), true, false, ""}, ltTestCase{uint32(150), false, false, ""}, ltTestCase{uint32(151), false, false, ""}, ltTestCase{uint64(0), true, false, ""}, ltTestCase{uint64(149), true, false, ""}, ltTestCase{uint64(150), false, false, ""}, ltTestCase{uint64(151), false, false, ""}, // Floating point. ltTestCase{float32(-1), true, false, ""}, ltTestCase{float32(149), true, false, ""}, ltTestCase{float32(149.9), true, false, ""}, ltTestCase{float32(150), false, false, ""}, ltTestCase{float32(150.1), false, false, ""}, ltTestCase{float32(151), false, false, ""}, ltTestCase{float64(-1), true, false, ""}, ltTestCase{float64(149), true, false, ""}, ltTestCase{float64(149.9), true, false, ""}, ltTestCase{float64(150), false, false, ""}, ltTestCase{float64(150.1), false, false, ""}, ltTestCase{float64(151), false, false, ""}, } t.checkTestCases(matcher, cases) } //////////////////////////////////////////////////////////////////////// // Float literals //////////////////////////////////////////////////////////////////////// func (t *LessThanTest) NegativeFloatLiteral() { matcher := LessThan(-150.1) desc := matcher.Description() expectedDesc := "less than -150.1" ExpectThat(desc, Equals(expectedDesc)) cases := []ltTestCase{ // Signed integers. ltTestCase{-(1 << 30), true, false, ""}, ltTestCase{-151, true, false, ""}, ltTestCase{-150, false, false, ""}, ltTestCase{0, false, false, ""}, ltTestCase{17, false, false, ""}, ltTestCase{int(-(1 << 30)), true, false, ""}, ltTestCase{int(-151), true, false, ""}, ltTestCase{int(-150), false, false, ""}, ltTestCase{int(0), false, false, ""}, ltTestCase{int(17), false, false, ""}, ltTestCase{int8(-127), false, false, ""}, ltTestCase{int8(0), false, false, ""}, ltTestCase{int8(17), false, false, ""}, ltTestCase{int16(-(1 << 14)), true, false, ""}, ltTestCase{int16(-151), true, false, ""}, ltTestCase{int16(-150), false, false, ""}, ltTestCase{int16(0), false, false, ""}, ltTestCase{int16(17), false, false, ""}, ltTestCase{int32(-(1 << 30)), true, false, ""}, ltTestCase{int32(-151), true, false, ""}, ltTestCase{int32(-150), false, false, ""}, ltTestCase{int32(0), false, false, ""}, ltTestCase{int32(17), false, false, ""}, ltTestCase{int64(-(1 << 30)), true, false, ""}, ltTestCase{int64(-151), true, false, ""}, ltTestCase{int64(-150), false, false, ""}, ltTestCase{int64(0), false, false, ""}, ltTestCase{int64(17), false, false, ""}, // Unsigned integers. ltTestCase{uint((1 << 32) - 151), false, false, ""}, ltTestCase{uint(0), false, false, ""}, ltTestCase{uint(17), false, false, ""}, ltTestCase{uint8(0), false, false, ""}, ltTestCase{uint8(17), false, false, ""}, ltTestCase{uint8(253), false, false, ""}, ltTestCase{uint16((1 << 16) - 151), false, false, ""}, ltTestCase{uint16(0), false, false, ""}, ltTestCase{uint16(17), false, false, ""}, ltTestCase{uint32((1 << 32) - 151), false, false, ""}, ltTestCase{uint32(0), false, false, ""}, ltTestCase{uint32(17), false, false, ""}, ltTestCase{uint64((1 << 64) - 151), false, false, ""}, ltTestCase{uint64(0), false, false, ""}, ltTestCase{uint64(17), false, false, ""}, // Floating point. ltTestCase{float32(-(1 << 30)), true, false, ""}, ltTestCase{float32(-151), true, false, ""}, ltTestCase{float32(-150.2), true, false, ""}, ltTestCase{float32(-150.1), false, false, ""}, ltTestCase{float32(-150), false, false, ""}, ltTestCase{float32(0), false, false, ""}, ltTestCase{float32(17), false, false, ""}, ltTestCase{float32(160), false, false, ""}, ltTestCase{float64(-(1 << 30)), true, false, ""}, ltTestCase{float64(-151), true, false, ""}, ltTestCase{float64(-150.2), true, false, ""}, ltTestCase{float64(-150.1), false, false, ""}, ltTestCase{float64(-150), false, false, ""}, ltTestCase{float64(0), false, false, ""}, ltTestCase{float64(17), false, false, ""}, ltTestCase{float64(160), false, false, ""}, } t.checkTestCases(matcher, cases) } func (t *LessThanTest) PositiveFloatLiteral() { matcher := LessThan(149.9) desc := matcher.Description() expectedDesc := "less than 149.9" ExpectThat(desc, Equals(expectedDesc)) cases := []ltTestCase{ // Signed integers. ltTestCase{-1, true, false, ""}, ltTestCase{149, true, false, ""}, ltTestCase{150, false, false, ""}, ltTestCase{151, false, false, ""}, ltTestCase{int(-1), true, false, ""}, ltTestCase{int(149), true, false, ""}, ltTestCase{int(150), false, false, ""}, ltTestCase{int(151), false, false, ""}, ltTestCase{int8(-1), true, false, ""}, ltTestCase{int8(0), true, false, ""}, ltTestCase{int8(17), true, false, ""}, ltTestCase{int8(127), true, false, ""}, ltTestCase{int16(-1), true, false, ""}, ltTestCase{int16(149), true, false, ""}, ltTestCase{int16(150), false, false, ""}, ltTestCase{int16(151), false, false, ""}, ltTestCase{int32(-1), true, false, ""}, ltTestCase{int32(149), true, false, ""}, ltTestCase{int32(150), false, false, ""}, ltTestCase{int32(151), false, false, ""}, ltTestCase{int64(-1), true, false, ""}, ltTestCase{int64(149), true, false, ""}, ltTestCase{int64(150), false, false, ""}, ltTestCase{int64(151), false, false, ""}, // Unsigned integers. ltTestCase{uint(0), true, false, ""}, ltTestCase{uint(149), true, false, ""}, ltTestCase{uint(150), false, false, ""}, ltTestCase{uint(151), false, false, ""}, ltTestCase{uint8(0), true, false, ""}, ltTestCase{uint8(127), true, false, ""}, ltTestCase{uint16(0), true, false, ""}, ltTestCase{uint16(149), true, false, ""}, ltTestCase{uint16(150), false, false, ""}, ltTestCase{uint16(151), false, false, ""}, ltTestCase{uint32(0), true, false, ""}, ltTestCase{uint32(149), true, false, ""}, ltTestCase{uint32(150), false, false, ""}, ltTestCase{uint32(151), false, false, ""}, ltTestCase{uint64(0), true, false, ""}, ltTestCase{uint64(149), true, false, ""}, ltTestCase{uint64(150), false, false, ""}, ltTestCase{uint64(151), false, false, ""}, // Floating point. ltTestCase{float32(-1), true, false, ""}, ltTestCase{float32(149), true, false, ""}, ltTestCase{float32(149.8), true, false, ""}, ltTestCase{float32(149.9), false, false, ""}, ltTestCase{float32(150), false, false, ""}, ltTestCase{float32(151), false, false, ""}, ltTestCase{float64(-1), true, false, ""}, ltTestCase{float64(149), true, false, ""}, ltTestCase{float64(149.8), true, false, ""}, ltTestCase{float64(149.9), false, false, ""}, ltTestCase{float64(150), false, false, ""}, ltTestCase{float64(151), false, false, ""}, } t.checkTestCases(matcher, cases) } //////////////////////////////////////////////////////////////////////// // Subtle cases //////////////////////////////////////////////////////////////////////// func (t *LessThanTest) Int64NotExactlyRepresentableBySinglePrecision() { // Single-precision floats don't have enough bits to represent the integers // near this one distinctly, so [2^25-1, 2^25+2] all receive the same value // and should be treated as equivalent when floats are in the mix. const kTwoTo25 = 1 << 25 matcher := LessThan(int64(kTwoTo25 + 1)) desc := matcher.Description() expectedDesc := "less than 33554433" ExpectThat(desc, Equals(expectedDesc)) cases := []ltTestCase{ // Signed integers. ltTestCase{-1, true, false, ""}, ltTestCase{kTwoTo25 + 0, true, false, ""}, ltTestCase{kTwoTo25 + 1, false, false, ""}, ltTestCase{kTwoTo25 + 2, false, false, ""}, ltTestCase{int(-1), true, false, ""}, ltTestCase{int(kTwoTo25 + 0), true, false, ""}, ltTestCase{int(kTwoTo25 + 1), false, false, ""}, ltTestCase{int(kTwoTo25 + 2), false, false, ""}, ltTestCase{int8(-1), true, false, ""}, ltTestCase{int8(127), true, false, ""}, ltTestCase{int16(-1), true, false, ""}, ltTestCase{int16(0), true, false, ""}, ltTestCase{int16(32767), true, false, ""}, ltTestCase{int32(-1), true, false, ""}, ltTestCase{int32(kTwoTo25 + 0), true, false, ""}, ltTestCase{int32(kTwoTo25 + 1), false, false, ""}, ltTestCase{int32(kTwoTo25 + 2), false, false, ""}, ltTestCase{int64(-1), true, false, ""}, ltTestCase{int64(kTwoTo25 + 0), true, false, ""}, ltTestCase{int64(kTwoTo25 + 1), false, false, ""}, ltTestCase{int64(kTwoTo25 + 2), false, false, ""}, // Unsigned integers. ltTestCase{uint(0), true, false, ""}, ltTestCase{uint(kTwoTo25 + 0), true, false, ""}, ltTestCase{uint(kTwoTo25 + 1), false, false, ""}, ltTestCase{uint(kTwoTo25 + 2), false, false, ""}, ltTestCase{uint8(0), true, false, ""}, ltTestCase{uint8(255), true, false, ""}, ltTestCase{uint16(0), true, false, ""}, ltTestCase{uint16(65535), true, false, ""}, ltTestCase{uint32(0), true, false, ""}, ltTestCase{uint32(kTwoTo25 + 0), true, false, ""}, ltTestCase{uint32(kTwoTo25 + 1), false, false, ""}, ltTestCase{uint32(kTwoTo25 + 2), false, false, ""}, ltTestCase{uint64(0), true, false, ""}, ltTestCase{uint64(kTwoTo25 + 0), true, false, ""}, ltTestCase{uint64(kTwoTo25 + 1), false, false, ""}, ltTestCase{uint64(kTwoTo25 + 2), false, false, ""}, // Floating point. ltTestCase{float32(-1), true, false, ""}, ltTestCase{float32(kTwoTo25 - 2), true, false, ""}, ltTestCase{float32(kTwoTo25 - 1), false, false, ""}, ltTestCase{float32(kTwoTo25 + 0), false, false, ""}, ltTestCase{float32(kTwoTo25 + 1), false, false, ""}, ltTestCase{float32(kTwoTo25 + 2), false, false, ""}, ltTestCase{float32(kTwoTo25 + 3), false, false, ""}, ltTestCase{float64(-1), true, false, ""}, ltTestCase{float64(kTwoTo25 - 2), true, false, ""}, ltTestCase{float64(kTwoTo25 - 1), true, false, ""}, ltTestCase{float64(kTwoTo25 + 0), true, false, ""}, ltTestCase{float64(kTwoTo25 + 1), false, false, ""}, ltTestCase{float64(kTwoTo25 + 2), false, false, ""}, ltTestCase{float64(kTwoTo25 + 3), false, false, ""}, } t.checkTestCases(matcher, cases) } func (t *LessThanTest) Int64NotExactlyRepresentableByDoublePrecision() { // Double-precision floats don't have enough bits to represent the integers // near this one distinctly, so [2^54-1, 2^54+2] all receive the same value // and should be treated as equivalent when floats are in the mix. const kTwoTo54 = 1 << 54 matcher := LessThan(int64(kTwoTo54 + 1)) desc := matcher.Description() expectedDesc := "less than 18014398509481985" ExpectThat(desc, Equals(expectedDesc)) cases := []ltTestCase{ // Signed integers. ltTestCase{-1, true, false, ""}, ltTestCase{1 << 30, true, false, ""}, ltTestCase{int(-1), true, false, ""}, ltTestCase{int(math.MaxInt32), true, false, ""}, ltTestCase{int8(-1), true, false, ""}, ltTestCase{int8(127), true, false, ""}, ltTestCase{int16(-1), true, false, ""}, ltTestCase{int16(0), true, false, ""}, ltTestCase{int16(32767), true, false, ""}, ltTestCase{int32(-1), true, false, ""}, ltTestCase{int32(math.MaxInt32), true, false, ""}, ltTestCase{int64(-1), true, false, ""}, ltTestCase{int64(kTwoTo54 - 1), true, false, ""}, ltTestCase{int64(kTwoTo54 + 0), true, false, ""}, ltTestCase{int64(kTwoTo54 + 1), false, false, ""}, ltTestCase{int64(kTwoTo54 + 2), false, false, ""}, // Unsigned integers. ltTestCase{uint(0), true, false, ""}, ltTestCase{uint(math.MaxUint32), true, false, ""}, ltTestCase{uint8(0), true, false, ""}, ltTestCase{uint8(255), true, false, ""}, ltTestCase{uint16(0), true, false, ""}, ltTestCase{uint16(65535), true, false, ""}, ltTestCase{uint32(0), true, false, ""}, ltTestCase{uint32(math.MaxUint32), true, false, ""}, ltTestCase{uint64(0), true, false, ""}, ltTestCase{uint64(kTwoTo54 - 1), true, false, ""}, ltTestCase{uint64(kTwoTo54 + 0), true, false, ""}, ltTestCase{uint64(kTwoTo54 + 1), false, false, ""}, ltTestCase{uint64(kTwoTo54 + 2), false, false, ""}, // Floating point. ltTestCase{float64(-1), true, false, ""}, ltTestCase{float64(kTwoTo54 - 2), true, false, ""}, ltTestCase{float64(kTwoTo54 - 1), false, false, ""}, ltTestCase{float64(kTwoTo54 + 0), false, false, ""}, ltTestCase{float64(kTwoTo54 + 1), false, false, ""}, ltTestCase{float64(kTwoTo54 + 2), false, false, ""}, ltTestCase{float64(kTwoTo54 + 3), false, false, ""}, } t.checkTestCases(matcher, cases) } func (t *LessThanTest) Uint64NotExactlyRepresentableBySinglePrecision() { // Single-precision floats don't have enough bits to represent the integers // near this one distinctly, so [2^25-1, 2^25+2] all receive the same value // and should be treated as equivalent when floats are in the mix. const kTwoTo25 = 1 << 25 matcher := LessThan(uint64(kTwoTo25 + 1)) desc := matcher.Description() expectedDesc := "less than 33554433" ExpectThat(desc, Equals(expectedDesc)) cases := []ltTestCase{ // Signed integers. ltTestCase{-1, true, false, ""}, ltTestCase{kTwoTo25 + 0, true, false, ""}, ltTestCase{kTwoTo25 + 1, false, false, ""}, ltTestCase{kTwoTo25 + 2, false, false, ""}, ltTestCase{int(-1), true, false, ""}, ltTestCase{int(kTwoTo25 + 0), true, false, ""}, ltTestCase{int(kTwoTo25 + 1), false, false, ""}, ltTestCase{int(kTwoTo25 + 2), false, false, ""}, ltTestCase{int8(-1), true, false, ""}, ltTestCase{int8(127), true, false, ""}, ltTestCase{int16(-1), true, false, ""}, ltTestCase{int16(0), true, false, ""}, ltTestCase{int16(32767), true, false, ""}, ltTestCase{int32(-1), true, false, ""}, ltTestCase{int32(kTwoTo25 + 0), true, false, ""}, ltTestCase{int32(kTwoTo25 + 1), false, false, ""}, ltTestCase{int32(kTwoTo25 + 2), false, false, ""}, ltTestCase{int64(-1), true, false, ""}, ltTestCase{int64(kTwoTo25 + 0), true, false, ""}, ltTestCase{int64(kTwoTo25 + 1), false, false, ""}, ltTestCase{int64(kTwoTo25 + 2), false, false, ""}, // Unsigned integers. ltTestCase{uint(0), true, false, ""}, ltTestCase{uint(kTwoTo25 + 0), true, false, ""}, ltTestCase{uint(kTwoTo25 + 1), false, false, ""}, ltTestCase{uint(kTwoTo25 + 2), false, false, ""}, ltTestCase{uint8(0), true, false, ""}, ltTestCase{uint8(255), true, false, ""}, ltTestCase{uint16(0), true, false, ""}, ltTestCase{uint16(65535), true, false, ""}, ltTestCase{uint32(0), true, false, ""}, ltTestCase{uint32(kTwoTo25 + 0), true, false, ""}, ltTestCase{uint32(kTwoTo25 + 1), false, false, ""}, ltTestCase{uint32(kTwoTo25 + 2), false, false, ""}, ltTestCase{uint64(0), true, false, ""}, ltTestCase{uint64(kTwoTo25 + 0), true, false, ""}, ltTestCase{uint64(kTwoTo25 + 1), false, false, ""}, ltTestCase{uint64(kTwoTo25 + 2), false, false, ""}, // Floating point. ltTestCase{float32(-1), true, false, ""}, ltTestCase{float32(kTwoTo25 - 2), true, false, ""}, ltTestCase{float32(kTwoTo25 - 1), false, false, ""}, ltTestCase{float32(kTwoTo25 + 0), false, false, ""}, ltTestCase{float32(kTwoTo25 + 1), false, false, ""}, ltTestCase{float32(kTwoTo25 + 2), false, false, ""}, ltTestCase{float32(kTwoTo25 + 3), false, false, ""}, ltTestCase{float64(-1), true, false, ""}, ltTestCase{float64(kTwoTo25 - 2), true, false, ""}, ltTestCase{float64(kTwoTo25 - 1), true, false, ""}, ltTestCase{float64(kTwoTo25 + 0), true, false, ""}, ltTestCase{float64(kTwoTo25 + 1), false, false, ""}, ltTestCase{float64(kTwoTo25 + 2), false, false, ""}, ltTestCase{float64(kTwoTo25 + 3), false, false, ""}, } t.checkTestCases(matcher, cases) } func (t *LessThanTest) Uint64NotExactlyRepresentableByDoublePrecision() { // Double-precision floats don't have enough bits to represent the integers // near this one distinctly, so [2^54-1, 2^54+2] all receive the same value // and should be treated as equivalent when floats are in the mix. const kTwoTo54 = 1 << 54 matcher := LessThan(uint64(kTwoTo54 + 1)) desc := matcher.Description() expectedDesc := "less than 18014398509481985" ExpectThat(desc, Equals(expectedDesc)) cases := []ltTestCase{ // Signed integers. ltTestCase{-1, true, false, ""}, ltTestCase{1 << 30, true, false, ""}, ltTestCase{int(-1), true, false, ""}, ltTestCase{int(math.MaxInt32), true, false, ""}, ltTestCase{int8(-1), true, false, ""}, ltTestCase{int8(127), true, false, ""}, ltTestCase{int16(-1), true, false, ""}, ltTestCase{int16(0), true, false, ""}, ltTestCase{int16(32767), true, false, ""}, ltTestCase{int32(-1), true, false, ""}, ltTestCase{int32(math.MaxInt32), true, false, ""}, ltTestCase{int64(-1), true, false, ""}, ltTestCase{int64(kTwoTo54 - 1), true, false, ""}, ltTestCase{int64(kTwoTo54 + 0), true, false, ""}, ltTestCase{int64(kTwoTo54 + 1), false, false, ""}, ltTestCase{int64(kTwoTo54 + 2), false, false, ""}, // Unsigned integers. ltTestCase{uint(0), true, false, ""}, ltTestCase{uint(math.MaxUint32), true, false, ""}, ltTestCase{uint8(0), true, false, ""}, ltTestCase{uint8(255), true, false, ""}, ltTestCase{uint16(0), true, false, ""}, ltTestCase{uint16(65535), true, false, ""}, ltTestCase{uint32(0), true, false, ""}, ltTestCase{uint32(math.MaxUint32), true, false, ""}, ltTestCase{uint64(0), true, false, ""}, ltTestCase{uint64(kTwoTo54 - 1), true, false, ""}, ltTestCase{uint64(kTwoTo54 + 0), true, false, ""}, ltTestCase{uint64(kTwoTo54 + 1), false, false, ""}, ltTestCase{uint64(kTwoTo54 + 2), false, false, ""}, // Floating point. ltTestCase{float64(-1), true, false, ""}, ltTestCase{float64(kTwoTo54 - 2), true, false, ""}, ltTestCase{float64(kTwoTo54 - 1), false, false, ""}, ltTestCase{float64(kTwoTo54 + 0), false, false, ""}, ltTestCase{float64(kTwoTo54 + 1), false, false, ""}, ltTestCase{float64(kTwoTo54 + 2), false, false, ""}, ltTestCase{float64(kTwoTo54 + 3), false, false, ""}, } t.checkTestCases(matcher, cases) } func (t *LessThanTest) Float32AboveExactIntegerRange() { // Single-precision floats don't have enough bits to represent the integers // near this one distinctly, so [2^25-1, 2^25+2] all receive the same value // and should be treated as equivalent when floats are in the mix. const kTwoTo25 = 1 << 25 matcher := LessThan(float32(kTwoTo25 + 1)) desc := matcher.Description() expectedDesc := "less than 3.3554432e+07" ExpectThat(desc, Equals(expectedDesc)) cases := []ltTestCase{ // Signed integers. ltTestCase{int64(-1), true, false, ""}, ltTestCase{int64(kTwoTo25 - 2), true, false, ""}, ltTestCase{int64(kTwoTo25 - 1), false, false, ""}, ltTestCase{int64(kTwoTo25 + 0), false, false, ""}, ltTestCase{int64(kTwoTo25 + 1), false, false, ""}, ltTestCase{int64(kTwoTo25 + 2), false, false, ""}, ltTestCase{int64(kTwoTo25 + 3), false, false, ""}, // Unsigned integers. ltTestCase{uint64(0), true, false, ""}, ltTestCase{uint64(kTwoTo25 - 2), true, false, ""}, ltTestCase{uint64(kTwoTo25 - 1), false, false, ""}, ltTestCase{uint64(kTwoTo25 + 0), false, false, ""}, ltTestCase{uint64(kTwoTo25 + 1), false, false, ""}, ltTestCase{uint64(kTwoTo25 + 2), false, false, ""}, ltTestCase{uint64(kTwoTo25 + 3), false, false, ""}, // Floating point. ltTestCase{float32(-1), true, false, ""}, ltTestCase{float32(kTwoTo25 - 2), true, false, ""}, ltTestCase{float32(kTwoTo25 - 1), false, false, ""}, ltTestCase{float32(kTwoTo25 + 0), false, false, ""}, ltTestCase{float32(kTwoTo25 + 1), false, false, ""}, ltTestCase{float32(kTwoTo25 + 2), false, false, ""}, ltTestCase{float32(kTwoTo25 + 3), false, false, ""}, ltTestCase{float64(-1), true, false, ""}, ltTestCase{float64(kTwoTo25 - 2), true, false, ""}, ltTestCase{float64(kTwoTo25 - 1), false, false, ""}, ltTestCase{float64(kTwoTo25 + 0), false, false, ""}, ltTestCase{float64(kTwoTo25 + 1), false, false, ""}, ltTestCase{float64(kTwoTo25 + 2), false, false, ""}, ltTestCase{float64(kTwoTo25 + 3), false, false, ""}, } t.checkTestCases(matcher, cases) } func (t *LessThanTest) Float64AboveExactIntegerRange() { // Double-precision floats don't have enough bits to represent the integers // near this one distinctly, so [2^54-1, 2^54+2] all receive the same value // and should be treated as equivalent when floats are in the mix. const kTwoTo54 = 1 << 54 matcher := LessThan(float64(kTwoTo54 + 1)) desc := matcher.Description() expectedDesc := "less than 1.8014398509481984e+16" ExpectThat(desc, Equals(expectedDesc)) cases := []ltTestCase{ // Signed integers. ltTestCase{int64(-1), true, false, ""}, ltTestCase{int64(kTwoTo54 - 2), true, false, ""}, ltTestCase{int64(kTwoTo54 - 1), false, false, ""}, ltTestCase{int64(kTwoTo54 + 0), false, false, ""}, ltTestCase{int64(kTwoTo54 + 1), false, false, ""}, ltTestCase{int64(kTwoTo54 + 2), false, false, ""}, ltTestCase{int64(kTwoTo54 + 3), false, false, ""}, // Unsigned integers. ltTestCase{uint64(0), true, false, ""}, ltTestCase{uint64(kTwoTo54 - 2), true, false, ""}, ltTestCase{uint64(kTwoTo54 - 1), false, false, ""}, ltTestCase{uint64(kTwoTo54 + 0), false, false, ""}, ltTestCase{uint64(kTwoTo54 + 1), false, false, ""}, ltTestCase{uint64(kTwoTo54 + 2), false, false, ""}, ltTestCase{uint64(kTwoTo54 + 3), false, false, ""}, // Floating point. ltTestCase{float64(-1), true, false, ""}, ltTestCase{float64(kTwoTo54 - 2), true, false, ""}, ltTestCase{float64(kTwoTo54 - 1), false, false, ""}, ltTestCase{float64(kTwoTo54 + 0), false, false, ""}, ltTestCase{float64(kTwoTo54 + 1), false, false, ""}, ltTestCase{float64(kTwoTo54 + 2), false, false, ""}, ltTestCase{float64(kTwoTo54 + 3), false, false, ""}, } t.checkTestCases(matcher, cases) } //////////////////////////////////////////////////////////////////////// // String literals //////////////////////////////////////////////////////////////////////// func (t *LessThanTest) EmptyString() { matcher := LessThan("") desc := matcher.Description() expectedDesc := "less than \"\"" ExpectThat(desc, Equals(expectedDesc)) cases := []ltTestCase{ ltTestCase{"", false, false, ""}, ltTestCase{"\x00", false, false, ""}, ltTestCase{"a", false, false, ""}, ltTestCase{"foo", false, false, ""}, } t.checkTestCases(matcher, cases) } func (t *LessThanTest) SingleNullByte() { matcher := LessThan("\x00") desc := matcher.Description() expectedDesc := "less than \"\x00\"" ExpectThat(desc, Equals(expectedDesc)) cases := []ltTestCase{ ltTestCase{"", true, false, ""}, ltTestCase{"\x00", false, false, ""}, ltTestCase{"a", false, false, ""}, ltTestCase{"foo", false, false, ""}, } t.checkTestCases(matcher, cases) } func (t *LessThanTest) LongerString() { matcher := LessThan("foo\x00") desc := matcher.Description() expectedDesc := "less than \"foo\x00\"" ExpectThat(desc, Equals(expectedDesc)) cases := []ltTestCase{ ltTestCase{"", true, false, ""}, ltTestCase{"\x00", true, false, ""}, ltTestCase{"bar", true, false, ""}, ltTestCase{"foo", true, false, ""}, ltTestCase{"foo\x00", false, false, ""}, ltTestCase{"fooa", false, false, ""}, ltTestCase{"qux", false, false, ""}, } t.checkTestCases(matcher, cases) } mongo-tools-r3.6.3/vendor/src/github.com/jacobsa/oglematchers/matcher.go000066400000000000000000000070711321131462300263370ustar00rootroot00000000000000// Copyright 2011 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers provides a set of matchers useful in a testing or // mocking framework. These matchers are inspired by and mostly compatible with // Google Test for C++ and Google JS Test. // // This package is used by github.com/jacobsa/ogletest and // github.com/jacobsa/oglemock, which may be more directly useful if you're not // writing your own testing package or defining your own matchers. package oglematchers // A Matcher is some predicate implicitly defining a set of values that it // matches. For example, GreaterThan(17) matches all numeric values greater // than 17, and HasSubstr("taco") matches all strings with the substring // "taco". // // Matchers are typically exposed to tests via constructor functions like // HasSubstr. In order to implement such a function you can either define your // own matcher type or use NewMatcher. type Matcher interface { // Check whether the supplied value belongs to the the set defined by the // matcher. Return a non-nil error if and only if it does not. // // The error describes why the value doesn't match. The error text is a // relative clause that is suitable for being placed after the value. For // example, a predicate that matches strings with a particular substring may, // when presented with a numerical value, return the following error text: // // "which is not a string" // // Then the failure message may look like: // // Expected: has substring "taco" // Actual: 17, which is not a string // // If the error is self-apparent based on the description of the matcher, the // error text may be empty (but the error still non-nil). For example: // // Expected: 17 // Actual: 19 // // If you are implementing a new matcher, see also the documentation on // FatalError. Matches(candidate interface{}) error // Description returns a string describing the property that values matching // this matcher have, as a verb phrase where the subject is the value. For // example, "is greather than 17" or "has substring "taco"". Description() string } // FatalError is an implementation of the error interface that may be returned // from matchers, indicating the error should be propagated. Returning a // *FatalError indicates that the matcher doesn't process values of the // supplied type, or otherwise doesn't know how to handle the value. // // For example, if GreaterThan(17) returned false for the value "taco" without // a fatal error, then Not(GreaterThan(17)) would return true. This is // technically correct, but is surprising and may mask failures where the wrong // sort of matcher is accidentally used. Instead, GreaterThan(17) can return a // fatal error, which will be propagated by Not(). type FatalError struct { errorText string } // NewFatalError creates a FatalError struct with the supplied error text. func NewFatalError(s string) *FatalError { return &FatalError{s} } func (e *FatalError) Error() string { return e.errorText } mongo-tools-r3.6.3/vendor/src/github.com/jacobsa/oglematchers/matches_regexp.go000066400000000000000000000035061321131462300277110ustar00rootroot00000000000000// Copyright 2011 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers import ( "errors" "fmt" "reflect" "regexp" ) // MatchesRegexp returns a matcher that matches strings and byte slices whose // contents match the supplied regular expression. The semantics are those of // regexp.Match. In particular, that means the match is not implicitly anchored // to the ends of the string: MatchesRegexp("bar") will match "foo bar baz". func MatchesRegexp(pattern string) Matcher { re, err := regexp.Compile(pattern) if err != nil { panic("MatchesRegexp: " + err.Error()) } return &matchesRegexpMatcher{re} } type matchesRegexpMatcher struct { re *regexp.Regexp } func (m *matchesRegexpMatcher) Description() string { return fmt.Sprintf("matches regexp \"%s\"", m.re.String()) } func (m *matchesRegexpMatcher) Matches(c interface{}) (err error) { v := reflect.ValueOf(c) isString := v.Kind() == reflect.String isByteSlice := v.Kind() == reflect.Slice && v.Elem().Kind() == reflect.Uint8 err = errors.New("") switch { case isString: if m.re.MatchString(v.String()) { err = nil } case isByteSlice: if m.re.Match(v.Bytes()) { err = nil } default: err = NewFatalError("which is not a string or []byte") } return } mongo-tools-r3.6.3/vendor/src/github.com/jacobsa/oglematchers/matches_regexp_test.go000066400000000000000000000046631321131462300307550ustar00rootroot00000000000000// Copyright 2011 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers_test import ( . "github.com/jacobsa/oglematchers" . "github.com/jacobsa/ogletest" ) //////////////////////////////////////////////////////////////////////// // Helpers //////////////////////////////////////////////////////////////////////// type MatchesRegexpTest struct { } func init() { RegisterTestSuite(&MatchesRegexpTest{}) } //////////////////////////////////////////////////////////////////////// // Tests //////////////////////////////////////////////////////////////////////// func (t *MatchesRegexpTest) Description() { m := MatchesRegexp("foo.*bar") ExpectEq("matches regexp \"foo.*bar\"", m.Description()) } func (t *MatchesRegexpTest) InvalidRegexp() { ExpectThat( func() { MatchesRegexp("(foo") }, Panics(HasSubstr("missing closing )"))) } func (t *MatchesRegexpTest) CandidateIsNil() { m := MatchesRegexp("") err := m.Matches(nil) ExpectThat(err, Error(Equals("which is not a string or []byte"))) ExpectTrue(isFatal(err)) } func (t *MatchesRegexpTest) CandidateIsInteger() { m := MatchesRegexp("") err := m.Matches(17) ExpectThat(err, Error(Equals("which is not a string or []byte"))) ExpectTrue(isFatal(err)) } func (t *MatchesRegexpTest) NonMatchingCandidates() { m := MatchesRegexp("fo[op]\\s+x") var err error err = m.Matches("fon x") ExpectThat(err, Error(Equals(""))) ExpectFalse(isFatal(err)) err = m.Matches("fopx") ExpectThat(err, Error(Equals(""))) ExpectFalse(isFatal(err)) err = m.Matches("fop ") ExpectThat(err, Error(Equals(""))) ExpectFalse(isFatal(err)) } func (t *MatchesRegexpTest) MatchingCandidates() { m := MatchesRegexp("fo[op]\\s+x") var err error err = m.Matches("foo x") ExpectEq(nil, err) err = m.Matches("fop x") ExpectEq(nil, err) err = m.Matches("blah blah foo x blah blah") ExpectEq(nil, err) } mongo-tools-r3.6.3/vendor/src/github.com/jacobsa/oglematchers/new_matcher.go000066400000000000000000000025621321131462300272100ustar00rootroot00000000000000// Copyright 2015 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers // Create a matcher with the given description and predicate function, which // will be invoked to handle calls to Matchers. // // Using this constructor may be a convenience over defining your own type that // implements Matcher if you do not need any logic in your Description method. func NewMatcher( predicate func(interface{}) error, description string) Matcher { return &predicateMatcher{ predicate: predicate, description: description, } } type predicateMatcher struct { predicate func(interface{}) error description string } func (pm *predicateMatcher) Matches(c interface{}) error { return pm.predicate(c) } func (pm *predicateMatcher) Description() string { return pm.description } mongo-tools-r3.6.3/vendor/src/github.com/jacobsa/oglematchers/not.go000066400000000000000000000026601321131462300255130ustar00rootroot00000000000000// Copyright 2011 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers import ( "errors" "fmt" ) // Not returns a matcher that inverts the set of values matched by the wrapped // matcher. It does not transform the result for values for which the wrapped // matcher returns a fatal error. func Not(m Matcher) Matcher { return ¬Matcher{m} } type notMatcher struct { wrapped Matcher } func (m *notMatcher) Matches(c interface{}) (err error) { err = m.wrapped.Matches(c) // Did the wrapped matcher say yes? if err == nil { return errors.New("") } // Did the wrapped matcher return a fatal error? if _, isFatal := err.(*FatalError); isFatal { return err } // The wrapped matcher returned a non-fatal error. return nil } func (m *notMatcher) Description() string { return fmt.Sprintf("not(%s)", m.wrapped.Description()) } mongo-tools-r3.6.3/vendor/src/github.com/jacobsa/oglematchers/not_test.go000066400000000000000000000051251321131462300265510ustar00rootroot00000000000000// Copyright 2011 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers_test import ( "errors" . "github.com/jacobsa/oglematchers" . "github.com/jacobsa/ogletest" "testing" ) //////////////////////////////////////////////////////////////////////// // Helpers //////////////////////////////////////////////////////////////////////// type fakeMatcher struct { matchFunc func(interface{}) error description string } func (m *fakeMatcher) Matches(c interface{}) error { return m.matchFunc(c) } func (m *fakeMatcher) Description() string { return m.description } type NotTest struct { } func init() { RegisterTestSuite(&NotTest{}) } func TestOgletest(t *testing.T) { RunTests(t) } //////////////////////////////////////////////////////////////////////// // Tests //////////////////////////////////////////////////////////////////////// func (t *NotTest) CallsWrapped() { var suppliedCandidate interface{} matchFunc := func(c interface{}) error { suppliedCandidate = c return nil } wrapped := &fakeMatcher{matchFunc, ""} matcher := Not(wrapped) matcher.Matches(17) ExpectThat(suppliedCandidate, Equals(17)) } func (t *NotTest) WrappedReturnsTrue() { matchFunc := func(c interface{}) error { return nil } wrapped := &fakeMatcher{matchFunc, ""} matcher := Not(wrapped) err := matcher.Matches(0) ExpectThat(err, Error(Equals(""))) } func (t *NotTest) WrappedReturnsNonFatalError() { matchFunc := func(c interface{}) error { return errors.New("taco") } wrapped := &fakeMatcher{matchFunc, ""} matcher := Not(wrapped) err := matcher.Matches(0) ExpectEq(nil, err) } func (t *NotTest) WrappedReturnsFatalError() { matchFunc := func(c interface{}) error { return NewFatalError("taco") } wrapped := &fakeMatcher{matchFunc, ""} matcher := Not(wrapped) err := matcher.Matches(0) ExpectThat(err, Error(Equals("taco"))) } func (t *NotTest) Description() { wrapped := &fakeMatcher{nil, "taco"} matcher := Not(wrapped) ExpectEq("not(taco)", matcher.Description()) } mongo-tools-r3.6.3/vendor/src/github.com/jacobsa/oglematchers/panics.go000066400000000000000000000037631321131462300261750ustar00rootroot00000000000000// Copyright 2011 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers import ( "errors" "fmt" "reflect" ) // Panics matches zero-arg functions which, when invoked, panic with an error // that matches the supplied matcher. // // NOTE(jacobsa): This matcher cannot detect the case where the function panics // using panic(nil), by design of the language. See here for more info: // // http://goo.gl/9aIQL // func Panics(m Matcher) Matcher { return &panicsMatcher{m} } type panicsMatcher struct { wrappedMatcher Matcher } func (m *panicsMatcher) Description() string { return "panics with: " + m.wrappedMatcher.Description() } func (m *panicsMatcher) Matches(c interface{}) (err error) { // Make sure c is a zero-arg function. v := reflect.ValueOf(c) if v.Kind() != reflect.Func || v.Type().NumIn() != 0 { err = NewFatalError("which is not a zero-arg function") return } // Call the function and check its panic error. defer func() { if e := recover(); e != nil { err = m.wrappedMatcher.Matches(e) // Set a clearer error message if the matcher said no. if err != nil { wrappedClause := "" if err.Error() != "" { wrappedClause = ", " + err.Error() } err = errors.New(fmt.Sprintf("which panicked with: %v%s", e, wrappedClause)) } } }() v.Call([]reflect.Value{}) // If we get here, the function didn't panic. err = errors.New("which didn't panic") return } mongo-tools-r3.6.3/vendor/src/github.com/jacobsa/oglematchers/panics_test.go000066400000000000000000000072611321131462300272310ustar00rootroot00000000000000// Copyright 2011 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers_test import ( "errors" . "github.com/jacobsa/oglematchers" . "github.com/jacobsa/ogletest" ) //////////////////////////////////////////////////////////////////////// // Helpers //////////////////////////////////////////////////////////////////////// type PanicsTest struct { matcherCalled bool suppliedCandidate interface{} wrappedError error matcher Matcher } func init() { RegisterTestSuite(&PanicsTest{}) } func (t *PanicsTest) SetUp(i *TestInfo) { wrapped := &fakeMatcher{ func(c interface{}) error { t.matcherCalled = true t.suppliedCandidate = c return t.wrappedError }, "foo", } t.matcher = Panics(wrapped) } //////////////////////////////////////////////////////////////////////// // Tests //////////////////////////////////////////////////////////////////////// func (t *PanicsTest) Description() { ExpectThat(t.matcher.Description(), Equals("panics with: foo")) } func (t *PanicsTest) CandidateIsNil() { err := t.matcher.Matches(nil) ExpectThat(err, Error(Equals("which is not a zero-arg function"))) ExpectTrue(isFatal(err)) } func (t *PanicsTest) CandidateIsString() { err := t.matcher.Matches("taco") ExpectThat(err, Error(Equals("which is not a zero-arg function"))) ExpectTrue(isFatal(err)) } func (t *PanicsTest) CandidateTakesArgs() { err := t.matcher.Matches(func(i int) string { return "" }) ExpectThat(err, Error(Equals("which is not a zero-arg function"))) ExpectTrue(isFatal(err)) } func (t *PanicsTest) CallsFunction() { callCount := 0 t.matcher.Matches(func() string { callCount++ return "" }) ExpectThat(callCount, Equals(1)) } func (t *PanicsTest) FunctionDoesntPanic() { err := t.matcher.Matches(func() {}) ExpectThat(err, Error(Equals("which didn't panic"))) ExpectFalse(isFatal(err)) } func (t *PanicsTest) CallsWrappedMatcher() { expectedErr := 17 t.wrappedError = errors.New("") t.matcher.Matches(func() { panic(expectedErr) }) ExpectThat(t.suppliedCandidate, Equals(expectedErr)) } func (t *PanicsTest) WrappedReturnsTrue() { err := t.matcher.Matches(func() { panic("") }) ExpectEq(nil, err) } func (t *PanicsTest) WrappedReturnsFatalErrorWithoutText() { t.wrappedError = NewFatalError("") err := t.matcher.Matches(func() { panic(17) }) ExpectThat(err, Error(Equals("which panicked with: 17"))) ExpectFalse(isFatal(err)) } func (t *PanicsTest) WrappedReturnsFatalErrorWithText() { t.wrappedError = NewFatalError("which blah") err := t.matcher.Matches(func() { panic(17) }) ExpectThat(err, Error(Equals("which panicked with: 17, which blah"))) ExpectFalse(isFatal(err)) } func (t *PanicsTest) WrappedReturnsNonFatalErrorWithoutText() { t.wrappedError = errors.New("") err := t.matcher.Matches(func() { panic(17) }) ExpectThat(err, Error(Equals("which panicked with: 17"))) ExpectFalse(isFatal(err)) } func (t *PanicsTest) WrappedReturnsNonFatalErrorWithText() { t.wrappedError = errors.New("which blah") err := t.matcher.Matches(func() { panic(17) }) ExpectThat(err, Error(Equals("which panicked with: 17, which blah"))) ExpectFalse(isFatal(err)) } mongo-tools-r3.6.3/vendor/src/github.com/jacobsa/oglematchers/pointee.go000066400000000000000000000034051321131462300263540ustar00rootroot00000000000000// Copyright 2012 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers import ( "errors" "fmt" "reflect" ) // Return a matcher that matches non-nil pointers whose pointee matches the // wrapped matcher. func Pointee(m Matcher) Matcher { return &pointeeMatcher{m} } type pointeeMatcher struct { wrapped Matcher } func (m *pointeeMatcher) Matches(c interface{}) (err error) { // Make sure the candidate is of the appropriate type. cv := reflect.ValueOf(c) if !cv.IsValid() || cv.Kind() != reflect.Ptr { return NewFatalError("which is not a pointer") } // Make sure the candidate is non-nil. if cv.IsNil() { return NewFatalError("") } // Defer to the wrapped matcher. Fix up empty errors so that failure messages // are more helpful than just printing a pointer for "Actual". pointee := cv.Elem().Interface() err = m.wrapped.Matches(pointee) if err != nil && err.Error() == "" { s := fmt.Sprintf("whose pointee is %v", pointee) if _, ok := err.(*FatalError); ok { err = NewFatalError(s) } else { err = errors.New(s) } } return err } func (m *pointeeMatcher) Description() string { return fmt.Sprintf("pointee(%s)", m.wrapped.Description()) } mongo-tools-r3.6.3/vendor/src/github.com/jacobsa/oglematchers/pointee_test.go000066400000000000000000000075111321131462300274150ustar00rootroot00000000000000// Copyright 2012 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers_test import ( "errors" . "github.com/jacobsa/oglematchers" . "github.com/jacobsa/ogletest" "testing" ) //////////////////////////////////////////////////////////////////////// // Helpers //////////////////////////////////////////////////////////////////////// type PointeeTest struct {} func init() { RegisterTestSuite(&PointeeTest{}) } func TestPointee(t *testing.T) { RunTests(t) } //////////////////////////////////////////////////////////////////////// // Tests //////////////////////////////////////////////////////////////////////// func (t *PointeeTest) Description() { wrapped := &fakeMatcher{nil, "taco"} matcher := Pointee(wrapped) ExpectEq("pointee(taco)", matcher.Description()) } func (t *PointeeTest) CandidateIsNotAPointer() { matcher := Pointee(HasSubstr("")) err := matcher.Matches([]byte{}) ExpectThat(err, Error(Equals("which is not a pointer"))) ExpectTrue(isFatal(err)) } func (t *PointeeTest) CandidateIsANilLiteral() { matcher := Pointee(HasSubstr("")) err := matcher.Matches(nil) ExpectThat(err, Error(Equals("which is not a pointer"))) ExpectTrue(isFatal(err)) } func (t *PointeeTest) CandidateIsANilPointer() { matcher := Pointee(HasSubstr("")) err := matcher.Matches((*int)(nil)) ExpectThat(err, Error(Equals(""))) ExpectTrue(isFatal(err)) } func (t *PointeeTest) CallsWrapped() { var suppliedCandidate interface{} matchFunc := func(c interface{}) error { suppliedCandidate = c return nil } wrapped := &fakeMatcher{matchFunc, ""} matcher := Pointee(wrapped) someSlice := []byte{} matcher.Matches(&someSlice) ExpectThat(suppliedCandidate, IdenticalTo(someSlice)) } func (t *PointeeTest) WrappedReturnsOkay() { matchFunc := func(c interface{}) error { return nil } wrapped := &fakeMatcher{matchFunc, ""} matcher := Pointee(wrapped) err := matcher.Matches(new(int)) ExpectEq(nil, err) } func (t *PointeeTest) WrappedReturnsNonFatalNonEmptyError() { matchFunc := func(c interface{}) error { return errors.New("taco") } wrapped := &fakeMatcher{matchFunc, ""} matcher := Pointee(wrapped) i := 17 err := matcher.Matches(&i) ExpectFalse(isFatal(err)) ExpectThat(err, Error(Equals("taco"))) } func (t *PointeeTest) WrappedReturnsNonFatalEmptyError() { matchFunc := func(c interface{}) error { return errors.New("") } wrapped := &fakeMatcher{matchFunc, ""} matcher := Pointee(wrapped) i := 17 err := matcher.Matches(&i) ExpectFalse(isFatal(err)) ExpectThat(err, Error(HasSubstr("whose pointee"))) ExpectThat(err, Error(HasSubstr("17"))) } func (t *PointeeTest) WrappedReturnsFatalNonEmptyError() { matchFunc := func(c interface{}) error { return NewFatalError("taco") } wrapped := &fakeMatcher{matchFunc, ""} matcher := Pointee(wrapped) i := 17 err := matcher.Matches(&i) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("taco"))) } func (t *PointeeTest) WrappedReturnsFatalEmptyError() { matchFunc := func(c interface{}) error { return NewFatalError("") } wrapped := &fakeMatcher{matchFunc, ""} matcher := Pointee(wrapped) i := 17 err := matcher.Matches(&i) ExpectTrue(isFatal(err)) ExpectThat(err, Error(HasSubstr("whose pointee"))) ExpectThat(err, Error(HasSubstr("17"))) } mongo-tools-r3.6.3/vendor/src/github.com/jacobsa/oglematchers/transform_description.go000066400000000000000000000023431321131462300313270ustar00rootroot00000000000000// Copyright 2011 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers // transformDescription returns a matcher that is equivalent to the supplied // one, except that it has the supplied description instead of the one attached // to the existing matcher. func transformDescription(m Matcher, newDesc string) Matcher { return &transformDescriptionMatcher{newDesc, m} } type transformDescriptionMatcher struct { desc string wrappedMatcher Matcher } func (m *transformDescriptionMatcher) Description() string { return m.desc } func (m *transformDescriptionMatcher) Matches(c interface{}) error { return m.wrappedMatcher.Matches(c) } mongo-tools-r3.6.3/vendor/src/github.com/jessevdk/000077500000000000000000000000001321131462300221175ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/jessevdk/go-flags/000077500000000000000000000000001321131462300236165ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/jessevdk/go-flags/.travis.yml000066400000000000000000000022721321131462300257320ustar00rootroot00000000000000language: go install: # go-flags - go get -d -v ./... - go build -v ./... # linting - go get golang.org/x/tools/cmd/vet - go get github.com/golang/lint - go install github.com/golang/lint/golint # code coverage - go get golang.org/x/tools/cmd/cover - go get github.com/onsi/ginkgo/ginkgo - go get github.com/modocache/gover - if [ "$TRAVIS_SECURE_ENV_VARS" = "true" ]; then go get github.com/mattn/goveralls; fi script: # go-flags - $(exit $(gofmt -l . | wc -l)) - go test -v ./... # linting - go tool vet -all=true -v=true . || true - $(go env GOPATH | awk 'BEGIN{FS=":"} {print $1}')/bin/golint ./... # code coverage - $(go env GOPATH | awk 'BEGIN{FS=":"} {print $1}')/bin/ginkgo -r -cover - $(go env GOPATH | awk 'BEGIN{FS=":"} {print $1}')/bin/gover - if [ "$TRAVIS_SECURE_ENV_VARS" = "true" ]; then $(go env GOPATH | awk 'BEGIN{FS=":"} {print $1}')/bin/goveralls -coverprofile=gover.coverprofile -service=travis-ci -repotoken $COVERALLS_TOKEN; fi env: # coveralls.io secure: "RCYbiB4P0RjQRIoUx/vG/AjP3mmYCbzOmr86DCww1Z88yNcy3hYr3Cq8rpPtYU5v0g7wTpu4adaKIcqRE9xknYGbqj3YWZiCoBP1/n4Z+9sHW3Dsd9D/GRGeHUus0laJUGARjWoCTvoEtOgTdGQDoX7mH+pUUY0FBltNYUdOiiU=" mongo-tools-r3.6.3/vendor/src/github.com/jessevdk/go-flags/LICENSE000066400000000000000000000027531321131462300246320ustar00rootroot00000000000000Copyright (c) 2012 Jesse van den Kieboom. 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. mongo-tools-r3.6.3/vendor/src/github.com/jessevdk/go-flags/README.md000066400000000000000000000114661321131462300251050ustar00rootroot00000000000000go-flags: a go library for parsing command line arguments ========================================================= [![GoDoc](https://godoc.org/github.com/jessevdk/go-flags?status.png)](https://godoc.org/github.com/jessevdk/go-flags) [![Build Status](https://travis-ci.org/jessevdk/go-flags.svg?branch=master)](https://travis-ci.org/jessevdk/go-flags) [![Coverage Status](https://img.shields.io/coveralls/jessevdk/go-flags.svg)](https://coveralls.io/r/jessevdk/go-flags?branch=master) This library provides similar functionality to the builtin flag library of go, but provides much more functionality and nicer formatting. From the documentation: Package flags provides an extensive command line option parser. The flags package is similar in functionality to the go builtin flag package but provides more options and uses reflection to provide a convenient and succinct way of specifying command line options. Supported features: * Options with short names (-v) * Options with long names (--verbose) * Options with and without arguments (bool v.s. other type) * Options with optional arguments and default values * Multiple option groups each containing a set of options * Generate and print well-formatted help message * Passing remaining command line arguments after -- (optional) * Ignoring unknown command line options (optional) * Supports -I/usr/include -I=/usr/include -I /usr/include option argument specification * Supports multiple short options -aux * Supports all primitive go types (string, int{8..64}, uint{8..64}, float) * Supports same option multiple times (can store in slice or last option counts) * Supports maps * Supports function callbacks * Supports namespaces for (nested) option groups The flags package uses structs, reflection and struct field tags to allow users to specify command line options. This results in very simple and concise specification of your application options. For example: ```go type Options struct { Verbose []bool `short:"v" long:"verbose" description:"Show verbose debug information"` } ``` This specifies one option with a short name -v and a long name --verbose. When either -v or --verbose is found on the command line, a 'true' value will be appended to the Verbose field. e.g. when specifying -vvv, the resulting value of Verbose will be {[true, true, true]}. Example: -------- ```go var opts struct { // Slice of bool will append 'true' each time the option // is encountered (can be set multiple times, like -vvv) Verbose []bool `short:"v" long:"verbose" description:"Show verbose debug information"` // Example of automatic marshalling to desired type (uint) Offset uint `long:"offset" description:"Offset"` // Example of a callback, called each time the option is found. Call func(string) `short:"c" description:"Call phone number"` // Example of a required flag Name string `short:"n" long:"name" description:"A name" required:"true"` // Example of a value name File string `short:"f" long:"file" description:"A file" value-name:"FILE"` // Example of a pointer Ptr *int `short:"p" description:"A pointer to an integer"` // Example of a slice of strings StringSlice []string `short:"s" description:"A slice of strings"` // Example of a slice of pointers PtrSlice []*string `long:"ptrslice" description:"A slice of pointers to string"` // Example of a map IntMap map[string]int `long:"intmap" description:"A map from string to int"` } // Callback which will invoke callto: to call a number. // Note that this works just on OS X (and probably only with // Skype) but it shows the idea. opts.Call = func(num string) { cmd := exec.Command("open", "callto:"+num) cmd.Start() cmd.Process.Release() } // Make some fake arguments to parse. args := []string{ "-vv", "--offset=5", "-n", "Me", "-p", "3", "-s", "hello", "-s", "world", "--ptrslice", "hello", "--ptrslice", "world", "--intmap", "a:1", "--intmap", "b:5", "arg1", "arg2", "arg3", } // Parse flags from `args'. Note that here we use flags.ParseArgs for // the sake of making a working example. Normally, you would simply use // flags.Parse(&opts) which uses os.Args args, err := flags.ParseArgs(&opts, args) if err != nil { panic(err) os.Exit(1) } fmt.Printf("Verbosity: %v\n", opts.Verbose) fmt.Printf("Offset: %d\n", opts.Offset) fmt.Printf("Name: %s\n", opts.Name) fmt.Printf("Ptr: %d\n", *opts.Ptr) fmt.Printf("StringSlice: %v\n", opts.StringSlice) fmt.Printf("PtrSlice: [%v %v]\n", *opts.PtrSlice[0], *opts.PtrSlice[1]) fmt.Printf("IntMap: [a:%v b:%v]\n", opts.IntMap["a"], opts.IntMap["b"]) fmt.Printf("Remaining args: %s\n", strings.Join(args, " ")) // Output: Verbosity: [true true] // Offset: 5 // Name: Me // Ptr: 3 // StringSlice: [hello world] // PtrSlice: [hello world] // IntMap: [a:1 b:5] // Remaining args: arg1 arg2 arg3 ``` More information can be found in the godocs: mongo-tools-r3.6.3/vendor/src/github.com/jessevdk/go-flags/arg.go000066400000000000000000000007141321131462300247200ustar00rootroot00000000000000package flags import ( "reflect" ) // Arg represents a positional argument on the command line. type Arg struct { // The name of the positional argument (used in the help) Name string // A description of the positional argument (used in the help) Description string // Whether a positional argument is required Required int value reflect.Value tag multiTag } func (a *Arg) isRemaining() bool { return a.value.Type().Kind() == reflect.Slice } mongo-tools-r3.6.3/vendor/src/github.com/jessevdk/go-flags/arg_test.go000066400000000000000000000057041321131462300257630ustar00rootroot00000000000000package flags import ( "testing" ) func TestPositional(t *testing.T) { var opts = struct { Value bool `short:"v"` Positional struct { Command int Filename string Rest []string } `positional-args:"yes" required:"yes"` }{} p := NewParser(&opts, Default) ret, err := p.ParseArgs([]string{"10", "arg_test.go", "a", "b"}) if err != nil { t.Fatalf("Unexpected error: %v", err) return } if opts.Positional.Command != 10 { t.Fatalf("Expected opts.Positional.Command to be 10, but got %v", opts.Positional.Command) } if opts.Positional.Filename != "arg_test.go" { t.Fatalf("Expected opts.Positional.Filename to be \"arg_test.go\", but got %v", opts.Positional.Filename) } assertStringArray(t, opts.Positional.Rest, []string{"a", "b"}) assertStringArray(t, ret, []string{}) } func TestPositionalRequired(t *testing.T) { var opts = struct { Value bool `short:"v"` Positional struct { Command int Filename string Rest []string } `positional-args:"yes" required:"yes"` }{} p := NewParser(&opts, None) _, err := p.ParseArgs([]string{"10"}) assertError(t, err, ErrRequired, "the required argument `Filename` was not provided") } func TestPositionalRequiredRest1Fail(t *testing.T) { var opts = struct { Value bool `short:"v"` Positional struct { Rest []string `required:"yes"` } `positional-args:"yes"` }{} p := NewParser(&opts, None) _, err := p.ParseArgs([]string{}) assertError(t, err, ErrRequired, "the required argument `Rest (at least 1 argument)` was not provided") } func TestPositionalRequiredRest1Pass(t *testing.T) { var opts = struct { Value bool `short:"v"` Positional struct { Rest []string `required:"yes"` } `positional-args:"yes"` }{} p := NewParser(&opts, None) _, err := p.ParseArgs([]string{"rest1"}) if err != nil { t.Fatalf("Unexpected error: %v", err) return } if len(opts.Positional.Rest) != 1 { t.Fatalf("Expected 1 positional rest argument") } assertString(t, opts.Positional.Rest[0], "rest1") } func TestPositionalRequiredRest2Fail(t *testing.T) { var opts = struct { Value bool `short:"v"` Positional struct { Rest []string `required:"2"` } `positional-args:"yes"` }{} p := NewParser(&opts, None) _, err := p.ParseArgs([]string{"rest1"}) assertError(t, err, ErrRequired, "the required argument `Rest (at least 2 arguments, but got only 1)` was not provided") } func TestPositionalRequiredRest2Pass(t *testing.T) { var opts = struct { Value bool `short:"v"` Positional struct { Rest []string `required:"2"` } `positional-args:"yes"` }{} p := NewParser(&opts, None) _, err := p.ParseArgs([]string{"rest1", "rest2", "rest3"}) if err != nil { t.Fatalf("Unexpected error: %v", err) return } if len(opts.Positional.Rest) != 3 { t.Fatalf("Expected 3 positional rest argument") } assertString(t, opts.Positional.Rest[0], "rest1") assertString(t, opts.Positional.Rest[1], "rest2") assertString(t, opts.Positional.Rest[2], "rest3") } mongo-tools-r3.6.3/vendor/src/github.com/jessevdk/go-flags/assert_test.go000066400000000000000000000071021321131462300265050ustar00rootroot00000000000000package flags import ( "fmt" "io" "io/ioutil" "os" "os/exec" "path" "runtime" "testing" ) func assertCallerInfo() (string, int) { ptr := make([]uintptr, 15) n := runtime.Callers(1, ptr) if n == 0 { return "", 0 } mef := runtime.FuncForPC(ptr[0]) mefile, meline := mef.FileLine(ptr[0]) for i := 2; i < n; i++ { f := runtime.FuncForPC(ptr[i]) file, line := f.FileLine(ptr[i]) if file != mefile { return file, line } } return mefile, meline } func assertErrorf(t *testing.T, format string, args ...interface{}) { msg := fmt.Sprintf(format, args...) file, line := assertCallerInfo() t.Errorf("%s:%d: %s", path.Base(file), line, msg) } func assertFatalf(t *testing.T, format string, args ...interface{}) { msg := fmt.Sprintf(format, args...) file, line := assertCallerInfo() t.Fatalf("%s:%d: %s", path.Base(file), line, msg) } func assertString(t *testing.T, a string, b string) { if a != b { assertErrorf(t, "Expected %#v, but got %#v", b, a) } } func assertStringArray(t *testing.T, a []string, b []string) { if len(a) != len(b) { assertErrorf(t, "Expected %#v, but got %#v", b, a) return } for i, v := range a { if b[i] != v { assertErrorf(t, "Expected %#v, but got %#v", b, a) return } } } func assertBoolArray(t *testing.T, a []bool, b []bool) { if len(a) != len(b) { assertErrorf(t, "Expected %#v, but got %#v", b, a) return } for i, v := range a { if b[i] != v { assertErrorf(t, "Expected %#v, but got %#v", b, a) return } } } func assertParserSuccess(t *testing.T, data interface{}, args ...string) (*Parser, []string) { parser := NewParser(data, Default&^PrintErrors) ret, err := parser.ParseArgs(args) if err != nil { t.Fatalf("Unexpected parse error: %s", err) return nil, nil } return parser, ret } func assertParseSuccess(t *testing.T, data interface{}, args ...string) []string { _, ret := assertParserSuccess(t, data, args...) return ret } func assertError(t *testing.T, err error, typ ErrorType, msg string) { if err == nil { assertFatalf(t, "Expected error: %s", msg) return } if e, ok := err.(*Error); !ok { assertFatalf(t, "Expected Error type, but got %#v", err) } else { if e.Type != typ { assertErrorf(t, "Expected error type {%s}, but got {%s}", typ, e.Type) } if e.Message != msg { assertErrorf(t, "Expected error message %#v, but got %#v", msg, e.Message) } } } func assertParseFail(t *testing.T, typ ErrorType, msg string, data interface{}, args ...string) []string { parser := NewParser(data, Default&^PrintErrors) ret, err := parser.ParseArgs(args) assertError(t, err, typ, msg) return ret } func diff(a, b string) (string, error) { atmp, err := ioutil.TempFile("", "help-diff") if err != nil { return "", err } btmp, err := ioutil.TempFile("", "help-diff") if err != nil { return "", err } if _, err := io.WriteString(atmp, a); err != nil { return "", err } if _, err := io.WriteString(btmp, b); err != nil { return "", err } ret, err := exec.Command("diff", "-u", "-d", "--label", "got", atmp.Name(), "--label", "expected", btmp.Name()).Output() os.Remove(atmp.Name()) os.Remove(btmp.Name()) if err.Error() == "exit status 1" { return string(ret), nil } return string(ret), err } func assertDiff(t *testing.T, actual, expected, msg string) { if actual == expected { return } ret, err := diff(actual, expected) if err != nil { assertErrorf(t, "Unexpected diff error: %s", err) assertErrorf(t, "Unexpected %s, expected:\n\n%s\n\nbut got\n\n%s", msg, expected, actual) } else { assertErrorf(t, "Unexpected %s:\n\n%s", msg, ret) } } mongo-tools-r3.6.3/vendor/src/github.com/jessevdk/go-flags/check_crosscompile.sh000077500000000000000000000005411321131462300300140ustar00rootroot00000000000000#!/bin/bash set -e echo '# linux arm7' GOARM=7 GOARCH=arm GOOS=linux go build echo '# linux arm5' GOARM=5 GOARCH=arm GOOS=linux go build echo '# windows 386' GOARCH=386 GOOS=windows go build echo '# windows amd64' GOARCH=amd64 GOOS=windows go build echo '# darwin' GOARCH=amd64 GOOS=darwin go build echo '# freebsd' GOARCH=amd64 GOOS=freebsd go build mongo-tools-r3.6.3/vendor/src/github.com/jessevdk/go-flags/closest.go000066400000000000000000000017031321131462300256220ustar00rootroot00000000000000package flags func levenshtein(s string, t string) int { if len(s) == 0 { return len(t) } if len(t) == 0 { return len(s) } dists := make([][]int, len(s)+1) for i := range dists { dists[i] = make([]int, len(t)+1) dists[i][0] = i } for j := range t { dists[0][j] = j } for i, sc := range s { for j, tc := range t { if sc == tc { dists[i+1][j+1] = dists[i][j] } else { dists[i+1][j+1] = dists[i][j] + 1 if dists[i+1][j] < dists[i+1][j+1] { dists[i+1][j+1] = dists[i+1][j] + 1 } if dists[i][j+1] < dists[i+1][j+1] { dists[i+1][j+1] = dists[i][j+1] + 1 } } } } return dists[len(s)][len(t)] } func closestChoice(cmd string, choices []string) (string, int) { if len(choices) == 0 { return "", 0 } mincmd := -1 mindist := -1 for i, c := range choices { l := levenshtein(cmd, c) if mincmd < 0 || l < mindist { mindist = l mincmd = i } } return choices[mincmd], mindist } mongo-tools-r3.6.3/vendor/src/github.com/jessevdk/go-flags/command.go000066400000000000000000000226701321131462300255720ustar00rootroot00000000000000package flags import ( "reflect" "sort" "strconv" "strings" "unsafe" ) // Command represents an application command. Commands can be added to the // parser (which itself is a command) and are selected/executed when its name // is specified on the command line. The Command type embeds a Group and // therefore also carries a set of command specific options. type Command struct { // Embedded, see Group for more information *Group // The name by which the command can be invoked Name string // The active sub command (set by parsing) or nil Active *Command // Whether subcommands are optional SubcommandsOptional bool // Aliases for the command Aliases []string // Whether positional arguments are required ArgsRequired bool commands []*Command hasBuiltinHelpGroup bool args []*Arg } // Commander is an interface which can be implemented by any command added in // the options. When implemented, the Execute method will be called for the last // specified (sub)command providing the remaining command line arguments. type Commander interface { // Execute will be called for the last active (sub)command. The // args argument contains the remaining command line arguments. The // error that Execute returns will be eventually passed out of the // Parse method of the Parser. Execute(args []string) error } // Usage is an interface which can be implemented to show a custom usage string // in the help message shown for a command. type Usage interface { // Usage is called for commands to allow customized printing of command // usage in the generated help message. Usage() string } type lookup struct { shortNames map[string]*Option longNames map[string]*Option commands map[string]*Command } // AddCommand adds a new command to the parser with the given name and data. The // data needs to be a pointer to a struct from which the fields indicate which // options are in the command. The provided data can implement the Command and // Usage interfaces. func (c *Command) AddCommand(command string, shortDescription string, longDescription string, data interface{}) (*Command, error) { cmd := newCommand(command, shortDescription, longDescription, data) cmd.parent = c if err := cmd.scan(); err != nil { return nil, err } c.commands = append(c.commands, cmd) return cmd, nil } // AddGroup adds a new group to the command with the given name and data. The // data needs to be a pointer to a struct from which the fields indicate which // options are in the group. func (c *Command) AddGroup(shortDescription string, longDescription string, data interface{}) (*Group, error) { group := newGroup(shortDescription, longDescription, data) group.parent = c if err := group.scanType(c.scanSubcommandHandler(group)); err != nil { return nil, err } c.groups = append(c.groups, group) return group, nil } // Commands returns a list of subcommands of this command. func (c *Command) Commands() []*Command { return c.commands } // Find locates the subcommand with the given name and returns it. If no such // command can be found Find will return nil. func (c *Command) Find(name string) *Command { for _, cc := range c.commands { if cc.match(name) { return cc } } return nil } // Find an option that is part of the command, or any of its // parent commands, by matching its long name // (including the option namespace). func (c *Command) FindOptionByLongName(longName string) (option *Option) { for option == nil && c != nil { option = c.Group.FindOptionByLongName(longName) c, _ = c.parent.(*Command) } return option } // Find an option that is part of the command, or any of its // parent commands, by matching its long name // (including the option namespace). func (c *Command) FindOptionByShortName(shortName rune) (option *Option) { for option == nil && c != nil { option = c.Group.FindOptionByShortName(shortName) c, _ = c.parent.(*Command) } return option } // Args returns a list of positional arguments associated with this command. func (c *Command) Args() []*Arg { ret := make([]*Arg, len(c.args)) copy(ret, c.args) return ret } func newCommand(name string, shortDescription string, longDescription string, data interface{}) *Command { return &Command{ Group: newGroup(shortDescription, longDescription, data), Name: name, } } func (c *Command) scanSubcommandHandler(parentg *Group) scanHandler { f := func(realval reflect.Value, sfield *reflect.StructField) (bool, error) { mtag := newMultiTag(string(sfield.Tag)) if err := mtag.Parse(); err != nil { return true, err } positional := mtag.Get("positional-args") if len(positional) != 0 { stype := realval.Type() for i := 0; i < stype.NumField(); i++ { field := stype.Field(i) m := newMultiTag((string(field.Tag))) if err := m.Parse(); err != nil { return true, err } name := m.Get("positional-arg-name") if len(name) == 0 { name = field.Name } var required int sreq := m.Get("required") if sreq != "" { required = 1 if preq, err := strconv.ParseInt(sreq, 10, 32); err == nil { required = int(preq) } } arg := &Arg{ Name: name, Description: m.Get("description"), Required: required, value: realval.Field(i), tag: m, } c.args = append(c.args, arg) if len(mtag.Get("required")) != 0 { c.ArgsRequired = true } } return true, nil } subcommand := mtag.Get("command") if len(subcommand) != 0 { ptrval := reflect.NewAt(realval.Type(), unsafe.Pointer(realval.UnsafeAddr())) shortDescription := mtag.Get("description") longDescription := mtag.Get("long-description") subcommandsOptional := mtag.Get("subcommands-optional") aliases := mtag.GetMany("alias") subc, err := c.AddCommand(subcommand, shortDescription, longDescription, ptrval.Interface()) if err != nil { return true, err } subc.Hidden = mtag.Get("hidden") != "" if len(subcommandsOptional) > 0 { subc.SubcommandsOptional = true } if len(aliases) > 0 { subc.Aliases = aliases } return true, nil } return parentg.scanSubGroupHandler(realval, sfield) } return f } func (c *Command) scan() error { return c.scanType(c.scanSubcommandHandler(c.Group)) } func (c *Command) eachOption(f func(*Command, *Group, *Option)) { c.eachCommand(func(c *Command) { c.eachGroup(func(g *Group) { for _, option := range g.options { f(c, g, option) } }) }, true) } func (c *Command) eachCommand(f func(*Command), recurse bool) { f(c) for _, cc := range c.commands { if recurse { cc.eachCommand(f, true) } else { f(cc) } } } func (c *Command) eachActiveGroup(f func(cc *Command, g *Group)) { c.eachGroup(func(g *Group) { f(c, g) }) if c.Active != nil { c.Active.eachActiveGroup(f) } } func (c *Command) addHelpGroups(showHelp func() error) { if !c.hasBuiltinHelpGroup { c.addHelpGroup(showHelp) c.hasBuiltinHelpGroup = true } for _, cc := range c.commands { cc.addHelpGroups(showHelp) } } func (c *Command) makeLookup() lookup { ret := lookup{ shortNames: make(map[string]*Option), longNames: make(map[string]*Option), commands: make(map[string]*Command), } parent := c.parent var parents []*Command for parent != nil { if cmd, ok := parent.(*Command); ok { parents = append(parents, cmd) parent = cmd.parent } else { parent = nil } } for i := len(parents) - 1; i >= 0; i-- { parents[i].fillLookup(&ret, true) } c.fillLookup(&ret, false) return ret } func (c *Command) fillLookup(ret *lookup, onlyOptions bool) { c.eachGroup(func(g *Group) { for _, option := range g.options { if option.ShortName != 0 { ret.shortNames[string(option.ShortName)] = option } if len(option.LongName) > 0 { ret.longNames[option.LongNameWithNamespace()] = option } } }) if onlyOptions { return } for _, subcommand := range c.commands { ret.commands[subcommand.Name] = subcommand for _, a := range subcommand.Aliases { ret.commands[a] = subcommand } } } func (c *Command) groupByName(name string) *Group { if grp := c.Group.groupByName(name); grp != nil { return grp } for _, subc := range c.commands { prefix := subc.Name + "." if strings.HasPrefix(name, prefix) { if grp := subc.groupByName(name[len(prefix):]); grp != nil { return grp } } else if name == subc.Name { return subc.Group } } return nil } type commandList []*Command func (c commandList) Less(i, j int) bool { return c[i].Name < c[j].Name } func (c commandList) Len() int { return len(c) } func (c commandList) Swap(i, j int) { c[i], c[j] = c[j], c[i] } func (c *Command) sortedVisibleCommands() []*Command { ret := commandList(c.visibleCommands()) sort.Sort(ret) return []*Command(ret) } func (c *Command) visibleCommands() []*Command { ret := make([]*Command, 0, len(c.commands)) for _, cmd := range c.commands { if !cmd.Hidden { ret = append(ret, cmd) } } return ret } func (c *Command) match(name string) bool { if c.Name == name { return true } for _, v := range c.Aliases { if v == name { return true } } return false } func (c *Command) hasCliOptions() bool { ret := false c.eachGroup(func(g *Group) { if g.isBuiltinHelp { return } for _, opt := range g.options { if opt.canCli() { ret = true } } }) return ret } func (c *Command) fillParseState(s *parseState) { s.positional = make([]*Arg, len(c.args)) copy(s.positional, c.args) s.lookup = c.makeLookup() s.command = c } mongo-tools-r3.6.3/vendor/src/github.com/jessevdk/go-flags/command_test.go000066400000000000000000000243121321131462300266240ustar00rootroot00000000000000package flags import ( "fmt" "testing" ) func TestCommandInline(t *testing.T) { var opts = struct { Value bool `short:"v"` Command struct { G bool `short:"g"` } `command:"cmd"` }{} p, ret := assertParserSuccess(t, &opts, "-v", "cmd", "-g") assertStringArray(t, ret, []string{}) if p.Active == nil { t.Errorf("Expected active command") } if !opts.Value { t.Errorf("Expected Value to be true") } if !opts.Command.G { t.Errorf("Expected Command.G to be true") } if p.Command.Find("cmd") != p.Active { t.Errorf("Expected to find command `cmd' to be active") } } func TestCommandInlineMulti(t *testing.T) { var opts = struct { Value bool `short:"v"` C1 struct { } `command:"c1"` C2 struct { G bool `short:"g"` } `command:"c2"` }{} p, ret := assertParserSuccess(t, &opts, "-v", "c2", "-g") assertStringArray(t, ret, []string{}) if p.Active == nil { t.Errorf("Expected active command") } if !opts.Value { t.Errorf("Expected Value to be true") } if !opts.C2.G { t.Errorf("Expected C2.G to be true") } if p.Command.Find("c1") == nil { t.Errorf("Expected to find command `c1'") } if c2 := p.Command.Find("c2"); c2 == nil { t.Errorf("Expected to find command `c2'") } else if c2 != p.Active { t.Errorf("Expected to find command `c2' to be active") } } func TestCommandFlagOrder1(t *testing.T) { var opts = struct { Value bool `short:"v"` Command struct { G bool `short:"g"` } `command:"cmd"` }{} assertParseFail(t, ErrUnknownFlag, "unknown flag `g'", &opts, "-v", "-g", "cmd") } func TestCommandFlagOrder2(t *testing.T) { var opts = struct { Value bool `short:"v"` Command struct { G bool `short:"g"` } `command:"cmd"` }{} assertParseSuccess(t, &opts, "cmd", "-v", "-g") if !opts.Value { t.Errorf("Expected Value to be true") } if !opts.Command.G { t.Errorf("Expected Command.G to be true") } } func TestCommandFlagOrderSub(t *testing.T) { var opts = struct { Value bool `short:"v"` Command struct { G bool `short:"g"` SubCommand struct { B bool `short:"b"` } `command:"sub"` } `command:"cmd"` }{} assertParseSuccess(t, &opts, "cmd", "sub", "-v", "-g", "-b") if !opts.Value { t.Errorf("Expected Value to be true") } if !opts.Command.G { t.Errorf("Expected Command.G to be true") } if !opts.Command.SubCommand.B { t.Errorf("Expected Command.SubCommand.B to be true") } } func TestCommandFlagOverride1(t *testing.T) { var opts = struct { Value bool `short:"v"` Command struct { Value bool `short:"v"` } `command:"cmd"` }{} assertParseSuccess(t, &opts, "-v", "cmd") if !opts.Value { t.Errorf("Expected Value to be true") } if opts.Command.Value { t.Errorf("Expected Command.Value to be false") } } func TestCommandFlagOverride2(t *testing.T) { var opts = struct { Value bool `short:"v"` Command struct { Value bool `short:"v"` } `command:"cmd"` }{} assertParseSuccess(t, &opts, "cmd", "-v") if opts.Value { t.Errorf("Expected Value to be false") } if !opts.Command.Value { t.Errorf("Expected Command.Value to be true") } } func TestCommandFlagOverrideSub(t *testing.T) { var opts = struct { Value bool `short:"v"` Command struct { Value bool `short:"v"` SubCommand struct { Value bool `short:"v"` } `command:"sub"` } `command:"cmd"` }{} assertParseSuccess(t, &opts, "cmd", "sub", "-v") if opts.Value { t.Errorf("Expected Value to be false") } if opts.Command.Value { t.Errorf("Expected Command.Value to be false") } if !opts.Command.SubCommand.Value { t.Errorf("Expected Command.Value to be true") } } func TestCommandFlagOverrideSub2(t *testing.T) { var opts = struct { Value bool `short:"v"` Command struct { Value bool `short:"v"` SubCommand struct { G bool `short:"g"` } `command:"sub"` } `command:"cmd"` }{} assertParseSuccess(t, &opts, "cmd", "sub", "-v") if opts.Value { t.Errorf("Expected Value to be false") } if !opts.Command.Value { t.Errorf("Expected Command.Value to be true") } } func TestCommandEstimate(t *testing.T) { var opts = struct { Value bool `short:"v"` Cmd1 struct { } `command:"remove"` Cmd2 struct { } `command:"add"` }{} p := NewParser(&opts, None) _, err := p.ParseArgs([]string{}) assertError(t, err, ErrCommandRequired, "Please specify one command of: add or remove") } func TestCommandEstimate2(t *testing.T) { var opts = struct { Value bool `short:"v"` Cmd1 struct { } `command:"remove"` Cmd2 struct { } `command:"add"` }{} p := NewParser(&opts, None) _, err := p.ParseArgs([]string{"rmive"}) assertError(t, err, ErrUnknownCommand, "Unknown command `rmive', did you mean `remove'?") } type testCommand struct { G bool `short:"g"` Executed bool EArgs []string } func (c *testCommand) Execute(args []string) error { c.Executed = true c.EArgs = args return nil } func TestCommandExecute(t *testing.T) { var opts = struct { Value bool `short:"v"` Command testCommand `command:"cmd"` }{} assertParseSuccess(t, &opts, "-v", "cmd", "-g", "a", "b") if !opts.Value { t.Errorf("Expected Value to be true") } if !opts.Command.Executed { t.Errorf("Did not execute command") } if !opts.Command.G { t.Errorf("Expected Command.C to be true") } assertStringArray(t, opts.Command.EArgs, []string{"a", "b"}) } func TestCommandClosest(t *testing.T) { var opts = struct { Value bool `short:"v"` Cmd1 struct { } `command:"remove"` Cmd2 struct { } `command:"add"` }{} args := assertParseFail(t, ErrUnknownCommand, "Unknown command `addd', did you mean `add'?", &opts, "-v", "addd") assertStringArray(t, args, []string{"addd"}) } func TestCommandAdd(t *testing.T) { var opts = struct { Value bool `short:"v"` }{} var cmd = struct { G bool `short:"g"` }{} p := NewParser(&opts, Default) c, err := p.AddCommand("cmd", "", "", &cmd) if err != nil { t.Fatalf("Unexpected error: %v", err) return } ret, err := p.ParseArgs([]string{"-v", "cmd", "-g", "rest"}) if err != nil { t.Fatalf("Unexpected error: %v", err) return } assertStringArray(t, ret, []string{"rest"}) if !opts.Value { t.Errorf("Expected Value to be true") } if !cmd.G { t.Errorf("Expected Command.G to be true") } if p.Command.Find("cmd") != c { t.Errorf("Expected to find command `cmd'") } if p.Commands()[0] != c { t.Errorf("Expected command %#v, but got %#v", c, p.Commands()[0]) } if c.Options()[0].ShortName != 'g' { t.Errorf("Expected short name `g' but got %v", c.Options()[0].ShortName) } } func TestCommandNestedInline(t *testing.T) { var opts = struct { Value bool `short:"v"` Command struct { G bool `short:"g"` Nested struct { N string `long:"n"` } `command:"nested"` } `command:"cmd"` }{} p, ret := assertParserSuccess(t, &opts, "-v", "cmd", "-g", "nested", "--n", "n", "rest") assertStringArray(t, ret, []string{"rest"}) if !opts.Value { t.Errorf("Expected Value to be true") } if !opts.Command.G { t.Errorf("Expected Command.G to be true") } assertString(t, opts.Command.Nested.N, "n") if c := p.Command.Find("cmd"); c == nil { t.Errorf("Expected to find command `cmd'") } else { if c != p.Active { t.Errorf("Expected `cmd' to be the active parser command") } if nested := c.Find("nested"); nested == nil { t.Errorf("Expected to find command `nested'") } else if nested != c.Active { t.Errorf("Expected to find command `nested' to be the active `cmd' command") } } } func TestRequiredOnCommand(t *testing.T) { var opts = struct { Value bool `short:"v" required:"true"` Command struct { G bool `short:"g"` } `command:"cmd"` }{} assertParseFail(t, ErrRequired, fmt.Sprintf("the required flag `%cv' was not specified", defaultShortOptDelimiter), &opts, "cmd") } func TestRequiredAllOnCommand(t *testing.T) { var opts = struct { Value bool `short:"v" required:"true"` Missing bool `long:"missing" required:"true"` Command struct { G bool `short:"g"` } `command:"cmd"` }{} assertParseFail(t, ErrRequired, fmt.Sprintf("the required flags `%smissing' and `%cv' were not specified", defaultLongOptDelimiter, defaultShortOptDelimiter), &opts, "cmd") } func TestDefaultOnCommand(t *testing.T) { var opts = struct { Command struct { G bool `short:"g" default:"true"` } `command:"cmd"` }{} assertParseSuccess(t, &opts, "cmd") if !opts.Command.G { t.Errorf("Expected G to be true") } } func TestSubcommandsOptional(t *testing.T) { var opts = struct { Value bool `short:"v"` Cmd1 struct { } `command:"remove"` Cmd2 struct { } `command:"add"` }{} p := NewParser(&opts, None) p.SubcommandsOptional = true _, err := p.ParseArgs([]string{"-v"}) if err != nil { t.Fatalf("Unexpected error: %v", err) return } if !opts.Value { t.Errorf("Expected Value to be true") } } func TestCommandAlias(t *testing.T) { var opts = struct { Command struct { G bool `short:"g" default:"true"` } `command:"cmd" alias:"cm"` }{} assertParseSuccess(t, &opts, "cm") if !opts.Command.G { t.Errorf("Expected G to be true") } } func TestSubCommandFindOptionByLongFlag(t *testing.T) { var opts struct { Testing bool `long:"testing" description:"Testing"` } var cmd struct { Other bool `long:"other" description:"Other"` } p := NewParser(&opts, Default) c, _ := p.AddCommand("command", "Short", "Long", &cmd) opt := c.FindOptionByLongName("other") if opt == nil { t.Errorf("Expected option, but found none") } assertString(t, opt.LongName, "other") opt = c.FindOptionByLongName("testing") if opt == nil { t.Errorf("Expected option, but found none") } assertString(t, opt.LongName, "testing") } func TestSubCommandFindOptionByShortFlag(t *testing.T) { var opts struct { Testing bool `short:"t" description:"Testing"` } var cmd struct { Other bool `short:"o" description:"Other"` } p := NewParser(&opts, Default) c, _ := p.AddCommand("command", "Short", "Long", &cmd) opt := c.FindOptionByShortName('o') if opt == nil { t.Errorf("Expected option, but found none") } if opt.ShortName != 'o' { t.Errorf("Expected 'o', but got %v", opt.ShortName) } opt = c.FindOptionByShortName('t') if opt == nil { t.Errorf("Expected option, but found none") } if opt.ShortName != 't' { t.Errorf("Expected 'o', but got %v", opt.ShortName) } } mongo-tools-r3.6.3/vendor/src/github.com/jessevdk/go-flags/completion.go000066400000000000000000000151371321131462300263250ustar00rootroot00000000000000package flags import ( "fmt" "path/filepath" "reflect" "sort" "strings" "unicode/utf8" ) // Completion is a type containing information of a completion. type Completion struct { // The completed item Item string // A description of the completed item (optional) Description string } type completions []Completion func (c completions) Len() int { return len(c) } func (c completions) Less(i, j int) bool { return c[i].Item < c[j].Item } func (c completions) Swap(i, j int) { c[i], c[j] = c[j], c[i] } // Completer is an interface which can be implemented by types // to provide custom command line argument completion. type Completer interface { // Complete receives a prefix representing a (partial) value // for its type and should provide a list of possible valid // completions. Complete(match string) []Completion } type completion struct { parser *Parser } // Filename is a string alias which provides filename completion. type Filename string func completionsWithoutDescriptions(items []string) []Completion { ret := make([]Completion, len(items)) for i, v := range items { ret[i].Item = v } return ret } // Complete returns a list of existing files with the given // prefix. func (f *Filename) Complete(match string) []Completion { ret, _ := filepath.Glob(match + "*") return completionsWithoutDescriptions(ret) } func (c *completion) skipPositional(s *parseState, n int) { if n >= len(s.positional) { s.positional = nil } else { s.positional = s.positional[n:] } } func (c *completion) completeOptionNames(names map[string]*Option, prefix string, match string) []Completion { n := make([]Completion, 0, len(names)) for k, opt := range names { if strings.HasPrefix(k, match) { n = append(n, Completion{ Item: prefix + k, Description: opt.Description, }) } } return n } func (c *completion) completeLongNames(s *parseState, prefix string, match string) []Completion { return c.completeOptionNames(s.lookup.longNames, prefix, match) } func (c *completion) completeShortNames(s *parseState, prefix string, match string) []Completion { if len(match) != 0 { return []Completion{ Completion{ Item: prefix + match, }, } } return c.completeOptionNames(s.lookup.shortNames, prefix, match) } func (c *completion) completeCommands(s *parseState, match string) []Completion { n := make([]Completion, 0, len(s.command.commands)) for _, cmd := range s.command.commands { if cmd.data != c && strings.HasPrefix(cmd.Name, match) { n = append(n, Completion{ Item: cmd.Name, Description: cmd.ShortDescription, }) } } return n } func (c *completion) completeValue(value reflect.Value, prefix string, match string) []Completion { i := value.Interface() var ret []Completion if cmp, ok := i.(Completer); ok { ret = cmp.Complete(match) } else if value.CanAddr() { if cmp, ok = value.Addr().Interface().(Completer); ok { ret = cmp.Complete(match) } } for i, v := range ret { ret[i].Item = prefix + v.Item } return ret } func (c *completion) completeArg(arg *Arg, prefix string, match string) []Completion { if arg.isRemaining() { // For remaining positional args (that are parsed into a slice), complete // based on the element type. return c.completeValue(reflect.New(arg.value.Type().Elem()), prefix, match) } return c.completeValue(arg.value, prefix, match) } func (c *completion) complete(args []string) []Completion { if len(args) == 0 { args = []string{""} } s := &parseState{ args: args, } c.parser.fillParseState(s) var opt *Option for len(s.args) > 1 { arg := s.pop() if (c.parser.Options&PassDoubleDash) != None && arg == "--" { opt = nil c.skipPositional(s, len(s.args)-1) break } if argumentIsOption(arg) { prefix, optname, islong := stripOptionPrefix(arg) optname, _, argument := splitOption(prefix, optname, islong) if argument == nil { var o *Option canarg := true if islong { o = s.lookup.longNames[optname] } else { for i, r := range optname { sname := string(r) o = s.lookup.shortNames[sname] if o == nil { break } if i == 0 && o.canArgument() && len(optname) != len(sname) { canarg = false break } } } if o == nil && (c.parser.Options&PassAfterNonOption) != None { opt = nil c.skipPositional(s, len(s.args)-1) break } else if o != nil && o.canArgument() && !o.OptionalArgument && canarg { if len(s.args) > 1 { s.pop() } else { opt = o } } } } else { if len(s.positional) > 0 { if !s.positional[0].isRemaining() { // Don't advance beyond a remaining positional arg (because // it consumes all subsequent args). s.positional = s.positional[1:] } } else if cmd, ok := s.lookup.commands[arg]; ok { cmd.fillParseState(s) } opt = nil } } lastarg := s.args[len(s.args)-1] var ret []Completion if opt != nil { // Completion for the argument of 'opt' ret = c.completeValue(opt.value, "", lastarg) } else if argumentStartsOption(lastarg) { // Complete the option prefix, optname, islong := stripOptionPrefix(lastarg) optname, split, argument := splitOption(prefix, optname, islong) if argument == nil && !islong { rname, n := utf8.DecodeRuneInString(optname) sname := string(rname) if opt := s.lookup.shortNames[sname]; opt != nil && opt.canArgument() { ret = c.completeValue(opt.value, prefix+sname, optname[n:]) } else { ret = c.completeShortNames(s, prefix, optname) } } else if argument != nil { if islong { opt = s.lookup.longNames[optname] } else { opt = s.lookup.shortNames[optname] } if opt != nil { ret = c.completeValue(opt.value, prefix+optname+split, *argument) } } else if islong { ret = c.completeLongNames(s, prefix, optname) } else { ret = c.completeShortNames(s, prefix, optname) } } else if len(s.positional) > 0 { // Complete for positional argument ret = c.completeArg(s.positional[0], "", lastarg) } else if len(s.command.commands) > 0 { // Complete for command ret = c.completeCommands(s, lastarg) } sort.Sort(completions(ret)) return ret } func (c *completion) print(items []Completion, showDescriptions bool) { if showDescriptions && len(items) > 1 { maxl := 0 for _, v := range items { if len(v.Item) > maxl { maxl = len(v.Item) } } for _, v := range items { fmt.Printf("%s", v.Item) if len(v.Description) > 0 { fmt.Printf("%s # %s", strings.Repeat(" ", maxl-len(v.Item)), v.Description) } fmt.Printf("\n") } } else { for _, v := range items { fmt.Println(v.Item) } } } mongo-tools-r3.6.3/vendor/src/github.com/jessevdk/go-flags/completion_test.go000066400000000000000000000143561321131462300273660ustar00rootroot00000000000000package flags import ( "bytes" "io" "os" "path" "path/filepath" "reflect" "runtime" "strings" "testing" ) type TestComplete struct { } func (t *TestComplete) Complete(match string) []Completion { options := []string{ "hello world", "hello universe", "hello multiverse", } ret := make([]Completion, 0, len(options)) for _, o := range options { if strings.HasPrefix(o, match) { ret = append(ret, Completion{ Item: o, }) } } return ret } var completionTestOptions struct { Verbose bool `short:"v" long:"verbose" description:"Verbose messages"` Debug bool `short:"d" long:"debug" description:"Enable debug"` Version bool `long:"version" description:"Show version"` Required bool `long:"required" required:"true" description:"This is required"` AddCommand struct { Positional struct { Filename Filename } `positional-args:"yes"` } `command:"add" description:"add an item"` AddMultiCommand struct { Positional struct { Filename []Filename } `positional-args:"yes"` } `command:"add-multi" description:"add multiple items"` RemoveCommand struct { Other bool `short:"o"` File Filename `short:"f" long:"filename"` } `command:"rm" description:"remove an item"` RenameCommand struct { Completed TestComplete `short:"c" long:"completed"` } `command:"rename" description:"rename an item"` } type completionTest struct { Args []string Completed []string ShowDescriptions bool } var completionTests []completionTest func init() { _, sourcefile, _, _ := runtime.Caller(0) completionTestSourcedir := filepath.Join(filepath.SplitList(path.Dir(sourcefile))...) completionTestFilename := []string{filepath.Join(completionTestSourcedir, "completion.go"), filepath.Join(completionTestSourcedir, "completion_test.go")} completionTests = []completionTest{ { // Short names []string{"-"}, []string{"-d", "-v"}, false, }, { // Short names concatenated []string{"-dv"}, []string{"-dv"}, false, }, { // Long names []string{"--"}, []string{"--debug", "--required", "--verbose", "--version"}, false, }, { // Long names with descriptions []string{"--"}, []string{ "--debug # Enable debug", "--required # This is required", "--verbose # Verbose messages", "--version # Show version", }, true, }, { // Long names partial []string{"--ver"}, []string{"--verbose", "--version"}, false, }, { // Commands []string{""}, []string{"add", "add-multi", "rename", "rm"}, false, }, { // Commands with descriptions []string{""}, []string{ "add # add an item", "add-multi # add multiple items", "rename # rename an item", "rm # remove an item", }, true, }, { // Commands partial []string{"r"}, []string{"rename", "rm"}, false, }, { // Positional filename []string{"add", filepath.Join(completionTestSourcedir, "completion")}, completionTestFilename, false, }, { // Multiple positional filename (1 arg) []string{"add-multi", filepath.Join(completionTestSourcedir, "completion")}, completionTestFilename, false, }, { // Multiple positional filename (2 args) []string{"add-multi", filepath.Join(completionTestSourcedir, "completion.go"), filepath.Join(completionTestSourcedir, "completion")}, completionTestFilename, false, }, { // Multiple positional filename (3 args) []string{"add-multi", filepath.Join(completionTestSourcedir, "completion.go"), filepath.Join(completionTestSourcedir, "completion.go"), filepath.Join(completionTestSourcedir, "completion")}, completionTestFilename, false, }, { // Flag filename []string{"rm", "-f", path.Join(completionTestSourcedir, "completion")}, completionTestFilename, false, }, { // Flag short concat last filename []string{"rm", "-of", path.Join(completionTestSourcedir, "completion")}, completionTestFilename, false, }, { // Flag concat filename []string{"rm", "-f" + path.Join(completionTestSourcedir, "completion")}, []string{"-f" + completionTestFilename[0], "-f" + completionTestFilename[1]}, false, }, { // Flag equal concat filename []string{"rm", "-f=" + path.Join(completionTestSourcedir, "completion")}, []string{"-f=" + completionTestFilename[0], "-f=" + completionTestFilename[1]}, false, }, { // Flag concat long filename []string{"rm", "--filename=" + path.Join(completionTestSourcedir, "completion")}, []string{"--filename=" + completionTestFilename[0], "--filename=" + completionTestFilename[1]}, false, }, { // Flag long filename []string{"rm", "--filename", path.Join(completionTestSourcedir, "completion")}, completionTestFilename, false, }, { // Custom completed []string{"rename", "-c", "hello un"}, []string{"hello universe"}, false, }, } } func TestCompletion(t *testing.T) { p := NewParser(&completionTestOptions, Default) c := &completion{parser: p} for _, test := range completionTests { if test.ShowDescriptions { continue } ret := c.complete(test.Args) items := make([]string, len(ret)) for i, v := range ret { items[i] = v.Item } if !reflect.DeepEqual(items, test.Completed) { t.Errorf("Args: %#v, %#v\n Expected: %#v\n Got: %#v", test.Args, test.ShowDescriptions, test.Completed, items) } } } func TestParserCompletion(t *testing.T) { for _, test := range completionTests { if test.ShowDescriptions { os.Setenv("GO_FLAGS_COMPLETION", "verbose") } else { os.Setenv("GO_FLAGS_COMPLETION", "1") } tmp := os.Stdout r, w, _ := os.Pipe() os.Stdout = w out := make(chan string) go func() { var buf bytes.Buffer io.Copy(&buf, r) out <- buf.String() }() p := NewParser(&completionTestOptions, None) p.CompletionHandler = func(items []Completion) { comp := &completion{parser: p} comp.print(items, test.ShowDescriptions) } _, err := p.ParseArgs(test.Args) w.Close() os.Stdout = tmp if err != nil { t.Fatalf("Unexpected error: %s", err) } got := strings.Split(strings.Trim(<-out, "\n"), "\n") if !reflect.DeepEqual(got, test.Completed) { t.Errorf("Expected: %#v\nGot: %#v", test.Completed, got) } } os.Setenv("GO_FLAGS_COMPLETION", "") } mongo-tools-r3.6.3/vendor/src/github.com/jessevdk/go-flags/convert.go000066400000000000000000000152151321131462300256310ustar00rootroot00000000000000// Copyright 2012 Jesse van den Kieboom. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package flags import ( "fmt" "reflect" "strconv" "strings" "time" ) // Marshaler is the interface implemented by types that can marshal themselves // to a string representation of the flag. type Marshaler interface { // MarshalFlag marshals a flag value to its string representation. MarshalFlag() (string, error) } // Unmarshaler is the interface implemented by types that can unmarshal a flag // argument to themselves. The provided value is directly passed from the // command line. type Unmarshaler interface { // UnmarshalFlag unmarshals a string value representation to the flag // value (which therefore needs to be a pointer receiver). UnmarshalFlag(value string) error } func getBase(options multiTag, base int) (int, error) { sbase := options.Get("base") var err error var ivbase int64 if sbase != "" { ivbase, err = strconv.ParseInt(sbase, 10, 32) base = int(ivbase) } return base, err } func convertMarshal(val reflect.Value) (bool, string, error) { // Check first for the Marshaler interface if val.Type().NumMethod() > 0 && val.CanInterface() { if marshaler, ok := val.Interface().(Marshaler); ok { ret, err := marshaler.MarshalFlag() return true, ret, err } } return false, "", nil } func convertToString(val reflect.Value, options multiTag) (string, error) { if ok, ret, err := convertMarshal(val); ok { return ret, err } tp := val.Type() // Support for time.Duration if tp == reflect.TypeOf((*time.Duration)(nil)).Elem() { stringer := val.Interface().(fmt.Stringer) return stringer.String(), nil } switch tp.Kind() { case reflect.String: return val.String(), nil case reflect.Bool: if val.Bool() { return "true", nil } return "false", nil case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: base, err := getBase(options, 10) if err != nil { return "", err } return strconv.FormatInt(val.Int(), base), nil case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64: base, err := getBase(options, 10) if err != nil { return "", err } return strconv.FormatUint(val.Uint(), base), nil case reflect.Float32, reflect.Float64: return strconv.FormatFloat(val.Float(), 'g', -1, tp.Bits()), nil case reflect.Slice: if val.Len() == 0 { return "", nil } ret := "[" for i := 0; i < val.Len(); i++ { if i != 0 { ret += ", " } item, err := convertToString(val.Index(i), options) if err != nil { return "", err } ret += item } return ret + "]", nil case reflect.Map: ret := "{" for i, key := range val.MapKeys() { if i != 0 { ret += ", " } keyitem, err := convertToString(key, options) if err != nil { return "", err } item, err := convertToString(val.MapIndex(key), options) if err != nil { return "", err } ret += keyitem + ":" + item } return ret + "}", nil case reflect.Ptr: return convertToString(reflect.Indirect(val), options) case reflect.Interface: if !val.IsNil() { return convertToString(val.Elem(), options) } } return "", nil } func convertUnmarshal(val string, retval reflect.Value) (bool, error) { if retval.Type().NumMethod() > 0 && retval.CanInterface() { if unmarshaler, ok := retval.Interface().(Unmarshaler); ok { return true, unmarshaler.UnmarshalFlag(val) } } if retval.Type().Kind() != reflect.Ptr && retval.CanAddr() { return convertUnmarshal(val, retval.Addr()) } if retval.Type().Kind() == reflect.Interface && !retval.IsNil() { return convertUnmarshal(val, retval.Elem()) } return false, nil } func convert(val string, retval reflect.Value, options multiTag) error { if ok, err := convertUnmarshal(val, retval); ok { return err } tp := retval.Type() // Support for time.Duration if tp == reflect.TypeOf((*time.Duration)(nil)).Elem() { parsed, err := time.ParseDuration(val) if err != nil { return err } retval.SetInt(int64(parsed)) return nil } switch tp.Kind() { case reflect.String: retval.SetString(val) case reflect.Bool: if val == "" { retval.SetBool(true) } else { b, err := strconv.ParseBool(val) if err != nil { return err } retval.SetBool(b) } case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: base, err := getBase(options, 10) if err != nil { return err } parsed, err := strconv.ParseInt(val, base, tp.Bits()) if err != nil { return err } retval.SetInt(parsed) case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64: base, err := getBase(options, 10) if err != nil { return err } parsed, err := strconv.ParseUint(val, base, tp.Bits()) if err != nil { return err } retval.SetUint(parsed) case reflect.Float32, reflect.Float64: parsed, err := strconv.ParseFloat(val, tp.Bits()) if err != nil { return err } retval.SetFloat(parsed) case reflect.Slice: elemtp := tp.Elem() elemvalptr := reflect.New(elemtp) elemval := reflect.Indirect(elemvalptr) if err := convert(val, elemval, options); err != nil { return err } retval.Set(reflect.Append(retval, elemval)) case reflect.Map: parts := strings.SplitN(val, ":", 2) key := parts[0] var value string if len(parts) == 2 { value = parts[1] } keytp := tp.Key() keyval := reflect.New(keytp) if err := convert(key, keyval, options); err != nil { return err } valuetp := tp.Elem() valueval := reflect.New(valuetp) if err := convert(value, valueval, options); err != nil { return err } if retval.IsNil() { retval.Set(reflect.MakeMap(tp)) } retval.SetMapIndex(reflect.Indirect(keyval), reflect.Indirect(valueval)) case reflect.Ptr: if retval.IsNil() { retval.Set(reflect.New(retval.Type().Elem())) } return convert(val, reflect.Indirect(retval), options) case reflect.Interface: if !retval.IsNil() { return convert(val, retval.Elem(), options) } } return nil } func isPrint(s string) bool { for _, c := range s { if !strconv.IsPrint(c) { return false } } return true } func quoteIfNeeded(s string) string { if !isPrint(s) { return strconv.Quote(s) } return s } func quoteIfNeededV(s []string) []string { ret := make([]string, len(s)) for i, v := range s { ret[i] = quoteIfNeeded(v) } return ret } func quoteV(s []string) []string { ret := make([]string, len(s)) for i, v := range s { ret[i] = strconv.Quote(v) } return ret } func unquoteIfPossible(s string) (string, error) { if len(s) == 0 || s[0] != '"' { return s, nil } return strconv.Unquote(s) } mongo-tools-r3.6.3/vendor/src/github.com/jessevdk/go-flags/convert_test.go000066400000000000000000000050071321131462300266660ustar00rootroot00000000000000package flags import ( "testing" "time" ) func expectConvert(t *testing.T, o *Option, expected string) { s, err := convertToString(o.value, o.tag) if err != nil { t.Errorf("Unexpected error: %v", err) return } assertString(t, s, expected) } func TestConvertToString(t *testing.T) { d, _ := time.ParseDuration("1h2m4s") var opts = struct { String string `long:"string"` Int int `long:"int"` Int8 int8 `long:"int8"` Int16 int16 `long:"int16"` Int32 int32 `long:"int32"` Int64 int64 `long:"int64"` Uint uint `long:"uint"` Uint8 uint8 `long:"uint8"` Uint16 uint16 `long:"uint16"` Uint32 uint32 `long:"uint32"` Uint64 uint64 `long:"uint64"` Float32 float32 `long:"float32"` Float64 float64 `long:"float64"` Duration time.Duration `long:"duration"` Bool bool `long:"bool"` IntSlice []int `long:"int-slice"` IntFloatMap map[int]float64 `long:"int-float-map"` PtrBool *bool `long:"ptr-bool"` Interface interface{} `long:"interface"` Int32Base int32 `long:"int32-base" base:"16"` Uint32Base uint32 `long:"uint32-base" base:"16"` }{ "string", -2, -1, 0, 1, 2, 1, 2, 3, 4, 5, 1.2, -3.4, d, true, []int{-3, 4, -2}, map[int]float64{-2: 4.5}, new(bool), float32(5.2), -5823, 4232, } p := NewNamedParser("test", Default) grp, _ := p.AddGroup("test group", "", &opts) expects := []string{ "string", "-2", "-1", "0", "1", "2", "1", "2", "3", "4", "5", "1.2", "-3.4", "1h2m4s", "true", "[-3, 4, -2]", "{-2:4.5}", "false", "5.2", "-16bf", "1088", } for i, v := range grp.Options() { expectConvert(t, v, expects[i]) } } func TestConvertToStringInvalidIntBase(t *testing.T) { var opts = struct { Int int `long:"int" base:"no"` }{ 2, } p := NewNamedParser("test", Default) grp, _ := p.AddGroup("test group", "", &opts) o := grp.Options()[0] _, err := convertToString(o.value, o.tag) if err != nil { err = newErrorf(ErrMarshal, "%v", err) } assertError(t, err, ErrMarshal, "strconv.ParseInt: parsing \"no\": invalid syntax") } func TestConvertToStringInvalidUintBase(t *testing.T) { var opts = struct { Uint uint `long:"uint" base:"no"` }{ 2, } p := NewNamedParser("test", Default) grp, _ := p.AddGroup("test group", "", &opts) o := grp.Options()[0] _, err := convertToString(o.value, o.tag) if err != nil { err = newErrorf(ErrMarshal, "%v", err) } assertError(t, err, ErrMarshal, "strconv.ParseInt: parsing \"no\": invalid syntax") } mongo-tools-r3.6.3/vendor/src/github.com/jessevdk/go-flags/error.go000066400000000000000000000054611321131462300253040ustar00rootroot00000000000000package flags import ( "fmt" ) // ErrorType represents the type of error. type ErrorType uint const ( // ErrUnknown indicates a generic error. ErrUnknown ErrorType = iota // ErrExpectedArgument indicates that an argument was expected. ErrExpectedArgument // ErrUnknownFlag indicates an unknown flag. ErrUnknownFlag // ErrUnknownGroup indicates an unknown group. ErrUnknownGroup // ErrMarshal indicates a marshalling error while converting values. ErrMarshal // ErrHelp indicates that the built-in help was shown (the error // contains the help message). ErrHelp // ErrNoArgumentForBool indicates that an argument was given for a // boolean flag (which don't not take any arguments). ErrNoArgumentForBool // ErrRequired indicates that a required flag was not provided. ErrRequired // ErrShortNameTooLong indicates that a short flag name was specified, // longer than one character. ErrShortNameTooLong // ErrDuplicatedFlag indicates that a short or long flag has been // defined more than once ErrDuplicatedFlag // ErrTag indicates an error while parsing flag tags. ErrTag // ErrCommandRequired indicates that a command was required but not // specified ErrCommandRequired // ErrUnknownCommand indicates that an unknown command was specified. ErrUnknownCommand // ErrInvalidChoice indicates an invalid option value which only allows // a certain number of choices. ErrInvalidChoice ) func (e ErrorType) String() string { switch e { case ErrUnknown: return "unknown" case ErrExpectedArgument: return "expected argument" case ErrUnknownFlag: return "unknown flag" case ErrUnknownGroup: return "unknown group" case ErrMarshal: return "marshal" case ErrHelp: return "help" case ErrNoArgumentForBool: return "no argument for bool" case ErrRequired: return "required" case ErrShortNameTooLong: return "short name too long" case ErrDuplicatedFlag: return "duplicated flag" case ErrTag: return "tag" case ErrCommandRequired: return "command required" case ErrUnknownCommand: return "unknown command" case ErrInvalidChoice: return "invalid choice" } return "unrecognized error type" } // Error represents a parser error. The error returned from Parse is of this // type. The error contains both a Type and Message. type Error struct { // The type of error Type ErrorType // The error message Message string } // Error returns the error's message func (e *Error) Error() string { return e.Message } func newError(tp ErrorType, message string) *Error { return &Error{ Type: tp, Message: message, } } func newErrorf(tp ErrorType, format string, args ...interface{}) *Error { return newError(tp, fmt.Sprintf(format, args...)) } func wrapError(err error) *Error { ret, ok := err.(*Error) if !ok { return newError(ErrUnknown, err.Error()) } return ret } mongo-tools-r3.6.3/vendor/src/github.com/jessevdk/go-flags/example_test.go000066400000000000000000000060361321131462300266440ustar00rootroot00000000000000// Example of use of the flags package. package flags import ( "fmt" "os/exec" ) func Example() { var opts struct { // Slice of bool will append 'true' each time the option // is encountered (can be set multiple times, like -vvv) Verbose []bool `short:"v" long:"verbose" description:"Show verbose debug information"` // Example of automatic marshalling to desired type (uint) Offset uint `long:"offset" description:"Offset"` // Example of a callback, called each time the option is found. Call func(string) `short:"c" description:"Call phone number"` // Example of a required flag Name string `short:"n" long:"name" description:"A name" required:"true"` // Example of a value name File string `short:"f" long:"file" description:"A file" value-name:"FILE"` // Example of a pointer Ptr *int `short:"p" description:"A pointer to an integer"` // Example of a slice of strings StringSlice []string `short:"s" description:"A slice of strings"` // Example of a slice of pointers PtrSlice []*string `long:"ptrslice" description:"A slice of pointers to string"` // Example of a map IntMap map[string]int `long:"intmap" description:"A map from string to int"` // Example of a filename (useful for completion) Filename Filename `long:"filename" description:"A filename"` // Example of positional arguments Args struct { Id string Num int Rest []string } `positional-args:"yes" required:"yes"` } // Callback which will invoke callto: to call a number. // Note that this works just on OS X (and probably only with // Skype) but it shows the idea. opts.Call = func(num string) { cmd := exec.Command("open", "callto:"+num) cmd.Start() cmd.Process.Release() } // Make some fake arguments to parse. args := []string{ "-vv", "--offset=5", "-n", "Me", "-p", "3", "-s", "hello", "-s", "world", "--ptrslice", "hello", "--ptrslice", "world", "--intmap", "a:1", "--intmap", "b:5", "--filename", "hello.go", "id", "10", "remaining1", "remaining2", } // Parse flags from `args'. Note that here we use flags.ParseArgs for // the sake of making a working example. Normally, you would simply use // flags.Parse(&opts) which uses os.Args _, err := ParseArgs(&opts, args) if err != nil { panic(err) } fmt.Printf("Verbosity: %v\n", opts.Verbose) fmt.Printf("Offset: %d\n", opts.Offset) fmt.Printf("Name: %s\n", opts.Name) fmt.Printf("Ptr: %d\n", *opts.Ptr) fmt.Printf("StringSlice: %v\n", opts.StringSlice) fmt.Printf("PtrSlice: [%v %v]\n", *opts.PtrSlice[0], *opts.PtrSlice[1]) fmt.Printf("IntMap: [a:%v b:%v]\n", opts.IntMap["a"], opts.IntMap["b"]) fmt.Printf("Filename: %v\n", opts.Filename) fmt.Printf("Args.Id: %s\n", opts.Args.Id) fmt.Printf("Args.Num: %d\n", opts.Args.Num) fmt.Printf("Args.Rest: %v\n", opts.Args.Rest) // Output: Verbosity: [true true] // Offset: 5 // Name: Me // Ptr: 3 // StringSlice: [hello world] // PtrSlice: [hello world] // IntMap: [a:1 b:5] // Filename: hello.go // Args.Id: id // Args.Num: 10 // Args.Rest: [remaining1 remaining2] } mongo-tools-r3.6.3/vendor/src/github.com/jessevdk/go-flags/examples/000077500000000000000000000000001321131462300254345ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/jessevdk/go-flags/examples/add.go000066400000000000000000000006411321131462300265140ustar00rootroot00000000000000package main import ( "fmt" ) type AddCommand struct { All bool `short:"a" long:"all" description:"Add all files"` } var addCommand AddCommand func (x *AddCommand) Execute(args []string) error { fmt.Printf("Adding (all=%v): %#v\n", x.All, args) return nil } func init() { parser.AddCommand("add", "Add a file", "The add command adds a file to the repository. Use -a to add all files.", &addCommand) } mongo-tools-r3.6.3/vendor/src/github.com/jessevdk/go-flags/examples/bash-completion000066400000000000000000000002711321131462300304430ustar00rootroot00000000000000_examples() { args=("${COMP_WORDS[@]:1:$COMP_CWORD}") local IFS=$'\n' COMPREPLY=($(GO_FLAGS_COMPLETION=1 ${COMP_WORDS[0]} "${args[@]}")) return 1 } complete -F _examples examples mongo-tools-r3.6.3/vendor/src/github.com/jessevdk/go-flags/examples/main.go000066400000000000000000000031121321131462300267040ustar00rootroot00000000000000package main import ( "errors" "fmt" "github.com/jessevdk/go-flags" "os" "strconv" "strings" ) type EditorOptions struct { Input flags.Filename `short:"i" long:"input" description:"Input file" default:"-"` Output flags.Filename `short:"o" long:"output" description:"Output file" default:"-"` } type Point struct { X, Y int } func (p *Point) UnmarshalFlag(value string) error { parts := strings.Split(value, ",") if len(parts) != 2 { return errors.New("expected two numbers separated by a ,") } x, err := strconv.ParseInt(parts[0], 10, 32) if err != nil { return err } y, err := strconv.ParseInt(parts[1], 10, 32) if err != nil { return err } p.X = int(x) p.Y = int(y) return nil } func (p Point) MarshalFlag() (string, error) { return fmt.Sprintf("%d,%d", p.X, p.Y), nil } type Options struct { // Example of verbosity with level Verbose []bool `short:"v" long:"verbose" description:"Verbose output"` // Example of optional value User string `short:"u" long:"user" description:"User name" optional:"yes" optional-value:"pancake"` // Example of map with multiple default values Users map[string]string `long:"users" description:"User e-mail map" default:"system:system@example.org" default:"admin:admin@example.org"` // Example of option group Editor EditorOptions `group:"Editor Options"` // Example of custom type Marshal/Unmarshal Point Point `long:"point" description:"A x,y point" default:"1,2"` } var options Options var parser = flags.NewParser(&options, flags.Default) func main() { if _, err := parser.Parse(); err != nil { os.Exit(1) } } mongo-tools-r3.6.3/vendor/src/github.com/jessevdk/go-flags/examples/rm.go000066400000000000000000000006741321131462300264100ustar00rootroot00000000000000package main import ( "fmt" ) type RmCommand struct { Force bool `short:"f" long:"force" description:"Force removal of files"` } var rmCommand RmCommand func (x *RmCommand) Execute(args []string) error { fmt.Printf("Removing (force=%v): %#v\n", x.Force, args) return nil } func init() { parser.AddCommand("rm", "Remove a file", "The rm command removes a file to the repository. Use -f to force removal of files.", &rmCommand) } mongo-tools-r3.6.3/vendor/src/github.com/jessevdk/go-flags/flags.go000066400000000000000000000275321321131462300252520ustar00rootroot00000000000000// Copyright 2012 Jesse van den Kieboom. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. /* Package flags provides an extensive command line option parser. The flags package is similar in functionality to the go built-in flag package but provides more options and uses reflection to provide a convenient and succinct way of specifying command line options. Supported features The following features are supported in go-flags: Options with short names (-v) Options with long names (--verbose) Options with and without arguments (bool v.s. other type) Options with optional arguments and default values Option default values from ENVIRONMENT_VARIABLES, including slice and map values Multiple option groups each containing a set of options Generate and print well-formatted help message Passing remaining command line arguments after -- (optional) Ignoring unknown command line options (optional) Supports -I/usr/include -I=/usr/include -I /usr/include option argument specification Supports multiple short options -aux Supports all primitive go types (string, int{8..64}, uint{8..64}, float) Supports same option multiple times (can store in slice or last option counts) Supports maps Supports function callbacks Supports namespaces for (nested) option groups Additional features specific to Windows: Options with short names (/v) Options with long names (/verbose) Windows-style options with arguments use a colon as the delimiter Modify generated help message with Windows-style / options Basic usage The flags package uses structs, reflection and struct field tags to allow users to specify command line options. This results in very simple and concise specification of your application options. For example: type Options struct { Verbose []bool `short:"v" long:"verbose" description:"Show verbose debug information"` } This specifies one option with a short name -v and a long name --verbose. When either -v or --verbose is found on the command line, a 'true' value will be appended to the Verbose field. e.g. when specifying -vvv, the resulting value of Verbose will be {[true, true, true]}. Slice options work exactly the same as primitive type options, except that whenever the option is encountered, a value is appended to the slice. Map options from string to primitive type are also supported. On the command line, you specify the value for such an option as key:value. For example type Options struct { AuthorInfo string[string] `short:"a"` } Then, the AuthorInfo map can be filled with something like -a name:Jesse -a "surname:van den Kieboom". Finally, for full control over the conversion between command line argument values and options, user defined types can choose to implement the Marshaler and Unmarshaler interfaces. Available field tags The following is a list of tags for struct fields supported by go-flags: short: the short name of the option (single character) long: the long name of the option required: whether an option is required to appear on the command line. If a required option is not present, the parser will return ErrRequired (optional) description: the description of the option (optional) long-description: the long description of the option. Currently only displayed in generated man pages (optional) no-flag: if non-empty this field is ignored as an option (optional) optional: whether an argument of the option is optional. When an argument is optional it can only be specified using --option=argument (optional) optional-value: the value of an optional option when the option occurs without an argument. This tag can be specified multiple times in the case of maps or slices (optional) default: the default value of an option. This tag can be specified multiple times in the case of slices or maps (optional) default-mask: when specified, this value will be displayed in the help instead of the actual default value. This is useful mostly for hiding otherwise sensitive information from showing up in the help. If default-mask takes the special value "-", then no default value will be shown at all (optional) env: the default value of the option is overridden from the specified environment variable, if one has been defined. (optional) env-delim: the 'env' default value from environment is split into multiple values with the given delimiter string, use with slices and maps (optional) value-name: the name of the argument value (to be shown in the help) (optional) choice: limits the values for an option to a set of values. This tag can be specified mltiple times (optional) hidden: the option is not visible in the help or man page. base: a base (radix) used to convert strings to integer values, the default base is 10 (i.e. decimal) (optional) ini-name: the explicit ini option name (optional) no-ini: if non-empty this field is ignored as an ini option (optional) group: when specified on a struct field, makes the struct field a separate group with the given name (optional) namespace: when specified on a group struct field, the namespace gets prepended to every option's long name and subgroup's namespace of this group, separated by the parser's namespace delimiter (optional) command: when specified on a struct field, makes the struct field a (sub)command with the given name (optional) subcommands-optional: when specified on a command struct field, makes any subcommands of that command optional (optional) alias: when specified on a command struct field, adds the specified name as an alias for the command. Can be be specified multiple times to add more than one alias (optional) positional-args: when specified on a field with a struct type, uses the fields of that struct to parse remaining positional command line arguments into (in order of the fields). If a field has a slice type, then all remaining arguments will be added to it. Positional arguments are optional by default, unless the "required" tag is specified together with the "positional-args" tag. The "required" tag can also be set on the individual rest argument fields, to require only the first N positional arguments. If the "required" tag is set on the rest arguments slice, then its value determines the minimum amount of rest arguments that needs to be provided (e.g. `required:"2"`) (optional) positional-arg-name: used on a field in a positional argument struct; name of the positional argument placeholder to be shown in the help (optional) Either the `short:` tag or the `long:` must be specified to make the field eligible as an option. Option groups Option groups are a simple way to semantically separate your options. All options in a particular group are shown together in the help under the name of the group. Namespaces can be used to specify option long names more precisely and emphasize the options affiliation to their group. There are currently three ways to specify option groups. 1. Use NewNamedParser specifying the various option groups. 2. Use AddGroup to add a group to an existing parser. 3. Add a struct field to the top-level options annotated with the group:"group-name" tag. Commands The flags package also has basic support for commands. Commands are often used in monolithic applications that support various commands or actions. Take git for example, all of the add, commit, checkout, etc. are called commands. Using commands you can easily separate multiple functions of your application. There are currently two ways to specify a command. 1. Use AddCommand on an existing parser. 2. Add a struct field to your options struct annotated with the command:"command-name" tag. The most common, idiomatic way to implement commands is to define a global parser instance and implement each command in a separate file. These command files should define a go init function which calls AddCommand on the global parser. When parsing ends and there is an active command and that command implements the Commander interface, then its Execute method will be run with the remaining command line arguments. Command structs can have options which become valid to parse after the command has been specified on the command line, in addition to the options of all the parent commands. I.e. considering a -v flag on the parser and an add command, the following are equivalent: ./app -v add ./app add -v However, if the -v flag is defined on the add command, then the first of the two examples above would fail since the -v flag is not defined before the add command. Completion go-flags has builtin support to provide bash completion of flags, commands and argument values. To use completion, the binary which uses go-flags can be invoked in a special environment to list completion of the current command line argument. It should be noted that this `executes` your application, and it is up to the user to make sure there are no negative side effects (for example from init functions). Setting the environment variable `GO_FLAGS_COMPLETION=1` enables completion by replacing the argument parsing routine with the completion routine which outputs completions for the passed arguments. The basic invocation to complete a set of arguments is therefore: GO_FLAGS_COMPLETION=1 ./completion-example arg1 arg2 arg3 where `completion-example` is the binary, `arg1` and `arg2` are the current arguments, and `arg3` (the last argument) is the argument to be completed. If the GO_FLAGS_COMPLETION is set to "verbose", then descriptions of possible completion items will also be shown, if there are more than 1 completion items. To use this with bash completion, a simple file can be written which calls the binary which supports go-flags completion: _completion_example() { # All arguments except the first one args=("${COMP_WORDS[@]:1:$COMP_CWORD}") # Only split on newlines local IFS=$'\n' # Call completion (note that the first element of COMP_WORDS is # the executable itself) COMPREPLY=($(GO_FLAGS_COMPLETION=1 ${COMP_WORDS[0]} "${args[@]}")) return 0 } complete -F _completion_example completion-example Completion requires the parser option PassDoubleDash and is therefore enforced if the environment variable GO_FLAGS_COMPLETION is set. Customized completion for argument values is supported by implementing the flags.Completer interface for the argument value type. An example of a type which does so is the flags.Filename type, an alias of string allowing simple filename completion. A slice or array argument value whose element type implements flags.Completer will also be completed. */ package flags mongo-tools-r3.6.3/vendor/src/github.com/jessevdk/go-flags/group.go000066400000000000000000000220301321131462300252760ustar00rootroot00000000000000// Copyright 2012 Jesse van den Kieboom. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package flags import ( "errors" "reflect" "strings" "unicode/utf8" "unsafe" ) // ErrNotPointerToStruct indicates that a provided data container is not // a pointer to a struct. Only pointers to structs are valid data containers // for options. var ErrNotPointerToStruct = errors.New("provided data is not a pointer to struct") // Group represents an option group. Option groups can be used to logically // group options together under a description. Groups are only used to provide // more structure to options both for the user (as displayed in the help message) // and for you, since groups can be nested. type Group struct { // A short description of the group. The // short description is primarily used in the built-in generated help // message ShortDescription string // A long description of the group. The long // description is primarily used to present information on commands // (Command embeds Group) in the built-in generated help and man pages. LongDescription string // The namespace of the group Namespace string // If true, the group is not displayed in the help or man page Hidden bool // The parent of the group or nil if it has no parent parent interface{} // All the options in the group options []*Option // All the subgroups groups []*Group // Whether the group represents the built-in help group isBuiltinHelp bool data interface{} } type scanHandler func(reflect.Value, *reflect.StructField) (bool, error) // AddGroup adds a new group to the command with the given name and data. The // data needs to be a pointer to a struct from which the fields indicate which // options are in the group. func (g *Group) AddGroup(shortDescription string, longDescription string, data interface{}) (*Group, error) { group := newGroup(shortDescription, longDescription, data) group.parent = g if err := group.scan(); err != nil { return nil, err } g.groups = append(g.groups, group) return group, nil } // Groups returns the list of groups embedded in this group. func (g *Group) Groups() []*Group { return g.groups } // Options returns the list of options in this group. func (g *Group) Options() []*Option { return g.options } // Find locates the subgroup with the given short description and returns it. // If no such group can be found Find will return nil. Note that the description // is matched case insensitively. func (g *Group) Find(shortDescription string) *Group { lshortDescription := strings.ToLower(shortDescription) var ret *Group g.eachGroup(func(gg *Group) { if gg != g && strings.ToLower(gg.ShortDescription) == lshortDescription { ret = gg } }) return ret } func (g *Group) findOption(matcher func(*Option) bool) (option *Option) { g.eachGroup(func(g *Group) { for _, opt := range g.options { if option == nil && matcher(opt) { option = opt } } }) return option } // Find an option that is part of the group, or any of its subgroups, // by matching its long name (including the option namespace). func (g *Group) FindOptionByLongName(longName string) *Option { return g.findOption(func(option *Option) bool { return option.LongNameWithNamespace() == longName }) } // Find an option that is part of the group, or any of its subgroups, // by matching its short name. func (g *Group) FindOptionByShortName(shortName rune) *Option { return g.findOption(func(option *Option) bool { return option.ShortName == shortName }) } func newGroup(shortDescription string, longDescription string, data interface{}) *Group { return &Group{ ShortDescription: shortDescription, LongDescription: longDescription, data: data, } } func (g *Group) optionByName(name string, namematch func(*Option, string) bool) *Option { prio := 0 var retopt *Option g.eachGroup(func(g *Group) { for _, opt := range g.options { if namematch != nil && namematch(opt, name) && prio < 4 { retopt = opt prio = 4 } if name == opt.field.Name && prio < 3 { retopt = opt prio = 3 } if name == opt.LongNameWithNamespace() && prio < 2 { retopt = opt prio = 2 } if opt.ShortName != 0 && name == string(opt.ShortName) && prio < 1 { retopt = opt prio = 1 } } }) return retopt } func (g *Group) eachGroup(f func(*Group)) { f(g) for _, gg := range g.groups { gg.eachGroup(f) } } func (g *Group) scanStruct(realval reflect.Value, sfield *reflect.StructField, handler scanHandler) error { stype := realval.Type() if sfield != nil { if ok, err := handler(realval, sfield); err != nil { return err } else if ok { return nil } } for i := 0; i < stype.NumField(); i++ { field := stype.Field(i) // PkgName is set only for non-exported fields, which we ignore if field.PkgPath != "" && !field.Anonymous { continue } mtag := newMultiTag(string(field.Tag)) if err := mtag.Parse(); err != nil { return err } // Skip fields with the no-flag tag if mtag.Get("no-flag") != "" { continue } // Dive deep into structs or pointers to structs kind := field.Type.Kind() fld := realval.Field(i) if kind == reflect.Struct { if err := g.scanStruct(fld, &field, handler); err != nil { return err } } else if kind == reflect.Ptr && field.Type.Elem().Kind() == reflect.Struct { if fld.IsNil() { fld.Set(reflect.New(fld.Type().Elem())) } if err := g.scanStruct(reflect.Indirect(fld), &field, handler); err != nil { return err } } longname := mtag.Get("long") shortname := mtag.Get("short") // Need at least either a short or long name if longname == "" && shortname == "" && mtag.Get("ini-name") == "" { continue } short := rune(0) rc := utf8.RuneCountInString(shortname) if rc > 1 { return newErrorf(ErrShortNameTooLong, "short names can only be 1 character long, not `%s'", shortname) } else if rc == 1 { short, _ = utf8.DecodeRuneInString(shortname) } description := mtag.Get("description") def := mtag.GetMany("default") optionalValue := mtag.GetMany("optional-value") valueName := mtag.Get("value-name") defaultMask := mtag.Get("default-mask") optional := (mtag.Get("optional") != "") required := (mtag.Get("required") != "") choices := mtag.GetMany("choice") hidden := (mtag.Get("hidden") != "") option := &Option{ Description: description, ShortName: short, LongName: longname, Default: def, EnvDefaultKey: mtag.Get("env"), EnvDefaultDelim: mtag.Get("env-delim"), OptionalArgument: optional, OptionalValue: optionalValue, Required: required, ValueName: valueName, DefaultMask: defaultMask, Choices: choices, Hidden: hidden, group: g, field: field, value: realval.Field(i), tag: mtag, } g.options = append(g.options, option) } return nil } func (g *Group) checkForDuplicateFlags() *Error { shortNames := make(map[rune]*Option) longNames := make(map[string]*Option) var duplicateError *Error g.eachGroup(func(g *Group) { for _, option := range g.options { if option.LongName != "" { longName := option.LongNameWithNamespace() if otherOption, ok := longNames[longName]; ok { duplicateError = newErrorf(ErrDuplicatedFlag, "option `%s' uses the same long name as option `%s'", option, otherOption) return } longNames[longName] = option } if option.ShortName != 0 { if otherOption, ok := shortNames[option.ShortName]; ok { duplicateError = newErrorf(ErrDuplicatedFlag, "option `%s' uses the same short name as option `%s'", option, otherOption) return } shortNames[option.ShortName] = option } } }) return duplicateError } func (g *Group) scanSubGroupHandler(realval reflect.Value, sfield *reflect.StructField) (bool, error) { mtag := newMultiTag(string(sfield.Tag)) if err := mtag.Parse(); err != nil { return true, err } subgroup := mtag.Get("group") if len(subgroup) != 0 { ptrval := reflect.NewAt(realval.Type(), unsafe.Pointer(realval.UnsafeAddr())) description := mtag.Get("description") group, err := g.AddGroup(subgroup, description, ptrval.Interface()) if err != nil { return true, err } group.Namespace = mtag.Get("namespace") group.Hidden = mtag.Get("hidden") != "" return true, nil } return false, nil } func (g *Group) scanType(handler scanHandler) error { // Get all the public fields in the data struct ptrval := reflect.ValueOf(g.data) if ptrval.Type().Kind() != reflect.Ptr { panic(ErrNotPointerToStruct) } stype := ptrval.Type().Elem() if stype.Kind() != reflect.Struct { panic(ErrNotPointerToStruct) } realval := reflect.Indirect(ptrval) if err := g.scanStruct(realval, nil, handler); err != nil { return err } if err := g.checkForDuplicateFlags(); err != nil { return err } return nil } func (g *Group) scan() error { return g.scanType(g.scanSubGroupHandler) } func (g *Group) groupByName(name string) *Group { if len(name) == 0 { return g } return g.Find(name) } mongo-tools-r3.6.3/vendor/src/github.com/jessevdk/go-flags/group_test.go000066400000000000000000000123621321131462300263440ustar00rootroot00000000000000package flags import ( "testing" ) func TestGroupInline(t *testing.T) { var opts = struct { Value bool `short:"v"` Group struct { G bool `short:"g"` } `group:"Grouped Options"` }{} p, ret := assertParserSuccess(t, &opts, "-v", "-g") assertStringArray(t, ret, []string{}) if !opts.Value { t.Errorf("Expected Value to be true") } if !opts.Group.G { t.Errorf("Expected Group.G to be true") } if p.Command.Group.Find("Grouped Options") == nil { t.Errorf("Expected to find group `Grouped Options'") } } func TestGroupAdd(t *testing.T) { var opts = struct { Value bool `short:"v"` }{} var grp = struct { G bool `short:"g"` }{} p := NewParser(&opts, Default) g, err := p.AddGroup("Grouped Options", "", &grp) if err != nil { t.Fatalf("Unexpected error: %v", err) return } ret, err := p.ParseArgs([]string{"-v", "-g", "rest"}) if err != nil { t.Fatalf("Unexpected error: %v", err) return } assertStringArray(t, ret, []string{"rest"}) if !opts.Value { t.Errorf("Expected Value to be true") } if !grp.G { t.Errorf("Expected Group.G to be true") } if p.Command.Group.Find("Grouped Options") != g { t.Errorf("Expected to find group `Grouped Options'") } if p.Groups()[1] != g { t.Errorf("Expected group %#v, but got %#v", g, p.Groups()[0]) } if g.Options()[0].ShortName != 'g' { t.Errorf("Expected short name `g' but got %v", g.Options()[0].ShortName) } } func TestGroupNestedInline(t *testing.T) { var opts = struct { Value bool `short:"v"` Group struct { G bool `short:"g"` Nested struct { N string `long:"n"` } `group:"Nested Options"` } `group:"Grouped Options"` }{} p, ret := assertParserSuccess(t, &opts, "-v", "-g", "--n", "n", "rest") assertStringArray(t, ret, []string{"rest"}) if !opts.Value { t.Errorf("Expected Value to be true") } if !opts.Group.G { t.Errorf("Expected Group.G to be true") } assertString(t, opts.Group.Nested.N, "n") if p.Command.Group.Find("Grouped Options") == nil { t.Errorf("Expected to find group `Grouped Options'") } if p.Command.Group.Find("Nested Options") == nil { t.Errorf("Expected to find group `Nested Options'") } } func TestGroupNestedInlineNamespace(t *testing.T) { var opts = struct { Opt string `long:"opt"` Group struct { Opt string `long:"opt"` Group struct { Opt string `long:"opt"` } `group:"Subsubgroup" namespace:"sap"` } `group:"Subgroup" namespace:"sip"` }{} p, ret := assertParserSuccess(t, &opts, "--opt", "a", "--sip.opt", "b", "--sip.sap.opt", "c", "rest") assertStringArray(t, ret, []string{"rest"}) assertString(t, opts.Opt, "a") assertString(t, opts.Group.Opt, "b") assertString(t, opts.Group.Group.Opt, "c") for _, name := range []string{"Subgroup", "Subsubgroup"} { if p.Command.Group.Find(name) == nil { t.Errorf("Expected to find group '%s'", name) } } } func TestDuplicateShortFlags(t *testing.T) { var opts struct { Verbose []bool `short:"v" long:"verbose" description:"Show verbose debug information"` Variables []string `short:"v" long:"variable" description:"Set a variable value."` } args := []string{ "--verbose", "-v", "123", "-v", "456", } _, err := ParseArgs(&opts, args) if err == nil { t.Errorf("Expected an error with type ErrDuplicatedFlag") } else { err2 := err.(*Error) if err2.Type != ErrDuplicatedFlag { t.Errorf("Expected an error with type ErrDuplicatedFlag") } } } func TestDuplicateLongFlags(t *testing.T) { var opts struct { Test1 []bool `short:"a" long:"testing" description:"Test 1"` Test2 []string `short:"b" long:"testing" description:"Test 2."` } args := []string{ "--testing", } _, err := ParseArgs(&opts, args) if err == nil { t.Errorf("Expected an error with type ErrDuplicatedFlag") } else { err2 := err.(*Error) if err2.Type != ErrDuplicatedFlag { t.Errorf("Expected an error with type ErrDuplicatedFlag") } } } func TestFindOptionByLongFlag(t *testing.T) { var opts struct { Testing bool `long:"testing" description:"Testing"` } p := NewParser(&opts, Default) opt := p.FindOptionByLongName("testing") if opt == nil { t.Errorf("Expected option, but found none") } assertString(t, opt.LongName, "testing") } func TestFindOptionByShortFlag(t *testing.T) { var opts struct { Testing bool `short:"t" description:"Testing"` } p := NewParser(&opts, Default) opt := p.FindOptionByShortName('t') if opt == nil { t.Errorf("Expected option, but found none") } if opt.ShortName != 't' { t.Errorf("Expected 't', but got %v", opt.ShortName) } } func TestFindOptionByLongFlagInSubGroup(t *testing.T) { var opts struct { Group struct { Testing bool `long:"testing" description:"Testing"` } `group:"sub-group"` } p := NewParser(&opts, Default) opt := p.FindOptionByLongName("testing") if opt == nil { t.Errorf("Expected option, but found none") } assertString(t, opt.LongName, "testing") } func TestFindOptionByShortFlagInSubGroup(t *testing.T) { var opts struct { Group struct { Testing bool `short:"t" description:"Testing"` } `group:"sub-group"` } p := NewParser(&opts, Default) opt := p.FindOptionByShortName('t') if opt == nil { t.Errorf("Expected option, but found none") } if opt.ShortName != 't' { t.Errorf("Expected 't', but got %v", opt.ShortName) } } mongo-tools-r3.6.3/vendor/src/github.com/jessevdk/go-flags/help.go000066400000000000000000000210311321131462300250720ustar00rootroot00000000000000// Copyright 2012 Jesse van den Kieboom. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package flags import ( "bufio" "bytes" "fmt" "io" "runtime" "strings" "unicode/utf8" ) type alignmentInfo struct { maxLongLen int hasShort bool hasValueName bool terminalColumns int indent bool } const ( paddingBeforeOption = 2 distanceBetweenOptionAndDescription = 2 ) func (a *alignmentInfo) descriptionStart() int { ret := a.maxLongLen + distanceBetweenOptionAndDescription if a.hasShort { ret += 2 } if a.maxLongLen > 0 { ret += 4 } if a.hasValueName { ret += 3 } return ret } func (a *alignmentInfo) updateLen(name string, indent bool) { l := utf8.RuneCountInString(name) if indent { l = l + 4 } if l > a.maxLongLen { a.maxLongLen = l } } func (p *Parser) getAlignmentInfo() alignmentInfo { ret := alignmentInfo{ maxLongLen: 0, hasShort: false, hasValueName: false, terminalColumns: getTerminalColumns(), } if ret.terminalColumns <= 0 { ret.terminalColumns = 80 } var prevcmd *Command p.eachActiveGroup(func(c *Command, grp *Group) { if c != prevcmd { for _, arg := range c.args { ret.updateLen(arg.Name, c != p.Command) } } for _, info := range grp.options { if !info.canCli() { continue } if info.ShortName != 0 { ret.hasShort = true } if len(info.ValueName) > 0 { ret.hasValueName = true } l := info.LongNameWithNamespace() + info.ValueName if len(info.Choices) != 0 { l += "[" + strings.Join(info.Choices, "|") + "]" } ret.updateLen(l, c != p.Command) } }) return ret } func wrapText(s string, l int, prefix string) string { var ret string // Basic text wrapping of s at spaces to fit in l lines := strings.Split(s, "\n") for _, line := range lines { var retline string line = strings.TrimSpace(line) for len(line) > l { // Try to split on space suffix := "" pos := strings.LastIndex(line[:l], " ") if pos < 0 { pos = l - 1 suffix = "-\n" } if len(retline) != 0 { retline += "\n" + prefix } retline += strings.TrimSpace(line[:pos]) + suffix line = strings.TrimSpace(line[pos:]) } if len(line) > 0 { if len(retline) != 0 { retline += "\n" + prefix } retline += line } if len(ret) > 0 { ret += "\n" if len(retline) > 0 { ret += prefix } } ret += retline } return ret } func (p *Parser) writeHelpOption(writer *bufio.Writer, option *Option, info alignmentInfo) { line := &bytes.Buffer{} prefix := paddingBeforeOption if info.indent { prefix += 4 } if option.Hidden { return } line.WriteString(strings.Repeat(" ", prefix)) if option.ShortName != 0 { line.WriteRune(defaultShortOptDelimiter) line.WriteRune(option.ShortName) } else if info.hasShort { line.WriteString(" ") } descstart := info.descriptionStart() + paddingBeforeOption if len(option.LongName) > 0 { if option.ShortName != 0 { line.WriteString(", ") } else if info.hasShort { line.WriteString(" ") } line.WriteString(defaultLongOptDelimiter) line.WriteString(option.LongNameWithNamespace()) } if option.canArgument() { line.WriteRune(defaultNameArgDelimiter) if len(option.ValueName) > 0 { line.WriteString(option.ValueName) } if len(option.Choices) > 0 { line.WriteString("[" + strings.Join(option.Choices, "|") + "]") } } written := line.Len() line.WriteTo(writer) if option.Description != "" { dw := descstart - written writer.WriteString(strings.Repeat(" ", dw)) var def string if len(option.DefaultMask) != 0 && option.DefaultMask != "-" { def = option.DefaultMask } else { def = option.defaultLiteral } var envDef string if option.EnvDefaultKey != "" { var envPrintable string if runtime.GOOS == "windows" { envPrintable = "%" + option.EnvDefaultKey + "%" } else { envPrintable = "$" + option.EnvDefaultKey } envDef = fmt.Sprintf(" [%s]", envPrintable) } var desc string if def != "" { desc = fmt.Sprintf("%s (default: %v)%s", option.Description, def, envDef) } else { desc = option.Description + envDef } writer.WriteString(wrapText(desc, info.terminalColumns-descstart, strings.Repeat(" ", descstart))) } writer.WriteString("\n") } func maxCommandLength(s []*Command) int { if len(s) == 0 { return 0 } ret := len(s[0].Name) for _, v := range s[1:] { l := len(v.Name) if l > ret { ret = l } } return ret } // WriteHelp writes a help message containing all the possible options and // their descriptions to the provided writer. Note that the HelpFlag parser // option provides a convenient way to add a -h/--help option group to the // command line parser which will automatically show the help messages using // this method. func (p *Parser) WriteHelp(writer io.Writer) { if writer == nil { return } wr := bufio.NewWriter(writer) aligninfo := p.getAlignmentInfo() cmd := p.Command for cmd.Active != nil { cmd = cmd.Active } if p.Name != "" { wr.WriteString("Usage:\n") wr.WriteString(" ") allcmd := p.Command for allcmd != nil { var usage string if allcmd == p.Command { if len(p.Usage) != 0 { usage = p.Usage } else if p.Options&HelpFlag != 0 { usage = "[OPTIONS]" } } else if us, ok := allcmd.data.(Usage); ok { usage = us.Usage() } else if allcmd.hasCliOptions() { usage = fmt.Sprintf("[%s-OPTIONS]", allcmd.Name) } if len(usage) != 0 { fmt.Fprintf(wr, " %s %s", allcmd.Name, usage) } else { fmt.Fprintf(wr, " %s", allcmd.Name) } if len(allcmd.args) > 0 { fmt.Fprintf(wr, " ") } for i, arg := range allcmd.args { if i != 0 { fmt.Fprintf(wr, " ") } name := arg.Name if arg.isRemaining() { name = name + "..." } if !allcmd.ArgsRequired { fmt.Fprintf(wr, "[%s]", name) } else { fmt.Fprintf(wr, "%s", name) } } if allcmd.Active == nil && len(allcmd.commands) > 0 { var co, cc string if allcmd.SubcommandsOptional { co, cc = "[", "]" } else { co, cc = "<", ">" } visibleCommands := allcmd.visibleCommands() if len(visibleCommands) > 3 { fmt.Fprintf(wr, " %scommand%s", co, cc) } else { subcommands := allcmd.sortedVisibleCommands() names := make([]string, len(subcommands)) for i, subc := range subcommands { names[i] = subc.Name } fmt.Fprintf(wr, " %s%s%s", co, strings.Join(names, " | "), cc) } } allcmd = allcmd.Active } fmt.Fprintln(wr) if len(cmd.LongDescription) != 0 { fmt.Fprintln(wr) t := wrapText(cmd.LongDescription, aligninfo.terminalColumns, "") fmt.Fprintln(wr, t) } } c := p.Command for c != nil { printcmd := c != p.Command c.eachGroup(func(grp *Group) { first := true // Skip built-in help group for all commands except the top-level // parser if grp.Hidden || (grp.isBuiltinHelp && c != p.Command) { return } for _, info := range grp.options { if !info.canCli() || info.Hidden { continue } if printcmd { fmt.Fprintf(wr, "\n[%s command options]\n", c.Name) aligninfo.indent = true printcmd = false } if first && cmd.Group != grp { fmt.Fprintln(wr) if aligninfo.indent { wr.WriteString(" ") } fmt.Fprintf(wr, "%s:\n", grp.ShortDescription) first = false } p.writeHelpOption(wr, info, aligninfo) } }) if len(c.args) > 0 { if c == p.Command { fmt.Fprintf(wr, "\nArguments:\n") } else { fmt.Fprintf(wr, "\n[%s command arguments]\n", c.Name) } maxlen := aligninfo.descriptionStart() for _, arg := range c.args { prefix := strings.Repeat(" ", paddingBeforeOption) fmt.Fprintf(wr, "%s%s", prefix, arg.Name) if len(arg.Description) > 0 { align := strings.Repeat(" ", maxlen-len(arg.Name)-1) fmt.Fprintf(wr, ":%s%s", align, arg.Description) } fmt.Fprintln(wr) } } c = c.Active } scommands := cmd.sortedVisibleCommands() if len(scommands) > 0 { maxnamelen := maxCommandLength(scommands) fmt.Fprintln(wr) fmt.Fprintln(wr, "Available commands:") for _, c := range scommands { fmt.Fprintf(wr, " %s", c.Name) if len(c.ShortDescription) > 0 { pad := strings.Repeat(" ", maxnamelen-len(c.Name)) fmt.Fprintf(wr, "%s %s", pad, c.ShortDescription) if len(c.Aliases) > 0 { fmt.Fprintf(wr, " (aliases: %s)", strings.Join(c.Aliases, ", ")) } } fmt.Fprintln(wr) } } wr.Flush() } mongo-tools-r3.6.3/vendor/src/github.com/jessevdk/go-flags/help_test.go000066400000000000000000000360711321131462300261430ustar00rootroot00000000000000package flags import ( "bytes" "fmt" "os" "runtime" "testing" "time" ) type helpOptions struct { Verbose []bool `short:"v" long:"verbose" description:"Show verbose debug information" ini-name:"verbose"` Call func(string) `short:"c" description:"Call phone number" ini-name:"call"` PtrSlice []*string `long:"ptrslice" description:"A slice of pointers to string"` EmptyDescription bool `long:"empty-description"` Default string `long:"default" default:"Some\nvalue" description:"Test default value"` DefaultArray []string `long:"default-array" default:"Some value" default:"Other\tvalue" description:"Test default array value"` DefaultMap map[string]string `long:"default-map" default:"some:value" default:"another:value" description:"Testdefault map value"` EnvDefault1 string `long:"env-default1" default:"Some value" env:"ENV_DEFAULT" description:"Test env-default1 value"` EnvDefault2 string `long:"env-default2" env:"ENV_DEFAULT" description:"Test env-default2 value"` OptionWithArgName string `long:"opt-with-arg-name" value-name:"something" description:"Option with named argument"` OptionWithChoices string `long:"opt-with-choices" value-name:"choice" choice:"dog" choice:"cat" description:"Option with choices"` Hidden string `long:"hidden" description:"Hidden option" hidden:"yes"` OnlyIni string `ini-name:"only-ini" description:"Option only available in ini"` Other struct { StringSlice []string `short:"s" default:"some" default:"value" description:"A slice of strings"` IntMap map[string]int `long:"intmap" default:"a:1" description:"A map from string to int" ini-name:"int-map"` } `group:"Other Options"` HiddenGroup struct { InsideHiddenGroup string `long:"inside-hidden-group" description:"Inside hidden group"` } `group:"Hidden group" hidden:"yes"` Group struct { Opt string `long:"opt" description:"This is a subgroup option"` HiddenInsideGroup string `long:"hidden-inside-group" description:"Hidden inside group" hidden:"yes"` Group struct { Opt string `long:"opt" description:"This is a subsubgroup option"` } `group:"Subsubgroup" namespace:"sap"` } `group:"Subgroup" namespace:"sip"` Command struct { ExtraVerbose []bool `long:"extra-verbose" description:"Use for extra verbosity"` } `command:"command" alias:"cm" alias:"cmd" description:"A command"` HiddenCommand struct { ExtraVerbose []bool `long:"extra-verbose" description:"Use for extra verbosity"` } `command:"hidden-command" description:"A hidden command" hidden:"yes"` Args struct { Filename string `positional-arg-name:"filename" description:"A filename"` Number int `positional-arg-name:"num" description:"A number"` } `positional-args:"yes"` } func TestHelp(t *testing.T) { oldEnv := EnvSnapshot() defer oldEnv.Restore() os.Setenv("ENV_DEFAULT", "env-def") var opts helpOptions p := NewNamedParser("TestHelp", HelpFlag) p.AddGroup("Application Options", "The application options", &opts) _, err := p.ParseArgs([]string{"--help"}) if err == nil { t.Fatalf("Expected help error") } if e, ok := err.(*Error); !ok { t.Fatalf("Expected flags.Error, but got %T", err) } else { if e.Type != ErrHelp { t.Errorf("Expected flags.ErrHelp type, but got %s", e.Type) } var expected string if runtime.GOOS == "windows" { expected = `Usage: TestHelp [OPTIONS] [filename] [num] Application Options: /v, /verbose Show verbose debug information /c: Call phone number /ptrslice: A slice of pointers to string /empty-description /default: Test default value (default: "Some\nvalue") /default-array: Test default array value (default: Some value, "Other\tvalue") /default-map: Testdefault map value (default: some:value, another:value) /env-default1: Test env-default1 value (default: Some value) [%ENV_DEFAULT%] /env-default2: Test env-default2 value [%ENV_DEFAULT%] /opt-with-arg-name:something Option with named argument /opt-with-choices:choice[dog|cat] Option with choices Other Options: /s: A slice of strings (default: some, value) /intmap: A map from string to int (default: a:1) Subgroup: /sip.opt: This is a subgroup option Subsubgroup: /sip.sap.opt: This is a subsubgroup option Help Options: /? Show this help message /h, /help Show this help message Arguments: filename: A filename num: A number Available commands: command A command (aliases: cm, cmd) ` } else { expected = `Usage: TestHelp [OPTIONS] [filename] [num] Application Options: -v, --verbose Show verbose debug information -c= Call phone number --ptrslice= A slice of pointers to string --empty-description --default= Test default value (default: "Some\nvalue") --default-array= Test default array value (default: Some value, "Other\tvalue") --default-map= Testdefault map value (default: some:value, another:value) --env-default1= Test env-default1 value (default: Some value) [$ENV_DEFAULT] --env-default2= Test env-default2 value [$ENV_DEFAULT] --opt-with-arg-name=something Option with named argument --opt-with-choices=choice[dog|cat] Option with choices Other Options: -s= A slice of strings (default: some, value) --intmap= A map from string to int (default: a:1) Subgroup: --sip.opt= This is a subgroup option Subsubgroup: --sip.sap.opt= This is a subsubgroup option Help Options: -h, --help Show this help message Arguments: filename: A filename num: A number Available commands: command A command (aliases: cm, cmd) ` } assertDiff(t, e.Message, expected, "help message") } } func TestMan(t *testing.T) { oldEnv := EnvSnapshot() defer oldEnv.Restore() os.Setenv("ENV_DEFAULT", "env-def") var opts helpOptions p := NewNamedParser("TestMan", HelpFlag) p.ShortDescription = "Test manpage generation" p.LongDescription = "This is a somewhat `longer' description of what this does" p.AddGroup("Application Options", "The application options", &opts) p.Commands()[0].LongDescription = "Longer `command' description" var buf bytes.Buffer p.WriteManPage(&buf) got := buf.String() tt := time.Now() var envDefaultName string if runtime.GOOS == "windows" { envDefaultName = "%ENV_DEFAULT%" } else { envDefaultName = "$ENV_DEFAULT" } expected := fmt.Sprintf(`.TH TestMan 1 "%s" .SH NAME TestMan \- Test manpage generation .SH SYNOPSIS \fBTestMan\fP [OPTIONS] .SH DESCRIPTION This is a somewhat \fBlonger\fP description of what this does .SH OPTIONS .TP \fB\fB\-v\fR, \fB\-\-verbose\fR\fP Show verbose debug information .TP \fB\fB\-c\fR\fP Call phone number .TP \fB\fB\-\-ptrslice\fR\fP A slice of pointers to string .TP \fB\fB\-\-empty-description\fR\fP .TP \fB\fB\-\-default\fR \fP Test default value .TP \fB\fB\-\-default-array\fR \fP Test default array value .TP \fB\fB\-\-default-map\fR \fP Testdefault map value .TP \fB\fB\-\-env-default1\fR \fP Test env-default1 value .TP \fB\fB\-\-env-default2\fR \fP Test env-default2 value .TP \fB\fB\-\-opt-with-arg-name\fR \fIsomething\fR\fP Option with named argument .TP \fB\fB\-\-opt-with-choices\fR \fIchoice\fR\fP Option with choices .TP \fB\fB\-s\fR \fP A slice of strings .TP \fB\fB\-\-intmap\fR \fP A map from string to int .TP \fB\fB\-\-sip.opt\fR\fP This is a subgroup option .TP \fB\fB\-\-sip.sap.opt\fR\fP This is a subsubgroup option .SH COMMANDS .SS command A command Longer \fBcommand\fP description \fBUsage\fP: TestMan [OPTIONS] command [command-OPTIONS] .TP \fBAliases\fP: cm, cmd .TP \fB\fB\-\-extra-verbose\fR\fP Use for extra verbosity `, tt.Format("2 January 2006"), envDefaultName) assertDiff(t, got, expected, "man page") } type helpCommandNoOptions struct { Command struct { } `command:"command" description:"A command"` } func TestHelpCommand(t *testing.T) { oldEnv := EnvSnapshot() defer oldEnv.Restore() os.Setenv("ENV_DEFAULT", "env-def") var opts helpCommandNoOptions p := NewNamedParser("TestHelpCommand", HelpFlag) p.AddGroup("Application Options", "The application options", &opts) _, err := p.ParseArgs([]string{"command", "--help"}) if err == nil { t.Fatalf("Expected help error") } if e, ok := err.(*Error); !ok { t.Fatalf("Expected flags.Error, but got %T", err) } else { if e.Type != ErrHelp { t.Errorf("Expected flags.ErrHelp type, but got %s", e.Type) } var expected string if runtime.GOOS == "windows" { expected = `Usage: TestHelpCommand [OPTIONS] command Help Options: /? Show this help message /h, /help Show this help message ` } else { expected = `Usage: TestHelpCommand [OPTIONS] command Help Options: -h, --help Show this help message ` } assertDiff(t, e.Message, expected, "help message") } } func TestHelpDefaults(t *testing.T) { var expected string if runtime.GOOS == "windows" { expected = `Usage: TestHelpDefaults [OPTIONS] Application Options: /with-default: With default (default: default-value) /without-default: Without default /with-programmatic-default: With programmatic default (default: default-value) Help Options: /? Show this help message /h, /help Show this help message ` } else { expected = `Usage: TestHelpDefaults [OPTIONS] Application Options: --with-default= With default (default: default-value) --without-default= Without default --with-programmatic-default= With programmatic default (default: default-value) Help Options: -h, --help Show this help message ` } tests := []struct { Args []string Output string }{ { Args: []string{"-h"}, Output: expected, }, { Args: []string{"--with-default", "other-value", "--with-programmatic-default", "other-value", "-h"}, Output: expected, }, } for _, test := range tests { var opts struct { WithDefault string `long:"with-default" default:"default-value" description:"With default"` WithoutDefault string `long:"without-default" description:"Without default"` WithProgrammaticDefault string `long:"with-programmatic-default" description:"With programmatic default"` } opts.WithProgrammaticDefault = "default-value" p := NewNamedParser("TestHelpDefaults", HelpFlag) p.AddGroup("Application Options", "The application options", &opts) _, err := p.ParseArgs(test.Args) if err == nil { t.Fatalf("Expected help error") } if e, ok := err.(*Error); !ok { t.Fatalf("Expected flags.Error, but got %T", err) } else { if e.Type != ErrHelp { t.Errorf("Expected flags.ErrHelp type, but got %s", e.Type) } assertDiff(t, e.Message, test.Output, "help message") } } } func TestHelpRestArgs(t *testing.T) { opts := struct { Verbose bool `short:"v"` }{} p := NewNamedParser("TestHelpDefaults", HelpFlag) p.AddGroup("Application Options", "The application options", &opts) retargs, err := p.ParseArgs([]string{"-h", "-v", "rest"}) if err == nil { t.Fatalf("Expected help error") } assertStringArray(t, retargs, []string{"-v", "rest"}) } func TestWrapText(t *testing.T) { s := "Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum." got := wrapText(s, 60, " ") expected := `Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.` assertDiff(t, got, expected, "wrapped text") } func TestWrapParagraph(t *testing.T) { s := "Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.\n\n" s += "Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.\n\n" s += "Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur.\n\n" s += "Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.\n" got := wrapText(s, 60, " ") expected := `Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum. ` assertDiff(t, got, expected, "wrapped paragraph") } mongo-tools-r3.6.3/vendor/src/github.com/jessevdk/go-flags/ini.go000066400000000000000000000313131321131462300247250ustar00rootroot00000000000000package flags import ( "bufio" "fmt" "io" "os" "reflect" "sort" "strconv" "strings" ) // IniError contains location information on where an error occured. type IniError struct { // The error message. Message string // The filename of the file in which the error occurred. File string // The line number at which the error occurred. LineNumber uint } // Error provides a "file:line: message" formatted message of the ini error. func (x *IniError) Error() string { return fmt.Sprintf( "%s:%d: %s", x.File, x.LineNumber, x.Message, ) } // IniOptions for writing type IniOptions uint const ( // IniNone indicates no options. IniNone IniOptions = 0 // IniIncludeDefaults indicates that default values should be written. IniIncludeDefaults = 1 << iota // IniCommentDefaults indicates that if IniIncludeDefaults is used // options with default values are written but commented out. IniCommentDefaults // IniIncludeComments indicates that comments containing the description // of an option should be written. IniIncludeComments // IniDefault provides a default set of options. IniDefault = IniIncludeComments ) // IniParser is a utility to read and write flags options from and to ini // formatted strings. type IniParser struct { parser *Parser } type iniValue struct { Name string Value string Quoted bool LineNumber uint } type iniSection []iniValue type ini struct { File string Sections map[string]iniSection } // NewIniParser creates a new ini parser for a given Parser. func NewIniParser(p *Parser) *IniParser { return &IniParser{ parser: p, } } // IniParse is a convenience function to parse command line options with default // settings from an ini formatted file. The provided data is a pointer to a struct // representing the default option group (named "Application Options"). For // more control, use flags.NewParser. func IniParse(filename string, data interface{}) error { p := NewParser(data, Default) return NewIniParser(p).ParseFile(filename) } // ParseFile parses flags from an ini formatted file. See Parse for more // information on the ini file format. The returned errors can be of the type // flags.Error or flags.IniError. func (i *IniParser) ParseFile(filename string) error { i.parser.clearIsSet() ini, err := readIniFromFile(filename) if err != nil { return err } return i.parse(ini) } // Parse parses flags from an ini format. You can use ParseFile as a // convenience function to parse from a filename instead of a general // io.Reader. // // The format of the ini file is as follows: // // [Option group name] // option = value // // Each section in the ini file represents an option group or command in the // flags parser. The default flags parser option group (i.e. when using // flags.Parse) is named 'Application Options'. The ini option name is matched // in the following order: // // 1. Compared to the ini-name tag on the option struct field (if present) // 2. Compared to the struct field name // 3. Compared to the option long name (if present) // 4. Compared to the option short name (if present) // // Sections for nested groups and commands can be addressed using a dot `.' // namespacing notation (i.e [subcommand.Options]). Group section names are // matched case insensitive. // // The returned errors can be of the type flags.Error or flags.IniError. func (i *IniParser) Parse(reader io.Reader) error { i.parser.clearIsSet() ini, err := readIni(reader, "") if err != nil { return err } return i.parse(ini) } // WriteFile writes the flags as ini format into a file. See WriteIni // for more information. The returned error occurs when the specified file // could not be opened for writing. func (i *IniParser) WriteFile(filename string, options IniOptions) error { return writeIniToFile(i, filename, options) } // Write writes the current values of all the flags to an ini format. // See Parse for more information on the ini file format. You typically // call this only after settings have been parsed since the default values of each // option are stored just before parsing the flags (this is only relevant when // IniIncludeDefaults is _not_ set in options). func (i *IniParser) Write(writer io.Writer, options IniOptions) { writeIni(i, writer, options) } func readFullLine(reader *bufio.Reader) (string, error) { var line []byte for { l, more, err := reader.ReadLine() if err != nil { return "", err } if line == nil && !more { return string(l), nil } line = append(line, l...) if !more { break } } return string(line), nil } func optionIniName(option *Option) string { name := option.tag.Get("_read-ini-name") if len(name) != 0 { return name } name = option.tag.Get("ini-name") if len(name) != 0 { return name } return option.field.Name } func writeGroupIni(cmd *Command, group *Group, namespace string, writer io.Writer, options IniOptions) { var sname string if len(namespace) != 0 { sname = namespace } if cmd.Group != group && len(group.ShortDescription) != 0 { if len(sname) != 0 { sname += "." } sname += group.ShortDescription } sectionwritten := false comments := (options & IniIncludeComments) != IniNone for _, option := range group.options { if option.isFunc() || option.Hidden { continue } if len(option.tag.Get("no-ini")) != 0 { continue } val := option.value if (options&IniIncludeDefaults) == IniNone && option.valueIsDefault() { continue } if !sectionwritten { fmt.Fprintf(writer, "[%s]\n", sname) sectionwritten = true } if comments && len(option.Description) != 0 { fmt.Fprintf(writer, "; %s\n", option.Description) } oname := optionIniName(option) commentOption := (options&(IniIncludeDefaults|IniCommentDefaults)) == IniIncludeDefaults|IniCommentDefaults && option.valueIsDefault() kind := val.Type().Kind() switch kind { case reflect.Slice: kind = val.Type().Elem().Kind() if val.Len() == 0 { writeOption(writer, oname, kind, "", "", true, option.iniQuote) } else { for idx := 0; idx < val.Len(); idx++ { v, _ := convertToString(val.Index(idx), option.tag) writeOption(writer, oname, kind, "", v, commentOption, option.iniQuote) } } case reflect.Map: kind = val.Type().Elem().Kind() if val.Len() == 0 { writeOption(writer, oname, kind, "", "", true, option.iniQuote) } else { mkeys := val.MapKeys() keys := make([]string, len(val.MapKeys())) kkmap := make(map[string]reflect.Value) for i, k := range mkeys { keys[i], _ = convertToString(k, option.tag) kkmap[keys[i]] = k } sort.Strings(keys) for _, k := range keys { v, _ := convertToString(val.MapIndex(kkmap[k]), option.tag) writeOption(writer, oname, kind, k, v, commentOption, option.iniQuote) } } default: v, _ := convertToString(val, option.tag) writeOption(writer, oname, kind, "", v, commentOption, option.iniQuote) } if comments { fmt.Fprintln(writer) } } if sectionwritten && !comments { fmt.Fprintln(writer) } } func writeOption(writer io.Writer, optionName string, optionType reflect.Kind, optionKey string, optionValue string, commentOption bool, forceQuote bool) { if forceQuote || (optionType == reflect.String && !isPrint(optionValue)) { optionValue = strconv.Quote(optionValue) } comment := "" if commentOption { comment = "; " } fmt.Fprintf(writer, "%s%s =", comment, optionName) if optionKey != "" { fmt.Fprintf(writer, " %s:%s", optionKey, optionValue) } else if optionValue != "" { fmt.Fprintf(writer, " %s", optionValue) } fmt.Fprintln(writer) } func writeCommandIni(command *Command, namespace string, writer io.Writer, options IniOptions) { command.eachGroup(func(group *Group) { if !group.Hidden { writeGroupIni(command, group, namespace, writer, options) } }) for _, c := range command.commands { var nns string if c.Hidden { continue } if len(namespace) != 0 { nns = c.Name + "." + nns } else { nns = c.Name } writeCommandIni(c, nns, writer, options) } } func writeIni(parser *IniParser, writer io.Writer, options IniOptions) { writeCommandIni(parser.parser.Command, "", writer, options) } func writeIniToFile(parser *IniParser, filename string, options IniOptions) error { file, err := os.Create(filename) if err != nil { return err } defer file.Close() writeIni(parser, file, options) return nil } func readIniFromFile(filename string) (*ini, error) { file, err := os.Open(filename) if err != nil { return nil, err } defer file.Close() return readIni(file, filename) } func readIni(contents io.Reader, filename string) (*ini, error) { ret := &ini{ File: filename, Sections: make(map[string]iniSection), } reader := bufio.NewReader(contents) // Empty global section section := make(iniSection, 0, 10) sectionname := "" ret.Sections[sectionname] = section var lineno uint for { line, err := readFullLine(reader) if err == io.EOF { break } else if err != nil { return nil, err } lineno++ line = strings.TrimSpace(line) // Skip empty lines and lines starting with ; (comments) if len(line) == 0 || line[0] == ';' || line[0] == '#' { continue } if line[0] == '[' { if line[0] != '[' || line[len(line)-1] != ']' { return nil, &IniError{ Message: "malformed section header", File: filename, LineNumber: lineno, } } name := strings.TrimSpace(line[1 : len(line)-1]) if len(name) == 0 { return nil, &IniError{ Message: "empty section name", File: filename, LineNumber: lineno, } } sectionname = name section = ret.Sections[name] if section == nil { section = make(iniSection, 0, 10) ret.Sections[name] = section } continue } // Parse option here keyval := strings.SplitN(line, "=", 2) if len(keyval) != 2 { return nil, &IniError{ Message: fmt.Sprintf("malformed key=value (%s)", line), File: filename, LineNumber: lineno, } } name := strings.TrimSpace(keyval[0]) value := strings.TrimSpace(keyval[1]) quoted := false if len(value) != 0 && value[0] == '"' { if v, err := strconv.Unquote(value); err == nil { value = v quoted = true } else { return nil, &IniError{ Message: err.Error(), File: filename, LineNumber: lineno, } } } section = append(section, iniValue{ Name: name, Value: value, Quoted: quoted, LineNumber: lineno, }) ret.Sections[sectionname] = section } return ret, nil } func (i *IniParser) matchingGroups(name string) []*Group { if len(name) == 0 { var ret []*Group i.parser.eachGroup(func(g *Group) { ret = append(ret, g) }) return ret } g := i.parser.groupByName(name) if g != nil { return []*Group{g} } return nil } func (i *IniParser) parse(ini *ini) error { p := i.parser var quotesLookup = make(map[*Option]bool) for name, section := range ini.Sections { groups := i.matchingGroups(name) if len(groups) == 0 { return newErrorf(ErrUnknownGroup, "could not find option group `%s'", name) } for _, inival := range section { var opt *Option for _, group := range groups { opt = group.optionByName(inival.Name, func(o *Option, n string) bool { return strings.ToLower(o.tag.Get("ini-name")) == strings.ToLower(n) }) if opt != nil && len(opt.tag.Get("no-ini")) != 0 { opt = nil } if opt != nil { break } } if opt == nil { if (p.Options & IgnoreUnknown) == None { return &IniError{ Message: fmt.Sprintf("unknown option: %s", inival.Name), File: ini.File, LineNumber: inival.LineNumber, } } continue } pval := &inival.Value if !opt.canArgument() && len(inival.Value) == 0 { pval = nil } else { if opt.value.Type().Kind() == reflect.Map { parts := strings.SplitN(inival.Value, ":", 2) // only handle unquoting if len(parts) == 2 && parts[1][0] == '"' { if v, err := strconv.Unquote(parts[1]); err == nil { parts[1] = v inival.Quoted = true } else { return &IniError{ Message: err.Error(), File: ini.File, LineNumber: inival.LineNumber, } } s := parts[0] + ":" + parts[1] pval = &s } } } if err := opt.set(pval); err != nil { return &IniError{ Message: err.Error(), File: ini.File, LineNumber: inival.LineNumber, } } // either all INI values are quoted or only values who need quoting if _, ok := quotesLookup[opt]; !inival.Quoted || !ok { quotesLookup[opt] = inival.Quoted } opt.tag.Set("_read-ini-name", inival.Name) } } for opt, quoted := range quotesLookup { opt.iniQuote = quoted } return nil } mongo-tools-r3.6.3/vendor/src/github.com/jessevdk/go-flags/ini_test.go000066400000000000000000000433451321131462300257740ustar00rootroot00000000000000package flags import ( "bytes" "fmt" "io/ioutil" "os" "reflect" "strings" "testing" ) func TestWriteIni(t *testing.T) { oldEnv := EnvSnapshot() defer oldEnv.Restore() os.Setenv("ENV_DEFAULT", "env-def") var tests = []struct { args []string options IniOptions expected string }{ { []string{"-vv", "--intmap=a:2", "--intmap", "b:3", "filename", "0", "command"}, IniDefault, `[Application Options] ; Show verbose debug information verbose = true verbose = true ; Test env-default1 value EnvDefault1 = env-def ; Test env-default2 value EnvDefault2 = env-def [Other Options] ; A map from string to int int-map = a:2 int-map = b:3 `, }, { []string{"-vv", "--intmap=a:2", "--intmap", "b:3", "filename", "0", "command"}, IniDefault | IniIncludeDefaults, `[Application Options] ; Show verbose debug information verbose = true verbose = true ; A slice of pointers to string ; PtrSlice = EmptyDescription = false ; Test default value Default = "Some\nvalue" ; Test default array value DefaultArray = Some value DefaultArray = "Other\tvalue" ; Testdefault map value DefaultMap = another:value DefaultMap = some:value ; Test env-default1 value EnvDefault1 = env-def ; Test env-default2 value EnvDefault2 = env-def ; Option with named argument OptionWithArgName = ; Option with choices OptionWithChoices = ; Option only available in ini only-ini = [Other Options] ; A slice of strings StringSlice = some StringSlice = value ; A map from string to int int-map = a:2 int-map = b:3 [Subgroup] ; This is a subgroup option Opt = [Subsubgroup] ; This is a subsubgroup option Opt = [command] ; Use for extra verbosity ; ExtraVerbose = `, }, { []string{"filename", "0", "command"}, IniDefault | IniIncludeDefaults | IniCommentDefaults, `[Application Options] ; Show verbose debug information ; verbose = ; A slice of pointers to string ; PtrSlice = ; EmptyDescription = false ; Test default value ; Default = "Some\nvalue" ; Test default array value ; DefaultArray = Some value ; DefaultArray = "Other\tvalue" ; Testdefault map value ; DefaultMap = another:value ; DefaultMap = some:value ; Test env-default1 value EnvDefault1 = env-def ; Test env-default2 value EnvDefault2 = env-def ; Option with named argument ; OptionWithArgName = ; Option with choices ; OptionWithChoices = ; Option only available in ini ; only-ini = [Other Options] ; A slice of strings ; StringSlice = some ; StringSlice = value ; A map from string to int ; int-map = a:1 [Subgroup] ; This is a subgroup option ; Opt = [Subsubgroup] ; This is a subsubgroup option ; Opt = [command] ; Use for extra verbosity ; ExtraVerbose = `, }, { []string{"--default=New value", "--default-array=New value", "--default-map=new:value", "filename", "0", "command"}, IniDefault | IniIncludeDefaults | IniCommentDefaults, `[Application Options] ; Show verbose debug information ; verbose = ; A slice of pointers to string ; PtrSlice = ; EmptyDescription = false ; Test default value Default = New value ; Test default array value DefaultArray = New value ; Testdefault map value DefaultMap = new:value ; Test env-default1 value EnvDefault1 = env-def ; Test env-default2 value EnvDefault2 = env-def ; Option with named argument ; OptionWithArgName = ; Option with choices ; OptionWithChoices = ; Option only available in ini ; only-ini = [Other Options] ; A slice of strings ; StringSlice = some ; StringSlice = value ; A map from string to int ; int-map = a:1 [Subgroup] ; This is a subgroup option ; Opt = [Subsubgroup] ; This is a subsubgroup option ; Opt = [command] ; Use for extra verbosity ; ExtraVerbose = `, }, } for _, test := range tests { var opts helpOptions p := NewNamedParser("TestIni", Default) p.AddGroup("Application Options", "The application options", &opts) _, err := p.ParseArgs(test.args) if err != nil { t.Fatalf("Unexpected error: %v", err) } inip := NewIniParser(p) var b bytes.Buffer inip.Write(&b, test.options) got := b.String() expected := test.expected msg := fmt.Sprintf("with arguments %+v and ini options %b", test.args, test.options) assertDiff(t, got, expected, msg) } } func TestReadIni_flagEquivalent(t *testing.T) { type options struct { Opt1 bool `long:"opt1"` Group1 struct { Opt2 bool `long:"opt2"` } `group:"group1"` Group2 struct { Opt3 bool `long:"opt3"` } `group:"group2" namespace:"ns1"` Cmd1 struct { Opt4 bool `long:"opt4"` Opt5 bool `long:"foo.opt5"` Group1 struct { Opt6 bool `long:"opt6"` Opt7 bool `long:"foo.opt7"` } `group:"group1"` Group2 struct { Opt8 bool `long:"opt8"` } `group:"group2" namespace:"ns1"` } `command:"cmd1"` } a := ` opt1=true [group1] opt2=true [group2] ns1.opt3=true [cmd1] opt4=true foo.opt5=true [cmd1.group1] opt6=true foo.opt7=true [cmd1.group2] ns1.opt8=true ` b := ` opt1=true opt2=true ns1.opt3=true [cmd1] opt4=true foo.opt5=true opt6=true foo.opt7=true ns1.opt8=true ` parse := func(readIni string) (opts options, writeIni string) { p := NewNamedParser("TestIni", Default) p.AddGroup("Application Options", "The application options", &opts) inip := NewIniParser(p) err := inip.Parse(strings.NewReader(readIni)) if err != nil { t.Fatalf("Unexpected error: %s\n\nFile:\n%s", err, readIni) } var b bytes.Buffer inip.Write(&b, Default) return opts, b.String() } aOpt, aIni := parse(a) bOpt, bIni := parse(b) assertDiff(t, aIni, bIni, "") if !reflect.DeepEqual(aOpt, bOpt) { t.Errorf("not equal") } } func TestReadIni(t *testing.T) { var opts helpOptions p := NewNamedParser("TestIni", Default) p.AddGroup("Application Options", "The application options", &opts) inip := NewIniParser(p) inic := ` ; Show verbose debug information verbose = true verbose = true DefaultMap = another:"value\n1" DefaultMap = some:value 2 [Application Options] ; A slice of pointers to string ; PtrSlice = ; Test default value Default = "New\nvalue" ; Test env-default1 value EnvDefault1 = New value [Other Options] # A slice of strings StringSlice = "some\nvalue" StringSlice = another value ; A map from string to int int-map = a:2 int-map = b:3 ` b := strings.NewReader(inic) err := inip.Parse(b) if err != nil { t.Fatalf("Unexpected error: %s", err) } assertBoolArray(t, opts.Verbose, []bool{true, true}) if v := map[string]string{"another": "value\n1", "some": "value 2"}; !reflect.DeepEqual(opts.DefaultMap, v) { t.Fatalf("Expected %#v for DefaultMap but got %#v", v, opts.DefaultMap) } assertString(t, opts.Default, "New\nvalue") assertString(t, opts.EnvDefault1, "New value") assertStringArray(t, opts.Other.StringSlice, []string{"some\nvalue", "another value"}) if v, ok := opts.Other.IntMap["a"]; !ok { t.Errorf("Expected \"a\" in Other.IntMap") } else if v != 2 { t.Errorf("Expected Other.IntMap[\"a\"] = 2, but got %v", v) } if v, ok := opts.Other.IntMap["b"]; !ok { t.Errorf("Expected \"b\" in Other.IntMap") } else if v != 3 { t.Errorf("Expected Other.IntMap[\"b\"] = 3, but got %v", v) } } func TestReadAndWriteIni(t *testing.T) { var tests = []struct { options IniOptions read string write string }{ { IniIncludeComments, `[Application Options] ; Show verbose debug information verbose = true verbose = true ; Test default value Default = "quote me" ; Test default array value DefaultArray = 1 DefaultArray = "2" DefaultArray = 3 ; Testdefault map value ; DefaultMap = ; Test env-default1 value EnvDefault1 = env-def ; Test env-default2 value EnvDefault2 = env-def [Other Options] ; A slice of strings ; StringSlice = ; A map from string to int int-map = a:2 int-map = b:"3" `, `[Application Options] ; Show verbose debug information verbose = true verbose = true ; Test default value Default = "quote me" ; Test default array value DefaultArray = 1 DefaultArray = 2 DefaultArray = 3 ; Testdefault map value ; DefaultMap = ; Test env-default1 value EnvDefault1 = env-def ; Test env-default2 value EnvDefault2 = env-def [Other Options] ; A slice of strings ; StringSlice = ; A map from string to int int-map = a:2 int-map = b:3 `, }, { IniIncludeComments, `[Application Options] ; Show verbose debug information verbose = true verbose = true ; Test default value Default = "quote me" ; Test default array value DefaultArray = "1" DefaultArray = "2" DefaultArray = "3" ; Testdefault map value ; DefaultMap = ; Test env-default1 value EnvDefault1 = env-def ; Test env-default2 value EnvDefault2 = env-def [Other Options] ; A slice of strings ; StringSlice = ; A map from string to int int-map = a:"2" int-map = b:"3" `, `[Application Options] ; Show verbose debug information verbose = true verbose = true ; Test default value Default = "quote me" ; Test default array value DefaultArray = "1" DefaultArray = "2" DefaultArray = "3" ; Testdefault map value ; DefaultMap = ; Test env-default1 value EnvDefault1 = env-def ; Test env-default2 value EnvDefault2 = env-def [Other Options] ; A slice of strings ; StringSlice = ; A map from string to int int-map = a:"2" int-map = b:"3" `, }, } for _, test := range tests { var opts helpOptions p := NewNamedParser("TestIni", Default) p.AddGroup("Application Options", "The application options", &opts) inip := NewIniParser(p) read := strings.NewReader(test.read) err := inip.Parse(read) if err != nil { t.Fatalf("Unexpected error: %s", err) } var write bytes.Buffer inip.Write(&write, test.options) got := write.String() msg := fmt.Sprintf("with ini options %b", test.options) assertDiff(t, got, test.write, msg) } } func TestReadIniWrongQuoting(t *testing.T) { var tests = []struct { iniFile string lineNumber uint }{ { iniFile: `Default = "New\nvalue`, lineNumber: 1, }, { iniFile: `StringSlice = "New\nvalue`, lineNumber: 1, }, { iniFile: `StringSlice = "New\nvalue" StringSlice = "Second\nvalue`, lineNumber: 2, }, { iniFile: `DefaultMap = some:"value`, lineNumber: 1, }, { iniFile: `DefaultMap = some:value DefaultMap = another:"value`, lineNumber: 2, }, } for _, test := range tests { var opts helpOptions p := NewNamedParser("TestIni", Default) p.AddGroup("Application Options", "The application options", &opts) inip := NewIniParser(p) inic := test.iniFile b := strings.NewReader(inic) err := inip.Parse(b) if err == nil { t.Fatalf("Expect error") } iniError := err.(*IniError) if iniError.LineNumber != test.lineNumber { t.Fatalf("Expect error on line %d", test.lineNumber) } } } func TestIniCommands(t *testing.T) { var opts struct { Value string `short:"v" long:"value"` Add struct { Name int `short:"n" long:"name" ini-name:"AliasName"` Other struct { O string `short:"o" long:"other"` } `group:"Other Options"` } `command:"add"` } p := NewNamedParser("TestIni", Default) p.AddGroup("Application Options", "The application options", &opts) inip := NewIniParser(p) inic := `[Application Options] value = some value [add] AliasName = 5 [add.Other Options] other = subgroup ` b := strings.NewReader(inic) err := inip.Parse(b) if err != nil { t.Fatalf("Unexpected error: %s", err) } assertString(t, opts.Value, "some value") if opts.Add.Name != 5 { t.Errorf("Expected opts.Add.Name to be 5, but got %v", opts.Add.Name) } assertString(t, opts.Add.Other.O, "subgroup") // Test writing it back buf := &bytes.Buffer{} inip.Write(buf, IniDefault) assertDiff(t, buf.String(), inic, "ini contents") } func TestIniNoIni(t *testing.T) { var opts struct { NoValue string `short:"n" long:"novalue" no-ini:"yes"` Value string `short:"v" long:"value"` } p := NewNamedParser("TestIni", Default) p.AddGroup("Application Options", "The application options", &opts) inip := NewIniParser(p) // read INI inic := `[Application Options] novalue = some value value = some other value ` b := strings.NewReader(inic) err := inip.Parse(b) if err == nil { t.Fatalf("Expected error") } iniError := err.(*IniError) if v := uint(2); iniError.LineNumber != v { t.Errorf("Expected opts.Add.Name to be %d, but got %d", v, iniError.LineNumber) } if v := "unknown option: novalue"; iniError.Message != v { t.Errorf("Expected opts.Add.Name to be %s, but got %s", v, iniError.Message) } // write INI opts.NoValue = "some value" opts.Value = "some other value" file, err := ioutil.TempFile("", "") if err != nil { t.Fatalf("Cannot create temporary file: %s", err) } defer os.Remove(file.Name()) err = inip.WriteFile(file.Name(), IniIncludeDefaults) if err != nil { t.Fatalf("Could not write ini file: %s", err) } found, err := ioutil.ReadFile(file.Name()) if err != nil { t.Fatalf("Could not read written ini file: %s", err) } expected := "[Application Options]\nValue = some other value\n\n" assertDiff(t, string(found), expected, "ini content") } func TestIniParse(t *testing.T) { file, err := ioutil.TempFile("", "") if err != nil { t.Fatalf("Cannot create temporary file: %s", err) } defer os.Remove(file.Name()) _, err = file.WriteString("value = 123") if err != nil { t.Fatalf("Cannot write to temporary file: %s", err) } file.Close() var opts struct { Value int `long:"value"` } err = IniParse(file.Name(), &opts) if err != nil { t.Fatalf("Could not parse ini: %s", err) } if opts.Value != 123 { t.Fatalf("Expected Value to be \"123\" but was \"%d\"", opts.Value) } } func TestIniCliOverrides(t *testing.T) { file, err := ioutil.TempFile("", "") if err != nil { t.Fatalf("Cannot create temporary file: %s", err) } defer os.Remove(file.Name()) _, err = file.WriteString("values = 123\n") _, err = file.WriteString("values = 456\n") if err != nil { t.Fatalf("Cannot write to temporary file: %s", err) } file.Close() var opts struct { Values []int `long:"values"` } p := NewParser(&opts, Default) err = NewIniParser(p).ParseFile(file.Name()) if err != nil { t.Fatalf("Could not parse ini: %s", err) } _, err = p.ParseArgs([]string{"--values", "111", "--values", "222"}) if err != nil { t.Fatalf("Failed to parse arguments: %s", err) } if len(opts.Values) != 2 { t.Fatalf("Expected Values to contain two elements, but got %d", len(opts.Values)) } if opts.Values[0] != 111 { t.Fatalf("Expected Values[0] to be 111, but got '%d'", opts.Values[0]) } if opts.Values[1] != 222 { t.Fatalf("Expected Values[0] to be 222, but got '%d'", opts.Values[1]) } } func TestIniOverrides(t *testing.T) { file, err := ioutil.TempFile("", "") if err != nil { t.Fatalf("Cannot create temporary file: %s", err) } defer os.Remove(file.Name()) _, err = file.WriteString("value-with-default = \"ini-value\"\n") _, err = file.WriteString("value-with-default-override-cli = \"ini-value\"\n") if err != nil { t.Fatalf("Cannot write to temporary file: %s", err) } file.Close() var opts struct { ValueWithDefault string `long:"value-with-default" default:"value"` ValueWithDefaultOverrideCli string `long:"value-with-default-override-cli" default:"value"` } p := NewParser(&opts, Default) err = NewIniParser(p).ParseFile(file.Name()) if err != nil { t.Fatalf("Could not parse ini: %s", err) } _, err = p.ParseArgs([]string{"--value-with-default-override-cli", "cli-value"}) if err != nil { t.Fatalf("Failed to parse arguments: %s", err) } assertString(t, opts.ValueWithDefault, "ini-value") assertString(t, opts.ValueWithDefaultOverrideCli, "cli-value") } func TestWriteFile(t *testing.T) { file, err := ioutil.TempFile("", "") if err != nil { t.Fatalf("Cannot create temporary file: %s", err) } defer os.Remove(file.Name()) var opts struct { Value int `long:"value"` } opts.Value = 123 p := NewParser(&opts, Default) ini := NewIniParser(p) err = ini.WriteFile(file.Name(), IniIncludeDefaults) if err != nil { t.Fatalf("Could not write ini file: %s", err) } found, err := ioutil.ReadFile(file.Name()) if err != nil { t.Fatalf("Could not read written ini file: %s", err) } expected := "[Application Options]\nValue = 123\n\n" assertDiff(t, string(found), expected, "ini content") } func TestOverwriteRequiredOptions(t *testing.T) { var tests = []struct { args []string expected []string }{ { args: []string{"--value", "from CLI"}, expected: []string{ "from CLI", "from default", }, }, { args: []string{"--value", "from CLI", "--default", "from CLI"}, expected: []string{ "from CLI", "from CLI", }, }, { args: []string{"--config", "no file name"}, expected: []string{ "from INI", "from INI", }, }, { args: []string{"--value", "from CLI before", "--default", "from CLI before", "--config", "no file name"}, expected: []string{ "from INI", "from INI", }, }, { args: []string{"--value", "from CLI before", "--default", "from CLI before", "--config", "no file name", "--value", "from CLI after", "--default", "from CLI after"}, expected: []string{ "from CLI after", "from CLI after", }, }, } for _, test := range tests { var opts struct { Config func(s string) error `long:"config" no-ini:"true"` Value string `long:"value" required:"true"` Default string `long:"default" required:"true" default:"from default"` } p := NewParser(&opts, Default) opts.Config = func(s string) error { ini := NewIniParser(p) return ini.Parse(bytes.NewBufferString("value = from INI\ndefault = from INI")) } _, err := p.ParseArgs(test.args) if err != nil { t.Fatalf("Unexpected error %s with args %+v", err, test.args) } if opts.Value != test.expected[0] { t.Fatalf("Expected Value to be \"%s\" but was \"%s\" with args %+v", test.expected[0], opts.Value, test.args) } if opts.Default != test.expected[1] { t.Fatalf("Expected Default to be \"%s\" but was \"%s\" with args %+v", test.expected[1], opts.Default, test.args) } } } mongo-tools-r3.6.3/vendor/src/github.com/jessevdk/go-flags/long_test.go000066400000000000000000000033701321131462300261460ustar00rootroot00000000000000package flags import ( "testing" ) func TestLong(t *testing.T) { var opts = struct { Value bool `long:"value"` }{} ret := assertParseSuccess(t, &opts, "--value") assertStringArray(t, ret, []string{}) if !opts.Value { t.Errorf("Expected Value to be true") } } func TestLongArg(t *testing.T) { var opts = struct { Value string `long:"value"` }{} ret := assertParseSuccess(t, &opts, "--value", "value") assertStringArray(t, ret, []string{}) assertString(t, opts.Value, "value") } func TestLongArgEqual(t *testing.T) { var opts = struct { Value string `long:"value"` }{} ret := assertParseSuccess(t, &opts, "--value=value") assertStringArray(t, ret, []string{}) assertString(t, opts.Value, "value") } func TestLongDefault(t *testing.T) { var opts = struct { Value string `long:"value" default:"value"` }{} ret := assertParseSuccess(t, &opts) assertStringArray(t, ret, []string{}) assertString(t, opts.Value, "value") } func TestLongOptional(t *testing.T) { var opts = struct { Value string `long:"value" optional:"yes" optional-value:"value"` }{} ret := assertParseSuccess(t, &opts, "--value") assertStringArray(t, ret, []string{}) assertString(t, opts.Value, "value") } func TestLongOptionalArg(t *testing.T) { var opts = struct { Value string `long:"value" optional:"yes" optional-value:"value"` }{} ret := assertParseSuccess(t, &opts, "--value", "no") assertStringArray(t, ret, []string{"no"}) assertString(t, opts.Value, "value") } func TestLongOptionalArgEqual(t *testing.T) { var opts = struct { Value string `long:"value" optional:"yes" optional-value:"value"` }{} ret := assertParseSuccess(t, &opts, "--value=value", "no") assertStringArray(t, ret, []string{"no"}) assertString(t, opts.Value, "value") } mongo-tools-r3.6.3/vendor/src/github.com/jessevdk/go-flags/man.go000066400000000000000000000104311321131462300247170ustar00rootroot00000000000000package flags import ( "fmt" "io" "runtime" "strings" "time" ) func manQuote(s string) string { return strings.Replace(s, "\\", "\\\\", -1) } func formatForMan(wr io.Writer, s string) { for { idx := strings.IndexRune(s, '`') if idx < 0 { fmt.Fprintf(wr, "%s", manQuote(s)) break } fmt.Fprintf(wr, "%s", manQuote(s[:idx])) s = s[idx+1:] idx = strings.IndexRune(s, '\'') if idx < 0 { fmt.Fprintf(wr, "%s", manQuote(s)) break } fmt.Fprintf(wr, "\\fB%s\\fP", manQuote(s[:idx])) s = s[idx+1:] } } func writeManPageOptions(wr io.Writer, grp *Group) { grp.eachGroup(func(group *Group) { if group.Hidden { return } for _, opt := range group.options { if !opt.canCli() || opt.Hidden { continue } fmt.Fprintln(wr, ".TP") fmt.Fprintf(wr, "\\fB") if opt.ShortName != 0 { fmt.Fprintf(wr, "\\fB\\-%c\\fR", opt.ShortName) } if len(opt.LongName) != 0 { if opt.ShortName != 0 { fmt.Fprintf(wr, ", ") } fmt.Fprintf(wr, "\\fB\\-\\-%s\\fR", manQuote(opt.LongNameWithNamespace())) } if len(opt.ValueName) != 0 || opt.OptionalArgument { if opt.OptionalArgument { fmt.Fprintf(wr, " [\\fI%s=%s\\fR]", manQuote(opt.ValueName), manQuote(strings.Join(quoteV(opt.OptionalValue), ", "))) } else { fmt.Fprintf(wr, " \\fI%s\\fR", manQuote(opt.ValueName)) } } if len(opt.Default) != 0 { fmt.Fprintf(wr, " ", manQuote(strings.Join(quoteV(opt.Default), ", "))) } else if len(opt.EnvDefaultKey) != 0 { if runtime.GOOS == "windows" { fmt.Fprintf(wr, " ", manQuote(opt.EnvDefaultKey)) } else { fmt.Fprintf(wr, " ", manQuote(opt.EnvDefaultKey)) } } if opt.Required { fmt.Fprintf(wr, " (\\fIrequired\\fR)") } fmt.Fprintln(wr, "\\fP") if len(opt.Description) != 0 { formatForMan(wr, opt.Description) fmt.Fprintln(wr, "") } } }) } func writeManPageSubcommands(wr io.Writer, name string, root *Command) { commands := root.sortedVisibleCommands() for _, c := range commands { var nn string if c.Hidden { continue } if len(name) != 0 { nn = name + " " + c.Name } else { nn = c.Name } writeManPageCommand(wr, nn, root, c) } } func writeManPageCommand(wr io.Writer, name string, root *Command, command *Command) { fmt.Fprintf(wr, ".SS %s\n", name) fmt.Fprintln(wr, command.ShortDescription) if len(command.LongDescription) > 0 { fmt.Fprintln(wr, "") cmdstart := fmt.Sprintf("The %s command", manQuote(command.Name)) if strings.HasPrefix(command.LongDescription, cmdstart) { fmt.Fprintf(wr, "The \\fI%s\\fP command", manQuote(command.Name)) formatForMan(wr, command.LongDescription[len(cmdstart):]) fmt.Fprintln(wr, "") } else { formatForMan(wr, command.LongDescription) fmt.Fprintln(wr, "") } } var usage string if us, ok := command.data.(Usage); ok { usage = us.Usage() } else if command.hasCliOptions() { usage = fmt.Sprintf("[%s-OPTIONS]", command.Name) } var pre string if root.hasCliOptions() { pre = fmt.Sprintf("%s [OPTIONS] %s", root.Name, command.Name) } else { pre = fmt.Sprintf("%s %s", root.Name, command.Name) } if len(usage) > 0 { fmt.Fprintf(wr, "\n\\fBUsage\\fP: %s %s\n.TP\n", manQuote(pre), manQuote(usage)) } if len(command.Aliases) > 0 { fmt.Fprintf(wr, "\n\\fBAliases\\fP: %s\n\n", manQuote(strings.Join(command.Aliases, ", "))) } writeManPageOptions(wr, command.Group) writeManPageSubcommands(wr, name, command) } // WriteManPage writes a basic man page in groff format to the specified // writer. func (p *Parser) WriteManPage(wr io.Writer) { t := time.Now() fmt.Fprintf(wr, ".TH %s 1 \"%s\"\n", manQuote(p.Name), t.Format("2 January 2006")) fmt.Fprintln(wr, ".SH NAME") fmt.Fprintf(wr, "%s \\- %s\n", manQuote(p.Name), manQuote(p.ShortDescription)) fmt.Fprintln(wr, ".SH SYNOPSIS") usage := p.Usage if len(usage) == 0 { usage = "[OPTIONS]" } fmt.Fprintf(wr, "\\fB%s\\fP %s\n", manQuote(p.Name), manQuote(usage)) fmt.Fprintln(wr, ".SH DESCRIPTION") formatForMan(wr, p.LongDescription) fmt.Fprintln(wr, "") fmt.Fprintln(wr, ".SH OPTIONS") writeManPageOptions(wr, p.Command.Group) if len(p.visibleCommands()) > 0 { fmt.Fprintln(wr, ".SH COMMANDS") writeManPageSubcommands(wr, "", p.Command) } } mongo-tools-r3.6.3/vendor/src/github.com/jessevdk/go-flags/marshal_test.go000066400000000000000000000036211321131462300266350ustar00rootroot00000000000000package flags import ( "fmt" "testing" ) type marshalled bool func (m *marshalled) UnmarshalFlag(value string) error { if value == "yes" { *m = true } else if value == "no" { *m = false } else { return fmt.Errorf("`%s' is not a valid value, please specify `yes' or `no'", value) } return nil } func (m marshalled) MarshalFlag() (string, error) { if m { return "yes", nil } return "no", nil } type marshalledError bool func (m marshalledError) MarshalFlag() (string, error) { return "", newErrorf(ErrMarshal, "Failed to marshal") } func TestUnmarshal(t *testing.T) { var opts = struct { Value marshalled `short:"v"` }{} ret := assertParseSuccess(t, &opts, "-v=yes") assertStringArray(t, ret, []string{}) if !opts.Value { t.Errorf("Expected Value to be true") } } func TestUnmarshalDefault(t *testing.T) { var opts = struct { Value marshalled `short:"v" default:"yes"` }{} ret := assertParseSuccess(t, &opts) assertStringArray(t, ret, []string{}) if !opts.Value { t.Errorf("Expected Value to be true") } } func TestUnmarshalOptional(t *testing.T) { var opts = struct { Value marshalled `short:"v" optional:"yes" optional-value:"yes"` }{} ret := assertParseSuccess(t, &opts, "-v") assertStringArray(t, ret, []string{}) if !opts.Value { t.Errorf("Expected Value to be true") } } func TestUnmarshalError(t *testing.T) { var opts = struct { Value marshalled `short:"v"` }{} assertParseFail(t, ErrMarshal, fmt.Sprintf("invalid argument for flag `%cv' (expected flags.marshalled): `invalid' is not a valid value, please specify `yes' or `no'", defaultShortOptDelimiter), &opts, "-vinvalid") } func TestMarshalError(t *testing.T) { var opts = struct { Value marshalledError `short:"v"` }{} p := NewParser(&opts, Default) o := p.Command.Groups()[0].Options()[0] _, err := convertToString(o.value, o.tag) assertError(t, err, ErrMarshal, "Failed to marshal") } mongo-tools-r3.6.3/vendor/src/github.com/jessevdk/go-flags/multitag.go000066400000000000000000000046271321131462300260040ustar00rootroot00000000000000package flags import ( "strconv" ) type multiTag struct { value string cache map[string][]string } func newMultiTag(v string) multiTag { return multiTag{ value: v, } } func (x *multiTag) scan() (map[string][]string, error) { v := x.value ret := make(map[string][]string) // This is mostly copied from reflect.StructTag.Get for v != "" { i := 0 // Skip whitespace for i < len(v) && v[i] == ' ' { i++ } v = v[i:] if v == "" { break } // Scan to colon to find key i = 0 for i < len(v) && v[i] != ' ' && v[i] != ':' && v[i] != '"' { i++ } if i >= len(v) { return nil, newErrorf(ErrTag, "expected `:' after key name, but got end of tag (in `%v`)", x.value) } if v[i] != ':' { return nil, newErrorf(ErrTag, "expected `:' after key name, but got `%v' (in `%v`)", v[i], x.value) } if i+1 >= len(v) { return nil, newErrorf(ErrTag, "expected `\"' to start tag value at end of tag (in `%v`)", x.value) } if v[i+1] != '"' { return nil, newErrorf(ErrTag, "expected `\"' to start tag value, but got `%v' (in `%v`)", v[i+1], x.value) } name := v[:i] v = v[i+1:] // Scan quoted string to find value i = 1 for i < len(v) && v[i] != '"' { if v[i] == '\n' { return nil, newErrorf(ErrTag, "unexpected newline in tag value `%v' (in `%v`)", name, x.value) } if v[i] == '\\' { i++ } i++ } if i >= len(v) { return nil, newErrorf(ErrTag, "expected end of tag value `\"' at end of tag (in `%v`)", x.value) } val, err := strconv.Unquote(v[:i+1]) if err != nil { return nil, newErrorf(ErrTag, "Malformed value of tag `%v:%v` => %v (in `%v`)", name, v[:i+1], err, x.value) } v = v[i+1:] ret[name] = append(ret[name], val) } return ret, nil } func (x *multiTag) Parse() error { vals, err := x.scan() x.cache = vals return err } func (x *multiTag) cached() map[string][]string { if x.cache == nil { cache, _ := x.scan() if cache == nil { cache = make(map[string][]string) } x.cache = cache } return x.cache } func (x *multiTag) Get(key string) string { c := x.cached() if v, ok := c[key]; ok { return v[len(v)-1] } return "" } func (x *multiTag) GetMany(key string) []string { c := x.cached() return c[key] } func (x *multiTag) Set(key string, value string) { c := x.cached() c[key] = []string{value} } func (x *multiTag) SetMany(key string, value []string) { c := x.cached() c[key] = value } mongo-tools-r3.6.3/vendor/src/github.com/jessevdk/go-flags/option.go000066400000000000000000000224561321131462300254660ustar00rootroot00000000000000package flags import ( "fmt" "reflect" "strings" "syscall" "unicode/utf8" ) // Option flag information. Contains a description of the option, short and // long name as well as a default value and whether an argument for this // flag is optional. type Option struct { // The description of the option flag. This description is shown // automatically in the built-in help. Description string // The short name of the option (a single character). If not 0, the // option flag can be 'activated' using -. Either ShortName // or LongName needs to be non-empty. ShortName rune // The long name of the option. If not "", the option flag can be // activated using --. Either ShortName or LongName needs // to be non-empty. LongName string // The default value of the option. Default []string // The optional environment default value key name. EnvDefaultKey string // The optional delimiter string for EnvDefaultKey values. EnvDefaultDelim string // If true, specifies that the argument to an option flag is optional. // When no argument to the flag is specified on the command line, the // value of OptionalValue will be set in the field this option represents. // This is only valid for non-boolean options. OptionalArgument bool // The optional value of the option. The optional value is used when // the option flag is marked as having an OptionalArgument. This means // that when the flag is specified, but no option argument is given, // the value of the field this option represents will be set to // OptionalValue. This is only valid for non-boolean options. OptionalValue []string // If true, the option _must_ be specified on the command line. If the // option is not specified, the parser will generate an ErrRequired type // error. Required bool // A name for the value of an option shown in the Help as --flag [ValueName] ValueName string // A mask value to show in the help instead of the default value. This // is useful for hiding sensitive information in the help, such as // passwords. DefaultMask string // If non empty, only a certain set of values is allowed for an option. Choices []string // If true, the option is not displayed in the help or man page Hidden bool // The group which the option belongs to group *Group // The struct field which the option represents. field reflect.StructField // The struct field value which the option represents. value reflect.Value // Determines if the option will be always quoted in the INI output iniQuote bool tag multiTag isSet bool preventDefault bool defaultLiteral string } // LongNameWithNamespace returns the option's long name with the group namespaces // prepended by walking up the option's group tree. Namespaces and the long name // itself are separated by the parser's namespace delimiter. If the long name is // empty an empty string is returned. func (option *Option) LongNameWithNamespace() string { if len(option.LongName) == 0 { return "" } // fetch the namespace delimiter from the parser which is always at the // end of the group hierarchy namespaceDelimiter := "" g := option.group for { if p, ok := g.parent.(*Parser); ok { namespaceDelimiter = p.NamespaceDelimiter break } switch i := g.parent.(type) { case *Command: g = i.Group case *Group: g = i } } // concatenate long name with namespace longName := option.LongName g = option.group for g != nil { if g.Namespace != "" { longName = g.Namespace + namespaceDelimiter + longName } switch i := g.parent.(type) { case *Command: g = i.Group case *Group: g = i case *Parser: g = nil } } return longName } // String converts an option to a human friendly readable string describing the // option. func (option *Option) String() string { var s string var short string if option.ShortName != 0 { data := make([]byte, utf8.RuneLen(option.ShortName)) utf8.EncodeRune(data, option.ShortName) short = string(data) if len(option.LongName) != 0 { s = fmt.Sprintf("%s%s, %s%s", string(defaultShortOptDelimiter), short, defaultLongOptDelimiter, option.LongNameWithNamespace()) } else { s = fmt.Sprintf("%s%s", string(defaultShortOptDelimiter), short) } } else if len(option.LongName) != 0 { s = fmt.Sprintf("%s%s", defaultLongOptDelimiter, option.LongNameWithNamespace()) } return s } // Value returns the option value as an interface{}. func (option *Option) Value() interface{} { return option.value.Interface() } // IsSet returns true if option has been set func (option *Option) IsSet() bool { return option.isSet } // Set the value of an option to the specified value. An error will be returned // if the specified value could not be converted to the corresponding option // value type. func (option *Option) set(value *string) error { kind := option.value.Type().Kind() if (kind == reflect.Map || kind == reflect.Slice) && !option.isSet { option.empty() } option.isSet = true option.preventDefault = true if len(option.Choices) != 0 { found := false for _, choice := range option.Choices { if choice == *value { found = true break } } if !found { allowed := strings.Join(option.Choices[0:len(option.Choices)-1], ", ") if len(option.Choices) > 1 { allowed += " or " + option.Choices[len(option.Choices)-1] } return newErrorf(ErrInvalidChoice, "Invalid value `%s' for option `%s'. Allowed values are: %s", *value, option, allowed) } } if option.isFunc() { return option.call(value) } else if value != nil { return convert(*value, option.value, option.tag) } return convert("", option.value, option.tag) } func (option *Option) canCli() bool { return option.ShortName != 0 || len(option.LongName) != 0 } func (option *Option) canArgument() bool { if u := option.isUnmarshaler(); u != nil { return true } return !option.isBool() } func (option *Option) emptyValue() reflect.Value { tp := option.value.Type() if tp.Kind() == reflect.Map { return reflect.MakeMap(tp) } return reflect.Zero(tp) } func (option *Option) empty() { if !option.isFunc() { option.value.Set(option.emptyValue()) } } func (option *Option) clearDefault() { usedDefault := option.Default if envKey := option.EnvDefaultKey; envKey != "" { // os.Getenv() makes no distinction between undefined and // empty values, so we use syscall.Getenv() if value, ok := syscall.Getenv(envKey); ok { if option.EnvDefaultDelim != "" { usedDefault = strings.Split(value, option.EnvDefaultDelim) } else { usedDefault = []string{value} } } } if len(usedDefault) > 0 { option.empty() for _, d := range usedDefault { option.set(&d) } } else { tp := option.value.Type() switch tp.Kind() { case reflect.Map: if option.value.IsNil() { option.empty() } case reflect.Slice: if option.value.IsNil() { option.empty() } } } } func (option *Option) valueIsDefault() bool { // Check if the value of the option corresponds to its // default value emptyval := option.emptyValue() checkvalptr := reflect.New(emptyval.Type()) checkval := reflect.Indirect(checkvalptr) checkval.Set(emptyval) if len(option.Default) != 0 { for _, v := range option.Default { convert(v, checkval, option.tag) } } return reflect.DeepEqual(option.value.Interface(), checkval.Interface()) } func (option *Option) isUnmarshaler() Unmarshaler { v := option.value for { if !v.CanInterface() { break } i := v.Interface() if u, ok := i.(Unmarshaler); ok { return u } if !v.CanAddr() { break } v = v.Addr() } return nil } func (option *Option) isBool() bool { tp := option.value.Type() for { switch tp.Kind() { case reflect.Bool: return true case reflect.Slice: return (tp.Elem().Kind() == reflect.Bool) case reflect.Func: return tp.NumIn() == 0 case reflect.Ptr: tp = tp.Elem() default: return false } } } func (option *Option) isFunc() bool { return option.value.Type().Kind() == reflect.Func } func (option *Option) call(value *string) error { var retval []reflect.Value if value == nil { retval = option.value.Call(nil) } else { tp := option.value.Type().In(0) val := reflect.New(tp) val = reflect.Indirect(val) if err := convert(*value, val, option.tag); err != nil { return err } retval = option.value.Call([]reflect.Value{val}) } if len(retval) == 1 && retval[0].Type() == reflect.TypeOf((*error)(nil)).Elem() { if retval[0].Interface() == nil { return nil } return retval[0].Interface().(error) } return nil } func (option *Option) updateDefaultLiteral() { defs := option.Default def := "" if len(defs) == 0 && option.canArgument() { var showdef bool switch option.field.Type.Kind() { case reflect.Func, reflect.Ptr: showdef = !option.value.IsNil() case reflect.Slice, reflect.String, reflect.Array: showdef = option.value.Len() > 0 case reflect.Map: showdef = !option.value.IsNil() && option.value.Len() > 0 default: zeroval := reflect.Zero(option.field.Type) showdef = !reflect.DeepEqual(zeroval.Interface(), option.value.Interface()) } if showdef { def, _ = convertToString(option.value, option.tag) } } else if len(defs) != 0 { l := len(defs) - 1 for i := 0; i < l; i++ { def += quoteIfNeeded(defs[i]) + ", " } def += quoteIfNeeded(defs[l]) } option.defaultLiteral = def } mongo-tools-r3.6.3/vendor/src/github.com/jessevdk/go-flags/options_test.go000066400000000000000000000014431321131462300267010ustar00rootroot00000000000000package flags import ( "testing" ) func TestPassDoubleDash(t *testing.T) { var opts = struct { Value bool `short:"v"` }{} p := NewParser(&opts, PassDoubleDash) ret, err := p.ParseArgs([]string{"-v", "--", "-v", "-g"}) if err != nil { t.Fatalf("Unexpected error: %v", err) return } if !opts.Value { t.Errorf("Expected Value to be true") } assertStringArray(t, ret, []string{"-v", "-g"}) } func TestPassAfterNonOption(t *testing.T) { var opts = struct { Value bool `short:"v"` }{} p := NewParser(&opts, PassAfterNonOption) ret, err := p.ParseArgs([]string{"-v", "arg", "-v", "-g"}) if err != nil { t.Fatalf("Unexpected error: %v", err) return } if !opts.Value { t.Errorf("Expected Value to be true") } assertStringArray(t, ret, []string{"arg", "-v", "-g"}) } mongo-tools-r3.6.3/vendor/src/github.com/jessevdk/go-flags/optstyle_other.go000066400000000000000000000031331321131462300272310ustar00rootroot00000000000000// +build !windows package flags import ( "strings" ) const ( defaultShortOptDelimiter = '-' defaultLongOptDelimiter = "--" defaultNameArgDelimiter = '=' ) func argumentStartsOption(arg string) bool { return len(arg) > 0 && arg[0] == '-' } func argumentIsOption(arg string) bool { if len(arg) > 1 && arg[0] == '-' && arg[1] != '-' { return true } if len(arg) > 2 && arg[0] == '-' && arg[1] == '-' && arg[2] != '-' { return true } return false } // stripOptionPrefix returns the option without the prefix and whether or // not the option is a long option or not. func stripOptionPrefix(optname string) (prefix string, name string, islong bool) { if strings.HasPrefix(optname, "--") { return "--", optname[2:], true } else if strings.HasPrefix(optname, "-") { return "-", optname[1:], false } return "", optname, false } // splitOption attempts to split the passed option into a name and an argument. // When there is no argument specified, nil will be returned for it. func splitOption(prefix string, option string, islong bool) (string, string, *string) { pos := strings.Index(option, "=") if (islong && pos >= 0) || (!islong && pos == 1) { rest := option[pos+1:] return option[:pos], "=", &rest } return option, "", nil } // addHelpGroup adds a new group that contains default help parameters. func (c *Command) addHelpGroup(showHelp func() error) *Group { var help struct { ShowHelp func() error `short:"h" long:"help" description:"Show this help message"` } help.ShowHelp = showHelp ret, _ := c.AddGroup("Help Options", "", &help) ret.isBuiltinHelp = true return ret } mongo-tools-r3.6.3/vendor/src/github.com/jessevdk/go-flags/optstyle_windows.go000066400000000000000000000055531321131462300276120ustar00rootroot00000000000000package flags import ( "strings" ) // Windows uses a front slash for both short and long options. Also it uses // a colon for name/argument delimter. const ( defaultShortOptDelimiter = '/' defaultLongOptDelimiter = "/" defaultNameArgDelimiter = ':' ) func argumentStartsOption(arg string) bool { return len(arg) > 0 && (arg[0] == '-' || arg[0] == '/') } func argumentIsOption(arg string) bool { // Windows-style options allow front slash for the option // delimiter. if len(arg) > 1 && arg[0] == '/' { return true } if len(arg) > 1 && arg[0] == '-' && arg[1] != '-' { return true } if len(arg) > 2 && arg[0] == '-' && arg[1] == '-' && arg[2] != '-' { return true } return false } // stripOptionPrefix returns the option without the prefix and whether or // not the option is a long option or not. func stripOptionPrefix(optname string) (prefix string, name string, islong bool) { // Determine if the argument is a long option or not. Windows // typically supports both long and short options with a single // front slash as the option delimiter, so handle this situation // nicely. possplit := 0 if strings.HasPrefix(optname, "--") { possplit = 2 islong = true } else if strings.HasPrefix(optname, "-") { possplit = 1 islong = false } else if strings.HasPrefix(optname, "/") { possplit = 1 islong = len(optname) > 2 } return optname[:possplit], optname[possplit:], islong } // splitOption attempts to split the passed option into a name and an argument. // When there is no argument specified, nil will be returned for it. func splitOption(prefix string, option string, islong bool) (string, string, *string) { if len(option) == 0 { return option, "", nil } // Windows typically uses a colon for the option name and argument // delimiter while POSIX typically uses an equals. Support both styles, // but don't allow the two to be mixed. That is to say /foo:bar and // --foo=bar are acceptable, but /foo=bar and --foo:bar are not. var pos int var sp string if prefix == "/" { sp = ":" pos = strings.Index(option, sp) } else if len(prefix) > 0 { sp = "=" pos = strings.Index(option, sp) } if (islong && pos >= 0) || (!islong && pos == 1) { rest := option[pos+1:] return option[:pos], sp, &rest } return option, "", nil } // addHelpGroup adds a new group that contains default help parameters. func (c *Command) addHelpGroup(showHelp func() error) *Group { // Windows CLI applications typically use /? for help, so make both // that available as well as the POSIX style h and help. var help struct { ShowHelpWindows func() error `short:"?" description:"Show this help message"` ShowHelpPosix func() error `short:"h" long:"help" description:"Show this help message"` } help.ShowHelpWindows = showHelp help.ShowHelpPosix = showHelp ret, _ := c.AddGroup("Help Options", "", &help) ret.isBuiltinHelp = true return ret } mongo-tools-r3.6.3/vendor/src/github.com/jessevdk/go-flags/parser.go000066400000000000000000000402541321131462300254460ustar00rootroot00000000000000// Copyright 2012 Jesse van den Kieboom. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package flags import ( "bytes" "fmt" "os" "path" "sort" "strings" "unicode/utf8" ) // A Parser provides command line option parsing. It can contain several // option groups each with their own set of options. type Parser struct { // Embedded, see Command for more information *Command // A usage string to be displayed in the help message. Usage string // Option flags changing the behavior of the parser. Options Options // NamespaceDelimiter separates group namespaces and option long names NamespaceDelimiter string // UnknownOptionsHandler is a function which gets called when the parser // encounters an unknown option. The function receives the unknown option // name, a SplitArgument which specifies its value if set with an argument // separator, and the remaining command line arguments. // It should return a new list of remaining arguments to continue parsing, // or an error to indicate a parse failure. UnknownOptionHandler func(option string, arg SplitArgument, args []string) ([]string, error) // CompletionHandler is a function gets called to handle the completion of // items. By default, the items are printed and the application is exited. // You can override this default behavior by specifying a custom CompletionHandler. CompletionHandler func(items []Completion) internalError error } // SplitArgument represents the argument value of an option that was passed using // an argument separator. type SplitArgument interface { // String returns the option's value as a string, and a boolean indicating // if the option was present. Value() (string, bool) } type strArgument struct { value *string } func (s strArgument) Value() (string, bool) { if s.value == nil { return "", false } return *s.value, true } // Options provides parser options that change the behavior of the option // parser. type Options uint const ( // None indicates no options. None Options = 0 // HelpFlag adds a default Help Options group to the parser containing // -h and --help options. When either -h or --help is specified on the // command line, the parser will return the special error of type // ErrHelp. When PrintErrors is also specified, then the help message // will also be automatically printed to os.Stderr. HelpFlag = 1 << iota // PassDoubleDash passes all arguments after a double dash, --, as // remaining command line arguments (i.e. they will not be parsed for // flags). PassDoubleDash // IgnoreUnknown ignores any unknown options and passes them as // remaining command line arguments instead of generating an error. IgnoreUnknown // PrintErrors prints any errors which occurred during parsing to // os.Stderr. PrintErrors // PassAfterNonOption passes all arguments after the first non option // as remaining command line arguments. This is equivalent to strict // POSIX processing. PassAfterNonOption // Default is a convenient default set of options which should cover // most of the uses of the flags package. Default = HelpFlag | PrintErrors | PassDoubleDash ) type parseState struct { arg string args []string retargs []string positional []*Arg err error command *Command lookup lookup } // Parse is a convenience function to parse command line options with default // settings. The provided data is a pointer to a struct representing the // default option group (named "Application Options"). For more control, use // flags.NewParser. func Parse(data interface{}) ([]string, error) { return NewParser(data, Default).Parse() } // ParseArgs is a convenience function to parse command line options with default // settings. The provided data is a pointer to a struct representing the // default option group (named "Application Options"). The args argument is // the list of command line arguments to parse. If you just want to parse the // default program command line arguments (i.e. os.Args), then use flags.Parse // instead. For more control, use flags.NewParser. func ParseArgs(data interface{}, args []string) ([]string, error) { return NewParser(data, Default).ParseArgs(args) } // NewParser creates a new parser. It uses os.Args[0] as the application // name and then calls Parser.NewNamedParser (see Parser.NewNamedParser for // more details). The provided data is a pointer to a struct representing the // default option group (named "Application Options"), or nil if the default // group should not be added. The options parameter specifies a set of options // for the parser. func NewParser(data interface{}, options Options) *Parser { p := NewNamedParser(path.Base(os.Args[0]), options) if data != nil { g, err := p.AddGroup("Application Options", "", data) if err == nil { g.parent = p } p.internalError = err } return p } // NewNamedParser creates a new parser. The appname is used to display the // executable name in the built-in help message. Option groups and commands can // be added to this parser by using AddGroup and AddCommand. func NewNamedParser(appname string, options Options) *Parser { p := &Parser{ Command: newCommand(appname, "", "", nil), Options: options, NamespaceDelimiter: ".", } p.Command.parent = p return p } // Parse parses the command line arguments from os.Args using Parser.ParseArgs. // For more detailed information see ParseArgs. func (p *Parser) Parse() ([]string, error) { return p.ParseArgs(os.Args[1:]) } // ParseArgs parses the command line arguments according to the option groups that // were added to the parser. On successful parsing of the arguments, the // remaining, non-option, arguments (if any) are returned. The returned error // indicates a parsing error and can be used with PrintError to display // contextual information on where the error occurred exactly. // // When the common help group has been added (AddHelp) and either -h or --help // was specified in the command line arguments, a help message will be // automatically printed if the PrintErrors option is enabled. // Furthermore, the special error type ErrHelp is returned. // It is up to the caller to exit the program if so desired. func (p *Parser) ParseArgs(args []string) ([]string, error) { if p.internalError != nil { return nil, p.internalError } p.eachOption(func(c *Command, g *Group, option *Option) { option.isSet = false option.updateDefaultLiteral() }) // Add built-in help group to all commands if necessary if (p.Options & HelpFlag) != None { p.addHelpGroups(p.showBuiltinHelp) } compval := os.Getenv("GO_FLAGS_COMPLETION") if len(compval) != 0 { comp := &completion{parser: p} items := comp.complete(args) if p.CompletionHandler != nil { p.CompletionHandler(items) } else { comp.print(items, compval == "verbose") os.Exit(0) } return nil, nil } s := &parseState{ args: args, retargs: make([]string, 0, len(args)), } p.fillParseState(s) for !s.eof() { arg := s.pop() // When PassDoubleDash is set and we encounter a --, then // simply append all the rest as arguments and break out if (p.Options&PassDoubleDash) != None && arg == "--" { s.addArgs(s.args...) break } if !argumentIsOption(arg) { // Note: this also sets s.err, so we can just check for // nil here and use s.err later if p.parseNonOption(s) != nil { break } continue } var err error prefix, optname, islong := stripOptionPrefix(arg) optname, _, argument := splitOption(prefix, optname, islong) if islong { err = p.parseLong(s, optname, argument) } else { err = p.parseShort(s, optname, argument) } if err != nil { ignoreUnknown := (p.Options & IgnoreUnknown) != None parseErr := wrapError(err) if parseErr.Type != ErrUnknownFlag || (!ignoreUnknown && p.UnknownOptionHandler == nil) { s.err = parseErr break } if ignoreUnknown { s.addArgs(arg) } else if p.UnknownOptionHandler != nil { modifiedArgs, err := p.UnknownOptionHandler(optname, strArgument{argument}, s.args) if err != nil { s.err = err break } s.args = modifiedArgs } } } if s.err == nil { p.eachOption(func(c *Command, g *Group, option *Option) { if option.preventDefault { return } option.clearDefault() }) s.checkRequired(p) } var reterr error if s.err != nil { reterr = s.err } else if len(s.command.commands) != 0 && !s.command.SubcommandsOptional { reterr = s.estimateCommand() } else if cmd, ok := s.command.data.(Commander); ok { reterr = cmd.Execute(s.retargs) } if reterr != nil { var retargs []string if ourErr, ok := reterr.(*Error); !ok || ourErr.Type != ErrHelp { retargs = append([]string{s.arg}, s.args...) } else { retargs = s.args } return retargs, p.printError(reterr) } return s.retargs, nil } func (p *parseState) eof() bool { return len(p.args) == 0 } func (p *parseState) pop() string { if p.eof() { return "" } p.arg = p.args[0] p.args = p.args[1:] return p.arg } func (p *parseState) peek() string { if p.eof() { return "" } return p.args[0] } func (p *parseState) checkRequired(parser *Parser) error { c := parser.Command var required []*Option for c != nil { c.eachGroup(func(g *Group) { for _, option := range g.options { if !option.isSet && option.Required { required = append(required, option) } } }) c = c.Active } if len(required) == 0 { if len(p.positional) > 0 { var reqnames []string for _, arg := range p.positional { argRequired := (!arg.isRemaining() && p.command.ArgsRequired) || arg.Required != 0 if !argRequired { continue } if arg.isRemaining() { if arg.value.Len() < arg.Required { var arguments string if arg.Required > 1 { arguments = "arguments, but got only " + fmt.Sprintf("%d", arg.value.Len()) } else { arguments = "argument" } reqnames = append(reqnames, "`"+arg.Name+" (at least "+fmt.Sprintf("%d", arg.Required)+" "+arguments+")`") } } else { reqnames = append(reqnames, "`"+arg.Name+"`") } } if len(reqnames) == 0 { return nil } var msg string if len(reqnames) == 1 { msg = fmt.Sprintf("the required argument %s was not provided", reqnames[0]) } else { msg = fmt.Sprintf("the required arguments %s and %s were not provided", strings.Join(reqnames[:len(reqnames)-1], ", "), reqnames[len(reqnames)-1]) } p.err = newError(ErrRequired, msg) return p.err } return nil } names := make([]string, 0, len(required)) for _, k := range required { names = append(names, "`"+k.String()+"'") } sort.Strings(names) var msg string if len(names) == 1 { msg = fmt.Sprintf("the required flag %s was not specified", names[0]) } else { msg = fmt.Sprintf("the required flags %s and %s were not specified", strings.Join(names[:len(names)-1], ", "), names[len(names)-1]) } p.err = newError(ErrRequired, msg) return p.err } func (p *parseState) estimateCommand() error { commands := p.command.sortedVisibleCommands() cmdnames := make([]string, len(commands)) for i, v := range commands { cmdnames[i] = v.Name } var msg string var errtype ErrorType if len(p.retargs) != 0 { c, l := closestChoice(p.retargs[0], cmdnames) msg = fmt.Sprintf("Unknown command `%s'", p.retargs[0]) errtype = ErrUnknownCommand if float32(l)/float32(len(c)) < 0.5 { msg = fmt.Sprintf("%s, did you mean `%s'?", msg, c) } else if len(cmdnames) == 1 { msg = fmt.Sprintf("%s. You should use the %s command", msg, cmdnames[0]) } else { msg = fmt.Sprintf("%s. Please specify one command of: %s or %s", msg, strings.Join(cmdnames[:len(cmdnames)-1], ", "), cmdnames[len(cmdnames)-1]) } } else { errtype = ErrCommandRequired if len(cmdnames) == 1 { msg = fmt.Sprintf("Please specify the %s command", cmdnames[0]) } else { msg = fmt.Sprintf("Please specify one command of: %s or %s", strings.Join(cmdnames[:len(cmdnames)-1], ", "), cmdnames[len(cmdnames)-1]) } } return newError(errtype, msg) } func (p *Parser) parseOption(s *parseState, name string, option *Option, canarg bool, argument *string) (err error) { if !option.canArgument() { if argument != nil { return newErrorf(ErrNoArgumentForBool, "bool flag `%s' cannot have an argument", option) } err = option.set(nil) } else if argument != nil || (canarg && !s.eof()) { var arg string if argument != nil { arg = *argument } else { arg = s.pop() if argumentIsOption(arg) { return newErrorf(ErrExpectedArgument, "expected argument for flag `%s', but got option `%s'", option, arg) } else if p.Options&PassDoubleDash != 0 && arg == "--" { return newErrorf(ErrExpectedArgument, "expected argument for flag `%s', but got double dash `--'", option) } } if option.tag.Get("unquote") != "false" { arg, err = unquoteIfPossible(arg) } if err == nil { err = option.set(&arg) } } else if option.OptionalArgument { option.empty() for _, v := range option.OptionalValue { err = option.set(&v) if err != nil { break } } } else { err = newErrorf(ErrExpectedArgument, "expected argument for flag `%s'", option) } if err != nil { if _, ok := err.(*Error); !ok { err = newErrorf(ErrMarshal, "invalid argument for flag `%s' (expected %s): %s", option, option.value.Type(), err.Error()) } } return err } func (p *Parser) parseLong(s *parseState, name string, argument *string) error { if option := s.lookup.longNames[name]; option != nil { // Only long options that are required can consume an argument // from the argument list canarg := !option.OptionalArgument return p.parseOption(s, name, option, canarg, argument) } return newErrorf(ErrUnknownFlag, "unknown flag `%s'", name) } func (p *Parser) splitShortConcatArg(s *parseState, optname string) (string, *string) { c, n := utf8.DecodeRuneInString(optname) if n == len(optname) { return optname, nil } first := string(c) if option := s.lookup.shortNames[first]; option != nil && option.canArgument() { arg := optname[n:] return first, &arg } return optname, nil } func (p *Parser) parseShort(s *parseState, optname string, argument *string) error { if argument == nil { optname, argument = p.splitShortConcatArg(s, optname) } for i, c := range optname { shortname := string(c) if option := s.lookup.shortNames[shortname]; option != nil { // Only the last short argument can consume an argument from // the arguments list, and only if it's non optional canarg := (i+utf8.RuneLen(c) == len(optname)) && !option.OptionalArgument if err := p.parseOption(s, shortname, option, canarg, argument); err != nil { return err } } else { return newErrorf(ErrUnknownFlag, "unknown flag `%s'", shortname) } // Only the first option can have a concatted argument, so just // clear argument here argument = nil } return nil } func (p *parseState) addArgs(args ...string) error { for len(p.positional) > 0 && len(args) > 0 { arg := p.positional[0] if err := convert(args[0], arg.value, arg.tag); err != nil { return err } if !arg.isRemaining() { p.positional = p.positional[1:] } args = args[1:] } p.retargs = append(p.retargs, args...) return nil } func (p *Parser) parseNonOption(s *parseState) error { if len(s.positional) > 0 { return s.addArgs(s.arg) } if cmd := s.lookup.commands[s.arg]; cmd != nil { s.command.Active = cmd cmd.fillParseState(s) } else if (p.Options & PassAfterNonOption) != None { // If PassAfterNonOption is set then all remaining arguments // are considered positional if err := s.addArgs(s.arg); err != nil { return err } if err := s.addArgs(s.args...); err != nil { return err } s.args = []string{} } else { return s.addArgs(s.arg) } return nil } func (p *Parser) showBuiltinHelp() error { var b bytes.Buffer p.WriteHelp(&b) return newError(ErrHelp, b.String()) } func (p *Parser) printError(err error) error { if err != nil && (p.Options&PrintErrors) != None { fmt.Fprintln(os.Stderr, err) } return err } func (p *Parser) clearIsSet() { p.eachCommand(func(c *Command) { c.eachGroup(func(g *Group) { for _, option := range g.options { option.isSet = false } }) }, true) } mongo-tools-r3.6.3/vendor/src/github.com/jessevdk/go-flags/parser_test.go000066400000000000000000000302651321131462300265060ustar00rootroot00000000000000package flags import ( "fmt" "os" "reflect" "strconv" "strings" "testing" "time" ) type defaultOptions struct { Int int `long:"i"` IntDefault int `long:"id" default:"1"` Float64 float64 `long:"f"` Float64Default float64 `long:"fd" default:"-3.14"` NumericFlag bool `short:"3" default:"false"` String string `long:"str"` StringDefault string `long:"strd" default:"abc"` StringNotUnquoted string `long:"strnot" unquote:"false"` Time time.Duration `long:"t"` TimeDefault time.Duration `long:"td" default:"1m"` Map map[string]int `long:"m"` MapDefault map[string]int `long:"md" default:"a:1"` Slice []int `long:"s"` SliceDefault []int `long:"sd" default:"1" default:"2"` } func TestDefaults(t *testing.T) { var tests = []struct { msg string args []string expected defaultOptions }{ { msg: "no arguments, expecting default values", args: []string{}, expected: defaultOptions{ Int: 0, IntDefault: 1, Float64: 0.0, Float64Default: -3.14, NumericFlag: false, String: "", StringDefault: "abc", Time: 0, TimeDefault: time.Minute, Map: map[string]int{}, MapDefault: map[string]int{"a": 1}, Slice: []int{}, SliceDefault: []int{1, 2}, }, }, { msg: "non-zero value arguments, expecting overwritten arguments", args: []string{"--i=3", "--id=3", "--f=-2.71", "--fd=2.71", "-3", "--str=def", "--strd=def", "--t=3ms", "--td=3ms", "--m=c:3", "--md=c:3", "--s=3", "--sd=3"}, expected: defaultOptions{ Int: 3, IntDefault: 3, Float64: -2.71, Float64Default: 2.71, NumericFlag: true, String: "def", StringDefault: "def", Time: 3 * time.Millisecond, TimeDefault: 3 * time.Millisecond, Map: map[string]int{"c": 3}, MapDefault: map[string]int{"c": 3}, Slice: []int{3}, SliceDefault: []int{3}, }, }, { msg: "zero value arguments, expecting overwritten arguments", args: []string{"--i=0", "--id=0", "--f=0", "--fd=0", "--str", "", "--strd=\"\"", "--t=0ms", "--td=0s", "--m=:0", "--md=:0", "--s=0", "--sd=0"}, expected: defaultOptions{ Int: 0, IntDefault: 0, Float64: 0, Float64Default: 0, String: "", StringDefault: "", Time: 0, TimeDefault: 0, Map: map[string]int{"": 0}, MapDefault: map[string]int{"": 0}, Slice: []int{0}, SliceDefault: []int{0}, }, }, } for _, test := range tests { var opts defaultOptions _, err := ParseArgs(&opts, test.args) if err != nil { t.Fatalf("%s:\nUnexpected error: %v", test.msg, err) } if opts.Slice == nil { opts.Slice = []int{} } if !reflect.DeepEqual(opts, test.expected) { t.Errorf("%s:\nUnexpected options with arguments %+v\nexpected\n%+v\nbut got\n%+v\n", test.msg, test.args, test.expected, opts) } } } func TestUnquoting(t *testing.T) { var tests = []struct { arg string err error value string }{ { arg: "\"abc", err: strconv.ErrSyntax, value: "", }, { arg: "\"\"abc\"", err: strconv.ErrSyntax, value: "", }, { arg: "\"abc\"", err: nil, value: "abc", }, { arg: "\"\\\"abc\\\"\"", err: nil, value: "\"abc\"", }, { arg: "\"\\\"abc\"", err: nil, value: "\"abc", }, } for _, test := range tests { var opts defaultOptions for _, delimiter := range []bool{false, true} { p := NewParser(&opts, None) var err error if delimiter { _, err = p.ParseArgs([]string{"--str=" + test.arg, "--strnot=" + test.arg}) } else { _, err = p.ParseArgs([]string{"--str", test.arg, "--strnot", test.arg}) } if test.err == nil { if err != nil { t.Fatalf("Expected no error but got: %v", err) } if test.value != opts.String { t.Fatalf("Expected String to be %q but got %q", test.value, opts.String) } if q := strconv.Quote(test.value); q != opts.StringNotUnquoted { t.Fatalf("Expected StringDefault to be %q but got %q", q, opts.StringNotUnquoted) } } else { if err == nil { t.Fatalf("Expected error") } else if e, ok := err.(*Error); ok { if strings.HasPrefix(e.Message, test.err.Error()) { t.Fatalf("Expected error message to end with %q but got %v", test.err.Error(), e.Message) } } } } } } // envRestorer keeps a copy of a set of env variables and can restore the env from them type envRestorer struct { env map[string]string } func (r *envRestorer) Restore() { os.Clearenv() for k, v := range r.env { os.Setenv(k, v) } } // EnvSnapshot returns a snapshot of the currently set env variables func EnvSnapshot() *envRestorer { r := envRestorer{make(map[string]string)} for _, kv := range os.Environ() { parts := strings.SplitN(kv, "=", 2) if len(parts) != 2 { panic("got a weird env variable: " + kv) } r.env[parts[0]] = parts[1] } return &r } type envDefaultOptions struct { Int int `long:"i" default:"1" env:"TEST_I"` Time time.Duration `long:"t" default:"1m" env:"TEST_T"` Map map[string]int `long:"m" default:"a:1" env:"TEST_M" env-delim:";"` Slice []int `long:"s" default:"1" default:"2" env:"TEST_S" env-delim:","` } func TestEnvDefaults(t *testing.T) { var tests = []struct { msg string args []string expected envDefaultOptions env map[string]string }{ { msg: "no arguments, no env, expecting default values", args: []string{}, expected: envDefaultOptions{ Int: 1, Time: time.Minute, Map: map[string]int{"a": 1}, Slice: []int{1, 2}, }, }, { msg: "no arguments, env defaults, expecting env default values", args: []string{}, expected: envDefaultOptions{ Int: 2, Time: 2 * time.Minute, Map: map[string]int{"a": 2, "b": 3}, Slice: []int{4, 5, 6}, }, env: map[string]string{ "TEST_I": "2", "TEST_T": "2m", "TEST_M": "a:2;b:3", "TEST_S": "4,5,6", }, }, { msg: "non-zero value arguments, expecting overwritten arguments", args: []string{"--i=3", "--t=3ms", "--m=c:3", "--s=3"}, expected: envDefaultOptions{ Int: 3, Time: 3 * time.Millisecond, Map: map[string]int{"c": 3}, Slice: []int{3}, }, env: map[string]string{ "TEST_I": "2", "TEST_T": "2m", "TEST_M": "a:2;b:3", "TEST_S": "4,5,6", }, }, { msg: "zero value arguments, expecting overwritten arguments", args: []string{"--i=0", "--t=0ms", "--m=:0", "--s=0"}, expected: envDefaultOptions{ Int: 0, Time: 0, Map: map[string]int{"": 0}, Slice: []int{0}, }, env: map[string]string{ "TEST_I": "2", "TEST_T": "2m", "TEST_M": "a:2;b:3", "TEST_S": "4,5,6", }, }, } oldEnv := EnvSnapshot() defer oldEnv.Restore() for _, test := range tests { var opts envDefaultOptions oldEnv.Restore() for envKey, envValue := range test.env { os.Setenv(envKey, envValue) } _, err := ParseArgs(&opts, test.args) if err != nil { t.Fatalf("%s:\nUnexpected error: %v", test.msg, err) } if opts.Slice == nil { opts.Slice = []int{} } if !reflect.DeepEqual(opts, test.expected) { t.Errorf("%s:\nUnexpected options with arguments %+v\nexpected\n%+v\nbut got\n%+v\n", test.msg, test.args, test.expected, opts) } } } func TestOptionAsArgument(t *testing.T) { var tests = []struct { args []string expectError bool errType ErrorType errMsg string rest []string }{ { // short option must not be accepted as argument args: []string{"--string-slice", "foobar", "--string-slice", "-o"}, expectError: true, errType: ErrExpectedArgument, errMsg: "expected argument for flag `" + defaultLongOptDelimiter + "string-slice', but got option `-o'", }, { // long option must not be accepted as argument args: []string{"--string-slice", "foobar", "--string-slice", "--other-option"}, expectError: true, errType: ErrExpectedArgument, errMsg: "expected argument for flag `" + defaultLongOptDelimiter + "string-slice', but got option `--other-option'", }, { // long option must not be accepted as argument args: []string{"--string-slice", "--"}, expectError: true, errType: ErrExpectedArgument, errMsg: "expected argument for flag `" + defaultLongOptDelimiter + "string-slice', but got double dash `--'", }, { // quoted and appended option should be accepted as argument (even if it looks like an option) args: []string{"--string-slice", "foobar", "--string-slice=\"--other-option\""}, }, { // Accept any single character arguments including '-' args: []string{"--string-slice", "-"}, }, { // Do not accept arguments which start with '-' even if the next character is a digit args: []string{"--string-slice", "-3.14"}, expectError: true, errType: ErrExpectedArgument, errMsg: "expected argument for flag `" + defaultLongOptDelimiter + "string-slice', but got option `-3.14'", }, { // Do not accept arguments which start with '-' if the next character is not a digit args: []string{"--string-slice", "-character"}, expectError: true, errType: ErrExpectedArgument, errMsg: "expected argument for flag `" + defaultLongOptDelimiter + "string-slice', but got option `-character'", }, { args: []string{"-o", "-", "-"}, rest: []string{"-", "-"}, }, } var opts struct { StringSlice []string `long:"string-slice"` OtherOption bool `long:"other-option" short:"o"` } for _, test := range tests { if test.expectError { assertParseFail(t, test.errType, test.errMsg, &opts, test.args...) } else { args := assertParseSuccess(t, &opts, test.args...) assertStringArray(t, args, test.rest) } } } func TestUnknownFlagHandler(t *testing.T) { var opts struct { Flag1 string `long:"flag1"` Flag2 string `long:"flag2"` } p := NewParser(&opts, None) var unknownFlag1 string var unknownFlag2 bool var unknownFlag3 string // Set up a callback to intercept unknown options during parsing p.UnknownOptionHandler = func(option string, arg SplitArgument, args []string) ([]string, error) { if option == "unknownFlag1" { if argValue, ok := arg.Value(); ok { unknownFlag1 = argValue return args, nil } // consume a value from remaining args list unknownFlag1 = args[0] return args[1:], nil } else if option == "unknownFlag2" { // treat this one as a bool switch, don't consume any args unknownFlag2 = true return args, nil } else if option == "unknownFlag3" { if argValue, ok := arg.Value(); ok { unknownFlag3 = argValue return args, nil } // consume a value from remaining args list unknownFlag3 = args[0] return args[1:], nil } return args, fmt.Errorf("Unknown flag: %v", option) } // Parse args containing some unknown flags, verify that // our callback can handle all of them _, err := p.ParseArgs([]string{"--flag1=stuff", "--unknownFlag1", "blah", "--unknownFlag2", "--unknownFlag3=baz", "--flag2=foo"}) if err != nil { assertErrorf(t, "Parser returned unexpected error %v", err) } assertString(t, opts.Flag1, "stuff") assertString(t, opts.Flag2, "foo") assertString(t, unknownFlag1, "blah") assertString(t, unknownFlag3, "baz") if !unknownFlag2 { assertErrorf(t, "Flag should have been set by unknown handler, but had value: %v", unknownFlag2) } // Parse args with unknown flags that callback doesn't handle, verify it returns error _, err = p.ParseArgs([]string{"--flag1=stuff", "--unknownFlagX", "blah", "--flag2=foo"}) if err == nil { assertErrorf(t, "Parser should have returned error, but returned nil") } } func TestChoices(t *testing.T) { var opts struct { Choice string `long:"choose" choice:"v1" choice:"v2"` } assertParseFail(t, ErrInvalidChoice, "Invalid value `invalid' for option `"+defaultLongOptDelimiter+"choose'. Allowed values are: v1 or v2", &opts, "--choose", "invalid") assertParseSuccess(t, &opts, "--choose", "v2") assertString(t, opts.Choice, "v2") } func TestEmbedded(t *testing.T) { type embedded struct { V bool `short:"v"` } var opts struct { embedded } assertParseSuccess(t, &opts, "-v") if !opts.V { t.Errorf("Expected V to be true") } } mongo-tools-r3.6.3/vendor/src/github.com/jessevdk/go-flags/pointer_test.go000066400000000000000000000031411321131462300266630ustar00rootroot00000000000000package flags import ( "testing" ) func TestPointerBool(t *testing.T) { var opts = struct { Value *bool `short:"v"` }{} ret := assertParseSuccess(t, &opts, "-v") assertStringArray(t, ret, []string{}) if !*opts.Value { t.Errorf("Expected Value to be true") } } func TestPointerString(t *testing.T) { var opts = struct { Value *string `short:"v"` }{} ret := assertParseSuccess(t, &opts, "-v", "value") assertStringArray(t, ret, []string{}) assertString(t, *opts.Value, "value") } func TestPointerSlice(t *testing.T) { var opts = struct { Value *[]string `short:"v"` }{} ret := assertParseSuccess(t, &opts, "-v", "value1", "-v", "value2") assertStringArray(t, ret, []string{}) assertStringArray(t, *opts.Value, []string{"value1", "value2"}) } func TestPointerMap(t *testing.T) { var opts = struct { Value *map[string]int `short:"v"` }{} ret := assertParseSuccess(t, &opts, "-v", "k1:2", "-v", "k2:-5") assertStringArray(t, ret, []string{}) if v, ok := (*opts.Value)["k1"]; !ok { t.Errorf("Expected key \"k1\" to exist") } else if v != 2 { t.Errorf("Expected \"k1\" to be 2, but got %#v", v) } if v, ok := (*opts.Value)["k2"]; !ok { t.Errorf("Expected key \"k2\" to exist") } else if v != -5 { t.Errorf("Expected \"k2\" to be -5, but got %#v", v) } } type PointerGroup struct { Value bool `short:"v"` } func TestPointerGroup(t *testing.T) { var opts = struct { Group *PointerGroup `group:"Group Options"` }{} ret := assertParseSuccess(t, &opts, "-v") assertStringArray(t, ret, []string{}) if !opts.Group.Value { t.Errorf("Expected Group.Value to be true") } } mongo-tools-r3.6.3/vendor/src/github.com/jessevdk/go-flags/short_test.go000066400000000000000000000077531321131462300263570ustar00rootroot00000000000000package flags import ( "fmt" "testing" ) func TestShort(t *testing.T) { var opts = struct { Value bool `short:"v"` }{} ret := assertParseSuccess(t, &opts, "-v") assertStringArray(t, ret, []string{}) if !opts.Value { t.Errorf("Expected Value to be true") } } func TestShortTooLong(t *testing.T) { var opts = struct { Value bool `short:"vv"` }{} assertParseFail(t, ErrShortNameTooLong, "short names can only be 1 character long, not `vv'", &opts) } func TestShortRequired(t *testing.T) { var opts = struct { Value bool `short:"v" required:"true"` }{} assertParseFail(t, ErrRequired, fmt.Sprintf("the required flag `%cv' was not specified", defaultShortOptDelimiter), &opts) } func TestShortMultiConcat(t *testing.T) { var opts = struct { V bool `short:"v"` O bool `short:"o"` F bool `short:"f"` }{} ret := assertParseSuccess(t, &opts, "-vo", "-f") assertStringArray(t, ret, []string{}) if !opts.V { t.Errorf("Expected V to be true") } if !opts.O { t.Errorf("Expected O to be true") } if !opts.F { t.Errorf("Expected F to be true") } } func TestShortMultiRequiredConcat(t *testing.T) { var opts = struct { V bool `short:"v" required:"true"` O bool `short:"o" required:"true"` F bool `short:"f" required:"true"` }{} ret := assertParseSuccess(t, &opts, "-vo", "-f") assertStringArray(t, ret, []string{}) if !opts.V { t.Errorf("Expected V to be true") } if !opts.O { t.Errorf("Expected O to be true") } if !opts.F { t.Errorf("Expected F to be true") } } func TestShortMultiSlice(t *testing.T) { var opts = struct { Values []bool `short:"v"` }{} ret := assertParseSuccess(t, &opts, "-v", "-v") assertStringArray(t, ret, []string{}) assertBoolArray(t, opts.Values, []bool{true, true}) } func TestShortMultiSliceConcat(t *testing.T) { var opts = struct { Values []bool `short:"v"` }{} ret := assertParseSuccess(t, &opts, "-vvv") assertStringArray(t, ret, []string{}) assertBoolArray(t, opts.Values, []bool{true, true, true}) } func TestShortWithEqualArg(t *testing.T) { var opts = struct { Value string `short:"v"` }{} ret := assertParseSuccess(t, &opts, "-v=value") assertStringArray(t, ret, []string{}) assertString(t, opts.Value, "value") } func TestShortWithArg(t *testing.T) { var opts = struct { Value string `short:"v"` }{} ret := assertParseSuccess(t, &opts, "-vvalue") assertStringArray(t, ret, []string{}) assertString(t, opts.Value, "value") } func TestShortArg(t *testing.T) { var opts = struct { Value string `short:"v"` }{} ret := assertParseSuccess(t, &opts, "-v", "value") assertStringArray(t, ret, []string{}) assertString(t, opts.Value, "value") } func TestShortMultiWithEqualArg(t *testing.T) { var opts = struct { F []bool `short:"f"` Value string `short:"v"` }{} assertParseFail(t, ErrExpectedArgument, fmt.Sprintf("expected argument for flag `%cv'", defaultShortOptDelimiter), &opts, "-ffv=value") } func TestShortMultiArg(t *testing.T) { var opts = struct { F []bool `short:"f"` Value string `short:"v"` }{} ret := assertParseSuccess(t, &opts, "-ffv", "value") assertStringArray(t, ret, []string{}) assertBoolArray(t, opts.F, []bool{true, true}) assertString(t, opts.Value, "value") } func TestShortMultiArgConcatFail(t *testing.T) { var opts = struct { F []bool `short:"f"` Value string `short:"v"` }{} assertParseFail(t, ErrExpectedArgument, fmt.Sprintf("expected argument for flag `%cv'", defaultShortOptDelimiter), &opts, "-ffvvalue") } func TestShortMultiArgConcat(t *testing.T) { var opts = struct { F []bool `short:"f"` Value string `short:"v"` }{} ret := assertParseSuccess(t, &opts, "-vff") assertStringArray(t, ret, []string{}) assertString(t, opts.Value, "ff") } func TestShortOptional(t *testing.T) { var opts = struct { F []bool `short:"f"` Value string `short:"v" optional:"yes" optional-value:"value"` }{} ret := assertParseSuccess(t, &opts, "-fv", "f") assertStringArray(t, ret, []string{"f"}) assertString(t, opts.Value, "value") } mongo-tools-r3.6.3/vendor/src/github.com/jessevdk/go-flags/tag_test.go000066400000000000000000000016061321131462300257620ustar00rootroot00000000000000package flags import ( "testing" ) func TestTagMissingColon(t *testing.T) { var opts = struct { Value bool `short` }{} assertParseFail(t, ErrTag, "expected `:' after key name, but got end of tag (in `short`)", &opts, "") } func TestTagMissingValue(t *testing.T) { var opts = struct { Value bool `short:` }{} assertParseFail(t, ErrTag, "expected `\"' to start tag value at end of tag (in `short:`)", &opts, "") } func TestTagMissingQuote(t *testing.T) { var opts = struct { Value bool `short:"v` }{} assertParseFail(t, ErrTag, "expected end of tag value `\"' at end of tag (in `short:\"v`)", &opts, "") } func TestTagNewline(t *testing.T) { var opts = struct { Value bool `long:"verbose" description:"verbose something"` }{} assertParseFail(t, ErrTag, "unexpected newline in tag value `description' (in `long:\"verbose\" description:\"verbose\nsomething\"`)", &opts, "") } mongo-tools-r3.6.3/vendor/src/github.com/jessevdk/go-flags/termsize.go000066400000000000000000000005671321131462300260170ustar00rootroot00000000000000// +build !windows,!plan9,!solaris package flags import ( "syscall" "unsafe" ) type winsize struct { row, col uint16 xpixel, ypixel uint16 } func getTerminalColumns() int { ws := winsize{} if tIOCGWINSZ != 0 { syscall.Syscall(syscall.SYS_IOCTL, uintptr(0), uintptr(tIOCGWINSZ), uintptr(unsafe.Pointer(&ws))) return int(ws.col) } return 80 } mongo-tools-r3.6.3/vendor/src/github.com/jessevdk/go-flags/termsize_linux.go000066400000000000000000000000771321131462300272320ustar00rootroot00000000000000// +build linux package flags const ( tIOCGWINSZ = 0x5413 ) mongo-tools-r3.6.3/vendor/src/github.com/jessevdk/go-flags/termsize_nosysioctl.go000066400000000000000000000001351321131462300302740ustar00rootroot00000000000000// +build windows plan9 solaris package flags func getTerminalColumns() int { return 80 } mongo-tools-r3.6.3/vendor/src/github.com/jessevdk/go-flags/termsize_other.go000066400000000000000000000001351321131462300272070ustar00rootroot00000000000000// +build !darwin,!freebsd,!netbsd,!openbsd,!linux package flags const ( tIOCGWINSZ = 0 ) mongo-tools-r3.6.3/vendor/src/github.com/jessevdk/go-flags/termsize_unix.go000066400000000000000000000001331321131462300270470ustar00rootroot00000000000000// +build darwin freebsd netbsd openbsd package flags const ( tIOCGWINSZ = 0x40087468 ) mongo-tools-r3.6.3/vendor/src/github.com/jessevdk/go-flags/unknown_test.go000066400000000000000000000017221321131462300267050ustar00rootroot00000000000000package flags import ( "testing" ) func TestUnknownFlags(t *testing.T) { var opts = struct { Verbose []bool `short:"v" long:"verbose" description:"Verbose output"` }{} args := []string{ "-f", } p := NewParser(&opts, 0) args, err := p.ParseArgs(args) if err == nil { t.Fatal("Expected error for unknown argument") } } func TestIgnoreUnknownFlags(t *testing.T) { var opts = struct { Verbose []bool `short:"v" long:"verbose" description:"Verbose output"` }{} args := []string{ "hello", "world", "-v", "--foo=bar", "--verbose", "-f", } p := NewParser(&opts, IgnoreUnknown) args, err := p.ParseArgs(args) if err != nil { t.Fatal(err) } exargs := []string{ "hello", "world", "--foo=bar", "-f", } issame := (len(args) == len(exargs)) if issame { for i := 0; i < len(args); i++ { if args[i] != exargs[i] { issame = false break } } } if !issame { t.Fatalf("Expected %v but got %v", exargs, args) } } mongo-tools-r3.6.3/vendor/src/github.com/jtolds/000077500000000000000000000000001321131462300216005ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/jtolds/gls/000077500000000000000000000000001321131462300223655ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/jtolds/gls/LICENSE000066400000000000000000000020471321131462300233750ustar00rootroot00000000000000Copyright (c) 2013, Space Monkey, Inc. 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. mongo-tools-r3.6.3/vendor/src/github.com/jtolds/gls/README.md000066400000000000000000000067551321131462300236610ustar00rootroot00000000000000gls === Goroutine local storage ### IMPORTANT NOTE ### It is my duty to point you to https://blog.golang.org/context, which is how Google solves all of the problems you'd perhaps consider using this package for at scale. One downside to Google's approach is that *all* of your functions must have a new first argument, but after clearing that hurdle everything else is much better. If you aren't interested in this warning, read on. ### Huhwaht? Why? ### Every so often, a thread shows up on the [golang-nuts](https://groups.google.com/d/forum/golang-nuts) asking for some form of goroutine-local-storage, or some kind of goroutine id, or some kind of context. There are a few valid use cases for goroutine-local-storage, one of the most prominent being log line context. One poster was interested in being able to log an HTTP request context id in every log line in the same goroutine as the incoming HTTP request, without having to change every library and function call he was interested in logging. This would be pretty useful. Provided that you could get some kind of goroutine-local-storage, you could call [log.SetOutput](http://golang.org/pkg/log/#SetOutput) with your own logging writer that checks goroutine-local-storage for some context information and adds that context to your log lines. But alas, Andrew Gerrand's typically diplomatic answer to the question of goroutine-local variables was: > We wouldn't even be having this discussion if thread local storage wasn't > useful. But every feature comes at a cost, and in my opinion the cost of > threadlocals far outweighs their benefits. They're just not a good fit for > Go. So, yeah, that makes sense. That's a pretty good reason for why the language won't support a specific and (relatively) unuseful feature that requires some runtime changes, just for the sake of a little bit of log improvement. But does Go require runtime changes? ### How it works ### Go has pretty fantastic introspective and reflective features, but one thing Go doesn't give you is any kind of access to the stack pointer, or frame pointer, or goroutine id, or anything contextual about your current stack. It gives you access to your list of callers, but only along with program counters, which are fixed at compile time. But it does give you the stack. So, we define 16 special functions and embed base-16 tags into the stack using the call order of those 16 functions. Then, we can read our tags back out of the stack looking at the callers list. We then use these tags as an index into a traditional map for implementing this library. ### What are people saying? ### "Wow, that's horrifying." "This is the most terrible thing I have seen in a very long time." "Where is it getting a context from? Is this serializing all the requests? What the heck is the client being bound to? What are these tags? Why does he need callers? Oh god no. No no no." ### Docs ### Please see the docs at http://godoc.org/github.com/jtolds/gls ### Related ### If you're okay relying on the string format of the current runtime stacktrace including a unique goroutine id (not guaranteed by the spec or anything, but very unlikely to change within a Go release), you might be able to squeeze out a bit more performance by using this similar library, inspired by some code Brad Fitzpatrick wrote for debugging his HTTP/2 library: https://github.com/tylerb/gls (in contrast, jtolds/gls doesn't require any knowledge of the string format of the runtime stacktrace, which probably adds unnecessary overhead). mongo-tools-r3.6.3/vendor/src/github.com/jtolds/gls/context.go000066400000000000000000000100751321131462300244030ustar00rootroot00000000000000// Package gls implements goroutine-local storage. package gls import ( "sync" ) const ( maxCallers = 64 ) var ( stackTagPool = &idPool{} mgrRegistry = make(map[*ContextManager]bool) mgrRegistryMtx sync.RWMutex ) // Values is simply a map of key types to value types. Used by SetValues to // set multiple values at once. type Values map[interface{}]interface{} // ContextManager is the main entrypoint for interacting with // Goroutine-local-storage. You can have multiple independent ContextManagers // at any given time. ContextManagers are usually declared globally for a given // class of context variables. You should use NewContextManager for // construction. type ContextManager struct { mtx sync.RWMutex values map[uint]Values } // NewContextManager returns a brand new ContextManager. It also registers the // new ContextManager in the ContextManager registry which is used by the Go // method. ContextManagers are typically defined globally at package scope. func NewContextManager() *ContextManager { mgr := &ContextManager{values: make(map[uint]Values)} mgrRegistryMtx.Lock() defer mgrRegistryMtx.Unlock() mgrRegistry[mgr] = true return mgr } // Unregister removes a ContextManager from the global registry, used by the // Go method. Only intended for use when you're completely done with a // ContextManager. Use of Unregister at all is rare. func (m *ContextManager) Unregister() { mgrRegistryMtx.Lock() defer mgrRegistryMtx.Unlock() delete(mgrRegistry, m) } // SetValues takes a collection of values and a function to call for those // values to be set in. Anything further down the stack will have the set // values available through GetValue. SetValues will add new values or replace // existing values of the same key and will not mutate or change values for // previous stack frames. // SetValues is slow (makes a copy of all current and new values for the new // gls-context) in order to reduce the amount of lookups GetValue requires. func (m *ContextManager) SetValues(new_values Values, context_call func()) { if len(new_values) == 0 { context_call() return } tags := readStackTags(1) m.mtx.Lock() values := new_values for _, tag := range tags { if existing_values, ok := m.values[tag]; ok { // oh, we found existing values, let's make a copy values = make(Values, len(existing_values)+len(new_values)) for key, val := range existing_values { values[key] = val } for key, val := range new_values { values[key] = val } break } } new_tag := stackTagPool.Acquire() m.values[new_tag] = values m.mtx.Unlock() defer func() { m.mtx.Lock() delete(m.values, new_tag) m.mtx.Unlock() stackTagPool.Release(new_tag) }() addStackTag(new_tag, context_call) } // GetValue will return a previously set value, provided that the value was set // by SetValues somewhere higher up the stack. If the value is not found, ok // will be false. func (m *ContextManager) GetValue(key interface{}) (value interface{}, ok bool) { tags := readStackTags(1) m.mtx.RLock() defer m.mtx.RUnlock() for _, tag := range tags { if values, ok := m.values[tag]; ok { value, ok := values[key] return value, ok } } return "", false } func (m *ContextManager) getValues() Values { tags := readStackTags(2) m.mtx.RLock() defer m.mtx.RUnlock() for _, tag := range tags { if values, ok := m.values[tag]; ok { return values } } return nil } // Go preserves ContextManager values and Goroutine-local-storage across new // goroutine invocations. The Go method makes a copy of all existing values on // all registered context managers and makes sure they are still set after // kicking off the provided function in a new goroutine. If you don't use this // Go method instead of the standard 'go' keyword, you will lose values in // ContextManagers, as goroutines have brand new stacks. func Go(cb func()) { mgrRegistryMtx.RLock() defer mgrRegistryMtx.RUnlock() for mgr, _ := range mgrRegistry { values := mgr.getValues() if len(values) > 0 { mgr_copy := mgr cb_copy := cb cb = func() { mgr_copy.SetValues(values, cb_copy) } } } go cb() } mongo-tools-r3.6.3/vendor/src/github.com/jtolds/gls/context_test.go000066400000000000000000000053471321131462300254500ustar00rootroot00000000000000package gls import ( "fmt" "sync" "testing" ) func TestContexts(t *testing.T) { mgr1 := NewContextManager() mgr2 := NewContextManager() CheckVal := func(mgr *ContextManager, key, exp_val string) { val, ok := mgr.GetValue(key) if len(exp_val) == 0 { if ok { t.Fatalf("expected no value for key %s, got %s", key, val) } return } if !ok { t.Fatalf("expected value %s for key %s, got no value", exp_val, key) } if exp_val != val { t.Fatalf("expected value %s for key %s, got %s", exp_val, key, val) } } Check := func(exp_m1v1, exp_m1v2, exp_m2v1, exp_m2v2 string) { CheckVal(mgr1, "key1", exp_m1v1) CheckVal(mgr1, "key2", exp_m1v2) CheckVal(mgr2, "key1", exp_m2v1) CheckVal(mgr2, "key2", exp_m2v2) } Check("", "", "", "") mgr2.SetValues(Values{"key1": "val1c"}, func() { Check("", "", "val1c", "") mgr1.SetValues(Values{"key1": "val1a"}, func() { Check("val1a", "", "val1c", "") mgr1.SetValues(Values{"key2": "val1b"}, func() { Check("val1a", "val1b", "val1c", "") var wg sync.WaitGroup wg.Add(2) go func() { defer wg.Done() Check("", "", "", "") }() Go(func() { defer wg.Done() Check("val1a", "val1b", "val1c", "") }) wg.Wait() }) }) }) } func ExampleContextManager_SetValues() { var ( mgr = NewContextManager() request_id_key = GenSym() ) MyLog := func() { if request_id, ok := mgr.GetValue(request_id_key); ok { fmt.Println("My request id is:", request_id) } else { fmt.Println("No request id found") } } mgr.SetValues(Values{request_id_key: "12345"}, func() { MyLog() }) MyLog() // Output: My request id is: 12345 // No request id found } func ExampleGo() { var ( mgr = NewContextManager() request_id_key = GenSym() ) MyLog := func() { if request_id, ok := mgr.GetValue(request_id_key); ok { fmt.Println("My request id is:", request_id) } else { fmt.Println("No request id found") } } mgr.SetValues(Values{request_id_key: "12345"}, func() { var wg sync.WaitGroup wg.Add(1) go func() { defer wg.Done() MyLog() }() wg.Wait() wg.Add(1) Go(func() { defer wg.Done() MyLog() }) wg.Wait() }) // Output: No request id found // My request id is: 12345 } func BenchmarkGetValue(b *testing.B) { mgr := NewContextManager() mgr.SetValues(Values{"test_key": "test_val"}, func() { b.ResetTimer() for i := 0; i < b.N; i++ { val, ok := mgr.GetValue("test_key") if !ok || val != "test_val" { b.FailNow() } } }) } func BenchmarkSetValues(b *testing.B) { mgr := NewContextManager() for i := 0; i < b.N/2; i++ { mgr.SetValues(Values{"test_key": "test_val"}, func() { mgr.SetValues(Values{"test_key2": "test_val2"}, func() {}) }) } } mongo-tools-r3.6.3/vendor/src/github.com/jtolds/gls/gen_sym.go000066400000000000000000000004411321131462300243540ustar00rootroot00000000000000package gls var ( symPool = &idPool{} ) // ContextKey is a throwaway value you can use as a key to a ContextManager type ContextKey struct{ id uint } // GenSym will return a brand new, never-before-used ContextKey func GenSym() ContextKey { return ContextKey{id: symPool.Acquire()} } mongo-tools-r3.6.3/vendor/src/github.com/jtolds/gls/id_pool.go000066400000000000000000000011711321131462300243410ustar00rootroot00000000000000package gls // though this could probably be better at keeping ids smaller, the goal of // this class is to keep a registry of the smallest unique integer ids // per-process possible import ( "sync" ) type idPool struct { mtx sync.Mutex released []uint max_id uint } func (p *idPool) Acquire() (id uint) { p.mtx.Lock() defer p.mtx.Unlock() if len(p.released) > 0 { id = p.released[len(p.released)-1] p.released = p.released[:len(p.released)-1] return id } id = p.max_id p.max_id++ return id } func (p *idPool) Release(id uint) { p.mtx.Lock() defer p.mtx.Unlock() p.released = append(p.released, id) } mongo-tools-r3.6.3/vendor/src/github.com/jtolds/gls/stack_tags.go000066400000000000000000000024031321131462300250360ustar00rootroot00000000000000package gls // so, basically, we're going to encode integer tags in base-16 on the stack const ( bitWidth = 4 ) func addStackTag(tag uint, context_call func()) { if context_call == nil { return } markS(tag, context_call) } func markS(tag uint, cb func()) { _m(tag, cb) } func mark0(tag uint, cb func()) { _m(tag, cb) } func mark1(tag uint, cb func()) { _m(tag, cb) } func mark2(tag uint, cb func()) { _m(tag, cb) } func mark3(tag uint, cb func()) { _m(tag, cb) } func mark4(tag uint, cb func()) { _m(tag, cb) } func mark5(tag uint, cb func()) { _m(tag, cb) } func mark6(tag uint, cb func()) { _m(tag, cb) } func mark7(tag uint, cb func()) { _m(tag, cb) } func mark8(tag uint, cb func()) { _m(tag, cb) } func mark9(tag uint, cb func()) { _m(tag, cb) } func markA(tag uint, cb func()) { _m(tag, cb) } func markB(tag uint, cb func()) { _m(tag, cb) } func markC(tag uint, cb func()) { _m(tag, cb) } func markD(tag uint, cb func()) { _m(tag, cb) } func markE(tag uint, cb func()) { _m(tag, cb) } func markF(tag uint, cb func()) { _m(tag, cb) } var pc_lookup = make(map[uintptr]int8, 17) var mark_lookup [16]func(uint, func()) func _m(tag_remainder uint, cb func()) { if tag_remainder == 0 { cb() } else { mark_lookup[tag_remainder&0xf](tag_remainder>>bitWidth, cb) } } mongo-tools-r3.6.3/vendor/src/github.com/jtolds/gls/stack_tags_js.go000066400000000000000000000042671321131462300255440ustar00rootroot00000000000000// +build js package gls // This file is used for GopherJS builds, which don't have normal runtime support import ( "regexp" "strconv" "strings" "github.com/gopherjs/gopherjs/js" ) var stackRE = regexp.MustCompile("\\s+at (\\S*) \\([^:]+:(\\d+):(\\d+)") func findPtr() uintptr { jsStack := js.Global.Get("Error").New().Get("stack").Call("split", "\n") for i := 1; i < jsStack.Get("length").Int(); i++ { item := jsStack.Index(i).String() matches := stackRE.FindAllStringSubmatch(item, -1) if matches == nil { return 0 } pkgPath := matches[0][1] if strings.HasPrefix(pkgPath, "$packages.github.com/jtolds/gls.mark") { line, _ := strconv.Atoi(matches[0][2]) char, _ := strconv.Atoi(matches[0][3]) x := (uintptr(line) << 16) | uintptr(char) return x } } return 0 } func init() { setEntries := func(f func(uint, func()), v int8) { var ptr uintptr f(0, func() { ptr = findPtr() }) pc_lookup[ptr] = v if v >= 0 { mark_lookup[v] = f } } setEntries(markS, -0x1) setEntries(mark0, 0x0) setEntries(mark1, 0x1) setEntries(mark2, 0x2) setEntries(mark3, 0x3) setEntries(mark4, 0x4) setEntries(mark5, 0x5) setEntries(mark6, 0x6) setEntries(mark7, 0x7) setEntries(mark8, 0x8) setEntries(mark9, 0x9) setEntries(markA, 0xa) setEntries(markB, 0xb) setEntries(markC, 0xc) setEntries(markD, 0xd) setEntries(markE, 0xe) setEntries(markF, 0xf) } func currentStack(skip int) (stack []uintptr) { jsStack := js.Global.Get("Error").New().Get("stack").Call("split", "\n") for i := skip + 2; i < jsStack.Get("length").Int(); i++ { item := jsStack.Index(i).String() matches := stackRE.FindAllStringSubmatch(item, -1) if matches == nil { return stack } line, _ := strconv.Atoi(matches[0][2]) char, _ := strconv.Atoi(matches[0][3]) x := (uintptr(line) << 16) | uintptr(char)&0xffff stack = append(stack, x) } return stack } func readStackTags(skip int) (tags []uint) { stack := currentStack(skip) var current_tag uint for _, pc := range stack { val, ok := pc_lookup[pc] if !ok { continue } if val < 0 { tags = append(tags, current_tag) current_tag = 0 continue } current_tag <<= bitWidth current_tag += uint(val) } return } mongo-tools-r3.6.3/vendor/src/github.com/jtolds/gls/stack_tags_main.go000066400000000000000000000022731321131462300260470ustar00rootroot00000000000000// +build !js package gls // This file is used for standard Go builds, which have the expected runtime support import ( "reflect" "runtime" ) func init() { setEntries := func(f func(uint, func()), v int8) { pc_lookup[reflect.ValueOf(f).Pointer()] = v if v >= 0 { mark_lookup[v] = f } } setEntries(markS, -0x1) setEntries(mark0, 0x0) setEntries(mark1, 0x1) setEntries(mark2, 0x2) setEntries(mark3, 0x3) setEntries(mark4, 0x4) setEntries(mark5, 0x5) setEntries(mark6, 0x6) setEntries(mark7, 0x7) setEntries(mark8, 0x8) setEntries(mark9, 0x9) setEntries(markA, 0xa) setEntries(markB, 0xb) setEntries(markC, 0xc) setEntries(markD, 0xd) setEntries(markE, 0xe) setEntries(markF, 0xf) } func currentStack(skip int) []uintptr { stack := make([]uintptr, maxCallers) return stack[:runtime.Callers(3+skip, stack)] } func readStackTags(skip int) (tags []uint) { stack := currentStack(skip) var current_tag uint for _, pc := range stack { pc = runtime.FuncForPC(pc).Entry() val, ok := pc_lookup[pc] if !ok { continue } if val < 0 { tags = append(tags, current_tag) current_tag = 0 continue } current_tag <<= bitWidth current_tag += uint(val) } return } mongo-tools-r3.6.3/vendor/src/github.com/mattn/000077500000000000000000000000001321131462300214245ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/mattn/go-runewidth/000077500000000000000000000000001321131462300240405ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/mattn/go-runewidth/.travis.yml000066400000000000000000000003151321131462300261500ustar00rootroot00000000000000language: go go: - tip before_install: - go get github.com/mattn/goveralls - go get golang.org/x/tools/cmd/cover script: - $HOME/gopath/bin/goveralls -repotoken lAKAWPzcGsD3A8yBX3BGGtRUdJ6CaGERL mongo-tools-r3.6.3/vendor/src/github.com/mattn/go-runewidth/README.mkd000066400000000000000000000012251321131462300254720ustar00rootroot00000000000000go-runewidth ============ [![Build Status](https://travis-ci.org/mattn/go-runewidth.png?branch=master)](https://travis-ci.org/mattn/go-runewidth) [![Coverage Status](https://coveralls.io/repos/mattn/go-runewidth/badge.png?branch=HEAD)](https://coveralls.io/r/mattn/go-runewidth?branch=HEAD) [![GoDoc](https://godoc.org/github.com/mattn/go-runewidth?status.svg)](http://godoc.org/github.com/mattn/go-runewidth) Provides functions to get fixed width of the character or string. Usage ----- ```go runewidth.StringWidth("ã¤ã®ã â˜†HIRO") == 12 ``` Author ------ Yasuhiro Matsumoto License ------- under the MIT License: http://mattn.mit-license.org/2013 mongo-tools-r3.6.3/vendor/src/github.com/mattn/go-runewidth/runewidth.go000066400000000000000000000305441321131462300264060ustar00rootroot00000000000000package runewidth var EastAsianWidth = IsEastAsian() var DefaultCondition = &Condition{EastAsianWidth} type interval struct { first rune last rune } var combining = []interval{ {0x0300, 0x036F}, {0x0483, 0x0486}, {0x0488, 0x0489}, {0x0591, 0x05BD}, {0x05BF, 0x05BF}, {0x05C1, 0x05C2}, {0x05C4, 0x05C5}, {0x05C7, 0x05C7}, {0x0600, 0x0603}, {0x0610, 0x0615}, {0x064B, 0x065E}, {0x0670, 0x0670}, {0x06D6, 0x06E4}, {0x06E7, 0x06E8}, {0x06EA, 0x06ED}, {0x070F, 0x070F}, {0x0711, 0x0711}, {0x0730, 0x074A}, {0x07A6, 0x07B0}, {0x07EB, 0x07F3}, {0x0901, 0x0902}, {0x093C, 0x093C}, {0x0941, 0x0948}, {0x094D, 0x094D}, {0x0951, 0x0954}, {0x0962, 0x0963}, {0x0981, 0x0981}, {0x09BC, 0x09BC}, {0x09C1, 0x09C4}, {0x09CD, 0x09CD}, {0x09E2, 0x09E3}, {0x0A01, 0x0A02}, {0x0A3C, 0x0A3C}, {0x0A41, 0x0A42}, {0x0A47, 0x0A48}, {0x0A4B, 0x0A4D}, {0x0A70, 0x0A71}, {0x0A81, 0x0A82}, {0x0ABC, 0x0ABC}, {0x0AC1, 0x0AC5}, {0x0AC7, 0x0AC8}, {0x0ACD, 0x0ACD}, {0x0AE2, 0x0AE3}, {0x0B01, 0x0B01}, {0x0B3C, 0x0B3C}, {0x0B3F, 0x0B3F}, {0x0B41, 0x0B43}, {0x0B4D, 0x0B4D}, {0x0B56, 0x0B56}, {0x0B82, 0x0B82}, {0x0BC0, 0x0BC0}, {0x0BCD, 0x0BCD}, {0x0C3E, 0x0C40}, {0x0C46, 0x0C48}, {0x0C4A, 0x0C4D}, {0x0C55, 0x0C56}, {0x0CBC, 0x0CBC}, {0x0CBF, 0x0CBF}, {0x0CC6, 0x0CC6}, {0x0CCC, 0x0CCD}, {0x0CE2, 0x0CE3}, {0x0D41, 0x0D43}, {0x0D4D, 0x0D4D}, {0x0DCA, 0x0DCA}, {0x0DD2, 0x0DD4}, {0x0DD6, 0x0DD6}, {0x0E31, 0x0E31}, {0x0E34, 0x0E3A}, {0x0E47, 0x0E4E}, {0x0EB1, 0x0EB1}, {0x0EB4, 0x0EB9}, {0x0EBB, 0x0EBC}, {0x0EC8, 0x0ECD}, {0x0F18, 0x0F19}, {0x0F35, 0x0F35}, {0x0F37, 0x0F37}, {0x0F39, 0x0F39}, {0x0F71, 0x0F7E}, {0x0F80, 0x0F84}, {0x0F86, 0x0F87}, {0x0F90, 0x0F97}, {0x0F99, 0x0FBC}, {0x0FC6, 0x0FC6}, {0x102D, 0x1030}, {0x1032, 0x1032}, {0x1036, 0x1037}, {0x1039, 0x1039}, {0x1058, 0x1059}, {0x1160, 0x11FF}, {0x135F, 0x135F}, {0x1712, 0x1714}, {0x1732, 0x1734}, {0x1752, 0x1753}, {0x1772, 0x1773}, {0x17B4, 0x17B5}, {0x17B7, 0x17BD}, {0x17C6, 0x17C6}, {0x17C9, 0x17D3}, {0x17DD, 0x17DD}, {0x180B, 0x180D}, {0x18A9, 0x18A9}, {0x1920, 0x1922}, {0x1927, 0x1928}, {0x1932, 0x1932}, {0x1939, 0x193B}, {0x1A17, 0x1A18}, {0x1B00, 0x1B03}, {0x1B34, 0x1B34}, {0x1B36, 0x1B3A}, {0x1B3C, 0x1B3C}, {0x1B42, 0x1B42}, {0x1B6B, 0x1B73}, {0x1DC0, 0x1DCA}, {0x1DFE, 0x1DFF}, {0x200B, 0x200F}, {0x202A, 0x202E}, {0x2060, 0x2063}, {0x206A, 0x206F}, {0x20D0, 0x20EF}, {0x302A, 0x302F}, {0x3099, 0x309A}, {0xA806, 0xA806}, {0xA80B, 0xA80B}, {0xA825, 0xA826}, {0xFB1E, 0xFB1E}, {0xFE00, 0xFE0F}, {0xFE20, 0xFE23}, {0xFEFF, 0xFEFF}, {0xFFF9, 0xFFFB}, {0x10A01, 0x10A03}, {0x10A05, 0x10A06}, {0x10A0C, 0x10A0F}, {0x10A38, 0x10A3A}, {0x10A3F, 0x10A3F}, {0x1D167, 0x1D169}, {0x1D173, 0x1D182}, {0x1D185, 0x1D18B}, {0x1D1AA, 0x1D1AD}, {0x1D242, 0x1D244}, {0xE0001, 0xE0001}, {0xE0020, 0xE007F}, {0xE0100, 0xE01EF}, } type ctype int const ( narrow ctype = iota ambiguous wide halfwidth fullwidth neutral ) type intervalType struct { first rune last rune ctype ctype } var ctypes = []intervalType{ {0x0020, 0x007E, narrow}, {0x00A1, 0x00A1, ambiguous}, {0x00A2, 0x00A3, narrow}, {0x00A4, 0x00A4, ambiguous}, {0x00A5, 0x00A6, narrow}, {0x00A7, 0x00A8, ambiguous}, {0x00AA, 0x00AA, ambiguous}, {0x00AC, 0x00AC, narrow}, {0x00AD, 0x00AE, ambiguous}, {0x00AF, 0x00AF, narrow}, {0x00B0, 0x00B4, ambiguous}, {0x00B6, 0x00BA, ambiguous}, {0x00BC, 0x00BF, ambiguous}, {0x00C6, 0x00C6, ambiguous}, {0x00D0, 0x00D0, ambiguous}, {0x00D7, 0x00D8, ambiguous}, {0x00DE, 0x00E1, ambiguous}, {0x00E6, 0x00E6, ambiguous}, {0x00E8, 0x00EA, ambiguous}, {0x00EC, 0x00ED, ambiguous}, {0x00F0, 0x00F0, ambiguous}, {0x00F2, 0x00F3, ambiguous}, {0x00F7, 0x00FA, ambiguous}, {0x00FC, 0x00FC, ambiguous}, {0x00FE, 0x00FE, ambiguous}, {0x0101, 0x0101, ambiguous}, {0x0111, 0x0111, ambiguous}, {0x0113, 0x0113, ambiguous}, {0x011B, 0x011B, ambiguous}, {0x0126, 0x0127, ambiguous}, {0x012B, 0x012B, ambiguous}, {0x0131, 0x0133, ambiguous}, {0x0138, 0x0138, ambiguous}, {0x013F, 0x0142, ambiguous}, {0x0144, 0x0144, ambiguous}, {0x0148, 0x014B, ambiguous}, {0x014D, 0x014D, ambiguous}, {0x0152, 0x0153, ambiguous}, {0x0166, 0x0167, ambiguous}, {0x016B, 0x016B, ambiguous}, {0x01CE, 0x01CE, ambiguous}, {0x01D0, 0x01D0, ambiguous}, {0x01D2, 0x01D2, ambiguous}, {0x01D4, 0x01D4, ambiguous}, {0x01D6, 0x01D6, ambiguous}, {0x01D8, 0x01D8, ambiguous}, {0x01DA, 0x01DA, ambiguous}, {0x01DC, 0x01DC, ambiguous}, {0x0251, 0x0251, ambiguous}, {0x0261, 0x0261, ambiguous}, {0x02C4, 0x02C4, ambiguous}, {0x02C7, 0x02C7, ambiguous}, {0x02C9, 0x02CB, ambiguous}, {0x02CD, 0x02CD, ambiguous}, {0x02D0, 0x02D0, ambiguous}, {0x02D8, 0x02DB, ambiguous}, {0x02DD, 0x02DD, ambiguous}, {0x02DF, 0x02DF, ambiguous}, {0x0300, 0x036F, ambiguous}, {0x0391, 0x03A2, ambiguous}, {0x03A3, 0x03A9, ambiguous}, {0x03B1, 0x03C1, ambiguous}, {0x03C3, 0x03C9, ambiguous}, {0x0401, 0x0401, ambiguous}, {0x0410, 0x044F, ambiguous}, {0x0451, 0x0451, ambiguous}, {0x1100, 0x115F, wide}, {0x2010, 0x2010, ambiguous}, {0x2013, 0x2016, ambiguous}, {0x2018, 0x2019, ambiguous}, {0x201C, 0x201D, ambiguous}, {0x2020, 0x2022, ambiguous}, {0x2024, 0x2027, ambiguous}, {0x2030, 0x2030, ambiguous}, {0x2032, 0x2033, ambiguous}, {0x2035, 0x2035, ambiguous}, {0x203B, 0x203B, ambiguous}, {0x203E, 0x203E, ambiguous}, {0x2074, 0x2074, ambiguous}, {0x207F, 0x207F, ambiguous}, {0x2081, 0x2084, ambiguous}, {0x20A9, 0x20A9, halfwidth}, {0x20AC, 0x20AC, ambiguous}, {0x2103, 0x2103, ambiguous}, {0x2105, 0x2105, ambiguous}, {0x2109, 0x2109, ambiguous}, {0x2113, 0x2113, ambiguous}, {0x2116, 0x2116, ambiguous}, {0x2121, 0x2122, ambiguous}, {0x2126, 0x2126, ambiguous}, {0x212B, 0x212B, ambiguous}, {0x2153, 0x2154, ambiguous}, {0x215B, 0x215E, ambiguous}, {0x2160, 0x216B, ambiguous}, {0x2170, 0x2179, ambiguous}, {0x2189, 0x218A, ambiguous}, {0x2190, 0x2199, ambiguous}, {0x21B8, 0x21B9, ambiguous}, {0x21D2, 0x21D2, ambiguous}, {0x21D4, 0x21D4, ambiguous}, {0x21E7, 0x21E7, ambiguous}, {0x2200, 0x2200, ambiguous}, {0x2202, 0x2203, ambiguous}, {0x2207, 0x2208, ambiguous}, {0x220B, 0x220B, ambiguous}, {0x220F, 0x220F, ambiguous}, {0x2211, 0x2211, ambiguous}, {0x2215, 0x2215, ambiguous}, {0x221A, 0x221A, ambiguous}, {0x221D, 0x2220, ambiguous}, {0x2223, 0x2223, ambiguous}, {0x2225, 0x2225, ambiguous}, {0x2227, 0x222C, ambiguous}, {0x222E, 0x222E, ambiguous}, {0x2234, 0x2237, ambiguous}, {0x223C, 0x223D, ambiguous}, {0x2248, 0x2248, ambiguous}, {0x224C, 0x224C, ambiguous}, {0x2252, 0x2252, ambiguous}, {0x2260, 0x2261, ambiguous}, {0x2264, 0x2267, ambiguous}, {0x226A, 0x226B, ambiguous}, {0x226E, 0x226F, ambiguous}, {0x2282, 0x2283, ambiguous}, {0x2286, 0x2287, ambiguous}, {0x2295, 0x2295, ambiguous}, {0x2299, 0x2299, ambiguous}, {0x22A5, 0x22A5, ambiguous}, {0x22BF, 0x22BF, ambiguous}, {0x2312, 0x2312, ambiguous}, {0x2329, 0x232A, wide}, {0x2460, 0x24E9, ambiguous}, {0x24EB, 0x254B, ambiguous}, {0x2550, 0x2573, ambiguous}, {0x2580, 0x258F, ambiguous}, {0x2592, 0x2595, ambiguous}, {0x25A0, 0x25A1, ambiguous}, {0x25A3, 0x25A9, ambiguous}, {0x25B2, 0x25B3, ambiguous}, {0x25B6, 0x25B7, ambiguous}, {0x25BC, 0x25BD, ambiguous}, {0x25C0, 0x25C1, ambiguous}, {0x25C6, 0x25C8, ambiguous}, {0x25CB, 0x25CB, ambiguous}, {0x25CE, 0x25D1, ambiguous}, {0x25E2, 0x25E5, ambiguous}, {0x25EF, 0x25EF, ambiguous}, {0x2605, 0x2606, ambiguous}, {0x2609, 0x2609, ambiguous}, {0x260E, 0x260F, ambiguous}, {0x2614, 0x2615, ambiguous}, {0x261C, 0x261C, ambiguous}, {0x261E, 0x261E, ambiguous}, {0x2640, 0x2640, ambiguous}, {0x2642, 0x2642, ambiguous}, {0x2660, 0x2661, ambiguous}, {0x2663, 0x2665, ambiguous}, {0x2667, 0x266A, ambiguous}, {0x266C, 0x266D, ambiguous}, {0x266F, 0x266F, ambiguous}, {0x269E, 0x269F, ambiguous}, {0x26BE, 0x26BF, ambiguous}, {0x26C4, 0x26CD, ambiguous}, {0x26CF, 0x26E1, ambiguous}, {0x26E3, 0x26E3, ambiguous}, {0x26E8, 0x26FF, ambiguous}, {0x273D, 0x273D, ambiguous}, {0x2757, 0x2757, ambiguous}, {0x2776, 0x277F, ambiguous}, {0x27E6, 0x27ED, narrow}, {0x2985, 0x2986, narrow}, {0x2B55, 0x2B59, ambiguous}, {0x2E80, 0x2E9A, wide}, {0x2E9B, 0x2EF4, wide}, {0x2F00, 0x2FD6, wide}, {0x2FF0, 0x2FFC, wide}, {0x3000, 0x3000, fullwidth}, {0x3001, 0x303E, wide}, {0x3041, 0x3097, wide}, {0x3099, 0x3100, wide}, {0x3105, 0x312E, wide}, {0x3131, 0x318F, wide}, {0x3190, 0x31BB, wide}, {0x31C0, 0x31E4, wide}, {0x31F0, 0x321F, wide}, {0x3220, 0x3247, wide}, {0x3248, 0x324F, ambiguous}, {0x3250, 0x32FF, wide}, {0x3300, 0x4DBF, wide}, {0x4E00, 0xA48D, wide}, {0xA490, 0xA4C7, wide}, {0xA960, 0xA97D, wide}, {0xAC00, 0xD7A4, wide}, {0xE000, 0xF8FF, ambiguous}, {0xF900, 0xFAFF, wide}, {0xFE00, 0xFE0F, ambiguous}, {0xFE10, 0xFE1A, wide}, {0xFE30, 0xFE53, wide}, {0xFE54, 0xFE67, wide}, {0xFE68, 0xFE6C, wide}, {0xFF01, 0xFF60, fullwidth}, {0xFF61, 0xFFBF, halfwidth}, {0xFFC2, 0xFFC8, halfwidth}, {0xFFCA, 0xFFD0, halfwidth}, {0xFFD2, 0xFFD8, halfwidth}, {0xFFDA, 0xFFDD, halfwidth}, {0xFFE0, 0xFFE7, fullwidth}, {0xFFE8, 0xFFEF, halfwidth}, {0xFFFD, 0xFFFE, ambiguous}, {0x1B000, 0x1B002, wide}, {0x1F100, 0x1F10A, ambiguous}, {0x1F110, 0x1F12D, ambiguous}, {0x1F130, 0x1F169, ambiguous}, {0x1F170, 0x1F19B, ambiguous}, {0x1F200, 0x1F203, wide}, {0x1F210, 0x1F23B, wide}, {0x1F240, 0x1F249, wide}, {0x1F250, 0x1F252, wide}, {0x20000, 0x2FFFE, wide}, {0x30000, 0x3FFFE, wide}, {0xE0100, 0xE01F0, ambiguous}, {0xF0000, 0xFFFFD, ambiguous}, {0x100000, 0x10FFFE, ambiguous}, } type Condition struct { EastAsianWidth bool } func NewCondition() *Condition { return &Condition{EastAsianWidth} } // RuneWidth returns the number of cells in r. // See http://www.unicode.org/reports/tr11/ func (c *Condition) RuneWidth(r rune) int { if r == 0 { return 0 } if r < 32 || (r >= 0x7f && r < 0xa0) { return 1 } for _, iv := range combining { if iv.first <= r && r <= iv.last { return 0 } } if c.EastAsianWidth && IsAmbiguousWidth(r) { return 2 } if r >= 0x1100 && (r <= 0x115f || r == 0x2329 || r == 0x232a || (r >= 0x2e80 && r <= 0xa4cf && r != 0x303f) || (r >= 0xac00 && r <= 0xd7a3) || (r >= 0xf900 && r <= 0xfaff) || (r >= 0xfe30 && r <= 0xfe6f) || (r >= 0xff00 && r <= 0xff60) || (r >= 0xffe0 && r <= 0xffe6) || (r >= 0x20000 && r <= 0x2fffd) || (r >= 0x30000 && r <= 0x3fffd)) { return 2 } return 1 } func (c *Condition) StringWidth(s string) (width int) { for _, r := range []rune(s) { width += c.RuneWidth(r) } return width } func (c *Condition) Truncate(s string, w int, tail string) string { if c.StringWidth(s) <= w { return s } r := []rune(s) tw := c.StringWidth(tail) w -= tw width := 0 i := 0 for ; i < len(r); i++ { cw := c.RuneWidth(r[i]) if width+cw > w { break } width += cw } return string(r[0:i]) + tail } func (c *Condition) Wrap(s string, w int) string { width := 0 out := "" for _, r := range []rune(s) { cw := RuneWidth(r) if r == '\n' { out += string(r) width = 0 continue } else if width+cw > w { out += "\n" width = 0 out += string(r) width += cw continue } out += string(r) width += cw } return out } func (c *Condition) FillLeft(s string, w int) string { width := c.StringWidth(s) count := w - width if count > 0 { b := make([]byte, count) for i := range b { b[i] = ' ' } return string(b) + s } return s } func (c *Condition) FillRight(s string, w int) string { width := c.StringWidth(s) count := w - width if count > 0 { b := make([]byte, count) for i := range b { b[i] = ' ' } return s + string(b) } return s } // RuneWidth returns the number of cells in r. // See http://www.unicode.org/reports/tr11/ func RuneWidth(r rune) int { return DefaultCondition.RuneWidth(r) } func ct(r rune) ctype { for _, iv := range ctypes { if iv.first <= r && r <= iv.last { return iv.ctype } } return neutral } // IsAmbiguousWidth returns whether is ambiguous width or not. func IsAmbiguousWidth(r rune) bool { return ct(r) == ambiguous } // IsAmbiguousWidth returns whether is ambiguous width or not. func IsNeutralWidth(r rune) bool { return ct(r) == neutral } func StringWidth(s string) (width int) { return DefaultCondition.StringWidth(s) } func Truncate(s string, w int, tail string) string { return DefaultCondition.Truncate(s, w, tail) } func Wrap(s string, w int) string { return DefaultCondition.Wrap(s, w) } func FillLeft(s string, w int) string { return DefaultCondition.FillLeft(s, w) } func FillRight(s string, w int) string { return DefaultCondition.FillRight(s, w) } mongo-tools-r3.6.3/vendor/src/github.com/mattn/go-runewidth/runewidth_js.go000066400000000000000000000002511321131462300270720ustar00rootroot00000000000000// +build js package runewidth func IsEastAsian() bool { // TODO: Implement this for the web. Detect east asian in a compatible way, and return true. return false } mongo-tools-r3.6.3/vendor/src/github.com/mattn/go-runewidth/runewidth_posix.go000066400000000000000000000023271321131462300276260ustar00rootroot00000000000000// +build !windows,!js package runewidth import ( "os" "regexp" "strings" ) var reLoc = regexp.MustCompile(`^[a-z][a-z][a-z]?(?:_[A-Z][A-Z])?\.(.+)`) func IsEastAsian() bool { locale := os.Getenv("LC_CTYPE") if locale == "" { locale = os.Getenv("LANG") } // ignore C locale if locale == "POSIX" || locale == "C" { return false } if len(locale) > 1 && locale[0] == 'C' && (locale[1] == '.' || locale[1] == '-') { return false } charset := strings.ToLower(locale) r := reLoc.FindStringSubmatch(locale) if len(r) == 2 { charset = strings.ToLower(r[1]) } if strings.HasSuffix(charset, "@cjk_narrow") { return false } for pos, b := range []byte(charset) { if b == '@' { charset = charset[:pos] break } } mbc_max := 1 switch charset { case "utf-8", "utf8": mbc_max = 6 case "jis": mbc_max = 8 case "eucjp": mbc_max = 3 case "euckr", "euccn": mbc_max = 2 case "sjis", "cp932", "cp51932", "cp936", "cp949", "cp950": mbc_max = 2 case "big5": mbc_max = 2 case "gbk", "gb2312": mbc_max = 2 } if mbc_max > 1 && (charset[0] != 'u' || strings.HasPrefix(locale, "ja") || strings.HasPrefix(locale, "ko") || strings.HasPrefix(locale, "zh")) { return true } return false } mongo-tools-r3.6.3/vendor/src/github.com/mattn/go-runewidth/runewidth_test.go000066400000000000000000000125111321131462300274370ustar00rootroot00000000000000package runewidth import ( "testing" ) var runewidthtests = []struct { in rune out int }{ {'世', 2}, {'ç•Œ', 2}, {'ï½¾', 1}, {'ｶ', 1}, {'ï½²', 1}, {'☆', 2}, // double width in ambiguous {'\x00', 0}, {'\x01', 1}, {'\u0300', 0}, } func TestRuneWidth(t *testing.T) { c := NewCondition() c.EastAsianWidth = true for _, tt := range runewidthtests { if out := c.RuneWidth(tt.in); out != tt.out { t.Errorf("Width(%q) = %q, want %q", tt.in, out, tt.out) } } } var isambiguouswidthtests = []struct { in rune out bool }{ {'世', false}, {'â– ', true}, {'ç•Œ', false}, {'â—‹', true}, {'㈱', false}, {'â‘ ', true}, {'â‘¡', true}, {'â‘¢', true}, {'â‘£', true}, {'⑤', true}, {'â‘¥', true}, {'⑦', true}, {'⑧', true}, {'⑨', true}, {'â‘©', true}, {'⑪', true}, {'â‘«', true}, {'⑬', true}, {'â‘­', true}, {'â‘®', true}, {'⑯', true}, {'â‘°', true}, {'⑱', true}, {'⑲', true}, {'⑳', true}, {'☆', true}, } func TestIsAmbiguousWidth(t *testing.T) { for _, tt := range isambiguouswidthtests { if out := IsAmbiguousWidth(tt.in); out != tt.out { t.Errorf("IsAmbiguousWidth(%q) = %q, want %q", tt.in, out, tt.out) } } } var stringwidthtests = []struct { in string out int }{ {"■㈱ã®ä¸–界①", 12}, {"スター☆", 8}, } func TestStringWidth(t *testing.T) { c := NewCondition() c.EastAsianWidth = true for _, tt := range stringwidthtests { if out := c.StringWidth(tt.in); out != tt.out { t.Errorf("StringWidth(%q) = %q, want %q", tt.in, out, tt.out) } } } func TestStringWidthInvalid(t *testing.T) { s := "ã“ã‚“ã«ã¡ã‚\x00世界" if out := StringWidth(s); out != 14 { t.Errorf("StringWidth(%q) = %q, want %q", s, out, 14) } } func TestTruncateSmaller(t *testing.T) { s := "ã‚ã„ã†ãˆãŠ" expected := "ã‚ã„ã†ãˆãŠ" if out := Truncate(s, 10, "..."); out != expected { t.Errorf("Truncate(%q) = %q, want %q", s, out, expected) } } func TestTruncate(t *testing.T) { s := "ã‚ã„ã†ãˆãŠã‚ã„ã†ãˆãŠãˆãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠ" expected := "ã‚ã„ã†ãˆãŠã‚ã„ã†ãˆãŠãˆãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠ..." out := Truncate(s, 80, "...") if out != expected { t.Errorf("Truncate(%q) = %q, want %q", s, out, expected) } width := StringWidth(out) if width != 79 { t.Errorf("width of Truncate(%q) should be %d, but %d", s, 79, width) } } func TestTruncateFit(t *testing.T) { s := "aã‚ã„ã†ãˆãŠã‚ã„ã†ãˆãŠãˆãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠ" expected := "aã‚ã„ã†ãˆãŠã‚ã„ã†ãˆãŠãˆãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠ..." out := Truncate(s, 80, "...") if out != expected { t.Errorf("Truncate(%q) = %q, want %q", s, out, expected) } width := StringWidth(out) if width != 80 { t.Errorf("width of Truncate(%q) should be %d, but %d", s, 80, width) } } func TestTruncateJustFit(t *testing.T) { s := "ã‚ã„ã†ãˆãŠã‚ã„ã†ãˆãŠãˆãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠ" expected := "ã‚ã„ã†ãˆãŠã‚ã„ã†ãˆãŠãˆãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠãŠ" out := Truncate(s, 80, "...") if out != expected { t.Errorf("Truncate(%q) = %q, want %q", s, out, expected) } width := StringWidth(out) if width != 80 { t.Errorf("width of Truncate(%q) should be %d, but %d", s, 80, width) } } func TestWrap(t *testing.T) { s := `æ±äº¬ç‰¹è¨±è¨±å¯å±€å±€é•·ã¯ã‚ˆã柿喰ã†å®¢ã /æ±äº¬ç‰¹è¨±è¨±å¯å±€å±€é•·ã¯ã‚ˆã柿喰ã†å®¢ã  123456789012345678901234567890 END` expected := `æ±äº¬ç‰¹è¨±è¨±å¯å±€å±€é•·ã¯ã‚ˆã柿喰ㆠ客ã /æ±äº¬ç‰¹è¨±è¨±å¯å±€å±€é•·ã¯ã‚ˆã 柿喰ã†å®¢ã  123456789012345678901234567890 END` if out := Wrap(s, 30); out != expected { t.Errorf("Wrap(%q) = %q, want %q", s, out, expected) } } func TestTruncateNoNeeded(t *testing.T) { s := "ã‚ã„ã†ãˆãŠã‚ã„" expected := "ã‚ã„ã†ãˆãŠã‚ã„" if out := Truncate(s, 80, "..."); out != expected { t.Errorf("Truncate(%q) = %q, want %q", s, out, expected) } } var isneutralwidthtests = []struct { in rune out bool }{ {'→', false}, {'┊', false}, {'┈', false}, {'～', false}, {'â””', false}, {'⣀', true}, {'⣀', true}, } func TestIsNeutralWidth(t *testing.T) { for _, tt := range isneutralwidthtests { if out := IsNeutralWidth(tt.in); out != tt.out { t.Errorf("IsNeutralWidth(%q) = %q, want %q", tt.in, out, tt.out) } } } func TestFillLeft(t *testing.T) { s := "ã‚xã„ã†ãˆãŠ" expected := " ã‚xã„ã†ãˆãŠ" if out := FillLeft(s, 15); out != expected { t.Errorf("FillLeft(%q) = %q, want %q", s, out, expected) } } func TestFillLeftFit(t *testing.T) { s := "ã‚ã„ã†ãˆãŠ" expected := "ã‚ã„ã†ãˆãŠ" if out := FillLeft(s, 10); out != expected { t.Errorf("FillLeft(%q) = %q, want %q", s, out, expected) } } func TestFillRight(t *testing.T) { s := "ã‚xã„ã†ãˆãŠ" expected := "ã‚xã„ã†ãˆãŠ " if out := FillRight(s, 15); out != expected { t.Errorf("FillRight(%q) = %q, want %q", s, out, expected) } } func TestFillRightFit(t *testing.T) { s := "ã‚ã„ã†ãˆãŠ" expected := "ã‚ã„ã†ãˆãŠ" if out := FillRight(s, 10); out != expected { t.Errorf("FillRight(%q) = %q, want %q", s, out, expected) } } mongo-tools-r3.6.3/vendor/src/github.com/mattn/go-runewidth/runewidth_windows.go000066400000000000000000000005501321131462300301520ustar00rootroot00000000000000package runewidth import ( "syscall" ) var ( kernel32 = syscall.NewLazyDLL("kernel32") procGetConsoleOutputCP = kernel32.NewProc("GetConsoleOutputCP") ) func IsEastAsian() bool { r1, _, _ := procGetConsoleOutputCP.Call() if r1 == 0 { return false } switch int(r1) { case 932, 51932, 936, 949, 950: return true } return false } mongo-tools-r3.6.3/vendor/src/github.com/nsf/000077500000000000000000000000001321131462300210675ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/nsf/termbox-go/000077500000000000000000000000001321131462300231525ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/nsf/termbox-go/AUTHORS000066400000000000000000000001451321131462300242220ustar00rootroot00000000000000# Please keep this file sorted. Georg Reinke nsf mongo-tools-r3.6.3/vendor/src/github.com/nsf/termbox-go/LICENSE000066400000000000000000000020461321131462300241610ustar00rootroot00000000000000Copyright (C) 2012 termbox-go authors 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. mongo-tools-r3.6.3/vendor/src/github.com/nsf/termbox-go/README.md000066400000000000000000000044571321131462300244430ustar00rootroot00000000000000## Termbox Termbox is a library that provides a minimalistic API which allows the programmer to write text-based user interfaces. The library is crossplatform and has both terminal-based implementations on *nix operating systems and a winapi console based implementation for windows operating systems. The basic idea is an abstraction of the greatest common subset of features available on all major terminals and other terminal-like APIs in a minimalistic fashion. Small API means it is easy to implement, test, maintain and learn it, that's what makes the termbox a distinct library in its area. ### Installation Install and update this go package with `go get -u github.com/nsf/termbox-go` ### Examples For examples of what can be done take a look at demos in the _demos directory. You can try them with go run: `go run _demos/keyboard.go` There are also some interesting projects using termbox-go: - [godit](https://github.com/nsf/godit) is an emacsish lightweight text editor written using termbox. - [gomatrix](https://github.com/GeertJohan/gomatrix) connects to The Matrix and displays its data streams in your terminal. - [gotetris](https://github.com/jjinux/gotetris) is an implementation of Tetris. - [sokoban-go](https://github.com/rn2dy/sokoban-go) is an implementation of sokoban game. - [hecate](https://github.com/evanmiller/hecate) is a hex editor designed by Satan. - [httopd](https://github.com/verdverm/httopd) is top for httpd logs. - [mop](https://github.com/michaeldv/mop) is stock market tracker for hackers. - [termui](https://github.com/gizak/termui) is a terminal dashboard. - [termloop](https://github.com/JoelOtter/termloop) is a terminal game engine. - [xterm-color-chart](https://github.com/kutuluk/xterm-color-chart) is a XTerm 256 color chart. - [gocui](https://github.com/jroimartin/gocui) is a minimalist Go library aimed at creating console user interfaces. - [dry](https://github.com/moncho/dry) is an interactive cli to manage Docker containers. - [pxl](https://github.com/ichinaski/pxl) displays images in the terminal. - [snake-game](https://github.com/DyegoCosta/snake-game) is an implementation of the Snake game. - [gone](https://github.com/guillaumebreton/gone) is a CLI pomodoro® timer. ### API reference [godoc.org/github.com/nsf/termbox-go](http://godoc.org/github.com/nsf/termbox-go) mongo-tools-r3.6.3/vendor/src/github.com/nsf/termbox-go/_demos/000077500000000000000000000000001321131462300244205ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/nsf/termbox-go/_demos/editbox.go000066400000000000000000000157141321131462300264150ustar00rootroot00000000000000package main import ( "github.com/mattn/go-runewidth" "github.com/nsf/termbox-go" "unicode/utf8" ) func tbprint(x, y int, fg, bg termbox.Attribute, msg string) { for _, c := range msg { termbox.SetCell(x, y, c, fg, bg) x += runewidth.RuneWidth(c) } } func fill(x, y, w, h int, cell termbox.Cell) { for ly := 0; ly < h; ly++ { for lx := 0; lx < w; lx++ { termbox.SetCell(x+lx, y+ly, cell.Ch, cell.Fg, cell.Bg) } } } func rune_advance_len(r rune, pos int) int { if r == '\t' { return tabstop_length - pos%tabstop_length } return runewidth.RuneWidth(r) } func voffset_coffset(text []byte, boffset int) (voffset, coffset int) { text = text[:boffset] for len(text) > 0 { r, size := utf8.DecodeRune(text) text = text[size:] coffset += 1 voffset += rune_advance_len(r, voffset) } return } func byte_slice_grow(s []byte, desired_cap int) []byte { if cap(s) < desired_cap { ns := make([]byte, len(s), desired_cap) copy(ns, s) return ns } return s } func byte_slice_remove(text []byte, from, to int) []byte { size := to - from copy(text[from:], text[to:]) text = text[:len(text)-size] return text } func byte_slice_insert(text []byte, offset int, what []byte) []byte { n := len(text) + len(what) text = byte_slice_grow(text, n) text = text[:n] copy(text[offset+len(what):], text[offset:]) copy(text[offset:], what) return text } const preferred_horizontal_threshold = 5 const tabstop_length = 8 type EditBox struct { text []byte line_voffset int cursor_boffset int // cursor offset in bytes cursor_voffset int // visual cursor offset in termbox cells cursor_coffset int // cursor offset in unicode code points } // Draws the EditBox in the given location, 'h' is not used at the moment func (eb *EditBox) Draw(x, y, w, h int) { eb.AdjustVOffset(w) const coldef = termbox.ColorDefault fill(x, y, w, h, termbox.Cell{Ch: ' '}) t := eb.text lx := 0 tabstop := 0 for { rx := lx - eb.line_voffset if len(t) == 0 { break } if lx == tabstop { tabstop += tabstop_length } if rx >= w { termbox.SetCell(x+w-1, y, '→', coldef, coldef) break } r, size := utf8.DecodeRune(t) if r == '\t' { for ; lx < tabstop; lx++ { rx = lx - eb.line_voffset if rx >= w { goto next } if rx >= 0 { termbox.SetCell(x+rx, y, ' ', coldef, coldef) } } } else { if rx >= 0 { termbox.SetCell(x+rx, y, r, coldef, coldef) } lx += runewidth.RuneWidth(r) } next: t = t[size:] } if eb.line_voffset != 0 { termbox.SetCell(x, y, 'â†', coldef, coldef) } } // Adjusts line visual offset to a proper value depending on width func (eb *EditBox) AdjustVOffset(width int) { ht := preferred_horizontal_threshold max_h_threshold := (width - 1) / 2 if ht > max_h_threshold { ht = max_h_threshold } threshold := width - 1 if eb.line_voffset != 0 { threshold = width - ht } if eb.cursor_voffset-eb.line_voffset >= threshold { eb.line_voffset = eb.cursor_voffset + (ht - width + 1) } if eb.line_voffset != 0 && eb.cursor_voffset-eb.line_voffset < ht { eb.line_voffset = eb.cursor_voffset - ht if eb.line_voffset < 0 { eb.line_voffset = 0 } } } func (eb *EditBox) MoveCursorTo(boffset int) { eb.cursor_boffset = boffset eb.cursor_voffset, eb.cursor_coffset = voffset_coffset(eb.text, boffset) } func (eb *EditBox) RuneUnderCursor() (rune, int) { return utf8.DecodeRune(eb.text[eb.cursor_boffset:]) } func (eb *EditBox) RuneBeforeCursor() (rune, int) { return utf8.DecodeLastRune(eb.text[:eb.cursor_boffset]) } func (eb *EditBox) MoveCursorOneRuneBackward() { if eb.cursor_boffset == 0 { return } _, size := eb.RuneBeforeCursor() eb.MoveCursorTo(eb.cursor_boffset - size) } func (eb *EditBox) MoveCursorOneRuneForward() { if eb.cursor_boffset == len(eb.text) { return } _, size := eb.RuneUnderCursor() eb.MoveCursorTo(eb.cursor_boffset + size) } func (eb *EditBox) MoveCursorToBeginningOfTheLine() { eb.MoveCursorTo(0) } func (eb *EditBox) MoveCursorToEndOfTheLine() { eb.MoveCursorTo(len(eb.text)) } func (eb *EditBox) DeleteRuneBackward() { if eb.cursor_boffset == 0 { return } eb.MoveCursorOneRuneBackward() _, size := eb.RuneUnderCursor() eb.text = byte_slice_remove(eb.text, eb.cursor_boffset, eb.cursor_boffset+size) } func (eb *EditBox) DeleteRuneForward() { if eb.cursor_boffset == len(eb.text) { return } _, size := eb.RuneUnderCursor() eb.text = byte_slice_remove(eb.text, eb.cursor_boffset, eb.cursor_boffset+size) } func (eb *EditBox) DeleteTheRestOfTheLine() { eb.text = eb.text[:eb.cursor_boffset] } func (eb *EditBox) InsertRune(r rune) { var buf [utf8.UTFMax]byte n := utf8.EncodeRune(buf[:], r) eb.text = byte_slice_insert(eb.text, eb.cursor_boffset, buf[:n]) eb.MoveCursorOneRuneForward() } // Please, keep in mind that cursor depends on the value of line_voffset, which // is being set on Draw() call, so.. call this method after Draw() one. func (eb *EditBox) CursorX() int { return eb.cursor_voffset - eb.line_voffset } var edit_box EditBox const edit_box_width = 30 func redraw_all() { const coldef = termbox.ColorDefault termbox.Clear(coldef, coldef) w, h := termbox.Size() midy := h / 2 midx := (w - edit_box_width) / 2 // unicode box drawing chars around the edit box termbox.SetCell(midx-1, midy, '│', coldef, coldef) termbox.SetCell(midx+edit_box_width, midy, '│', coldef, coldef) termbox.SetCell(midx-1, midy-1, '┌', coldef, coldef) termbox.SetCell(midx-1, midy+1, 'â””', coldef, coldef) termbox.SetCell(midx+edit_box_width, midy-1, 'â”', coldef, coldef) termbox.SetCell(midx+edit_box_width, midy+1, '┘', coldef, coldef) fill(midx, midy-1, edit_box_width, 1, termbox.Cell{Ch: '─'}) fill(midx, midy+1, edit_box_width, 1, termbox.Cell{Ch: '─'}) edit_box.Draw(midx, midy, edit_box_width, 1) termbox.SetCursor(midx+edit_box.CursorX(), midy) tbprint(midx+6, midy+3, coldef, coldef, "Press ESC to quit") termbox.Flush() } func main() { err := termbox.Init() if err != nil { panic(err) } defer termbox.Close() termbox.SetInputMode(termbox.InputEsc) redraw_all() mainloop: for { switch ev := termbox.PollEvent(); ev.Type { case termbox.EventKey: switch ev.Key { case termbox.KeyEsc: break mainloop case termbox.KeyArrowLeft, termbox.KeyCtrlB: edit_box.MoveCursorOneRuneBackward() case termbox.KeyArrowRight, termbox.KeyCtrlF: edit_box.MoveCursorOneRuneForward() case termbox.KeyBackspace, termbox.KeyBackspace2: edit_box.DeleteRuneBackward() case termbox.KeyDelete, termbox.KeyCtrlD: edit_box.DeleteRuneForward() case termbox.KeyTab: edit_box.InsertRune('\t') case termbox.KeySpace: edit_box.InsertRune(' ') case termbox.KeyCtrlK: edit_box.DeleteTheRestOfTheLine() case termbox.KeyHome, termbox.KeyCtrlA: edit_box.MoveCursorToBeginningOfTheLine() case termbox.KeyEnd, termbox.KeyCtrlE: edit_box.MoveCursorToEndOfTheLine() default: if ev.Ch != 0 { edit_box.InsertRune(ev.Ch) } } case termbox.EventError: panic(ev.Err) } redraw_all() } } mongo-tools-r3.6.3/vendor/src/github.com/nsf/termbox-go/_demos/interrupt.go000066400000000000000000000023521321131462300270050ustar00rootroot00000000000000package main import ( "fmt" "github.com/nsf/termbox-go" "time" ) func tbPrint(x, y int, fg, bg termbox.Attribute, msg string) { for _, c := range msg { termbox.SetCell(x, y, c, fg, bg) x++ } } func draw(i int) { termbox.Clear(termbox.ColorDefault, termbox.ColorDefault) defer termbox.Flush() w, h := termbox.Size() s := fmt.Sprintf("count = %d", i) tbPrint((w/2)-(len(s)/2), h/2, termbox.ColorRed, termbox.ColorDefault, s) } func main() { err := termbox.Init() if err != nil { panic(err) } termbox.SetInputMode(termbox.InputEsc) go func() { time.Sleep(5 * time.Second) termbox.Interrupt() // This should never run - the Interrupt(), above, should cause the event // loop below to exit, which then exits the process. If something goes // wrong, this panic will trigger and show what happened. time.Sleep(1 * time.Second) panic("this should never run") }() var count int draw(count) mainloop: for { switch ev := termbox.PollEvent(); ev.Type { case termbox.EventKey: if ev.Ch == '+' { count++ } else if ev.Ch == '-' { count-- } case termbox.EventError: panic(ev.Err) case termbox.EventInterrupt: break mainloop } draw(count) } termbox.Close() fmt.Println("Finished") } mongo-tools-r3.6.3/vendor/src/github.com/nsf/termbox-go/_demos/keyboard.go000066400000000000000000000603721321131462300265570ustar00rootroot00000000000000package main import "github.com/nsf/termbox-go" import "fmt" type key struct { x int y int ch rune } var K_ESC = []key{{1, 1, 'E'}, {2, 1, 'S'}, {3, 1, 'C'}} var K_F1 = []key{{6, 1, 'F'}, {7, 1, '1'}} var K_F2 = []key{{9, 1, 'F'}, {10, 1, '2'}} var K_F3 = []key{{12, 1, 'F'}, {13, 1, '3'}} var K_F4 = []key{{15, 1, 'F'}, {16, 1, '4'}} var K_F5 = []key{{19, 1, 'F'}, {20, 1, '5'}} var K_F6 = []key{{22, 1, 'F'}, {23, 1, '6'}} var K_F7 = []key{{25, 1, 'F'}, {26, 1, '7'}} var K_F8 = []key{{28, 1, 'F'}, {29, 1, '8'}} var K_F9 = []key{{33, 1, 'F'}, {34, 1, '9'}} var K_F10 = []key{{36, 1, 'F'}, {37, 1, '1'}, {38, 1, '0'}} var K_F11 = []key{{40, 1, 'F'}, {41, 1, '1'}, {42, 1, '1'}} var K_F12 = []key{{44, 1, 'F'}, {45, 1, '1'}, {46, 1, '2'}} var K_PRN = []key{{50, 1, 'P'}, {51, 1, 'R'}, {52, 1, 'N'}} var K_SCR = []key{{54, 1, 'S'}, {55, 1, 'C'}, {56, 1, 'R'}} var K_BRK = []key{{58, 1, 'B'}, {59, 1, 'R'}, {60, 1, 'K'}} var K_LED1 = []key{{66, 1, '-'}} var K_LED2 = []key{{70, 1, '-'}} var K_LED3 = []key{{74, 1, '-'}} var K_TILDE = []key{{1, 4, '`'}} var K_TILDE_SHIFT = []key{{1, 4, '~'}} var K_1 = []key{{4, 4, '1'}} var K_1_SHIFT = []key{{4, 4, '!'}} var K_2 = []key{{7, 4, '2'}} var K_2_SHIFT = []key{{7, 4, '@'}} var K_3 = []key{{10, 4, '3'}} var K_3_SHIFT = []key{{10, 4, '#'}} var K_4 = []key{{13, 4, '4'}} var K_4_SHIFT = []key{{13, 4, '$'}} var K_5 = []key{{16, 4, '5'}} var K_5_SHIFT = []key{{16, 4, '%'}} var K_6 = []key{{19, 4, '6'}} var K_6_SHIFT = []key{{19, 4, '^'}} var K_7 = []key{{22, 4, '7'}} var K_7_SHIFT = []key{{22, 4, '&'}} var K_8 = []key{{25, 4, '8'}} var K_8_SHIFT = []key{{25, 4, '*'}} var K_9 = []key{{28, 4, '9'}} var K_9_SHIFT = []key{{28, 4, '('}} var K_0 = []key{{31, 4, '0'}} var K_0_SHIFT = []key{{31, 4, ')'}} var K_MINUS = []key{{34, 4, '-'}} var K_MINUS_SHIFT = []key{{34, 4, '_'}} var K_EQUALS = []key{{37, 4, '='}} var K_EQUALS_SHIFT = []key{{37, 4, '+'}} var K_BACKSLASH = []key{{40, 4, '\\'}} var K_BACKSLASH_SHIFT = []key{{40, 4, '|'}} var K_BACKSPACE = []key{{44, 4, 0x2190}, {45, 4, 0x2500}, {46, 4, 0x2500}} var K_INS = []key{{50, 4, 'I'}, {51, 4, 'N'}, {52, 4, 'S'}} var K_HOM = []key{{54, 4, 'H'}, {55, 4, 'O'}, {56, 4, 'M'}} var K_PGU = []key{{58, 4, 'P'}, {59, 4, 'G'}, {60, 4, 'U'}} var K_K_NUMLOCK = []key{{65, 4, 'N'}} var K_K_SLASH = []key{{68, 4, '/'}} var K_K_STAR = []key{{71, 4, '*'}} var K_K_MINUS = []key{{74, 4, '-'}} var K_TAB = []key{{1, 6, 'T'}, {2, 6, 'A'}, {3, 6, 'B'}} var K_q = []key{{6, 6, 'q'}} var K_Q = []key{{6, 6, 'Q'}} var K_w = []key{{9, 6, 'w'}} var K_W = []key{{9, 6, 'W'}} var K_e = []key{{12, 6, 'e'}} var K_E = []key{{12, 6, 'E'}} var K_r = []key{{15, 6, 'r'}} var K_R = []key{{15, 6, 'R'}} var K_t = []key{{18, 6, 't'}} var K_T = []key{{18, 6, 'T'}} var K_y = []key{{21, 6, 'y'}} var K_Y = []key{{21, 6, 'Y'}} var K_u = []key{{24, 6, 'u'}} var K_U = []key{{24, 6, 'U'}} var K_i = []key{{27, 6, 'i'}} var K_I = []key{{27, 6, 'I'}} var K_o = []key{{30, 6, 'o'}} var K_O = []key{{30, 6, 'O'}} var K_p = []key{{33, 6, 'p'}} var K_P = []key{{33, 6, 'P'}} var K_LSQB = []key{{36, 6, '['}} var K_LCUB = []key{{36, 6, '{'}} var K_RSQB = []key{{39, 6, ']'}} var K_RCUB = []key{{39, 6, '}'}} var K_ENTER = []key{ {43, 6, 0x2591}, {44, 6, 0x2591}, {45, 6, 0x2591}, {46, 6, 0x2591}, {43, 7, 0x2591}, {44, 7, 0x2591}, {45, 7, 0x21B5}, {46, 7, 0x2591}, {41, 8, 0x2591}, {42, 8, 0x2591}, {43, 8, 0x2591}, {44, 8, 0x2591}, {45, 8, 0x2591}, {46, 8, 0x2591}, } var K_DEL = []key{{50, 6, 'D'}, {51, 6, 'E'}, {52, 6, 'L'}} var K_END = []key{{54, 6, 'E'}, {55, 6, 'N'}, {56, 6, 'D'}} var K_PGD = []key{{58, 6, 'P'}, {59, 6, 'G'}, {60, 6, 'D'}} var K_K_7 = []key{{65, 6, '7'}} var K_K_8 = []key{{68, 6, '8'}} var K_K_9 = []key{{71, 6, '9'}} var K_K_PLUS = []key{{74, 6, ' '}, {74, 7, '+'}, {74, 8, ' '}} var K_CAPS = []key{{1, 8, 'C'}, {2, 8, 'A'}, {3, 8, 'P'}, {4, 8, 'S'}} var K_a = []key{{7, 8, 'a'}} var K_A = []key{{7, 8, 'A'}} var K_s = []key{{10, 8, 's'}} var K_S = []key{{10, 8, 'S'}} var K_d = []key{{13, 8, 'd'}} var K_D = []key{{13, 8, 'D'}} var K_f = []key{{16, 8, 'f'}} var K_F = []key{{16, 8, 'F'}} var K_g = []key{{19, 8, 'g'}} var K_G = []key{{19, 8, 'G'}} var K_h = []key{{22, 8, 'h'}} var K_H = []key{{22, 8, 'H'}} var K_j = []key{{25, 8, 'j'}} var K_J = []key{{25, 8, 'J'}} var K_k = []key{{28, 8, 'k'}} var K_K = []key{{28, 8, 'K'}} var K_l = []key{{31, 8, 'l'}} var K_L = []key{{31, 8, 'L'}} var K_SEMICOLON = []key{{34, 8, ';'}} var K_PARENTHESIS = []key{{34, 8, ':'}} var K_QUOTE = []key{{37, 8, '\''}} var K_DOUBLEQUOTE = []key{{37, 8, '"'}} var K_K_4 = []key{{65, 8, '4'}} var K_K_5 = []key{{68, 8, '5'}} var K_K_6 = []key{{71, 8, '6'}} var K_LSHIFT = []key{{1, 10, 'S'}, {2, 10, 'H'}, {3, 10, 'I'}, {4, 10, 'F'}, {5, 10, 'T'}} var K_z = []key{{9, 10, 'z'}} var K_Z = []key{{9, 10, 'Z'}} var K_x = []key{{12, 10, 'x'}} var K_X = []key{{12, 10, 'X'}} var K_c = []key{{15, 10, 'c'}} var K_C = []key{{15, 10, 'C'}} var K_v = []key{{18, 10, 'v'}} var K_V = []key{{18, 10, 'V'}} var K_b = []key{{21, 10, 'b'}} var K_B = []key{{21, 10, 'B'}} var K_n = []key{{24, 10, 'n'}} var K_N = []key{{24, 10, 'N'}} var K_m = []key{{27, 10, 'm'}} var K_M = []key{{27, 10, 'M'}} var K_COMMA = []key{{30, 10, ','}} var K_LANB = []key{{30, 10, '<'}} var K_PERIOD = []key{{33, 10, '.'}} var K_RANB = []key{{33, 10, '>'}} var K_SLASH = []key{{36, 10, '/'}} var K_QUESTION = []key{{36, 10, '?'}} var K_RSHIFT = []key{{42, 10, 'S'}, {43, 10, 'H'}, {44, 10, 'I'}, {45, 10, 'F'}, {46, 10, 'T'}} var K_ARROW_UP = []key{{54, 10, '('}, {55, 10, 0x2191}, {56, 10, ')'}} var K_K_1 = []key{{65, 10, '1'}} var K_K_2 = []key{{68, 10, '2'}} var K_K_3 = []key{{71, 10, '3'}} var K_K_ENTER = []key{{74, 10, 0x2591}, {74, 11, 0x2591}, {74, 12, 0x2591}} var K_LCTRL = []key{{1, 12, 'C'}, {2, 12, 'T'}, {3, 12, 'R'}, {4, 12, 'L'}} var K_LWIN = []key{{6, 12, 'W'}, {7, 12, 'I'}, {8, 12, 'N'}} var K_LALT = []key{{10, 12, 'A'}, {11, 12, 'L'}, {12, 12, 'T'}} var K_SPACE = []key{ {14, 12, ' '}, {15, 12, ' '}, {16, 12, ' '}, {17, 12, ' '}, {18, 12, ' '}, {19, 12, 'S'}, {20, 12, 'P'}, {21, 12, 'A'}, {22, 12, 'C'}, {23, 12, 'E'}, {24, 12, ' '}, {25, 12, ' '}, {26, 12, ' '}, {27, 12, ' '}, {28, 12, ' '}, } var K_RALT = []key{{30, 12, 'A'}, {31, 12, 'L'}, {32, 12, 'T'}} var K_RWIN = []key{{34, 12, 'W'}, {35, 12, 'I'}, {36, 12, 'N'}} var K_RPROP = []key{{38, 12, 'P'}, {39, 12, 'R'}, {40, 12, 'O'}, {41, 12, 'P'}} var K_RCTRL = []key{{43, 12, 'C'}, {44, 12, 'T'}, {45, 12, 'R'}, {46, 12, 'L'}} var K_ARROW_LEFT = []key{{50, 12, '('}, {51, 12, 0x2190}, {52, 12, ')'}} var K_ARROW_DOWN = []key{{54, 12, '('}, {55, 12, 0x2193}, {56, 12, ')'}} var K_ARROW_RIGHT = []key{{58, 12, '('}, {59, 12, 0x2192}, {60, 12, ')'}} var K_K_0 = []key{{65, 12, ' '}, {66, 12, '0'}, {67, 12, ' '}, {68, 12, ' '}} var K_K_PERIOD = []key{{71, 12, '.'}} type combo struct { keys [][]key } var combos = []combo{ {[][]key{K_TILDE, K_2, K_SPACE, K_LCTRL, K_RCTRL}}, {[][]key{K_A, K_LCTRL, K_RCTRL}}, {[][]key{K_B, K_LCTRL, K_RCTRL}}, {[][]key{K_C, K_LCTRL, K_RCTRL}}, {[][]key{K_D, K_LCTRL, K_RCTRL}}, {[][]key{K_E, K_LCTRL, K_RCTRL}}, {[][]key{K_F, K_LCTRL, K_RCTRL}}, {[][]key{K_G, K_LCTRL, K_RCTRL}}, {[][]key{K_H, K_BACKSPACE, K_LCTRL, K_RCTRL}}, {[][]key{K_I, K_TAB, K_LCTRL, K_RCTRL}}, {[][]key{K_J, K_LCTRL, K_RCTRL}}, {[][]key{K_K, K_LCTRL, K_RCTRL}}, {[][]key{K_L, K_LCTRL, K_RCTRL}}, {[][]key{K_M, K_ENTER, K_K_ENTER, K_LCTRL, K_RCTRL}}, {[][]key{K_N, K_LCTRL, K_RCTRL}}, {[][]key{K_O, K_LCTRL, K_RCTRL}}, {[][]key{K_P, K_LCTRL, K_RCTRL}}, {[][]key{K_Q, K_LCTRL, K_RCTRL}}, {[][]key{K_R, K_LCTRL, K_RCTRL}}, {[][]key{K_S, K_LCTRL, K_RCTRL}}, {[][]key{K_T, K_LCTRL, K_RCTRL}}, {[][]key{K_U, K_LCTRL, K_RCTRL}}, {[][]key{K_V, K_LCTRL, K_RCTRL}}, {[][]key{K_W, K_LCTRL, K_RCTRL}}, {[][]key{K_X, K_LCTRL, K_RCTRL}}, {[][]key{K_Y, K_LCTRL, K_RCTRL}}, {[][]key{K_Z, K_LCTRL, K_RCTRL}}, {[][]key{K_LSQB, K_ESC, K_3, K_LCTRL, K_RCTRL}}, {[][]key{K_4, K_BACKSLASH, K_LCTRL, K_RCTRL}}, {[][]key{K_RSQB, K_5, K_LCTRL, K_RCTRL}}, {[][]key{K_6, K_LCTRL, K_RCTRL}}, {[][]key{K_7, K_SLASH, K_MINUS_SHIFT, K_LCTRL, K_RCTRL}}, {[][]key{K_SPACE}}, {[][]key{K_1_SHIFT, K_LSHIFT, K_RSHIFT}}, {[][]key{K_DOUBLEQUOTE, K_LSHIFT, K_RSHIFT}}, {[][]key{K_3_SHIFT, K_LSHIFT, K_RSHIFT}}, {[][]key{K_4_SHIFT, K_LSHIFT, K_RSHIFT}}, {[][]key{K_5_SHIFT, K_LSHIFT, K_RSHIFT}}, {[][]key{K_7_SHIFT, K_LSHIFT, K_RSHIFT}}, {[][]key{K_QUOTE}}, {[][]key{K_9_SHIFT, K_LSHIFT, K_RSHIFT}}, {[][]key{K_0_SHIFT, K_LSHIFT, K_RSHIFT}}, {[][]key{K_8_SHIFT, K_K_STAR, K_LSHIFT, K_RSHIFT}}, {[][]key{K_EQUALS_SHIFT, K_K_PLUS, K_LSHIFT, K_RSHIFT}}, {[][]key{K_COMMA}}, {[][]key{K_MINUS, K_K_MINUS}}, {[][]key{K_PERIOD, K_K_PERIOD}}, {[][]key{K_SLASH, K_K_SLASH}}, {[][]key{K_0, K_K_0}}, {[][]key{K_1, K_K_1}}, {[][]key{K_2, K_K_2}}, {[][]key{K_3, K_K_3}}, {[][]key{K_4, K_K_4}}, {[][]key{K_5, K_K_5}}, {[][]key{K_6, K_K_6}}, {[][]key{K_7, K_K_7}}, {[][]key{K_8, K_K_8}}, {[][]key{K_9, K_K_9}}, {[][]key{K_PARENTHESIS, K_LSHIFT, K_RSHIFT}}, {[][]key{K_SEMICOLON}}, {[][]key{K_LANB, K_LSHIFT, K_RSHIFT}}, {[][]key{K_EQUALS}}, {[][]key{K_RANB, K_LSHIFT, K_RSHIFT}}, {[][]key{K_QUESTION, K_LSHIFT, K_RSHIFT}}, {[][]key{K_2_SHIFT, K_LSHIFT, K_RSHIFT}}, {[][]key{K_A, K_LSHIFT, K_RSHIFT}}, {[][]key{K_B, K_LSHIFT, K_RSHIFT}}, {[][]key{K_C, K_LSHIFT, K_RSHIFT}}, {[][]key{K_D, K_LSHIFT, K_RSHIFT}}, {[][]key{K_E, K_LSHIFT, K_RSHIFT}}, {[][]key{K_F, K_LSHIFT, K_RSHIFT}}, {[][]key{K_G, K_LSHIFT, K_RSHIFT}}, {[][]key{K_H, K_LSHIFT, K_RSHIFT}}, {[][]key{K_I, K_LSHIFT, K_RSHIFT}}, {[][]key{K_J, K_LSHIFT, K_RSHIFT}}, {[][]key{K_K, K_LSHIFT, K_RSHIFT}}, {[][]key{K_L, K_LSHIFT, K_RSHIFT}}, {[][]key{K_M, K_LSHIFT, K_RSHIFT}}, {[][]key{K_N, K_LSHIFT, K_RSHIFT}}, {[][]key{K_O, K_LSHIFT, K_RSHIFT}}, {[][]key{K_P, K_LSHIFT, K_RSHIFT}}, {[][]key{K_Q, K_LSHIFT, K_RSHIFT}}, {[][]key{K_R, K_LSHIFT, K_RSHIFT}}, {[][]key{K_S, K_LSHIFT, K_RSHIFT}}, {[][]key{K_T, K_LSHIFT, K_RSHIFT}}, {[][]key{K_U, K_LSHIFT, K_RSHIFT}}, {[][]key{K_V, K_LSHIFT, K_RSHIFT}}, {[][]key{K_W, K_LSHIFT, K_RSHIFT}}, {[][]key{K_X, K_LSHIFT, K_RSHIFT}}, {[][]key{K_Y, K_LSHIFT, K_RSHIFT}}, {[][]key{K_Z, K_LSHIFT, K_RSHIFT}}, {[][]key{K_LSQB}}, {[][]key{K_BACKSLASH}}, {[][]key{K_RSQB}}, {[][]key{K_6_SHIFT, K_LSHIFT, K_RSHIFT}}, {[][]key{K_MINUS_SHIFT, K_LSHIFT, K_RSHIFT}}, {[][]key{K_TILDE}}, {[][]key{K_a}}, {[][]key{K_b}}, {[][]key{K_c}}, {[][]key{K_d}}, {[][]key{K_e}}, {[][]key{K_f}}, {[][]key{K_g}}, {[][]key{K_h}}, {[][]key{K_i}}, {[][]key{K_j}}, {[][]key{K_k}}, {[][]key{K_l}}, {[][]key{K_m}}, {[][]key{K_n}}, {[][]key{K_o}}, {[][]key{K_p}}, {[][]key{K_q}}, {[][]key{K_r}}, {[][]key{K_s}}, {[][]key{K_t}}, {[][]key{K_u}}, {[][]key{K_v}}, {[][]key{K_w}}, {[][]key{K_x}}, {[][]key{K_y}}, {[][]key{K_z}}, {[][]key{K_LCUB, K_LSHIFT, K_RSHIFT}}, {[][]key{K_BACKSLASH_SHIFT, K_LSHIFT, K_RSHIFT}}, {[][]key{K_RCUB, K_LSHIFT, K_RSHIFT}}, {[][]key{K_TILDE_SHIFT, K_LSHIFT, K_RSHIFT}}, {[][]key{K_8, K_BACKSPACE, K_LCTRL, K_RCTRL}}, } var func_combos = []combo{ {[][]key{K_F1}}, {[][]key{K_F2}}, {[][]key{K_F3}}, {[][]key{K_F4}}, {[][]key{K_F5}}, {[][]key{K_F6}}, {[][]key{K_F7}}, {[][]key{K_F8}}, {[][]key{K_F9}}, {[][]key{K_F10}}, {[][]key{K_F11}}, {[][]key{K_F12}}, {[][]key{K_INS}}, {[][]key{K_DEL}}, {[][]key{K_HOM}}, {[][]key{K_END}}, {[][]key{K_PGU}}, {[][]key{K_PGD}}, {[][]key{K_ARROW_UP}}, {[][]key{K_ARROW_DOWN}}, {[][]key{K_ARROW_LEFT}}, {[][]key{K_ARROW_RIGHT}}, } func print_tb(x, y int, fg, bg termbox.Attribute, msg string) { for _, c := range msg { termbox.SetCell(x, y, c, fg, bg) x++ } } func printf_tb(x, y int, fg, bg termbox.Attribute, format string, args ...interface{}) { s := fmt.Sprintf(format, args...) print_tb(x, y, fg, bg, s) } func draw_key(k []key, fg, bg termbox.Attribute) { for _, k := range k { termbox.SetCell(k.x+2, k.y+4, k.ch, fg, bg) } } func draw_keyboard() { termbox.SetCell(0, 0, 0x250C, termbox.ColorWhite, termbox.ColorBlack) termbox.SetCell(79, 0, 0x2510, termbox.ColorWhite, termbox.ColorBlack) termbox.SetCell(0, 23, 0x2514, termbox.ColorWhite, termbox.ColorBlack) termbox.SetCell(79, 23, 0x2518, termbox.ColorWhite, termbox.ColorBlack) for i := 1; i < 79; i++ { termbox.SetCell(i, 0, 0x2500, termbox.ColorWhite, termbox.ColorBlack) termbox.SetCell(i, 23, 0x2500, termbox.ColorWhite, termbox.ColorBlack) termbox.SetCell(i, 17, 0x2500, termbox.ColorWhite, termbox.ColorBlack) termbox.SetCell(i, 4, 0x2500, termbox.ColorWhite, termbox.ColorBlack) } for i := 1; i < 23; i++ { termbox.SetCell(0, i, 0x2502, termbox.ColorWhite, termbox.ColorBlack) termbox.SetCell(79, i, 0x2502, termbox.ColorWhite, termbox.ColorBlack) } termbox.SetCell(0, 17, 0x251C, termbox.ColorWhite, termbox.ColorBlack) termbox.SetCell(79, 17, 0x2524, termbox.ColorWhite, termbox.ColorBlack) termbox.SetCell(0, 4, 0x251C, termbox.ColorWhite, termbox.ColorBlack) termbox.SetCell(79, 4, 0x2524, termbox.ColorWhite, termbox.ColorBlack) for i := 5; i < 17; i++ { termbox.SetCell(1, i, 0x2588, termbox.ColorYellow, termbox.ColorYellow) termbox.SetCell(78, i, 0x2588, termbox.ColorYellow, termbox.ColorYellow) } draw_key(K_ESC, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_F1, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_F2, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_F3, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_F4, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_F5, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_F6, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_F7, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_F8, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_F9, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_F10, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_F11, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_F12, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_PRN, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_SCR, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_BRK, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_LED1, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_LED2, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_LED3, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_TILDE, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_1, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_2, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_3, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_4, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_5, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_6, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_7, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_8, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_9, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_0, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_MINUS, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_EQUALS, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_BACKSLASH, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_BACKSPACE, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_INS, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_HOM, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_PGU, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_K_NUMLOCK, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_K_SLASH, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_K_STAR, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_K_MINUS, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_TAB, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_q, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_w, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_e, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_r, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_t, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_y, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_u, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_i, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_o, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_p, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_LSQB, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_RSQB, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_ENTER, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_DEL, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_END, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_PGD, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_K_7, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_K_8, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_K_9, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_K_PLUS, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_CAPS, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_a, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_s, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_d, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_f, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_g, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_h, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_j, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_k, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_l, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_SEMICOLON, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_QUOTE, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_K_4, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_K_5, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_K_6, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_LSHIFT, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_z, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_x, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_c, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_v, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_b, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_n, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_m, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_COMMA, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_PERIOD, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_SLASH, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_RSHIFT, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_ARROW_UP, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_K_1, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_K_2, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_K_3, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_K_ENTER, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_LCTRL, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_LWIN, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_LALT, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_SPACE, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_RCTRL, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_RPROP, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_RWIN, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_RALT, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_ARROW_LEFT, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_ARROW_DOWN, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_ARROW_RIGHT, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_K_0, termbox.ColorWhite, termbox.ColorBlue) draw_key(K_K_PERIOD, termbox.ColorWhite, termbox.ColorBlue) printf_tb(33, 1, termbox.ColorMagenta|termbox.AttrBold, termbox.ColorBlack, "Keyboard demo!") printf_tb(21, 2, termbox.ColorMagenta, termbox.ColorBlack, "(press CTRL+X and then CTRL+Q to exit)") printf_tb(15, 3, termbox.ColorMagenta, termbox.ColorBlack, "(press CTRL+X and then CTRL+C to change input mode)") inputmode := termbox.SetInputMode(termbox.InputCurrent) inputmode_str := "" switch { case inputmode&termbox.InputEsc != 0: inputmode_str = "termbox.InputEsc" case inputmode&termbox.InputAlt != 0: inputmode_str = "termbox.InputAlt" } if inputmode&termbox.InputMouse != 0 { inputmode_str += " | termbox.InputMouse" } printf_tb(3, 18, termbox.ColorWhite, termbox.ColorBlack, "Input mode: %s", inputmode_str) } var fcmap = []string{ "CTRL+2, CTRL+~", "CTRL+A", "CTRL+B", "CTRL+C", "CTRL+D", "CTRL+E", "CTRL+F", "CTRL+G", "CTRL+H, BACKSPACE", "CTRL+I, TAB", "CTRL+J", "CTRL+K", "CTRL+L", "CTRL+M, ENTER", "CTRL+N", "CTRL+O", "CTRL+P", "CTRL+Q", "CTRL+R", "CTRL+S", "CTRL+T", "CTRL+U", "CTRL+V", "CTRL+W", "CTRL+X", "CTRL+Y", "CTRL+Z", "CTRL+3, ESC, CTRL+[", "CTRL+4, CTRL+\\", "CTRL+5, CTRL+]", "CTRL+6", "CTRL+7, CTRL+/, CTRL+_", "SPACE", } var fkmap = []string{ "F1", "F2", "F3", "F4", "F5", "F6", "F7", "F8", "F9", "F10", "F11", "F12", "INSERT", "DELETE", "HOME", "END", "PGUP", "PGDN", "ARROW UP", "ARROW DOWN", "ARROW LEFT", "ARROW RIGHT", } func funckeymap(k termbox.Key) string { if k == termbox.KeyCtrl8 { return "CTRL+8, BACKSPACE 2" /* 0x7F */ } else if k >= termbox.KeyArrowRight && k <= 0xFFFF { return fkmap[0xFFFF-k] } else if k <= termbox.KeySpace { return fcmap[k] } return "UNKNOWN" } func pretty_print_press(ev *termbox.Event) { printf_tb(3, 19, termbox.ColorWhite, termbox.ColorBlack, "Key: ") printf_tb(8, 19, termbox.ColorYellow, termbox.ColorBlack, "decimal: %d", ev.Key) printf_tb(8, 20, termbox.ColorGreen, termbox.ColorBlack, "hex: 0x%X", ev.Key) printf_tb(8, 21, termbox.ColorCyan, termbox.ColorBlack, "octal: 0%o", ev.Key) printf_tb(8, 22, termbox.ColorRed, termbox.ColorBlack, "string: %s", funckeymap(ev.Key)) printf_tb(54, 19, termbox.ColorWhite, termbox.ColorBlack, "Char: ") printf_tb(60, 19, termbox.ColorYellow, termbox.ColorBlack, "decimal: %d", ev.Ch) printf_tb(60, 20, termbox.ColorGreen, termbox.ColorBlack, "hex: 0x%X", ev.Ch) printf_tb(60, 21, termbox.ColorCyan, termbox.ColorBlack, "octal: 0%o", ev.Ch) printf_tb(60, 22, termbox.ColorRed, termbox.ColorBlack, "string: %s", string(ev.Ch)) modifier := "none" if ev.Mod != 0 { modifier = "termbox.ModAlt" } printf_tb(54, 18, termbox.ColorWhite, termbox.ColorBlack, "Modifier: %s", modifier) } func pretty_print_resize(ev *termbox.Event) { printf_tb(3, 19, termbox.ColorWhite, termbox.ColorBlack, "Resize event: %d x %d", ev.Width, ev.Height) } var counter = 0 func pretty_print_mouse(ev *termbox.Event) { printf_tb(3, 19, termbox.ColorWhite, termbox.ColorBlack, "Mouse event: %d x %d", ev.MouseX, ev.MouseY) button := "" switch ev.Key { case termbox.MouseLeft: button = "MouseLeft: %d" case termbox.MouseMiddle: button = "MouseMiddle: %d" case termbox.MouseRight: button = "MouseRight: %d" case termbox.MouseWheelUp: button = "MouseWheelUp: %d" case termbox.MouseWheelDown: button = "MouseWheelDown: %d" case termbox.MouseRelease: button = "MouseRelease: %d" } if ev.Mod&termbox.ModMotion != 0 { button += "*" } counter++ printf_tb(43, 19, termbox.ColorWhite, termbox.ColorBlack, "Key: ") printf_tb(48, 19, termbox.ColorYellow, termbox.ColorBlack, button, counter) } func dispatch_press(ev *termbox.Event) { if ev.Mod&termbox.ModAlt != 0 { draw_key(K_LALT, termbox.ColorWhite, termbox.ColorRed) draw_key(K_RALT, termbox.ColorWhite, termbox.ColorRed) } var k *combo if ev.Key >= termbox.KeyArrowRight { k = &func_combos[0xFFFF-ev.Key] } else if ev.Ch < 128 { if ev.Ch == 0 && ev.Key < 128 { k = &combos[ev.Key] } else { k = &combos[ev.Ch] } } if k == nil { return } keys := k.keys for _, k := range keys { draw_key(k, termbox.ColorWhite, termbox.ColorRed) } } func main() { err := termbox.Init() if err != nil { panic(err) } defer termbox.Close() termbox.SetInputMode(termbox.InputEsc | termbox.InputMouse) termbox.Clear(termbox.ColorDefault, termbox.ColorDefault) draw_keyboard() termbox.Flush() inputmode := 0 ctrlxpressed := false loop: for { switch ev := termbox.PollEvent(); ev.Type { case termbox.EventKey: if ev.Key == termbox.KeyCtrlS && ctrlxpressed { termbox.Sync() } if ev.Key == termbox.KeyCtrlQ && ctrlxpressed { break loop } if ev.Key == termbox.KeyCtrlC && ctrlxpressed { chmap := []termbox.InputMode{ termbox.InputEsc | termbox.InputMouse, termbox.InputAlt | termbox.InputMouse, termbox.InputEsc, termbox.InputAlt, } inputmode++ if inputmode >= len(chmap) { inputmode = 0 } termbox.SetInputMode(chmap[inputmode]) } if ev.Key == termbox.KeyCtrlX { ctrlxpressed = true } else { ctrlxpressed = false } termbox.Clear(termbox.ColorDefault, termbox.ColorDefault) draw_keyboard() dispatch_press(&ev) pretty_print_press(&ev) termbox.Flush() case termbox.EventResize: termbox.Clear(termbox.ColorDefault, termbox.ColorDefault) draw_keyboard() pretty_print_resize(&ev) termbox.Flush() case termbox.EventMouse: termbox.Clear(termbox.ColorDefault, termbox.ColorDefault) draw_keyboard() pretty_print_mouse(&ev) termbox.Flush() case termbox.EventError: panic(ev.Err) } } } mongo-tools-r3.6.3/vendor/src/github.com/nsf/termbox-go/_demos/output.go000066400000000000000000000133351321131462300263140ustar00rootroot00000000000000package main import "github.com/mattn/go-runewidth" import "github.com/nsf/termbox-go" const chars = "nnnnnnnnnbbbbbbbbbuuuuuuuuuBBBBBBBBB" var output_mode = termbox.OutputNormal func next_char(current int) int { current++ if current >= len(chars) { return 0 } return current } func print_combinations_table(sx, sy int, attrs []termbox.Attribute) { var bg termbox.Attribute current_char := 0 y := sy all_attrs := []termbox.Attribute{ 0, termbox.AttrBold, termbox.AttrUnderline, termbox.AttrBold | termbox.AttrUnderline, } draw_line := func() { x := sx for _, a := range all_attrs { for c := termbox.ColorDefault; c <= termbox.ColorWhite; c++ { fg := a | c termbox.SetCell(x, y, rune(chars[current_char]), fg, bg) current_char = next_char(current_char) x++ } } } for _, a := range attrs { for c := termbox.ColorDefault; c <= termbox.ColorWhite; c++ { bg = a | c draw_line() y++ } } } func print_wide(x, y int, s string) { red := false for _, r := range s { c := termbox.ColorDefault if red { c = termbox.ColorRed } termbox.SetCell(x, y, r, termbox.ColorDefault, c) w := runewidth.RuneWidth(r) if w == 0 || (w == 2 && runewidth.IsAmbiguousWidth(r)) { w = 1 } x += w red = !red } } const hello_world = "ã“ã‚“ã«ã¡ã¯ä¸–ç•Œ" func draw_all() { termbox.Clear(termbox.ColorDefault, termbox.ColorDefault) switch output_mode { case termbox.OutputNormal: print_combinations_table(1, 1, []termbox.Attribute{ 0, termbox.AttrBold, }) print_combinations_table(2+len(chars), 1, []termbox.Attribute{ termbox.AttrReverse, }) print_wide(2+len(chars), 11, hello_world) case termbox.OutputGrayscale: for y := 0; y < 26; y++ { for x := 0; x < 26; x++ { termbox.SetCell(x, y, 'n', termbox.Attribute(x+1), termbox.Attribute(y+1)) termbox.SetCell(x+27, y, 'b', termbox.Attribute(x+1)|termbox.AttrBold, termbox.Attribute(26-y)) termbox.SetCell(x+54, y, 'u', termbox.Attribute(x+1)|termbox.AttrUnderline, termbox.Attribute(y+1)) } termbox.SetCell(82, y, 'd', termbox.Attribute(y+1), termbox.ColorDefault) termbox.SetCell(83, y, 'd', termbox.ColorDefault, termbox.Attribute(26-y)) } case termbox.Output216: for r := 0; r < 6; r++ { for g := 0; g < 6; g++ { for b := 0; b < 6; b++ { y := r x := g + 6*b c1 := termbox.Attribute(1 + r*36 + g*6 + b) bg := termbox.Attribute(1 + g*36 + b*6 + r) c2 := termbox.Attribute(1 + b*36 + r*6 + g) bc1 := c1 | termbox.AttrBold uc1 := c1 | termbox.AttrUnderline bc2 := c2 | termbox.AttrBold uc2 := c2 | termbox.AttrUnderline termbox.SetCell(x, y, 'n', c1, bg) termbox.SetCell(x, y+6, 'b', bc1, bg) termbox.SetCell(x, y+12, 'u', uc1, bg) termbox.SetCell(x, y+18, 'B', bc1|uc1, bg) termbox.SetCell(x+37, y, 'n', c2, bg) termbox.SetCell(x+37, y+6, 'b', bc2, bg) termbox.SetCell(x+37, y+12, 'u', uc2, bg) termbox.SetCell(x+37, y+18, 'B', bc2|uc2, bg) } c1 := termbox.Attribute(1 + g*6 + r*36) c2 := termbox.Attribute(6 + g*6 + r*36) termbox.SetCell(74+g, r, 'd', c1, termbox.ColorDefault) termbox.SetCell(74+g, r+6, 'd', c2, termbox.ColorDefault) termbox.SetCell(74+g, r+12, 'd', termbox.ColorDefault, c1) termbox.SetCell(74+g, r+18, 'd', termbox.ColorDefault, c2) } } case termbox.Output256: for y := 0; y < 4; y++ { for x := 0; x < 8; x++ { for z := 0; z < 8; z++ { bg := termbox.Attribute(1 + y*64 + x*8 + z) c1 := termbox.Attribute(256 - y*64 - x*8 - z) c2 := termbox.Attribute(1 + y*64 + z*8 + x) c3 := termbox.Attribute(256 - y*64 - z*8 - x) c4 := termbox.Attribute(1 + y*64 + x*4 + z*4) bold := c2 | termbox.AttrBold under := c3 | termbox.AttrUnderline both := c1 | termbox.AttrBold | termbox.AttrUnderline termbox.SetCell(z+8*x, y, ' ', 0, bg) termbox.SetCell(z+8*x, y+5, 'n', c4, bg) termbox.SetCell(z+8*x, y+10, 'b', bold, bg) termbox.SetCell(z+8*x, y+15, 'u', under, bg) termbox.SetCell(z+8*x, y+20, 'B', both, bg) } } } for x := 0; x < 12; x++ { for y := 0; y < 2; y++ { c1 := termbox.Attribute(233 + y*12 + x) termbox.SetCell(66+x, y, 'd', c1, termbox.ColorDefault) termbox.SetCell(66+x, 2+y, 'd', termbox.ColorDefault, c1) } } for x := 0; x < 6; x++ { for y := 0; y < 6; y++ { c1 := termbox.Attribute(17 + x*6 + y*36) c2 := termbox.Attribute(17 + 5 + x*6 + y*36) termbox.SetCell(66+x, 6+y, 'd', c1, termbox.ColorDefault) termbox.SetCell(66+x, 12+y, 'd', c2, termbox.ColorDefault) termbox.SetCell(72+x, 6+y, 'd', termbox.ColorDefault, c1) termbox.SetCell(72+x, 12+y, 'd', termbox.ColorDefault, c2) } } } termbox.Flush() } var available_modes = []termbox.OutputMode{ termbox.OutputNormal, termbox.OutputGrayscale, termbox.Output216, termbox.Output256, } var output_mode_index = 0 func switch_output_mode(direction int) { output_mode_index += direction if output_mode_index < 0 { output_mode_index = len(available_modes) - 1 } else if output_mode_index >= len(available_modes) { output_mode_index = 0 } output_mode = termbox.SetOutputMode(available_modes[output_mode_index]) termbox.Clear(termbox.ColorDefault, termbox.ColorDefault) termbox.Sync() } func main() { err := termbox.Init() if err != nil { panic(err) } defer termbox.Close() draw_all() loop: for { switch ev := termbox.PollEvent(); ev.Type { case termbox.EventKey: switch ev.Key { case termbox.KeyEsc: break loop case termbox.KeyArrowUp, termbox.KeyArrowRight: switch_output_mode(1) draw_all() case termbox.KeyArrowDown, termbox.KeyArrowLeft: switch_output_mode(-1) draw_all() } case termbox.EventResize: draw_all() } } } mongo-tools-r3.6.3/vendor/src/github.com/nsf/termbox-go/_demos/paint.go000066400000000000000000000052011321131462300260600ustar00rootroot00000000000000package main import ( "github.com/nsf/termbox-go" ) var curCol = 0 var curRune = 0 var backbuf []termbox.Cell var bbw, bbh int var runes = []rune{' ', 'â–‘', 'â–’', 'â–“', 'â–ˆ'} var colors = []termbox.Attribute{ termbox.ColorBlack, termbox.ColorRed, termbox.ColorGreen, termbox.ColorYellow, termbox.ColorBlue, termbox.ColorMagenta, termbox.ColorCyan, termbox.ColorWhite, } type attrFunc func(int) (rune, termbox.Attribute, termbox.Attribute) func updateAndDrawButtons(current *int, x, y int, mx, my int, n int, attrf attrFunc) { lx, ly := x, y for i := 0; i < n; i++ { if lx <= mx && mx <= lx+3 && ly <= my && my <= ly+1 { *current = i } r, fg, bg := attrf(i) termbox.SetCell(lx+0, ly+0, r, fg, bg) termbox.SetCell(lx+1, ly+0, r, fg, bg) termbox.SetCell(lx+2, ly+0, r, fg, bg) termbox.SetCell(lx+3, ly+0, r, fg, bg) termbox.SetCell(lx+0, ly+1, r, fg, bg) termbox.SetCell(lx+1, ly+1, r, fg, bg) termbox.SetCell(lx+2, ly+1, r, fg, bg) termbox.SetCell(lx+3, ly+1, r, fg, bg) lx += 4 } lx, ly = x, y for i := 0; i < n; i++ { if *current == i { fg := termbox.ColorRed | termbox.AttrBold bg := termbox.ColorDefault termbox.SetCell(lx+0, ly+2, '^', fg, bg) termbox.SetCell(lx+1, ly+2, '^', fg, bg) termbox.SetCell(lx+2, ly+2, '^', fg, bg) termbox.SetCell(lx+3, ly+2, '^', fg, bg) } lx += 4 } } func update_and_redraw_all(mx, my int) { termbox.Clear(termbox.ColorDefault, termbox.ColorDefault) if mx != -1 && my != -1 { backbuf[bbw*my+mx] = termbox.Cell{Ch: runes[curRune], Fg: colors[curCol]} } copy(termbox.CellBuffer(), backbuf) _, h := termbox.Size() updateAndDrawButtons(&curRune, 0, 0, mx, my, len(runes), func(i int) (rune, termbox.Attribute, termbox.Attribute) { return runes[i], termbox.ColorDefault, termbox.ColorDefault }) updateAndDrawButtons(&curCol, 0, h-3, mx, my, len(colors), func(i int) (rune, termbox.Attribute, termbox.Attribute) { return ' ', termbox.ColorDefault, colors[i] }) termbox.Flush() } func reallocBackBuffer(w, h int) { bbw, bbh = w, h backbuf = make([]termbox.Cell, w*h) } func main() { err := termbox.Init() if err != nil { panic(err) } defer termbox.Close() termbox.SetInputMode(termbox.InputEsc | termbox.InputMouse) reallocBackBuffer(termbox.Size()) update_and_redraw_all(-1, -1) mainloop: for { mx, my := -1, -1 switch ev := termbox.PollEvent(); ev.Type { case termbox.EventKey: if ev.Key == termbox.KeyEsc { break mainloop } case termbox.EventMouse: if ev.Key == termbox.MouseLeft { mx, my = ev.MouseX, ev.MouseY } case termbox.EventResize: reallocBackBuffer(ev.Width, ev.Height) } update_and_redraw_all(mx, my) } } mongo-tools-r3.6.3/vendor/src/github.com/nsf/termbox-go/_demos/random_output.go000066400000000000000000000013761321131462300276560ustar00rootroot00000000000000package main import "github.com/nsf/termbox-go" import "math/rand" import "time" func draw() { w, h := termbox.Size() termbox.Clear(termbox.ColorDefault, termbox.ColorDefault) for y := 0; y < h; y++ { for x := 0; x < w; x++ { termbox.SetCell(x, y, ' ', termbox.ColorDefault, termbox.Attribute(rand.Int()%8)+1) } } termbox.Flush() } func main() { err := termbox.Init() if err != nil { panic(err) } defer termbox.Close() event_queue := make(chan termbox.Event) go func() { for { event_queue <- termbox.PollEvent() } }() draw() loop: for { select { case ev := <-event_queue: if ev.Type == termbox.EventKey && ev.Key == termbox.KeyEsc { break loop } default: draw() time.Sleep(10 * time.Millisecond) } } } mongo-tools-r3.6.3/vendor/src/github.com/nsf/termbox-go/_demos/raw_input.go000066400000000000000000000045201321131462300267600ustar00rootroot00000000000000package main import ( "fmt" "github.com/nsf/termbox-go" "strings" ) func tbprint(x, y int, fg, bg termbox.Attribute, msg string) { for _, c := range msg { termbox.SetCell(x, y, c, fg, bg) x++ } } var current string var curev termbox.Event func mouse_button_str(k termbox.Key) string { switch k { case termbox.MouseLeft: return "MouseLeft" case termbox.MouseMiddle: return "MouseMiddle" case termbox.MouseRight: return "MouseRight" case termbox.MouseRelease: return "MouseRelease" case termbox.MouseWheelUp: return "MouseWheelUp" case termbox.MouseWheelDown: return "MouseWheelDown" } return "Key" } func mod_str(m termbox.Modifier) string { var out []string if m&termbox.ModAlt != 0 { out = append(out, "ModAlt") } if m&termbox.ModMotion != 0 { out = append(out, "ModMotion") } return strings.Join(out, " | ") } func redraw_all() { const coldef = termbox.ColorDefault termbox.Clear(coldef, coldef) tbprint(0, 0, termbox.ColorMagenta, coldef, "Press 'q' to quit") tbprint(0, 1, coldef, coldef, current) switch curev.Type { case termbox.EventKey: tbprint(0, 2, coldef, coldef, fmt.Sprintf("EventKey: k: %d, c: %c, mod: %s", curev.Key, curev.Ch, mod_str(curev.Mod))) case termbox.EventMouse: tbprint(0, 2, coldef, coldef, fmt.Sprintf("EventMouse: x: %d, y: %d, b: %s, mod: %s", curev.MouseX, curev.MouseY, mouse_button_str(curev.Key), mod_str(curev.Mod))) case termbox.EventNone: tbprint(0, 2, coldef, coldef, "EventNone") } tbprint(0, 3, coldef, coldef, fmt.Sprintf("%d", curev.N)) termbox.Flush() } func main() { err := termbox.Init() if err != nil { panic(err) } defer termbox.Close() termbox.SetInputMode(termbox.InputAlt | termbox.InputMouse) redraw_all() data := make([]byte, 0, 64) mainloop: for { if cap(data)-len(data) < 32 { newdata := make([]byte, len(data), len(data)+32) copy(newdata, data) data = newdata } beg := len(data) d := data[beg : beg+32] switch ev := termbox.PollRawEvent(d); ev.Type { case termbox.EventRaw: data = data[:beg+ev.N] current = fmt.Sprintf("%q", data) if current == `"q"` { break mainloop } for { ev := termbox.ParseEvent(data) if ev.N == 0 { break } curev = ev copy(data, data[curev.N:]) data = data[:len(data)-curev.N] } case termbox.EventError: panic(ev.Err) } redraw_all() } } mongo-tools-r3.6.3/vendor/src/github.com/nsf/termbox-go/api.go000066400000000000000000000273451321131462300242650ustar00rootroot00000000000000// +build !windows package termbox import "github.com/mattn/go-runewidth" import "fmt" import "os" import "os/signal" import "syscall" import "runtime" // public API // Initializes termbox library. This function should be called before any other functions. // After successful initialization, the library must be finalized using 'Close' function. // // Example usage: // err := termbox.Init() // if err != nil { // panic(err) // } // defer termbox.Close() func Init() error { var err error out, err = os.OpenFile("/dev/tty", syscall.O_WRONLY, 0) if err != nil { return err } in, err = syscall.Open("/dev/tty", syscall.O_RDONLY, 0) if err != nil { return err } err = setup_term() if err != nil { return fmt.Errorf("termbox: error while reading terminfo data: %v", err) } signal.Notify(sigwinch, syscall.SIGWINCH) signal.Notify(sigio, syscall.SIGIO) _, err = fcntl(in, syscall.F_SETFL, syscall.O_ASYNC|syscall.O_NONBLOCK) if err != nil { return err } _, err = fcntl(in, syscall.F_SETOWN, syscall.Getpid()) if runtime.GOOS != "darwin" && err != nil { return err } err = tcgetattr(out.Fd(), &orig_tios) if err != nil { return err } tios := orig_tios tios.Iflag &^= syscall_IGNBRK | syscall_BRKINT | syscall_PARMRK | syscall_ISTRIP | syscall_INLCR | syscall_IGNCR | syscall_ICRNL | syscall_IXON tios.Lflag &^= syscall_ECHO | syscall_ECHONL | syscall_ICANON | syscall_ISIG | syscall_IEXTEN tios.Cflag &^= syscall_CSIZE | syscall_PARENB tios.Cflag |= syscall_CS8 tios.Cc[syscall_VMIN] = 1 tios.Cc[syscall_VTIME] = 0 err = tcsetattr(out.Fd(), &tios) if err != nil { return err } out.WriteString(funcs[t_enter_ca]) out.WriteString(funcs[t_enter_keypad]) out.WriteString(funcs[t_hide_cursor]) out.WriteString(funcs[t_clear_screen]) termw, termh = get_term_size(out.Fd()) back_buffer.init(termw, termh) front_buffer.init(termw, termh) back_buffer.clear() front_buffer.clear() go func() { buf := make([]byte, 128) for { select { case <-sigio: for { n, err := syscall.Read(in, buf) if err == syscall.EAGAIN || err == syscall.EWOULDBLOCK { break } select { case input_comm <- input_event{buf[:n], err}: ie := <-input_comm buf = ie.data[:128] case <-quit: return } } case <-quit: return } } }() IsInit = true return nil } // Interrupt an in-progress call to PollEvent by causing it to return // EventInterrupt. Note that this function will block until the PollEvent // function has successfully been interrupted. func Interrupt() { interrupt_comm <- struct{}{} } // Finalizes termbox library, should be called after successful initialization // when termbox's functionality isn't required anymore. func Close() { quit <- 1 out.WriteString(funcs[t_show_cursor]) out.WriteString(funcs[t_sgr0]) out.WriteString(funcs[t_clear_screen]) out.WriteString(funcs[t_exit_ca]) out.WriteString(funcs[t_exit_keypad]) out.WriteString(funcs[t_exit_mouse]) tcsetattr(out.Fd(), &orig_tios) out.Close() syscall.Close(in) // reset the state, so that on next Init() it will work again termw = 0 termh = 0 input_mode = InputEsc out = nil in = 0 lastfg = attr_invalid lastbg = attr_invalid lastx = coord_invalid lasty = coord_invalid cursor_x = cursor_hidden cursor_y = cursor_hidden foreground = ColorDefault background = ColorDefault IsInit = false } // Synchronizes the internal back buffer with the terminal. func Flush() error { // invalidate cursor position lastx = coord_invalid lasty = coord_invalid update_size_maybe() for y := 0; y < front_buffer.height; y++ { line_offset := y * front_buffer.width for x := 0; x < front_buffer.width; { cell_offset := line_offset + x back := &back_buffer.cells[cell_offset] front := &front_buffer.cells[cell_offset] if back.Ch < ' ' { back.Ch = ' ' } w := runewidth.RuneWidth(back.Ch) if w == 0 || w == 2 && runewidth.IsAmbiguousWidth(back.Ch) { w = 1 } if *back == *front { x += w continue } *front = *back send_attr(back.Fg, back.Bg) if w == 2 && x == front_buffer.width-1 { // there's not enough space for 2-cells rune, // let's just put a space in there send_char(x, y, ' ') } else { send_char(x, y, back.Ch) if w == 2 { next := cell_offset + 1 front_buffer.cells[next] = Cell{ Ch: 0, Fg: back.Fg, Bg: back.Bg, } } } x += w } } if !is_cursor_hidden(cursor_x, cursor_y) { write_cursor(cursor_x, cursor_y) } return flush() } // Sets the position of the cursor. See also HideCursor(). func SetCursor(x, y int) { if is_cursor_hidden(cursor_x, cursor_y) && !is_cursor_hidden(x, y) { outbuf.WriteString(funcs[t_show_cursor]) } if !is_cursor_hidden(cursor_x, cursor_y) && is_cursor_hidden(x, y) { outbuf.WriteString(funcs[t_hide_cursor]) } cursor_x, cursor_y = x, y if !is_cursor_hidden(cursor_x, cursor_y) { write_cursor(cursor_x, cursor_y) } } // The shortcut for SetCursor(-1, -1). func HideCursor() { SetCursor(cursor_hidden, cursor_hidden) } // Changes cell's parameters in the internal back buffer at the specified // position. func SetCell(x, y int, ch rune, fg, bg Attribute) { if x < 0 || x >= back_buffer.width { return } if y < 0 || y >= back_buffer.height { return } back_buffer.cells[y*back_buffer.width+x] = Cell{ch, fg, bg} } // Returns a slice into the termbox's back buffer. You can get its dimensions // using 'Size' function. The slice remains valid as long as no 'Clear' or // 'Flush' function calls were made after call to this function. func CellBuffer() []Cell { return back_buffer.cells } // After getting a raw event from PollRawEvent function call, you can parse it // again into an ordinary one using termbox logic. That is parse an event as // termbox would do it. Returned event in addition to usual Event struct fields // sets N field to the amount of bytes used within 'data' slice. If the length // of 'data' slice is zero or event cannot be parsed for some other reason, the // function will return a special event type: EventNone. // // IMPORTANT: EventNone may contain a non-zero N, which means you should skip // these bytes, because termbox cannot recognize them. // // NOTE: This API is experimental and may change in future. func ParseEvent(data []byte) Event { event := Event{Type: EventKey} ok := extract_event(data, &event) if !ok { return Event{Type: EventNone, N: event.N} } return event } // Wait for an event and return it. This is a blocking function call. Instead // of EventKey and EventMouse it returns EventRaw events. Raw event is written // into `data` slice and Event's N field is set to the amount of bytes written. // The minimum required length of the 'data' slice is 1. This requirement may // vary on different platforms. // // NOTE: This API is experimental and may change in future. func PollRawEvent(data []byte) Event { if len(data) == 0 { panic("len(data) >= 1 is a requirement") } var event Event if extract_raw_event(data, &event) { return event } for { select { case ev := <-input_comm: if ev.err != nil { return Event{Type: EventError, Err: ev.err} } inbuf = append(inbuf, ev.data...) input_comm <- ev if extract_raw_event(data, &event) { return event } case <-interrupt_comm: event.Type = EventInterrupt return event case <-sigwinch: event.Type = EventResize event.Width, event.Height = get_term_size(out.Fd()) return event } } } // Wait for an event and return it. This is a blocking function call. func PollEvent() Event { var event Event // try to extract event from input buffer, return on success event.Type = EventKey ok := extract_event(inbuf, &event) if event.N != 0 { copy(inbuf, inbuf[event.N:]) inbuf = inbuf[:len(inbuf)-event.N] } if ok { return event } for { select { case ev := <-input_comm: if ev.err != nil { return Event{Type: EventError, Err: ev.err} } inbuf = append(inbuf, ev.data...) input_comm <- ev ok := extract_event(inbuf, &event) if event.N != 0 { copy(inbuf, inbuf[event.N:]) inbuf = inbuf[:len(inbuf)-event.N] } if ok { return event } case <-interrupt_comm: event.Type = EventInterrupt return event case <-sigwinch: event.Type = EventResize event.Width, event.Height = get_term_size(out.Fd()) return event } } panic("unreachable") } // Returns the size of the internal back buffer (which is mostly the same as // terminal's window size in characters). But it doesn't always match the size // of the terminal window, after the terminal size has changed, the internal // back buffer will get in sync only after Clear or Flush function calls. func Size() (width int, height int) { return termw, termh } // Clears the internal back buffer. func Clear(fg, bg Attribute) error { foreground, background = fg, bg err := update_size_maybe() back_buffer.clear() return err } // Sets termbox input mode. Termbox has two input modes: // // 1. Esc input mode. When ESC sequence is in the buffer and it doesn't match // any known sequence. ESC means KeyEsc. This is the default input mode. // // 2. Alt input mode. When ESC sequence is in the buffer and it doesn't match // any known sequence. ESC enables ModAlt modifier for the next keyboard event. // // Both input modes can be OR'ed with Mouse mode. Setting Mouse mode bit up will // enable mouse button press/release and drag events. // // If 'mode' is InputCurrent, returns the current input mode. See also Input* // constants. func SetInputMode(mode InputMode) InputMode { if mode == InputCurrent { return input_mode } if mode&(InputEsc|InputAlt) == 0 { mode |= InputEsc } if mode&(InputEsc|InputAlt) == InputEsc|InputAlt { mode &^= InputAlt } if mode&InputMouse != 0 { out.WriteString(funcs[t_enter_mouse]) } else { out.WriteString(funcs[t_exit_mouse]) } input_mode = mode return input_mode } // Sets the termbox output mode. Termbox has four output options: // // 1. OutputNormal => [1..8] // This mode provides 8 different colors: // black, red, green, yellow, blue, magenta, cyan, white // Shortcut: ColorBlack, ColorRed, ... // Attributes: AttrBold, AttrUnderline, AttrReverse // // Example usage: // SetCell(x, y, '@', ColorBlack | AttrBold, ColorRed); // // 2. Output256 => [1..256] // In this mode you can leverage the 256 terminal mode: // 0x01 - 0x08: the 8 colors as in OutputNormal // 0x09 - 0x10: Color* | AttrBold // 0x11 - 0xe8: 216 different colors // 0xe9 - 0x1ff: 24 different shades of grey // // Example usage: // SetCell(x, y, '@', 184, 240); // SetCell(x, y, '@', 0xb8, 0xf0); // // 3. Output216 => [1..216] // This mode supports the 3rd range of the 256 mode only. // But you dont need to provide an offset. // // 4. OutputGrayscale => [1..26] // This mode supports the 4th range of the 256 mode // and black and white colors from 3th range of the 256 mode // But you dont need to provide an offset. // // In all modes, 0x00 represents the default color. // // `go run _demos/output.go` to see its impact on your terminal. // // If 'mode' is OutputCurrent, it returns the current output mode. // // Note that this may return a different OutputMode than the one requested, // as the requested mode may not be available on the target platform. func SetOutputMode(mode OutputMode) OutputMode { if mode == OutputCurrent { return output_mode } output_mode = mode return output_mode } // Sync comes handy when something causes desync between termbox's understanding // of a terminal buffer and the reality. Such as a third party process. Sync // forces a complete resync between the termbox and a terminal, it may not be // visually pretty though. func Sync() error { front_buffer.clear() err := send_clear() if err != nil { return err } return Flush() } mongo-tools-r3.6.3/vendor/src/github.com/nsf/termbox-go/api_common.go000066400000000000000000000105231321131462300256230ustar00rootroot00000000000000// termbox is a library for creating cross-platform text-based interfaces package termbox // public API, common OS agnostic part type ( InputMode int OutputMode int EventType uint8 Modifier uint8 Key uint16 Attribute uint16 ) // This type represents a termbox event. The 'Mod', 'Key' and 'Ch' fields are // valid if 'Type' is EventKey. The 'Width' and 'Height' fields are valid if // 'Type' is EventResize. The 'Err' field is valid if 'Type' is EventError. type Event struct { Type EventType // one of Event* constants Mod Modifier // one of Mod* constants or 0 Key Key // one of Key* constants, invalid if 'Ch' is not 0 Ch rune // a unicode character Width int // width of the screen Height int // height of the screen Err error // error in case if input failed MouseX int // x coord of mouse MouseY int // y coord of mouse N int // number of bytes written when getting a raw event } // A cell, single conceptual entity on the screen. The screen is basically a 2d // array of cells. 'Ch' is a unicode character, 'Fg' and 'Bg' are foreground // and background attributes respectively. type Cell struct { Ch rune Fg Attribute Bg Attribute } // To know if termbox has been initialized or not var ( IsInit bool = false ) // Key constants, see Event.Key field. const ( KeyF1 Key = 0xFFFF - iota KeyF2 KeyF3 KeyF4 KeyF5 KeyF6 KeyF7 KeyF8 KeyF9 KeyF10 KeyF11 KeyF12 KeyInsert KeyDelete KeyHome KeyEnd KeyPgup KeyPgdn KeyArrowUp KeyArrowDown KeyArrowLeft KeyArrowRight key_min // see terminfo MouseLeft MouseMiddle MouseRight MouseRelease MouseWheelUp MouseWheelDown ) const ( KeyCtrlTilde Key = 0x00 KeyCtrl2 Key = 0x00 KeyCtrlSpace Key = 0x00 KeyCtrlA Key = 0x01 KeyCtrlB Key = 0x02 KeyCtrlC Key = 0x03 KeyCtrlD Key = 0x04 KeyCtrlE Key = 0x05 KeyCtrlF Key = 0x06 KeyCtrlG Key = 0x07 KeyBackspace Key = 0x08 KeyCtrlH Key = 0x08 KeyTab Key = 0x09 KeyCtrlI Key = 0x09 KeyCtrlJ Key = 0x0A KeyCtrlK Key = 0x0B KeyCtrlL Key = 0x0C KeyEnter Key = 0x0D KeyCtrlM Key = 0x0D KeyCtrlN Key = 0x0E KeyCtrlO Key = 0x0F KeyCtrlP Key = 0x10 KeyCtrlQ Key = 0x11 KeyCtrlR Key = 0x12 KeyCtrlS Key = 0x13 KeyCtrlT Key = 0x14 KeyCtrlU Key = 0x15 KeyCtrlV Key = 0x16 KeyCtrlW Key = 0x17 KeyCtrlX Key = 0x18 KeyCtrlY Key = 0x19 KeyCtrlZ Key = 0x1A KeyEsc Key = 0x1B KeyCtrlLsqBracket Key = 0x1B KeyCtrl3 Key = 0x1B KeyCtrl4 Key = 0x1C KeyCtrlBackslash Key = 0x1C KeyCtrl5 Key = 0x1D KeyCtrlRsqBracket Key = 0x1D KeyCtrl6 Key = 0x1E KeyCtrl7 Key = 0x1F KeyCtrlSlash Key = 0x1F KeyCtrlUnderscore Key = 0x1F KeySpace Key = 0x20 KeyBackspace2 Key = 0x7F KeyCtrl8 Key = 0x7F ) // Alt modifier constant, see Event.Mod field and SetInputMode function. const ( ModAlt Modifier = 1 << iota ModMotion ) // Cell colors, you can combine a color with multiple attributes using bitwise // OR ('|'). const ( ColorDefault Attribute = iota ColorBlack ColorRed ColorGreen ColorYellow ColorBlue ColorMagenta ColorCyan ColorWhite ) // Cell attributes, it is possible to use multiple attributes by combining them // using bitwise OR ('|'). Although, colors cannot be combined. But you can // combine attributes and a single color. // // It's worth mentioning that some platforms don't support certain attibutes. // For example windows console doesn't support AttrUnderline. And on some // terminals applying AttrBold to background may result in blinking text. Use // them with caution and test your code on various terminals. const ( AttrBold Attribute = 1 << (iota + 9) AttrUnderline AttrReverse ) // Input mode. See SetInputMode function. const ( InputEsc InputMode = 1 << iota InputAlt InputMouse InputCurrent InputMode = 0 ) // Output mode. See SetOutputMode function. const ( OutputCurrent OutputMode = iota OutputNormal Output256 Output216 OutputGrayscale ) // Event type. See Event.Type field. const ( EventKey EventType = iota EventResize EventMouse EventError EventInterrupt EventRaw EventNone ) mongo-tools-r3.6.3/vendor/src/github.com/nsf/termbox-go/api_windows.go000066400000000000000000000136221321131462300260300ustar00rootroot00000000000000package termbox import ( "syscall" ) // public API // Initializes termbox library. This function should be called before any other functions. // After successful initialization, the library must be finalized using 'Close' function. // // Example usage: // err := termbox.Init() // if err != nil { // panic(err) // } // defer termbox.Close() func Init() error { var err error interrupt, err = create_event() if err != nil { return err } in, err = syscall.Open("CONIN$", syscall.O_RDWR, 0) if err != nil { return err } out, err = syscall.Open("CONOUT$", syscall.O_RDWR, 0) if err != nil { return err } err = get_console_mode(in, &orig_mode) if err != nil { return err } err = set_console_mode(in, enable_window_input) if err != nil { return err } orig_size = get_term_size(out) win_size := get_win_size(out) err = set_console_screen_buffer_size(out, win_size) if err != nil { return err } err = get_console_cursor_info(out, &orig_cursor_info) if err != nil { return err } show_cursor(false) term_size = get_term_size(out) back_buffer.init(int(term_size.x), int(term_size.y)) front_buffer.init(int(term_size.x), int(term_size.y)) back_buffer.clear() front_buffer.clear() clear() diffbuf = make([]diff_msg, 0, 32) go input_event_producer() IsInit = true return nil } // Finalizes termbox library, should be called after successful initialization // when termbox's functionality isn't required anymore. func Close() { // we ignore errors here, because we can't really do anything about them Clear(0, 0) Flush() // stop event producer cancel_comm <- true set_event(interrupt) select { case <-input_comm: default: } <-cancel_done_comm set_console_cursor_info(out, &orig_cursor_info) set_console_cursor_position(out, coord{}) set_console_screen_buffer_size(out, orig_size) set_console_mode(in, orig_mode) syscall.Close(in) syscall.Close(out) syscall.Close(interrupt) IsInit = false } // Interrupt an in-progress call to PollEvent by causing it to return // EventInterrupt. Note that this function will block until the PollEvent // function has successfully been interrupted. func Interrupt() { interrupt_comm <- struct{}{} } // Synchronizes the internal back buffer with the terminal. func Flush() error { update_size_maybe() prepare_diff_messages() for _, diff := range diffbuf { r := small_rect{ left: 0, top: diff.pos, right: term_size.x - 1, bottom: diff.pos + diff.lines - 1, } write_console_output(out, diff.chars, r) } if !is_cursor_hidden(cursor_x, cursor_y) { move_cursor(cursor_x, cursor_y) } return nil } // Sets the position of the cursor. See also HideCursor(). func SetCursor(x, y int) { if is_cursor_hidden(cursor_x, cursor_y) && !is_cursor_hidden(x, y) { show_cursor(true) } if !is_cursor_hidden(cursor_x, cursor_y) && is_cursor_hidden(x, y) { show_cursor(false) } cursor_x, cursor_y = x, y if !is_cursor_hidden(cursor_x, cursor_y) { move_cursor(cursor_x, cursor_y) } } // The shortcut for SetCursor(-1, -1). func HideCursor() { SetCursor(cursor_hidden, cursor_hidden) } // Changes cell's parameters in the internal back buffer at the specified // position. func SetCell(x, y int, ch rune, fg, bg Attribute) { if x < 0 || x >= back_buffer.width { return } if y < 0 || y >= back_buffer.height { return } back_buffer.cells[y*back_buffer.width+x] = Cell{ch, fg, bg} } // Returns a slice into the termbox's back buffer. You can get its dimensions // using 'Size' function. The slice remains valid as long as no 'Clear' or // 'Flush' function calls were made after call to this function. func CellBuffer() []Cell { return back_buffer.cells } // Wait for an event and return it. This is a blocking function call. func PollEvent() Event { select { case ev := <-input_comm: return ev case <-interrupt_comm: return Event{Type: EventInterrupt} } } // Returns the size of the internal back buffer (which is mostly the same as // console's window size in characters). But it doesn't always match the size // of the console window, after the console size has changed, the internal back // buffer will get in sync only after Clear or Flush function calls. func Size() (int, int) { return int(term_size.x), int(term_size.y) } // Clears the internal back buffer. func Clear(fg, bg Attribute) error { foreground, background = fg, bg update_size_maybe() back_buffer.clear() return nil } // Sets termbox input mode. Termbox has two input modes: // // 1. Esc input mode. When ESC sequence is in the buffer and it doesn't match // any known sequence. ESC means KeyEsc. This is the default input mode. // // 2. Alt input mode. When ESC sequence is in the buffer and it doesn't match // any known sequence. ESC enables ModAlt modifier for the next keyboard event. // // Both input modes can be OR'ed with Mouse mode. Setting Mouse mode bit up will // enable mouse button press/release and drag events. // // If 'mode' is InputCurrent, returns the current input mode. See also Input* // constants. func SetInputMode(mode InputMode) InputMode { if mode == InputCurrent { return input_mode } if mode&InputMouse != 0 { err := set_console_mode(in, enable_window_input|enable_mouse_input|enable_extended_flags) if err != nil { panic(err) } } else { err := set_console_mode(in, enable_window_input) if err != nil { panic(err) } } input_mode = mode return input_mode } // Sets the termbox output mode. // // Windows console does not support extra colour modes, // so this will always set and return OutputNormal. func SetOutputMode(mode OutputMode) OutputMode { return OutputNormal } // Sync comes handy when something causes desync between termbox's understanding // of a terminal buffer and the reality. Such as a third party process. Sync // forces a complete resync between the termbox and a terminal, it may not be // visually pretty though. At the moment on Windows it does nothing. func Sync() error { return nil } mongo-tools-r3.6.3/vendor/src/github.com/nsf/termbox-go/collect_terminfo.py000077500000000000000000000037711321131462300270670ustar00rootroot00000000000000#!/usr/bin/env python import sys, os, subprocess def escaped(s): return repr(s)[1:-1] def tput(term, name): try: return subprocess.check_output(['tput', '-T%s' % term, name]).decode() except subprocess.CalledProcessError as e: return e.output.decode() def w(s): if s == None: return sys.stdout.write(s) terminals = { 'xterm' : 'xterm', 'rxvt-256color' : 'rxvt_256color', 'rxvt-unicode' : 'rxvt_unicode', 'linux' : 'linux', 'Eterm' : 'eterm', 'screen' : 'screen' } keys = [ "F1", "kf1", "F2", "kf2", "F3", "kf3", "F4", "kf4", "F5", "kf5", "F6", "kf6", "F7", "kf7", "F8", "kf8", "F9", "kf9", "F10", "kf10", "F11", "kf11", "F12", "kf12", "INSERT", "kich1", "DELETE", "kdch1", "HOME", "khome", "END", "kend", "PGUP", "kpp", "PGDN", "knp", "KEY_UP", "kcuu1", "KEY_DOWN", "kcud1", "KEY_LEFT", "kcub1", "KEY_RIGHT", "kcuf1" ] funcs = [ "T_ENTER_CA", "smcup", "T_EXIT_CA", "rmcup", "T_SHOW_CURSOR", "cnorm", "T_HIDE_CURSOR", "civis", "T_CLEAR_SCREEN", "clear", "T_SGR0", "sgr0", "T_UNDERLINE", "smul", "T_BOLD", "bold", "T_BLINK", "blink", "T_REVERSE", "rev", "T_ENTER_KEYPAD", "smkx", "T_EXIT_KEYPAD", "rmkx" ] def iter_pairs(iterable): iterable = iter(iterable) while True: yield (next(iterable), next(iterable)) def do_term(term, nick): w("// %s\n" % term) w("var %s_keys = []string{\n\t" % nick) for k, v in iter_pairs(keys): w('"') w(escaped(tput(term, v))) w('",') w("\n}\n") w("var %s_funcs = []string{\n\t" % nick) for k,v in iter_pairs(funcs): w('"') if v == "sgr": w("\\033[3%d;4%dm") elif v == "cup": w("\\033[%d;%dH") else: w(escaped(tput(term, v))) w('", ') w("\n}\n\n") def do_terms(d): w("var terms = []struct {\n") w("\tname string\n") w("\tkeys []string\n") w("\tfuncs []string\n") w("}{\n") for k, v in d.items(): w('\t{"%s", %s_keys, %s_funcs},\n' % (k, v, v)) w("}\n\n") w("// +build !windows\n\npackage termbox\n\n") for k,v in terminals.items(): do_term(k, v) do_terms(terminals) mongo-tools-r3.6.3/vendor/src/github.com/nsf/termbox-go/syscalls.go000066400000000000000000000014051321131462300253360ustar00rootroot00000000000000// +build ignore package termbox /* #include #include */ import "C" type syscall_Termios C.struct_termios const ( syscall_IGNBRK = C.IGNBRK syscall_BRKINT = C.BRKINT syscall_PARMRK = C.PARMRK syscall_ISTRIP = C.ISTRIP syscall_INLCR = C.INLCR syscall_IGNCR = C.IGNCR syscall_ICRNL = C.ICRNL syscall_IXON = C.IXON syscall_OPOST = C.OPOST syscall_ECHO = C.ECHO syscall_ECHONL = C.ECHONL syscall_ICANON = C.ICANON syscall_ISIG = C.ISIG syscall_IEXTEN = C.IEXTEN syscall_CSIZE = C.CSIZE syscall_PARENB = C.PARENB syscall_CS8 = C.CS8 syscall_VMIN = C.VMIN syscall_VTIME = C.VTIME // on darwin change these to (on *bsd too?): // C.TIOCGETA // C.TIOCSETA syscall_TCGETS = C.TCGETS syscall_TCSETS = C.TCSETS ) mongo-tools-r3.6.3/vendor/src/github.com/nsf/termbox-go/syscalls_darwin.go000066400000000000000000000013611321131462300267030ustar00rootroot00000000000000// Created by cgo -godefs - DO NOT EDIT // cgo -godefs syscalls.go // +build !amd64 package termbox type syscall_Termios struct { Iflag uint32 Oflag uint32 Cflag uint32 Lflag uint32 Cc [20]uint8 Ispeed uint32 Ospeed uint32 } const ( syscall_IGNBRK = 0x1 syscall_BRKINT = 0x2 syscall_PARMRK = 0x8 syscall_ISTRIP = 0x20 syscall_INLCR = 0x40 syscall_IGNCR = 0x80 syscall_ICRNL = 0x100 syscall_IXON = 0x200 syscall_OPOST = 0x1 syscall_ECHO = 0x8 syscall_ECHONL = 0x10 syscall_ICANON = 0x100 syscall_ISIG = 0x80 syscall_IEXTEN = 0x400 syscall_CSIZE = 0x300 syscall_PARENB = 0x1000 syscall_CS8 = 0x300 syscall_VMIN = 0x10 syscall_VTIME = 0x11 syscall_TCGETS = 0x402c7413 syscall_TCSETS = 0x802c7414 ) mongo-tools-r3.6.3/vendor/src/github.com/nsf/termbox-go/syscalls_darwin_amd64.go000066400000000000000000000014071321131462300276770ustar00rootroot00000000000000// Created by cgo -godefs - DO NOT EDIT // cgo -godefs syscalls.go package termbox type syscall_Termios struct { Iflag uint64 Oflag uint64 Cflag uint64 Lflag uint64 Cc [20]uint8 Pad_cgo_0 [4]byte Ispeed uint64 Ospeed uint64 } const ( syscall_IGNBRK = 0x1 syscall_BRKINT = 0x2 syscall_PARMRK = 0x8 syscall_ISTRIP = 0x20 syscall_INLCR = 0x40 syscall_IGNCR = 0x80 syscall_ICRNL = 0x100 syscall_IXON = 0x200 syscall_OPOST = 0x1 syscall_ECHO = 0x8 syscall_ECHONL = 0x10 syscall_ICANON = 0x100 syscall_ISIG = 0x80 syscall_IEXTEN = 0x400 syscall_CSIZE = 0x300 syscall_PARENB = 0x1000 syscall_CS8 = 0x300 syscall_VMIN = 0x10 syscall_VTIME = 0x11 syscall_TCGETS = 0x40487413 syscall_TCSETS = 0x80487414 ) mongo-tools-r3.6.3/vendor/src/github.com/nsf/termbox-go/syscalls_freebsd.go000066400000000000000000000013371321131462300270340ustar00rootroot00000000000000// Created by cgo -godefs - DO NOT EDIT // cgo -godefs syscalls.go package termbox type syscall_Termios struct { Iflag uint32 Oflag uint32 Cflag uint32 Lflag uint32 Cc [20]uint8 Ispeed uint32 Ospeed uint32 } const ( syscall_IGNBRK = 0x1 syscall_BRKINT = 0x2 syscall_PARMRK = 0x8 syscall_ISTRIP = 0x20 syscall_INLCR = 0x40 syscall_IGNCR = 0x80 syscall_ICRNL = 0x100 syscall_IXON = 0x200 syscall_OPOST = 0x1 syscall_ECHO = 0x8 syscall_ECHONL = 0x10 syscall_ICANON = 0x100 syscall_ISIG = 0x80 syscall_IEXTEN = 0x400 syscall_CSIZE = 0x300 syscall_PARENB = 0x1000 syscall_CS8 = 0x300 syscall_VMIN = 0x10 syscall_VTIME = 0x11 syscall_TCGETS = 0x402c7413 syscall_TCSETS = 0x802c7414 ) mongo-tools-r3.6.3/vendor/src/github.com/nsf/termbox-go/syscalls_linux.go000066400000000000000000000014741321131462300265630ustar00rootroot00000000000000// Created by cgo -godefs - DO NOT EDIT // cgo -godefs syscalls.go package termbox import "syscall" type syscall_Termios syscall.Termios const ( syscall_IGNBRK = syscall.IGNBRK syscall_BRKINT = syscall.BRKINT syscall_PARMRK = syscall.PARMRK syscall_ISTRIP = syscall.ISTRIP syscall_INLCR = syscall.INLCR syscall_IGNCR = syscall.IGNCR syscall_ICRNL = syscall.ICRNL syscall_IXON = syscall.IXON syscall_OPOST = syscall.OPOST syscall_ECHO = syscall.ECHO syscall_ECHONL = syscall.ECHONL syscall_ICANON = syscall.ICANON syscall_ISIG = syscall.ISIG syscall_IEXTEN = syscall.IEXTEN syscall_CSIZE = syscall.CSIZE syscall_PARENB = syscall.PARENB syscall_CS8 = syscall.CS8 syscall_VMIN = syscall.VMIN syscall_VTIME = syscall.VTIME syscall_TCGETS = syscall.TCGETS syscall_TCSETS = syscall.TCSETS ) mongo-tools-r3.6.3/vendor/src/github.com/nsf/termbox-go/syscalls_netbsd.go000066400000000000000000000013351321131462300266770ustar00rootroot00000000000000// Created by cgo -godefs - DO NOT EDIT // cgo -godefs syscalls.go package termbox type syscall_Termios struct { Iflag uint32 Oflag uint32 Cflag uint32 Lflag uint32 Cc [20]uint8 Ispeed int32 Ospeed int32 } const ( syscall_IGNBRK = 0x1 syscall_BRKINT = 0x2 syscall_PARMRK = 0x8 syscall_ISTRIP = 0x20 syscall_INLCR = 0x40 syscall_IGNCR = 0x80 syscall_ICRNL = 0x100 syscall_IXON = 0x200 syscall_OPOST = 0x1 syscall_ECHO = 0x8 syscall_ECHONL = 0x10 syscall_ICANON = 0x100 syscall_ISIG = 0x80 syscall_IEXTEN = 0x400 syscall_CSIZE = 0x300 syscall_PARENB = 0x1000 syscall_CS8 = 0x300 syscall_VMIN = 0x10 syscall_VTIME = 0x11 syscall_TCGETS = 0x402c7413 syscall_TCSETS = 0x802c7414 ) mongo-tools-r3.6.3/vendor/src/github.com/nsf/termbox-go/syscalls_openbsd.go000066400000000000000000000013351321131462300270520ustar00rootroot00000000000000// Created by cgo -godefs - DO NOT EDIT // cgo -godefs syscalls.go package termbox type syscall_Termios struct { Iflag uint32 Oflag uint32 Cflag uint32 Lflag uint32 Cc [20]uint8 Ispeed int32 Ospeed int32 } const ( syscall_IGNBRK = 0x1 syscall_BRKINT = 0x2 syscall_PARMRK = 0x8 syscall_ISTRIP = 0x20 syscall_INLCR = 0x40 syscall_IGNCR = 0x80 syscall_ICRNL = 0x100 syscall_IXON = 0x200 syscall_OPOST = 0x1 syscall_ECHO = 0x8 syscall_ECHONL = 0x10 syscall_ICANON = 0x100 syscall_ISIG = 0x80 syscall_IEXTEN = 0x400 syscall_CSIZE = 0x300 syscall_PARENB = 0x1000 syscall_CS8 = 0x300 syscall_VMIN = 0x10 syscall_VTIME = 0x11 syscall_TCGETS = 0x402c7413 syscall_TCSETS = 0x802c7414 ) mongo-tools-r3.6.3/vendor/src/github.com/nsf/termbox-go/syscalls_windows.go000066400000000000000000000027171321131462300271170ustar00rootroot00000000000000// Created by cgo -godefs - DO NOT EDIT // cgo -godefs -- -DUNICODE syscalls.go package termbox const ( foreground_blue = 0x1 foreground_green = 0x2 foreground_red = 0x4 foreground_intensity = 0x8 background_blue = 0x10 background_green = 0x20 background_red = 0x40 background_intensity = 0x80 std_input_handle = -0xa std_output_handle = -0xb key_event = 0x1 mouse_event = 0x2 window_buffer_size_event = 0x4 enable_window_input = 0x8 enable_mouse_input = 0x10 enable_extended_flags = 0x80 vk_f1 = 0x70 vk_f2 = 0x71 vk_f3 = 0x72 vk_f4 = 0x73 vk_f5 = 0x74 vk_f6 = 0x75 vk_f7 = 0x76 vk_f8 = 0x77 vk_f9 = 0x78 vk_f10 = 0x79 vk_f11 = 0x7a vk_f12 = 0x7b vk_insert = 0x2d vk_delete = 0x2e vk_home = 0x24 vk_end = 0x23 vk_pgup = 0x21 vk_pgdn = 0x22 vk_arrow_up = 0x26 vk_arrow_down = 0x28 vk_arrow_left = 0x25 vk_arrow_right = 0x27 vk_backspace = 0x8 vk_tab = 0x9 vk_enter = 0xd vk_esc = 0x1b vk_space = 0x20 left_alt_pressed = 0x2 left_ctrl_pressed = 0x8 right_alt_pressed = 0x1 right_ctrl_pressed = 0x4 shift_pressed = 0x10 generic_read = 0x80000000 generic_write = 0x40000000 console_textmode_buffer = 0x1 ) mongo-tools-r3.6.3/vendor/src/github.com/nsf/termbox-go/termbox.go000066400000000000000000000255041321131462300251670ustar00rootroot00000000000000// +build !windows package termbox import "unicode/utf8" import "bytes" import "syscall" import "unsafe" import "strings" import "strconv" import "os" import "io" // private API const ( t_enter_ca = iota t_exit_ca t_show_cursor t_hide_cursor t_clear_screen t_sgr0 t_underline t_bold t_blink t_reverse t_enter_keypad t_exit_keypad t_enter_mouse t_exit_mouse t_max_funcs ) const ( coord_invalid = -2 attr_invalid = Attribute(0xFFFF) ) type input_event struct { data []byte err error } var ( // term specific sequences keys []string funcs []string // termbox inner state orig_tios syscall_Termios back_buffer cellbuf front_buffer cellbuf termw int termh int input_mode = InputEsc output_mode = OutputNormal out *os.File in int lastfg = attr_invalid lastbg = attr_invalid lastx = coord_invalid lasty = coord_invalid cursor_x = cursor_hidden cursor_y = cursor_hidden foreground = ColorDefault background = ColorDefault inbuf = make([]byte, 0, 64) outbuf bytes.Buffer sigwinch = make(chan os.Signal, 1) sigio = make(chan os.Signal, 1) quit = make(chan int) input_comm = make(chan input_event) interrupt_comm = make(chan struct{}) intbuf = make([]byte, 0, 16) // grayscale indexes grayscale = []Attribute{ 0, 17, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 232, } ) func write_cursor(x, y int) { outbuf.WriteString("\033[") outbuf.Write(strconv.AppendUint(intbuf, uint64(y+1), 10)) outbuf.WriteString(";") outbuf.Write(strconv.AppendUint(intbuf, uint64(x+1), 10)) outbuf.WriteString("H") } func write_sgr_fg(a Attribute) { switch output_mode { case Output256, Output216, OutputGrayscale: outbuf.WriteString("\033[38;5;") outbuf.Write(strconv.AppendUint(intbuf, uint64(a-1), 10)) outbuf.WriteString("m") default: outbuf.WriteString("\033[3") outbuf.Write(strconv.AppendUint(intbuf, uint64(a-1), 10)) outbuf.WriteString("m") } } func write_sgr_bg(a Attribute) { switch output_mode { case Output256, Output216, OutputGrayscale: outbuf.WriteString("\033[48;5;") outbuf.Write(strconv.AppendUint(intbuf, uint64(a-1), 10)) outbuf.WriteString("m") default: outbuf.WriteString("\033[4") outbuf.Write(strconv.AppendUint(intbuf, uint64(a-1), 10)) outbuf.WriteString("m") } } func write_sgr(fg, bg Attribute) { switch output_mode { case Output256, Output216, OutputGrayscale: outbuf.WriteString("\033[38;5;") outbuf.Write(strconv.AppendUint(intbuf, uint64(fg-1), 10)) outbuf.WriteString("m") outbuf.WriteString("\033[48;5;") outbuf.Write(strconv.AppendUint(intbuf, uint64(bg-1), 10)) outbuf.WriteString("m") default: outbuf.WriteString("\033[3") outbuf.Write(strconv.AppendUint(intbuf, uint64(fg-1), 10)) outbuf.WriteString(";4") outbuf.Write(strconv.AppendUint(intbuf, uint64(bg-1), 10)) outbuf.WriteString("m") } } type winsize struct { rows uint16 cols uint16 xpixels uint16 ypixels uint16 } func get_term_size(fd uintptr) (int, int) { var sz winsize _, _, _ = syscall.Syscall(syscall.SYS_IOCTL, fd, uintptr(syscall.TIOCGWINSZ), uintptr(unsafe.Pointer(&sz))) return int(sz.cols), int(sz.rows) } func send_attr(fg, bg Attribute) { if fg == lastfg && bg == lastbg { return } outbuf.WriteString(funcs[t_sgr0]) var fgcol, bgcol Attribute switch output_mode { case Output256: fgcol = fg & 0x1FF bgcol = bg & 0x1FF case Output216: fgcol = fg & 0xFF bgcol = bg & 0xFF if fgcol > 216 { fgcol = ColorDefault } if bgcol > 216 { bgcol = ColorDefault } if fgcol != ColorDefault { fgcol += 0x10 } if bgcol != ColorDefault { bgcol += 0x10 } case OutputGrayscale: fgcol = fg & 0x1F bgcol = bg & 0x1F if fgcol > 26 { fgcol = ColorDefault } if bgcol > 26 { bgcol = ColorDefault } if fgcol != ColorDefault { fgcol = grayscale[fgcol] } if bgcol != ColorDefault { bgcol = grayscale[bgcol] } default: fgcol = fg & 0x0F bgcol = bg & 0x0F } if fgcol != ColorDefault { if bgcol != ColorDefault { write_sgr(fgcol, bgcol) } else { write_sgr_fg(fgcol) } } else if bgcol != ColorDefault { write_sgr_bg(bgcol) } if fg&AttrBold != 0 { outbuf.WriteString(funcs[t_bold]) } if bg&AttrBold != 0 { outbuf.WriteString(funcs[t_blink]) } if fg&AttrUnderline != 0 { outbuf.WriteString(funcs[t_underline]) } if fg&AttrReverse|bg&AttrReverse != 0 { outbuf.WriteString(funcs[t_reverse]) } lastfg, lastbg = fg, bg } func send_char(x, y int, ch rune) { var buf [8]byte n := utf8.EncodeRune(buf[:], ch) if x-1 != lastx || y != lasty { write_cursor(x, y) } lastx, lasty = x, y outbuf.Write(buf[:n]) } func flush() error { _, err := io.Copy(out, &outbuf) outbuf.Reset() if err != nil { return err } return nil } func send_clear() error { send_attr(foreground, background) outbuf.WriteString(funcs[t_clear_screen]) if !is_cursor_hidden(cursor_x, cursor_y) { write_cursor(cursor_x, cursor_y) } // we need to invalidate cursor position too and these two vars are // used only for simple cursor positioning optimization, cursor // actually may be in the correct place, but we simply discard // optimization once and it gives us simple solution for the case when // cursor moved lastx = coord_invalid lasty = coord_invalid return flush() } func update_size_maybe() error { w, h := get_term_size(out.Fd()) if w != termw || h != termh { termw, termh = w, h back_buffer.resize(termw, termh) front_buffer.resize(termw, termh) front_buffer.clear() return send_clear() } return nil } func tcsetattr(fd uintptr, termios *syscall_Termios) error { r, _, e := syscall.Syscall(syscall.SYS_IOCTL, fd, uintptr(syscall_TCSETS), uintptr(unsafe.Pointer(termios))) if r != 0 { return os.NewSyscallError("SYS_IOCTL", e) } return nil } func tcgetattr(fd uintptr, termios *syscall_Termios) error { r, _, e := syscall.Syscall(syscall.SYS_IOCTL, fd, uintptr(syscall_TCGETS), uintptr(unsafe.Pointer(termios))) if r != 0 { return os.NewSyscallError("SYS_IOCTL", e) } return nil } func parse_mouse_event(event *Event, buf string) (int, bool) { if strings.HasPrefix(buf, "\033[M") && len(buf) >= 6 { // X10 mouse encoding, the simplest one // \033 [ M Cb Cx Cy b := buf[3] - 32 switch b & 3 { case 0: if b&64 != 0 { event.Key = MouseWheelUp } else { event.Key = MouseLeft } case 1: if b&64 != 0 { event.Key = MouseWheelDown } else { event.Key = MouseMiddle } case 2: event.Key = MouseRight case 3: event.Key = MouseRelease default: return 6, false } event.Type = EventMouse // KeyEvent by default if b&32 != 0 { event.Mod |= ModMotion } // the coord is 1,1 for upper left event.MouseX = int(buf[4]) - 1 - 32 event.MouseY = int(buf[5]) - 1 - 32 return 6, true } else if strings.HasPrefix(buf, "\033[<") || strings.HasPrefix(buf, "\033[") { // xterm 1006 extended mode or urxvt 1015 extended mode // xterm: \033 [ < Cb ; Cx ; Cy (M or m) // urxvt: \033 [ Cb ; Cx ; Cy M // find the first M or m, that's where we stop mi := strings.IndexAny(buf, "Mm") if mi == -1 { return 0, false } // whether it's a capital M or not isM := buf[mi] == 'M' // whether it's urxvt or not isU := false // buf[2] is safe here, because having M or m found means we have at // least 3 bytes in a string if buf[2] == '<' { buf = buf[3:mi] } else { isU = true buf = buf[2:mi] } s1 := strings.Index(buf, ";") s2 := strings.LastIndex(buf, ";") // not found or only one ';' if s1 == -1 || s2 == -1 || s1 == s2 { return 0, false } n1, err := strconv.ParseInt(buf[0:s1], 10, 64) if err != nil { return 0, false } n2, err := strconv.ParseInt(buf[s1+1:s2], 10, 64) if err != nil { return 0, false } n3, err := strconv.ParseInt(buf[s2+1:], 10, 64) if err != nil { return 0, false } // on urxvt, first number is encoded exactly as in X10, but we need to // make it zero-based, on xterm it is zero-based already if isU { n1 -= 32 } switch n1 & 3 { case 0: if n1&64 != 0 { event.Key = MouseWheelUp } else { event.Key = MouseLeft } case 1: if n1&64 != 0 { event.Key = MouseWheelDown } else { event.Key = MouseMiddle } case 2: event.Key = MouseRight case 3: event.Key = MouseRelease default: return mi + 1, false } if !isM { // on xterm mouse release is signaled by lowercase m event.Key = MouseRelease } event.Type = EventMouse // KeyEvent by default if n1&32 != 0 { event.Mod |= ModMotion } event.MouseX = int(n2) - 1 event.MouseY = int(n3) - 1 return mi + 1, true } return 0, false } func parse_escape_sequence(event *Event, buf []byte) (int, bool) { bufstr := string(buf) for i, key := range keys { if strings.HasPrefix(bufstr, key) { event.Ch = 0 event.Key = Key(0xFFFF - i) return len(key), true } } // if none of the keys match, let's try mouse seqences return parse_mouse_event(event, bufstr) } func extract_raw_event(data []byte, event *Event) bool { if len(inbuf) == 0 { return false } n := len(data) if n == 0 { return false } n = copy(data, inbuf) copy(inbuf, inbuf[n:]) inbuf = inbuf[:len(inbuf)-n] event.N = n event.Type = EventRaw return true } func extract_event(inbuf []byte, event *Event) bool { if len(inbuf) == 0 { event.N = 0 return false } if inbuf[0] == '\033' { // possible escape sequence if n, ok := parse_escape_sequence(event, inbuf); n != 0 { event.N = n return ok } // it's not escape sequence, then it's Alt or Esc, check input_mode switch { case input_mode&InputEsc != 0: // if we're in escape mode, fill Esc event, pop buffer, return success event.Ch = 0 event.Key = KeyEsc event.Mod = 0 event.N = 1 return true case input_mode&InputAlt != 0: // if we're in alt mode, set Alt modifier to event and redo parsing event.Mod = ModAlt ok := extract_event(inbuf[1:], event) if ok { event.N++ } else { event.N = 0 } return ok default: panic("unreachable") } } // if we're here, this is not an escape sequence and not an alt sequence // so, it's a FUNCTIONAL KEY or a UNICODE character // first of all check if it's a functional key if Key(inbuf[0]) <= KeySpace || Key(inbuf[0]) == KeyBackspace2 { // fill event, pop buffer, return success event.Ch = 0 event.Key = Key(inbuf[0]) event.N = 1 return true } // the only possible option is utf8 rune if r, n := utf8.DecodeRune(inbuf); r != utf8.RuneError { event.Ch = r event.Key = 0 event.N = n return true } return false } func fcntl(fd int, cmd int, arg int) (val int, err error) { r, _, e := syscall.Syscall(syscall.SYS_FCNTL, uintptr(fd), uintptr(cmd), uintptr(arg)) val = int(r) if e != 0 { err = e } return } mongo-tools-r3.6.3/vendor/src/github.com/nsf/termbox-go/termbox_common.go000066400000000000000000000017421321131462300265350ustar00rootroot00000000000000package termbox // private API, common OS agnostic part type cellbuf struct { width int height int cells []Cell } func (this *cellbuf) init(width, height int) { this.width = width this.height = height this.cells = make([]Cell, width*height) } func (this *cellbuf) resize(width, height int) { if this.width == width && this.height == height { return } oldw := this.width oldh := this.height oldcells := this.cells this.init(width, height) this.clear() minw, minh := oldw, oldh if width < minw { minw = width } if height < minh { minh = height } for i := 0; i < minh; i++ { srco, dsto := i*oldw, i*width src := oldcells[srco : srco+minw] dst := this.cells[dsto : dsto+minw] copy(dst, src) } } func (this *cellbuf) clear() { for i := range this.cells { c := &this.cells[i] c.Ch = ' ' c.Fg = foreground c.Bg = background } } const cursor_hidden = -1 func is_cursor_hidden(x, y int) bool { return x == cursor_hidden || y == cursor_hidden } mongo-tools-r3.6.3/vendor/src/github.com/nsf/termbox-go/termbox_windows.go000066400000000000000000000476011321131462300267430ustar00rootroot00000000000000package termbox import "syscall" import "unsafe" import "unicode/utf16" import "github.com/mattn/go-runewidth" type ( wchar uint16 short int16 dword uint32 word uint16 char_info struct { char wchar attr word } coord struct { x short y short } small_rect struct { left short top short right short bottom short } console_screen_buffer_info struct { size coord cursor_position coord attributes word window small_rect maximum_window_size coord } console_cursor_info struct { size dword visible int32 } input_record struct { event_type word _ [2]byte event [16]byte } key_event_record struct { key_down int32 repeat_count word virtual_key_code word virtual_scan_code word unicode_char wchar control_key_state dword } window_buffer_size_record struct { size coord } mouse_event_record struct { mouse_pos coord button_state dword control_key_state dword event_flags dword } ) const ( mouse_lmb = 0x1 mouse_rmb = 0x2 mouse_mmb = 0x4 | 0x8 | 0x10 ) func (this coord) uintptr() uintptr { return uintptr(*(*int32)(unsafe.Pointer(&this))) } var kernel32 = syscall.NewLazyDLL("kernel32.dll") var is_cjk = runewidth.IsEastAsian() var ( proc_set_console_active_screen_buffer = kernel32.NewProc("SetConsoleActiveScreenBuffer") proc_set_console_screen_buffer_size = kernel32.NewProc("SetConsoleScreenBufferSize") proc_create_console_screen_buffer = kernel32.NewProc("CreateConsoleScreenBuffer") proc_get_console_screen_buffer_info = kernel32.NewProc("GetConsoleScreenBufferInfo") proc_write_console_output = kernel32.NewProc("WriteConsoleOutputW") proc_write_console_output_character = kernel32.NewProc("WriteConsoleOutputCharacterW") proc_write_console_output_attribute = kernel32.NewProc("WriteConsoleOutputAttribute") proc_set_console_cursor_info = kernel32.NewProc("SetConsoleCursorInfo") proc_set_console_cursor_position = kernel32.NewProc("SetConsoleCursorPosition") proc_get_console_cursor_info = kernel32.NewProc("GetConsoleCursorInfo") proc_read_console_input = kernel32.NewProc("ReadConsoleInputW") proc_get_console_mode = kernel32.NewProc("GetConsoleMode") proc_set_console_mode = kernel32.NewProc("SetConsoleMode") proc_fill_console_output_character = kernel32.NewProc("FillConsoleOutputCharacterW") proc_fill_console_output_attribute = kernel32.NewProc("FillConsoleOutputAttribute") proc_create_event = kernel32.NewProc("CreateEventW") proc_wait_for_multiple_objects = kernel32.NewProc("WaitForMultipleObjects") proc_set_event = kernel32.NewProc("SetEvent") ) func set_console_active_screen_buffer(h syscall.Handle) (err error) { r0, _, e1 := syscall.Syscall(proc_set_console_active_screen_buffer.Addr(), 1, uintptr(h), 0, 0) if int(r0) == 0 { if e1 != 0 { err = error(e1) } else { err = syscall.EINVAL } } return } func set_console_screen_buffer_size(h syscall.Handle, size coord) (err error) { r0, _, e1 := syscall.Syscall(proc_set_console_screen_buffer_size.Addr(), 2, uintptr(h), size.uintptr(), 0) if int(r0) == 0 { if e1 != 0 { err = error(e1) } else { err = syscall.EINVAL } } return } func create_console_screen_buffer() (h syscall.Handle, err error) { r0, _, e1 := syscall.Syscall6(proc_create_console_screen_buffer.Addr(), 5, uintptr(generic_read|generic_write), 0, 0, console_textmode_buffer, 0, 0) if int(r0) == 0 { if e1 != 0 { err = error(e1) } else { err = syscall.EINVAL } } return syscall.Handle(r0), err } func get_console_screen_buffer_info(h syscall.Handle, info *console_screen_buffer_info) (err error) { r0, _, e1 := syscall.Syscall(proc_get_console_screen_buffer_info.Addr(), 2, uintptr(h), uintptr(unsafe.Pointer(info)), 0) if int(r0) == 0 { if e1 != 0 { err = error(e1) } else { err = syscall.EINVAL } } return } func write_console_output(h syscall.Handle, chars []char_info, dst small_rect) (err error) { tmp_coord = coord{dst.right - dst.left + 1, dst.bottom - dst.top + 1} tmp_rect = dst r0, _, e1 := syscall.Syscall6(proc_write_console_output.Addr(), 5, uintptr(h), uintptr(unsafe.Pointer(&chars[0])), tmp_coord.uintptr(), tmp_coord0.uintptr(), uintptr(unsafe.Pointer(&tmp_rect)), 0) if int(r0) == 0 { if e1 != 0 { err = error(e1) } else { err = syscall.EINVAL } } return } func write_console_output_character(h syscall.Handle, chars []wchar, pos coord) (err error) { r0, _, e1 := syscall.Syscall6(proc_write_console_output_character.Addr(), 5, uintptr(h), uintptr(unsafe.Pointer(&chars[0])), uintptr(len(chars)), pos.uintptr(), uintptr(unsafe.Pointer(&tmp_arg)), 0) if int(r0) == 0 { if e1 != 0 { err = error(e1) } else { err = syscall.EINVAL } } return } func write_console_output_attribute(h syscall.Handle, attrs []word, pos coord) (err error) { r0, _, e1 := syscall.Syscall6(proc_write_console_output_attribute.Addr(), 5, uintptr(h), uintptr(unsafe.Pointer(&attrs[0])), uintptr(len(attrs)), pos.uintptr(), uintptr(unsafe.Pointer(&tmp_arg)), 0) if int(r0) == 0 { if e1 != 0 { err = error(e1) } else { err = syscall.EINVAL } } return } func set_console_cursor_info(h syscall.Handle, info *console_cursor_info) (err error) { r0, _, e1 := syscall.Syscall(proc_set_console_cursor_info.Addr(), 2, uintptr(h), uintptr(unsafe.Pointer(info)), 0) if int(r0) == 0 { if e1 != 0 { err = error(e1) } else { err = syscall.EINVAL } } return } func get_console_cursor_info(h syscall.Handle, info *console_cursor_info) (err error) { r0, _, e1 := syscall.Syscall(proc_get_console_cursor_info.Addr(), 2, uintptr(h), uintptr(unsafe.Pointer(info)), 0) if int(r0) == 0 { if e1 != 0 { err = error(e1) } else { err = syscall.EINVAL } } return } func set_console_cursor_position(h syscall.Handle, pos coord) (err error) { r0, _, e1 := syscall.Syscall(proc_set_console_cursor_position.Addr(), 2, uintptr(h), pos.uintptr(), 0) if int(r0) == 0 { if e1 != 0 { err = error(e1) } else { err = syscall.EINVAL } } return } func read_console_input(h syscall.Handle, record *input_record) (err error) { r0, _, e1 := syscall.Syscall6(proc_read_console_input.Addr(), 4, uintptr(h), uintptr(unsafe.Pointer(record)), 1, uintptr(unsafe.Pointer(&tmp_arg)), 0, 0) if int(r0) == 0 { if e1 != 0 { err = error(e1) } else { err = syscall.EINVAL } } return } func get_console_mode(h syscall.Handle, mode *dword) (err error) { r0, _, e1 := syscall.Syscall(proc_get_console_mode.Addr(), 2, uintptr(h), uintptr(unsafe.Pointer(mode)), 0) if int(r0) == 0 { if e1 != 0 { err = error(e1) } else { err = syscall.EINVAL } } return } func set_console_mode(h syscall.Handle, mode dword) (err error) { r0, _, e1 := syscall.Syscall(proc_set_console_mode.Addr(), 2, uintptr(h), uintptr(mode), 0) if int(r0) == 0 { if e1 != 0 { err = error(e1) } else { err = syscall.EINVAL } } return } func fill_console_output_character(h syscall.Handle, char wchar, n int) (err error) { r0, _, e1 := syscall.Syscall6(proc_fill_console_output_character.Addr(), 5, uintptr(h), uintptr(char), uintptr(n), tmp_coord.uintptr(), uintptr(unsafe.Pointer(&tmp_arg)), 0) if int(r0) == 0 { if e1 != 0 { err = error(e1) } else { err = syscall.EINVAL } } return } func fill_console_output_attribute(h syscall.Handle, attr word, n int) (err error) { r0, _, e1 := syscall.Syscall6(proc_fill_console_output_attribute.Addr(), 5, uintptr(h), uintptr(attr), uintptr(n), tmp_coord.uintptr(), uintptr(unsafe.Pointer(&tmp_arg)), 0) if int(r0) == 0 { if e1 != 0 { err = error(e1) } else { err = syscall.EINVAL } } return } func create_event() (out syscall.Handle, err error) { r0, _, e1 := syscall.Syscall6(proc_create_event.Addr(), 4, 0, 0, 0, 0, 0, 0) if int(r0) == 0 { if e1 != 0 { err = error(e1) } else { err = syscall.EINVAL } } return syscall.Handle(r0), err } func wait_for_multiple_objects(objects []syscall.Handle) (err error) { r0, _, e1 := syscall.Syscall6(proc_wait_for_multiple_objects.Addr(), 4, uintptr(len(objects)), uintptr(unsafe.Pointer(&objects[0])), 0, 0xFFFFFFFF, 0, 0) if uint32(r0) == 0xFFFFFFFF { if e1 != 0 { err = error(e1) } else { err = syscall.EINVAL } } return } func set_event(ev syscall.Handle) (err error) { r0, _, e1 := syscall.Syscall(proc_set_event.Addr(), 1, uintptr(ev), 0, 0) if int(r0) == 0 { if e1 != 0 { err = error(e1) } else { err = syscall.EINVAL } } return } type diff_msg struct { pos short lines short chars []char_info } type input_event struct { event Event err error } var ( orig_cursor_info console_cursor_info orig_size coord orig_mode dword orig_screen syscall.Handle back_buffer cellbuf front_buffer cellbuf term_size coord input_mode = InputEsc cursor_x = cursor_hidden cursor_y = cursor_hidden foreground = ColorDefault background = ColorDefault in syscall.Handle out syscall.Handle interrupt syscall.Handle charbuf []char_info diffbuf []diff_msg beg_x = -1 beg_y = -1 beg_i = -1 input_comm = make(chan Event) interrupt_comm = make(chan struct{}) cancel_comm = make(chan bool, 1) cancel_done_comm = make(chan bool) alt_mode_esc = false // these ones just to prevent heap allocs at all costs tmp_info console_screen_buffer_info tmp_arg dword tmp_coord0 = coord{0, 0} tmp_coord = coord{0, 0} tmp_rect = small_rect{0, 0, 0, 0} ) func get_cursor_position(out syscall.Handle) coord { err := get_console_screen_buffer_info(out, &tmp_info) if err != nil { panic(err) } return tmp_info.cursor_position } func get_term_size(out syscall.Handle) coord { err := get_console_screen_buffer_info(out, &tmp_info) if err != nil { panic(err) } return tmp_info.size } func get_win_size(out syscall.Handle) coord { err := get_console_screen_buffer_info(out, &tmp_info) if err != nil { panic(err) } return coord{ x: tmp_info.window.right - tmp_info.window.left + 1, y: tmp_info.window.bottom - tmp_info.window.top + 1, } } func update_size_maybe() { size := get_term_size(out) if size.x != term_size.x || size.y != term_size.y { term_size = size back_buffer.resize(int(size.x), int(size.y)) front_buffer.resize(int(size.x), int(size.y)) front_buffer.clear() clear() area := int(size.x) * int(size.y) if cap(charbuf) < area { charbuf = make([]char_info, 0, area) } } } var color_table_bg = []word{ 0, // default (black) 0, // black background_red, background_green, background_red | background_green, // yellow background_blue, background_red | background_blue, // magenta background_green | background_blue, // cyan background_red | background_blue | background_green, // white } var color_table_fg = []word{ foreground_red | foreground_blue | foreground_green, // default (white) 0, foreground_red, foreground_green, foreground_red | foreground_green, // yellow foreground_blue, foreground_red | foreground_blue, // magenta foreground_green | foreground_blue, // cyan foreground_red | foreground_blue | foreground_green, // white } const ( replacement_char = '\uFFFD' max_rune = '\U0010FFFF' surr1 = 0xd800 surr2 = 0xdc00 surr3 = 0xe000 surr_self = 0x10000 ) func append_diff_line(y int) int { n := 0 for x := 0; x < front_buffer.width; { cell_offset := y*front_buffer.width + x back := &back_buffer.cells[cell_offset] front := &front_buffer.cells[cell_offset] attr, char := cell_to_char_info(*back) charbuf = append(charbuf, char_info{attr: attr, char: char[0]}) *front = *back n++ w := runewidth.RuneWidth(back.Ch) if w == 0 || w == 2 && runewidth.IsAmbiguousWidth(back.Ch) { w = 1 } x += w // If not CJK, fill trailing space with whitespace if !is_cjk && w == 2 { charbuf = append(charbuf, char_info{attr: attr, char: ' '}) } } return n } // compares 'back_buffer' with 'front_buffer' and prepares all changes in the form of // 'diff_msg's in the 'diff_buf' func prepare_diff_messages() { // clear buffers diffbuf = diffbuf[:0] charbuf = charbuf[:0] var diff diff_msg gbeg := 0 for y := 0; y < front_buffer.height; y++ { same := true line_offset := y * front_buffer.width for x := 0; x < front_buffer.width; x++ { cell_offset := line_offset + x back := &back_buffer.cells[cell_offset] front := &front_buffer.cells[cell_offset] if *back != *front { same = false break } } if same && diff.lines > 0 { diffbuf = append(diffbuf, diff) diff = diff_msg{} } if !same { beg := len(charbuf) end := beg + append_diff_line(y) if diff.lines == 0 { diff.pos = short(y) gbeg = beg } diff.lines++ diff.chars = charbuf[gbeg:end] } } if diff.lines > 0 { diffbuf = append(diffbuf, diff) diff = diff_msg{} } } func get_ct(table []word, idx int) word { idx = idx & 0x0F if idx >= len(table) { idx = len(table) - 1 } return table[idx] } func cell_to_char_info(c Cell) (attr word, wc [2]wchar) { attr = get_ct(color_table_fg, int(c.Fg)) | get_ct(color_table_bg, int(c.Bg)) if c.Fg&AttrReverse|c.Bg&AttrReverse != 0 { attr = (attr&0xF0)>>4 | (attr&0x0F)<<4 } if c.Fg&AttrBold != 0 { attr |= foreground_intensity } if c.Bg&AttrBold != 0 { attr |= background_intensity } r0, r1 := utf16.EncodeRune(c.Ch) if r0 == 0xFFFD { wc[0] = wchar(c.Ch) wc[1] = ' ' } else { wc[0] = wchar(r0) wc[1] = wchar(r1) } return } func move_cursor(x, y int) { err := set_console_cursor_position(out, coord{short(x), short(y)}) if err != nil { panic(err) } } func show_cursor(visible bool) { var v int32 if visible { v = 1 } var info console_cursor_info info.size = 100 info.visible = v err := set_console_cursor_info(out, &info) if err != nil { panic(err) } } func clear() { var err error attr, char := cell_to_char_info(Cell{ ' ', foreground, background, }) area := int(term_size.x) * int(term_size.y) err = fill_console_output_attribute(out, attr, area) if err != nil { panic(err) } err = fill_console_output_character(out, char[0], area) if err != nil { panic(err) } if !is_cursor_hidden(cursor_x, cursor_y) { move_cursor(cursor_x, cursor_y) } } func key_event_record_to_event(r *key_event_record) (Event, bool) { if r.key_down == 0 { return Event{}, false } e := Event{Type: EventKey} if input_mode&InputAlt != 0 { if alt_mode_esc { e.Mod = ModAlt alt_mode_esc = false } if r.control_key_state&(left_alt_pressed|right_alt_pressed) != 0 { e.Mod = ModAlt } } ctrlpressed := r.control_key_state&(left_ctrl_pressed|right_ctrl_pressed) != 0 if r.virtual_key_code >= vk_f1 && r.virtual_key_code <= vk_f12 { switch r.virtual_key_code { case vk_f1: e.Key = KeyF1 case vk_f2: e.Key = KeyF2 case vk_f3: e.Key = KeyF3 case vk_f4: e.Key = KeyF4 case vk_f5: e.Key = KeyF5 case vk_f6: e.Key = KeyF6 case vk_f7: e.Key = KeyF7 case vk_f8: e.Key = KeyF8 case vk_f9: e.Key = KeyF9 case vk_f10: e.Key = KeyF10 case vk_f11: e.Key = KeyF11 case vk_f12: e.Key = KeyF12 default: panic("unreachable") } return e, true } if r.virtual_key_code <= vk_delete { switch r.virtual_key_code { case vk_insert: e.Key = KeyInsert case vk_delete: e.Key = KeyDelete case vk_home: e.Key = KeyHome case vk_end: e.Key = KeyEnd case vk_pgup: e.Key = KeyPgup case vk_pgdn: e.Key = KeyPgdn case vk_arrow_up: e.Key = KeyArrowUp case vk_arrow_down: e.Key = KeyArrowDown case vk_arrow_left: e.Key = KeyArrowLeft case vk_arrow_right: e.Key = KeyArrowRight case vk_backspace: if ctrlpressed { e.Key = KeyBackspace2 } else { e.Key = KeyBackspace } case vk_tab: e.Key = KeyTab case vk_enter: e.Key = KeyEnter case vk_esc: switch { case input_mode&InputEsc != 0: e.Key = KeyEsc case input_mode&InputAlt != 0: alt_mode_esc = true return Event{}, false } case vk_space: if ctrlpressed { // manual return here, because KeyCtrlSpace is zero e.Key = KeyCtrlSpace return e, true } else { e.Key = KeySpace } } if e.Key != 0 { return e, true } } if ctrlpressed { if Key(r.unicode_char) >= KeyCtrlA && Key(r.unicode_char) <= KeyCtrlRsqBracket { e.Key = Key(r.unicode_char) if input_mode&InputAlt != 0 && e.Key == KeyEsc { alt_mode_esc = true return Event{}, false } return e, true } switch r.virtual_key_code { case 192, 50: // manual return here, because KeyCtrl2 is zero e.Key = KeyCtrl2 return e, true case 51: if input_mode&InputAlt != 0 { alt_mode_esc = true return Event{}, false } e.Key = KeyCtrl3 case 52: e.Key = KeyCtrl4 case 53: e.Key = KeyCtrl5 case 54: e.Key = KeyCtrl6 case 189, 191, 55: e.Key = KeyCtrl7 case 8, 56: e.Key = KeyCtrl8 } if e.Key != 0 { return e, true } } if r.unicode_char != 0 { e.Ch = rune(r.unicode_char) return e, true } return Event{}, false } func input_event_producer() { var r input_record var err error var last_button Key var last_button_pressed Key var last_state = dword(0) var last_x, last_y = -1, -1 handles := []syscall.Handle{in, interrupt} for { err = wait_for_multiple_objects(handles) if err != nil { input_comm <- Event{Type: EventError, Err: err} } select { case <-cancel_comm: cancel_done_comm <- true return default: } err = read_console_input(in, &r) if err != nil { input_comm <- Event{Type: EventError, Err: err} } switch r.event_type { case key_event: kr := (*key_event_record)(unsafe.Pointer(&r.event)) ev, ok := key_event_record_to_event(kr) if ok { for i := 0; i < int(kr.repeat_count); i++ { input_comm <- ev } } case window_buffer_size_event: sr := *(*window_buffer_size_record)(unsafe.Pointer(&r.event)) input_comm <- Event{ Type: EventResize, Width: int(sr.size.x), Height: int(sr.size.y), } case mouse_event: mr := *(*mouse_event_record)(unsafe.Pointer(&r.event)) ev := Event{Type: EventMouse} switch mr.event_flags { case 0, 2: // single or double click cur_state := mr.button_state switch { case last_state&mouse_lmb == 0 && cur_state&mouse_lmb != 0: last_button = MouseLeft last_button_pressed = last_button case last_state&mouse_rmb == 0 && cur_state&mouse_rmb != 0: last_button = MouseRight last_button_pressed = last_button case last_state&mouse_mmb == 0 && cur_state&mouse_mmb != 0: last_button = MouseMiddle last_button_pressed = last_button case last_state&mouse_lmb != 0 && cur_state&mouse_lmb == 0: last_button = MouseRelease case last_state&mouse_rmb != 0 && cur_state&mouse_rmb == 0: last_button = MouseRelease case last_state&mouse_mmb != 0 && cur_state&mouse_mmb == 0: last_button = MouseRelease default: last_state = cur_state continue } last_state = cur_state ev.Key = last_button last_x, last_y = int(mr.mouse_pos.x), int(mr.mouse_pos.y) ev.MouseX = last_x ev.MouseY = last_y case 1: // mouse motion x, y := int(mr.mouse_pos.x), int(mr.mouse_pos.y) if last_state != 0 && (last_x != x || last_y != y) { ev.Key = last_button_pressed ev.Mod = ModMotion ev.MouseX = x ev.MouseY = y last_x, last_y = x, y } else { ev.Type = EventNone } case 4: // mouse wheel n := int16(mr.button_state >> 16) if n > 0 { ev.Key = MouseWheelUp } else { ev.Key = MouseWheelDown } last_x, last_y = int(mr.mouse_pos.x), int(mr.mouse_pos.y) ev.MouseX = last_x ev.MouseY = last_y default: ev.Type = EventNone } if ev.Type != EventNone { input_comm <- ev } } } } mongo-tools-r3.6.3/vendor/src/github.com/nsf/termbox-go/terminfo.go000066400000000000000000000124751321131462300253350ustar00rootroot00000000000000// +build !windows // This file contains a simple and incomplete implementation of the terminfo // database. Information was taken from the ncurses manpages term(5) and // terminfo(5). Currently, only the string capabilities for special keys and for // functions without parameters are actually used. Colors are still done with // ANSI escape sequences. Other special features that are not (yet?) supported // are reading from ~/.terminfo, the TERMINFO_DIRS variable, Berkeley database // format and extended capabilities. package termbox import ( "bytes" "encoding/binary" "encoding/hex" "errors" "fmt" "io/ioutil" "os" "strings" ) const ( ti_magic = 0432 ti_header_length = 12 ti_mouse_enter = "\x1b[?1000h\x1b[?1002h\x1b[?1015h\x1b[?1006h" ti_mouse_leave = "\x1b[?1006l\x1b[?1015l\x1b[?1002l\x1b[?1000l" ) func load_terminfo() ([]byte, error) { var data []byte var err error term := os.Getenv("TERM") if term == "" { return nil, fmt.Errorf("termbox: TERM not set") } // The following behaviour follows the one described in terminfo(5) as // distributed by ncurses. terminfo := os.Getenv("TERMINFO") if terminfo != "" { // if TERMINFO is set, no other directory should be searched return ti_try_path(terminfo) } // next, consider ~/.terminfo home := os.Getenv("HOME") if home != "" { data, err = ti_try_path(home + "/.terminfo") if err == nil { return data, nil } } // next, TERMINFO_DIRS dirs := os.Getenv("TERMINFO_DIRS") if dirs != "" { for _, dir := range strings.Split(dirs, ":") { if dir == "" { // "" -> "/usr/share/terminfo" dir = "/usr/share/terminfo" } data, err = ti_try_path(dir) if err == nil { return data, nil } } } // fall back to /usr/share/terminfo return ti_try_path("/usr/share/terminfo") } func ti_try_path(path string) (data []byte, err error) { // load_terminfo already made sure it is set term := os.Getenv("TERM") // first try, the typical *nix path terminfo := path + "/" + term[0:1] + "/" + term data, err = ioutil.ReadFile(terminfo) if err == nil { return } // fallback to darwin specific dirs structure terminfo = path + "/" + hex.EncodeToString([]byte(term[:1])) + "/" + term data, err = ioutil.ReadFile(terminfo) return } func setup_term_builtin() error { name := os.Getenv("TERM") if name == "" { return errors.New("termbox: TERM environment variable not set") } for _, t := range terms { if t.name == name { keys = t.keys funcs = t.funcs return nil } } compat_table := []struct { partial string keys []string funcs []string }{ {"xterm", xterm_keys, xterm_funcs}, {"rxvt", rxvt_unicode_keys, rxvt_unicode_funcs}, {"linux", linux_keys, linux_funcs}, {"Eterm", eterm_keys, eterm_funcs}, {"screen", screen_keys, screen_funcs}, // let's assume that 'cygwin' is xterm compatible {"cygwin", xterm_keys, xterm_funcs}, {"st", xterm_keys, xterm_funcs}, } // try compatibility variants for _, it := range compat_table { if strings.Contains(name, it.partial) { keys = it.keys funcs = it.funcs return nil } } return errors.New("termbox: unsupported terminal") } func setup_term() (err error) { var data []byte var header [6]int16 var str_offset, table_offset int16 data, err = load_terminfo() if err != nil { return setup_term_builtin() } rd := bytes.NewReader(data) // 0: magic number, 1: size of names section, 2: size of boolean section, 3: // size of numbers section (in integers), 4: size of the strings section (in // integers), 5: size of the string table err = binary.Read(rd, binary.LittleEndian, header[:]) if err != nil { return } if (header[1]+header[2])%2 != 0 { // old quirk to align everything on word boundaries header[2] += 1 } str_offset = ti_header_length + header[1] + header[2] + 2*header[3] table_offset = str_offset + 2*header[4] keys = make([]string, 0xFFFF-key_min) for i, _ := range keys { keys[i], err = ti_read_string(rd, str_offset+2*ti_keys[i], table_offset) if err != nil { return } } funcs = make([]string, t_max_funcs) // the last two entries are reserved for mouse. because the table offset is // not there, the two entries have to fill in manually for i, _ := range funcs[:len(funcs)-2] { funcs[i], err = ti_read_string(rd, str_offset+2*ti_funcs[i], table_offset) if err != nil { return } } funcs[t_max_funcs-2] = ti_mouse_enter funcs[t_max_funcs-1] = ti_mouse_leave return nil } func ti_read_string(rd *bytes.Reader, str_off, table int16) (string, error) { var off int16 _, err := rd.Seek(int64(str_off), 0) if err != nil { return "", err } err = binary.Read(rd, binary.LittleEndian, &off) if err != nil { return "", err } _, err = rd.Seek(int64(table+off), 0) if err != nil { return "", err } var bs []byte for { b, err := rd.ReadByte() if err != nil { return "", err } if b == byte(0x00) { break } bs = append(bs, b) } return string(bs), nil } // "Maps" the function constants from termbox.go to the number of the respective // string capability in the terminfo file. Taken from (ncurses) term.h. var ti_funcs = []int16{ 28, 40, 16, 13, 5, 39, 36, 27, 26, 34, 89, 88, } // Same as above for the special keys. var ti_keys = []int16{ 66, 68 /* apparently not a typo; 67 is F10 for whatever reason */, 69, 70, 71, 72, 73, 74, 75, 67, 216, 217, 77, 59, 76, 164, 82, 81, 87, 61, 79, 83, } mongo-tools-r3.6.3/vendor/src/github.com/nsf/termbox-go/terminfo_builtin.go000066400000000000000000000065431321131462300270620ustar00rootroot00000000000000// +build !windows package termbox // Eterm var eterm_keys = []string{ "\x1b[11~", "\x1b[12~", "\x1b[13~", "\x1b[14~", "\x1b[15~", "\x1b[17~", "\x1b[18~", "\x1b[19~", "\x1b[20~", "\x1b[21~", "\x1b[23~", "\x1b[24~", "\x1b[2~", "\x1b[3~", "\x1b[7~", "\x1b[8~", "\x1b[5~", "\x1b[6~", "\x1b[A", "\x1b[B", "\x1b[D", "\x1b[C", } var eterm_funcs = []string{ "\x1b7\x1b[?47h", "\x1b[2J\x1b[?47l\x1b8", "\x1b[?25h", "\x1b[?25l", "\x1b[H\x1b[2J", "\x1b[m\x0f", "\x1b[4m", "\x1b[1m", "\x1b[5m", "\x1b[7m", "", "", "", "", } // screen var screen_keys = []string{ "\x1bOP", "\x1bOQ", "\x1bOR", "\x1bOS", "\x1b[15~", "\x1b[17~", "\x1b[18~", "\x1b[19~", "\x1b[20~", "\x1b[21~", "\x1b[23~", "\x1b[24~", "\x1b[2~", "\x1b[3~", "\x1b[1~", "\x1b[4~", "\x1b[5~", "\x1b[6~", "\x1bOA", "\x1bOB", "\x1bOD", "\x1bOC", } var screen_funcs = []string{ "\x1b[?1049h", "\x1b[?1049l", "\x1b[34h\x1b[?25h", "\x1b[?25l", "\x1b[H\x1b[J", "\x1b[m\x0f", "\x1b[4m", "\x1b[1m", "\x1b[5m", "\x1b[7m", "\x1b[?1h\x1b=", "\x1b[?1l\x1b>", ti_mouse_enter, ti_mouse_leave, } // xterm var xterm_keys = []string{ "\x1bOP", "\x1bOQ", "\x1bOR", "\x1bOS", "\x1b[15~", "\x1b[17~", "\x1b[18~", "\x1b[19~", "\x1b[20~", "\x1b[21~", "\x1b[23~", "\x1b[24~", "\x1b[2~", "\x1b[3~", "\x1bOH", "\x1bOF", "\x1b[5~", "\x1b[6~", "\x1bOA", "\x1bOB", "\x1bOD", "\x1bOC", } var xterm_funcs = []string{ "\x1b[?1049h", "\x1b[?1049l", "\x1b[?12l\x1b[?25h", "\x1b[?25l", "\x1b[H\x1b[2J", "\x1b(B\x1b[m", "\x1b[4m", "\x1b[1m", "\x1b[5m", "\x1b[7m", "\x1b[?1h\x1b=", "\x1b[?1l\x1b>", ti_mouse_enter, ti_mouse_leave, } // rxvt-unicode var rxvt_unicode_keys = []string{ "\x1b[11~", "\x1b[12~", "\x1b[13~", "\x1b[14~", "\x1b[15~", "\x1b[17~", "\x1b[18~", "\x1b[19~", "\x1b[20~", "\x1b[21~", "\x1b[23~", "\x1b[24~", "\x1b[2~", "\x1b[3~", "\x1b[7~", "\x1b[8~", "\x1b[5~", "\x1b[6~", "\x1b[A", "\x1b[B", "\x1b[D", "\x1b[C", } var rxvt_unicode_funcs = []string{ "\x1b[?1049h", "\x1b[r\x1b[?1049l", "\x1b[?25h", "\x1b[?25l", "\x1b[H\x1b[2J", "\x1b[m\x1b(B", "\x1b[4m", "\x1b[1m", "\x1b[5m", "\x1b[7m", "\x1b=", "\x1b>", ti_mouse_enter, ti_mouse_leave, } // linux var linux_keys = []string{ "\x1b[[A", "\x1b[[B", "\x1b[[C", "\x1b[[D", "\x1b[[E", "\x1b[17~", "\x1b[18~", "\x1b[19~", "\x1b[20~", "\x1b[21~", "\x1b[23~", "\x1b[24~", "\x1b[2~", "\x1b[3~", "\x1b[1~", "\x1b[4~", "\x1b[5~", "\x1b[6~", "\x1b[A", "\x1b[B", "\x1b[D", "\x1b[C", } var linux_funcs = []string{ "", "", "\x1b[?25h\x1b[?0c", "\x1b[?25l\x1b[?1c", "\x1b[H\x1b[J", "\x1b[0;10m", "\x1b[4m", "\x1b[1m", "\x1b[5m", "\x1b[7m", "", "", "", "", } // rxvt-256color var rxvt_256color_keys = []string{ "\x1b[11~", "\x1b[12~", "\x1b[13~", "\x1b[14~", "\x1b[15~", "\x1b[17~", "\x1b[18~", "\x1b[19~", "\x1b[20~", "\x1b[21~", "\x1b[23~", "\x1b[24~", "\x1b[2~", "\x1b[3~", "\x1b[7~", "\x1b[8~", "\x1b[5~", "\x1b[6~", "\x1b[A", "\x1b[B", "\x1b[D", "\x1b[C", } var rxvt_256color_funcs = []string{ "\x1b7\x1b[?47h", "\x1b[2J\x1b[?47l\x1b8", "\x1b[?25h", "\x1b[?25l", "\x1b[H\x1b[2J", "\x1b[m\x0f", "\x1b[4m", "\x1b[1m", "\x1b[5m", "\x1b[7m", "\x1b=", "\x1b>", ti_mouse_enter, ti_mouse_leave, } var terms = []struct { name string keys []string funcs []string }{ {"Eterm", eterm_keys, eterm_funcs}, {"screen", screen_keys, screen_funcs}, {"xterm", xterm_keys, xterm_funcs}, {"rxvt-unicode", rxvt_unicode_keys, rxvt_unicode_funcs}, {"linux", linux_keys, linux_funcs}, {"rxvt-256color", rxvt_256color_keys, rxvt_256color_funcs}, } mongo-tools-r3.6.3/vendor/src/github.com/patrickmn/000077500000000000000000000000001321131462300222715ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/patrickmn/go-cache/000077500000000000000000000000001321131462300237375ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/patrickmn/go-cache/CONTRIBUTORS000066400000000000000000000005541321131462300256230ustar00rootroot00000000000000This is a list of people who have contributed code to go-cache. They, or their employers, are the copyright holders of the contributed code. Contributed code is subject to the license restrictions listed in LICENSE (as they were when the code was contributed.) Dustin Sallings Jason Mooberry Sergey Shepelev mongo-tools-r3.6.3/vendor/src/github.com/patrickmn/go-cache/LICENSE000066400000000000000000000021151321131462300247430ustar00rootroot00000000000000Copyright (c) 2012-2015 Patrick Mylund Nielsen and the go-cache contributors 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. mongo-tools-r3.6.3/vendor/src/github.com/patrickmn/go-cache/README.md000066400000000000000000000062151321131462300252220ustar00rootroot00000000000000# go-cache go-cache is an in-memory key:value store/cache similar to memcached that is suitable for applications running on a single machine. Its major advantage is that, being essentially a thread-safe `map[string]interface{}` with expiration times, it doesn't need to serialize or transmit its contents over the network. Any object can be stored, for a given duration or forever, and the cache can be safely used by multiple goroutines. Although go-cache isn't meant to be used as a persistent datastore, the entire cache can be saved to and loaded from a file (using `c.Items()` to retrieve the items map to serialize, and `NewFrom()` to create a cache from a deserialized one) to recover from downtime quickly. (See the docs for `NewFrom()` for caveats.) ### Installation `go get github.com/patrickmn/go-cache` ### Usage ```go import ( "fmt" "github.com/patrickmn/go-cache" "time" ) func main() { // Create a cache with a default expiration time of 5 minutes, and which // purges expired items every 30 seconds c := cache.New(5*time.Minute, 30*time.Second) // Set the value of the key "foo" to "bar", with the default expiration time c.Set("foo", "bar", cache.DefaultExpiration) // Set the value of the key "baz" to 42, with no expiration time // (the item won't be removed until it is re-set, or removed using // c.Delete("baz") c.Set("baz", 42, cache.NoExpiration) // Get the string associated with the key "foo" from the cache foo, found := c.Get("foo") if found { fmt.Println(foo) } // Since Go is statically typed, and cache values can be anything, type // assertion is needed when values are being passed to functions that don't // take arbitrary types, (i.e. interface{}). The simplest way to do this for // values which will only be used once--e.g. for passing to another // function--is: foo, found := c.Get("foo") if found { MyFunction(foo.(string)) } // This gets tedious if the value is used several times in the same function. // You might do either of the following instead: if x, found := c.Get("foo"); found { foo := x.(string) // ... } // or var foo string if x, found := c.Get("foo"); found { foo = x.(string) } // ... // foo can then be passed around freely as a string // Want performance? Store pointers! c.Set("foo", &MyStruct, cache.DefaultExpiration) if x, found := c.Get("foo"); found { foo := x.(*MyStruct) // ... } // If you store a reference type like a pointer, slice, map or channel, you // do not need to run Set if you modify the underlying data. The cached // reference points to the same memory, so if you modify a struct whose // pointer you've stored in the cache, retrieving that pointer with Get will // point you to the same data: foo := &MyStruct{Num: 1} c.Set("foo", foo, cache.DefaultExpiration) // ... x, _ := c.Get("foo") foo := x.(*MyStruct) fmt.Println(foo.Num) // ... foo.Num++ // ... x, _ := c.Get("foo") foo := x.(*MyStruct) foo.Println(foo.Num) // will print: // 1 // 2 } ``` ### Reference `godoc` or [http://godoc.org/github.com/patrickmn/go-cache](http://godoc.org/github.com/patrickmn/go-cache) mongo-tools-r3.6.3/vendor/src/github.com/patrickmn/go-cache/cache.go000066400000000000000000000724711321131462300253440ustar00rootroot00000000000000package cache import ( "encoding/gob" "fmt" "io" "os" "runtime" "sync" "time" ) type Item struct { Object interface{} Expiration int64 } // Returns true if the item has expired. func (item Item) Expired() bool { if item.Expiration == 0 { return false } return time.Now().UnixNano() > item.Expiration } const ( // For use with functions that take an expiration time. NoExpiration time.Duration = -1 // For use with functions that take an expiration time. Equivalent to // passing in the same expiration duration as was given to New() or // NewFrom() when the cache was created (e.g. 5 minutes.) DefaultExpiration time.Duration = 0 ) type Cache struct { *cache // If this is confusing, see the comment at the bottom of New() } type cache struct { defaultExpiration time.Duration items map[string]Item mu sync.RWMutex onEvicted func(string, interface{}) janitor *janitor } // Add an item to the cache, replacing any existing item. If the duration is 0 // (DefaultExpiration), the cache's default expiration time is used. If it is -1 // (NoExpiration), the item never expires. func (c *cache) Set(k string, x interface{}, d time.Duration) { // "Inlining" of set var e int64 if d == DefaultExpiration { d = c.defaultExpiration } if d > 0 { e = time.Now().Add(d).UnixNano() } c.mu.Lock() c.items[k] = Item{ Object: x, Expiration: e, } // TODO: Calls to mu.Unlock are currently not deferred because defer // adds ~200 ns (as of go1.) c.mu.Unlock() } func (c *cache) set(k string, x interface{}, d time.Duration) { var e int64 if d == DefaultExpiration { d = c.defaultExpiration } if d > 0 { e = time.Now().Add(d).UnixNano() } c.items[k] = Item{ Object: x, Expiration: e, } } // Add an item to the cache only if an item doesn't already exist for the given // key, or if the existing item has expired. Returns an error otherwise. func (c *cache) Add(k string, x interface{}, d time.Duration) error { c.mu.Lock() _, found := c.get(k) if found { c.mu.Unlock() return fmt.Errorf("Item %s already exists", k) } c.set(k, x, d) c.mu.Unlock() return nil } // Set a new value for the cache key only if it already exists, and the existing // item hasn't expired. Returns an error otherwise. func (c *cache) Replace(k string, x interface{}, d time.Duration) error { c.mu.Lock() _, found := c.get(k) if !found { c.mu.Unlock() return fmt.Errorf("Item %s doesn't exist", k) } c.set(k, x, d) c.mu.Unlock() return nil } // Get an item from the cache. Returns the item or nil, and a bool indicating // whether the key was found. func (c *cache) Get(k string) (interface{}, bool) { c.mu.RLock() // "Inlining" of get and Expired item, found := c.items[k] if !found { c.mu.RUnlock() return nil, false } if item.Expiration > 0 { if time.Now().UnixNano() > item.Expiration { c.mu.RUnlock() return nil, false } } c.mu.RUnlock() return item.Object, true } func (c *cache) get(k string) (interface{}, bool) { item, found := c.items[k] if !found { return nil, false } // "Inlining" of Expired if item.Expiration > 0 { if time.Now().UnixNano() > item.Expiration { return nil, false } } return item.Object, true } // Increment an item of type int, int8, int16, int32, int64, uintptr, uint, // uint8, uint32, or uint64, float32 or float64 by n. Returns an error if the // item's value is not an integer, if it was not found, or if it is not // possible to increment it by n. To retrieve the incremented value, use one // of the specialized methods, e.g. IncrementInt64. func (c *cache) Increment(k string, n int64) error { c.mu.Lock() v, found := c.items[k] if !found || v.Expired() { c.mu.Unlock() return fmt.Errorf("Item %s not found", k) } switch v.Object.(type) { case int: v.Object = v.Object.(int) + int(n) case int8: v.Object = v.Object.(int8) + int8(n) case int16: v.Object = v.Object.(int16) + int16(n) case int32: v.Object = v.Object.(int32) + int32(n) case int64: v.Object = v.Object.(int64) + n case uint: v.Object = v.Object.(uint) + uint(n) case uintptr: v.Object = v.Object.(uintptr) + uintptr(n) case uint8: v.Object = v.Object.(uint8) + uint8(n) case uint16: v.Object = v.Object.(uint16) + uint16(n) case uint32: v.Object = v.Object.(uint32) + uint32(n) case uint64: v.Object = v.Object.(uint64) + uint64(n) case float32: v.Object = v.Object.(float32) + float32(n) case float64: v.Object = v.Object.(float64) + float64(n) default: c.mu.Unlock() return fmt.Errorf("The value for %s is not an integer", k) } c.items[k] = v c.mu.Unlock() return nil } // Increment an item of type float32 or float64 by n. Returns an error if the // item's value is not floating point, if it was not found, or if it is not // possible to increment it by n. Pass a negative number to decrement the // value. To retrieve the incremented value, use one of the specialized methods, // e.g. IncrementFloat64. func (c *cache) IncrementFloat(k string, n float64) error { c.mu.Lock() v, found := c.items[k] if !found || v.Expired() { c.mu.Unlock() return fmt.Errorf("Item %s not found", k) } switch v.Object.(type) { case float32: v.Object = v.Object.(float32) + float32(n) case float64: v.Object = v.Object.(float64) + n default: c.mu.Unlock() return fmt.Errorf("The value for %s does not have type float32 or float64", k) } c.items[k] = v c.mu.Unlock() return nil } // Increment an item of type int by n. Returns an error if the item's value is // not an int, or if it was not found. If there is no error, the incremented // value is returned. func (c *cache) IncrementInt(k string, n int) (int, error) { c.mu.Lock() v, found := c.items[k] if !found || v.Expired() { c.mu.Unlock() return 0, fmt.Errorf("Item %s not found", k) } rv, ok := v.Object.(int) if !ok { c.mu.Unlock() return 0, fmt.Errorf("The value for %s is not an int", k) } nv := rv + n v.Object = nv c.items[k] = v c.mu.Unlock() return nv, nil } // Increment an item of type int8 by n. Returns an error if the item's value is // not an int8, or if it was not found. If there is no error, the incremented // value is returned. func (c *cache) IncrementInt8(k string, n int8) (int8, error) { c.mu.Lock() v, found := c.items[k] if !found || v.Expired() { c.mu.Unlock() return 0, fmt.Errorf("Item %s not found", k) } rv, ok := v.Object.(int8) if !ok { c.mu.Unlock() return 0, fmt.Errorf("The value for %s is not an int8", k) } nv := rv + n v.Object = nv c.items[k] = v c.mu.Unlock() return nv, nil } // Increment an item of type int16 by n. Returns an error if the item's value is // not an int16, or if it was not found. If there is no error, the incremented // value is returned. func (c *cache) IncrementInt16(k string, n int16) (int16, error) { c.mu.Lock() v, found := c.items[k] if !found || v.Expired() { c.mu.Unlock() return 0, fmt.Errorf("Item %s not found", k) } rv, ok := v.Object.(int16) if !ok { c.mu.Unlock() return 0, fmt.Errorf("The value for %s is not an int16", k) } nv := rv + n v.Object = nv c.items[k] = v c.mu.Unlock() return nv, nil } // Increment an item of type int32 by n. Returns an error if the item's value is // not an int32, or if it was not found. If there is no error, the incremented // value is returned. func (c *cache) IncrementInt32(k string, n int32) (int32, error) { c.mu.Lock() v, found := c.items[k] if !found || v.Expired() { c.mu.Unlock() return 0, fmt.Errorf("Item %s not found", k) } rv, ok := v.Object.(int32) if !ok { c.mu.Unlock() return 0, fmt.Errorf("The value for %s is not an int32", k) } nv := rv + n v.Object = nv c.items[k] = v c.mu.Unlock() return nv, nil } // Increment an item of type int64 by n. Returns an error if the item's value is // not an int64, or if it was not found. If there is no error, the incremented // value is returned. func (c *cache) IncrementInt64(k string, n int64) (int64, error) { c.mu.Lock() v, found := c.items[k] if !found || v.Expired() { c.mu.Unlock() return 0, fmt.Errorf("Item %s not found", k) } rv, ok := v.Object.(int64) if !ok { c.mu.Unlock() return 0, fmt.Errorf("The value for %s is not an int64", k) } nv := rv + n v.Object = nv c.items[k] = v c.mu.Unlock() return nv, nil } // Increment an item of type uint by n. Returns an error if the item's value is // not an uint, or if it was not found. If there is no error, the incremented // value is returned. func (c *cache) IncrementUint(k string, n uint) (uint, error) { c.mu.Lock() v, found := c.items[k] if !found || v.Expired() { c.mu.Unlock() return 0, fmt.Errorf("Item %s not found", k) } rv, ok := v.Object.(uint) if !ok { c.mu.Unlock() return 0, fmt.Errorf("The value for %s is not an uint", k) } nv := rv + n v.Object = nv c.items[k] = v c.mu.Unlock() return nv, nil } // Increment an item of type uintptr by n. Returns an error if the item's value // is not an uintptr, or if it was not found. If there is no error, the // incremented value is returned. func (c *cache) IncrementUintptr(k string, n uintptr) (uintptr, error) { c.mu.Lock() v, found := c.items[k] if !found || v.Expired() { c.mu.Unlock() return 0, fmt.Errorf("Item %s not found", k) } rv, ok := v.Object.(uintptr) if !ok { c.mu.Unlock() return 0, fmt.Errorf("The value for %s is not an uintptr", k) } nv := rv + n v.Object = nv c.items[k] = v c.mu.Unlock() return nv, nil } // Increment an item of type uint8 by n. Returns an error if the item's value // is not an uint8, or if it was not found. If there is no error, the // incremented value is returned. func (c *cache) IncrementUint8(k string, n uint8) (uint8, error) { c.mu.Lock() v, found := c.items[k] if !found || v.Expired() { c.mu.Unlock() return 0, fmt.Errorf("Item %s not found", k) } rv, ok := v.Object.(uint8) if !ok { c.mu.Unlock() return 0, fmt.Errorf("The value for %s is not an uint8", k) } nv := rv + n v.Object = nv c.items[k] = v c.mu.Unlock() return nv, nil } // Increment an item of type uint16 by n. Returns an error if the item's value // is not an uint16, or if it was not found. If there is no error, the // incremented value is returned. func (c *cache) IncrementUint16(k string, n uint16) (uint16, error) { c.mu.Lock() v, found := c.items[k] if !found || v.Expired() { c.mu.Unlock() return 0, fmt.Errorf("Item %s not found", k) } rv, ok := v.Object.(uint16) if !ok { c.mu.Unlock() return 0, fmt.Errorf("The value for %s is not an uint16", k) } nv := rv + n v.Object = nv c.items[k] = v c.mu.Unlock() return nv, nil } // Increment an item of type uint32 by n. Returns an error if the item's value // is not an uint32, or if it was not found. If there is no error, the // incremented value is returned. func (c *cache) IncrementUint32(k string, n uint32) (uint32, error) { c.mu.Lock() v, found := c.items[k] if !found || v.Expired() { c.mu.Unlock() return 0, fmt.Errorf("Item %s not found", k) } rv, ok := v.Object.(uint32) if !ok { c.mu.Unlock() return 0, fmt.Errorf("The value for %s is not an uint32", k) } nv := rv + n v.Object = nv c.items[k] = v c.mu.Unlock() return nv, nil } // Increment an item of type uint64 by n. Returns an error if the item's value // is not an uint64, or if it was not found. If there is no error, the // incremented value is returned. func (c *cache) IncrementUint64(k string, n uint64) (uint64, error) { c.mu.Lock() v, found := c.items[k] if !found || v.Expired() { c.mu.Unlock() return 0, fmt.Errorf("Item %s not found", k) } rv, ok := v.Object.(uint64) if !ok { c.mu.Unlock() return 0, fmt.Errorf("The value for %s is not an uint64", k) } nv := rv + n v.Object = nv c.items[k] = v c.mu.Unlock() return nv, nil } // Increment an item of type float32 by n. Returns an error if the item's value // is not an float32, or if it was not found. If there is no error, the // incremented value is returned. func (c *cache) IncrementFloat32(k string, n float32) (float32, error) { c.mu.Lock() v, found := c.items[k] if !found || v.Expired() { c.mu.Unlock() return 0, fmt.Errorf("Item %s not found", k) } rv, ok := v.Object.(float32) if !ok { c.mu.Unlock() return 0, fmt.Errorf("The value for %s is not an float32", k) } nv := rv + n v.Object = nv c.items[k] = v c.mu.Unlock() return nv, nil } // Increment an item of type float64 by n. Returns an error if the item's value // is not an float64, or if it was not found. If there is no error, the // incremented value is returned. func (c *cache) IncrementFloat64(k string, n float64) (float64, error) { c.mu.Lock() v, found := c.items[k] if !found || v.Expired() { c.mu.Unlock() return 0, fmt.Errorf("Item %s not found", k) } rv, ok := v.Object.(float64) if !ok { c.mu.Unlock() return 0, fmt.Errorf("The value for %s is not an float64", k) } nv := rv + n v.Object = nv c.items[k] = v c.mu.Unlock() return nv, nil } // Decrement an item of type int, int8, int16, int32, int64, uintptr, uint, // uint8, uint32, or uint64, float32 or float64 by n. Returns an error if the // item's value is not an integer, if it was not found, or if it is not // possible to decrement it by n. To retrieve the decremented value, use one // of the specialized methods, e.g. DecrementInt64. func (c *cache) Decrement(k string, n int64) error { // TODO: Implement Increment and Decrement more cleanly. // (Cannot do Increment(k, n*-1) for uints.) c.mu.Lock() v, found := c.items[k] if !found || v.Expired() { c.mu.Unlock() return fmt.Errorf("Item not found") } switch v.Object.(type) { case int: v.Object = v.Object.(int) - int(n) case int8: v.Object = v.Object.(int8) - int8(n) case int16: v.Object = v.Object.(int16) - int16(n) case int32: v.Object = v.Object.(int32) - int32(n) case int64: v.Object = v.Object.(int64) - n case uint: v.Object = v.Object.(uint) - uint(n) case uintptr: v.Object = v.Object.(uintptr) - uintptr(n) case uint8: v.Object = v.Object.(uint8) - uint8(n) case uint16: v.Object = v.Object.(uint16) - uint16(n) case uint32: v.Object = v.Object.(uint32) - uint32(n) case uint64: v.Object = v.Object.(uint64) - uint64(n) case float32: v.Object = v.Object.(float32) - float32(n) case float64: v.Object = v.Object.(float64) - float64(n) default: c.mu.Unlock() return fmt.Errorf("The value for %s is not an integer", k) } c.items[k] = v c.mu.Unlock() return nil } // Decrement an item of type float32 or float64 by n. Returns an error if the // item's value is not floating point, if it was not found, or if it is not // possible to decrement it by n. Pass a negative number to decrement the // value. To retrieve the decremented value, use one of the specialized methods, // e.g. DecrementFloat64. func (c *cache) DecrementFloat(k string, n float64) error { c.mu.Lock() v, found := c.items[k] if !found || v.Expired() { c.mu.Unlock() return fmt.Errorf("Item %s not found", k) } switch v.Object.(type) { case float32: v.Object = v.Object.(float32) - float32(n) case float64: v.Object = v.Object.(float64) - n default: c.mu.Unlock() return fmt.Errorf("The value for %s does not have type float32 or float64", k) } c.items[k] = v c.mu.Unlock() return nil } // Decrement an item of type int by n. Returns an error if the item's value is // not an int, or if it was not found. If there is no error, the decremented // value is returned. func (c *cache) DecrementInt(k string, n int) (int, error) { c.mu.Lock() v, found := c.items[k] if !found || v.Expired() { c.mu.Unlock() return 0, fmt.Errorf("Item %s not found", k) } rv, ok := v.Object.(int) if !ok { c.mu.Unlock() return 0, fmt.Errorf("The value for %s is not an int", k) } nv := rv - n v.Object = nv c.items[k] = v c.mu.Unlock() return nv, nil } // Decrement an item of type int8 by n. Returns an error if the item's value is // not an int8, or if it was not found. If there is no error, the decremented // value is returned. func (c *cache) DecrementInt8(k string, n int8) (int8, error) { c.mu.Lock() v, found := c.items[k] if !found || v.Expired() { c.mu.Unlock() return 0, fmt.Errorf("Item %s not found", k) } rv, ok := v.Object.(int8) if !ok { c.mu.Unlock() return 0, fmt.Errorf("The value for %s is not an int8", k) } nv := rv - n v.Object = nv c.items[k] = v c.mu.Unlock() return nv, nil } // Decrement an item of type int16 by n. Returns an error if the item's value is // not an int16, or if it was not found. If there is no error, the decremented // value is returned. func (c *cache) DecrementInt16(k string, n int16) (int16, error) { c.mu.Lock() v, found := c.items[k] if !found || v.Expired() { c.mu.Unlock() return 0, fmt.Errorf("Item %s not found", k) } rv, ok := v.Object.(int16) if !ok { c.mu.Unlock() return 0, fmt.Errorf("The value for %s is not an int16", k) } nv := rv - n v.Object = nv c.items[k] = v c.mu.Unlock() return nv, nil } // Decrement an item of type int32 by n. Returns an error if the item's value is // not an int32, or if it was not found. If there is no error, the decremented // value is returned. func (c *cache) DecrementInt32(k string, n int32) (int32, error) { c.mu.Lock() v, found := c.items[k] if !found || v.Expired() { c.mu.Unlock() return 0, fmt.Errorf("Item %s not found", k) } rv, ok := v.Object.(int32) if !ok { c.mu.Unlock() return 0, fmt.Errorf("The value for %s is not an int32", k) } nv := rv - n v.Object = nv c.items[k] = v c.mu.Unlock() return nv, nil } // Decrement an item of type int64 by n. Returns an error if the item's value is // not an int64, or if it was not found. If there is no error, the decremented // value is returned. func (c *cache) DecrementInt64(k string, n int64) (int64, error) { c.mu.Lock() v, found := c.items[k] if !found || v.Expired() { c.mu.Unlock() return 0, fmt.Errorf("Item %s not found", k) } rv, ok := v.Object.(int64) if !ok { c.mu.Unlock() return 0, fmt.Errorf("The value for %s is not an int64", k) } nv := rv - n v.Object = nv c.items[k] = v c.mu.Unlock() return nv, nil } // Decrement an item of type uint by n. Returns an error if the item's value is // not an uint, or if it was not found. If there is no error, the decremented // value is returned. func (c *cache) DecrementUint(k string, n uint) (uint, error) { c.mu.Lock() v, found := c.items[k] if !found || v.Expired() { c.mu.Unlock() return 0, fmt.Errorf("Item %s not found", k) } rv, ok := v.Object.(uint) if !ok { c.mu.Unlock() return 0, fmt.Errorf("The value for %s is not an uint", k) } nv := rv - n v.Object = nv c.items[k] = v c.mu.Unlock() return nv, nil } // Decrement an item of type uintptr by n. Returns an error if the item's value // is not an uintptr, or if it was not found. If there is no error, the // decremented value is returned. func (c *cache) DecrementUintptr(k string, n uintptr) (uintptr, error) { c.mu.Lock() v, found := c.items[k] if !found || v.Expired() { c.mu.Unlock() return 0, fmt.Errorf("Item %s not found", k) } rv, ok := v.Object.(uintptr) if !ok { c.mu.Unlock() return 0, fmt.Errorf("The value for %s is not an uintptr", k) } nv := rv - n v.Object = nv c.items[k] = v c.mu.Unlock() return nv, nil } // Decrement an item of type uint8 by n. Returns an error if the item's value is // not an uint8, or if it was not found. If there is no error, the decremented // value is returned. func (c *cache) DecrementUint8(k string, n uint8) (uint8, error) { c.mu.Lock() v, found := c.items[k] if !found || v.Expired() { c.mu.Unlock() return 0, fmt.Errorf("Item %s not found", k) } rv, ok := v.Object.(uint8) if !ok { c.mu.Unlock() return 0, fmt.Errorf("The value for %s is not an uint8", k) } nv := rv - n v.Object = nv c.items[k] = v c.mu.Unlock() return nv, nil } // Decrement an item of type uint16 by n. Returns an error if the item's value // is not an uint16, or if it was not found. If there is no error, the // decremented value is returned. func (c *cache) DecrementUint16(k string, n uint16) (uint16, error) { c.mu.Lock() v, found := c.items[k] if !found || v.Expired() { c.mu.Unlock() return 0, fmt.Errorf("Item %s not found", k) } rv, ok := v.Object.(uint16) if !ok { c.mu.Unlock() return 0, fmt.Errorf("The value for %s is not an uint16", k) } nv := rv - n v.Object = nv c.items[k] = v c.mu.Unlock() return nv, nil } // Decrement an item of type uint32 by n. Returns an error if the item's value // is not an uint32, or if it was not found. If there is no error, the // decremented value is returned. func (c *cache) DecrementUint32(k string, n uint32) (uint32, error) { c.mu.Lock() v, found := c.items[k] if !found || v.Expired() { c.mu.Unlock() return 0, fmt.Errorf("Item %s not found", k) } rv, ok := v.Object.(uint32) if !ok { c.mu.Unlock() return 0, fmt.Errorf("The value for %s is not an uint32", k) } nv := rv - n v.Object = nv c.items[k] = v c.mu.Unlock() return nv, nil } // Decrement an item of type uint64 by n. Returns an error if the item's value // is not an uint64, or if it was not found. If there is no error, the // decremented value is returned. func (c *cache) DecrementUint64(k string, n uint64) (uint64, error) { c.mu.Lock() v, found := c.items[k] if !found || v.Expired() { c.mu.Unlock() return 0, fmt.Errorf("Item %s not found", k) } rv, ok := v.Object.(uint64) if !ok { c.mu.Unlock() return 0, fmt.Errorf("The value for %s is not an uint64", k) } nv := rv - n v.Object = nv c.items[k] = v c.mu.Unlock() return nv, nil } // Decrement an item of type float32 by n. Returns an error if the item's value // is not an float32, or if it was not found. If there is no error, the // decremented value is returned. func (c *cache) DecrementFloat32(k string, n float32) (float32, error) { c.mu.Lock() v, found := c.items[k] if !found || v.Expired() { c.mu.Unlock() return 0, fmt.Errorf("Item %s not found", k) } rv, ok := v.Object.(float32) if !ok { c.mu.Unlock() return 0, fmt.Errorf("The value for %s is not an float32", k) } nv := rv - n v.Object = nv c.items[k] = v c.mu.Unlock() return nv, nil } // Decrement an item of type float64 by n. Returns an error if the item's value // is not an float64, or if it was not found. If there is no error, the // decremented value is returned. func (c *cache) DecrementFloat64(k string, n float64) (float64, error) { c.mu.Lock() v, found := c.items[k] if !found || v.Expired() { c.mu.Unlock() return 0, fmt.Errorf("Item %s not found", k) } rv, ok := v.Object.(float64) if !ok { c.mu.Unlock() return 0, fmt.Errorf("The value for %s is not an float64", k) } nv := rv - n v.Object = nv c.items[k] = v c.mu.Unlock() return nv, nil } // Delete an item from the cache. Does nothing if the key is not in the cache. func (c *cache) Delete(k string) { c.mu.Lock() v, evicted := c.delete(k) c.mu.Unlock() if evicted { c.onEvicted(k, v) } } func (c *cache) delete(k string) (interface{}, bool) { if c.onEvicted != nil { if v, found := c.items[k]; found { delete(c.items, k) return v.Object, true } } delete(c.items, k) return nil, false } type keyAndValue struct { key string value interface{} } // Delete all expired items from the cache. func (c *cache) DeleteExpired() { var evictedItems []keyAndValue now := time.Now().UnixNano() c.mu.Lock() for k, v := range c.items { // "Inlining" of expired if v.Expiration > 0 && now > v.Expiration { ov, evicted := c.delete(k) if evicted { evictedItems = append(evictedItems, keyAndValue{k, ov}) } } } c.mu.Unlock() for _, v := range evictedItems { c.onEvicted(v.key, v.value) } } // Sets an (optional) function that is called with the key and value when an // item is evicted from the cache. (Including when it is deleted manually, but // not when it is overwritten.) Set to nil to disable. func (c *cache) OnEvicted(f func(string, interface{})) { c.mu.Lock() c.onEvicted = f c.mu.Unlock() } // Write the cache's items (using Gob) to an io.Writer. // // NOTE: This method is deprecated in favor of c.Items() and NewFrom() (see the // documentation for NewFrom().) func (c *cache) Save(w io.Writer) (err error) { enc := gob.NewEncoder(w) defer func() { if x := recover(); x != nil { err = fmt.Errorf("Error registering item types with Gob library") } }() c.mu.RLock() defer c.mu.RUnlock() for _, v := range c.items { gob.Register(v.Object) } err = enc.Encode(&c.items) return } // Save the cache's items to the given filename, creating the file if it // doesn't exist, and overwriting it if it does. // // NOTE: This method is deprecated in favor of c.Items() and NewFrom() (see the // documentation for NewFrom().) func (c *cache) SaveFile(fname string) error { fp, err := os.Create(fname) if err != nil { return err } err = c.Save(fp) if err != nil { fp.Close() return err } return fp.Close() } // Add (Gob-serialized) cache items from an io.Reader, excluding any items with // keys that already exist (and haven't expired) in the current cache. // // NOTE: This method is deprecated in favor of c.Items() and NewFrom() (see the // documentation for NewFrom().) func (c *cache) Load(r io.Reader) error { dec := gob.NewDecoder(r) items := map[string]Item{} err := dec.Decode(&items) if err == nil { c.mu.Lock() defer c.mu.Unlock() for k, v := range items { ov, found := c.items[k] if !found || ov.Expired() { c.items[k] = v } } } return err } // Load and add cache items from the given filename, excluding any items with // keys that already exist in the current cache. // // NOTE: This method is deprecated in favor of c.Items() and NewFrom() (see the // documentation for NewFrom().) func (c *cache) LoadFile(fname string) error { fp, err := os.Open(fname) if err != nil { return err } err = c.Load(fp) if err != nil { fp.Close() return err } return fp.Close() } // Returns the items in the cache. This may include items that have expired, // but have not yet been cleaned up. If this is significant, the Expiration // fields of the items should be checked. Note that explicit synchronization // is needed to use a cache and its corresponding Items() return value at // the same time, as the map is shared. func (c *cache) Items() map[string]Item { c.mu.RLock() defer c.mu.RUnlock() return c.items } // Returns the number of items in the cache. This may include items that have // expired, but have not yet been cleaned up. Equivalent to len(c.Items()). func (c *cache) ItemCount() int { c.mu.RLock() n := len(c.items) c.mu.RUnlock() return n } // Delete all items from the cache. func (c *cache) Flush() { c.mu.Lock() c.items = map[string]Item{} c.mu.Unlock() } type janitor struct { Interval time.Duration stop chan bool } func (j *janitor) Run(c *cache) { j.stop = make(chan bool) ticker := time.NewTicker(j.Interval) for { select { case <-ticker.C: c.DeleteExpired() case <-j.stop: ticker.Stop() return } } } func stopJanitor(c *Cache) { c.janitor.stop <- true } func runJanitor(c *cache, ci time.Duration) { j := &janitor{ Interval: ci, } c.janitor = j go j.Run(c) } func newCache(de time.Duration, m map[string]Item) *cache { if de == 0 { de = -1 } c := &cache{ defaultExpiration: de, items: m, } return c } func newCacheWithJanitor(de time.Duration, ci time.Duration, m map[string]Item) *Cache { c := newCache(de, m) // This trick ensures that the janitor goroutine (which--granted it // was enabled--is running DeleteExpired on c forever) does not keep // the returned C object from being garbage collected. When it is // garbage collected, the finalizer stops the janitor goroutine, after // which c can be collected. C := &Cache{c} if ci > 0 { runJanitor(c, ci) runtime.SetFinalizer(C, stopJanitor) } return C } // Return a new cache with a given default expiration duration and cleanup // interval. If the expiration duration is less than one (or NoExpiration), // the items in the cache never expire (by default), and must be deleted // manually. If the cleanup interval is less than one, expired items are not // deleted from the cache before calling c.DeleteExpired(). func New(defaultExpiration, cleanupInterval time.Duration) *Cache { items := make(map[string]Item) return newCacheWithJanitor(defaultExpiration, cleanupInterval, items) } // Return a new cache with a given default expiration duration and cleanup // interval. If the expiration duration is less than one (or NoExpiration), // the items in the cache never expire (by default), and must be deleted // manually. If the cleanup interval is less than one, expired items are not // deleted from the cache before calling c.DeleteExpired(). // // NewFrom() also accepts an items map which will serve as the underlying map // for the cache. This is useful for starting from a deserialized cache // (serialized using e.g. gob.Encode() on c.Items()), or passing in e.g. // make(map[string]Item, 500) to improve startup performance when the cache // is expected to reach a certain minimum size. // // Only the cache's methods synchronize access to this map, so it is not // recommended to keep any references to the map around after creating a cache. // If need be, the map can be accessed at a later point using c.Items() (subject // to the same caveat.) // // Note regarding serialization: When using e.g. gob, make sure to // gob.Register() the individual types stored in the cache before encoding a // map retrieved with c.Items(), and to register those same types before // decoding a blob containing an items map. func NewFrom(defaultExpiration, cleanupInterval time.Duration, items map[string]Item) *Cache { return newCacheWithJanitor(defaultExpiration, cleanupInterval, items) } mongo-tools-r3.6.3/vendor/src/github.com/patrickmn/go-cache/cache_test.go000066400000000000000000001074571321131462300264060ustar00rootroot00000000000000package cache import ( "bytes" "io/ioutil" "runtime" "strconv" "sync" "testing" "time" ) type TestStruct struct { Num int Children []*TestStruct } func TestCache(t *testing.T) { tc := New(DefaultExpiration, 0) a, found := tc.Get("a") if found || a != nil { t.Error("Getting A found value that shouldn't exist:", a) } b, found := tc.Get("b") if found || b != nil { t.Error("Getting B found value that shouldn't exist:", b) } c, found := tc.Get("c") if found || c != nil { t.Error("Getting C found value that shouldn't exist:", c) } tc.Set("a", 1, DefaultExpiration) tc.Set("b", "b", DefaultExpiration) tc.Set("c", 3.5, DefaultExpiration) x, found := tc.Get("a") if !found { t.Error("a was not found while getting a2") } if x == nil { t.Error("x for a is nil") } else if a2 := x.(int); a2+2 != 3 { t.Error("a2 (which should be 1) plus 2 does not equal 3; value:", a2) } x, found = tc.Get("b") if !found { t.Error("b was not found while getting b2") } if x == nil { t.Error("x for b is nil") } else if b2 := x.(string); b2+"B" != "bB" { t.Error("b2 (which should be b) plus B does not equal bB; value:", b2) } x, found = tc.Get("c") if !found { t.Error("c was not found while getting c2") } if x == nil { t.Error("x for c is nil") } else if c2 := x.(float64); c2+1.2 != 4.7 { t.Error("c2 (which should be 3.5) plus 1.2 does not equal 4.7; value:", c2) } } func TestCacheTimes(t *testing.T) { var found bool tc := New(50*time.Millisecond, 1*time.Millisecond) tc.Set("a", 1, DefaultExpiration) tc.Set("b", 2, NoExpiration) tc.Set("c", 3, 20*time.Millisecond) tc.Set("d", 4, 70*time.Millisecond) <-time.After(25 * time.Millisecond) _, found = tc.Get("c") if found { t.Error("Found c when it should have been automatically deleted") } <-time.After(30 * time.Millisecond) _, found = tc.Get("a") if found { t.Error("Found a when it should have been automatically deleted") } _, found = tc.Get("b") if !found { t.Error("Did not find b even though it was set to never expire") } _, found = tc.Get("d") if !found { t.Error("Did not find d even though it was set to expire later than the default") } <-time.After(20 * time.Millisecond) _, found = tc.Get("d") if found { t.Error("Found d when it should have been automatically deleted (later than the default)") } } func TestNewFrom(t *testing.T) { m := map[string]Item{ "a": Item{ Object: 1, Expiration: 0, }, "b": Item{ Object: 2, Expiration: 0, }, } tc := NewFrom(DefaultExpiration, 0, m) a, found := tc.Get("a") if !found { t.Fatal("Did not find a") } if a.(int) != 1 { t.Fatal("a is not 1") } b, found := tc.Get("b") if !found { t.Fatal("Did not find b") } if b.(int) != 2 { t.Fatal("b is not 2") } } func TestStorePointerToStruct(t *testing.T) { tc := New(DefaultExpiration, 0) tc.Set("foo", &TestStruct{Num: 1}, DefaultExpiration) x, found := tc.Get("foo") if !found { t.Fatal("*TestStruct was not found for foo") } foo := x.(*TestStruct) foo.Num++ y, found := tc.Get("foo") if !found { t.Fatal("*TestStruct was not found for foo (second time)") } bar := y.(*TestStruct) if bar.Num != 2 { t.Fatal("TestStruct.Num is not 2") } } func TestIncrementWithInt(t *testing.T) { tc := New(DefaultExpiration, 0) tc.Set("tint", 1, DefaultExpiration) err := tc.Increment("tint", 2) if err != nil { t.Error("Error incrementing:", err) } x, found := tc.Get("tint") if !found { t.Error("tint was not found") } if x.(int) != 3 { t.Error("tint is not 3:", x) } } func TestIncrementWithInt8(t *testing.T) { tc := New(DefaultExpiration, 0) tc.Set("tint8", int8(1), DefaultExpiration) err := tc.Increment("tint8", 2) if err != nil { t.Error("Error incrementing:", err) } x, found := tc.Get("tint8") if !found { t.Error("tint8 was not found") } if x.(int8) != 3 { t.Error("tint8 is not 3:", x) } } func TestIncrementWithInt16(t *testing.T) { tc := New(DefaultExpiration, 0) tc.Set("tint16", int16(1), DefaultExpiration) err := tc.Increment("tint16", 2) if err != nil { t.Error("Error incrementing:", err) } x, found := tc.Get("tint16") if !found { t.Error("tint16 was not found") } if x.(int16) != 3 { t.Error("tint16 is not 3:", x) } } func TestIncrementWithInt32(t *testing.T) { tc := New(DefaultExpiration, 0) tc.Set("tint32", int32(1), DefaultExpiration) err := tc.Increment("tint32", 2) if err != nil { t.Error("Error incrementing:", err) } x, found := tc.Get("tint32") if !found { t.Error("tint32 was not found") } if x.(int32) != 3 { t.Error("tint32 is not 3:", x) } } func TestIncrementWithInt64(t *testing.T) { tc := New(DefaultExpiration, 0) tc.Set("tint64", int64(1), DefaultExpiration) err := tc.Increment("tint64", 2) if err != nil { t.Error("Error incrementing:", err) } x, found := tc.Get("tint64") if !found { t.Error("tint64 was not found") } if x.(int64) != 3 { t.Error("tint64 is not 3:", x) } } func TestIncrementWithUint(t *testing.T) { tc := New(DefaultExpiration, 0) tc.Set("tuint", uint(1), DefaultExpiration) err := tc.Increment("tuint", 2) if err != nil { t.Error("Error incrementing:", err) } x, found := tc.Get("tuint") if !found { t.Error("tuint was not found") } if x.(uint) != 3 { t.Error("tuint is not 3:", x) } } func TestIncrementWithUintptr(t *testing.T) { tc := New(DefaultExpiration, 0) tc.Set("tuintptr", uintptr(1), DefaultExpiration) err := tc.Increment("tuintptr", 2) if err != nil { t.Error("Error incrementing:", err) } x, found := tc.Get("tuintptr") if !found { t.Error("tuintptr was not found") } if x.(uintptr) != 3 { t.Error("tuintptr is not 3:", x) } } func TestIncrementWithUint8(t *testing.T) { tc := New(DefaultExpiration, 0) tc.Set("tuint8", uint8(1), DefaultExpiration) err := tc.Increment("tuint8", 2) if err != nil { t.Error("Error incrementing:", err) } x, found := tc.Get("tuint8") if !found { t.Error("tuint8 was not found") } if x.(uint8) != 3 { t.Error("tuint8 is not 3:", x) } } func TestIncrementWithUint16(t *testing.T) { tc := New(DefaultExpiration, 0) tc.Set("tuint16", uint16(1), DefaultExpiration) err := tc.Increment("tuint16", 2) if err != nil { t.Error("Error incrementing:", err) } x, found := tc.Get("tuint16") if !found { t.Error("tuint16 was not found") } if x.(uint16) != 3 { t.Error("tuint16 is not 3:", x) } } func TestIncrementWithUint32(t *testing.T) { tc := New(DefaultExpiration, 0) tc.Set("tuint32", uint32(1), DefaultExpiration) err := tc.Increment("tuint32", 2) if err != nil { t.Error("Error incrementing:", err) } x, found := tc.Get("tuint32") if !found { t.Error("tuint32 was not found") } if x.(uint32) != 3 { t.Error("tuint32 is not 3:", x) } } func TestIncrementWithUint64(t *testing.T) { tc := New(DefaultExpiration, 0) tc.Set("tuint64", uint64(1), DefaultExpiration) err := tc.Increment("tuint64", 2) if err != nil { t.Error("Error incrementing:", err) } x, found := tc.Get("tuint64") if !found { t.Error("tuint64 was not found") } if x.(uint64) != 3 { t.Error("tuint64 is not 3:", x) } } func TestIncrementWithFloat32(t *testing.T) { tc := New(DefaultExpiration, 0) tc.Set("float32", float32(1.5), DefaultExpiration) err := tc.Increment("float32", 2) if err != nil { t.Error("Error incrementing:", err) } x, found := tc.Get("float32") if !found { t.Error("float32 was not found") } if x.(float32) != 3.5 { t.Error("float32 is not 3.5:", x) } } func TestIncrementWithFloat64(t *testing.T) { tc := New(DefaultExpiration, 0) tc.Set("float64", float64(1.5), DefaultExpiration) err := tc.Increment("float64", 2) if err != nil { t.Error("Error incrementing:", err) } x, found := tc.Get("float64") if !found { t.Error("float64 was not found") } if x.(float64) != 3.5 { t.Error("float64 is not 3.5:", x) } } func TestIncrementFloatWithFloat32(t *testing.T) { tc := New(DefaultExpiration, 0) tc.Set("float32", float32(1.5), DefaultExpiration) err := tc.IncrementFloat("float32", 2) if err != nil { t.Error("Error incrementfloating:", err) } x, found := tc.Get("float32") if !found { t.Error("float32 was not found") } if x.(float32) != 3.5 { t.Error("float32 is not 3.5:", x) } } func TestIncrementFloatWithFloat64(t *testing.T) { tc := New(DefaultExpiration, 0) tc.Set("float64", float64(1.5), DefaultExpiration) err := tc.IncrementFloat("float64", 2) if err != nil { t.Error("Error incrementfloating:", err) } x, found := tc.Get("float64") if !found { t.Error("float64 was not found") } if x.(float64) != 3.5 { t.Error("float64 is not 3.5:", x) } } func TestDecrementWithInt(t *testing.T) { tc := New(DefaultExpiration, 0) tc.Set("int", int(5), DefaultExpiration) err := tc.Decrement("int", 2) if err != nil { t.Error("Error decrementing:", err) } x, found := tc.Get("int") if !found { t.Error("int was not found") } if x.(int) != 3 { t.Error("int is not 3:", x) } } func TestDecrementWithInt8(t *testing.T) { tc := New(DefaultExpiration, 0) tc.Set("int8", int8(5), DefaultExpiration) err := tc.Decrement("int8", 2) if err != nil { t.Error("Error decrementing:", err) } x, found := tc.Get("int8") if !found { t.Error("int8 was not found") } if x.(int8) != 3 { t.Error("int8 is not 3:", x) } } func TestDecrementWithInt16(t *testing.T) { tc := New(DefaultExpiration, 0) tc.Set("int16", int16(5), DefaultExpiration) err := tc.Decrement("int16", 2) if err != nil { t.Error("Error decrementing:", err) } x, found := tc.Get("int16") if !found { t.Error("int16 was not found") } if x.(int16) != 3 { t.Error("int16 is not 3:", x) } } func TestDecrementWithInt32(t *testing.T) { tc := New(DefaultExpiration, 0) tc.Set("int32", int32(5), DefaultExpiration) err := tc.Decrement("int32", 2) if err != nil { t.Error("Error decrementing:", err) } x, found := tc.Get("int32") if !found { t.Error("int32 was not found") } if x.(int32) != 3 { t.Error("int32 is not 3:", x) } } func TestDecrementWithInt64(t *testing.T) { tc := New(DefaultExpiration, 0) tc.Set("int64", int64(5), DefaultExpiration) err := tc.Decrement("int64", 2) if err != nil { t.Error("Error decrementing:", err) } x, found := tc.Get("int64") if !found { t.Error("int64 was not found") } if x.(int64) != 3 { t.Error("int64 is not 3:", x) } } func TestDecrementWithUint(t *testing.T) { tc := New(DefaultExpiration, 0) tc.Set("uint", uint(5), DefaultExpiration) err := tc.Decrement("uint", 2) if err != nil { t.Error("Error decrementing:", err) } x, found := tc.Get("uint") if !found { t.Error("uint was not found") } if x.(uint) != 3 { t.Error("uint is not 3:", x) } } func TestDecrementWithUintptr(t *testing.T) { tc := New(DefaultExpiration, 0) tc.Set("uintptr", uintptr(5), DefaultExpiration) err := tc.Decrement("uintptr", 2) if err != nil { t.Error("Error decrementing:", err) } x, found := tc.Get("uintptr") if !found { t.Error("uintptr was not found") } if x.(uintptr) != 3 { t.Error("uintptr is not 3:", x) } } func TestDecrementWithUint8(t *testing.T) { tc := New(DefaultExpiration, 0) tc.Set("uint8", uint8(5), DefaultExpiration) err := tc.Decrement("uint8", 2) if err != nil { t.Error("Error decrementing:", err) } x, found := tc.Get("uint8") if !found { t.Error("uint8 was not found") } if x.(uint8) != 3 { t.Error("uint8 is not 3:", x) } } func TestDecrementWithUint16(t *testing.T) { tc := New(DefaultExpiration, 0) tc.Set("uint16", uint16(5), DefaultExpiration) err := tc.Decrement("uint16", 2) if err != nil { t.Error("Error decrementing:", err) } x, found := tc.Get("uint16") if !found { t.Error("uint16 was not found") } if x.(uint16) != 3 { t.Error("uint16 is not 3:", x) } } func TestDecrementWithUint32(t *testing.T) { tc := New(DefaultExpiration, 0) tc.Set("uint32", uint32(5), DefaultExpiration) err := tc.Decrement("uint32", 2) if err != nil { t.Error("Error decrementing:", err) } x, found := tc.Get("uint32") if !found { t.Error("uint32 was not found") } if x.(uint32) != 3 { t.Error("uint32 is not 3:", x) } } func TestDecrementWithUint64(t *testing.T) { tc := New(DefaultExpiration, 0) tc.Set("uint64", uint64(5), DefaultExpiration) err := tc.Decrement("uint64", 2) if err != nil { t.Error("Error decrementing:", err) } x, found := tc.Get("uint64") if !found { t.Error("uint64 was not found") } if x.(uint64) != 3 { t.Error("uint64 is not 3:", x) } } func TestDecrementWithFloat32(t *testing.T) { tc := New(DefaultExpiration, 0) tc.Set("float32", float32(5.5), DefaultExpiration) err := tc.Decrement("float32", 2) if err != nil { t.Error("Error decrementing:", err) } x, found := tc.Get("float32") if !found { t.Error("float32 was not found") } if x.(float32) != 3.5 { t.Error("float32 is not 3:", x) } } func TestDecrementWithFloat64(t *testing.T) { tc := New(DefaultExpiration, 0) tc.Set("float64", float64(5.5), DefaultExpiration) err := tc.Decrement("float64", 2) if err != nil { t.Error("Error decrementing:", err) } x, found := tc.Get("float64") if !found { t.Error("float64 was not found") } if x.(float64) != 3.5 { t.Error("float64 is not 3:", x) } } func TestDecrementFloatWithFloat32(t *testing.T) { tc := New(DefaultExpiration, 0) tc.Set("float32", float32(5.5), DefaultExpiration) err := tc.DecrementFloat("float32", 2) if err != nil { t.Error("Error decrementing:", err) } x, found := tc.Get("float32") if !found { t.Error("float32 was not found") } if x.(float32) != 3.5 { t.Error("float32 is not 3:", x) } } func TestDecrementFloatWithFloat64(t *testing.T) { tc := New(DefaultExpiration, 0) tc.Set("float64", float64(5.5), DefaultExpiration) err := tc.DecrementFloat("float64", 2) if err != nil { t.Error("Error decrementing:", err) } x, found := tc.Get("float64") if !found { t.Error("float64 was not found") } if x.(float64) != 3.5 { t.Error("float64 is not 3:", x) } } func TestIncrementInt(t *testing.T) { tc := New(DefaultExpiration, 0) tc.Set("tint", 1, DefaultExpiration) n, err := tc.IncrementInt("tint", 2) if err != nil { t.Error("Error incrementing:", err) } if n != 3 { t.Error("Returned number is not 3:", n) } x, found := tc.Get("tint") if !found { t.Error("tint was not found") } if x.(int) != 3 { t.Error("tint is not 3:", x) } } func TestIncrementInt8(t *testing.T) { tc := New(DefaultExpiration, 0) tc.Set("tint8", int8(1), DefaultExpiration) n, err := tc.IncrementInt8("tint8", 2) if err != nil { t.Error("Error incrementing:", err) } if n != 3 { t.Error("Returned number is not 3:", n) } x, found := tc.Get("tint8") if !found { t.Error("tint8 was not found") } if x.(int8) != 3 { t.Error("tint8 is not 3:", x) } } func TestIncrementInt16(t *testing.T) { tc := New(DefaultExpiration, 0) tc.Set("tint16", int16(1), DefaultExpiration) n, err := tc.IncrementInt16("tint16", 2) if err != nil { t.Error("Error incrementing:", err) } if n != 3 { t.Error("Returned number is not 3:", n) } x, found := tc.Get("tint16") if !found { t.Error("tint16 was not found") } if x.(int16) != 3 { t.Error("tint16 is not 3:", x) } } func TestIncrementInt32(t *testing.T) { tc := New(DefaultExpiration, 0) tc.Set("tint32", int32(1), DefaultExpiration) n, err := tc.IncrementInt32("tint32", 2) if err != nil { t.Error("Error incrementing:", err) } if n != 3 { t.Error("Returned number is not 3:", n) } x, found := tc.Get("tint32") if !found { t.Error("tint32 was not found") } if x.(int32) != 3 { t.Error("tint32 is not 3:", x) } } func TestIncrementInt64(t *testing.T) { tc := New(DefaultExpiration, 0) tc.Set("tint64", int64(1), DefaultExpiration) n, err := tc.IncrementInt64("tint64", 2) if err != nil { t.Error("Error incrementing:", err) } if n != 3 { t.Error("Returned number is not 3:", n) } x, found := tc.Get("tint64") if !found { t.Error("tint64 was not found") } if x.(int64) != 3 { t.Error("tint64 is not 3:", x) } } func TestIncrementUint(t *testing.T) { tc := New(DefaultExpiration, 0) tc.Set("tuint", uint(1), DefaultExpiration) n, err := tc.IncrementUint("tuint", 2) if err != nil { t.Error("Error incrementing:", err) } if n != 3 { t.Error("Returned number is not 3:", n) } x, found := tc.Get("tuint") if !found { t.Error("tuint was not found") } if x.(uint) != 3 { t.Error("tuint is not 3:", x) } } func TestIncrementUintptr(t *testing.T) { tc := New(DefaultExpiration, 0) tc.Set("tuintptr", uintptr(1), DefaultExpiration) n, err := tc.IncrementUintptr("tuintptr", 2) if err != nil { t.Error("Error incrementing:", err) } if n != 3 { t.Error("Returned number is not 3:", n) } x, found := tc.Get("tuintptr") if !found { t.Error("tuintptr was not found") } if x.(uintptr) != 3 { t.Error("tuintptr is not 3:", x) } } func TestIncrementUint8(t *testing.T) { tc := New(DefaultExpiration, 0) tc.Set("tuint8", uint8(1), DefaultExpiration) n, err := tc.IncrementUint8("tuint8", 2) if err != nil { t.Error("Error incrementing:", err) } if n != 3 { t.Error("Returned number is not 3:", n) } x, found := tc.Get("tuint8") if !found { t.Error("tuint8 was not found") } if x.(uint8) != 3 { t.Error("tuint8 is not 3:", x) } } func TestIncrementUint16(t *testing.T) { tc := New(DefaultExpiration, 0) tc.Set("tuint16", uint16(1), DefaultExpiration) n, err := tc.IncrementUint16("tuint16", 2) if err != nil { t.Error("Error incrementing:", err) } if n != 3 { t.Error("Returned number is not 3:", n) } x, found := tc.Get("tuint16") if !found { t.Error("tuint16 was not found") } if x.(uint16) != 3 { t.Error("tuint16 is not 3:", x) } } func TestIncrementUint32(t *testing.T) { tc := New(DefaultExpiration, 0) tc.Set("tuint32", uint32(1), DefaultExpiration) n, err := tc.IncrementUint32("tuint32", 2) if err != nil { t.Error("Error incrementing:", err) } if n != 3 { t.Error("Returned number is not 3:", n) } x, found := tc.Get("tuint32") if !found { t.Error("tuint32 was not found") } if x.(uint32) != 3 { t.Error("tuint32 is not 3:", x) } } func TestIncrementUint64(t *testing.T) { tc := New(DefaultExpiration, 0) tc.Set("tuint64", uint64(1), DefaultExpiration) n, err := tc.IncrementUint64("tuint64", 2) if err != nil { t.Error("Error incrementing:", err) } if n != 3 { t.Error("Returned number is not 3:", n) } x, found := tc.Get("tuint64") if !found { t.Error("tuint64 was not found") } if x.(uint64) != 3 { t.Error("tuint64 is not 3:", x) } } func TestIncrementFloat32(t *testing.T) { tc := New(DefaultExpiration, 0) tc.Set("float32", float32(1.5), DefaultExpiration) n, err := tc.IncrementFloat32("float32", 2) if err != nil { t.Error("Error incrementing:", err) } if n != 3.5 { t.Error("Returned number is not 3.5:", n) } x, found := tc.Get("float32") if !found { t.Error("float32 was not found") } if x.(float32) != 3.5 { t.Error("float32 is not 3.5:", x) } } func TestIncrementFloat64(t *testing.T) { tc := New(DefaultExpiration, 0) tc.Set("float64", float64(1.5), DefaultExpiration) n, err := tc.IncrementFloat64("float64", 2) if err != nil { t.Error("Error incrementing:", err) } if n != 3.5 { t.Error("Returned number is not 3.5:", n) } x, found := tc.Get("float64") if !found { t.Error("float64 was not found") } if x.(float64) != 3.5 { t.Error("float64 is not 3.5:", x) } } func TestDecrementInt8(t *testing.T) { tc := New(DefaultExpiration, 0) tc.Set("int8", int8(5), DefaultExpiration) n, err := tc.DecrementInt8("int8", 2) if err != nil { t.Error("Error decrementing:", err) } if n != 3 { t.Error("Returned number is not 3:", n) } x, found := tc.Get("int8") if !found { t.Error("int8 was not found") } if x.(int8) != 3 { t.Error("int8 is not 3:", x) } } func TestDecrementInt16(t *testing.T) { tc := New(DefaultExpiration, 0) tc.Set("int16", int16(5), DefaultExpiration) n, err := tc.DecrementInt16("int16", 2) if err != nil { t.Error("Error decrementing:", err) } if n != 3 { t.Error("Returned number is not 3:", n) } x, found := tc.Get("int16") if !found { t.Error("int16 was not found") } if x.(int16) != 3 { t.Error("int16 is not 3:", x) } } func TestDecrementInt32(t *testing.T) { tc := New(DefaultExpiration, 0) tc.Set("int32", int32(5), DefaultExpiration) n, err := tc.DecrementInt32("int32", 2) if err != nil { t.Error("Error decrementing:", err) } if n != 3 { t.Error("Returned number is not 3:", n) } x, found := tc.Get("int32") if !found { t.Error("int32 was not found") } if x.(int32) != 3 { t.Error("int32 is not 3:", x) } } func TestDecrementInt64(t *testing.T) { tc := New(DefaultExpiration, 0) tc.Set("int64", int64(5), DefaultExpiration) n, err := tc.DecrementInt64("int64", 2) if err != nil { t.Error("Error decrementing:", err) } if n != 3 { t.Error("Returned number is not 3:", n) } x, found := tc.Get("int64") if !found { t.Error("int64 was not found") } if x.(int64) != 3 { t.Error("int64 is not 3:", x) } } func TestDecrementUint(t *testing.T) { tc := New(DefaultExpiration, 0) tc.Set("uint", uint(5), DefaultExpiration) n, err := tc.DecrementUint("uint", 2) if err != nil { t.Error("Error decrementing:", err) } if n != 3 { t.Error("Returned number is not 3:", n) } x, found := tc.Get("uint") if !found { t.Error("uint was not found") } if x.(uint) != 3 { t.Error("uint is not 3:", x) } } func TestDecrementUintptr(t *testing.T) { tc := New(DefaultExpiration, 0) tc.Set("uintptr", uintptr(5), DefaultExpiration) n, err := tc.DecrementUintptr("uintptr", 2) if err != nil { t.Error("Error decrementing:", err) } if n != 3 { t.Error("Returned number is not 3:", n) } x, found := tc.Get("uintptr") if !found { t.Error("uintptr was not found") } if x.(uintptr) != 3 { t.Error("uintptr is not 3:", x) } } func TestDecrementUint8(t *testing.T) { tc := New(DefaultExpiration, 0) tc.Set("uint8", uint8(5), DefaultExpiration) n, err := tc.DecrementUint8("uint8", 2) if err != nil { t.Error("Error decrementing:", err) } if n != 3 { t.Error("Returned number is not 3:", n) } x, found := tc.Get("uint8") if !found { t.Error("uint8 was not found") } if x.(uint8) != 3 { t.Error("uint8 is not 3:", x) } } func TestDecrementUint16(t *testing.T) { tc := New(DefaultExpiration, 0) tc.Set("uint16", uint16(5), DefaultExpiration) n, err := tc.DecrementUint16("uint16", 2) if err != nil { t.Error("Error decrementing:", err) } if n != 3 { t.Error("Returned number is not 3:", n) } x, found := tc.Get("uint16") if !found { t.Error("uint16 was not found") } if x.(uint16) != 3 { t.Error("uint16 is not 3:", x) } } func TestDecrementUint32(t *testing.T) { tc := New(DefaultExpiration, 0) tc.Set("uint32", uint32(5), DefaultExpiration) n, err := tc.DecrementUint32("uint32", 2) if err != nil { t.Error("Error decrementing:", err) } if n != 3 { t.Error("Returned number is not 3:", n) } x, found := tc.Get("uint32") if !found { t.Error("uint32 was not found") } if x.(uint32) != 3 { t.Error("uint32 is not 3:", x) } } func TestDecrementUint64(t *testing.T) { tc := New(DefaultExpiration, 0) tc.Set("uint64", uint64(5), DefaultExpiration) n, err := tc.DecrementUint64("uint64", 2) if err != nil { t.Error("Error decrementing:", err) } if n != 3 { t.Error("Returned number is not 3:", n) } x, found := tc.Get("uint64") if !found { t.Error("uint64 was not found") } if x.(uint64) != 3 { t.Error("uint64 is not 3:", x) } } func TestDecrementFloat32(t *testing.T) { tc := New(DefaultExpiration, 0) tc.Set("float32", float32(5), DefaultExpiration) n, err := tc.DecrementFloat32("float32", 2) if err != nil { t.Error("Error decrementing:", err) } if n != 3 { t.Error("Returned number is not 3:", n) } x, found := tc.Get("float32") if !found { t.Error("float32 was not found") } if x.(float32) != 3 { t.Error("float32 is not 3:", x) } } func TestDecrementFloat64(t *testing.T) { tc := New(DefaultExpiration, 0) tc.Set("float64", float64(5), DefaultExpiration) n, err := tc.DecrementFloat64("float64", 2) if err != nil { t.Error("Error decrementing:", err) } if n != 3 { t.Error("Returned number is not 3:", n) } x, found := tc.Get("float64") if !found { t.Error("float64 was not found") } if x.(float64) != 3 { t.Error("float64 is not 3:", x) } } func TestAdd(t *testing.T) { tc := New(DefaultExpiration, 0) err := tc.Add("foo", "bar", DefaultExpiration) if err != nil { t.Error("Couldn't add foo even though it shouldn't exist") } err = tc.Add("foo", "baz", DefaultExpiration) if err == nil { t.Error("Successfully added another foo when it should have returned an error") } } func TestReplace(t *testing.T) { tc := New(DefaultExpiration, 0) err := tc.Replace("foo", "bar", DefaultExpiration) if err == nil { t.Error("Replaced foo when it shouldn't exist") } tc.Set("foo", "bar", DefaultExpiration) err = tc.Replace("foo", "bar", DefaultExpiration) if err != nil { t.Error("Couldn't replace existing key foo") } } func TestDelete(t *testing.T) { tc := New(DefaultExpiration, 0) tc.Set("foo", "bar", DefaultExpiration) tc.Delete("foo") x, found := tc.Get("foo") if found { t.Error("foo was found, but it should have been deleted") } if x != nil { t.Error("x is not nil:", x) } } func TestItemCount(t *testing.T) { tc := New(DefaultExpiration, 0) tc.Set("foo", "1", DefaultExpiration) tc.Set("bar", "2", DefaultExpiration) tc.Set("baz", "3", DefaultExpiration) if n := tc.ItemCount(); n != 3 { t.Errorf("Item count is not 3: %d", n) } } func TestFlush(t *testing.T) { tc := New(DefaultExpiration, 0) tc.Set("foo", "bar", DefaultExpiration) tc.Set("baz", "yes", DefaultExpiration) tc.Flush() x, found := tc.Get("foo") if found { t.Error("foo was found, but it should have been deleted") } if x != nil { t.Error("x is not nil:", x) } x, found = tc.Get("baz") if found { t.Error("baz was found, but it should have been deleted") } if x != nil { t.Error("x is not nil:", x) } } func TestIncrementOverflowInt(t *testing.T) { tc := New(DefaultExpiration, 0) tc.Set("int8", int8(127), DefaultExpiration) err := tc.Increment("int8", 1) if err != nil { t.Error("Error incrementing int8:", err) } x, _ := tc.Get("int8") int8 := x.(int8) if int8 != -128 { t.Error("int8 did not overflow as expected; value:", int8) } } func TestIncrementOverflowUint(t *testing.T) { tc := New(DefaultExpiration, 0) tc.Set("uint8", uint8(255), DefaultExpiration) err := tc.Increment("uint8", 1) if err != nil { t.Error("Error incrementing int8:", err) } x, _ := tc.Get("uint8") uint8 := x.(uint8) if uint8 != 0 { t.Error("uint8 did not overflow as expected; value:", uint8) } } func TestDecrementUnderflowUint(t *testing.T) { tc := New(DefaultExpiration, 0) tc.Set("uint8", uint8(0), DefaultExpiration) err := tc.Decrement("uint8", 1) if err != nil { t.Error("Error decrementing int8:", err) } x, _ := tc.Get("uint8") uint8 := x.(uint8) if uint8 != 255 { t.Error("uint8 did not underflow as expected; value:", uint8) } } func TestOnEvicted(t *testing.T) { tc := New(DefaultExpiration, 0) tc.Set("foo", 3, DefaultExpiration) if tc.onEvicted != nil { t.Fatal("tc.onEvicted is not nil") } works := false tc.OnEvicted(func(k string, v interface{}) { if k == "foo" && v.(int) == 3 { works = true } tc.Set("bar", 4, DefaultExpiration) }) tc.Delete("foo") x, _ := tc.Get("bar") if !works { t.Error("works bool not true") } if x.(int) != 4 { t.Error("bar was not 4") } } func TestCacheSerialization(t *testing.T) { tc := New(DefaultExpiration, 0) testFillAndSerialize(t, tc) // Check if gob.Register behaves properly even after multiple gob.Register // on c.Items (many of which will be the same type) testFillAndSerialize(t, tc) } func testFillAndSerialize(t *testing.T, tc *Cache) { tc.Set("a", "a", DefaultExpiration) tc.Set("b", "b", DefaultExpiration) tc.Set("c", "c", DefaultExpiration) tc.Set("expired", "foo", 1*time.Millisecond) tc.Set("*struct", &TestStruct{Num: 1}, DefaultExpiration) tc.Set("[]struct", []TestStruct{ {Num: 2}, {Num: 3}, }, DefaultExpiration) tc.Set("[]*struct", []*TestStruct{ &TestStruct{Num: 4}, &TestStruct{Num: 5}, }, DefaultExpiration) tc.Set("structception", &TestStruct{ Num: 42, Children: []*TestStruct{ &TestStruct{Num: 6174}, &TestStruct{Num: 4716}, }, }, DefaultExpiration) fp := &bytes.Buffer{} err := tc.Save(fp) if err != nil { t.Fatal("Couldn't save cache to fp:", err) } oc := New(DefaultExpiration, 0) err = oc.Load(fp) if err != nil { t.Fatal("Couldn't load cache from fp:", err) } a, found := oc.Get("a") if !found { t.Error("a was not found") } if a.(string) != "a" { t.Error("a is not a") } b, found := oc.Get("b") if !found { t.Error("b was not found") } if b.(string) != "b" { t.Error("b is not b") } c, found := oc.Get("c") if !found { t.Error("c was not found") } if c.(string) != "c" { t.Error("c is not c") } <-time.After(5 * time.Millisecond) _, found = oc.Get("expired") if found { t.Error("expired was found") } s1, found := oc.Get("*struct") if !found { t.Error("*struct was not found") } if s1.(*TestStruct).Num != 1 { t.Error("*struct.Num is not 1") } s2, found := oc.Get("[]struct") if !found { t.Error("[]struct was not found") } s2r := s2.([]TestStruct) if len(s2r) != 2 { t.Error("Length of s2r is not 2") } if s2r[0].Num != 2 { t.Error("s2r[0].Num is not 2") } if s2r[1].Num != 3 { t.Error("s2r[1].Num is not 3") } s3, found := oc.get("[]*struct") if !found { t.Error("[]*struct was not found") } s3r := s3.([]*TestStruct) if len(s3r) != 2 { t.Error("Length of s3r is not 2") } if s3r[0].Num != 4 { t.Error("s3r[0].Num is not 4") } if s3r[1].Num != 5 { t.Error("s3r[1].Num is not 5") } s4, found := oc.get("structception") if !found { t.Error("structception was not found") } s4r := s4.(*TestStruct) if len(s4r.Children) != 2 { t.Error("Length of s4r.Children is not 2") } if s4r.Children[0].Num != 6174 { t.Error("s4r.Children[0].Num is not 6174") } if s4r.Children[1].Num != 4716 { t.Error("s4r.Children[1].Num is not 4716") } } func TestFileSerialization(t *testing.T) { tc := New(DefaultExpiration, 0) tc.Add("a", "a", DefaultExpiration) tc.Add("b", "b", DefaultExpiration) f, err := ioutil.TempFile("", "go-cache-cache.dat") if err != nil { t.Fatal("Couldn't create cache file:", err) } fname := f.Name() f.Close() tc.SaveFile(fname) oc := New(DefaultExpiration, 0) oc.Add("a", "aa", 0) // this should not be overwritten err = oc.LoadFile(fname) if err != nil { t.Error(err) } a, found := oc.Get("a") if !found { t.Error("a was not found") } astr := a.(string) if astr != "aa" { if astr == "a" { t.Error("a was overwritten") } else { t.Error("a is not aa") } } b, found := oc.Get("b") if !found { t.Error("b was not found") } if b.(string) != "b" { t.Error("b is not b") } } func TestSerializeUnserializable(t *testing.T) { tc := New(DefaultExpiration, 0) ch := make(chan bool, 1) ch <- true tc.Set("chan", ch, DefaultExpiration) fp := &bytes.Buffer{} err := tc.Save(fp) // this should fail gracefully if err.Error() != "gob NewTypeObject can't handle type: chan bool" { t.Error("Error from Save was not gob NewTypeObject can't handle type chan bool:", err) } } func BenchmarkCacheGetExpiring(b *testing.B) { benchmarkCacheGet(b, 5*time.Minute) } func BenchmarkCacheGetNotExpiring(b *testing.B) { benchmarkCacheGet(b, NoExpiration) } func benchmarkCacheGet(b *testing.B, exp time.Duration) { b.StopTimer() tc := New(exp, 0) tc.Set("foo", "bar", DefaultExpiration) b.StartTimer() for i := 0; i < b.N; i++ { tc.Get("foo") } } func BenchmarkRWMutexMapGet(b *testing.B) { b.StopTimer() m := map[string]string{ "foo": "bar", } mu := sync.RWMutex{} b.StartTimer() for i := 0; i < b.N; i++ { mu.RLock() _, _ = m["foo"] mu.RUnlock() } } func BenchmarkRWMutexInterfaceMapGetStruct(b *testing.B) { b.StopTimer() s := struct{name string}{name: "foo"} m := map[interface{}]string{ s: "bar", } mu := sync.RWMutex{} b.StartTimer() for i := 0; i < b.N; i++ { mu.RLock() _, _ = m[s] mu.RUnlock() } } func BenchmarkRWMutexInterfaceMapGetString(b *testing.B) { b.StopTimer() m := map[interface{}]string{ "foo": "bar", } mu := sync.RWMutex{} b.StartTimer() for i := 0; i < b.N; i++ { mu.RLock() _, _ = m["foo"] mu.RUnlock() } } func BenchmarkCacheGetConcurrentExpiring(b *testing.B) { benchmarkCacheGetConcurrent(b, 5*time.Minute) } func BenchmarkCacheGetConcurrentNotExpiring(b *testing.B) { benchmarkCacheGetConcurrent(b, NoExpiration) } func benchmarkCacheGetConcurrent(b *testing.B, exp time.Duration) { b.StopTimer() tc := New(exp, 0) tc.Set("foo", "bar", DefaultExpiration) wg := new(sync.WaitGroup) workers := runtime.NumCPU() each := b.N / workers wg.Add(workers) b.StartTimer() for i := 0; i < workers; i++ { go func() { for j := 0; j < each; j++ { tc.Get("foo") } wg.Done() }() } wg.Wait() } func BenchmarkRWMutexMapGetConcurrent(b *testing.B) { b.StopTimer() m := map[string]string{ "foo": "bar", } mu := sync.RWMutex{} wg := new(sync.WaitGroup) workers := runtime.NumCPU() each := b.N / workers wg.Add(workers) b.StartTimer() for i := 0; i < workers; i++ { go func() { for j := 0; j < each; j++ { mu.RLock() _, _ = m["foo"] mu.RUnlock() } wg.Done() }() } wg.Wait() } func BenchmarkCacheGetManyConcurrentExpiring(b *testing.B) { benchmarkCacheGetManyConcurrent(b, 5*time.Minute) } func BenchmarkCacheGetManyConcurrentNotExpiring(b *testing.B) { benchmarkCacheGetManyConcurrent(b, NoExpiration) } func benchmarkCacheGetManyConcurrent(b *testing.B, exp time.Duration) { // This is the same as BenchmarkCacheGetConcurrent, but its result // can be compared against BenchmarkShardedCacheGetManyConcurrent // in sharded_test.go. b.StopTimer() n := 10000 tc := New(exp, 0) keys := make([]string, n) for i := 0; i < n; i++ { k := "foo" + strconv.Itoa(n) keys[i] = k tc.Set(k, "bar", DefaultExpiration) } each := b.N / n wg := new(sync.WaitGroup) wg.Add(n) for _, v := range keys { go func() { for j := 0; j < each; j++ { tc.Get(v) } wg.Done() }() } b.StartTimer() wg.Wait() } func BenchmarkCacheSetExpiring(b *testing.B) { benchmarkCacheSet(b, 5*time.Minute) } func BenchmarkCacheSetNotExpiring(b *testing.B) { benchmarkCacheSet(b, NoExpiration) } func benchmarkCacheSet(b *testing.B, exp time.Duration) { b.StopTimer() tc := New(exp, 0) b.StartTimer() for i := 0; i < b.N; i++ { tc.Set("foo", "bar", DefaultExpiration) } } func BenchmarkRWMutexMapSet(b *testing.B) { b.StopTimer() m := map[string]string{} mu := sync.RWMutex{} b.StartTimer() for i := 0; i < b.N; i++ { mu.Lock() m["foo"] = "bar" mu.Unlock() } } func BenchmarkCacheSetDelete(b *testing.B) { b.StopTimer() tc := New(DefaultExpiration, 0) b.StartTimer() for i := 0; i < b.N; i++ { tc.Set("foo", "bar", DefaultExpiration) tc.Delete("foo") } } func BenchmarkRWMutexMapSetDelete(b *testing.B) { b.StopTimer() m := map[string]string{} mu := sync.RWMutex{} b.StartTimer() for i := 0; i < b.N; i++ { mu.Lock() m["foo"] = "bar" mu.Unlock() mu.Lock() delete(m, "foo") mu.Unlock() } } func BenchmarkCacheSetDeleteSingleLock(b *testing.B) { b.StopTimer() tc := New(DefaultExpiration, 0) b.StartTimer() for i := 0; i < b.N; i++ { tc.mu.Lock() tc.set("foo", "bar", DefaultExpiration) tc.delete("foo") tc.mu.Unlock() } } func BenchmarkRWMutexMapSetDeleteSingleLock(b *testing.B) { b.StopTimer() m := map[string]string{} mu := sync.RWMutex{} b.StartTimer() for i := 0; i < b.N; i++ { mu.Lock() m["foo"] = "bar" delete(m, "foo") mu.Unlock() } } func BenchmarkIncrementInt(b *testing.B) { b.StopTimer() tc := New(DefaultExpiration, 0) tc.Set("foo", 0, DefaultExpiration) b.StartTimer() for i := 0; i < b.N; i++ { tc.IncrementInt("foo", 1) } } func BenchmarkDeleteExpiredLoop(b *testing.B) { b.StopTimer() tc := New(5*time.Minute, 0) tc.mu.Lock() for i := 0; i < 100000; i++ { tc.set(strconv.Itoa(i), "bar", DefaultExpiration) } tc.mu.Unlock() b.StartTimer() for i := 0; i < b.N; i++ { tc.DeleteExpired() } } mongo-tools-r3.6.3/vendor/src/github.com/patrickmn/go-cache/sharded.go000066400000000000000000000107711321131462300257060ustar00rootroot00000000000000package cache import ( "crypto/rand" "math" "math/big" insecurerand "math/rand" "os" "runtime" "time" ) // This is an experimental and unexported (for now) attempt at making a cache // with better algorithmic complexity than the standard one, namely by // preventing write locks of the entire cache when an item is added. As of the // time of writing, the overhead of selecting buckets results in cache // operations being about twice as slow as for the standard cache with small // total cache sizes, and faster for larger ones. // // See cache_test.go for a few benchmarks. type unexportedShardedCache struct { *shardedCache } type shardedCache struct { seed uint32 m uint32 cs []*cache janitor *shardedJanitor } // djb2 with better shuffling. 5x faster than FNV with the hash.Hash overhead. func djb33(seed uint32, k string) uint32 { var ( l = uint32(len(k)) d = 5381 + seed + l i = uint32(0) ) // Why is all this 5x faster than a for loop? if l >= 4 { for i < l-4 { d = (d * 33) ^ uint32(k[i]) d = (d * 33) ^ uint32(k[i+1]) d = (d * 33) ^ uint32(k[i+2]) d = (d * 33) ^ uint32(k[i+3]) i += 4 } } switch l - i { case 1: case 2: d = (d * 33) ^ uint32(k[i]) case 3: d = (d * 33) ^ uint32(k[i]) d = (d * 33) ^ uint32(k[i+1]) case 4: d = (d * 33) ^ uint32(k[i]) d = (d * 33) ^ uint32(k[i+1]) d = (d * 33) ^ uint32(k[i+2]) } return d ^ (d >> 16) } func (sc *shardedCache) bucket(k string) *cache { return sc.cs[djb33(sc.seed, k)%sc.m] } func (sc *shardedCache) Set(k string, x interface{}, d time.Duration) { sc.bucket(k).Set(k, x, d) } func (sc *shardedCache) Add(k string, x interface{}, d time.Duration) error { return sc.bucket(k).Add(k, x, d) } func (sc *shardedCache) Replace(k string, x interface{}, d time.Duration) error { return sc.bucket(k).Replace(k, x, d) } func (sc *shardedCache) Get(k string) (interface{}, bool) { return sc.bucket(k).Get(k) } func (sc *shardedCache) Increment(k string, n int64) error { return sc.bucket(k).Increment(k, n) } func (sc *shardedCache) IncrementFloat(k string, n float64) error { return sc.bucket(k).IncrementFloat(k, n) } func (sc *shardedCache) Decrement(k string, n int64) error { return sc.bucket(k).Decrement(k, n) } func (sc *shardedCache) Delete(k string) { sc.bucket(k).Delete(k) } func (sc *shardedCache) DeleteExpired() { for _, v := range sc.cs { v.DeleteExpired() } } // Returns the items in the cache. This may include items that have expired, // but have not yet been cleaned up. If this is significant, the Expiration // fields of the items should be checked. Note that explicit synchronization // is needed to use a cache and its corresponding Items() return values at // the same time, as the maps are shared. func (sc *shardedCache) Items() []map[string]Item { res := make([]map[string]Item, len(sc.cs)) for i, v := range sc.cs { res[i] = v.Items() } return res } func (sc *shardedCache) Flush() { for _, v := range sc.cs { v.Flush() } } type shardedJanitor struct { Interval time.Duration stop chan bool } func (j *shardedJanitor) Run(sc *shardedCache) { j.stop = make(chan bool) tick := time.Tick(j.Interval) for { select { case <-tick: sc.DeleteExpired() case <-j.stop: return } } } func stopShardedJanitor(sc *unexportedShardedCache) { sc.janitor.stop <- true } func runShardedJanitor(sc *shardedCache, ci time.Duration) { j := &shardedJanitor{ Interval: ci, } sc.janitor = j go j.Run(sc) } func newShardedCache(n int, de time.Duration) *shardedCache { max := big.NewInt(0).SetUint64(uint64(math.MaxUint32)) rnd, err := rand.Int(rand.Reader, max) var seed uint32 if err != nil { os.Stderr.Write([]byte("WARNING: go-cache's newShardedCache failed to read from the system CSPRNG (/dev/urandom or equivalent.) Your system's security may be compromised. Continuing with an insecure seed.\n")) seed = insecurerand.Uint32() } else { seed = uint32(rnd.Uint64()) } sc := &shardedCache{ seed: seed, m: uint32(n), cs: make([]*cache, n), } for i := 0; i < n; i++ { c := &cache{ defaultExpiration: de, items: map[string]Item{}, } sc.cs[i] = c } return sc } func unexportedNewSharded(defaultExpiration, cleanupInterval time.Duration, shards int) *unexportedShardedCache { if defaultExpiration == 0 { defaultExpiration = -1 } sc := newShardedCache(shards, defaultExpiration) SC := &unexportedShardedCache{sc} if cleanupInterval > 0 { runShardedJanitor(sc, cleanupInterval) runtime.SetFinalizer(SC, stopShardedJanitor) } return SC } mongo-tools-r3.6.3/vendor/src/github.com/patrickmn/go-cache/sharded_test.go000066400000000000000000000031621321131462300267410ustar00rootroot00000000000000package cache import ( "strconv" "sync" "testing" "time" ) // func TestDjb33(t *testing.T) { // } var shardedKeys = []string{ "f", "fo", "foo", "barf", "barfo", "foobar", "bazbarf", "bazbarfo", "bazbarfoo", "foobarbazq", "foobarbazqu", "foobarbazquu", "foobarbazquux", } func TestShardedCache(t *testing.T) { tc := unexportedNewSharded(DefaultExpiration, 0, 13) for _, v := range shardedKeys { tc.Set(v, "value", DefaultExpiration) } } func BenchmarkShardedCacheGetExpiring(b *testing.B) { benchmarkShardedCacheGet(b, 5*time.Minute) } func BenchmarkShardedCacheGetNotExpiring(b *testing.B) { benchmarkShardedCacheGet(b, NoExpiration) } func benchmarkShardedCacheGet(b *testing.B, exp time.Duration) { b.StopTimer() tc := unexportedNewSharded(exp, 0, 10) tc.Set("foobarba", "zquux", DefaultExpiration) b.StartTimer() for i := 0; i < b.N; i++ { tc.Get("foobarba") } } func BenchmarkShardedCacheGetManyConcurrentExpiring(b *testing.B) { benchmarkShardedCacheGetManyConcurrent(b, 5*time.Minute) } func BenchmarkShardedCacheGetManyConcurrentNotExpiring(b *testing.B) { benchmarkShardedCacheGetManyConcurrent(b, NoExpiration) } func benchmarkShardedCacheGetManyConcurrent(b *testing.B, exp time.Duration) { b.StopTimer() n := 10000 tsc := unexportedNewSharded(exp, 0, 20) keys := make([]string, n) for i := 0; i < n; i++ { k := "foo" + strconv.Itoa(n) keys[i] = k tsc.Set(k, "bar", DefaultExpiration) } each := b.N / n wg := new(sync.WaitGroup) wg.Add(n) for _, v := range keys { go func() { for j := 0; j < each; j++ { tsc.Get(v) } wg.Done() }() } b.StartTimer() wg.Wait() } mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/000077500000000000000000000000001321131462300232325ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/000077500000000000000000000000001321131462300254245ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/.gitignore000066400000000000000000000000331321131462300274100ustar00rootroot00000000000000.DS_Store Thumbs.db /.idea mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/.travis.yml000066400000000000000000000001611321131462300275330ustar00rootroot00000000000000language: go go: - 1.2 - 1.3 - 1.4 - 1.5 install: - go get -t ./... script: go test -v sudo: false mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/LICENSE.md000066400000000000000000000024211321131462300270270ustar00rootroot00000000000000Copyright (c) 2015 SmartyStreets, LLC 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. NOTE: Various optional and subordinate components carry their own licensing requirements and restrictions. Use of those components is subject to the terms and conditions outlined the respective license of each component. mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/README.md000066400000000000000000000427341321131462300267150ustar00rootroot00000000000000# assertions -- import "github.com/smartystreets/assertions" Package assertions contains the implementations for all assertions which are referenced in goconvey's `convey` package (github.com/smartystreets/goconvey/convey) and gunit (github.com/smartystreets/gunit) for use with the So(...) method. They can also be used in traditional Go test functions and even in applications. Many of the assertions lean heavily on work done by Aaron Jacobs in his excellent oglematchers library. (https://github.com/jacobsa/oglematchers) The ShouldResemble assertion leans heavily on work done by Daniel Jacques in his very helpful go-render library. (https://github.com/luci/go-render) ## Usage #### func GoConveyMode ```go func GoConveyMode(yes bool) ``` GoConveyMode provides control over JSON serialization of failures. When using the assertions in this package from the convey package JSON results are very helpful and can be rendered in a DIFF view. In that case, this function will be called with a true value to enable the JSON serialization. By default, the assertions in this package will not serializer a JSON result, making standalone ussage more convenient. #### func ShouldAlmostEqual ```go func ShouldAlmostEqual(actual interface{}, expected ...interface{}) string ``` ShouldAlmostEqual makes sure that two parameters are close enough to being equal. The acceptable delta may be specified with a third argument, or a very small default delta will be used. #### func ShouldBeBetween ```go func ShouldBeBetween(actual interface{}, expected ...interface{}) string ``` ShouldBeBetween receives exactly three parameters: an actual value, a lower bound, and an upper bound. It ensures that the actual value is between both bounds (but not equal to either of them). #### func ShouldBeBetweenOrEqual ```go func ShouldBeBetweenOrEqual(actual interface{}, expected ...interface{}) string ``` ShouldBeBetweenOrEqual receives exactly three parameters: an actual value, a lower bound, and an upper bound. It ensures that the actual value is between both bounds or equal to one of them. #### func ShouldBeBlank ```go func ShouldBeBlank(actual interface{}, expected ...interface{}) string ``` ShouldBeBlank receives exactly 1 string parameter and ensures that it is equal to "". #### func ShouldBeChronological ```go func ShouldBeChronological(actual interface{}, expected ...interface{}) string ``` ShouldBeChronological receives a []time.Time slice and asserts that the are in chronological order starting with the first time.Time as the earliest. #### func ShouldBeEmpty ```go func ShouldBeEmpty(actual interface{}, expected ...interface{}) string ``` ShouldBeEmpty receives a single parameter (actual) and determines whether or not calling len(actual) would return `0`. It obeys the rules specified by the len function for determining length: http://golang.org/pkg/builtin/#len #### func ShouldBeFalse ```go func ShouldBeFalse(actual interface{}, expected ...interface{}) string ``` ShouldBeFalse receives a single parameter and ensures that it is false. #### func ShouldBeGreaterThan ```go func ShouldBeGreaterThan(actual interface{}, expected ...interface{}) string ``` ShouldBeGreaterThan receives exactly two parameters and ensures that the first is greater than the second. #### func ShouldBeGreaterThanOrEqualTo ```go func ShouldBeGreaterThanOrEqualTo(actual interface{}, expected ...interface{}) string ``` ShouldBeGreaterThanOrEqualTo receives exactly two parameters and ensures that the first is greater than or equal to the second. #### func ShouldBeIn ```go func ShouldBeIn(actual interface{}, expected ...interface{}) string ``` ShouldBeIn receives at least 2 parameters. The first is a proposed member of the collection that is passed in either as the second parameter, or of the collection that is comprised of all the remaining parameters. This assertion ensures that the proposed member is in the collection (using ShouldEqual). #### func ShouldBeLessThan ```go func ShouldBeLessThan(actual interface{}, expected ...interface{}) string ``` ShouldBeLessThan receives exactly two parameters and ensures that the first is less than the second. #### func ShouldBeLessThanOrEqualTo ```go func ShouldBeLessThanOrEqualTo(actual interface{}, expected ...interface{}) string ``` ShouldBeLessThan receives exactly two parameters and ensures that the first is less than or equal to the second. #### func ShouldBeNil ```go func ShouldBeNil(actual interface{}, expected ...interface{}) string ``` ShouldBeNil receives a single parameter and ensures that it is nil. #### func ShouldBeTrue ```go func ShouldBeTrue(actual interface{}, expected ...interface{}) string ``` ShouldBeTrue receives a single parameter and ensures that it is true. #### func ShouldBeZeroValue ```go func ShouldBeZeroValue(actual interface{}, expected ...interface{}) string ``` ShouldBeZeroValue receives a single parameter and ensures that it is the Go equivalent of the default value, or "zero" value. #### func ShouldContain ```go func ShouldContain(actual interface{}, expected ...interface{}) string ``` ShouldContain receives exactly two parameters. The first is a slice and the second is a proposed member. Membership is determined using ShouldEqual. #### func ShouldContainKey ```go func ShouldContainKey(actual interface{}, expected ...interface{}) string ``` ShouldContainKey receives exactly two parameters. The first is a map and the second is a proposed key. Keys are compared with a simple '=='. #### func ShouldContainSubstring ```go func ShouldContainSubstring(actual interface{}, expected ...interface{}) string ``` ShouldContainSubstring receives exactly 2 string parameters and ensures that the first contains the second as a substring. #### func ShouldEndWith ```go func ShouldEndWith(actual interface{}, expected ...interface{}) string ``` ShouldEndWith receives exactly 2 string parameters and ensures that the first ends with the second. #### func ShouldEqual ```go func ShouldEqual(actual interface{}, expected ...interface{}) string ``` ShouldEqual receives exactly two parameters and does an equality check. #### func ShouldEqualTrimSpace ```go func ShouldEqualTrimSpace(actual interface{}, expected ...interface{}) string ``` ShouldEqualTrimSpace receives exactly 2 string parameters and ensures that the first is equal to the second after removing all leading and trailing whitespace using strings.TrimSpace(first). #### func ShouldEqualWithout ```go func ShouldEqualWithout(actual interface{}, expected ...interface{}) string ``` ShouldEqualWithout receives exactly 3 string parameters and ensures that the first is equal to the second after removing all instances of the third from the first using strings.Replace(first, third, "", -1). #### func ShouldHappenAfter ```go func ShouldHappenAfter(actual interface{}, expected ...interface{}) string ``` ShouldHappenAfter receives exactly 2 time.Time arguments and asserts that the first happens after the second. #### func ShouldHappenBefore ```go func ShouldHappenBefore(actual interface{}, expected ...interface{}) string ``` ShouldHappenBefore receives exactly 2 time.Time arguments and asserts that the first happens before the second. #### func ShouldHappenBetween ```go func ShouldHappenBetween(actual interface{}, expected ...interface{}) string ``` ShouldHappenBetween receives exactly 3 time.Time arguments and asserts that the first happens between (not on) the second and third. #### func ShouldHappenOnOrAfter ```go func ShouldHappenOnOrAfter(actual interface{}, expected ...interface{}) string ``` ShouldHappenOnOrAfter receives exactly 2 time.Time arguments and asserts that the first happens on or after the second. #### func ShouldHappenOnOrBefore ```go func ShouldHappenOnOrBefore(actual interface{}, expected ...interface{}) string ``` ShouldHappenOnOrBefore receives exactly 2 time.Time arguments and asserts that the first happens on or before the second. #### func ShouldHappenOnOrBetween ```go func ShouldHappenOnOrBetween(actual interface{}, expected ...interface{}) string ``` ShouldHappenOnOrBetween receives exactly 3 time.Time arguments and asserts that the first happens between or on the second and third. #### func ShouldHappenWithin ```go func ShouldHappenWithin(actual interface{}, expected ...interface{}) string ``` ShouldHappenWithin receives a time.Time, a time.Duration, and a time.Time (3 arguments) and asserts that the first time.Time happens within or on the duration specified relative to the other time.Time. #### func ShouldHaveLength ```go func ShouldHaveLength(actual interface{}, expected ...interface{}) string ``` ShouldHaveLength receives 2 parameters. The first is a collection to check the length of, the second being the expected length. It obeys the rules specified by the len function for determining length: http://golang.org/pkg/builtin/#len #### func ShouldHaveSameTypeAs ```go func ShouldHaveSameTypeAs(actual interface{}, expected ...interface{}) string ``` ShouldHaveSameTypeAs receives exactly two parameters and compares their underlying types for equality. #### func ShouldImplement ```go func ShouldImplement(actual interface{}, expectedList ...interface{}) string ``` ShouldImplement receives exactly two parameters and ensures that the first implements the interface type of the second. #### func ShouldNotAlmostEqual ```go func ShouldNotAlmostEqual(actual interface{}, expected ...interface{}) string ``` ShouldNotAlmostEqual is the inverse of ShouldAlmostEqual #### func ShouldNotBeBetween ```go func ShouldNotBeBetween(actual interface{}, expected ...interface{}) string ``` ShouldNotBeBetween receives exactly three parameters: an actual value, a lower bound, and an upper bound. It ensures that the actual value is NOT between both bounds. #### func ShouldNotBeBetweenOrEqual ```go func ShouldNotBeBetweenOrEqual(actual interface{}, expected ...interface{}) string ``` ShouldNotBeBetweenOrEqual receives exactly three parameters: an actual value, a lower bound, and an upper bound. It ensures that the actual value is nopt between the bounds nor equal to either of them. #### func ShouldNotBeBlank ```go func ShouldNotBeBlank(actual interface{}, expected ...interface{}) string ``` ShouldNotBeBlank receives exactly 1 string parameter and ensures that it is equal to "". #### func ShouldNotBeEmpty ```go func ShouldNotBeEmpty(actual interface{}, expected ...interface{}) string ``` ShouldNotBeEmpty receives a single parameter (actual) and determines whether or not calling len(actual) would return a value greater than zero. It obeys the rules specified by the `len` function for determining length: http://golang.org/pkg/builtin/#len #### func ShouldNotBeIn ```go func ShouldNotBeIn(actual interface{}, expected ...interface{}) string ``` ShouldNotBeIn receives at least 2 parameters. The first is a proposed member of the collection that is passed in either as the second parameter, or of the collection that is comprised of all the remaining parameters. This assertion ensures that the proposed member is NOT in the collection (using ShouldEqual). #### func ShouldNotBeNil ```go func ShouldNotBeNil(actual interface{}, expected ...interface{}) string ``` ShouldNotBeNil receives a single parameter and ensures that it is not nil. #### func ShouldNotContain ```go func ShouldNotContain(actual interface{}, expected ...interface{}) string ``` ShouldNotContain receives exactly two parameters. The first is a slice and the second is a proposed member. Membership is determinied using ShouldEqual. #### func ShouldNotContainKey ```go func ShouldNotContainKey(actual interface{}, expected ...interface{}) string ``` ShouldNotContainKey receives exactly two parameters. The first is a map and the second is a proposed absent key. Keys are compared with a simple '=='. #### func ShouldNotContainSubstring ```go func ShouldNotContainSubstring(actual interface{}, expected ...interface{}) string ``` ShouldNotContainSubstring receives exactly 2 string parameters and ensures that the first does NOT contain the second as a substring. #### func ShouldNotEndWith ```go func ShouldNotEndWith(actual interface{}, expected ...interface{}) string ``` ShouldEndWith receives exactly 2 string parameters and ensures that the first does not end with the second. #### func ShouldNotEqual ```go func ShouldNotEqual(actual interface{}, expected ...interface{}) string ``` ShouldNotEqual receives exactly two parameters and does an inequality check. #### func ShouldNotHappenOnOrBetween ```go func ShouldNotHappenOnOrBetween(actual interface{}, expected ...interface{}) string ``` ShouldNotHappenOnOrBetween receives exactly 3 time.Time arguments and asserts that the first does NOT happen between or on the second or third. #### func ShouldNotHappenWithin ```go func ShouldNotHappenWithin(actual interface{}, expected ...interface{}) string ``` ShouldNotHappenWithin receives a time.Time, a time.Duration, and a time.Time (3 arguments) and asserts that the first time.Time does NOT happen within or on the duration specified relative to the other time.Time. #### func ShouldNotHaveSameTypeAs ```go func ShouldNotHaveSameTypeAs(actual interface{}, expected ...interface{}) string ``` ShouldNotHaveSameTypeAs receives exactly two parameters and compares their underlying types for inequality. #### func ShouldNotImplement ```go func ShouldNotImplement(actual interface{}, expectedList ...interface{}) string ``` ShouldNotImplement receives exactly two parameters and ensures that the first does NOT implement the interface type of the second. #### func ShouldNotPanic ```go func ShouldNotPanic(actual interface{}, expected ...interface{}) (message string) ``` ShouldNotPanic receives a void, niladic function and expects to execute the function without any panic. #### func ShouldNotPanicWith ```go func ShouldNotPanicWith(actual interface{}, expected ...interface{}) (message string) ``` ShouldNotPanicWith receives a void, niladic function and expects to recover a panic whose content differs from the second argument. #### func ShouldNotPointTo ```go func ShouldNotPointTo(actual interface{}, expected ...interface{}) string ``` ShouldNotPointTo receives exactly two parameters and checks to see that they point to different addresess. #### func ShouldNotResemble ```go func ShouldNotResemble(actual interface{}, expected ...interface{}) string ``` ShouldNotResemble receives exactly two parameters and does an inverse deep equal check (see reflect.DeepEqual) #### func ShouldNotStartWith ```go func ShouldNotStartWith(actual interface{}, expected ...interface{}) string ``` ShouldNotStartWith receives exactly 2 string parameters and ensures that the first does not start with the second. #### func ShouldPanic ```go func ShouldPanic(actual interface{}, expected ...interface{}) (message string) ``` ShouldPanic receives a void, niladic function and expects to recover a panic. #### func ShouldPanicWith ```go func ShouldPanicWith(actual interface{}, expected ...interface{}) (message string) ``` ShouldPanicWith receives a void, niladic function and expects to recover a panic with the second argument as the content. #### func ShouldPointTo ```go func ShouldPointTo(actual interface{}, expected ...interface{}) string ``` ShouldPointTo receives exactly two parameters and checks to see that they point to the same address. #### func ShouldResemble ```go func ShouldResemble(actual interface{}, expected ...interface{}) string ``` ShouldResemble receives exactly two parameters and does a deep equal check (see reflect.DeepEqual) #### func ShouldStartWith ```go func ShouldStartWith(actual interface{}, expected ...interface{}) string ``` ShouldStartWith receives exactly 2 string parameters and ensures that the first starts with the second. #### func So ```go func So(actual interface{}, assert assertion, expected ...interface{}) (bool, string) ``` So is a convenience function (as opposed to an inconvenience function?) for running assertions on arbitrary arguments in any context, be it for testing or even application logging. It allows you to perform assertion-like behavior (and get nicely formatted messages detailing discrepancies) but without the program blowing up or panicking. All that is required is to import this package and call `So` with one of the assertions exported by this package as the second parameter. The first return parameter is a boolean indicating if the assertion was true. The second return parameter is the well-formatted message showing why an assertion was incorrect, or blank if the assertion was correct. Example: if ok, message := So(x, ShouldBeGreaterThan, y); !ok { log.Println(message) } #### type Assertion ```go type Assertion struct { } ``` #### func New ```go func New(t testingT) *Assertion ``` New swallows the *testing.T struct and prints failed assertions using t.Error. Example: assertions.New(t).So(1, should.Equal, 1) #### func (*Assertion) Failed ```go func (this *Assertion) Failed() bool ``` Failed reports whether any calls to So (on this Assertion instance) have failed. #### func (*Assertion) So ```go func (this *Assertion) So(actual interface{}, assert assertion, expected ...interface{}) bool ``` So calls the standalone So function and additionally, calls t.Error in failure scenarios. #### type FailureView ```go type FailureView struct { Message string `json:"Message"` Expected string `json:"Expected"` Actual string `json:"Actual"` } ``` This struct is also declared in github.com/smartystreets/goconvey/convey/reporting. The json struct tags should be equal in both declarations. #### type Serializer ```go type Serializer interface { // contains filtered or unexported methods } ``` mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/assertions.goconvey000066400000000000000000000001731321131462300313720ustar00rootroot00000000000000#ignore -timeout=1s -coverpkg=github.com/smartystreets/assertions,github.com/smartystreets/assertions/internal/oglematchersmongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/collections.go000066400000000000000000000166121321131462300302770ustar00rootroot00000000000000package assertions import ( "fmt" "reflect" "github.com/smartystreets/assertions/internal/oglematchers" ) // ShouldContain receives exactly two parameters. The first is a slice and the // second is a proposed member. Membership is determined using ShouldEqual. func ShouldContain(actual interface{}, expected ...interface{}) string { if fail := need(1, expected); fail != success { return fail } if matchError := oglematchers.Contains(expected[0]).Matches(actual); matchError != nil { typeName := reflect.TypeOf(actual) if fmt.Sprintf("%v", matchError) == "which is not a slice or array" { return fmt.Sprintf(shouldHaveBeenAValidCollection, typeName) } return fmt.Sprintf(shouldHaveContained, typeName, expected[0]) } return success } // ShouldNotContain receives exactly two parameters. The first is a slice and the // second is a proposed member. Membership is determinied using ShouldEqual. func ShouldNotContain(actual interface{}, expected ...interface{}) string { if fail := need(1, expected); fail != success { return fail } typeName := reflect.TypeOf(actual) if matchError := oglematchers.Contains(expected[0]).Matches(actual); matchError != nil { if fmt.Sprintf("%v", matchError) == "which is not a slice or array" { return fmt.Sprintf(shouldHaveBeenAValidCollection, typeName) } return success } return fmt.Sprintf(shouldNotHaveContained, typeName, expected[0]) } // ShouldContainKey receives exactly two parameters. The first is a map and the // second is a proposed key. Keys are compared with a simple '=='. func ShouldContainKey(actual interface{}, expected ...interface{}) string { if fail := need(1, expected); fail != success { return fail } keys, isMap := mapKeys(actual) if !isMap { return fmt.Sprintf(shouldHaveBeenAValidMap, reflect.TypeOf(actual)) } if !keyFound(keys, expected[0]) { return fmt.Sprintf(shouldHaveContainedKey, reflect.TypeOf(actual), expected) } return "" } // ShouldNotContainKey receives exactly two parameters. The first is a map and the // second is a proposed absent key. Keys are compared with a simple '=='. func ShouldNotContainKey(actual interface{}, expected ...interface{}) string { if fail := need(1, expected); fail != success { return fail } keys, isMap := mapKeys(actual) if !isMap { return fmt.Sprintf(shouldHaveBeenAValidMap, reflect.TypeOf(actual)) } if keyFound(keys, expected[0]) { return fmt.Sprintf(shouldNotHaveContainedKey, reflect.TypeOf(actual), expected) } return "" } func mapKeys(m interface{}) ([]reflect.Value, bool) { value := reflect.ValueOf(m) if value.Kind() != reflect.Map { return nil, false } return value.MapKeys(), true } func keyFound(keys []reflect.Value, expectedKey interface{}) bool { found := false for _, key := range keys { if key.Interface() == expectedKey { found = true } } return found } // ShouldBeIn receives at least 2 parameters. The first is a proposed member of the collection // that is passed in either as the second parameter, or of the collection that is comprised // of all the remaining parameters. This assertion ensures that the proposed member is in // the collection (using ShouldEqual). func ShouldBeIn(actual interface{}, expected ...interface{}) string { if fail := atLeast(1, expected); fail != success { return fail } if len(expected) == 1 { return shouldBeIn(actual, expected[0]) } return shouldBeIn(actual, expected) } func shouldBeIn(actual interface{}, expected interface{}) string { if matchError := oglematchers.Contains(actual).Matches(expected); matchError != nil { return fmt.Sprintf(shouldHaveBeenIn, actual, reflect.TypeOf(expected)) } return success } // ShouldNotBeIn receives at least 2 parameters. The first is a proposed member of the collection // that is passed in either as the second parameter, or of the collection that is comprised // of all the remaining parameters. This assertion ensures that the proposed member is NOT in // the collection (using ShouldEqual). func ShouldNotBeIn(actual interface{}, expected ...interface{}) string { if fail := atLeast(1, expected); fail != success { return fail } if len(expected) == 1 { return shouldNotBeIn(actual, expected[0]) } return shouldNotBeIn(actual, expected) } func shouldNotBeIn(actual interface{}, expected interface{}) string { if matchError := oglematchers.Contains(actual).Matches(expected); matchError == nil { return fmt.Sprintf(shouldNotHaveBeenIn, actual, reflect.TypeOf(expected)) } return success } // ShouldBeEmpty receives a single parameter (actual) and determines whether or not // calling len(actual) would return `0`. It obeys the rules specified by the len // function for determining length: http://golang.org/pkg/builtin/#len func ShouldBeEmpty(actual interface{}, expected ...interface{}) string { if fail := need(0, expected); fail != success { return fail } if actual == nil { return success } value := reflect.ValueOf(actual) switch value.Kind() { case reflect.Slice: if value.Len() == 0 { return success } case reflect.Chan: if value.Len() == 0 { return success } case reflect.Map: if value.Len() == 0 { return success } case reflect.String: if value.Len() == 0 { return success } case reflect.Ptr: elem := value.Elem() kind := elem.Kind() if (kind == reflect.Slice || kind == reflect.Array) && elem.Len() == 0 { return success } } return fmt.Sprintf(shouldHaveBeenEmpty, actual) } // ShouldNotBeEmpty receives a single parameter (actual) and determines whether or not // calling len(actual) would return a value greater than zero. It obeys the rules // specified by the `len` function for determining length: http://golang.org/pkg/builtin/#len func ShouldNotBeEmpty(actual interface{}, expected ...interface{}) string { if fail := need(0, expected); fail != success { return fail } if empty := ShouldBeEmpty(actual, expected...); empty != success { return success } return fmt.Sprintf(shouldNotHaveBeenEmpty, actual) } // ShouldHaveLength receives 2 parameters. The first is a collection to check // the length of, the second being the expected length. It obeys the rules // specified by the len function for determining length: // http://golang.org/pkg/builtin/#len func ShouldHaveLength(actual interface{}, expected ...interface{}) string { if fail := need(1, expected); fail != success { return fail } var expectedLen int64 lenValue := reflect.ValueOf(expected[0]) switch lenValue.Kind() { case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: expectedLen = lenValue.Int() case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64: expectedLen = int64(lenValue.Uint()) default: return fmt.Sprintf(shouldHaveBeenAValidInteger, reflect.TypeOf(expected[0])) } if expectedLen < 0 { return fmt.Sprintf(shouldHaveBeenAValidLength, expected[0]) } value := reflect.ValueOf(actual) switch value.Kind() { case reflect.Slice, reflect.Chan, reflect.Map, reflect.String: if int64(value.Len()) == expectedLen { return success } else { return fmt.Sprintf(shouldHaveHadLength, actual, value.Len(), expectedLen) } case reflect.Ptr: elem := value.Elem() kind := elem.Kind() if kind == reflect.Slice || kind == reflect.Array { if int64(elem.Len()) == expectedLen { return success } else { return fmt.Sprintf(shouldHaveHadLength, actual, elem.Len(), expectedLen) } } } return fmt.Sprintf(shouldHaveBeenAValidCollection, reflect.TypeOf(actual)) } mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/collections_test.go000066400000000000000000000231001321131462300313240ustar00rootroot00000000000000package assertions import ( "fmt" "testing" "time" ) func TestShouldContainKey(t *testing.T) { fail(t, so(map[int]int{}, ShouldContainKey), "This assertion requires exactly 1 comparison values (you provided 0).") fail(t, so(map[int]int{}, ShouldContainKey, 1, 2, 3), "This assertion requires exactly 1 comparison values (you provided 3).") fail(t, so(Thing1{}, ShouldContainKey, 1), "You must provide a valid map type (was assertions.Thing1)!") fail(t, so(nil, ShouldContainKey, 1), "You must provide a valid map type (was )!") fail(t, so(map[int]int{1: 41}, ShouldContainKey, 2), "Expected the map[int]int to contain the key: [2] (but it didn't)!") pass(t, so(map[int]int{1: 41}, ShouldContainKey, 1)) pass(t, so(map[int]int{1: 41, 2: 42, 3: 43}, ShouldContainKey, 2)) } func TestShouldNotContainKey(t *testing.T) { fail(t, so(map[int]int{}, ShouldNotContainKey), "This assertion requires exactly 1 comparison values (you provided 0).") fail(t, so(map[int]int{}, ShouldNotContainKey, 1, 2, 3), "This assertion requires exactly 1 comparison values (you provided 3).") fail(t, so(Thing1{}, ShouldNotContainKey, 1), "You must provide a valid map type (was assertions.Thing1)!") fail(t, so(nil, ShouldNotContainKey, 1), "You must provide a valid map type (was )!") fail(t, so(map[int]int{1: 41}, ShouldNotContainKey, 1), "Expected the map[int]int NOT to contain the key: [1] (but it did)!") pass(t, so(map[int]int{1: 41}, ShouldNotContainKey, 2)) } func TestShouldContain(t *testing.T) { fail(t, so([]int{}, ShouldContain), "This assertion requires exactly 1 comparison values (you provided 0).") fail(t, so([]int{}, ShouldContain, 1, 2, 3), "This assertion requires exactly 1 comparison values (you provided 3).") fail(t, so(Thing1{}, ShouldContain, 1), "You must provide a valid container (was assertions.Thing1)!") fail(t, so(nil, ShouldContain, 1), "You must provide a valid container (was )!") fail(t, so([]int{1}, ShouldContain, 2), "Expected the container ([]int) to contain: '2' (but it didn't)!") pass(t, so([]int{1}, ShouldContain, 1)) pass(t, so([]int{1, 2, 3}, ShouldContain, 2)) } func TestShouldNotContain(t *testing.T) { fail(t, so([]int{}, ShouldNotContain), "This assertion requires exactly 1 comparison values (you provided 0).") fail(t, so([]int{}, ShouldNotContain, 1, 2, 3), "This assertion requires exactly 1 comparison values (you provided 3).") fail(t, so(Thing1{}, ShouldNotContain, 1), "You must provide a valid container (was assertions.Thing1)!") fail(t, so(nil, ShouldNotContain, 1), "You must provide a valid container (was )!") fail(t, so([]int{1}, ShouldNotContain, 1), "Expected the container ([]int) NOT to contain: '1' (but it did)!") fail(t, so([]int{1, 2, 3}, ShouldNotContain, 2), "Expected the container ([]int) NOT to contain: '2' (but it did)!") pass(t, so([]int{1}, ShouldNotContain, 2)) } func TestShouldBeIn(t *testing.T) { fail(t, so(4, ShouldBeIn), needNonEmptyCollection) container := []int{1, 2, 3, 4} pass(t, so(4, ShouldBeIn, container)) pass(t, so(4, ShouldBeIn, 1, 2, 3, 4)) fail(t, so(4, ShouldBeIn, 1, 2, 3), "Expected '4' to be in the container ([]interface {}), but it wasn't!") fail(t, so(4, ShouldBeIn, []int{1, 2, 3}), "Expected '4' to be in the container ([]int), but it wasn't!") } func TestShouldNotBeIn(t *testing.T) { fail(t, so(4, ShouldNotBeIn), needNonEmptyCollection) container := []int{1, 2, 3, 4} pass(t, so(42, ShouldNotBeIn, container)) pass(t, so(42, ShouldNotBeIn, 1, 2, 3, 4)) fail(t, so(2, ShouldNotBeIn, 1, 2, 3), "Expected '2' NOT to be in the container ([]interface {}), but it was!") fail(t, so(2, ShouldNotBeIn, []int{1, 2, 3}), "Expected '2' NOT to be in the container ([]int), but it was!") } func TestShouldBeEmpty(t *testing.T) { fail(t, so(1, ShouldBeEmpty, 2, 3), "This assertion requires exactly 0 comparison values (you provided 2).") pass(t, so([]int{}, ShouldBeEmpty)) // empty slice pass(t, so([]interface{}{}, ShouldBeEmpty)) // empty slice pass(t, so(map[string]int{}, ShouldBeEmpty)) // empty map pass(t, so("", ShouldBeEmpty)) // empty string pass(t, so(&[]int{}, ShouldBeEmpty)) // pointer to empty slice pass(t, so(&[0]int{}, ShouldBeEmpty)) // pointer to empty array pass(t, so(nil, ShouldBeEmpty)) // nil pass(t, so(make(chan string), ShouldBeEmpty)) // empty channel fail(t, so([]int{1}, ShouldBeEmpty), "Expected [1] to be empty (but it wasn't)!") // non-empty slice fail(t, so([]interface{}{1}, ShouldBeEmpty), "Expected [1] to be empty (but it wasn't)!") // non-empty slice fail(t, so(map[string]int{"hi": 0}, ShouldBeEmpty), "Expected map[hi:0] to be empty (but it wasn't)!") // non-empty map fail(t, so("hi", ShouldBeEmpty), "Expected hi to be empty (but it wasn't)!") // non-empty string fail(t, so(&[]int{1}, ShouldBeEmpty), "Expected &[1] to be empty (but it wasn't)!") // pointer to non-empty slice fail(t, so(&[1]int{1}, ShouldBeEmpty), "Expected &[1] to be empty (but it wasn't)!") // pointer to non-empty array c := make(chan int, 1) // non-empty channel go func() { c <- 1 }() time.Sleep(time.Millisecond) fail(t, so(c, ShouldBeEmpty), fmt.Sprintf("Expected %+v to be empty (but it wasn't)!", c)) } func TestShouldNotBeEmpty(t *testing.T) { fail(t, so(1, ShouldNotBeEmpty, 2, 3), "This assertion requires exactly 0 comparison values (you provided 2).") fail(t, so([]int{}, ShouldNotBeEmpty), "Expected [] to NOT be empty (but it was)!") // empty slice fail(t, so([]interface{}{}, ShouldNotBeEmpty), "Expected [] to NOT be empty (but it was)!") // empty slice fail(t, so(map[string]int{}, ShouldNotBeEmpty), "Expected map[] to NOT be empty (but it was)!") // empty map fail(t, so("", ShouldNotBeEmpty), "Expected to NOT be empty (but it was)!") // empty string fail(t, so(&[]int{}, ShouldNotBeEmpty), "Expected &[] to NOT be empty (but it was)!") // pointer to empty slice fail(t, so(&[0]int{}, ShouldNotBeEmpty), "Expected &[] to NOT be empty (but it was)!") // pointer to empty array fail(t, so(nil, ShouldNotBeEmpty), "Expected to NOT be empty (but it was)!") // nil c := make(chan int, 0) // non-empty channel fail(t, so(c, ShouldNotBeEmpty), fmt.Sprintf("Expected %+v to NOT be empty (but it was)!", c)) // empty channel pass(t, so([]int{1}, ShouldNotBeEmpty)) // non-empty slice pass(t, so([]interface{}{1}, ShouldNotBeEmpty)) // non-empty slice pass(t, so(map[string]int{"hi": 0}, ShouldNotBeEmpty)) // non-empty map pass(t, so("hi", ShouldNotBeEmpty)) // non-empty string pass(t, so(&[]int{1}, ShouldNotBeEmpty)) // pointer to non-empty slice pass(t, so(&[1]int{1}, ShouldNotBeEmpty)) // pointer to non-empty array c = make(chan int, 1) go func() { c <- 1 }() time.Sleep(time.Millisecond) pass(t, so(c, ShouldNotBeEmpty)) } func TestShouldHaveLength(t *testing.T) { fail(t, so(1, ShouldHaveLength, 2), "You must provide a valid container (was int)!") fail(t, so(nil, ShouldHaveLength, 1), "You must provide a valid container (was )!") fail(t, so("hi", ShouldHaveLength, float64(1.0)), "You must provide a valid integer (was float64)!") fail(t, so([]string{}, ShouldHaveLength), "This assertion requires exactly 1 comparison values (you provided 0).") fail(t, so([]string{}, ShouldHaveLength, 1, 2), "This assertion requires exactly 1 comparison values (you provided 2).") fail(t, so([]string{}, ShouldHaveLength, -10), "You must provide a valid positive integer (was -10)!") fail(t, so([]int{}, ShouldHaveLength, 1), "Expected [] (length: 0) to have length equal to '1', but it wasn't!") // empty slice fail(t, so([]interface{}{}, ShouldHaveLength, 1), "Expected [] (length: 0) to have length equal to '1', but it wasn't!") // empty slice fail(t, so(map[string]int{}, ShouldHaveLength, 1), "Expected map[] (length: 0) to have length equal to '1', but it wasn't!") // empty map fail(t, so("", ShouldHaveLength, 1), "Expected (length: 0) to have length equal to '1', but it wasn't!") // empty string fail(t, so(&[]int{}, ShouldHaveLength, 1), "Expected &[] (length: 0) to have length equal to '1', but it wasn't!") // pointer to empty slice fail(t, so(&[0]int{}, ShouldHaveLength, 1), "Expected &[] (length: 0) to have length equal to '1', but it wasn't!") // pointer to empty array c := make(chan int, 0) // non-empty channel fail(t, so(c, ShouldHaveLength, 1), fmt.Sprintf("Expected %+v (length: 0) to have length equal to '1', but it wasn't!", c)) c = make(chan int) // empty channel fail(t, so(c, ShouldHaveLength, 1), fmt.Sprintf("Expected %+v (length: 0) to have length equal to '1', but it wasn't!", c)) pass(t, so([]int{1}, ShouldHaveLength, 1)) // non-empty slice pass(t, so([]interface{}{1}, ShouldHaveLength, 1)) // non-empty slice pass(t, so(map[string]int{"hi": 0}, ShouldHaveLength, 1)) // non-empty map pass(t, so("hi", ShouldHaveLength, 2)) // non-empty string pass(t, so(&[]int{1}, ShouldHaveLength, 1)) // pointer to non-empty slice pass(t, so(&[1]int{1}, ShouldHaveLength, 1)) // pointer to non-empty array c = make(chan int, 1) go func() { c <- 1 }() time.Sleep(time.Millisecond) pass(t, so(c, ShouldHaveLength, 1)) } mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/doc.go000066400000000000000000000100211321131462300265120ustar00rootroot00000000000000// Package assertions contains the implementations for all assertions which // are referenced in goconvey's `convey` package // (github.com/smartystreets/goconvey/convey) and gunit (github.com/smartystreets/gunit) // for use with the So(...) method. // They can also be used in traditional Go test functions and even in // applications. // // Many of the assertions lean heavily on work done by Aaron Jacobs in his excellent oglematchers library. // (https://github.com/jacobsa/oglematchers) // The ShouldResemble assertion leans heavily on work done by Daniel Jacques in his very helpful go-render library. // (https://github.com/luci/go-render) package assertions import ( "fmt" "runtime" ) // By default we use a no-op serializer. The actual Serializer provides a JSON // representation of failure results on selected assertions so the goconvey // web UI can display a convenient diff. var serializer Serializer = new(noopSerializer) // GoConveyMode provides control over JSON serialization of failures. When // using the assertions in this package from the convey package JSON results // are very helpful and can be rendered in a DIFF view. In that case, this function // will be called with a true value to enable the JSON serialization. By default, // the assertions in this package will not serializer a JSON result, making // standalone ussage more convenient. func GoConveyMode(yes bool) { if yes { serializer = newSerializer() } else { serializer = new(noopSerializer) } } type testingT interface { Error(args ...interface{}) } type Assertion struct { t testingT failed bool } // New swallows the *testing.T struct and prints failed assertions using t.Error. // Example: assertions.New(t).So(1, should.Equal, 1) func New(t testingT) *Assertion { return &Assertion{t: t} } // Failed reports whether any calls to So (on this Assertion instance) have failed. func (this *Assertion) Failed() bool { return this.failed } // So calls the standalone So function and additionally, calls t.Error in failure scenarios. func (this *Assertion) So(actual interface{}, assert assertion, expected ...interface{}) bool { ok, result := So(actual, assert, expected...) if !ok { this.failed = true _, file, line, _ := runtime.Caller(1) this.t.Error(fmt.Sprintf("\n%s:%d\n%s", file, line, result)) } return ok } // So is a convenience function (as opposed to an inconvenience function?) // for running assertions on arbitrary arguments in any context, be it for testing or even // application logging. It allows you to perform assertion-like behavior (and get nicely // formatted messages detailing discrepancies) but without the program blowing up or panicking. // All that is required is to import this package and call `So` with one of the assertions // exported by this package as the second parameter. // The first return parameter is a boolean indicating if the assertion was true. The second // return parameter is the well-formatted message showing why an assertion was incorrect, or // blank if the assertion was correct. // // Example: // // if ok, message := So(x, ShouldBeGreaterThan, y); !ok { // log.Println(message) // } // func So(actual interface{}, assert assertion, expected ...interface{}) (bool, string) { if result := so(actual, assert, expected...); len(result) == 0 { return true, result } else { return false, result } } // so is like So, except that it only returns the string message, which is blank if the // assertion passed. Used to facilitate testing. func so(actual interface{}, assert func(interface{}, ...interface{}) string, expected ...interface{}) string { return assert(actual, expected...) } // assertion is an alias for a function with a signature that the So() // function can handle. Any future or custom assertions should conform to this // method signature. The return value should be an empty string if the assertion // passes and a well-formed failure message if not. type assertion func(actual interface{}, expected ...interface{}) string //////////////////////////////////////////////////////////////////////////// mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/doc_test.go000066400000000000000000000023471321131462300275650ustar00rootroot00000000000000package assertions import ( "bytes" "fmt" "testing" ) func TestPassingAssertion(t *testing.T) { fake := &FakeT{buffer: new(bytes.Buffer)} assertion := New(fake) passed := assertion.So(1, ShouldEqual, 1) if !passed { t.Error("Assertion failed when it should have passed.") } if fake.buffer.Len() > 0 { t.Error("Unexpected error message was printed.") } } func TestFailingAssertion(t *testing.T) { fake := &FakeT{buffer: new(bytes.Buffer)} assertion := New(fake) passed := assertion.So(1, ShouldEqual, 2) if passed { t.Error("Assertion passed when it should have failed.") } if fake.buffer.Len() == 0 { t.Error("Expected error message not printed.") } } func TestFailingGroupsOfAssertions(t *testing.T) { fake := &FakeT{buffer: new(bytes.Buffer)} assertion1 := New(fake) assertion2 := New(fake) assertion1.So(1, ShouldEqual, 2) // fail assertion2.So(1, ShouldEqual, 1) // pass if !assertion1.Failed() { t.Error("Expected the first assertion to have been marked as failed.") } if assertion2.Failed() { t.Error("Expected the second assertion to NOT have been marked as failed.") } } type FakeT struct { buffer *bytes.Buffer } func (this *FakeT) Error(args ...interface{}) { fmt.Fprint(this.buffer, args...) } mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/equality.go000066400000000000000000000221721321131462300276140ustar00rootroot00000000000000package assertions import ( "errors" "fmt" "math" "reflect" "strings" "github.com/smartystreets/assertions/internal/oglematchers" "github.com/smartystreets/assertions/internal/go-render/render" ) // default acceptable delta for ShouldAlmostEqual const defaultDelta = 0.0000000001 // ShouldEqual receives exactly two parameters and does an equality check. func ShouldEqual(actual interface{}, expected ...interface{}) string { if message := need(1, expected); message != success { return message } return shouldEqual(actual, expected[0]) } func shouldEqual(actual, expected interface{}) (message string) { defer func() { if r := recover(); r != nil { message = serializer.serialize(expected, actual, fmt.Sprintf(shouldHaveBeenEqual, expected, actual)) return } }() if matchError := oglematchers.Equals(expected).Matches(actual); matchError != nil { expectedSyntax := fmt.Sprintf("%v", expected) actualSyntax := fmt.Sprintf("%v", actual) if expectedSyntax == actualSyntax && reflect.TypeOf(expected) != reflect.TypeOf(actual) { message = fmt.Sprintf(shouldHaveBeenEqualTypeMismatch, expected, expected, actual, actual) } else { message = fmt.Sprintf(shouldHaveBeenEqual, expected, actual) } message = serializer.serialize(expected, actual, message) return } return success } // ShouldNotEqual receives exactly two parameters and does an inequality check. func ShouldNotEqual(actual interface{}, expected ...interface{}) string { if fail := need(1, expected); fail != success { return fail } else if ShouldEqual(actual, expected[0]) == success { return fmt.Sprintf(shouldNotHaveBeenEqual, actual, expected[0]) } return success } // ShouldAlmostEqual makes sure that two parameters are close enough to being equal. // The acceptable delta may be specified with a third argument, // or a very small default delta will be used. func ShouldAlmostEqual(actual interface{}, expected ...interface{}) string { actualFloat, expectedFloat, deltaFloat, err := cleanAlmostEqualInput(actual, expected...) if err != "" { return err } if math.Abs(actualFloat-expectedFloat) <= deltaFloat { return success } else { return fmt.Sprintf(shouldHaveBeenAlmostEqual, actualFloat, expectedFloat) } } // ShouldNotAlmostEqual is the inverse of ShouldAlmostEqual func ShouldNotAlmostEqual(actual interface{}, expected ...interface{}) string { actualFloat, expectedFloat, deltaFloat, err := cleanAlmostEqualInput(actual, expected...) if err != "" { return err } if math.Abs(actualFloat-expectedFloat) > deltaFloat { return success } else { return fmt.Sprintf(shouldHaveNotBeenAlmostEqual, actualFloat, expectedFloat) } } func cleanAlmostEqualInput(actual interface{}, expected ...interface{}) (float64, float64, float64, string) { deltaFloat := 0.0000000001 if len(expected) == 0 { return 0.0, 0.0, 0.0, "This assertion requires exactly one comparison value and an optional delta (you provided neither)" } else if len(expected) == 2 { delta, err := getFloat(expected[1]) if err != nil { return 0.0, 0.0, 0.0, "delta must be a numerical type" } deltaFloat = delta } else if len(expected) > 2 { return 0.0, 0.0, 0.0, "This assertion requires exactly one comparison value and an optional delta (you provided more values)" } actualFloat, err := getFloat(actual) if err != nil { return 0.0, 0.0, 0.0, err.Error() } expectedFloat, err := getFloat(expected[0]) if err != nil { return 0.0, 0.0, 0.0, err.Error() } return actualFloat, expectedFloat, deltaFloat, "" } // returns the float value of any real number, or error if it is not a numerical type func getFloat(num interface{}) (float64, error) { numValue := reflect.ValueOf(num) numKind := numValue.Kind() if numKind == reflect.Int || numKind == reflect.Int8 || numKind == reflect.Int16 || numKind == reflect.Int32 || numKind == reflect.Int64 { return float64(numValue.Int()), nil } else if numKind == reflect.Uint || numKind == reflect.Uint8 || numKind == reflect.Uint16 || numKind == reflect.Uint32 || numKind == reflect.Uint64 { return float64(numValue.Uint()), nil } else if numKind == reflect.Float32 || numKind == reflect.Float64 { return numValue.Float(), nil } else { return 0.0, errors.New("must be a numerical type, but was " + numKind.String()) } } // ShouldResemble receives exactly two parameters and does a deep equal check (see reflect.DeepEqual) func ShouldResemble(actual interface{}, expected ...interface{}) string { if message := need(1, expected); message != success { return message } if matchError := oglematchers.DeepEquals(expected[0]).Matches(actual); matchError != nil { return serializer.serializeDetailed(expected[0], actual, fmt.Sprintf(shouldHaveResembled, render.Render(expected[0]), render.Render(actual))) } return success } // ShouldNotResemble receives exactly two parameters and does an inverse deep equal check (see reflect.DeepEqual) func ShouldNotResemble(actual interface{}, expected ...interface{}) string { if message := need(1, expected); message != success { return message } else if ShouldResemble(actual, expected[0]) == success { return fmt.Sprintf(shouldNotHaveResembled, render.Render(actual), render.Render(expected[0])) } return success } // ShouldPointTo receives exactly two parameters and checks to see that they point to the same address. func ShouldPointTo(actual interface{}, expected ...interface{}) string { if message := need(1, expected); message != success { return message } return shouldPointTo(actual, expected[0]) } func shouldPointTo(actual, expected interface{}) string { actualValue := reflect.ValueOf(actual) expectedValue := reflect.ValueOf(expected) if ShouldNotBeNil(actual) != success { return fmt.Sprintf(shouldHaveBeenNonNilPointer, "first", "nil") } else if ShouldNotBeNil(expected) != success { return fmt.Sprintf(shouldHaveBeenNonNilPointer, "second", "nil") } else if actualValue.Kind() != reflect.Ptr { return fmt.Sprintf(shouldHaveBeenNonNilPointer, "first", "not") } else if expectedValue.Kind() != reflect.Ptr { return fmt.Sprintf(shouldHaveBeenNonNilPointer, "second", "not") } else if ShouldEqual(actualValue.Pointer(), expectedValue.Pointer()) != success { actualAddress := reflect.ValueOf(actual).Pointer() expectedAddress := reflect.ValueOf(expected).Pointer() return serializer.serialize(expectedAddress, actualAddress, fmt.Sprintf(shouldHavePointedTo, actual, actualAddress, expected, expectedAddress)) } return success } // ShouldNotPointTo receives exactly two parameters and checks to see that they point to different addresess. func ShouldNotPointTo(actual interface{}, expected ...interface{}) string { if message := need(1, expected); message != success { return message } compare := ShouldPointTo(actual, expected[0]) if strings.HasPrefix(compare, shouldBePointers) { return compare } else if compare == success { return fmt.Sprintf(shouldNotHavePointedTo, actual, expected[0], reflect.ValueOf(actual).Pointer()) } return success } // ShouldBeNil receives a single parameter and ensures that it is nil. func ShouldBeNil(actual interface{}, expected ...interface{}) string { if fail := need(0, expected); fail != success { return fail } else if actual == nil { return success } else if interfaceHasNilValue(actual) { return success } return fmt.Sprintf(shouldHaveBeenNil, actual) } func interfaceHasNilValue(actual interface{}) bool { value := reflect.ValueOf(actual) kind := value.Kind() nilable := kind == reflect.Slice || kind == reflect.Chan || kind == reflect.Func || kind == reflect.Ptr || kind == reflect.Map // Careful: reflect.Value.IsNil() will panic unless it's an interface, chan, map, func, slice, or ptr // Reference: http://golang.org/pkg/reflect/#Value.IsNil return nilable && value.IsNil() } // ShouldNotBeNil receives a single parameter and ensures that it is not nil. func ShouldNotBeNil(actual interface{}, expected ...interface{}) string { if fail := need(0, expected); fail != success { return fail } else if ShouldBeNil(actual) == success { return fmt.Sprintf(shouldNotHaveBeenNil, actual) } return success } // ShouldBeTrue receives a single parameter and ensures that it is true. func ShouldBeTrue(actual interface{}, expected ...interface{}) string { if fail := need(0, expected); fail != success { return fail } else if actual != true { return fmt.Sprintf(shouldHaveBeenTrue, actual) } return success } // ShouldBeFalse receives a single parameter and ensures that it is false. func ShouldBeFalse(actual interface{}, expected ...interface{}) string { if fail := need(0, expected); fail != success { return fail } else if actual != false { return fmt.Sprintf(shouldHaveBeenFalse, actual) } return success } // ShouldBeZeroValue receives a single parameter and ensures that it is // the Go equivalent of the default value, or "zero" value. func ShouldBeZeroValue(actual interface{}, expected ...interface{}) string { if fail := need(0, expected); fail != success { return fail } zeroVal := reflect.Zero(reflect.TypeOf(actual)).Interface() if !reflect.DeepEqual(zeroVal, actual) { return serializer.serialize(zeroVal, actual, fmt.Sprintf(shouldHaveBeenZeroValue, actual)) } return success } mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/equality_test.go000066400000000000000000000314461321131462300306570ustar00rootroot00000000000000package assertions import ( "fmt" "reflect" "testing" ) func TestShouldEqual(t *testing.T) { serializer = newFakeSerializer() fail(t, so(1, ShouldEqual), "This assertion requires exactly 1 comparison values (you provided 0).") fail(t, so(1, ShouldEqual, 1, 2), "This assertion requires exactly 1 comparison values (you provided 2).") fail(t, so(1, ShouldEqual, 1, 2, 3), "This assertion requires exactly 1 comparison values (you provided 3).") pass(t, so(1, ShouldEqual, 1)) fail(t, so(1, ShouldEqual, 2), "2|1|Expected: '2' Actual: '1' (Should be equal)") fail(t, so(1, ShouldEqual, "1"), "1|1|Expected: '1' (string) Actual: '1' (int) (Should be equal, type mismatch)") pass(t, so(true, ShouldEqual, true)) fail(t, so(true, ShouldEqual, false), "false|true|Expected: 'false' Actual: 'true' (Should be equal)") pass(t, so("hi", ShouldEqual, "hi")) fail(t, so("hi", ShouldEqual, "bye"), "bye|hi|Expected: 'bye' Actual: 'hi' (Should be equal)") pass(t, so(42, ShouldEqual, uint(42))) fail(t, so(Thing1{"hi"}, ShouldEqual, Thing1{}), "{}|{hi}|Expected: '{}' Actual: '{hi}' (Should be equal)") fail(t, so(Thing1{"hi"}, ShouldEqual, Thing1{"hi"}), "{hi}|{hi}|Expected: '{hi}' Actual: '{hi}' (Should be equal)") fail(t, so(&Thing1{"hi"}, ShouldEqual, &Thing1{"hi"}), "&{hi}|&{hi}|Expected: '&{hi}' Actual: '&{hi}' (Should be equal)") fail(t, so(Thing1{}, ShouldEqual, Thing2{}), "{}|{}|Expected: '{}' Actual: '{}' (Should be equal)") } func TestShouldNotEqual(t *testing.T) { fail(t, so(1, ShouldNotEqual), "This assertion requires exactly 1 comparison values (you provided 0).") fail(t, so(1, ShouldNotEqual, 1, 2), "This assertion requires exactly 1 comparison values (you provided 2).") fail(t, so(1, ShouldNotEqual, 1, 2, 3), "This assertion requires exactly 1 comparison values (you provided 3).") pass(t, so(1, ShouldNotEqual, 2)) pass(t, so(1, ShouldNotEqual, "1")) fail(t, so(1, ShouldNotEqual, 1), "Expected '1' to NOT equal '1' (but it did)!") pass(t, so(true, ShouldNotEqual, false)) fail(t, so(true, ShouldNotEqual, true), "Expected 'true' to NOT equal 'true' (but it did)!") pass(t, so("hi", ShouldNotEqual, "bye")) fail(t, so("hi", ShouldNotEqual, "hi"), "Expected 'hi' to NOT equal 'hi' (but it did)!") pass(t, so(&Thing1{"hi"}, ShouldNotEqual, &Thing1{"hi"})) pass(t, so(Thing1{"hi"}, ShouldNotEqual, Thing1{"hi"})) pass(t, so(Thing1{}, ShouldNotEqual, Thing1{})) pass(t, so(Thing1{}, ShouldNotEqual, Thing2{})) } func TestShouldAlmostEqual(t *testing.T) { fail(t, so(1, ShouldAlmostEqual), "This assertion requires exactly one comparison value and an optional delta (you provided neither)") fail(t, so(1, ShouldAlmostEqual, 1, 2, 3), "This assertion requires exactly one comparison value and an optional delta (you provided more values)") // with the default delta pass(t, so(1, ShouldAlmostEqual, .99999999999999)) pass(t, so(1.3612499999999996, ShouldAlmostEqual, 1.36125)) pass(t, so(0.7285312499999999, ShouldAlmostEqual, 0.72853125)) fail(t, so(1, ShouldAlmostEqual, .99), "Expected '1' to almost equal '0.99' (but it didn't)!") // with a different delta pass(t, so(100.0, ShouldAlmostEqual, 110.0, 10.0)) fail(t, so(100.0, ShouldAlmostEqual, 111.0, 10.5), "Expected '100' to almost equal '111' (but it didn't)!") // ints should work pass(t, so(100, ShouldAlmostEqual, 100.0)) fail(t, so(100, ShouldAlmostEqual, 99.0), "Expected '100' to almost equal '99' (but it didn't)!") // float32 should work pass(t, so(float64(100.0), ShouldAlmostEqual, float32(100.0))) fail(t, so(float32(100.0), ShouldAlmostEqual, 99.0, float32(0.1)), "Expected '100' to almost equal '99' (but it didn't)!") } func TestShouldNotAlmostEqual(t *testing.T) { fail(t, so(1, ShouldNotAlmostEqual), "This assertion requires exactly one comparison value and an optional delta (you provided neither)") fail(t, so(1, ShouldNotAlmostEqual, 1, 2, 3), "This assertion requires exactly one comparison value and an optional delta (you provided more values)") // with the default delta fail(t, so(1, ShouldNotAlmostEqual, .99999999999999), "Expected '1' to NOT almost equal '0.99999999999999' (but it did)!") fail(t, so(1.3612499999999996, ShouldNotAlmostEqual, 1.36125), "Expected '1.3612499999999996' to NOT almost equal '1.36125' (but it did)!") pass(t, so(1, ShouldNotAlmostEqual, .99)) // with a different delta fail(t, so(100.0, ShouldNotAlmostEqual, 110.0, 10.0), "Expected '100' to NOT almost equal '110' (but it did)!") pass(t, so(100.0, ShouldNotAlmostEqual, 111.0, 10.5)) // ints should work fail(t, so(100, ShouldNotAlmostEqual, 100.0), "Expected '100' to NOT almost equal '100' (but it did)!") pass(t, so(100, ShouldNotAlmostEqual, 99.0)) // float32 should work fail(t, so(float64(100.0), ShouldNotAlmostEqual, float32(100.0)), "Expected '100' to NOT almost equal '100' (but it did)!") pass(t, so(float32(100.0), ShouldNotAlmostEqual, 99.0, float32(0.1))) } func TestShouldResemble(t *testing.T) { serializer = newFakeSerializer() fail(t, so(Thing1{"hi"}, ShouldResemble), "This assertion requires exactly 1 comparison values (you provided 0).") fail(t, so(Thing1{"hi"}, ShouldResemble, Thing1{"hi"}, Thing1{"hi"}), "This assertion requires exactly 1 comparison values (you provided 2).") pass(t, so(Thing1{"hi"}, ShouldResemble, Thing1{"hi"})) fail(t, so(Thing1{"hi"}, ShouldResemble, Thing1{"bye"}), `{bye}|{hi}|Expected: '"assertions.Thing1{a:\"bye\"}"' Actual: '"assertions.Thing1{a:\"hi\"}"' (Should resemble)!`) var ( a []int b []int = []int{} ) fail(t, so(a, ShouldResemble, b), `[]|[]|Expected: '"[]int{}"' Actual: '"[]int(nil)"' (Should resemble)!`) fail(t, so(2, ShouldResemble, 1), `1|2|Expected: '"1"' Actual: '"2"' (Should resemble)!`) fail(t, so(StringStringMapAlias{"hi": "bye"}, ShouldResemble, map[string]string{"hi": "bye"}), `map[hi:bye]|map[hi:bye]|Expected: '"map[string]string{\"hi\":\"bye\"}"' Actual: '"assertions.StringStringMapAlias{\"hi\":\"bye\"}"' (Should resemble)!`) fail(t, so(StringSliceAlias{"hi", "bye"}, ShouldResemble, []string{"hi", "bye"}), `[hi bye]|[hi bye]|Expected: '"[]string{\"hi\", \"bye\"}"' Actual: '"assertions.StringSliceAlias{\"hi\", \"bye\"}"' (Should resemble)!`) // some types come out looking the same when represented with "%#v" so we show type mismatch info: fail(t, so(StringAlias("hi"), ShouldResemble, "hi"), `hi|hi|Expected: '"\"hi\""' Actual: '"assertions.StringAlias(\"hi\")"' (Should resemble)!`) fail(t, so(IntAlias(42), ShouldResemble, 42), `42|42|Expected: '"42"' Actual: '"assertions.IntAlias(42)"' (Should resemble)!`) } func TestShouldNotResemble(t *testing.T) { fail(t, so(Thing1{"hi"}, ShouldNotResemble), "This assertion requires exactly 1 comparison values (you provided 0).") fail(t, so(Thing1{"hi"}, ShouldNotResemble, Thing1{"hi"}, Thing1{"hi"}), "This assertion requires exactly 1 comparison values (you provided 2).") pass(t, so(Thing1{"hi"}, ShouldNotResemble, Thing1{"bye"})) fail(t, so(Thing1{"hi"}, ShouldNotResemble, Thing1{"hi"}), `Expected '"assertions.Thing1{a:\"hi\"}"' to NOT resemble '"assertions.Thing1{a:\"hi\"}"' (but it did)!`) pass(t, so(map[string]string{"hi": "bye"}, ShouldResemble, map[string]string{"hi": "bye"})) pass(t, so(IntAlias(42), ShouldNotResemble, 42)) pass(t, so(StringSliceAlias{"hi", "bye"}, ShouldNotResemble, []string{"hi", "bye"})) } func TestShouldPointTo(t *testing.T) { serializer = newFakeSerializer() t1 := &Thing1{} t2 := t1 t3 := &Thing1{} pointer1 := reflect.ValueOf(t1).Pointer() pointer3 := reflect.ValueOf(t3).Pointer() fail(t, so(t1, ShouldPointTo), "This assertion requires exactly 1 comparison values (you provided 0).") fail(t, so(t1, ShouldPointTo, t2, t3), "This assertion requires exactly 1 comparison values (you provided 2).") pass(t, so(t1, ShouldPointTo, t2)) fail(t, so(t1, ShouldPointTo, t3), fmt.Sprintf( "%v|%v|Expected '&{a:}' (address: '%v') and '&{a:}' (address: '%v') to be the same address (but their weren't)!", pointer3, pointer1, pointer1, pointer3)) t4 := Thing1{} t5 := t4 fail(t, so(t4, ShouldPointTo, t5), "Both arguments should be pointers (the first was not)!") fail(t, so(&t4, ShouldPointTo, t5), "Both arguments should be pointers (the second was not)!") fail(t, so(nil, ShouldPointTo, nil), "Both arguments should be pointers (the first was nil)!") fail(t, so(&t4, ShouldPointTo, nil), "Both arguments should be pointers (the second was nil)!") } func TestShouldNotPointTo(t *testing.T) { t1 := &Thing1{} t2 := t1 t3 := &Thing1{} pointer1 := reflect.ValueOf(t1).Pointer() fail(t, so(t1, ShouldNotPointTo), "This assertion requires exactly 1 comparison values (you provided 0).") fail(t, so(t1, ShouldNotPointTo, t2, t3), "This assertion requires exactly 1 comparison values (you provided 2).") pass(t, so(t1, ShouldNotPointTo, t3)) fail(t, so(t1, ShouldNotPointTo, t2), fmt.Sprintf("Expected '&{a:}' and '&{a:}' to be different references (but they matched: '%v')!", pointer1)) t4 := Thing1{} t5 := t4 fail(t, so(t4, ShouldNotPointTo, t5), "Both arguments should be pointers (the first was not)!") fail(t, so(&t4, ShouldNotPointTo, t5), "Both arguments should be pointers (the second was not)!") fail(t, so(nil, ShouldNotPointTo, nil), "Both arguments should be pointers (the first was nil)!") fail(t, so(&t4, ShouldNotPointTo, nil), "Both arguments should be pointers (the second was nil)!") } func TestShouldBeNil(t *testing.T) { fail(t, so(nil, ShouldBeNil, nil, nil, nil), "This assertion requires exactly 0 comparison values (you provided 3).") fail(t, so(nil, ShouldBeNil, nil), "This assertion requires exactly 0 comparison values (you provided 1).") pass(t, so(nil, ShouldBeNil)) fail(t, so(1, ShouldBeNil), "Expected: nil Actual: '1'") var thing Thinger pass(t, so(thing, ShouldBeNil)) thing = &Thing{} fail(t, so(thing, ShouldBeNil), "Expected: nil Actual: '&{}'") var thingOne *Thing1 pass(t, so(thingOne, ShouldBeNil)) var nilSlice []int = nil pass(t, so(nilSlice, ShouldBeNil)) var nilMap map[string]string = nil pass(t, so(nilMap, ShouldBeNil)) var nilChannel chan int = nil pass(t, so(nilChannel, ShouldBeNil)) var nilFunc func() = nil pass(t, so(nilFunc, ShouldBeNil)) var nilInterface interface{} = nil pass(t, so(nilInterface, ShouldBeNil)) } func TestShouldNotBeNil(t *testing.T) { fail(t, so(nil, ShouldNotBeNil, nil, nil, nil), "This assertion requires exactly 0 comparison values (you provided 3).") fail(t, so(nil, ShouldNotBeNil, nil), "This assertion requires exactly 0 comparison values (you provided 1).") fail(t, so(nil, ShouldNotBeNil), "Expected '' to NOT be nil (but it was)!") pass(t, so(1, ShouldNotBeNil)) var thing Thinger fail(t, so(thing, ShouldNotBeNil), "Expected '' to NOT be nil (but it was)!") thing = &Thing{} pass(t, so(thing, ShouldNotBeNil)) } func TestShouldBeTrue(t *testing.T) { fail(t, so(true, ShouldBeTrue, 1, 2, 3), "This assertion requires exactly 0 comparison values (you provided 3).") fail(t, so(true, ShouldBeTrue, 1), "This assertion requires exactly 0 comparison values (you provided 1).") fail(t, so(false, ShouldBeTrue), "Expected: true Actual: false") fail(t, so(1, ShouldBeTrue), "Expected: true Actual: 1") pass(t, so(true, ShouldBeTrue)) } func TestShouldBeFalse(t *testing.T) { fail(t, so(false, ShouldBeFalse, 1, 2, 3), "This assertion requires exactly 0 comparison values (you provided 3).") fail(t, so(false, ShouldBeFalse, 1), "This assertion requires exactly 0 comparison values (you provided 1).") fail(t, so(true, ShouldBeFalse), "Expected: false Actual: true") fail(t, so(1, ShouldBeFalse), "Expected: false Actual: 1") pass(t, so(false, ShouldBeFalse)) } func TestShouldBeZeroValue(t *testing.T) { serializer = newFakeSerializer() fail(t, so(0, ShouldBeZeroValue, 1, 2, 3), "This assertion requires exactly 0 comparison values (you provided 3).") fail(t, so(false, ShouldBeZeroValue, true), "This assertion requires exactly 0 comparison values (you provided 1).") fail(t, so(1, ShouldBeZeroValue), "0|1|'1' should have been the zero value") //"Expected: (zero value) Actual: 1") fail(t, so(true, ShouldBeZeroValue), "false|true|'true' should have been the zero value") //"Expected: (zero value) Actual: true") fail(t, so("123", ShouldBeZeroValue), "|123|'123' should have been the zero value") //"Expected: (zero value) Actual: 123") fail(t, so(" ", ShouldBeZeroValue), "| |' ' should have been the zero value") //"Expected: (zero value) Actual: ") fail(t, so([]string{"Nonempty"}, ShouldBeZeroValue), "[]|[Nonempty]|'[Nonempty]' should have been the zero value") //"Expected: (zero value) Actual: [Nonempty]") fail(t, so(struct{ a string }{a: "asdf"}, ShouldBeZeroValue), "{}|{asdf}|'{a:asdf}' should have been the zero value") pass(t, so(0, ShouldBeZeroValue)) pass(t, so(false, ShouldBeZeroValue)) pass(t, so("", ShouldBeZeroValue)) pass(t, so(struct{}{}, ShouldBeZeroValue)) }mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/filter.go000066400000000000000000000011001321131462300272300ustar00rootroot00000000000000package assertions import "fmt" const ( success = "" needExactValues = "This assertion requires exactly %d comparison values (you provided %d)." needNonEmptyCollection = "This assertion requires at least 1 comparison value (you provided 0)." ) func need(needed int, expected []interface{}) string { if len(expected) != needed { return fmt.Sprintf(needExactValues, needed, len(expected)) } return success } func atLeast(minimum int, expected []interface{}) string { if len(expected) < 1 { return needNonEmptyCollection } return success } mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/000077500000000000000000000000001321131462300272405ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/Makefile000066400000000000000000000014771321131462300307110ustar00rootroot00000000000000# This Makefile pulls the latest oglematchers (with dependencies), # rewrites the imports to match this location, # and ensures that all the tests pass. go: clean clone rewrite clean: rm -rf ogle* rm -rf reqtrace rm -rf go-render clone: git clone https://github.com/jacobsa/ogletest.git && rm -rf ogletest/.git git clone https://github.com/jacobsa/oglemock.git && rm -rf oglemock/.git git clone https://github.com/jacobsa/oglematchers.git && rm -rf oglematchers/.git git clone https://github.com/jacobsa/reqtrace.git && rm -rf reqtrace/.git git clone https://github.com/luci/go-render.git && rm -rf go-render/.git rewrite: grep -rl --exclude Makefile 'github.com/jacobsa' . | xargs sed -i '' 's#github.com/jacobsa#github.com/smartystreets/assertions/internal#g' test: go test github.com/smartystreets/assertions/... mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/go-render/000077500000000000000000000000001321131462300311225ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/go-render/.travis.yml000066400000000000000000000011231321131462300332300ustar00rootroot00000000000000# Copyright (c) 2015 The Chromium Authors. All rights reserved. # Use of this source code is governed by a BSD-style license that can be # found in the LICENSE file. # {sudo: required, dist: trusty} is the magic incantation to pick the trusty # beta environment, which is the only environment we can get that has >4GB # memory. Currently the `go test -race` tests that we run will peak at just # over 4GB, which results in everything getting OOM-killed. sudo: required dist: trusty language: go go: - 1.4.2 before_install: - go get github.com/maruel/pre-commit-go/cmd/pcg script: - pcg mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/go-render/LICENSE000066400000000000000000000030331321131462300321260ustar00rootroot00000000000000// Copyright (c) 2015 The Chromium 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. mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/go-render/PRESUBMIT.py000066400000000000000000000066601321131462300330560ustar00rootroot00000000000000# Copyright 2015 The Chromium Authors. All rights reserved. # Use of this source code is governed by a BSD-style license that can be # found in the LICENSE file. """Top-level presubmit script. See https://dev.chromium.org/developers/how-tos/depottools/presubmit-scripts for details on the presubmit API built into depot_tools. """ import os import sys def PreCommitGo(input_api, output_api, pcg_mode): """Run go-specific checks via pre-commit-go (pcg) if it's in PATH.""" if input_api.is_committing: error_type = output_api.PresubmitError else: error_type = output_api.PresubmitPromptWarning exe = 'pcg.exe' if sys.platform == 'win32' else 'pcg' pcg = None for p in os.environ['PATH'].split(os.pathsep): pcg = os.path.join(p, exe) if os.access(pcg, os.X_OK): break else: return [ error_type( 'pre-commit-go executable (pcg) could not be found in PATH. All Go ' 'checks are skipped. See https://github.com/maruel/pre-commit-go.') ] cmd = [pcg, 'run', '-m', ','.join(pcg_mode)] if input_api.verbose: cmd.append('-v') # pcg can figure out what files to check on its own based on upstream ref, # but on PRESUBMIT try builder upsteram isn't set, and it's just 1 commit. if os.getenv('PRESUBMIT_BUILDER', ''): cmd.extend(['-r', 'HEAD~1']) return input_api.RunTests([ input_api.Command( name='pre-commit-go: %s' % ', '.join(pcg_mode), cmd=cmd, kwargs={}, message=error_type), ]) def header(input_api): """Returns the expected license header regexp for this project.""" current_year = int(input_api.time.strftime('%Y')) allowed_years = (str(s) for s in reversed(xrange(2011, current_year + 1))) years_re = '(' + '|'.join(allowed_years) + ')' license_header = ( r'.*? Copyright %(year)s The Chromium Authors\. ' r'All rights reserved\.\n' r'.*? Use of this source code is governed by a BSD-style license ' r'that can be\n' r'.*? found in the LICENSE file\.(?: \*/)?\n' ) % { 'year': years_re, } return license_header def source_file_filter(input_api): """Returns filter that selects source code files only.""" bl = list(input_api.DEFAULT_BLACK_LIST) + [ r'.+\.pb\.go$', r'.+_string\.go$', ] wl = list(input_api.DEFAULT_WHITE_LIST) + [ r'.+\.go$', ] return lambda x: input_api.FilterSourceFile(x, white_list=wl, black_list=bl) def CommonChecks(input_api, output_api): results = [] results.extend( input_api.canned_checks.CheckChangeHasNoStrayWhitespace( input_api, output_api, source_file_filter=source_file_filter(input_api))) results.extend( input_api.canned_checks.CheckLicense( input_api, output_api, header(input_api), source_file_filter=source_file_filter(input_api))) return results def CheckChangeOnUpload(input_api, output_api): results = CommonChecks(input_api, output_api) results.extend(PreCommitGo(input_api, output_api, ['lint', 'pre-commit'])) return results def CheckChangeOnCommit(input_api, output_api): results = CommonChecks(input_api, output_api) results.extend(input_api.canned_checks.CheckChangeHasDescription( input_api, output_api)) results.extend(input_api.canned_checks.CheckDoNotSubmitInDescription( input_api, output_api)) results.extend(input_api.canned_checks.CheckDoNotSubmitInFiles( input_api, output_api)) results.extend(PreCommitGo( input_api, output_api, ['continuous-integration'])) return results mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/go-render/README.md000066400000000000000000000051151321131462300324030ustar00rootroot00000000000000go-render: A verbose recursive Go type-to-string conversion library. ==================================================================== [![GoDoc](https://godoc.org/github.com/luci/go-render?status.svg)](https://godoc.org/github.com/luci/go-render) [![Build Status](https://travis-ci.org/luci/go-render.svg)](https://travis-ci.org/luci/go-render) This is not an official Google product. ## Overview The *render* package implements a more verbose form of the standard Go string formatter, `fmt.Sprintf("%#v", value)`, adding: - Pointer recursion. Normally, Go stops at the first pointer and prints its address. The *render* package will recurse and continue to render pointer values. - Recursion loop detection. Recursion is nice, but if a recursion path detects a loop, *render* will note this and move on. - Custom type name rendering. - Deterministic key sorting for `string`- and `int`-keyed maps. - Testing! Call `render.Render` and pass it an `interface{}`. For example: ```Go type customType int type testStruct struct { S string V *map[string]int I interface{} } a := testStruct{ S: "hello", V: &map[string]int{"foo": 0, "bar": 1}, I: customType(42), } fmt.Println("Render test:") fmt.Printf("fmt.Printf: %#v\n", a))) fmt.Printf("render.Render: %s\n", Render(a)) ``` Yields: ``` fmt.Printf: render.testStruct{S:"hello", V:(*map[string]int)(0x600dd065), I:42} render.Render: render.testStruct{S:"hello", V:(*map[string]int){"bar":1, "foo":0}, I:render.customType(42)} ``` This is not intended to be a high-performance library, but it's not terrible either. Contributing ------------ * Sign the [Google CLA](https://cla.developers.google.com/clas). * Make sure your `user.email` and `user.name` are configured in `git config`. * Install the [pcg](https://github.com/maruel/pre-commit-go) git hook: `go get -u github.com/maruel/pre-commit-go/cmd/... && pcg` Run the following to setup the code review tool and create your first review: git clone https://chromium.googlesource.com/chromium/tools/depot_tools.git $HOME/src/depot_tools export PATH="$PATH:$HOME/src/depot_tools" cd $GOROOT/github.com/luci/go-render git checkout -b work origin/master # hack hack git commit -a -m "This is awesome\nR=joe@example.com" # This will ask for your Google Account credentials. git cl upload -s # Wait for LGTM over email. # Check the commit queue box in codereview website. # Wait for the change to be tested and landed automatically. Use `git cl help` and `git cl help ` for more details. mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/go-render/WATCHLISTS000066400000000000000000000010641321131462300325330ustar00rootroot00000000000000# Copyright 2015 The Chromium Authors. All rights reserved. # Use of this source code is governed by a BSD-style license that can be # found in the LICENSE file. # Watchlist Rules # Refer: http://dev.chromium.org/developers/contributing-code/watchlists { 'WATCHLIST_DEFINITIONS': { 'all': { 'filepath': '.+', }, }, 'WATCHLISTS': { 'all': [ # Add yourself here to get explicitly spammed. 'maruel@chromium.org', 'tandrii+luci-go@chromium.org', 'todd@cloudera.com', 'andrew.wang@cloudera.com', ], }, } pre-commit-go.yml000066400000000000000000000030651321131462300342510ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/go-render# https://github.com/maruel/pre-commit-go configuration file to run checks # automatically on commit, on push and on continuous integration service after # a push or on merge of a pull request. # # See https://godoc.org/github.com/maruel/pre-commit-go/checks for more # information. min_version: 0.4.7 modes: continuous-integration: checks: build: - build_all: false extra_args: [] coverage: - use_global_inference: false use_coveralls: true global: min_coverage: 50 max_coverage: 100 per_dir_default: min_coverage: 1 max_coverage: 100 per_dir: {} gofmt: - {} goimports: - {} test: - extra_args: - -v - -race max_duration: 600 lint: checks: golint: - blacklist: [] govet: - blacklist: - ' composite literal uses unkeyed fields' max_duration: 15 pre-commit: checks: build: - build_all: false extra_args: [] gofmt: - {} test: - extra_args: - -short max_duration: 35 pre-push: checks: coverage: - use_global_inference: false use_coveralls: false global: min_coverage: 50 max_coverage: 100 per_dir_default: min_coverage: 1 max_coverage: 100 per_dir: {} goimports: - {} test: - extra_args: - -v - -race max_duration: 35 ignore_patterns: - .* - _* - '*.pb.go' - '*_string.go' - '*-gen.go' mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/go-render/render/000077500000000000000000000000001321131462300324015ustar00rootroot00000000000000render.go000066400000000000000000000163121321131462300341330ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/go-render/render// Copyright 2015 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. package render import ( "bytes" "fmt" "reflect" "sort" "strconv" ) var implicitTypeMap = map[reflect.Kind]string{ reflect.Bool: "bool", reflect.String: "string", reflect.Int: "int", reflect.Int8: "int8", reflect.Int16: "int16", reflect.Int32: "int32", reflect.Int64: "int64", reflect.Uint: "uint", reflect.Uint8: "uint8", reflect.Uint16: "uint16", reflect.Uint32: "uint32", reflect.Uint64: "uint64", reflect.Float32: "float32", reflect.Float64: "float64", reflect.Complex64: "complex64", reflect.Complex128: "complex128", } // Render converts a structure to a string representation. Unline the "%#v" // format string, this resolves pointer types' contents in structs, maps, and // slices/arrays and prints their field values. func Render(v interface{}) string { buf := bytes.Buffer{} s := (*traverseState)(nil) s.render(&buf, 0, reflect.ValueOf(v)) return buf.String() } // renderPointer is called to render a pointer value. // // This is overridable so that the test suite can have deterministic pointer // values in its expectations. var renderPointer = func(buf *bytes.Buffer, p uintptr) { fmt.Fprintf(buf, "0x%016x", p) } // traverseState is used to note and avoid recursion as struct members are being // traversed. // // traverseState is allowed to be nil. Specifically, the root state is nil. type traverseState struct { parent *traverseState ptr uintptr } func (s *traverseState) forkFor(ptr uintptr) *traverseState { for cur := s; cur != nil; cur = cur.parent { if ptr == cur.ptr { return nil } } fs := &traverseState{ parent: s, ptr: ptr, } return fs } func (s *traverseState) render(buf *bytes.Buffer, ptrs int, v reflect.Value) { if v.Kind() == reflect.Invalid { buf.WriteString("nil") return } vt := v.Type() // If the type being rendered is a potentially recursive type (a type that // can contain itself as a member), we need to avoid recursion. // // If we've already seen this type before, mark that this is the case and // write a recursion placeholder instead of actually rendering it. // // If we haven't seen it before, fork our `seen` tracking so any higher-up // renderers will also render it at least once, then mark that we've seen it // to avoid recursing on lower layers. pe := uintptr(0) vk := vt.Kind() switch vk { case reflect.Ptr: // Since structs and arrays aren't pointers, they can't directly be // recursed, but they can contain pointers to themselves. Record their // pointer to avoid this. switch v.Elem().Kind() { case reflect.Struct, reflect.Array: pe = v.Pointer() } case reflect.Slice, reflect.Map: pe = v.Pointer() } if pe != 0 { s = s.forkFor(pe) if s == nil { buf.WriteString("") return } } switch vk { case reflect.Struct: writeType(buf, ptrs, vt) buf.WriteRune('{') for i := 0; i < vt.NumField(); i++ { if i > 0 { buf.WriteString(", ") } buf.WriteString(vt.Field(i).Name) buf.WriteRune(':') s.render(buf, 0, v.Field(i)) } buf.WriteRune('}') case reflect.Slice: if v.IsNil() { writeType(buf, ptrs, vt) buf.WriteString("(nil)") return } fallthrough case reflect.Array: writeType(buf, ptrs, vt) buf.WriteString("{") for i := 0; i < v.Len(); i++ { if i > 0 { buf.WriteString(", ") } s.render(buf, 0, v.Index(i)) } buf.WriteRune('}') case reflect.Map: writeType(buf, ptrs, vt) if v.IsNil() { buf.WriteString("(nil)") } else { buf.WriteString("{") mkeys := v.MapKeys() tryAndSortMapKeys(vt, mkeys) for i, mk := range mkeys { if i > 0 { buf.WriteString(", ") } s.render(buf, 0, mk) buf.WriteString(":") s.render(buf, 0, v.MapIndex(mk)) } buf.WriteRune('}') } case reflect.Ptr: ptrs++ fallthrough case reflect.Interface: if v.IsNil() { writeType(buf, ptrs, v.Type()) buf.WriteRune('(') fmt.Fprint(buf, "nil") buf.WriteRune(')') } else { s.render(buf, ptrs, v.Elem()) } case reflect.Chan, reflect.Func, reflect.UnsafePointer: writeType(buf, ptrs, vt) buf.WriteRune('(') renderPointer(buf, v.Pointer()) buf.WriteRune(')') default: tstr := vt.String() implicit := ptrs == 0 && implicitTypeMap[vk] == tstr if !implicit { writeType(buf, ptrs, vt) buf.WriteRune('(') } switch vk { case reflect.String: fmt.Fprintf(buf, "%q", v.String()) case reflect.Bool: fmt.Fprintf(buf, "%v", v.Bool()) case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: fmt.Fprintf(buf, "%d", v.Int()) case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64: fmt.Fprintf(buf, "%d", v.Uint()) case reflect.Float32, reflect.Float64: fmt.Fprintf(buf, "%g", v.Float()) case reflect.Complex64, reflect.Complex128: fmt.Fprintf(buf, "%g", v.Complex()) } if !implicit { buf.WriteRune(')') } } } func writeType(buf *bytes.Buffer, ptrs int, t reflect.Type) { parens := ptrs > 0 switch t.Kind() { case reflect.Chan, reflect.Func, reflect.UnsafePointer: parens = true } if parens { buf.WriteRune('(') for i := 0; i < ptrs; i++ { buf.WriteRune('*') } } switch t.Kind() { case reflect.Ptr: if ptrs == 0 { // This pointer was referenced from within writeType (e.g., as part of // rendering a list), and so hasn't had its pointer asterisk accounted // for. buf.WriteRune('*') } writeType(buf, 0, t.Elem()) case reflect.Interface: if n := t.Name(); n != "" { buf.WriteString(t.String()) } else { buf.WriteString("interface{}") } case reflect.Array: buf.WriteRune('[') buf.WriteString(strconv.FormatInt(int64(t.Len()), 10)) buf.WriteRune(']') writeType(buf, 0, t.Elem()) case reflect.Slice: if t == reflect.SliceOf(t.Elem()) { buf.WriteString("[]") writeType(buf, 0, t.Elem()) } else { // Custom slice type, use type name. buf.WriteString(t.String()) } case reflect.Map: if t == reflect.MapOf(t.Key(), t.Elem()) { buf.WriteString("map[") writeType(buf, 0, t.Key()) buf.WriteRune(']') writeType(buf, 0, t.Elem()) } else { // Custom map type, use type name. buf.WriteString(t.String()) } default: buf.WriteString(t.String()) } if parens { buf.WriteRune(')') } } type sortableValueSlice struct { kind reflect.Kind elements []reflect.Value } func (s *sortableValueSlice) Len() int { return len(s.elements) } func (s *sortableValueSlice) Less(i, j int) bool { switch s.kind { case reflect.String: return s.elements[i].String() < s.elements[j].String() case reflect.Int: return s.elements[i].Int() < s.elements[j].Int() default: panic(fmt.Errorf("unsupported sort kind: %s", s.kind)) } } func (s *sortableValueSlice) Swap(i, j int) { s.elements[i], s.elements[j] = s.elements[j], s.elements[i] } func tryAndSortMapKeys(mt reflect.Type, k []reflect.Value) { // Try our stock sortable values. switch mt.Key().Kind() { case reflect.String, reflect.Int: vs := &sortableValueSlice{ kind: mt.Key().Kind(), elements: k, } sort.Sort(vs) } } render_test.go000066400000000000000000000113611321131462300351710ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/go-render/render// Copyright 2015 Google Inc. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. package render import ( "bytes" "fmt" "regexp" "runtime" "testing" ) func init() { // For testing purposes, pointers will render as "PTR" so that they are // deterministic. renderPointer = func(buf *bytes.Buffer, p uintptr) { buf.WriteString("PTR") } } func assertRendersLike(t *testing.T, name string, v interface{}, exp string) { act := Render(v) if act != exp { _, _, line, _ := runtime.Caller(1) t.Errorf("On line #%d, [%s] did not match expectations:\nExpected: %s\nActual : %s\n", line, name, exp, act) } } func TestRenderList(t *testing.T) { t.Parallel() // Note that we make some of the fields exportable. This is to avoid a fun case // where the first reflect.Value has a read-only bit set, but follow-on values // do not, so recursion tests are off by one. type testStruct struct { Name string I interface{} m string } type myStringSlice []string type myStringMap map[string]string type myIntType int type myStringType string s0 := "string0" s0P := &s0 mit := myIntType(42) stringer := fmt.Stringer(nil) for i, tc := range []struct { a interface{} s string }{ {nil, `nil`}, {make(chan int), `(chan int)(PTR)`}, {&stringer, `(*fmt.Stringer)(nil)`}, {123, `123`}, {"hello", `"hello"`}, {(*testStruct)(nil), `(*render.testStruct)(nil)`}, {(**testStruct)(nil), `(**render.testStruct)(nil)`}, {[]***testStruct(nil), `[]***render.testStruct(nil)`}, {testStruct{Name: "foo", I: &testStruct{Name: "baz"}}, `render.testStruct{Name:"foo", I:(*render.testStruct){Name:"baz", I:interface{}(nil), m:""}, m:""}`}, {[]byte(nil), `[]uint8(nil)`}, {[]byte{}, `[]uint8{}`}, {map[string]string(nil), `map[string]string(nil)`}, {[]*testStruct{ {Name: "foo"}, {Name: "bar"}, }, `[]*render.testStruct{(*render.testStruct){Name:"foo", I:interface{}(nil), m:""}, ` + `(*render.testStruct){Name:"bar", I:interface{}(nil), m:""}}`}, {myStringSlice{"foo", "bar"}, `render.myStringSlice{"foo", "bar"}`}, {myStringMap{"foo": "bar"}, `render.myStringMap{"foo":"bar"}`}, {myIntType(12), `render.myIntType(12)`}, {&mit, `(*render.myIntType)(42)`}, {myStringType("foo"), `render.myStringType("foo")`}, {struct { a int b string }{123, "foo"}, `struct { a int; b string }{a:123, b:"foo"}`}, {[]string{"foo", "foo", "bar", "baz", "qux", "qux"}, `[]string{"foo", "foo", "bar", "baz", "qux", "qux"}`}, {[...]int{1, 2, 3}, `[3]int{1, 2, 3}`}, {map[string]bool{ "foo": true, "bar": false, }, `map[string]bool{"bar":false, "foo":true}`}, {map[int]string{1: "foo", 2: "bar"}, `map[int]string{1:"foo", 2:"bar"}`}, {uint32(1337), `1337`}, {3.14, `3.14`}, {complex(3, 0.14), `(3+0.14i)`}, {&s0, `(*string)("string0")`}, {&s0P, `(**string)("string0")`}, {[]interface{}{nil, 1, 2, nil}, `[]interface{}{interface{}(nil), 1, 2, interface{}(nil)}`}, } { assertRendersLike(t, fmt.Sprintf("Input #%d", i), tc.a, tc.s) } } func TestRenderRecursiveStruct(t *testing.T) { type testStruct struct { Name string I interface{} } s := &testStruct{ Name: "recursive", } s.I = s assertRendersLike(t, "Recursive struct", s, `(*render.testStruct){Name:"recursive", I:}`) } func TestRenderRecursiveArray(t *testing.T) { a := [2]interface{}{} a[0] = &a a[1] = &a assertRendersLike(t, "Recursive array", &a, `(*[2]interface{}){, }`) } func TestRenderRecursiveMap(t *testing.T) { m := map[string]interface{}{} foo := "foo" m["foo"] = m m["bar"] = [](*string){&foo, &foo} v := []map[string]interface{}{m, m} assertRendersLike(t, "Recursive map", v, `[]map[string]interface{}{map[string]interface{}{`+ `"bar":[]*string{(*string)("foo"), (*string)("foo")}, `+ `"foo":}, `+ `map[string]interface{}{`+ `"bar":[]*string{(*string)("foo"), (*string)("foo")}, `+ `"foo":}}`) } func ExampleInReadme() { type customType int type testStruct struct { S string V *map[string]int I interface{} } a := testStruct{ S: "hello", V: &map[string]int{"foo": 0, "bar": 1}, I: customType(42), } fmt.Println("Render test:") fmt.Printf("fmt.Printf: %s\n", sanitizePointer(fmt.Sprintf("%#v", a))) fmt.Printf("render.Render: %s\n", Render(a)) // Output: Render test: // fmt.Printf: render.testStruct{S:"hello", V:(*map[string]int)(0x600dd065), I:42} // render.Render: render.testStruct{S:"hello", V:(*map[string]int){"bar":1, "foo":0}, I:render.customType(42)} } var pointerRE = regexp.MustCompile(`\(0x[a-f0-9]+\)`) func sanitizePointer(s string) string { return pointerRE.ReplaceAllString(s, "(0x600dd065)") } mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/000077500000000000000000000000001321131462300317155ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/.gitignore000066400000000000000000000000441321131462300337030ustar00rootroot00000000000000*.6 6.out _obj/ _test/ _testmain.go mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/.travis.yml000066400000000000000000000001671321131462300340320ustar00rootroot00000000000000# Cf. http://docs.travis-ci.com/user/getting-started/ # Cf. http://docs.travis-ci.com/user/languages/go/ language: go mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/LICENSE000066400000000000000000000261361321131462300327320ustar00rootroot00000000000000 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. mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/README.md000066400000000000000000000037531321131462300332040ustar00rootroot00000000000000[![GoDoc](https://godoc.org/github.com/smartystreets/assertions/internal/oglematchers?status.svg)](https://godoc.org/github.com/smartystreets/assertions/internal/oglematchers) `oglematchers` is a package for the Go programming language containing a set of matchers, useful in a testing or mocking framework, inspired by and mostly compatible with [Google Test][googletest] for C++ and [Google JS Test][google-js-test]. The package is used by the [ogletest][ogletest] testing framework and [oglemock][oglemock] mocking framework, which may be more directly useful to you, but can be generically used elsewhere as well. A "matcher" is simply an object with a `Matches` method defining a set of golang values matched by the matcher, and a `Description` method describing that set. For example, here are some matchers: ```go // Numbers Equals(17.13) LessThan(19) // Strings Equals("taco") HasSubstr("burrito") MatchesRegex("t.*o") // Combining matchers AnyOf(LessThan(17), GreaterThan(19)) ``` There are lots more; see [here][reference] for a reference. You can also add your own simply by implementing the `oglematchers.Matcher` interface. Installation ------------ First, make sure you have installed Go 1.0.2 or newer. See [here][golang-install] for instructions. Use the following command to install `oglematchers` and keep it up to date: go get -u github.com/smartystreets/assertions/internal/oglematchers Documentation ------------- See [here][reference] for documentation. Alternatively, you can install the package and then use `godoc`: godoc github.com/smartystreets/assertions/internal/oglematchers [reference]: http://godoc.org/github.com/smartystreets/assertions/internal/oglematchers [golang-install]: http://golang.org/doc/install.html [googletest]: http://code.google.com/p/googletest/ [google-js-test]: http://code.google.com/p/google-js-test/ [ogletest]: http://github.com/smartystreets/assertions/internal/ogletest [oglemock]: http://github.com/smartystreets/assertions/internal/oglemock mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/all_of.go000066400000000000000000000040011321131462300334730ustar00rootroot00000000000000// Copyright 2011 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers import ( "strings" ) // AllOf accepts a set of matchers S and returns a matcher that follows the // algorithm below when considering a candidate c: // // 1. Return true if for every Matcher m in S, m matches c. // // 2. Otherwise, if there is a matcher m in S such that m returns a fatal // error for c, return that matcher's error message. // // 3. Otherwise, return false with the error from some wrapped matcher. // // This is akin to a logical AND operation for matchers. func AllOf(matchers ...Matcher) Matcher { return &allOfMatcher{matchers} } type allOfMatcher struct { wrappedMatchers []Matcher } func (m *allOfMatcher) Description() string { // Special case: the empty set. if len(m.wrappedMatchers) == 0 { return "is anything" } // Join the descriptions for the wrapped matchers. wrappedDescs := make([]string, len(m.wrappedMatchers)) for i, wrappedMatcher := range m.wrappedMatchers { wrappedDescs[i] = wrappedMatcher.Description() } return strings.Join(wrappedDescs, ", and ") } func (m *allOfMatcher) Matches(c interface{}) (err error) { for _, wrappedMatcher := range m.wrappedMatchers { if wrappedErr := wrappedMatcher.Matches(c); wrappedErr != nil { err = wrappedErr // If the error is fatal, return immediately with this error. _, ok := wrappedErr.(*FatalError) if ok { return } } } return } all_of_test.go000066400000000000000000000054431321131462300344660ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglematchers// Copyright 2011 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers_test import ( . "github.com/smartystreets/assertions/internal/oglematchers" . "github.com/smartystreets/assertions/internal/ogletest" "errors" ) //////////////////////////////////////////////////////////////////////// // Helpers //////////////////////////////////////////////////////////////////////// type allOfFakeMatcher struct { desc string err error } func (m *allOfFakeMatcher) Matches(c interface{}) error { return m.err } func (m *allOfFakeMatcher) Description() string { return m.desc } type AllOfTest struct { } func init() { RegisterTestSuite(&AllOfTest{}) } //////////////////////////////////////////////////////////////////////// // Tests //////////////////////////////////////////////////////////////////////// func (t *AllOfTest) DescriptionWithEmptySet() { m := AllOf() ExpectEq("is anything", m.Description()) } func (t *AllOfTest) DescriptionWithOneMatcher() { m := AllOf(&allOfFakeMatcher{"taco", errors.New("")}) ExpectEq("taco", m.Description()) } func (t *AllOfTest) DescriptionWithMultipleMatchers() { m := AllOf( &allOfFakeMatcher{"taco", errors.New("")}, &allOfFakeMatcher{"burrito", errors.New("")}, &allOfFakeMatcher{"enchilada", errors.New("")}) ExpectEq("taco, and burrito, and enchilada", m.Description()) } func (t *AllOfTest) EmptySet() { m := AllOf() err := m.Matches(17) ExpectEq(nil, err) } func (t *AllOfTest) OneMatcherReturnsFatalErrorAndSomeOthersFail() { m := AllOf( &allOfFakeMatcher{"", errors.New("")}, &allOfFakeMatcher{"", NewFatalError("taco")}, &allOfFakeMatcher{"", errors.New("")}, &allOfFakeMatcher{"", nil}) err := m.Matches(17) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("taco"))) } func (t *AllOfTest) OneMatcherReturnsNonFatalAndOthersSayTrue() { m := AllOf( &allOfFakeMatcher{"", nil}, &allOfFakeMatcher{"", errors.New("taco")}, &allOfFakeMatcher{"", nil}) err := m.Matches(17) ExpectFalse(isFatal(err)) ExpectThat(err, Error(Equals("taco"))) } func (t *AllOfTest) AllMatchersSayTrue() { m := AllOf( &allOfFakeMatcher{"", nil}, &allOfFakeMatcher{"", nil}, &allOfFakeMatcher{"", nil}) err := m.Matches(17) ExpectEq(nil, err) } mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/any.go000066400000000000000000000016551321131462300330420ustar00rootroot00000000000000// Copyright 2011 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers // Any returns a matcher that matches any value. func Any() Matcher { return &anyMatcher{} } type anyMatcher struct { } func (m *anyMatcher) Description() string { return "is anything" } func (m *anyMatcher) Matches(c interface{}) error { return nil } mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/any_of.go000066400000000000000000000051371321131462300335250ustar00rootroot00000000000000// Copyright 2011 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers import ( "errors" "fmt" "reflect" "strings" ) // AnyOf accepts a set of values S and returns a matcher that follows the // algorithm below when considering a candidate c: // // 1. If there exists a value m in S such that m implements the Matcher // interface and m matches c, return true. // // 2. Otherwise, if there exists a value v in S such that v does not implement // the Matcher interface and the matcher Equals(v) matches c, return true. // // 3. Otherwise, if there is a value m in S such that m implements the Matcher // interface and m returns a fatal error for c, return that fatal error. // // 4. Otherwise, return false. // // This is akin to a logical OR operation for matchers, with non-matchers x // being treated as Equals(x). func AnyOf(vals ...interface{}) Matcher { // Get ahold of a type variable for the Matcher interface. var dummy *Matcher matcherType := reflect.TypeOf(dummy).Elem() // Create a matcher for each value, or use the value itself if it's already a // matcher. wrapped := make([]Matcher, len(vals)) for i, v := range vals { t := reflect.TypeOf(v) if t != nil && t.Implements(matcherType) { wrapped[i] = v.(Matcher) } else { wrapped[i] = Equals(v) } } return &anyOfMatcher{wrapped} } type anyOfMatcher struct { wrapped []Matcher } func (m *anyOfMatcher) Description() string { wrappedDescs := make([]string, len(m.wrapped)) for i, matcher := range m.wrapped { wrappedDescs[i] = matcher.Description() } return fmt.Sprintf("or(%s)", strings.Join(wrappedDescs, ", ")) } func (m *anyOfMatcher) Matches(c interface{}) (err error) { err = errors.New("") // Try each matcher in turn. for _, matcher := range m.wrapped { wrappedErr := matcher.Matches(c) // Return immediately if there's a match. if wrappedErr == nil { err = nil return } // Note the fatal error, if any. if _, isFatal := wrappedErr.(*FatalError); isFatal { err = wrappedErr } } return } any_of_test.go000066400000000000000000000061011321131462300344750ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglematchers// Copyright 2011 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers_test import ( "errors" . "github.com/smartystreets/assertions/internal/oglematchers" . "github.com/smartystreets/assertions/internal/ogletest" ) //////////////////////////////////////////////////////////////////////// // Helpers //////////////////////////////////////////////////////////////////////// type fakeAnyOfMatcher struct { desc string err error } func (m *fakeAnyOfMatcher) Matches(c interface{}) error { return m.err } func (m *fakeAnyOfMatcher) Description() string { return m.desc } type AnyOfTest struct { } func init() { RegisterTestSuite(&AnyOfTest{}) } //////////////////////////////////////////////////////////////////////// // Tests //////////////////////////////////////////////////////////////////////// func (t *AnyOfTest) EmptySet() { matcher := AnyOf() err := matcher.Matches(0) ExpectThat(err, Error(Equals(""))) } func (t *AnyOfTest) OneTrue() { matcher := AnyOf( &fakeAnyOfMatcher{"", NewFatalError("foo")}, 17, &fakeAnyOfMatcher{"", errors.New("foo")}, &fakeAnyOfMatcher{"", nil}, &fakeAnyOfMatcher{"", errors.New("foo")}, ) err := matcher.Matches(0) ExpectEq(nil, err) } func (t *AnyOfTest) OneEqual() { matcher := AnyOf( &fakeAnyOfMatcher{"", NewFatalError("foo")}, &fakeAnyOfMatcher{"", errors.New("foo")}, 13, "taco", 19, &fakeAnyOfMatcher{"", errors.New("foo")}, ) err := matcher.Matches("taco") ExpectEq(nil, err) } func (t *AnyOfTest) OneFatal() { matcher := AnyOf( &fakeAnyOfMatcher{"", errors.New("foo")}, 17, &fakeAnyOfMatcher{"", NewFatalError("taco")}, &fakeAnyOfMatcher{"", errors.New("foo")}, ) err := matcher.Matches(0) ExpectThat(err, Error(Equals("taco"))) } func (t *AnyOfTest) OneNil() { var err error matcher := AnyOf( 13, nil, 19, ) // No match err = matcher.Matches(14) ExpectNe(nil, err) // Match err = matcher.Matches(nil) ExpectEq(nil, err) } func (t *AnyOfTest) AllFalseAndNotEqual() { matcher := AnyOf( &fakeAnyOfMatcher{"", errors.New("foo")}, 17, &fakeAnyOfMatcher{"", errors.New("foo")}, 19, ) err := matcher.Matches(0) ExpectThat(err, Error(Equals(""))) } func (t *AnyOfTest) DescriptionForEmptySet() { matcher := AnyOf() ExpectEq("or()", matcher.Description()) } func (t *AnyOfTest) DescriptionForNonEmptySet() { matcher := AnyOf( &fakeAnyOfMatcher{"taco", nil}, "burrito", &fakeAnyOfMatcher{"enchilada", nil}, ) ExpectEq("or(taco, burrito, enchilada)", matcher.Description()) } mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/any_test.go000066400000000000000000000027211321131462300340740ustar00rootroot00000000000000// Copyright 2011 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers_test import ( . "github.com/smartystreets/assertions/internal/oglematchers" . "github.com/smartystreets/assertions/internal/ogletest" ) //////////////////////////////////////////////////////////////////////// // Helpers //////////////////////////////////////////////////////////////////////// type AnyTest struct { } func init() { RegisterTestSuite(&AnyTest{}) } //////////////////////////////////////////////////////////////////////// // Tests //////////////////////////////////////////////////////////////////////// func (t *AnyTest) Description() { m := Any() ExpectEq("is anything", m.Description()) } func (t *AnyTest) Matches() { var err error m := Any() err = m.Matches(nil) ExpectEq(nil, err) err = m.Matches(17) ExpectEq(nil, err) err = m.Matches("taco") ExpectEq(nil, err) } mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/contains.go000066400000000000000000000033271321131462300340670ustar00rootroot00000000000000// Copyright 2012 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers import ( "fmt" "reflect" ) // Return a matcher that matches arrays slices with at least one element that // matches the supplied argument. If the argument x is not itself a Matcher, // this is equivalent to Contains(Equals(x)). func Contains(x interface{}) Matcher { var result containsMatcher var ok bool if result.elementMatcher, ok = x.(Matcher); !ok { result.elementMatcher = Equals(x) } return &result } type containsMatcher struct { elementMatcher Matcher } func (m *containsMatcher) Description() string { return fmt.Sprintf("contains: %s", m.elementMatcher.Description()) } func (m *containsMatcher) Matches(candidate interface{}) error { // The candidate must be a slice or an array. v := reflect.ValueOf(candidate) if v.Kind() != reflect.Slice && v.Kind() != reflect.Array { return NewFatalError("which is not a slice or array") } // Check each element. for i := 0; i < v.Len(); i++ { elem := v.Index(i) if matchErr := m.elementMatcher.Matches(elem.Interface()); matchErr == nil { return nil } } return fmt.Errorf("") } contains_test.go000066400000000000000000000134361321131462300350510ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglematchers// Copyright 2012 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers_test import ( . "github.com/smartystreets/assertions/internal/oglematchers" . "github.com/smartystreets/assertions/internal/ogletest" ) //////////////////////////////////////////////////////////////////////// // Helpers //////////////////////////////////////////////////////////////////////// type ContainsTest struct {} func init() { RegisterTestSuite(&ContainsTest{}) } //////////////////////////////////////////////////////////////////////// // Tests //////////////////////////////////////////////////////////////////////// func (t *ContainsTest) WrongTypeCandidates() { m := Contains("") ExpectEq("contains: ", m.Description()) var err error // Nil candidate err = m.Matches(nil) ExpectTrue(isFatal(err)) ExpectThat(err, Error(HasSubstr("array"))) ExpectThat(err, Error(HasSubstr("slice"))) // String candidate err = m.Matches("") ExpectTrue(isFatal(err)) ExpectThat(err, Error(HasSubstr("array"))) ExpectThat(err, Error(HasSubstr("slice"))) // Map candidate err = m.Matches(make(map[string]string)) ExpectTrue(isFatal(err)) ExpectThat(err, Error(HasSubstr("array"))) ExpectThat(err, Error(HasSubstr("slice"))) } func (t *ContainsTest) NilArgument() { m := Contains(nil) ExpectEq("contains: is nil", m.Description()) var c interface{} var err error // Empty array of pointers c = [...]*int{} err = m.Matches(c) ExpectThat(err, Error(Equals(""))) // Empty slice of pointers c = []*int{} err = m.Matches(c) ExpectThat(err, Error(Equals(""))) // Non-empty array of integers c = [...]int{17, 0, 19} err = m.Matches(c) ExpectThat(err, Error(Equals(""))) // Non-empty slice of integers c = []int{17, 0, 19} err = m.Matches(c) ExpectThat(err, Error(Equals(""))) // Non-matching array of pointers c = [...]*int{new(int), new(int)} err = m.Matches(c) ExpectThat(err, Error(Equals(""))) // Non-matching slice of pointers c = []*int{new(int), new(int)} err = m.Matches(c) ExpectThat(err, Error(Equals(""))) // Matching array of pointers c = [...]*int{new(int), nil, new(int)} err = m.Matches(c) ExpectEq(nil, err) // Matching slice of pointers c = []*int{new(int), nil, new(int)} err = m.Matches(c) ExpectEq(nil, err) // Non-matching slice of pointers from matching array someArray := [...]*int{new(int), nil, new(int)} c = someArray[0:1] err = m.Matches(c) ExpectThat(err, Error(Equals(""))) } func (t *ContainsTest) StringArgument() { m := Contains("taco") ExpectEq("contains: taco", m.Description()) var c interface{} var err error // Non-matching array of strings c = [...]string{"burrito", "enchilada"} err = m.Matches(c) ExpectThat(err, Error(Equals(""))) // Non-matching slice of strings c = []string{"burrito", "enchilada"} err = m.Matches(c) ExpectThat(err, Error(Equals(""))) // Matching array of strings c = [...]string{"burrito", "taco", "enchilada"} err = m.Matches(c) ExpectEq(nil, err) // Matching slice of strings c = []string{"burrito", "taco", "enchilada"} err = m.Matches(c) ExpectEq(nil, err) // Non-matching slice of strings from matching array someArray := [...]string{"burrito", "taco", "enchilada"} c = someArray[0:1] err = m.Matches(c) ExpectThat(err, Error(Equals(""))) } func (t *ContainsTest) IntegerArgument() { m := Contains(int(17)) ExpectEq("contains: 17", m.Description()) var c interface{} var err error // Non-matching array of integers c = [...]int{13, 19} err = m.Matches(c) ExpectThat(err, Error(Equals(""))) // Non-matching slice of integers c = []int{13, 19} err = m.Matches(c) ExpectThat(err, Error(Equals(""))) // Matching array of integers c = [...]int{13, 17, 19} err = m.Matches(c) ExpectEq(nil, err) // Matching slice of integers c = []int{13, 17, 19} err = m.Matches(c) ExpectEq(nil, err) // Non-matching slice of integers from matching array someArray := [...]int{13, 17, 19} c = someArray[0:1] err = m.Matches(c) ExpectThat(err, Error(Equals(""))) // Non-matching array of floats c = [...]float32{13, 17.5, 19} err = m.Matches(c) ExpectThat(err, Error(Equals(""))) // Non-matching slice of floats c = []float32{13, 17.5, 19} err = m.Matches(c) ExpectThat(err, Error(Equals(""))) // Matching array of floats c = [...]float32{13, 17, 19} err = m.Matches(c) ExpectEq(nil, err) // Matching slice of floats c = []float32{13, 17, 19} err = m.Matches(c) ExpectEq(nil, err) } func (t *ContainsTest) MatcherArgument() { m := Contains(HasSubstr("ac")) ExpectEq("contains: has substring \"ac\"", m.Description()) var c interface{} var err error // Non-matching array of strings c = [...]string{"burrito", "enchilada"} err = m.Matches(c) ExpectThat(err, Error(Equals(""))) // Non-matching slice of strings c = []string{"burrito", "enchilada"} err = m.Matches(c) ExpectThat(err, Error(Equals(""))) // Matching array of strings c = [...]string{"burrito", "taco", "enchilada"} err = m.Matches(c) ExpectEq(nil, err) // Matching slice of strings c = []string{"burrito", "taco", "enchilada"} err = m.Matches(c) ExpectEq(nil, err) // Non-matching slice of strings from matching array someArray := [...]string{"burrito", "taco", "enchilada"} c = someArray[0:1] err = m.Matches(c) ExpectThat(err, Error(Equals(""))) } deep_equals.go000066400000000000000000000045201321131462300344550ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglematchers// Copyright 2012 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers import ( "bytes" "errors" "fmt" "reflect" ) var byteSliceType reflect.Type = reflect.TypeOf([]byte{}) // DeepEquals returns a matcher that matches based on 'deep equality', as // defined by the reflect package. This matcher requires that values have // identical types to x. func DeepEquals(x interface{}) Matcher { return &deepEqualsMatcher{x} } type deepEqualsMatcher struct { x interface{} } func (m *deepEqualsMatcher) Description() string { xDesc := fmt.Sprintf("%v", m.x) xValue := reflect.ValueOf(m.x) // Special case: fmt.Sprintf presents nil slices as "[]", but // reflect.DeepEqual makes a distinction between nil and empty slices. Make // this less confusing. if xValue.Kind() == reflect.Slice && xValue.IsNil() { xDesc = "" } return fmt.Sprintf("deep equals: %s", xDesc) } func (m *deepEqualsMatcher) Matches(c interface{}) error { // Make sure the types match. ct := reflect.TypeOf(c) xt := reflect.TypeOf(m.x) if ct != xt { return NewFatalError(fmt.Sprintf("which is of type %v", ct)) } // Special case: handle byte slices more efficiently. cValue := reflect.ValueOf(c) xValue := reflect.ValueOf(m.x) if ct == byteSliceType && !cValue.IsNil() && !xValue.IsNil() { xBytes := m.x.([]byte) cBytes := c.([]byte) if bytes.Equal(cBytes, xBytes) { return nil } return errors.New("") } // Defer to the reflect package. if reflect.DeepEqual(m.x, c) { return nil } // Special case: if the comparison failed because c is the nil slice, given // an indication of this (since its value is printed as "[]"). if cValue.Kind() == reflect.Slice && cValue.IsNil() { return errors.New("which is nil") } return errors.New("") } deep_equals_test.go000066400000000000000000000173751321131462300355300ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglematchers// Copyright 2012 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers_test import ( . "github.com/smartystreets/assertions/internal/oglematchers" . "github.com/smartystreets/assertions/internal/ogletest" "bytes" "testing" ) //////////////////////////////////////////////////////////////////////// // Helpers //////////////////////////////////////////////////////////////////////// type DeepEqualsTest struct {} func init() { RegisterTestSuite(&DeepEqualsTest{}) } //////////////////////////////////////////////////////////////////////// // Tests //////////////////////////////////////////////////////////////////////// func (t *DeepEqualsTest) WrongTypeCandidateWithScalarValue() { var x int = 17 m := DeepEquals(x) var err error // Nil candidate. err = m.Matches(nil) AssertNe(nil, err) ExpectTrue(isFatal(err)) ExpectThat(err, Error(HasSubstr("type"))) ExpectThat(err, Error(HasSubstr(""))) // Int alias candidate. type intAlias int err = m.Matches(intAlias(x)) AssertNe(nil, err) ExpectTrue(isFatal(err)) ExpectThat(err, Error(HasSubstr("type"))) ExpectThat(err, Error(HasSubstr("intAlias"))) // String candidate. err = m.Matches("taco") AssertNe(nil, err) ExpectTrue(isFatal(err)) ExpectThat(err, Error(HasSubstr("type"))) ExpectThat(err, Error(HasSubstr("string"))) // Byte slice candidate. err = m.Matches([]byte{}) AssertNe(nil, err) ExpectTrue(isFatal(err)) ExpectThat(err, Error(HasSubstr("type"))) ExpectThat(err, Error(HasSubstr("[]uint8"))) // Other slice candidate. err = m.Matches([]uint16{}) AssertNe(nil, err) ExpectTrue(isFatal(err)) ExpectThat(err, Error(HasSubstr("type"))) ExpectThat(err, Error(HasSubstr("[]uint16"))) // Unsigned int candidate. err = m.Matches(uint(17)) AssertNe(nil, err) ExpectTrue(isFatal(err)) ExpectThat(err, Error(HasSubstr("type"))) ExpectThat(err, Error(HasSubstr("uint"))) } func (t *DeepEqualsTest) WrongTypeCandidateWithByteSliceValue() { x := []byte{} m := DeepEquals(x) var err error // Nil candidate. err = m.Matches(nil) AssertNe(nil, err) ExpectTrue(isFatal(err)) ExpectThat(err, Error(HasSubstr("type"))) ExpectThat(err, Error(HasSubstr(""))) // String candidate. err = m.Matches("taco") AssertNe(nil, err) ExpectTrue(isFatal(err)) ExpectThat(err, Error(HasSubstr("type"))) ExpectThat(err, Error(HasSubstr("string"))) // Slice candidate with wrong value type. err = m.Matches([]uint16{}) AssertNe(nil, err) ExpectTrue(isFatal(err)) ExpectThat(err, Error(HasSubstr("type"))) ExpectThat(err, Error(HasSubstr("[]uint16"))) } func (t *DeepEqualsTest) WrongTypeCandidateWithOtherSliceValue() { x := []uint16{} m := DeepEquals(x) var err error // Nil candidate. err = m.Matches(nil) AssertNe(nil, err) ExpectTrue(isFatal(err)) ExpectThat(err, Error(HasSubstr("type"))) ExpectThat(err, Error(HasSubstr(""))) // String candidate. err = m.Matches("taco") AssertNe(nil, err) ExpectTrue(isFatal(err)) ExpectThat(err, Error(HasSubstr("type"))) ExpectThat(err, Error(HasSubstr("string"))) // Byte slice candidate with wrong value type. err = m.Matches([]byte{}) AssertNe(nil, err) ExpectTrue(isFatal(err)) ExpectThat(err, Error(HasSubstr("type"))) ExpectThat(err, Error(HasSubstr("[]uint8"))) // Other slice candidate with wrong value type. err = m.Matches([]uint32{}) AssertNe(nil, err) ExpectTrue(isFatal(err)) ExpectThat(err, Error(HasSubstr("type"))) ExpectThat(err, Error(HasSubstr("[]uint32"))) } func (t *DeepEqualsTest) WrongTypeCandidateWithNilLiteralValue() { m := DeepEquals(nil) var err error // String candidate. err = m.Matches("taco") AssertNe(nil, err) ExpectTrue(isFatal(err)) ExpectThat(err, Error(HasSubstr("type"))) ExpectThat(err, Error(HasSubstr("string"))) // Nil byte slice candidate. err = m.Matches([]byte(nil)) AssertNe(nil, err) ExpectTrue(isFatal(err)) ExpectThat(err, Error(HasSubstr("type"))) ExpectThat(err, Error(HasSubstr("[]uint8"))) // Nil other slice candidate. err = m.Matches([]uint16(nil)) AssertNe(nil, err) ExpectTrue(isFatal(err)) ExpectThat(err, Error(HasSubstr("type"))) ExpectThat(err, Error(HasSubstr("[]uint16"))) } func (t *DeepEqualsTest) NilLiteralValue() { m := DeepEquals(nil) ExpectEq("deep equals: ", m.Description()) var c interface{} var err error // Nil literal candidate. c = nil err = m.Matches(c) ExpectEq(nil, err) } func (t *DeepEqualsTest) IntValue() { m := DeepEquals(int(17)) ExpectEq("deep equals: 17", m.Description()) var c interface{} var err error // Matching int. c = int(17) err = m.Matches(c) ExpectEq(nil, err) // Non-matching int. c = int(18) err = m.Matches(c) ExpectThat(err, Error(Equals(""))) } func (t *DeepEqualsTest) ByteSliceValue() { x := []byte{17, 19} m := DeepEquals(x) ExpectEq("deep equals: [17 19]", m.Description()) var c []byte var err error // Matching. c = make([]byte, len(x)) AssertEq(len(x), copy(c, x)) err = m.Matches(c) ExpectEq(nil, err) // Nil slice. c = []byte(nil) err = m.Matches(c) ExpectThat(err, Error(Equals("which is nil"))) // Prefix. AssertGt(len(x), 1) c = make([]byte, len(x)-1) AssertEq(len(x)-1, copy(c, x)) err = m.Matches(c) ExpectThat(err, Error(Equals(""))) // Suffix. c = make([]byte, len(x)+1) AssertEq(len(x), copy(c, x)) err = m.Matches(c) ExpectThat(err, Error(Equals(""))) } func (t *DeepEqualsTest) OtherSliceValue() { x := []uint16{17, 19} m := DeepEquals(x) ExpectEq("deep equals: [17 19]", m.Description()) var c []uint16 var err error // Matching. c = make([]uint16, len(x)) AssertEq(len(x), copy(c, x)) err = m.Matches(c) ExpectEq(nil, err) // Nil slice. c = []uint16(nil) err = m.Matches(c) ExpectThat(err, Error(Equals("which is nil"))) // Prefix. AssertGt(len(x), 1) c = make([]uint16, len(x)-1) AssertEq(len(x)-1, copy(c, x)) err = m.Matches(c) ExpectThat(err, Error(Equals(""))) // Suffix. c = make([]uint16, len(x)+1) AssertEq(len(x), copy(c, x)) err = m.Matches(c) ExpectThat(err, Error(Equals(""))) } func (t *DeepEqualsTest) NilByteSliceValue() { x := []byte(nil) m := DeepEquals(x) ExpectEq("deep equals: ", m.Description()) var c []byte var err error // Nil slice. c = []byte(nil) err = m.Matches(c) ExpectEq(nil, err) // Non-nil slice. c = []byte{} err = m.Matches(c) ExpectThat(err, Error(Equals(""))) } func (t *DeepEqualsTest) NilOtherSliceValue() { x := []uint16(nil) m := DeepEquals(x) ExpectEq("deep equals: ", m.Description()) var c []uint16 var err error // Nil slice. c = []uint16(nil) err = m.Matches(c) ExpectEq(nil, err) // Non-nil slice. c = []uint16{} err = m.Matches(c) ExpectThat(err, Error(Equals(""))) } //////////////////////////////////////////////////////////////////////// // Benchmarks //////////////////////////////////////////////////////////////////////// func benchmarkWithSize(b *testing.B, size int) { b.StopTimer() buf := bytes.Repeat([]byte{0x01}, size) bufCopy := make([]byte, size) copy(bufCopy, buf) matcher := DeepEquals(buf) b.StartTimer() for i := 0; i < b.N; i++ { matcher.Matches(bufCopy) } b.SetBytes(int64(size)) } func BenchmarkShortByteSlice(b *testing.B) { benchmarkWithSize(b, 256) } func BenchmarkLongByteSlice(b *testing.B) { benchmarkWithSize(b, 1<<24) } elements_are.go000066400000000000000000000050621321131462300346330ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglematchers// Copyright 2012 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers import ( "errors" "fmt" "reflect" "strings" ) // Given a list of arguments M, ElementsAre returns a matcher that matches // arrays and slices A where all of the following hold: // // * A is the same length as M. // // * For each i < len(A) where M[i] is a matcher, A[i] matches M[i]. // // * For each i < len(A) where M[i] is not a matcher, A[i] matches // Equals(M[i]). // func ElementsAre(M ...interface{}) Matcher { // Copy over matchers, or convert to Equals(x) for non-matcher x. subMatchers := make([]Matcher, len(M)) for i, x := range M { if matcher, ok := x.(Matcher); ok { subMatchers[i] = matcher continue } subMatchers[i] = Equals(x) } return &elementsAreMatcher{subMatchers} } type elementsAreMatcher struct { subMatchers []Matcher } func (m *elementsAreMatcher) Description() string { subDescs := make([]string, len(m.subMatchers)) for i, sm := range m.subMatchers { subDescs[i] = sm.Description() } return fmt.Sprintf("elements are: [%s]", strings.Join(subDescs, ", ")) } func (m *elementsAreMatcher) Matches(candidates interface{}) error { // The candidate must be a slice or an array. v := reflect.ValueOf(candidates) if v.Kind() != reflect.Slice && v.Kind() != reflect.Array { return NewFatalError("which is not a slice or array") } // The length must be correct. if v.Len() != len(m.subMatchers) { return errors.New(fmt.Sprintf("which is of length %d", v.Len())) } // Check each element. for i, subMatcher := range m.subMatchers { c := v.Index(i) if matchErr := subMatcher.Matches(c.Interface()); matchErr != nil { // Return an errors indicating which element doesn't match. If the // matcher error was fatal, make this one fatal too. err := errors.New(fmt.Sprintf("whose element %d doesn't match", i)) if _, isFatal := matchErr.(*FatalError); isFatal { err = NewFatalError(err.Error()) } return err } } return nil } elements_are_test.go000066400000000000000000000116431321131462300356740ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglematchers// Copyright 2012 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers_test import ( . "github.com/smartystreets/assertions/internal/oglematchers" . "github.com/smartystreets/assertions/internal/ogletest" ) //////////////////////////////////////////////////////////////////////// // Helpers //////////////////////////////////////////////////////////////////////// type ElementsAreTest struct { } func init() { RegisterTestSuite(&ElementsAreTest{}) } //////////////////////////////////////////////////////////////////////// // Tests //////////////////////////////////////////////////////////////////////// func (t *ElementsAreTest) EmptySet() { m := ElementsAre() ExpectEq("elements are: []", m.Description()) var c []interface{} var err error // No candidates. c = []interface{}{} err = m.Matches(c) ExpectEq(nil, err) // One candidate. c = []interface{}{17} err = m.Matches(c) ExpectThat(err, Error(HasSubstr("length 1"))) } func (t *ElementsAreTest) OneMatcher() { m := ElementsAre(LessThan(17)) ExpectEq("elements are: [less than 17]", m.Description()) var c []interface{} var err error // No candidates. c = []interface{}{} err = m.Matches(c) ExpectThat(err, Error(HasSubstr("length 0"))) // Matching candidate. c = []interface{}{16} err = m.Matches(c) ExpectEq(nil, err) // Non-matching candidate. c = []interface{}{19} err = m.Matches(c) ExpectNe(nil, err) // Two candidates. c = []interface{}{17, 19} err = m.Matches(c) ExpectThat(err, Error(HasSubstr("length 2"))) } func (t *ElementsAreTest) OneValue() { m := ElementsAre(17) ExpectEq("elements are: [17]", m.Description()) var c []interface{} var err error // No candidates. c = []interface{}{} err = m.Matches(c) ExpectThat(err, Error(HasSubstr("length 0"))) // Matching int. c = []interface{}{int(17)} err = m.Matches(c) ExpectEq(nil, err) // Matching float. c = []interface{}{float32(17)} err = m.Matches(c) ExpectEq(nil, err) // Non-matching candidate. c = []interface{}{19} err = m.Matches(c) ExpectNe(nil, err) // Two candidates. c = []interface{}{17, 19} err = m.Matches(c) ExpectThat(err, Error(HasSubstr("length 2"))) } func (t *ElementsAreTest) MultipleElements() { m := ElementsAre("taco", LessThan(17)) ExpectEq("elements are: [taco, less than 17]", m.Description()) var c []interface{} var err error // One candidate. c = []interface{}{17} err = m.Matches(c) ExpectThat(err, Error(HasSubstr("length 1"))) // Both matching. c = []interface{}{"taco", 16} err = m.Matches(c) ExpectEq(nil, err) // First non-matching. c = []interface{}{"burrito", 16} err = m.Matches(c) ExpectThat(err, Error(Equals("whose element 0 doesn't match"))) // Second non-matching. c = []interface{}{"taco", 17} err = m.Matches(c) ExpectThat(err, Error(Equals("whose element 1 doesn't match"))) // Three candidates. c = []interface{}{"taco", 17, 19} err = m.Matches(c) ExpectThat(err, Error(HasSubstr("length 3"))) } func (t *ElementsAreTest) ArrayCandidates() { m := ElementsAre("taco", LessThan(17)) var err error // One candidate. err = m.Matches([1]interface{}{"taco"}) ExpectThat(err, Error(HasSubstr("length 1"))) // Both matching. err = m.Matches([2]interface{}{"taco", 16}) ExpectEq(nil, err) // First non-matching. err = m.Matches([2]interface{}{"burrito", 16}) ExpectThat(err, Error(Equals("whose element 0 doesn't match"))) } func (t *ElementsAreTest) WrongTypeCandidate() { m := ElementsAre("taco") var err error // String candidate. err = m.Matches("taco") ExpectTrue(isFatal(err)) ExpectThat(err, Error(HasSubstr("array"))) ExpectThat(err, Error(HasSubstr("slice"))) // Map candidate. err = m.Matches(map[string]string{}) ExpectTrue(isFatal(err)) ExpectThat(err, Error(HasSubstr("array"))) ExpectThat(err, Error(HasSubstr("slice"))) // Nil candidate. err = m.Matches(nil) ExpectTrue(isFatal(err)) ExpectThat(err, Error(HasSubstr("array"))) ExpectThat(err, Error(HasSubstr("slice"))) } func (t *ElementsAreTest) PropagatesFatality() { m := ElementsAre(LessThan(17)) ExpectEq("elements are: [less than 17]", m.Description()) var c []interface{} var err error // Non-fatal error. c = []interface{}{19} err = m.Matches(c) AssertNe(nil, err) ExpectFalse(isFatal(err)) // Fatal error. c = []interface{}{"taco"} err = m.Matches(c) AssertNe(nil, err) ExpectTrue(isFatal(err)) } mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/equals.go000066400000000000000000000307171321131462300335460ustar00rootroot00000000000000// Copyright 2011 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers import ( "errors" "fmt" "math" "reflect" ) // Equals(x) returns a matcher that matches values v such that v and x are // equivalent. This includes the case when the comparison v == x using Go's // built-in comparison operator is legal (except for structs, which this // matcher does not support), but for convenience the following rules also // apply: // // * Type checking is done based on underlying types rather than actual // types, so that e.g. two aliases for string can be compared: // // type stringAlias1 string // type stringAlias2 string // // a := "taco" // b := stringAlias1("taco") // c := stringAlias2("taco") // // ExpectTrue(a == b) // Legal, passes // ExpectTrue(b == c) // Illegal, doesn't compile // // ExpectThat(a, Equals(b)) // Passes // ExpectThat(b, Equals(c)) // Passes // // * Values of numeric type are treated as if they were abstract numbers, and // compared accordingly. Therefore Equals(17) will match int(17), // int16(17), uint(17), float32(17), complex64(17), and so on. // // If you want a stricter matcher that contains no such cleverness, see // IdenticalTo instead. // // Arrays are supported by this matcher, but do not participate in the // exceptions above. Two arrays compared with this matcher must have identical // types, and their element type must itself be comparable according to Go's == // operator. func Equals(x interface{}) Matcher { v := reflect.ValueOf(x) // This matcher doesn't support structs. if v.Kind() == reflect.Struct { panic(fmt.Sprintf("oglematchers.Equals: unsupported kind %v", v.Kind())) } // The == operator is not defined for non-nil slices. if v.Kind() == reflect.Slice && v.Pointer() != uintptr(0) { panic(fmt.Sprintf("oglematchers.Equals: non-nil slice")) } return &equalsMatcher{v} } type equalsMatcher struct { expectedValue reflect.Value } //////////////////////////////////////////////////////////////////////// // Numeric types //////////////////////////////////////////////////////////////////////// func isSignedInteger(v reflect.Value) bool { k := v.Kind() return k >= reflect.Int && k <= reflect.Int64 } func isUnsignedInteger(v reflect.Value) bool { k := v.Kind() return k >= reflect.Uint && k <= reflect.Uintptr } func isInteger(v reflect.Value) bool { return isSignedInteger(v) || isUnsignedInteger(v) } func isFloat(v reflect.Value) bool { k := v.Kind() return k == reflect.Float32 || k == reflect.Float64 } func isComplex(v reflect.Value) bool { k := v.Kind() return k == reflect.Complex64 || k == reflect.Complex128 } func checkAgainstInt64(e int64, c reflect.Value) (err error) { err = errors.New("") switch { case isSignedInteger(c): if c.Int() == e { err = nil } case isUnsignedInteger(c): u := c.Uint() if u <= math.MaxInt64 && int64(u) == e { err = nil } // Turn around the various floating point types so that the checkAgainst* // functions for them can deal with precision issues. case isFloat(c), isComplex(c): return Equals(c.Interface()).Matches(e) default: err = NewFatalError("which is not numeric") } return } func checkAgainstUint64(e uint64, c reflect.Value) (err error) { err = errors.New("") switch { case isSignedInteger(c): i := c.Int() if i >= 0 && uint64(i) == e { err = nil } case isUnsignedInteger(c): if c.Uint() == e { err = nil } // Turn around the various floating point types so that the checkAgainst* // functions for them can deal with precision issues. case isFloat(c), isComplex(c): return Equals(c.Interface()).Matches(e) default: err = NewFatalError("which is not numeric") } return } func checkAgainstFloat32(e float32, c reflect.Value) (err error) { err = errors.New("") switch { case isSignedInteger(c): if float32(c.Int()) == e { err = nil } case isUnsignedInteger(c): if float32(c.Uint()) == e { err = nil } case isFloat(c): // Compare using float32 to avoid a false sense of precision; otherwise // e.g. Equals(float32(0.1)) won't match float32(0.1). if float32(c.Float()) == e { err = nil } case isComplex(c): comp := c.Complex() rl := real(comp) im := imag(comp) // Compare using float32 to avoid a false sense of precision; otherwise // e.g. Equals(float32(0.1)) won't match (0.1 + 0i). if im == 0 && float32(rl) == e { err = nil } default: err = NewFatalError("which is not numeric") } return } func checkAgainstFloat64(e float64, c reflect.Value) (err error) { err = errors.New("") ck := c.Kind() switch { case isSignedInteger(c): if float64(c.Int()) == e { err = nil } case isUnsignedInteger(c): if float64(c.Uint()) == e { err = nil } // If the actual value is lower precision, turn the comparison around so we // apply the low-precision rules. Otherwise, e.g. Equals(0.1) may not match // float32(0.1). case ck == reflect.Float32 || ck == reflect.Complex64: return Equals(c.Interface()).Matches(e) // Otherwise, compare with double precision. case isFloat(c): if c.Float() == e { err = nil } case isComplex(c): comp := c.Complex() rl := real(comp) im := imag(comp) if im == 0 && rl == e { err = nil } default: err = NewFatalError("which is not numeric") } return } func checkAgainstComplex64(e complex64, c reflect.Value) (err error) { err = errors.New("") realPart := real(e) imaginaryPart := imag(e) switch { case isInteger(c) || isFloat(c): // If we have no imaginary part, then we should just compare against the // real part. Otherwise, we can't be equal. if imaginaryPart != 0 { return } return checkAgainstFloat32(realPart, c) case isComplex(c): // Compare using complex64 to avoid a false sense of precision; otherwise // e.g. Equals(0.1 + 0i) won't match float32(0.1). if complex64(c.Complex()) == e { err = nil } default: err = NewFatalError("which is not numeric") } return } func checkAgainstComplex128(e complex128, c reflect.Value) (err error) { err = errors.New("") realPart := real(e) imaginaryPart := imag(e) switch { case isInteger(c) || isFloat(c): // If we have no imaginary part, then we should just compare against the // real part. Otherwise, we can't be equal. if imaginaryPart != 0 { return } return checkAgainstFloat64(realPart, c) case isComplex(c): if c.Complex() == e { err = nil } default: err = NewFatalError("which is not numeric") } return } //////////////////////////////////////////////////////////////////////// // Other types //////////////////////////////////////////////////////////////////////// func checkAgainstBool(e bool, c reflect.Value) (err error) { if c.Kind() != reflect.Bool { err = NewFatalError("which is not a bool") return } err = errors.New("") if c.Bool() == e { err = nil } return } func checkAgainstChan(e reflect.Value, c reflect.Value) (err error) { // Create a description of e's type, e.g. "chan int". typeStr := fmt.Sprintf("%s %s", e.Type().ChanDir(), e.Type().Elem()) // Make sure c is a chan of the correct type. if c.Kind() != reflect.Chan || c.Type().ChanDir() != e.Type().ChanDir() || c.Type().Elem() != e.Type().Elem() { err = NewFatalError(fmt.Sprintf("which is not a %s", typeStr)) return } err = errors.New("") if c.Pointer() == e.Pointer() { err = nil } return } func checkAgainstFunc(e reflect.Value, c reflect.Value) (err error) { // Make sure c is a function. if c.Kind() != reflect.Func { err = NewFatalError("which is not a function") return } err = errors.New("") if c.Pointer() == e.Pointer() { err = nil } return } func checkAgainstMap(e reflect.Value, c reflect.Value) (err error) { // Make sure c is a map. if c.Kind() != reflect.Map { err = NewFatalError("which is not a map") return } err = errors.New("") if c.Pointer() == e.Pointer() { err = nil } return } func checkAgainstPtr(e reflect.Value, c reflect.Value) (err error) { // Create a description of e's type, e.g. "*int". typeStr := fmt.Sprintf("*%v", e.Type().Elem()) // Make sure c is a pointer of the correct type. if c.Kind() != reflect.Ptr || c.Type().Elem() != e.Type().Elem() { err = NewFatalError(fmt.Sprintf("which is not a %s", typeStr)) return } err = errors.New("") if c.Pointer() == e.Pointer() { err = nil } return } func checkAgainstSlice(e reflect.Value, c reflect.Value) (err error) { // Create a description of e's type, e.g. "[]int". typeStr := fmt.Sprintf("[]%v", e.Type().Elem()) // Make sure c is a slice of the correct type. if c.Kind() != reflect.Slice || c.Type().Elem() != e.Type().Elem() { err = NewFatalError(fmt.Sprintf("which is not a %s", typeStr)) return } err = errors.New("") if c.Pointer() == e.Pointer() { err = nil } return } func checkAgainstString(e reflect.Value, c reflect.Value) (err error) { // Make sure c is a string. if c.Kind() != reflect.String { err = NewFatalError("which is not a string") return } err = errors.New("") if c.String() == e.String() { err = nil } return } func checkAgainstArray(e reflect.Value, c reflect.Value) (err error) { // Create a description of e's type, e.g. "[2]int". typeStr := fmt.Sprintf("%v", e.Type()) // Make sure c is the correct type. if c.Type() != e.Type() { err = NewFatalError(fmt.Sprintf("which is not %s", typeStr)) return } // Check for equality. if e.Interface() != c.Interface() { err = errors.New("") return } return } func checkAgainstUnsafePointer(e reflect.Value, c reflect.Value) (err error) { // Make sure c is a pointer. if c.Kind() != reflect.UnsafePointer { err = NewFatalError("which is not a unsafe.Pointer") return } err = errors.New("") if c.Pointer() == e.Pointer() { err = nil } return } func checkForNil(c reflect.Value) (err error) { err = errors.New("") // Make sure it is legal to call IsNil. switch c.Kind() { case reflect.Invalid: case reflect.Chan: case reflect.Func: case reflect.Interface: case reflect.Map: case reflect.Ptr: case reflect.Slice: default: err = NewFatalError("which cannot be compared to nil") return } // Ask whether the value is nil. Handle a nil literal (kind Invalid) // specially, since it's not legal to call IsNil there. if c.Kind() == reflect.Invalid || c.IsNil() { err = nil } return } //////////////////////////////////////////////////////////////////////// // Public implementation //////////////////////////////////////////////////////////////////////// func (m *equalsMatcher) Matches(candidate interface{}) error { e := m.expectedValue c := reflect.ValueOf(candidate) ek := e.Kind() switch { case ek == reflect.Bool: return checkAgainstBool(e.Bool(), c) case isSignedInteger(e): return checkAgainstInt64(e.Int(), c) case isUnsignedInteger(e): return checkAgainstUint64(e.Uint(), c) case ek == reflect.Float32: return checkAgainstFloat32(float32(e.Float()), c) case ek == reflect.Float64: return checkAgainstFloat64(e.Float(), c) case ek == reflect.Complex64: return checkAgainstComplex64(complex64(e.Complex()), c) case ek == reflect.Complex128: return checkAgainstComplex128(complex128(e.Complex()), c) case ek == reflect.Chan: return checkAgainstChan(e, c) case ek == reflect.Func: return checkAgainstFunc(e, c) case ek == reflect.Map: return checkAgainstMap(e, c) case ek == reflect.Ptr: return checkAgainstPtr(e, c) case ek == reflect.Slice: return checkAgainstSlice(e, c) case ek == reflect.String: return checkAgainstString(e, c) case ek == reflect.Array: return checkAgainstArray(e, c) case ek == reflect.UnsafePointer: return checkAgainstUnsafePointer(e, c) case ek == reflect.Invalid: return checkForNil(c) } panic(fmt.Sprintf("equalsMatcher.Matches: unexpected kind: %v", ek)) } func (m *equalsMatcher) Description() string { // Special case: handle nil. if !m.expectedValue.IsValid() { return "is nil" } return fmt.Sprintf("%v", m.expectedValue.Interface()) } equals_test.go000066400000000000000000005050141321131462300345230ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglematchers// Copyright 2011 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers_test import ( "fmt" "math" "unsafe" . "github.com/smartystreets/assertions/internal/oglematchers" . "github.com/smartystreets/assertions/internal/ogletest" ) var someInt int = -17 //////////////////////////////////////////////////////////////////////// // Helpers //////////////////////////////////////////////////////////////////////// type EqualsTest struct { } func init() { RegisterTestSuite(&EqualsTest{}) } type equalsTestCase struct { candidate interface{} expectedResult bool shouldBeFatal bool expectedError string } func (t *EqualsTest) checkTestCases(matcher Matcher, cases []equalsTestCase) { for i, c := range cases { err := matcher.Matches(c.candidate) ExpectEq( c.expectedResult, (err == nil), "Result for case %d: %v (Error: %v)", i, c, err) if err == nil { continue } _, isFatal := err.(*FatalError) ExpectEq(c.shouldBeFatal, isFatal, "Fatality for case %d: %v", i, c) ExpectThat(err, Error(Equals(c.expectedError)), "Case %d: %v", i, c) } } //////////////////////////////////////////////////////////////////////// // nil //////////////////////////////////////////////////////////////////////// func (t *EqualsTest) EqualsNil() { matcher := Equals(nil) ExpectEq("is nil", matcher.Description()) cases := []equalsTestCase{ // Legal types equalsTestCase{nil, true, false, ""}, equalsTestCase{chan int(nil), true, false, ""}, equalsTestCase{(func())(nil), true, false, ""}, equalsTestCase{interface{}(nil), true, false, ""}, equalsTestCase{map[int]int(nil), true, false, ""}, equalsTestCase{(*int)(nil), true, false, ""}, equalsTestCase{[]int(nil), true, false, ""}, equalsTestCase{make(chan int), false, false, ""}, equalsTestCase{func() {}, false, false, ""}, equalsTestCase{map[int]int{}, false, false, ""}, equalsTestCase{&someInt, false, false, ""}, equalsTestCase{[]int{}, false, false, ""}, // Illegal types equalsTestCase{17, false, true, "which cannot be compared to nil"}, equalsTestCase{int8(17), false, true, "which cannot be compared to nil"}, equalsTestCase{uintptr(17), false, true, "which cannot be compared to nil"}, equalsTestCase{[...]int{}, false, true, "which cannot be compared to nil"}, equalsTestCase{"taco", false, true, "which cannot be compared to nil"}, equalsTestCase{equalsTestCase{}, false, true, "which cannot be compared to nil"}, equalsTestCase{unsafe.Pointer(&someInt), false, true, "which cannot be compared to nil"}, } t.checkTestCases(matcher, cases) } //////////////////////////////////////////////////////////////////////// // Integer literals //////////////////////////////////////////////////////////////////////// func (t *EqualsTest) NegativeIntegerLiteral() { // -2^30 matcher := Equals(-1073741824) ExpectEq("-1073741824", matcher.Description()) cases := []equalsTestCase{ // Various types of -1073741824. equalsTestCase{-1073741824, true, false, ""}, equalsTestCase{-1073741824.0, true, false, ""}, equalsTestCase{-1073741824 + 0i, true, false, ""}, equalsTestCase{int(-1073741824), true, false, ""}, equalsTestCase{int32(-1073741824), true, false, ""}, equalsTestCase{int64(-1073741824), true, false, ""}, equalsTestCase{float32(-1073741824), true, false, ""}, equalsTestCase{float64(-1073741824), true, false, ""}, equalsTestCase{complex64(-1073741824), true, false, ""}, equalsTestCase{complex128(-1073741824), true, false, ""}, equalsTestCase{interface{}(int(-1073741824)), true, false, ""}, // Values that would be -1073741824 in two's complement. equalsTestCase{uint((1 << 32) - 1073741824), false, false, ""}, equalsTestCase{uint32((1 << 32) - 1073741824), false, false, ""}, equalsTestCase{uint64((1 << 64) - 1073741824), false, false, ""}, equalsTestCase{uintptr((1 << 64) - 1073741824), false, false, ""}, // Non-equal values of signed integer type. equalsTestCase{int(-1073741823), false, false, ""}, equalsTestCase{int32(-1073741823), false, false, ""}, equalsTestCase{int64(-1073741823), false, false, ""}, // Non-equal values of other numeric types. equalsTestCase{float64(-1073741824.1), false, false, ""}, equalsTestCase{float64(-1073741823.9), false, false, ""}, equalsTestCase{complex128(-1073741823), false, false, ""}, equalsTestCase{complex128(-1073741824 + 2i), false, false, ""}, // Non-numeric types. equalsTestCase{true, false, true, "which is not numeric"}, equalsTestCase{[...]int{}, false, true, "which is not numeric"}, equalsTestCase{make(chan int), false, true, "which is not numeric"}, equalsTestCase{func() {}, false, true, "which is not numeric"}, equalsTestCase{map[int]int{}, false, true, "which is not numeric"}, equalsTestCase{&someInt, false, true, "which is not numeric"}, equalsTestCase{[]int{}, false, true, "which is not numeric"}, equalsTestCase{"taco", false, true, "which is not numeric"}, equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) PositiveIntegerLiteral() { // 2^30 matcher := Equals(1073741824) ExpectEq("1073741824", matcher.Description()) cases := []equalsTestCase{ // Various types of 1073741824. equalsTestCase{1073741824, true, false, ""}, equalsTestCase{1073741824.0, true, false, ""}, equalsTestCase{1073741824 + 0i, true, false, ""}, equalsTestCase{int(1073741824), true, false, ""}, equalsTestCase{uint(1073741824), true, false, ""}, equalsTestCase{int32(1073741824), true, false, ""}, equalsTestCase{int64(1073741824), true, false, ""}, equalsTestCase{uint32(1073741824), true, false, ""}, equalsTestCase{uint64(1073741824), true, false, ""}, equalsTestCase{uintptr(1073741824), true, false, ""}, equalsTestCase{float32(1073741824), true, false, ""}, equalsTestCase{float64(1073741824), true, false, ""}, equalsTestCase{complex64(1073741824), true, false, ""}, equalsTestCase{complex128(1073741824), true, false, ""}, equalsTestCase{interface{}(int(1073741824)), true, false, ""}, equalsTestCase{interface{}(uint(1073741824)), true, false, ""}, // Non-equal values of numeric type. equalsTestCase{int(1073741823), false, false, ""}, equalsTestCase{int32(1073741823), false, false, ""}, equalsTestCase{int64(1073741823), false, false, ""}, equalsTestCase{float64(1073741824.1), false, false, ""}, equalsTestCase{float64(1073741823.9), false, false, ""}, equalsTestCase{complex128(1073741823), false, false, ""}, equalsTestCase{complex128(1073741824 + 2i), false, false, ""}, // Non-numeric types. equalsTestCase{true, false, true, "which is not numeric"}, equalsTestCase{[...]int{}, false, true, "which is not numeric"}, equalsTestCase{make(chan int), false, true, "which is not numeric"}, equalsTestCase{func() {}, false, true, "which is not numeric"}, equalsTestCase{map[int]int{}, false, true, "which is not numeric"}, equalsTestCase{&someInt, false, true, "which is not numeric"}, equalsTestCase{[]int{}, false, true, "which is not numeric"}, equalsTestCase{"taco", false, true, "which is not numeric"}, equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"}, } t.checkTestCases(matcher, cases) } //////////////////////////////////////////////////////////////////////// // Floating point literals //////////////////////////////////////////////////////////////////////// func (t *EqualsTest) NegativeIntegralFloatingPointLiteral() { // -2^30 matcher := Equals(-1073741824.0) ExpectEq("-1.073741824e+09", matcher.Description()) cases := []equalsTestCase{ // Various types of -1073741824. equalsTestCase{-1073741824, true, false, ""}, equalsTestCase{-1073741824.0, true, false, ""}, equalsTestCase{-1073741824 + 0i, true, false, ""}, equalsTestCase{int(-1073741824), true, false, ""}, equalsTestCase{int32(-1073741824), true, false, ""}, equalsTestCase{int64(-1073741824), true, false, ""}, equalsTestCase{float32(-1073741824), true, false, ""}, equalsTestCase{float64(-1073741824), true, false, ""}, equalsTestCase{complex64(-1073741824), true, false, ""}, equalsTestCase{complex128(-1073741824), true, false, ""}, equalsTestCase{interface{}(int(-1073741824)), true, false, ""}, equalsTestCase{interface{}(float64(-1073741824)), true, false, ""}, // Values that would be -1073741824 in two's complement. equalsTestCase{uint((1 << 32) - 1073741824), false, false, ""}, equalsTestCase{uint32((1 << 32) - 1073741824), false, false, ""}, equalsTestCase{uint64((1 << 64) - 1073741824), false, false, ""}, equalsTestCase{uintptr((1 << 64) - 1073741824), false, false, ""}, // Non-equal values of signed integer type. equalsTestCase{int(-1073741823), false, false, ""}, equalsTestCase{int32(-1073741823), false, false, ""}, equalsTestCase{int64(-1073741823), false, false, ""}, // Non-equal values of other numeric types. equalsTestCase{float64(-1073741824.1), false, false, ""}, equalsTestCase{float64(-1073741823.9), false, false, ""}, equalsTestCase{complex128(-1073741823), false, false, ""}, equalsTestCase{complex128(-1073741824 + 2i), false, false, ""}, // Non-numeric types. equalsTestCase{true, false, true, "which is not numeric"}, equalsTestCase{[...]int{}, false, true, "which is not numeric"}, equalsTestCase{make(chan int), false, true, "which is not numeric"}, equalsTestCase{func() {}, false, true, "which is not numeric"}, equalsTestCase{map[int]int{}, false, true, "which is not numeric"}, equalsTestCase{&someInt, false, true, "which is not numeric"}, equalsTestCase{[]int{}, false, true, "which is not numeric"}, equalsTestCase{"taco", false, true, "which is not numeric"}, equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) PositiveIntegralFloatingPointLiteral() { // 2^30 matcher := Equals(1073741824.0) ExpectEq("1.073741824e+09", matcher.Description()) cases := []equalsTestCase{ // Various types of 1073741824. equalsTestCase{1073741824, true, false, ""}, equalsTestCase{1073741824.0, true, false, ""}, equalsTestCase{1073741824 + 0i, true, false, ""}, equalsTestCase{int(1073741824), true, false, ""}, equalsTestCase{int32(1073741824), true, false, ""}, equalsTestCase{int64(1073741824), true, false, ""}, equalsTestCase{uint(1073741824), true, false, ""}, equalsTestCase{uint32(1073741824), true, false, ""}, equalsTestCase{uint64(1073741824), true, false, ""}, equalsTestCase{float32(1073741824), true, false, ""}, equalsTestCase{float64(1073741824), true, false, ""}, equalsTestCase{complex64(1073741824), true, false, ""}, equalsTestCase{complex128(1073741824), true, false, ""}, equalsTestCase{interface{}(int(1073741824)), true, false, ""}, equalsTestCase{interface{}(float64(1073741824)), true, false, ""}, // Values that would be 1073741824 in two's complement. equalsTestCase{uint((1 << 32) - 1073741824), false, false, ""}, equalsTestCase{uint32((1 << 32) - 1073741824), false, false, ""}, equalsTestCase{uint64((1 << 64) - 1073741824), false, false, ""}, equalsTestCase{uintptr((1 << 64) - 1073741824), false, false, ""}, // Non-equal values of numeric type. equalsTestCase{int(1073741823), false, false, ""}, equalsTestCase{int32(1073741823), false, false, ""}, equalsTestCase{int64(1073741823), false, false, ""}, equalsTestCase{uint(1073741823), false, false, ""}, equalsTestCase{uint32(1073741823), false, false, ""}, equalsTestCase{uint64(1073741823), false, false, ""}, equalsTestCase{float64(1073741824.1), false, false, ""}, equalsTestCase{float64(1073741823.9), false, false, ""}, equalsTestCase{complex128(1073741823), false, false, ""}, equalsTestCase{complex128(1073741824 + 2i), false, false, ""}, // Non-numeric types. equalsTestCase{true, false, true, "which is not numeric"}, equalsTestCase{[...]int{}, false, true, "which is not numeric"}, equalsTestCase{make(chan int), false, true, "which is not numeric"}, equalsTestCase{func() {}, false, true, "which is not numeric"}, equalsTestCase{map[int]int{}, false, true, "which is not numeric"}, equalsTestCase{&someInt, false, true, "which is not numeric"}, equalsTestCase{[]int{}, false, true, "which is not numeric"}, equalsTestCase{"taco", false, true, "which is not numeric"}, equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) NonIntegralFloatingPointLiteral() { matcher := Equals(17.1) ExpectEq("17.1", matcher.Description()) cases := []equalsTestCase{ // Various types of 17.1. equalsTestCase{17.1, true, false, ""}, equalsTestCase{17.1, true, false, ""}, equalsTestCase{17.1 + 0i, true, false, ""}, equalsTestCase{float32(17.1), true, false, ""}, equalsTestCase{float64(17.1), true, false, ""}, equalsTestCase{complex64(17.1), true, false, ""}, equalsTestCase{complex128(17.1), true, false, ""}, // Non-equal values of numeric type. equalsTestCase{17, false, false, ""}, equalsTestCase{17.2, false, false, ""}, equalsTestCase{18, false, false, ""}, equalsTestCase{int(17), false, false, ""}, equalsTestCase{int(18), false, false, ""}, equalsTestCase{int32(17), false, false, ""}, equalsTestCase{int64(17), false, false, ""}, equalsTestCase{uint(17), false, false, ""}, equalsTestCase{uint32(17), false, false, ""}, equalsTestCase{uint64(17), false, false, ""}, equalsTestCase{uintptr(17), false, false, ""}, equalsTestCase{complex128(17.1 + 2i), false, false, ""}, // Non-numeric types. equalsTestCase{true, false, true, "which is not numeric"}, equalsTestCase{[...]int{}, false, true, "which is not numeric"}, equalsTestCase{make(chan int), false, true, "which is not numeric"}, equalsTestCase{func() {}, false, true, "which is not numeric"}, equalsTestCase{map[int]int{}, false, true, "which is not numeric"}, equalsTestCase{&someInt, false, true, "which is not numeric"}, equalsTestCase{[]int{}, false, true, "which is not numeric"}, equalsTestCase{"taco", false, true, "which is not numeric"}, equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"}, } t.checkTestCases(matcher, cases) } //////////////////////////////////////////////////////////////////////// // bool //////////////////////////////////////////////////////////////////////// func (t *EqualsTest) False() { matcher := Equals(false) ExpectEq("false", matcher.Description()) cases := []equalsTestCase{ // bools equalsTestCase{false, true, false, ""}, equalsTestCase{bool(false), true, false, ""}, equalsTestCase{true, false, false, ""}, equalsTestCase{bool(true), false, false, ""}, // Other types. equalsTestCase{int(0), false, true, "which is not a bool"}, equalsTestCase{int8(0), false, true, "which is not a bool"}, equalsTestCase{int16(0), false, true, "which is not a bool"}, equalsTestCase{int32(0), false, true, "which is not a bool"}, equalsTestCase{int64(0), false, true, "which is not a bool"}, equalsTestCase{uint(0), false, true, "which is not a bool"}, equalsTestCase{uint8(0), false, true, "which is not a bool"}, equalsTestCase{uint16(0), false, true, "which is not a bool"}, equalsTestCase{uint32(0), false, true, "which is not a bool"}, equalsTestCase{uint64(0), false, true, "which is not a bool"}, equalsTestCase{uintptr(0), false, true, "which is not a bool"}, equalsTestCase{[...]int{}, false, true, "which is not a bool"}, equalsTestCase{make(chan int), false, true, "which is not a bool"}, equalsTestCase{func() {}, false, true, "which is not a bool"}, equalsTestCase{map[int]int{}, false, true, "which is not a bool"}, equalsTestCase{&someInt, false, true, "which is not a bool"}, equalsTestCase{[]int{}, false, true, "which is not a bool"}, equalsTestCase{"taco", false, true, "which is not a bool"}, equalsTestCase{equalsTestCase{}, false, true, "which is not a bool"}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) True() { matcher := Equals(true) ExpectEq("true", matcher.Description()) cases := []equalsTestCase{ // bools equalsTestCase{true, true, false, ""}, equalsTestCase{bool(true), true, false, ""}, equalsTestCase{false, false, false, ""}, equalsTestCase{bool(false), false, false, ""}, // Other types. equalsTestCase{int(1), false, true, "which is not a bool"}, equalsTestCase{int8(1), false, true, "which is not a bool"}, equalsTestCase{int16(1), false, true, "which is not a bool"}, equalsTestCase{int32(1), false, true, "which is not a bool"}, equalsTestCase{int64(1), false, true, "which is not a bool"}, equalsTestCase{uint(1), false, true, "which is not a bool"}, equalsTestCase{uint8(1), false, true, "which is not a bool"}, equalsTestCase{uint16(1), false, true, "which is not a bool"}, equalsTestCase{uint32(1), false, true, "which is not a bool"}, equalsTestCase{uint64(1), false, true, "which is not a bool"}, equalsTestCase{uintptr(1), false, true, "which is not a bool"}, equalsTestCase{[...]int{}, false, true, "which is not a bool"}, equalsTestCase{make(chan int), false, true, "which is not a bool"}, equalsTestCase{func() {}, false, true, "which is not a bool"}, equalsTestCase{map[int]int{}, false, true, "which is not a bool"}, equalsTestCase{&someInt, false, true, "which is not a bool"}, equalsTestCase{[]int{}, false, true, "which is not a bool"}, equalsTestCase{"taco", false, true, "which is not a bool"}, equalsTestCase{equalsTestCase{}, false, true, "which is not a bool"}, } t.checkTestCases(matcher, cases) } //////////////////////////////////////////////////////////////////////// // int //////////////////////////////////////////////////////////////////////// func (t *EqualsTest) NegativeInt() { // -2^30 matcher := Equals(int(-1073741824)) ExpectEq("-1073741824", matcher.Description()) cases := []equalsTestCase{ // Various types of -1073741824. equalsTestCase{-1073741824, true, false, ""}, equalsTestCase{-1073741824.0, true, false, ""}, equalsTestCase{-1073741824 + 0i, true, false, ""}, equalsTestCase{int(-1073741824), true, false, ""}, equalsTestCase{int32(-1073741824), true, false, ""}, equalsTestCase{int64(-1073741824), true, false, ""}, equalsTestCase{float32(-1073741824), true, false, ""}, equalsTestCase{float64(-1073741824), true, false, ""}, equalsTestCase{complex64(-1073741824), true, false, ""}, equalsTestCase{complex128(-1073741824), true, false, ""}, equalsTestCase{interface{}(int(-1073741824)), true, false, ""}, // Values that would be -1073741824 in two's complement. equalsTestCase{uint((1 << 32) - 1073741824), false, false, ""}, equalsTestCase{uint32((1 << 32) - 1073741824), false, false, ""}, equalsTestCase{uint64((1 << 64) - 1073741824), false, false, ""}, equalsTestCase{uintptr((1 << 64) - 1073741824), false, false, ""}, // Non-equal values of signed integer type. equalsTestCase{int(-1073741823), false, false, ""}, equalsTestCase{int32(-1073741823), false, false, ""}, equalsTestCase{int64(-1073741823), false, false, ""}, // Non-equal values of other numeric types. equalsTestCase{float64(-1073741824.1), false, false, ""}, equalsTestCase{float64(-1073741823.9), false, false, ""}, equalsTestCase{complex128(-1073741823), false, false, ""}, equalsTestCase{complex128(-1073741824 + 2i), false, false, ""}, // Non-numeric types. equalsTestCase{true, false, true, "which is not numeric"}, equalsTestCase{[...]int{}, false, true, "which is not numeric"}, equalsTestCase{make(chan int), false, true, "which is not numeric"}, equalsTestCase{func() {}, false, true, "which is not numeric"}, equalsTestCase{map[int]int{}, false, true, "which is not numeric"}, equalsTestCase{&someInt, false, true, "which is not numeric"}, equalsTestCase{[]int{}, false, true, "which is not numeric"}, equalsTestCase{"taco", false, true, "which is not numeric"}, equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) PositiveInt() { // 2^30 matcher := Equals(int(1073741824)) ExpectEq("1073741824", matcher.Description()) cases := []equalsTestCase{ // Various types of 1073741824. equalsTestCase{1073741824, true, false, ""}, equalsTestCase{1073741824.0, true, false, ""}, equalsTestCase{1073741824 + 0i, true, false, ""}, equalsTestCase{int(1073741824), true, false, ""}, equalsTestCase{uint(1073741824), true, false, ""}, equalsTestCase{int32(1073741824), true, false, ""}, equalsTestCase{int64(1073741824), true, false, ""}, equalsTestCase{uint32(1073741824), true, false, ""}, equalsTestCase{uint64(1073741824), true, false, ""}, equalsTestCase{uintptr(1073741824), true, false, ""}, equalsTestCase{float32(1073741824), true, false, ""}, equalsTestCase{float64(1073741824), true, false, ""}, equalsTestCase{complex64(1073741824), true, false, ""}, equalsTestCase{complex128(1073741824), true, false, ""}, equalsTestCase{interface{}(int(1073741824)), true, false, ""}, equalsTestCase{interface{}(uint(1073741824)), true, false, ""}, // Non-equal values of numeric type. equalsTestCase{int(1073741823), false, false, ""}, equalsTestCase{int32(1073741823), false, false, ""}, equalsTestCase{int64(1073741823), false, false, ""}, equalsTestCase{float64(1073741824.1), false, false, ""}, equalsTestCase{float64(1073741823.9), false, false, ""}, equalsTestCase{complex128(1073741823), false, false, ""}, equalsTestCase{complex128(1073741824 + 2i), false, false, ""}, // Non-numeric types. equalsTestCase{true, false, true, "which is not numeric"}, equalsTestCase{[...]int{}, false, true, "which is not numeric"}, equalsTestCase{make(chan int), false, true, "which is not numeric"}, equalsTestCase{func() {}, false, true, "which is not numeric"}, equalsTestCase{map[int]int{}, false, true, "which is not numeric"}, equalsTestCase{&someInt, false, true, "which is not numeric"}, equalsTestCase{[]int{}, false, true, "which is not numeric"}, equalsTestCase{"taco", false, true, "which is not numeric"}, equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"}, } t.checkTestCases(matcher, cases) } //////////////////////////////////////////////////////////////////////// // int8 //////////////////////////////////////////////////////////////////////// func (t *EqualsTest) NegativeInt8() { matcher := Equals(int8(-17)) ExpectEq("-17", matcher.Description()) cases := []equalsTestCase{ // Various types of -17. equalsTestCase{-17, true, false, ""}, equalsTestCase{-17.0, true, false, ""}, equalsTestCase{-17 + 0i, true, false, ""}, equalsTestCase{int(-17), true, false, ""}, equalsTestCase{int8(-17), true, false, ""}, equalsTestCase{int16(-17), true, false, ""}, equalsTestCase{int32(-17), true, false, ""}, equalsTestCase{int64(-17), true, false, ""}, equalsTestCase{float32(-17), true, false, ""}, equalsTestCase{float64(-17), true, false, ""}, equalsTestCase{complex64(-17), true, false, ""}, equalsTestCase{complex128(-17), true, false, ""}, equalsTestCase{interface{}(int(-17)), true, false, ""}, // Values that would be -17 in two's complement. equalsTestCase{uint((1 << 32) - 17), false, false, ""}, equalsTestCase{uint8((1 << 8) - 17), false, false, ""}, equalsTestCase{uint16((1 << 16) - 17), false, false, ""}, equalsTestCase{uint32((1 << 32) - 17), false, false, ""}, equalsTestCase{uint64((1 << 64) - 17), false, false, ""}, equalsTestCase{uintptr((1 << 64) - 17), false, false, ""}, // Non-equal values of signed integer type. equalsTestCase{int(-16), false, false, ""}, equalsTestCase{int8(-16), false, false, ""}, equalsTestCase{int16(-16), false, false, ""}, equalsTestCase{int32(-16), false, false, ""}, equalsTestCase{int64(-16), false, false, ""}, // Non-equal values of other numeric types. equalsTestCase{float32(-17.1), false, false, ""}, equalsTestCase{float32(-16.9), false, false, ""}, equalsTestCase{complex64(-16), false, false, ""}, equalsTestCase{complex64(-17 + 2i), false, false, ""}, // Non-numeric types. equalsTestCase{true, false, true, "which is not numeric"}, equalsTestCase{[...]int{-17}, false, true, "which is not numeric"}, equalsTestCase{make(chan int), false, true, "which is not numeric"}, equalsTestCase{func() {}, false, true, "which is not numeric"}, equalsTestCase{map[int]int{}, false, true, "which is not numeric"}, equalsTestCase{&someInt, false, true, "which is not numeric"}, equalsTestCase{[]int{-17}, false, true, "which is not numeric"}, equalsTestCase{"-17", false, true, "which is not numeric"}, equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) ZeroInt8() { matcher := Equals(int8(0)) ExpectEq("0", matcher.Description()) cases := []equalsTestCase{ // Various types of 0. equalsTestCase{0, true, false, ""}, equalsTestCase{0.0, true, false, ""}, equalsTestCase{0 + 0i, true, false, ""}, equalsTestCase{int(0), true, false, ""}, equalsTestCase{int8(0), true, false, ""}, equalsTestCase{int16(0), true, false, ""}, equalsTestCase{int32(0), true, false, ""}, equalsTestCase{int64(0), true, false, ""}, equalsTestCase{float32(0), true, false, ""}, equalsTestCase{float64(0), true, false, ""}, equalsTestCase{complex64(0), true, false, ""}, equalsTestCase{complex128(0), true, false, ""}, equalsTestCase{interface{}(int(0)), true, false, ""}, equalsTestCase{uint(0), true, false, ""}, equalsTestCase{uint8(0), true, false, ""}, equalsTestCase{uint16(0), true, false, ""}, equalsTestCase{uint32(0), true, false, ""}, equalsTestCase{uint64(0), true, false, ""}, equalsTestCase{uintptr(0), true, false, ""}, // Non-equal values of numeric type. equalsTestCase{int(1), false, false, ""}, equalsTestCase{int8(1), false, false, ""}, equalsTestCase{int16(1), false, false, ""}, equalsTestCase{int32(1), false, false, ""}, equalsTestCase{int64(1), false, false, ""}, equalsTestCase{float32(-0.1), false, false, ""}, equalsTestCase{float32(0.1), false, false, ""}, equalsTestCase{complex64(1), false, false, ""}, equalsTestCase{complex64(0 + 2i), false, false, ""}, // Non-numeric types. equalsTestCase{true, false, true, "which is not numeric"}, equalsTestCase{[...]int{0}, false, true, "which is not numeric"}, equalsTestCase{make(chan int), false, true, "which is not numeric"}, equalsTestCase{func() {}, false, true, "which is not numeric"}, equalsTestCase{map[int]int{}, false, true, "which is not numeric"}, equalsTestCase{&someInt, false, true, "which is not numeric"}, equalsTestCase{[]int{0}, false, true, "which is not numeric"}, equalsTestCase{"0", false, true, "which is not numeric"}, equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) PositiveInt8() { matcher := Equals(int8(17)) ExpectEq("17", matcher.Description()) cases := []equalsTestCase{ // Various types of 17. equalsTestCase{17, true, false, ""}, equalsTestCase{17.0, true, false, ""}, equalsTestCase{17 + 0i, true, false, ""}, equalsTestCase{int(17), true, false, ""}, equalsTestCase{int8(17), true, false, ""}, equalsTestCase{int16(17), true, false, ""}, equalsTestCase{int32(17), true, false, ""}, equalsTestCase{int64(17), true, false, ""}, equalsTestCase{float32(17), true, false, ""}, equalsTestCase{float64(17), true, false, ""}, equalsTestCase{complex64(17), true, false, ""}, equalsTestCase{complex128(17), true, false, ""}, equalsTestCase{interface{}(int(17)), true, false, ""}, equalsTestCase{uint(17), true, false, ""}, equalsTestCase{uint8(17), true, false, ""}, equalsTestCase{uint16(17), true, false, ""}, equalsTestCase{uint32(17), true, false, ""}, equalsTestCase{uint64(17), true, false, ""}, equalsTestCase{uintptr(17), true, false, ""}, // Non-equal values of numeric type. equalsTestCase{int(16), false, false, ""}, equalsTestCase{int8(16), false, false, ""}, equalsTestCase{int16(16), false, false, ""}, equalsTestCase{int32(16), false, false, ""}, equalsTestCase{int64(16), false, false, ""}, equalsTestCase{float32(16.9), false, false, ""}, equalsTestCase{float32(17.1), false, false, ""}, equalsTestCase{complex64(16), false, false, ""}, equalsTestCase{complex64(17 + 2i), false, false, ""}, // Non-numeric types. equalsTestCase{true, false, true, "which is not numeric"}, equalsTestCase{[...]int{17}, false, true, "which is not numeric"}, equalsTestCase{make(chan int), false, true, "which is not numeric"}, equalsTestCase{func() {}, false, true, "which is not numeric"}, equalsTestCase{map[int]int{}, false, true, "which is not numeric"}, equalsTestCase{&someInt, false, true, "which is not numeric"}, equalsTestCase{[]int{17}, false, true, "which is not numeric"}, equalsTestCase{"17", false, true, "which is not numeric"}, equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"}, } t.checkTestCases(matcher, cases) } //////////////////////////////////////////////////////////////////////// // int16 //////////////////////////////////////////////////////////////////////// func (t *EqualsTest) NegativeInt16() { matcher := Equals(int16(-32766)) ExpectEq("-32766", matcher.Description()) cases := []equalsTestCase{ // Various types of -32766. equalsTestCase{-32766, true, false, ""}, equalsTestCase{-32766.0, true, false, ""}, equalsTestCase{-32766 + 0i, true, false, ""}, equalsTestCase{int(-32766), true, false, ""}, equalsTestCase{int16(-32766), true, false, ""}, equalsTestCase{int32(-32766), true, false, ""}, equalsTestCase{int64(-32766), true, false, ""}, equalsTestCase{float32(-32766), true, false, ""}, equalsTestCase{float64(-32766), true, false, ""}, equalsTestCase{complex64(-32766), true, false, ""}, equalsTestCase{complex128(-32766), true, false, ""}, equalsTestCase{interface{}(int(-32766)), true, false, ""}, // Values that would be -32766 in two's complement. equalsTestCase{uint((1 << 32) - 32766), false, false, ""}, equalsTestCase{uint16((1 << 16) - 32766), false, false, ""}, equalsTestCase{uint32((1 << 32) - 32766), false, false, ""}, equalsTestCase{uint64((1 << 64) - 32766), false, false, ""}, equalsTestCase{uintptr((1 << 64) - 32766), false, false, ""}, // Non-equal values of signed integer type. equalsTestCase{int(-16), false, false, ""}, equalsTestCase{int8(-16), false, false, ""}, equalsTestCase{int16(-16), false, false, ""}, equalsTestCase{int32(-16), false, false, ""}, equalsTestCase{int64(-16), false, false, ""}, // Non-equal values of other numeric types. equalsTestCase{float32(-32766.1), false, false, ""}, equalsTestCase{float32(-32765.9), false, false, ""}, equalsTestCase{complex64(-32766.1), false, false, ""}, equalsTestCase{complex64(-32766 + 2i), false, false, ""}, // Non-numeric types. equalsTestCase{true, false, true, "which is not numeric"}, equalsTestCase{[...]int{-32766}, false, true, "which is not numeric"}, equalsTestCase{make(chan int), false, true, "which is not numeric"}, equalsTestCase{func() {}, false, true, "which is not numeric"}, equalsTestCase{map[int]int{}, false, true, "which is not numeric"}, equalsTestCase{&someInt, false, true, "which is not numeric"}, equalsTestCase{[]int{-32766}, false, true, "which is not numeric"}, equalsTestCase{"-32766", false, true, "which is not numeric"}, equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) ZeroInt16() { matcher := Equals(int16(0)) ExpectEq("0", matcher.Description()) cases := []equalsTestCase{ // Various types of 0. equalsTestCase{0, true, false, ""}, equalsTestCase{0.0, true, false, ""}, equalsTestCase{0 + 0i, true, false, ""}, equalsTestCase{int(0), true, false, ""}, equalsTestCase{int8(0), true, false, ""}, equalsTestCase{int16(0), true, false, ""}, equalsTestCase{int32(0), true, false, ""}, equalsTestCase{int64(0), true, false, ""}, equalsTestCase{float32(0), true, false, ""}, equalsTestCase{float64(0), true, false, ""}, equalsTestCase{complex64(0), true, false, ""}, equalsTestCase{complex128(0), true, false, ""}, equalsTestCase{interface{}(int(0)), true, false, ""}, equalsTestCase{uint(0), true, false, ""}, equalsTestCase{uint8(0), true, false, ""}, equalsTestCase{uint16(0), true, false, ""}, equalsTestCase{uint32(0), true, false, ""}, equalsTestCase{uint64(0), true, false, ""}, equalsTestCase{uintptr(0), true, false, ""}, // Non-equal values of numeric type. equalsTestCase{int(1), false, false, ""}, equalsTestCase{int8(1), false, false, ""}, equalsTestCase{int16(1), false, false, ""}, equalsTestCase{int32(1), false, false, ""}, equalsTestCase{int64(1), false, false, ""}, equalsTestCase{float32(-0.1), false, false, ""}, equalsTestCase{float32(0.1), false, false, ""}, equalsTestCase{complex64(1), false, false, ""}, equalsTestCase{complex64(0 + 2i), false, false, ""}, // Non-numeric types. equalsTestCase{true, false, true, "which is not numeric"}, equalsTestCase{[...]int{0}, false, true, "which is not numeric"}, equalsTestCase{make(chan int), false, true, "which is not numeric"}, equalsTestCase{func() {}, false, true, "which is not numeric"}, equalsTestCase{map[int]int{}, false, true, "which is not numeric"}, equalsTestCase{&someInt, false, true, "which is not numeric"}, equalsTestCase{[]int{0}, false, true, "which is not numeric"}, equalsTestCase{"0", false, true, "which is not numeric"}, equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) PositiveInt16() { matcher := Equals(int16(32765)) ExpectEq("32765", matcher.Description()) cases := []equalsTestCase{ // Various types of 32765. equalsTestCase{32765, true, false, ""}, equalsTestCase{32765.0, true, false, ""}, equalsTestCase{32765 + 0i, true, false, ""}, equalsTestCase{int(32765), true, false, ""}, equalsTestCase{int16(32765), true, false, ""}, equalsTestCase{int32(32765), true, false, ""}, equalsTestCase{int64(32765), true, false, ""}, equalsTestCase{float32(32765), true, false, ""}, equalsTestCase{float64(32765), true, false, ""}, equalsTestCase{complex64(32765), true, false, ""}, equalsTestCase{complex128(32765), true, false, ""}, equalsTestCase{interface{}(int(32765)), true, false, ""}, equalsTestCase{uint(32765), true, false, ""}, equalsTestCase{uint16(32765), true, false, ""}, equalsTestCase{uint32(32765), true, false, ""}, equalsTestCase{uint64(32765), true, false, ""}, equalsTestCase{uintptr(32765), true, false, ""}, // Non-equal values of numeric type. equalsTestCase{int(32764), false, false, ""}, equalsTestCase{int16(32764), false, false, ""}, equalsTestCase{int32(32764), false, false, ""}, equalsTestCase{int64(32764), false, false, ""}, equalsTestCase{float32(32764.9), false, false, ""}, equalsTestCase{float32(32765.1), false, false, ""}, equalsTestCase{complex64(32765.9), false, false, ""}, equalsTestCase{complex64(32765 + 2i), false, false, ""}, // Non-numeric types. equalsTestCase{true, false, true, "which is not numeric"}, equalsTestCase{[...]int{32765}, false, true, "which is not numeric"}, equalsTestCase{make(chan int), false, true, "which is not numeric"}, equalsTestCase{func() {}, false, true, "which is not numeric"}, equalsTestCase{map[int]int{}, false, true, "which is not numeric"}, equalsTestCase{&someInt, false, true, "which is not numeric"}, equalsTestCase{[]int{32765}, false, true, "which is not numeric"}, equalsTestCase{"32765", false, true, "which is not numeric"}, equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"}, } t.checkTestCases(matcher, cases) } //////////////////////////////////////////////////////////////////////// // int32 //////////////////////////////////////////////////////////////////////// func (t *EqualsTest) NegativeInt32() { // -2^30 matcher := Equals(int32(-1073741824)) ExpectEq("-1073741824", matcher.Description()) cases := []equalsTestCase{ // Various types of -1073741824. equalsTestCase{-1073741824, true, false, ""}, equalsTestCase{-1073741824.0, true, false, ""}, equalsTestCase{-1073741824 + 0i, true, false, ""}, equalsTestCase{int(-1073741824), true, false, ""}, equalsTestCase{int32(-1073741824), true, false, ""}, equalsTestCase{int64(-1073741824), true, false, ""}, equalsTestCase{float32(-1073741824), true, false, ""}, equalsTestCase{float64(-1073741824), true, false, ""}, equalsTestCase{complex64(-1073741824), true, false, ""}, equalsTestCase{complex128(-1073741824), true, false, ""}, equalsTestCase{interface{}(int(-1073741824)), true, false, ""}, // Values that would be -1073741824 in two's complement. equalsTestCase{uint((1 << 32) - 1073741824), false, false, ""}, equalsTestCase{uint32((1 << 32) - 1073741824), false, false, ""}, equalsTestCase{uint64((1 << 64) - 1073741824), false, false, ""}, equalsTestCase{uintptr((1 << 64) - 1073741824), false, false, ""}, // Non-equal values of signed integer type. equalsTestCase{int(-1073741823), false, false, ""}, equalsTestCase{int32(-1073741823), false, false, ""}, equalsTestCase{int64(-1073741823), false, false, ""}, // Non-equal values of other numeric types. equalsTestCase{float64(-1073741824.1), false, false, ""}, equalsTestCase{float64(-1073741823.9), false, false, ""}, equalsTestCase{complex128(-1073741823), false, false, ""}, equalsTestCase{complex128(-1073741824 + 2i), false, false, ""}, // Non-numeric types. equalsTestCase{true, false, true, "which is not numeric"}, equalsTestCase{[...]int{}, false, true, "which is not numeric"}, equalsTestCase{make(chan int), false, true, "which is not numeric"}, equalsTestCase{func() {}, false, true, "which is not numeric"}, equalsTestCase{map[int]int{}, false, true, "which is not numeric"}, equalsTestCase{&someInt, false, true, "which is not numeric"}, equalsTestCase{[]int{}, false, true, "which is not numeric"}, equalsTestCase{"taco", false, true, "which is not numeric"}, equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) PositiveInt32() { // 2^30 matcher := Equals(int32(1073741824)) ExpectEq("1073741824", matcher.Description()) cases := []equalsTestCase{ // Various types of 1073741824. equalsTestCase{1073741824, true, false, ""}, equalsTestCase{1073741824.0, true, false, ""}, equalsTestCase{1073741824 + 0i, true, false, ""}, equalsTestCase{int(1073741824), true, false, ""}, equalsTestCase{uint(1073741824), true, false, ""}, equalsTestCase{int32(1073741824), true, false, ""}, equalsTestCase{int64(1073741824), true, false, ""}, equalsTestCase{uint32(1073741824), true, false, ""}, equalsTestCase{uint64(1073741824), true, false, ""}, equalsTestCase{uintptr(1073741824), true, false, ""}, equalsTestCase{float32(1073741824), true, false, ""}, equalsTestCase{float64(1073741824), true, false, ""}, equalsTestCase{complex64(1073741824), true, false, ""}, equalsTestCase{complex128(1073741824), true, false, ""}, equalsTestCase{interface{}(int(1073741824)), true, false, ""}, equalsTestCase{interface{}(uint(1073741824)), true, false, ""}, // Non-equal values of numeric type. equalsTestCase{int(1073741823), false, false, ""}, equalsTestCase{int32(1073741823), false, false, ""}, equalsTestCase{int64(1073741823), false, false, ""}, equalsTestCase{float64(1073741824.1), false, false, ""}, equalsTestCase{float64(1073741823.9), false, false, ""}, equalsTestCase{complex128(1073741823), false, false, ""}, equalsTestCase{complex128(1073741824 + 2i), false, false, ""}, // Non-numeric types. equalsTestCase{true, false, true, "which is not numeric"}, equalsTestCase{[...]int{}, false, true, "which is not numeric"}, equalsTestCase{make(chan int), false, true, "which is not numeric"}, equalsTestCase{func() {}, false, true, "which is not numeric"}, equalsTestCase{map[int]int{}, false, true, "which is not numeric"}, equalsTestCase{&someInt, false, true, "which is not numeric"}, equalsTestCase{[]int{}, false, true, "which is not numeric"}, equalsTestCase{"taco", false, true, "which is not numeric"}, equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"}, } t.checkTestCases(matcher, cases) } //////////////////////////////////////////////////////////////////////// // int64 //////////////////////////////////////////////////////////////////////// func (t *EqualsTest) NegativeInt64() { // -2^40 matcher := Equals(int64(-1099511627776)) ExpectEq("-1099511627776", matcher.Description()) cases := []equalsTestCase{ // Various types of -1099511627776. equalsTestCase{-1099511627776.0, true, false, ""}, equalsTestCase{-1099511627776 + 0i, true, false, ""}, equalsTestCase{int64(-1099511627776), true, false, ""}, equalsTestCase{float32(-1099511627776), true, false, ""}, equalsTestCase{float64(-1099511627776), true, false, ""}, equalsTestCase{complex64(-1099511627776), true, false, ""}, equalsTestCase{complex128(-1099511627776), true, false, ""}, equalsTestCase{interface{}(int64(-1099511627776)), true, false, ""}, // Values that would be -1099511627776 in two's complement. equalsTestCase{uint64((1 << 64) - 1099511627776), false, false, ""}, // Non-equal values of signed integer type. equalsTestCase{int64(-1099511627775), false, false, ""}, // Non-equal values of other numeric types. equalsTestCase{float64(-1099511627776.1), false, false, ""}, equalsTestCase{float64(-1099511627775.9), false, false, ""}, equalsTestCase{complex128(-1099511627775), false, false, ""}, equalsTestCase{complex128(-1099511627776 + 2i), false, false, ""}, // Non-numeric types. equalsTestCase{true, false, true, "which is not numeric"}, equalsTestCase{[...]int{}, false, true, "which is not numeric"}, equalsTestCase{make(chan int), false, true, "which is not numeric"}, equalsTestCase{func() {}, false, true, "which is not numeric"}, equalsTestCase{map[int]int{}, false, true, "which is not numeric"}, equalsTestCase{&someInt, false, true, "which is not numeric"}, equalsTestCase{[]int{}, false, true, "which is not numeric"}, equalsTestCase{"taco", false, true, "which is not numeric"}, equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) PositiveInt64() { // 2^40 matcher := Equals(int64(1099511627776)) ExpectEq("1099511627776", matcher.Description()) cases := []equalsTestCase{ // Various types of 1099511627776. equalsTestCase{1099511627776.0, true, false, ""}, equalsTestCase{1099511627776 + 0i, true, false, ""}, equalsTestCase{int64(1099511627776), true, false, ""}, equalsTestCase{uint64(1099511627776), true, false, ""}, equalsTestCase{uintptr(1099511627776), true, false, ""}, equalsTestCase{float32(1099511627776), true, false, ""}, equalsTestCase{float64(1099511627776), true, false, ""}, equalsTestCase{complex64(1099511627776), true, false, ""}, equalsTestCase{complex128(1099511627776), true, false, ""}, equalsTestCase{interface{}(int64(1099511627776)), true, false, ""}, equalsTestCase{interface{}(uint64(1099511627776)), true, false, ""}, // Non-equal values of numeric type. equalsTestCase{int64(1099511627775), false, false, ""}, equalsTestCase{uint64(1099511627775), false, false, ""}, equalsTestCase{float64(1099511627776.1), false, false, ""}, equalsTestCase{float64(1099511627775.9), false, false, ""}, equalsTestCase{complex128(1099511627775), false, false, ""}, equalsTestCase{complex128(1099511627776 + 2i), false, false, ""}, // Non-numeric types. equalsTestCase{true, false, true, "which is not numeric"}, equalsTestCase{[...]int{}, false, true, "which is not numeric"}, equalsTestCase{make(chan int), false, true, "which is not numeric"}, equalsTestCase{func() {}, false, true, "which is not numeric"}, equalsTestCase{map[int]int{}, false, true, "which is not numeric"}, equalsTestCase{&someInt, false, true, "which is not numeric"}, equalsTestCase{[]int{}, false, true, "which is not numeric"}, equalsTestCase{"taco", false, true, "which is not numeric"}, equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) Int64NotExactlyRepresentableBySinglePrecision() { // Single-precision floats don't have enough bits to represent the integers // near this one distinctly, so [2^25-1, 2^25+2] all receive the same value // and should be treated as equivalent when floats are in the mix. const kTwoTo25 = 1 << 25 matcher := Equals(int64(kTwoTo25 + 1)) ExpectEq("33554433", matcher.Description()) cases := []equalsTestCase{ // Integers. equalsTestCase{int64(kTwoTo25 + 0), false, false, ""}, equalsTestCase{int64(kTwoTo25 + 1), true, false, ""}, equalsTestCase{int64(kTwoTo25 + 2), false, false, ""}, equalsTestCase{uint64(kTwoTo25 + 0), false, false, ""}, equalsTestCase{uint64(kTwoTo25 + 1), true, false, ""}, equalsTestCase{uint64(kTwoTo25 + 2), false, false, ""}, // Single-precision floating point. equalsTestCase{float32(kTwoTo25 - 2), false, false, ""}, equalsTestCase{float32(kTwoTo25 - 1), true, false, ""}, equalsTestCase{float32(kTwoTo25 + 0), true, false, ""}, equalsTestCase{float32(kTwoTo25 + 1), true, false, ""}, equalsTestCase{float32(kTwoTo25 + 2), true, false, ""}, equalsTestCase{float32(kTwoTo25 + 3), false, false, ""}, equalsTestCase{complex64(kTwoTo25 - 2), false, false, ""}, equalsTestCase{complex64(kTwoTo25 - 1), true, false, ""}, equalsTestCase{complex64(kTwoTo25 + 0), true, false, ""}, equalsTestCase{complex64(kTwoTo25 + 1), true, false, ""}, equalsTestCase{complex64(kTwoTo25 + 2), true, false, ""}, equalsTestCase{complex64(kTwoTo25 + 3), false, false, ""}, // Double-precision floating point. equalsTestCase{float64(kTwoTo25 + 0), false, false, ""}, equalsTestCase{float64(kTwoTo25 + 1), true, false, ""}, equalsTestCase{float64(kTwoTo25 + 2), false, false, ""}, equalsTestCase{complex128(kTwoTo25 + 0), false, false, ""}, equalsTestCase{complex128(kTwoTo25 + 1), true, false, ""}, equalsTestCase{complex128(kTwoTo25 + 2), false, false, ""}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) Int64NotExactlyRepresentableByDoublePrecision() { // Double-precision floats don't have enough bits to represent the integers // near this one distinctly, so [2^54-1, 2^54+2] all receive the same value // and should be treated as equivalent when floats are in the mix. const kTwoTo54 = 1 << 54 matcher := Equals(int64(kTwoTo54 + 1)) ExpectEq("18014398509481985", matcher.Description()) cases := []equalsTestCase{ // Integers. equalsTestCase{int64(kTwoTo54 + 0), false, false, ""}, equalsTestCase{int64(kTwoTo54 + 1), true, false, ""}, equalsTestCase{int64(kTwoTo54 + 2), false, false, ""}, equalsTestCase{uint64(kTwoTo54 + 0), false, false, ""}, equalsTestCase{uint64(kTwoTo54 + 1), true, false, ""}, equalsTestCase{uint64(kTwoTo54 + 2), false, false, ""}, // Double-precision floating point. equalsTestCase{float64(kTwoTo54 - 2), false, false, ""}, equalsTestCase{float64(kTwoTo54 - 1), true, false, ""}, equalsTestCase{float64(kTwoTo54 + 0), true, false, ""}, equalsTestCase{float64(kTwoTo54 + 1), true, false, ""}, equalsTestCase{float64(kTwoTo54 + 2), true, false, ""}, equalsTestCase{float64(kTwoTo54 + 3), false, false, ""}, equalsTestCase{complex128(kTwoTo54 - 2), false, false, ""}, equalsTestCase{complex128(kTwoTo54 - 1), true, false, ""}, equalsTestCase{complex128(kTwoTo54 + 0), true, false, ""}, equalsTestCase{complex128(kTwoTo54 + 1), true, false, ""}, equalsTestCase{complex128(kTwoTo54 + 2), true, false, ""}, equalsTestCase{complex128(kTwoTo54 + 3), false, false, ""}, } t.checkTestCases(matcher, cases) } //////////////////////////////////////////////////////////////////////// // uint //////////////////////////////////////////////////////////////////////// func (t *EqualsTest) SmallUint() { const kExpected = 17 matcher := Equals(uint(kExpected)) ExpectEq("17", matcher.Description()) cases := []equalsTestCase{ // Various types of the expected value. equalsTestCase{17, true, false, ""}, equalsTestCase{17.0, true, false, ""}, equalsTestCase{17 + 0i, true, false, ""}, equalsTestCase{int(kExpected), true, false, ""}, equalsTestCase{int8(kExpected), true, false, ""}, equalsTestCase{int16(kExpected), true, false, ""}, equalsTestCase{int32(kExpected), true, false, ""}, equalsTestCase{int64(kExpected), true, false, ""}, equalsTestCase{uint(kExpected), true, false, ""}, equalsTestCase{uint8(kExpected), true, false, ""}, equalsTestCase{uint16(kExpected), true, false, ""}, equalsTestCase{uint32(kExpected), true, false, ""}, equalsTestCase{uint64(kExpected), true, false, ""}, equalsTestCase{uintptr(kExpected), true, false, ""}, equalsTestCase{float32(kExpected), true, false, ""}, equalsTestCase{float64(kExpected), true, false, ""}, equalsTestCase{complex64(kExpected), true, false, ""}, equalsTestCase{complex128(kExpected), true, false, ""}, // Non-equal values of numeric types. equalsTestCase{kExpected + 1, false, false, ""}, equalsTestCase{int(kExpected + 1), false, false, ""}, equalsTestCase{int8(kExpected + 1), false, false, ""}, equalsTestCase{int16(kExpected + 1), false, false, ""}, equalsTestCase{int32(kExpected + 1), false, false, ""}, equalsTestCase{int64(kExpected + 1), false, false, ""}, equalsTestCase{uint(kExpected + 1), false, false, ""}, equalsTestCase{uint8(kExpected + 1), false, false, ""}, equalsTestCase{uint16(kExpected + 1), false, false, ""}, equalsTestCase{uint32(kExpected + 1), false, false, ""}, equalsTestCase{uint64(kExpected + 1), false, false, ""}, equalsTestCase{uintptr(kExpected + 1), false, false, ""}, equalsTestCase{float32(kExpected + 1), false, false, ""}, equalsTestCase{float64(kExpected + 1), false, false, ""}, equalsTestCase{complex64(kExpected + 2i), false, false, ""}, equalsTestCase{complex64(kExpected + 1), false, false, ""}, equalsTestCase{complex128(kExpected + 2i), false, false, ""}, equalsTestCase{complex128(kExpected + 1), false, false, ""}, // Non-numeric types. equalsTestCase{true, false, true, "which is not numeric"}, equalsTestCase{[...]int{}, false, true, "which is not numeric"}, equalsTestCase{make(chan int), false, true, "which is not numeric"}, equalsTestCase{func() {}, false, true, "which is not numeric"}, equalsTestCase{map[int]int{}, false, true, "which is not numeric"}, equalsTestCase{&someInt, false, true, "which is not numeric"}, equalsTestCase{[]int{}, false, true, "which is not numeric"}, equalsTestCase{"taco", false, true, "which is not numeric"}, equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) LargeUint() { const kExpected = (1 << 16) + 17 matcher := Equals(uint(kExpected)) ExpectEq("65553", matcher.Description()) cases := []equalsTestCase{ // Various types of the expected value. equalsTestCase{65553, true, false, ""}, equalsTestCase{65553.0, true, false, ""}, equalsTestCase{65553 + 0i, true, false, ""}, equalsTestCase{int32(kExpected), true, false, ""}, equalsTestCase{int64(kExpected), true, false, ""}, equalsTestCase{uint32(kExpected), true, false, ""}, equalsTestCase{uint64(kExpected), true, false, ""}, equalsTestCase{float32(kExpected), true, false, ""}, equalsTestCase{float64(kExpected), true, false, ""}, equalsTestCase{complex64(kExpected), true, false, ""}, equalsTestCase{complex128(kExpected), true, false, ""}, // Non-equal values of numeric types. equalsTestCase{int16(17), false, false, ""}, equalsTestCase{int32(kExpected + 1), false, false, ""}, equalsTestCase{int64(kExpected + 1), false, false, ""}, equalsTestCase{uint16(17), false, false, ""}, equalsTestCase{uint32(kExpected + 1), false, false, ""}, equalsTestCase{uint64(kExpected + 1), false, false, ""}, equalsTestCase{float64(kExpected + 1), false, false, ""}, equalsTestCase{complex128(kExpected + 2i), false, false, ""}, equalsTestCase{complex128(kExpected + 1), false, false, ""}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) UintNotExactlyRepresentableBySinglePrecision() { // Single-precision floats don't have enough bits to represent the integers // near this one distinctly, so [2^25-1, 2^25+2] all receive the same value // and should be treated as equivalent when floats are in the mix. const kTwoTo25 = 1 << 25 matcher := Equals(uint(kTwoTo25 + 1)) ExpectEq("33554433", matcher.Description()) cases := []equalsTestCase{ // Integers. equalsTestCase{int64(kTwoTo25 + 0), false, false, ""}, equalsTestCase{int64(kTwoTo25 + 1), true, false, ""}, equalsTestCase{int64(kTwoTo25 + 2), false, false, ""}, equalsTestCase{uint64(kTwoTo25 + 0), false, false, ""}, equalsTestCase{uint64(kTwoTo25 + 1), true, false, ""}, equalsTestCase{uint64(kTwoTo25 + 2), false, false, ""}, // Single-precision floating point. equalsTestCase{float32(kTwoTo25 - 2), false, false, ""}, equalsTestCase{float32(kTwoTo25 - 1), true, false, ""}, equalsTestCase{float32(kTwoTo25 + 0), true, false, ""}, equalsTestCase{float32(kTwoTo25 + 1), true, false, ""}, equalsTestCase{float32(kTwoTo25 + 2), true, false, ""}, equalsTestCase{float32(kTwoTo25 + 3), false, false, ""}, equalsTestCase{complex64(kTwoTo25 - 2), false, false, ""}, equalsTestCase{complex64(kTwoTo25 - 1), true, false, ""}, equalsTestCase{complex64(kTwoTo25 + 0), true, false, ""}, equalsTestCase{complex64(kTwoTo25 + 1), true, false, ""}, equalsTestCase{complex64(kTwoTo25 + 2), true, false, ""}, equalsTestCase{complex64(kTwoTo25 + 3), false, false, ""}, // Double-precision floating point. equalsTestCase{float64(kTwoTo25 + 0), false, false, ""}, equalsTestCase{float64(kTwoTo25 + 1), true, false, ""}, equalsTestCase{float64(kTwoTo25 + 2), false, false, ""}, equalsTestCase{complex128(kTwoTo25 + 0), false, false, ""}, equalsTestCase{complex128(kTwoTo25 + 1), true, false, ""}, equalsTestCase{complex128(kTwoTo25 + 2), false, false, ""}, } t.checkTestCases(matcher, cases) } //////////////////////////////////////////////////////////////////////// // uint8 //////////////////////////////////////////////////////////////////////// func (t *EqualsTest) SmallUint8() { const kExpected = 17 matcher := Equals(uint8(kExpected)) ExpectEq("17", matcher.Description()) cases := []equalsTestCase{ // Various types of the expected value. equalsTestCase{17, true, false, ""}, equalsTestCase{17.0, true, false, ""}, equalsTestCase{17 + 0i, true, false, ""}, equalsTestCase{int(kExpected), true, false, ""}, equalsTestCase{int8(kExpected), true, false, ""}, equalsTestCase{int16(kExpected), true, false, ""}, equalsTestCase{int32(kExpected), true, false, ""}, equalsTestCase{int64(kExpected), true, false, ""}, equalsTestCase{uint(kExpected), true, false, ""}, equalsTestCase{uint8(kExpected), true, false, ""}, equalsTestCase{uint16(kExpected), true, false, ""}, equalsTestCase{uint32(kExpected), true, false, ""}, equalsTestCase{uint64(kExpected), true, false, ""}, equalsTestCase{uintptr(kExpected), true, false, ""}, equalsTestCase{float32(kExpected), true, false, ""}, equalsTestCase{float64(kExpected), true, false, ""}, equalsTestCase{complex64(kExpected), true, false, ""}, equalsTestCase{complex128(kExpected), true, false, ""}, // Non-equal values of numeric types. equalsTestCase{kExpected + 1, false, false, ""}, equalsTestCase{int(kExpected + 1), false, false, ""}, equalsTestCase{int8(kExpected + 1), false, false, ""}, equalsTestCase{int16(kExpected + 1), false, false, ""}, equalsTestCase{int32(kExpected + 1), false, false, ""}, equalsTestCase{int64(kExpected + 1), false, false, ""}, equalsTestCase{uint(kExpected + 1), false, false, ""}, equalsTestCase{uint8(kExpected + 1), false, false, ""}, equalsTestCase{uint16(kExpected + 1), false, false, ""}, equalsTestCase{uint32(kExpected + 1), false, false, ""}, equalsTestCase{uint64(kExpected + 1), false, false, ""}, equalsTestCase{uintptr(kExpected + 1), false, false, ""}, equalsTestCase{float32(kExpected + 1), false, false, ""}, equalsTestCase{float64(kExpected + 1), false, false, ""}, equalsTestCase{complex64(kExpected + 2i), false, false, ""}, equalsTestCase{complex64(kExpected + 1), false, false, ""}, equalsTestCase{complex128(kExpected + 2i), false, false, ""}, equalsTestCase{complex128(kExpected + 1), false, false, ""}, // Non-numeric types. equalsTestCase{true, false, true, "which is not numeric"}, equalsTestCase{[...]int{}, false, true, "which is not numeric"}, equalsTestCase{make(chan int), false, true, "which is not numeric"}, equalsTestCase{func() {}, false, true, "which is not numeric"}, equalsTestCase{map[int]int{}, false, true, "which is not numeric"}, equalsTestCase{&someInt, false, true, "which is not numeric"}, equalsTestCase{[]int{}, false, true, "which is not numeric"}, equalsTestCase{"taco", false, true, "which is not numeric"}, equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"}, } t.checkTestCases(matcher, cases) } //////////////////////////////////////////////////////////////////////// // uint16 //////////////////////////////////////////////////////////////////////// func (t *EqualsTest) SmallUint16() { const kExpected = 17 matcher := Equals(uint16(kExpected)) ExpectEq("17", matcher.Description()) cases := []equalsTestCase{ // Various types of the expected value. equalsTestCase{17, true, false, ""}, equalsTestCase{17.0, true, false, ""}, equalsTestCase{17 + 0i, true, false, ""}, equalsTestCase{int(kExpected), true, false, ""}, equalsTestCase{int8(kExpected), true, false, ""}, equalsTestCase{int16(kExpected), true, false, ""}, equalsTestCase{int32(kExpected), true, false, ""}, equalsTestCase{int64(kExpected), true, false, ""}, equalsTestCase{uint(kExpected), true, false, ""}, equalsTestCase{uint8(kExpected), true, false, ""}, equalsTestCase{uint16(kExpected), true, false, ""}, equalsTestCase{uint32(kExpected), true, false, ""}, equalsTestCase{uint64(kExpected), true, false, ""}, equalsTestCase{uintptr(kExpected), true, false, ""}, equalsTestCase{float32(kExpected), true, false, ""}, equalsTestCase{float64(kExpected), true, false, ""}, equalsTestCase{complex64(kExpected), true, false, ""}, equalsTestCase{complex128(kExpected), true, false, ""}, // Non-equal values of numeric types. equalsTestCase{kExpected + 1, false, false, ""}, equalsTestCase{int(kExpected + 1), false, false, ""}, equalsTestCase{int8(kExpected + 1), false, false, ""}, equalsTestCase{int16(kExpected + 1), false, false, ""}, equalsTestCase{int32(kExpected + 1), false, false, ""}, equalsTestCase{int64(kExpected + 1), false, false, ""}, equalsTestCase{uint(kExpected + 1), false, false, ""}, equalsTestCase{uint8(kExpected + 1), false, false, ""}, equalsTestCase{uint16(kExpected + 1), false, false, ""}, equalsTestCase{uint32(kExpected + 1), false, false, ""}, equalsTestCase{uint64(kExpected + 1), false, false, ""}, equalsTestCase{uintptr(kExpected + 1), false, false, ""}, equalsTestCase{float32(kExpected + 1), false, false, ""}, equalsTestCase{float64(kExpected + 1), false, false, ""}, equalsTestCase{complex64(kExpected + 2i), false, false, ""}, equalsTestCase{complex64(kExpected + 1), false, false, ""}, equalsTestCase{complex128(kExpected + 2i), false, false, ""}, equalsTestCase{complex128(kExpected + 1), false, false, ""}, // Non-numeric types. equalsTestCase{true, false, true, "which is not numeric"}, equalsTestCase{[...]int{}, false, true, "which is not numeric"}, equalsTestCase{make(chan int), false, true, "which is not numeric"}, equalsTestCase{func() {}, false, true, "which is not numeric"}, equalsTestCase{map[int]int{}, false, true, "which is not numeric"}, equalsTestCase{&someInt, false, true, "which is not numeric"}, equalsTestCase{[]int{}, false, true, "which is not numeric"}, equalsTestCase{"taco", false, true, "which is not numeric"}, equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) LargeUint16() { const kExpected = (1 << 8) + 17 matcher := Equals(uint16(kExpected)) ExpectEq("273", matcher.Description()) cases := []equalsTestCase{ // Various types of the expected value. equalsTestCase{273, true, false, ""}, equalsTestCase{273.0, true, false, ""}, equalsTestCase{273 + 0i, true, false, ""}, equalsTestCase{int16(kExpected), true, false, ""}, equalsTestCase{int32(kExpected), true, false, ""}, equalsTestCase{int64(kExpected), true, false, ""}, equalsTestCase{uint16(kExpected), true, false, ""}, equalsTestCase{uint32(kExpected), true, false, ""}, equalsTestCase{uint64(kExpected), true, false, ""}, equalsTestCase{float32(kExpected), true, false, ""}, equalsTestCase{float64(kExpected), true, false, ""}, equalsTestCase{complex64(kExpected), true, false, ""}, equalsTestCase{complex128(kExpected), true, false, ""}, // Non-equal values of numeric types. equalsTestCase{int8(17), false, false, ""}, equalsTestCase{int16(kExpected + 1), false, false, ""}, equalsTestCase{int32(kExpected + 1), false, false, ""}, equalsTestCase{int64(kExpected + 1), false, false, ""}, equalsTestCase{uint8(17), false, false, ""}, equalsTestCase{uint16(kExpected + 1), false, false, ""}, equalsTestCase{uint32(kExpected + 1), false, false, ""}, equalsTestCase{uint64(kExpected + 1), false, false, ""}, equalsTestCase{float64(kExpected + 1), false, false, ""}, equalsTestCase{complex128(kExpected + 2i), false, false, ""}, equalsTestCase{complex128(kExpected + 1), false, false, ""}, } t.checkTestCases(matcher, cases) } //////////////////////////////////////////////////////////////////////// // uint32 //////////////////////////////////////////////////////////////////////// func (t *EqualsTest) SmallUint32() { const kExpected = 17 matcher := Equals(uint32(kExpected)) ExpectEq("17", matcher.Description()) cases := []equalsTestCase{ // Various types of the expected value. equalsTestCase{17, true, false, ""}, equalsTestCase{17.0, true, false, ""}, equalsTestCase{17 + 0i, true, false, ""}, equalsTestCase{int(kExpected), true, false, ""}, equalsTestCase{int8(kExpected), true, false, ""}, equalsTestCase{int16(kExpected), true, false, ""}, equalsTestCase{int32(kExpected), true, false, ""}, equalsTestCase{int64(kExpected), true, false, ""}, equalsTestCase{uint(kExpected), true, false, ""}, equalsTestCase{uint8(kExpected), true, false, ""}, equalsTestCase{uint16(kExpected), true, false, ""}, equalsTestCase{uint32(kExpected), true, false, ""}, equalsTestCase{uint64(kExpected), true, false, ""}, equalsTestCase{uintptr(kExpected), true, false, ""}, equalsTestCase{float32(kExpected), true, false, ""}, equalsTestCase{float64(kExpected), true, false, ""}, equalsTestCase{complex64(kExpected), true, false, ""}, equalsTestCase{complex128(kExpected), true, false, ""}, // Non-equal values of numeric types. equalsTestCase{kExpected + 1, false, false, ""}, equalsTestCase{int(kExpected + 1), false, false, ""}, equalsTestCase{int8(kExpected + 1), false, false, ""}, equalsTestCase{int16(kExpected + 1), false, false, ""}, equalsTestCase{int32(kExpected + 1), false, false, ""}, equalsTestCase{int64(kExpected + 1), false, false, ""}, equalsTestCase{uint(kExpected + 1), false, false, ""}, equalsTestCase{uint8(kExpected + 1), false, false, ""}, equalsTestCase{uint16(kExpected + 1), false, false, ""}, equalsTestCase{uint32(kExpected + 1), false, false, ""}, equalsTestCase{uint64(kExpected + 1), false, false, ""}, equalsTestCase{uintptr(kExpected + 1), false, false, ""}, equalsTestCase{float32(kExpected + 1), false, false, ""}, equalsTestCase{float64(kExpected + 1), false, false, ""}, equalsTestCase{complex64(kExpected + 2i), false, false, ""}, equalsTestCase{complex64(kExpected + 1), false, false, ""}, equalsTestCase{complex128(kExpected + 2i), false, false, ""}, equalsTestCase{complex128(kExpected + 1), false, false, ""}, // Non-numeric types. equalsTestCase{true, false, true, "which is not numeric"}, equalsTestCase{[...]int{}, false, true, "which is not numeric"}, equalsTestCase{make(chan int), false, true, "which is not numeric"}, equalsTestCase{func() {}, false, true, "which is not numeric"}, equalsTestCase{map[int]int{}, false, true, "which is not numeric"}, equalsTestCase{&someInt, false, true, "which is not numeric"}, equalsTestCase{[]int{}, false, true, "which is not numeric"}, equalsTestCase{"taco", false, true, "which is not numeric"}, equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) LargeUint32() { const kExpected = (1 << 16) + 17 matcher := Equals(uint32(kExpected)) ExpectEq("65553", matcher.Description()) cases := []equalsTestCase{ // Various types of the expected value. equalsTestCase{65553, true, false, ""}, equalsTestCase{65553.0, true, false, ""}, equalsTestCase{65553 + 0i, true, false, ""}, equalsTestCase{int32(kExpected), true, false, ""}, equalsTestCase{int64(kExpected), true, false, ""}, equalsTestCase{uint32(kExpected), true, false, ""}, equalsTestCase{uint64(kExpected), true, false, ""}, equalsTestCase{float32(kExpected), true, false, ""}, equalsTestCase{float64(kExpected), true, false, ""}, equalsTestCase{complex64(kExpected), true, false, ""}, equalsTestCase{complex128(kExpected), true, false, ""}, // Non-equal values of numeric types. equalsTestCase{int16(17), false, false, ""}, equalsTestCase{int32(kExpected + 1), false, false, ""}, equalsTestCase{int64(kExpected + 1), false, false, ""}, equalsTestCase{uint16(17), false, false, ""}, equalsTestCase{uint32(kExpected + 1), false, false, ""}, equalsTestCase{uint64(kExpected + 1), false, false, ""}, equalsTestCase{float64(kExpected + 1), false, false, ""}, equalsTestCase{complex128(kExpected + 2i), false, false, ""}, equalsTestCase{complex128(kExpected + 1), false, false, ""}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) Uint32NotExactlyRepresentableBySinglePrecision() { // Single-precision floats don't have enough bits to represent the integers // near this one distinctly, so [2^25-1, 2^25+2] all receive the same value // and should be treated as equivalent when floats are in the mix. const kTwoTo25 = 1 << 25 matcher := Equals(uint32(kTwoTo25 + 1)) ExpectEq("33554433", matcher.Description()) cases := []equalsTestCase{ // Integers. equalsTestCase{int64(kTwoTo25 + 0), false, false, ""}, equalsTestCase{int64(kTwoTo25 + 1), true, false, ""}, equalsTestCase{int64(kTwoTo25 + 2), false, false, ""}, equalsTestCase{uint64(kTwoTo25 + 0), false, false, ""}, equalsTestCase{uint64(kTwoTo25 + 1), true, false, ""}, equalsTestCase{uint64(kTwoTo25 + 2), false, false, ""}, // Single-precision floating point. equalsTestCase{float32(kTwoTo25 - 2), false, false, ""}, equalsTestCase{float32(kTwoTo25 - 1), true, false, ""}, equalsTestCase{float32(kTwoTo25 + 0), true, false, ""}, equalsTestCase{float32(kTwoTo25 + 1), true, false, ""}, equalsTestCase{float32(kTwoTo25 + 2), true, false, ""}, equalsTestCase{float32(kTwoTo25 + 3), false, false, ""}, equalsTestCase{complex64(kTwoTo25 - 2), false, false, ""}, equalsTestCase{complex64(kTwoTo25 - 1), true, false, ""}, equalsTestCase{complex64(kTwoTo25 + 0), true, false, ""}, equalsTestCase{complex64(kTwoTo25 + 1), true, false, ""}, equalsTestCase{complex64(kTwoTo25 + 2), true, false, ""}, equalsTestCase{complex64(kTwoTo25 + 3), false, false, ""}, // Double-precision floating point. equalsTestCase{float64(kTwoTo25 + 0), false, false, ""}, equalsTestCase{float64(kTwoTo25 + 1), true, false, ""}, equalsTestCase{float64(kTwoTo25 + 2), false, false, ""}, equalsTestCase{complex128(kTwoTo25 + 0), false, false, ""}, equalsTestCase{complex128(kTwoTo25 + 1), true, false, ""}, equalsTestCase{complex128(kTwoTo25 + 2), false, false, ""}, } t.checkTestCases(matcher, cases) } //////////////////////////////////////////////////////////////////////// // uint64 //////////////////////////////////////////////////////////////////////// func (t *EqualsTest) SmallUint64() { const kExpected = 17 matcher := Equals(uint64(kExpected)) ExpectEq("17", matcher.Description()) cases := []equalsTestCase{ // Various types of the expected value. equalsTestCase{17, true, false, ""}, equalsTestCase{17.0, true, false, ""}, equalsTestCase{17 + 0i, true, false, ""}, equalsTestCase{int(kExpected), true, false, ""}, equalsTestCase{int8(kExpected), true, false, ""}, equalsTestCase{int16(kExpected), true, false, ""}, equalsTestCase{int32(kExpected), true, false, ""}, equalsTestCase{int64(kExpected), true, false, ""}, equalsTestCase{uint(kExpected), true, false, ""}, equalsTestCase{uint8(kExpected), true, false, ""}, equalsTestCase{uint16(kExpected), true, false, ""}, equalsTestCase{uint32(kExpected), true, false, ""}, equalsTestCase{uint64(kExpected), true, false, ""}, equalsTestCase{uintptr(kExpected), true, false, ""}, equalsTestCase{float32(kExpected), true, false, ""}, equalsTestCase{float64(kExpected), true, false, ""}, equalsTestCase{complex64(kExpected), true, false, ""}, equalsTestCase{complex128(kExpected), true, false, ""}, // Non-equal values of numeric types. equalsTestCase{kExpected + 1, false, false, ""}, equalsTestCase{int(kExpected + 1), false, false, ""}, equalsTestCase{int8(kExpected + 1), false, false, ""}, equalsTestCase{int16(kExpected + 1), false, false, ""}, equalsTestCase{int32(kExpected + 1), false, false, ""}, equalsTestCase{int64(kExpected + 1), false, false, ""}, equalsTestCase{uint(kExpected + 1), false, false, ""}, equalsTestCase{uint8(kExpected + 1), false, false, ""}, equalsTestCase{uint16(kExpected + 1), false, false, ""}, equalsTestCase{uint32(kExpected + 1), false, false, ""}, equalsTestCase{uint64(kExpected + 1), false, false, ""}, equalsTestCase{uintptr(kExpected + 1), false, false, ""}, equalsTestCase{float32(kExpected + 1), false, false, ""}, equalsTestCase{float64(kExpected + 1), false, false, ""}, equalsTestCase{complex64(kExpected + 2i), false, false, ""}, equalsTestCase{complex64(kExpected + 1), false, false, ""}, equalsTestCase{complex128(kExpected + 2i), false, false, ""}, equalsTestCase{complex128(kExpected + 1), false, false, ""}, // Non-numeric types. equalsTestCase{true, false, true, "which is not numeric"}, equalsTestCase{[...]int{}, false, true, "which is not numeric"}, equalsTestCase{make(chan int), false, true, "which is not numeric"}, equalsTestCase{func() {}, false, true, "which is not numeric"}, equalsTestCase{map[int]int{}, false, true, "which is not numeric"}, equalsTestCase{&someInt, false, true, "which is not numeric"}, equalsTestCase{[]int{}, false, true, "which is not numeric"}, equalsTestCase{"taco", false, true, "which is not numeric"}, equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) LargeUint64() { const kExpected = (1 << 32) + 17 matcher := Equals(uint64(kExpected)) ExpectEq("4294967313", matcher.Description()) cases := []equalsTestCase{ // Various types of the expected value. equalsTestCase{4294967313.0, true, false, ""}, equalsTestCase{4294967313 + 0i, true, false, ""}, equalsTestCase{int64(kExpected), true, false, ""}, equalsTestCase{uint64(kExpected), true, false, ""}, equalsTestCase{float32(kExpected), true, false, ""}, equalsTestCase{float64(kExpected), true, false, ""}, equalsTestCase{complex64(kExpected), true, false, ""}, equalsTestCase{complex128(kExpected), true, false, ""}, // Non-equal values of numeric types. equalsTestCase{int(17), false, false, ""}, equalsTestCase{int32(17), false, false, ""}, equalsTestCase{int64(kExpected + 1), false, false, ""}, equalsTestCase{uint(17), false, false, ""}, equalsTestCase{uint32(17), false, false, ""}, equalsTestCase{uint64(kExpected + 1), false, false, ""}, equalsTestCase{float64(kExpected + 1), false, false, ""}, equalsTestCase{complex128(kExpected + 2i), false, false, ""}, equalsTestCase{complex128(kExpected + 1), false, false, ""}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) Uint64NotExactlyRepresentableBySinglePrecision() { // Single-precision floats don't have enough bits to represent the integers // near this one distinctly, so [2^25-1, 2^25+2] all receive the same value // and should be treated as equivalent when floats are in the mix. const kTwoTo25 = 1 << 25 matcher := Equals(uint64(kTwoTo25 + 1)) ExpectEq("33554433", matcher.Description()) cases := []equalsTestCase{ // Integers. equalsTestCase{int64(kTwoTo25 + 0), false, false, ""}, equalsTestCase{int64(kTwoTo25 + 1), true, false, ""}, equalsTestCase{int64(kTwoTo25 + 2), false, false, ""}, equalsTestCase{uint64(kTwoTo25 + 0), false, false, ""}, equalsTestCase{uint64(kTwoTo25 + 1), true, false, ""}, equalsTestCase{uint64(kTwoTo25 + 2), false, false, ""}, // Single-precision floating point. equalsTestCase{float32(kTwoTo25 - 2), false, false, ""}, equalsTestCase{float32(kTwoTo25 - 1), true, false, ""}, equalsTestCase{float32(kTwoTo25 + 0), true, false, ""}, equalsTestCase{float32(kTwoTo25 + 1), true, false, ""}, equalsTestCase{float32(kTwoTo25 + 2), true, false, ""}, equalsTestCase{float32(kTwoTo25 + 3), false, false, ""}, equalsTestCase{complex64(kTwoTo25 - 2), false, false, ""}, equalsTestCase{complex64(kTwoTo25 - 1), true, false, ""}, equalsTestCase{complex64(kTwoTo25 + 0), true, false, ""}, equalsTestCase{complex64(kTwoTo25 + 1), true, false, ""}, equalsTestCase{complex64(kTwoTo25 + 2), true, false, ""}, equalsTestCase{complex64(kTwoTo25 + 3), false, false, ""}, // Double-precision floating point. equalsTestCase{float64(kTwoTo25 + 0), false, false, ""}, equalsTestCase{float64(kTwoTo25 + 1), true, false, ""}, equalsTestCase{float64(kTwoTo25 + 2), false, false, ""}, equalsTestCase{complex128(kTwoTo25 + 0), false, false, ""}, equalsTestCase{complex128(kTwoTo25 + 1), true, false, ""}, equalsTestCase{complex128(kTwoTo25 + 2), false, false, ""}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) Uint64NotExactlyRepresentableByDoublePrecision() { // Double-precision floats don't have enough bits to represent the integers // near this one distinctly, so [2^54-1, 2^54+2] all receive the same value // and should be treated as equivalent when floats are in the mix. const kTwoTo54 = 1 << 54 matcher := Equals(uint64(kTwoTo54 + 1)) ExpectEq("18014398509481985", matcher.Description()) cases := []equalsTestCase{ // Integers. equalsTestCase{int64(kTwoTo54 + 0), false, false, ""}, equalsTestCase{int64(kTwoTo54 + 1), true, false, ""}, equalsTestCase{int64(kTwoTo54 + 2), false, false, ""}, equalsTestCase{uint64(kTwoTo54 + 0), false, false, ""}, equalsTestCase{uint64(kTwoTo54 + 1), true, false, ""}, equalsTestCase{uint64(kTwoTo54 + 2), false, false, ""}, // Double-precision floating point. equalsTestCase{float64(kTwoTo54 - 2), false, false, ""}, equalsTestCase{float64(kTwoTo54 - 1), true, false, ""}, equalsTestCase{float64(kTwoTo54 + 0), true, false, ""}, equalsTestCase{float64(kTwoTo54 + 1), true, false, ""}, equalsTestCase{float64(kTwoTo54 + 2), true, false, ""}, equalsTestCase{float64(kTwoTo54 + 3), false, false, ""}, equalsTestCase{complex128(kTwoTo54 - 2), false, false, ""}, equalsTestCase{complex128(kTwoTo54 - 1), true, false, ""}, equalsTestCase{complex128(kTwoTo54 + 0), true, false, ""}, equalsTestCase{complex128(kTwoTo54 + 1), true, false, ""}, equalsTestCase{complex128(kTwoTo54 + 2), true, false, ""}, equalsTestCase{complex128(kTwoTo54 + 3), false, false, ""}, } t.checkTestCases(matcher, cases) } //////////////////////////////////////////////////////////////////////// // uintptr //////////////////////////////////////////////////////////////////////// func (t *EqualsTest) SmallUintptr() { const kExpected = 17 matcher := Equals(uintptr(kExpected)) ExpectEq("17", matcher.Description()) cases := []equalsTestCase{ // Various types of the expected value. equalsTestCase{17, true, false, ""}, equalsTestCase{17.0, true, false, ""}, equalsTestCase{17 + 0i, true, false, ""}, equalsTestCase{int(kExpected), true, false, ""}, equalsTestCase{int8(kExpected), true, false, ""}, equalsTestCase{int16(kExpected), true, false, ""}, equalsTestCase{int32(kExpected), true, false, ""}, equalsTestCase{int64(kExpected), true, false, ""}, equalsTestCase{uint(kExpected), true, false, ""}, equalsTestCase{uint8(kExpected), true, false, ""}, equalsTestCase{uint16(kExpected), true, false, ""}, equalsTestCase{uint32(kExpected), true, false, ""}, equalsTestCase{uint64(kExpected), true, false, ""}, equalsTestCase{uintptr(kExpected), true, false, ""}, equalsTestCase{float32(kExpected), true, false, ""}, equalsTestCase{float64(kExpected), true, false, ""}, equalsTestCase{complex64(kExpected), true, false, ""}, equalsTestCase{complex128(kExpected), true, false, ""}, // Non-equal values of numeric types. equalsTestCase{kExpected + 1, false, false, ""}, equalsTestCase{int(kExpected + 1), false, false, ""}, equalsTestCase{int8(kExpected + 1), false, false, ""}, equalsTestCase{int16(kExpected + 1), false, false, ""}, equalsTestCase{int32(kExpected + 1), false, false, ""}, equalsTestCase{int64(kExpected + 1), false, false, ""}, equalsTestCase{uint(kExpected + 1), false, false, ""}, equalsTestCase{uint8(kExpected + 1), false, false, ""}, equalsTestCase{uint16(kExpected + 1), false, false, ""}, equalsTestCase{uint32(kExpected + 1), false, false, ""}, equalsTestCase{uint64(kExpected + 1), false, false, ""}, equalsTestCase{uintptr(kExpected + 1), false, false, ""}, equalsTestCase{float32(kExpected + 1), false, false, ""}, equalsTestCase{float64(kExpected + 1), false, false, ""}, equalsTestCase{complex64(kExpected + 2i), false, false, ""}, equalsTestCase{complex64(kExpected + 1), false, false, ""}, equalsTestCase{complex128(kExpected + 2i), false, false, ""}, equalsTestCase{complex128(kExpected + 1), false, false, ""}, // Non-numeric types. equalsTestCase{true, false, true, "which is not numeric"}, equalsTestCase{[...]int{}, false, true, "which is not numeric"}, equalsTestCase{make(chan int), false, true, "which is not numeric"}, equalsTestCase{func() {}, false, true, "which is not numeric"}, equalsTestCase{map[int]int{}, false, true, "which is not numeric"}, equalsTestCase{&someInt, false, true, "which is not numeric"}, equalsTestCase{[]int{}, false, true, "which is not numeric"}, equalsTestCase{"taco", false, true, "which is not numeric"}, equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) LargeUintptr() { const kExpected = (1 << 32) + 17 matcher := Equals(uintptr(kExpected)) ExpectEq("4294967313", matcher.Description()) cases := []equalsTestCase{ // Various types of the expected value. equalsTestCase{4294967313.0, true, false, ""}, equalsTestCase{4294967313 + 0i, true, false, ""}, equalsTestCase{int64(kExpected), true, false, ""}, equalsTestCase{uint64(kExpected), true, false, ""}, equalsTestCase{uintptr(kExpected), true, false, ""}, equalsTestCase{float32(kExpected), true, false, ""}, equalsTestCase{float64(kExpected), true, false, ""}, equalsTestCase{complex64(kExpected), true, false, ""}, equalsTestCase{complex128(kExpected), true, false, ""}, // Non-equal values of numeric types. equalsTestCase{int(17), false, false, ""}, equalsTestCase{int32(17), false, false, ""}, equalsTestCase{int64(kExpected + 1), false, false, ""}, equalsTestCase{uint(17), false, false, ""}, equalsTestCase{uint32(17), false, false, ""}, equalsTestCase{uint64(kExpected + 1), false, false, ""}, equalsTestCase{uintptr(kExpected + 1), false, false, ""}, equalsTestCase{float64(kExpected + 1), false, false, ""}, equalsTestCase{complex128(kExpected + 2i), false, false, ""}, equalsTestCase{complex128(kExpected + 1), false, false, ""}, } t.checkTestCases(matcher, cases) } //////////////////////////////////////////////////////////////////////// // float32 //////////////////////////////////////////////////////////////////////// func (t *EqualsTest) NegativeIntegralFloat32() { matcher := Equals(float32(-32769)) ExpectEq("-32769", matcher.Description()) cases := []equalsTestCase{ // Various types of -32769. equalsTestCase{-32769.0, true, false, ""}, equalsTestCase{-32769 + 0i, true, false, ""}, equalsTestCase{int32(-32769), true, false, ""}, equalsTestCase{int64(-32769), true, false, ""}, equalsTestCase{float32(-32769), true, false, ""}, equalsTestCase{float64(-32769), true, false, ""}, equalsTestCase{complex64(-32769), true, false, ""}, equalsTestCase{complex128(-32769), true, false, ""}, equalsTestCase{interface{}(float32(-32769)), true, false, ""}, equalsTestCase{interface{}(int64(-32769)), true, false, ""}, // Values that would be -32769 in two's complement. equalsTestCase{uint64((1 << 64) - 32769), false, false, ""}, equalsTestCase{uintptr((1 << 64) - 32769), false, false, ""}, // Non-equal values of numeric type. equalsTestCase{int64(-32770), false, false, ""}, equalsTestCase{float32(-32769.1), false, false, ""}, equalsTestCase{float32(-32768.9), false, false, ""}, equalsTestCase{float64(-32769.1), false, false, ""}, equalsTestCase{float64(-32768.9), false, false, ""}, equalsTestCase{complex128(-32768), false, false, ""}, equalsTestCase{complex128(-32769 + 2i), false, false, ""}, // Non-numeric types. equalsTestCase{true, false, true, "which is not numeric"}, equalsTestCase{[...]int{}, false, true, "which is not numeric"}, equalsTestCase{make(chan int), false, true, "which is not numeric"}, equalsTestCase{func() {}, false, true, "which is not numeric"}, equalsTestCase{map[int]int{}, false, true, "which is not numeric"}, equalsTestCase{&someInt, false, true, "which is not numeric"}, equalsTestCase{[]int{}, false, true, "which is not numeric"}, equalsTestCase{"taco", false, true, "which is not numeric"}, equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) NegativeNonIntegralFloat32() { matcher := Equals(float32(-32769.1)) ExpectEq("-32769.1", matcher.Description()) cases := []equalsTestCase{ // Various types of -32769.1. equalsTestCase{-32769.1, true, false, ""}, equalsTestCase{-32769.1 + 0i, true, false, ""}, equalsTestCase{float32(-32769.1), true, false, ""}, equalsTestCase{float64(-32769.1), true, false, ""}, equalsTestCase{complex64(-32769.1), true, false, ""}, equalsTestCase{complex128(-32769.1), true, false, ""}, // Non-equal values of numeric type. equalsTestCase{int32(-32769), false, false, ""}, equalsTestCase{int32(-32770), false, false, ""}, equalsTestCase{int64(-32769), false, false, ""}, equalsTestCase{int64(-32770), false, false, ""}, equalsTestCase{float32(-32769.2), false, false, ""}, equalsTestCase{float32(-32769.0), false, false, ""}, equalsTestCase{float64(-32769.2), false, false, ""}, equalsTestCase{complex128(-32769.1 + 2i), false, false, ""}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) LargeNegativeFloat32() { const kExpected = -1 * (1 << 65) matcher := Equals(float32(kExpected)) ExpectEq("-3.689349e+19", matcher.Description()) floatExpected := float32(kExpected) castedInt := int64(floatExpected) cases := []equalsTestCase{ // Equal values of numeric type. equalsTestCase{kExpected + 0i, true, false, ""}, equalsTestCase{float32(kExpected), true, false, ""}, equalsTestCase{float64(kExpected), true, false, ""}, equalsTestCase{complex64(kExpected), true, false, ""}, equalsTestCase{complex128(kExpected), true, false, ""}, // Non-equal values of numeric type. equalsTestCase{castedInt, false, false, ""}, equalsTestCase{int64(0), false, false, ""}, equalsTestCase{int64(math.MinInt64), false, false, ""}, equalsTestCase{int64(math.MaxInt64), false, false, ""}, equalsTestCase{float32(kExpected / 2), false, false, ""}, equalsTestCase{float64(kExpected / 2), false, false, ""}, equalsTestCase{complex128(kExpected + 2i), false, false, ""}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) ZeroFloat32() { matcher := Equals(float32(0)) ExpectEq("0", matcher.Description()) cases := []equalsTestCase{ // Various types of zero. equalsTestCase{0.0, true, false, ""}, equalsTestCase{0 + 0i, true, false, ""}, equalsTestCase{int(0), true, false, ""}, equalsTestCase{int8(0), true, false, ""}, equalsTestCase{int16(0), true, false, ""}, equalsTestCase{int32(0), true, false, ""}, equalsTestCase{int64(0), true, false, ""}, equalsTestCase{uint(0), true, false, ""}, equalsTestCase{uint8(0), true, false, ""}, equalsTestCase{uint16(0), true, false, ""}, equalsTestCase{uint32(0), true, false, ""}, equalsTestCase{uint64(0), true, false, ""}, equalsTestCase{uintptr(0), true, false, ""}, equalsTestCase{float32(0), true, false, ""}, equalsTestCase{float64(0), true, false, ""}, equalsTestCase{complex64(0), true, false, ""}, equalsTestCase{complex128(0), true, false, ""}, equalsTestCase{interface{}(float32(0)), true, false, ""}, // Non-equal values of numeric type. equalsTestCase{int64(1), false, false, ""}, equalsTestCase{int64(-1), false, false, ""}, equalsTestCase{float32(1), false, false, ""}, equalsTestCase{float32(-1), false, false, ""}, equalsTestCase{complex128(0 + 2i), false, false, ""}, // Non-numeric types. equalsTestCase{true, false, true, "which is not numeric"}, equalsTestCase{[...]int{}, false, true, "which is not numeric"}, equalsTestCase{make(chan int), false, true, "which is not numeric"}, equalsTestCase{func() {}, false, true, "which is not numeric"}, equalsTestCase{map[int]int{}, false, true, "which is not numeric"}, equalsTestCase{&someInt, false, true, "which is not numeric"}, equalsTestCase{[]int{}, false, true, "which is not numeric"}, equalsTestCase{"taco", false, true, "which is not numeric"}, equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) PositiveIntegralFloat32() { matcher := Equals(float32(32769)) ExpectEq("32769", matcher.Description()) cases := []equalsTestCase{ // Various types of 32769. equalsTestCase{32769.0, true, false, ""}, equalsTestCase{32769 + 0i, true, false, ""}, equalsTestCase{int(32769), true, false, ""}, equalsTestCase{int32(32769), true, false, ""}, equalsTestCase{int64(32769), true, false, ""}, equalsTestCase{uint(32769), true, false, ""}, equalsTestCase{uint32(32769), true, false, ""}, equalsTestCase{uint64(32769), true, false, ""}, equalsTestCase{uintptr(32769), true, false, ""}, equalsTestCase{float32(32769), true, false, ""}, equalsTestCase{float64(32769), true, false, ""}, equalsTestCase{complex64(32769), true, false, ""}, equalsTestCase{complex128(32769), true, false, ""}, equalsTestCase{interface{}(float32(32769)), true, false, ""}, // Non-equal values of numeric type. equalsTestCase{int64(32770), false, false, ""}, equalsTestCase{uint64(32770), false, false, ""}, equalsTestCase{float32(32769.1), false, false, ""}, equalsTestCase{float32(32768.9), false, false, ""}, equalsTestCase{float64(32769.1), false, false, ""}, equalsTestCase{float64(32768.9), false, false, ""}, equalsTestCase{complex128(32768), false, false, ""}, equalsTestCase{complex128(32769 + 2i), false, false, ""}, // Non-numeric types. equalsTestCase{true, false, true, "which is not numeric"}, equalsTestCase{[...]int{}, false, true, "which is not numeric"}, equalsTestCase{make(chan int), false, true, "which is not numeric"}, equalsTestCase{func() {}, false, true, "which is not numeric"}, equalsTestCase{map[int]int{}, false, true, "which is not numeric"}, equalsTestCase{&someInt, false, true, "which is not numeric"}, equalsTestCase{[]int{}, false, true, "which is not numeric"}, equalsTestCase{"taco", false, true, "which is not numeric"}, equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) PositiveNonIntegralFloat32() { matcher := Equals(float32(32769.1)) ExpectEq("32769.1", matcher.Description()) cases := []equalsTestCase{ // Various types of 32769.1. equalsTestCase{32769.1, true, false, ""}, equalsTestCase{32769.1 + 0i, true, false, ""}, equalsTestCase{float32(32769.1), true, false, ""}, equalsTestCase{float64(32769.1), true, false, ""}, equalsTestCase{complex64(32769.1), true, false, ""}, equalsTestCase{complex128(32769.1), true, false, ""}, // Non-equal values of numeric type. equalsTestCase{int32(32769), false, false, ""}, equalsTestCase{int32(32770), false, false, ""}, equalsTestCase{uint64(32769), false, false, ""}, equalsTestCase{uint64(32770), false, false, ""}, equalsTestCase{float32(32769.2), false, false, ""}, equalsTestCase{float32(32769.0), false, false, ""}, equalsTestCase{float64(32769.2), false, false, ""}, equalsTestCase{complex128(32769.1 + 2i), false, false, ""}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) LargePositiveFloat32() { const kExpected = 1 << 65 matcher := Equals(float32(kExpected)) ExpectEq("3.689349e+19", matcher.Description()) floatExpected := float32(kExpected) castedInt := uint64(floatExpected) cases := []equalsTestCase{ // Equal values of numeric type. equalsTestCase{kExpected + 0i, true, false, ""}, equalsTestCase{float32(kExpected), true, false, ""}, equalsTestCase{float64(kExpected), true, false, ""}, equalsTestCase{complex64(kExpected), true, false, ""}, equalsTestCase{complex128(kExpected), true, false, ""}, // Non-equal values of numeric type. equalsTestCase{castedInt, false, false, ""}, equalsTestCase{int64(0), false, false, ""}, equalsTestCase{int64(math.MinInt64), false, false, ""}, equalsTestCase{int64(math.MaxInt64), false, false, ""}, equalsTestCase{uint64(0), false, false, ""}, equalsTestCase{uint64(math.MaxUint64), false, false, ""}, equalsTestCase{float32(kExpected / 2), false, false, ""}, equalsTestCase{float64(kExpected / 2), false, false, ""}, equalsTestCase{complex128(kExpected + 2i), false, false, ""}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) Float32AboveExactIntegerRange() { // Single-precision floats don't have enough bits to represent the integers // near this one distinctly, so [2^25-1, 2^25+2] all receive the same value // and should be treated as equivalent when floats are in the mix. const kTwoTo25 = 1 << 25 matcher := Equals(float32(kTwoTo25 + 1)) ExpectEq("3.3554432e+07", matcher.Description()) cases := []equalsTestCase{ // Integers. equalsTestCase{int64(kTwoTo25 - 2), false, false, ""}, equalsTestCase{int64(kTwoTo25 - 1), true, false, ""}, equalsTestCase{int64(kTwoTo25 + 0), true, false, ""}, equalsTestCase{int64(kTwoTo25 + 1), true, false, ""}, equalsTestCase{int64(kTwoTo25 + 2), true, false, ""}, equalsTestCase{int64(kTwoTo25 + 3), false, false, ""}, equalsTestCase{uint64(kTwoTo25 - 2), false, false, ""}, equalsTestCase{uint64(kTwoTo25 - 1), true, false, ""}, equalsTestCase{uint64(kTwoTo25 + 0), true, false, ""}, equalsTestCase{uint64(kTwoTo25 + 1), true, false, ""}, equalsTestCase{uint64(kTwoTo25 + 2), true, false, ""}, equalsTestCase{uint64(kTwoTo25 + 3), false, false, ""}, // Single-precision floating point. equalsTestCase{float32(kTwoTo25 - 2), false, false, ""}, equalsTestCase{float32(kTwoTo25 - 1), true, false, ""}, equalsTestCase{float32(kTwoTo25 + 0), true, false, ""}, equalsTestCase{float32(kTwoTo25 + 1), true, false, ""}, equalsTestCase{float32(kTwoTo25 + 2), true, false, ""}, equalsTestCase{float32(kTwoTo25 + 3), false, false, ""}, equalsTestCase{complex64(kTwoTo25 - 2), false, false, ""}, equalsTestCase{complex64(kTwoTo25 - 1), true, false, ""}, equalsTestCase{complex64(kTwoTo25 + 0), true, false, ""}, equalsTestCase{complex64(kTwoTo25 + 1), true, false, ""}, equalsTestCase{complex64(kTwoTo25 + 2), true, false, ""}, equalsTestCase{complex64(kTwoTo25 + 3), false, false, ""}, // Double-precision floating point. equalsTestCase{float64(kTwoTo25 - 2), false, false, ""}, equalsTestCase{float64(kTwoTo25 - 1), true, false, ""}, equalsTestCase{float64(kTwoTo25 + 0), true, false, ""}, equalsTestCase{float64(kTwoTo25 + 1), true, false, ""}, equalsTestCase{float64(kTwoTo25 + 2), true, false, ""}, equalsTestCase{float64(kTwoTo25 + 3), false, false, ""}, equalsTestCase{complex128(kTwoTo25 - 2), false, false, ""}, equalsTestCase{complex128(kTwoTo25 - 1), true, false, ""}, equalsTestCase{complex128(kTwoTo25 + 0), true, false, ""}, equalsTestCase{complex128(kTwoTo25 + 1), true, false, ""}, equalsTestCase{complex128(kTwoTo25 + 2), true, false, ""}, equalsTestCase{complex128(kTwoTo25 + 3), false, false, ""}, } t.checkTestCases(matcher, cases) } //////////////////////////////////////////////////////////////////////// // float64 //////////////////////////////////////////////////////////////////////// func (t *EqualsTest) NegativeIntegralFloat64() { const kExpected = -(1 << 50) matcher := Equals(float64(kExpected)) ExpectEq("-1.125899906842624e+15", matcher.Description()) cases := []equalsTestCase{ // Various types of the expected value. equalsTestCase{-1125899906842624.0, true, false, ""}, equalsTestCase{-1125899906842624.0 + 0i, true, false, ""}, equalsTestCase{int64(kExpected), true, false, ""}, equalsTestCase{float32(kExpected), true, false, ""}, equalsTestCase{float64(kExpected), true, false, ""}, equalsTestCase{complex64(kExpected), true, false, ""}, equalsTestCase{complex128(kExpected), true, false, ""}, equalsTestCase{interface{}(float64(kExpected)), true, false, ""}, // Values that would be kExpected in two's complement. equalsTestCase{uint64((1 << 64) + kExpected), false, false, ""}, // Non-equal values of numeric type. equalsTestCase{int64(kExpected + 1), false, false, ""}, equalsTestCase{float32(kExpected - (1 << 30)), false, false, ""}, equalsTestCase{float32(kExpected + (1 << 30)), false, false, ""}, equalsTestCase{float64(kExpected - 0.5), false, false, ""}, equalsTestCase{float64(kExpected + 0.5), false, false, ""}, equalsTestCase{complex128(kExpected - 1), false, false, ""}, equalsTestCase{complex128(kExpected + 2i), false, false, ""}, // Non-numeric types. equalsTestCase{true, false, true, "which is not numeric"}, equalsTestCase{[...]int{}, false, true, "which is not numeric"}, equalsTestCase{make(chan int), false, true, "which is not numeric"}, equalsTestCase{func() {}, false, true, "which is not numeric"}, equalsTestCase{map[int]int{}, false, true, "which is not numeric"}, equalsTestCase{&someInt, false, true, "which is not numeric"}, equalsTestCase{[]int{}, false, true, "which is not numeric"}, equalsTestCase{"taco", false, true, "which is not numeric"}, equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) NegativeNonIntegralFloat64() { const kTwoTo50 = 1 << 50 const kExpected = -kTwoTo50 - 0.25 matcher := Equals(float64(kExpected)) ExpectEq("-1.1258999068426242e+15", matcher.Description()) cases := []equalsTestCase{ // Various types of the expected value. equalsTestCase{kExpected, true, false, ""}, equalsTestCase{kExpected + 0i, true, false, ""}, equalsTestCase{float32(kExpected), true, false, ""}, equalsTestCase{float64(kExpected), true, false, ""}, equalsTestCase{complex64(kExpected), true, false, ""}, equalsTestCase{complex128(kExpected), true, false, ""}, // Non-equal values of numeric type. equalsTestCase{int64(-kTwoTo50), false, false, ""}, equalsTestCase{int64(-kTwoTo50 - 1), false, false, ""}, equalsTestCase{float32(kExpected - (1 << 30)), false, false, ""}, equalsTestCase{float64(kExpected - 0.25), false, false, ""}, equalsTestCase{float64(kExpected + 0.25), false, false, ""}, equalsTestCase{complex128(kExpected + 2i), false, false, ""}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) LargeNegativeFloat64() { const kExpected = -1 * (1 << 65) matcher := Equals(float64(kExpected)) ExpectEq("-3.6893488147419103e+19", matcher.Description()) floatExpected := float64(kExpected) castedInt := int64(floatExpected) cases := []equalsTestCase{ // Equal values of numeric type. equalsTestCase{kExpected + 0i, true, false, ""}, equalsTestCase{float32(kExpected), true, false, ""}, equalsTestCase{float64(kExpected), true, false, ""}, equalsTestCase{complex64(kExpected), true, false, ""}, equalsTestCase{complex128(kExpected), true, false, ""}, // Non-equal values of numeric type. equalsTestCase{castedInt, false, false, ""}, equalsTestCase{int64(0), false, false, ""}, equalsTestCase{int64(math.MinInt64), false, false, ""}, equalsTestCase{int64(math.MaxInt64), false, false, ""}, equalsTestCase{float32(kExpected / 2), false, false, ""}, equalsTestCase{float64(kExpected / 2), false, false, ""}, equalsTestCase{complex128(kExpected + 2i), false, false, ""}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) ZeroFloat64() { matcher := Equals(float64(0)) ExpectEq("0", matcher.Description()) cases := []equalsTestCase{ // Various types of zero. equalsTestCase{0.0, true, false, ""}, equalsTestCase{0 + 0i, true, false, ""}, equalsTestCase{int(0), true, false, ""}, equalsTestCase{int8(0), true, false, ""}, equalsTestCase{int16(0), true, false, ""}, equalsTestCase{int32(0), true, false, ""}, equalsTestCase{int64(0), true, false, ""}, equalsTestCase{uint(0), true, false, ""}, equalsTestCase{uint8(0), true, false, ""}, equalsTestCase{uint16(0), true, false, ""}, equalsTestCase{uint32(0), true, false, ""}, equalsTestCase{uint64(0), true, false, ""}, equalsTestCase{uintptr(0), true, false, ""}, equalsTestCase{float32(0), true, false, ""}, equalsTestCase{float64(0), true, false, ""}, equalsTestCase{complex64(0), true, false, ""}, equalsTestCase{complex128(0), true, false, ""}, equalsTestCase{interface{}(float32(0)), true, false, ""}, // Non-equal values of numeric type. equalsTestCase{int64(1), false, false, ""}, equalsTestCase{int64(-1), false, false, ""}, equalsTestCase{float32(1), false, false, ""}, equalsTestCase{float32(-1), false, false, ""}, equalsTestCase{complex128(0 + 2i), false, false, ""}, // Non-numeric types. equalsTestCase{true, false, true, "which is not numeric"}, equalsTestCase{[...]int{}, false, true, "which is not numeric"}, equalsTestCase{make(chan int), false, true, "which is not numeric"}, equalsTestCase{func() {}, false, true, "which is not numeric"}, equalsTestCase{map[int]int{}, false, true, "which is not numeric"}, equalsTestCase{&someInt, false, true, "which is not numeric"}, equalsTestCase{[]int{}, false, true, "which is not numeric"}, equalsTestCase{"taco", false, true, "which is not numeric"}, equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) PositiveIntegralFloat64() { const kExpected = 1 << 50 matcher := Equals(float64(kExpected)) ExpectEq("1.125899906842624e+15", matcher.Description()) cases := []equalsTestCase{ // Various types of 32769. equalsTestCase{1125899906842624.0, true, false, ""}, equalsTestCase{1125899906842624.0 + 0i, true, false, ""}, equalsTestCase{int64(kExpected), true, false, ""}, equalsTestCase{uint64(kExpected), true, false, ""}, equalsTestCase{uintptr(kExpected), true, false, ""}, equalsTestCase{float32(kExpected), true, false, ""}, equalsTestCase{float64(kExpected), true, false, ""}, equalsTestCase{complex64(kExpected), true, false, ""}, equalsTestCase{complex128(kExpected), true, false, ""}, equalsTestCase{interface{}(float64(kExpected)), true, false, ""}, // Non-equal values of numeric type. equalsTestCase{int64(kExpected + 1), false, false, ""}, equalsTestCase{uint64(kExpected + 1), false, false, ""}, equalsTestCase{uintptr(kExpected + 1), false, false, ""}, equalsTestCase{float32(kExpected - (1 << 30)), false, false, ""}, equalsTestCase{float32(kExpected + (1 << 30)), false, false, ""}, equalsTestCase{float64(kExpected - 0.5), false, false, ""}, equalsTestCase{float64(kExpected + 0.5), false, false, ""}, equalsTestCase{complex128(kExpected - 1), false, false, ""}, equalsTestCase{complex128(kExpected + 2i), false, false, ""}, // Non-numeric types. equalsTestCase{true, false, true, "which is not numeric"}, equalsTestCase{[...]int{}, false, true, "which is not numeric"}, equalsTestCase{make(chan int), false, true, "which is not numeric"}, equalsTestCase{func() {}, false, true, "which is not numeric"}, equalsTestCase{map[int]int{}, false, true, "which is not numeric"}, equalsTestCase{&someInt, false, true, "which is not numeric"}, equalsTestCase{[]int{}, false, true, "which is not numeric"}, equalsTestCase{"taco", false, true, "which is not numeric"}, equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) PositiveNonIntegralFloat64() { const kTwoTo50 = 1 << 50 const kExpected = kTwoTo50 + 0.25 matcher := Equals(float64(kExpected)) ExpectEq("1.1258999068426242e+15", matcher.Description()) cases := []equalsTestCase{ // Various types of the expected value. equalsTestCase{kExpected, true, false, ""}, equalsTestCase{kExpected + 0i, true, false, ""}, equalsTestCase{float32(kExpected), true, false, ""}, equalsTestCase{float64(kExpected), true, false, ""}, equalsTestCase{complex64(kExpected), true, false, ""}, equalsTestCase{complex128(kExpected), true, false, ""}, // Non-equal values of numeric type. equalsTestCase{int64(kTwoTo50), false, false, ""}, equalsTestCase{int64(kTwoTo50 - 1), false, false, ""}, equalsTestCase{float64(kExpected - 0.25), false, false, ""}, equalsTestCase{float64(kExpected + 0.25), false, false, ""}, equalsTestCase{complex128(kExpected + 2i), false, false, ""}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) LargePositiveFloat64() { const kExpected = 1 << 65 matcher := Equals(float64(kExpected)) ExpectEq("3.6893488147419103e+19", matcher.Description()) floatExpected := float64(kExpected) castedInt := uint64(floatExpected) cases := []equalsTestCase{ // Equal values of numeric type. equalsTestCase{kExpected + 0i, true, false, ""}, equalsTestCase{float32(kExpected), true, false, ""}, equalsTestCase{float64(kExpected), true, false, ""}, equalsTestCase{complex64(kExpected), true, false, ""}, equalsTestCase{complex128(kExpected), true, false, ""}, // Non-equal values of numeric type. equalsTestCase{castedInt, false, false, ""}, equalsTestCase{int64(0), false, false, ""}, equalsTestCase{int64(math.MinInt64), false, false, ""}, equalsTestCase{int64(math.MaxInt64), false, false, ""}, equalsTestCase{uint64(0), false, false, ""}, equalsTestCase{uint64(math.MaxUint64), false, false, ""}, equalsTestCase{float32(kExpected / 2), false, false, ""}, equalsTestCase{float64(kExpected / 2), false, false, ""}, equalsTestCase{complex128(kExpected + 2i), false, false, ""}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) Float64AboveExactIntegerRange() { // Double-precision floats don't have enough bits to represent the integers // near this one distinctly, so [2^54-1, 2^54+2] all receive the same value // and should be treated as equivalent when floats are in the mix. const kTwoTo54 = 1 << 54 matcher := Equals(float64(kTwoTo54 + 1)) ExpectEq("1.8014398509481984e+16", matcher.Description()) cases := []equalsTestCase{ // Integers. equalsTestCase{int64(kTwoTo54 - 2), false, false, ""}, equalsTestCase{int64(kTwoTo54 - 1), true, false, ""}, equalsTestCase{int64(kTwoTo54 + 0), true, false, ""}, equalsTestCase{int64(kTwoTo54 + 1), true, false, ""}, equalsTestCase{int64(kTwoTo54 + 2), true, false, ""}, equalsTestCase{int64(kTwoTo54 + 3), false, false, ""}, equalsTestCase{uint64(kTwoTo54 - 2), false, false, ""}, equalsTestCase{uint64(kTwoTo54 - 1), true, false, ""}, equalsTestCase{uint64(kTwoTo54 + 0), true, false, ""}, equalsTestCase{uint64(kTwoTo54 + 1), true, false, ""}, equalsTestCase{uint64(kTwoTo54 + 2), true, false, ""}, equalsTestCase{uint64(kTwoTo54 + 3), false, false, ""}, // Double-precision floating point. equalsTestCase{float64(kTwoTo54 - 2), false, false, ""}, equalsTestCase{float64(kTwoTo54 - 1), true, false, ""}, equalsTestCase{float64(kTwoTo54 + 0), true, false, ""}, equalsTestCase{float64(kTwoTo54 + 1), true, false, ""}, equalsTestCase{float64(kTwoTo54 + 2), true, false, ""}, equalsTestCase{float64(kTwoTo54 + 3), false, false, ""}, equalsTestCase{complex128(kTwoTo54 - 2), false, false, ""}, equalsTestCase{complex128(kTwoTo54 - 1), true, false, ""}, equalsTestCase{complex128(kTwoTo54 + 0), true, false, ""}, equalsTestCase{complex128(kTwoTo54 + 1), true, false, ""}, equalsTestCase{complex128(kTwoTo54 + 2), true, false, ""}, equalsTestCase{complex128(kTwoTo54 + 3), false, false, ""}, } t.checkTestCases(matcher, cases) } //////////////////////////////////////////////////////////////////////// // complex64 //////////////////////////////////////////////////////////////////////// func (t *EqualsTest) NegativeIntegralComplex64() { const kExpected = -32769 matcher := Equals(complex64(kExpected)) ExpectEq("(-32769+0i)", matcher.Description()) cases := []equalsTestCase{ // Various types of the expected value. equalsTestCase{-32769.0, true, false, ""}, equalsTestCase{-32769.0 + 0i, true, false, ""}, equalsTestCase{int(kExpected), true, false, ""}, equalsTestCase{int32(kExpected), true, false, ""}, equalsTestCase{int64(kExpected), true, false, ""}, equalsTestCase{float32(kExpected), true, false, ""}, equalsTestCase{float64(kExpected), true, false, ""}, equalsTestCase{complex64(kExpected), true, false, ""}, equalsTestCase{complex128(kExpected), true, false, ""}, equalsTestCase{interface{}(float64(kExpected)), true, false, ""}, // Values that would be kExpected in two's complement. equalsTestCase{uint32((1 << 32) + kExpected), false, false, ""}, equalsTestCase{uint64((1 << 64) + kExpected), false, false, ""}, equalsTestCase{uintptr((1 << 64) + kExpected), false, false, ""}, // Non-equal values of numeric type. equalsTestCase{int64(kExpected + 1), false, false, ""}, equalsTestCase{float32(kExpected - (1 << 30)), false, false, ""}, equalsTestCase{float32(kExpected + (1 << 30)), false, false, ""}, equalsTestCase{float64(kExpected - 0.5), false, false, ""}, equalsTestCase{float64(kExpected + 0.5), false, false, ""}, equalsTestCase{complex64(kExpected - 1), false, false, ""}, equalsTestCase{complex64(kExpected + 2i), false, false, ""}, equalsTestCase{complex128(kExpected - 1), false, false, ""}, equalsTestCase{complex128(kExpected + 2i), false, false, ""}, // Non-numeric types. equalsTestCase{true, false, true, "which is not numeric"}, equalsTestCase{[...]int{}, false, true, "which is not numeric"}, equalsTestCase{make(chan int), false, true, "which is not numeric"}, equalsTestCase{func() {}, false, true, "which is not numeric"}, equalsTestCase{map[int]int{}, false, true, "which is not numeric"}, equalsTestCase{&someInt, false, true, "which is not numeric"}, equalsTestCase{[]int{}, false, true, "which is not numeric"}, equalsTestCase{"taco", false, true, "which is not numeric"}, equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) NegativeNonIntegralComplex64() { const kTwoTo20 = 1 << 20 const kExpected = -kTwoTo20 - 0.25 matcher := Equals(complex64(kExpected)) ExpectEq("(-1.0485762e+06+0i)", matcher.Description()) cases := []equalsTestCase{ // Various types of the expected value. equalsTestCase{kExpected, true, false, ""}, equalsTestCase{kExpected + 0i, true, false, ""}, equalsTestCase{float32(kExpected), true, false, ""}, equalsTestCase{float64(kExpected), true, false, ""}, equalsTestCase{complex64(kExpected), true, false, ""}, equalsTestCase{complex128(kExpected), true, false, ""}, // Non-equal values of numeric type. equalsTestCase{int(-kTwoTo20), false, false, ""}, equalsTestCase{int(-kTwoTo20 - 1), false, false, ""}, equalsTestCase{int32(-kTwoTo20), false, false, ""}, equalsTestCase{int32(-kTwoTo20 - 1), false, false, ""}, equalsTestCase{int64(-kTwoTo20), false, false, ""}, equalsTestCase{int64(-kTwoTo20 - 1), false, false, ""}, equalsTestCase{float32(kExpected - (1 << 30)), false, false, ""}, equalsTestCase{float64(kExpected - 0.25), false, false, ""}, equalsTestCase{float64(kExpected + 0.25), false, false, ""}, equalsTestCase{complex64(kExpected - 0.75), false, false, ""}, equalsTestCase{complex64(kExpected + 2i), false, false, ""}, equalsTestCase{complex128(kExpected - 0.75), false, false, ""}, equalsTestCase{complex128(kExpected + 2i), false, false, ""}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) LargeNegativeComplex64() { const kExpected = -1 * (1 << 65) matcher := Equals(complex64(kExpected)) ExpectEq("(-3.689349e+19+0i)", matcher.Description()) floatExpected := float64(kExpected) castedInt := int64(floatExpected) cases := []equalsTestCase{ // Equal values of numeric type. equalsTestCase{kExpected + 0i, true, false, ""}, equalsTestCase{float32(kExpected), true, false, ""}, equalsTestCase{float64(kExpected), true, false, ""}, equalsTestCase{complex64(kExpected), true, false, ""}, equalsTestCase{complex128(kExpected), true, false, ""}, // Non-equal values of numeric type. equalsTestCase{castedInt, false, false, ""}, equalsTestCase{int64(0), false, false, ""}, equalsTestCase{int64(math.MinInt64), false, false, ""}, equalsTestCase{int64(math.MaxInt64), false, false, ""}, equalsTestCase{float32(kExpected / 2), false, false, ""}, equalsTestCase{float64(kExpected / 2), false, false, ""}, equalsTestCase{complex64(kExpected + 2i), false, false, ""}, equalsTestCase{complex128(kExpected + 2i), false, false, ""}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) ZeroComplex64() { matcher := Equals(complex64(0)) ExpectEq("(0+0i)", matcher.Description()) cases := []equalsTestCase{ // Various types of zero. equalsTestCase{0.0, true, false, ""}, equalsTestCase{0 + 0i, true, false, ""}, equalsTestCase{int(0), true, false, ""}, equalsTestCase{int8(0), true, false, ""}, equalsTestCase{int16(0), true, false, ""}, equalsTestCase{int32(0), true, false, ""}, equalsTestCase{int64(0), true, false, ""}, equalsTestCase{uint(0), true, false, ""}, equalsTestCase{uint8(0), true, false, ""}, equalsTestCase{uint16(0), true, false, ""}, equalsTestCase{uint32(0), true, false, ""}, equalsTestCase{uint64(0), true, false, ""}, equalsTestCase{uintptr(0), true, false, ""}, equalsTestCase{float32(0), true, false, ""}, equalsTestCase{float64(0), true, false, ""}, equalsTestCase{complex64(0), true, false, ""}, equalsTestCase{complex128(0), true, false, ""}, equalsTestCase{interface{}(float32(0)), true, false, ""}, // Non-equal values of numeric type. equalsTestCase{int64(1), false, false, ""}, equalsTestCase{int64(-1), false, false, ""}, equalsTestCase{float32(1), false, false, ""}, equalsTestCase{float32(-1), false, false, ""}, equalsTestCase{float64(1), false, false, ""}, equalsTestCase{float64(-1), false, false, ""}, equalsTestCase{complex64(0 + 2i), false, false, ""}, equalsTestCase{complex128(0 + 2i), false, false, ""}, // Non-numeric types. equalsTestCase{true, false, true, "which is not numeric"}, equalsTestCase{[...]int{}, false, true, "which is not numeric"}, equalsTestCase{make(chan int), false, true, "which is not numeric"}, equalsTestCase{func() {}, false, true, "which is not numeric"}, equalsTestCase{map[int]int{}, false, true, "which is not numeric"}, equalsTestCase{&someInt, false, true, "which is not numeric"}, equalsTestCase{[]int{}, false, true, "which is not numeric"}, equalsTestCase{"taco", false, true, "which is not numeric"}, equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) PositiveIntegralComplex64() { const kExpected = 1 << 20 matcher := Equals(complex64(kExpected)) ExpectEq("(1.048576e+06+0i)", matcher.Description()) cases := []equalsTestCase{ // Various types of 32769. equalsTestCase{1048576.0, true, false, ""}, equalsTestCase{1048576.0 + 0i, true, false, ""}, equalsTestCase{int(kExpected), true, false, ""}, equalsTestCase{int32(kExpected), true, false, ""}, equalsTestCase{int64(kExpected), true, false, ""}, equalsTestCase{uint(kExpected), true, false, ""}, equalsTestCase{uint32(kExpected), true, false, ""}, equalsTestCase{uint64(kExpected), true, false, ""}, equalsTestCase{uintptr(kExpected), true, false, ""}, equalsTestCase{float32(kExpected), true, false, ""}, equalsTestCase{float64(kExpected), true, false, ""}, equalsTestCase{complex64(kExpected), true, false, ""}, equalsTestCase{complex128(kExpected), true, false, ""}, equalsTestCase{interface{}(float64(kExpected)), true, false, ""}, // Non-equal values of numeric type. equalsTestCase{int(kExpected + 1), false, false, ""}, equalsTestCase{int32(kExpected + 1), false, false, ""}, equalsTestCase{int64(kExpected + 1), false, false, ""}, equalsTestCase{uint(kExpected + 1), false, false, ""}, equalsTestCase{uint32(kExpected + 1), false, false, ""}, equalsTestCase{uint64(kExpected + 1), false, false, ""}, equalsTestCase{uintptr(kExpected + 1), false, false, ""}, equalsTestCase{float32(kExpected - (1 << 30)), false, false, ""}, equalsTestCase{float32(kExpected + (1 << 30)), false, false, ""}, equalsTestCase{float64(kExpected - 0.5), false, false, ""}, equalsTestCase{float64(kExpected + 0.5), false, false, ""}, equalsTestCase{complex128(kExpected - 1), false, false, ""}, equalsTestCase{complex128(kExpected + 2i), false, false, ""}, // Non-numeric types. equalsTestCase{true, false, true, "which is not numeric"}, equalsTestCase{[...]int{}, false, true, "which is not numeric"}, equalsTestCase{make(chan int), false, true, "which is not numeric"}, equalsTestCase{func() {}, false, true, "which is not numeric"}, equalsTestCase{map[int]int{}, false, true, "which is not numeric"}, equalsTestCase{&someInt, false, true, "which is not numeric"}, equalsTestCase{[]int{}, false, true, "which is not numeric"}, equalsTestCase{"taco", false, true, "which is not numeric"}, equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) PositiveNonIntegralComplex64() { const kTwoTo20 = 1 << 20 const kExpected = kTwoTo20 + 0.25 matcher := Equals(complex64(kExpected)) ExpectEq("(1.0485762e+06+0i)", matcher.Description()) cases := []equalsTestCase{ // Various types of the expected value. equalsTestCase{kExpected, true, false, ""}, equalsTestCase{kExpected + 0i, true, false, ""}, equalsTestCase{float32(kExpected), true, false, ""}, equalsTestCase{float64(kExpected), true, false, ""}, equalsTestCase{complex64(kExpected), true, false, ""}, equalsTestCase{complex128(kExpected), true, false, ""}, // Non-equal values of numeric type. equalsTestCase{int64(kTwoTo20), false, false, ""}, equalsTestCase{int64(kTwoTo20 - 1), false, false, ""}, equalsTestCase{uint64(kTwoTo20), false, false, ""}, equalsTestCase{uint64(kTwoTo20 - 1), false, false, ""}, equalsTestCase{float32(kExpected - 1), false, false, ""}, equalsTestCase{float32(kExpected + 1), false, false, ""}, equalsTestCase{float64(kExpected - 0.25), false, false, ""}, equalsTestCase{float64(kExpected + 0.25), false, false, ""}, equalsTestCase{complex64(kExpected - 1), false, false, ""}, equalsTestCase{complex64(kExpected - 1i), false, false, ""}, equalsTestCase{complex128(kExpected - 1), false, false, ""}, equalsTestCase{complex128(kExpected - 1i), false, false, ""}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) LargePositiveComplex64() { const kExpected = 1 << 65 matcher := Equals(complex64(kExpected)) ExpectEq("(3.689349e+19+0i)", matcher.Description()) floatExpected := float64(kExpected) castedInt := uint64(floatExpected) cases := []equalsTestCase{ // Equal values of numeric type. equalsTestCase{kExpected + 0i, true, false, ""}, equalsTestCase{float32(kExpected), true, false, ""}, equalsTestCase{float64(kExpected), true, false, ""}, equalsTestCase{complex64(kExpected), true, false, ""}, equalsTestCase{complex128(kExpected), true, false, ""}, // Non-equal values of numeric type. equalsTestCase{castedInt, false, false, ""}, equalsTestCase{int64(0), false, false, ""}, equalsTestCase{int64(math.MinInt64), false, false, ""}, equalsTestCase{int64(math.MaxInt64), false, false, ""}, equalsTestCase{uint64(0), false, false, ""}, equalsTestCase{uint64(math.MaxUint64), false, false, ""}, equalsTestCase{float32(kExpected / 2), false, false, ""}, equalsTestCase{float64(kExpected / 2), false, false, ""}, equalsTestCase{complex128(kExpected + 2i), false, false, ""}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) Complex64AboveExactIntegerRange() { // Single-precision floats don't have enough bits to represent the integers // near this one distinctly, so [2^25-1, 2^25+2] all receive the same value // and should be treated as equivalent when floats are in the mix. const kTwoTo25 = 1 << 25 matcher := Equals(complex64(kTwoTo25 + 1)) ExpectEq("(3.3554432e+07+0i)", matcher.Description()) cases := []equalsTestCase{ // Integers. equalsTestCase{int64(kTwoTo25 - 2), false, false, ""}, equalsTestCase{int64(kTwoTo25 - 1), true, false, ""}, equalsTestCase{int64(kTwoTo25 + 0), true, false, ""}, equalsTestCase{int64(kTwoTo25 + 1), true, false, ""}, equalsTestCase{int64(kTwoTo25 + 2), true, false, ""}, equalsTestCase{int64(kTwoTo25 + 3), false, false, ""}, equalsTestCase{uint64(kTwoTo25 - 2), false, false, ""}, equalsTestCase{uint64(kTwoTo25 - 1), true, false, ""}, equalsTestCase{uint64(kTwoTo25 + 0), true, false, ""}, equalsTestCase{uint64(kTwoTo25 + 1), true, false, ""}, equalsTestCase{uint64(kTwoTo25 + 2), true, false, ""}, equalsTestCase{uint64(kTwoTo25 + 3), false, false, ""}, // Single-precision floating point. equalsTestCase{float32(kTwoTo25 - 2), false, false, ""}, equalsTestCase{float32(kTwoTo25 - 1), true, false, ""}, equalsTestCase{float32(kTwoTo25 + 0), true, false, ""}, equalsTestCase{float32(kTwoTo25 + 1), true, false, ""}, equalsTestCase{float32(kTwoTo25 + 2), true, false, ""}, equalsTestCase{float32(kTwoTo25 + 3), false, false, ""}, equalsTestCase{complex64(kTwoTo25 - 2), false, false, ""}, equalsTestCase{complex64(kTwoTo25 - 1), true, false, ""}, equalsTestCase{complex64(kTwoTo25 + 0), true, false, ""}, equalsTestCase{complex64(kTwoTo25 + 1), true, false, ""}, equalsTestCase{complex64(kTwoTo25 + 2), true, false, ""}, equalsTestCase{complex64(kTwoTo25 + 3), false, false, ""}, // Double-precision floating point. equalsTestCase{float64(kTwoTo25 - 2), false, false, ""}, equalsTestCase{float64(kTwoTo25 - 1), true, false, ""}, equalsTestCase{float64(kTwoTo25 + 0), true, false, ""}, equalsTestCase{float64(kTwoTo25 + 1), true, false, ""}, equalsTestCase{float64(kTwoTo25 + 2), true, false, ""}, equalsTestCase{float64(kTwoTo25 + 3), false, false, ""}, equalsTestCase{complex128(kTwoTo25 - 2), false, false, ""}, equalsTestCase{complex128(kTwoTo25 - 1), true, false, ""}, equalsTestCase{complex128(kTwoTo25 + 0), true, false, ""}, equalsTestCase{complex128(kTwoTo25 + 1), true, false, ""}, equalsTestCase{complex128(kTwoTo25 + 2), true, false, ""}, equalsTestCase{complex128(kTwoTo25 + 3), false, false, ""}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) Complex64WithNonZeroImaginaryPart() { const kRealPart = 17 const kImagPart = 0.25i const kExpected = kRealPart + kImagPart matcher := Equals(complex64(kExpected)) ExpectEq("(17+0.25i)", matcher.Description()) cases := []equalsTestCase{ // Various types of the expected value. equalsTestCase{kExpected, true, false, ""}, equalsTestCase{kRealPart + kImagPart, true, false, ""}, equalsTestCase{complex64(kExpected), true, false, ""}, equalsTestCase{complex128(kExpected), true, false, ""}, // Non-equal values of numeric type. equalsTestCase{int(kRealPart), false, false, ""}, equalsTestCase{int8(kRealPart), false, false, ""}, equalsTestCase{int16(kRealPart), false, false, ""}, equalsTestCase{int32(kRealPart), false, false, ""}, equalsTestCase{int64(kRealPart), false, false, ""}, equalsTestCase{uint(kRealPart), false, false, ""}, equalsTestCase{uint8(kRealPart), false, false, ""}, equalsTestCase{uint16(kRealPart), false, false, ""}, equalsTestCase{uint32(kRealPart), false, false, ""}, equalsTestCase{uint64(kRealPart), false, false, ""}, equalsTestCase{float32(kRealPart), false, false, ""}, equalsTestCase{float64(kRealPart), false, false, ""}, equalsTestCase{complex64(kRealPart), false, false, ""}, equalsTestCase{complex64(kRealPart + kImagPart + 0.5), false, false, ""}, equalsTestCase{complex64(kRealPart + kImagPart + 0.5i), false, false, ""}, equalsTestCase{complex128(kRealPart), false, false, ""}, equalsTestCase{complex128(kRealPart + kImagPart + 0.5), false, false, ""}, equalsTestCase{complex128(kRealPart + kImagPart + 0.5i), false, false, ""}, } t.checkTestCases(matcher, cases) } //////////////////////////////////////////////////////////////////////// // complex128 //////////////////////////////////////////////////////////////////////// func (t *EqualsTest) NegativeIntegralComplex128() { const kExpected = -32769 matcher := Equals(complex128(kExpected)) ExpectEq("(-32769+0i)", matcher.Description()) cases := []equalsTestCase{ // Various types of the expected value. equalsTestCase{-32769.0, true, false, ""}, equalsTestCase{-32769.0 + 0i, true, false, ""}, equalsTestCase{int(kExpected), true, false, ""}, equalsTestCase{int32(kExpected), true, false, ""}, equalsTestCase{int64(kExpected), true, false, ""}, equalsTestCase{float32(kExpected), true, false, ""}, equalsTestCase{float64(kExpected), true, false, ""}, equalsTestCase{complex64(kExpected), true, false, ""}, equalsTestCase{complex128(kExpected), true, false, ""}, equalsTestCase{interface{}(float64(kExpected)), true, false, ""}, // Values that would be kExpected in two's complement. equalsTestCase{uint32((1 << 32) + kExpected), false, false, ""}, equalsTestCase{uint64((1 << 64) + kExpected), false, false, ""}, equalsTestCase{uintptr((1 << 64) + kExpected), false, false, ""}, // Non-equal values of numeric type. equalsTestCase{int64(kExpected + 1), false, false, ""}, equalsTestCase{float32(kExpected - (1 << 30)), false, false, ""}, equalsTestCase{float32(kExpected + (1 << 30)), false, false, ""}, equalsTestCase{float64(kExpected - 0.5), false, false, ""}, equalsTestCase{float64(kExpected + 0.5), false, false, ""}, equalsTestCase{complex64(kExpected - 1), false, false, ""}, equalsTestCase{complex64(kExpected + 2i), false, false, ""}, equalsTestCase{complex128(kExpected - 1), false, false, ""}, equalsTestCase{complex128(kExpected + 2i), false, false, ""}, // Non-numeric types. equalsTestCase{true, false, true, "which is not numeric"}, equalsTestCase{[...]int{}, false, true, "which is not numeric"}, equalsTestCase{make(chan int), false, true, "which is not numeric"}, equalsTestCase{func() {}, false, true, "which is not numeric"}, equalsTestCase{map[int]int{}, false, true, "which is not numeric"}, equalsTestCase{&someInt, false, true, "which is not numeric"}, equalsTestCase{[]int{}, false, true, "which is not numeric"}, equalsTestCase{"taco", false, true, "which is not numeric"}, equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) NegativeNonIntegralComplex128() { const kTwoTo20 = 1 << 20 const kExpected = -kTwoTo20 - 0.25 matcher := Equals(complex128(kExpected)) ExpectEq("(-1.04857625e+06+0i)", matcher.Description()) cases := []equalsTestCase{ // Various types of the expected value. equalsTestCase{kExpected, true, false, ""}, equalsTestCase{kExpected + 0i, true, false, ""}, equalsTestCase{float32(kExpected), true, false, ""}, equalsTestCase{float64(kExpected), true, false, ""}, equalsTestCase{complex64(kExpected), true, false, ""}, equalsTestCase{complex128(kExpected), true, false, ""}, // Non-equal values of numeric type. equalsTestCase{int(-kTwoTo20), false, false, ""}, equalsTestCase{int(-kTwoTo20 - 1), false, false, ""}, equalsTestCase{int32(-kTwoTo20), false, false, ""}, equalsTestCase{int32(-kTwoTo20 - 1), false, false, ""}, equalsTestCase{int64(-kTwoTo20), false, false, ""}, equalsTestCase{int64(-kTwoTo20 - 1), false, false, ""}, equalsTestCase{float32(kExpected - (1 << 30)), false, false, ""}, equalsTestCase{float64(kExpected - 0.25), false, false, ""}, equalsTestCase{float64(kExpected + 0.25), false, false, ""}, equalsTestCase{complex64(kExpected - 0.75), false, false, ""}, equalsTestCase{complex64(kExpected + 2i), false, false, ""}, equalsTestCase{complex128(kExpected - 0.75), false, false, ""}, equalsTestCase{complex128(kExpected + 2i), false, false, ""}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) LargeNegativeComplex128() { const kExpected = -1 * (1 << 65) matcher := Equals(complex128(kExpected)) ExpectEq("(-3.6893488147419103e+19+0i)", matcher.Description()) floatExpected := float64(kExpected) castedInt := int64(floatExpected) cases := []equalsTestCase{ // Equal values of numeric type. equalsTestCase{kExpected + 0i, true, false, ""}, equalsTestCase{float32(kExpected), true, false, ""}, equalsTestCase{float64(kExpected), true, false, ""}, equalsTestCase{complex64(kExpected), true, false, ""}, equalsTestCase{complex128(kExpected), true, false, ""}, // Non-equal values of numeric type. equalsTestCase{castedInt, false, false, ""}, equalsTestCase{int64(0), false, false, ""}, equalsTestCase{int64(math.MinInt64), false, false, ""}, equalsTestCase{int64(math.MaxInt64), false, false, ""}, equalsTestCase{float32(kExpected / 2), false, false, ""}, equalsTestCase{float64(kExpected / 2), false, false, ""}, equalsTestCase{complex64(kExpected + 2i), false, false, ""}, equalsTestCase{complex128(kExpected + 2i), false, false, ""}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) ZeroComplex128() { matcher := Equals(complex128(0)) ExpectEq("(0+0i)", matcher.Description()) cases := []equalsTestCase{ // Various types of zero. equalsTestCase{0.0, true, false, ""}, equalsTestCase{0 + 0i, true, false, ""}, equalsTestCase{int(0), true, false, ""}, equalsTestCase{int8(0), true, false, ""}, equalsTestCase{int16(0), true, false, ""}, equalsTestCase{int32(0), true, false, ""}, equalsTestCase{int64(0), true, false, ""}, equalsTestCase{uint(0), true, false, ""}, equalsTestCase{uint8(0), true, false, ""}, equalsTestCase{uint16(0), true, false, ""}, equalsTestCase{uint32(0), true, false, ""}, equalsTestCase{uint64(0), true, false, ""}, equalsTestCase{uintptr(0), true, false, ""}, equalsTestCase{float32(0), true, false, ""}, equalsTestCase{float64(0), true, false, ""}, equalsTestCase{complex64(0), true, false, ""}, equalsTestCase{complex128(0), true, false, ""}, equalsTestCase{interface{}(float32(0)), true, false, ""}, // Non-equal values of numeric type. equalsTestCase{int64(1), false, false, ""}, equalsTestCase{int64(-1), false, false, ""}, equalsTestCase{float32(1), false, false, ""}, equalsTestCase{float32(-1), false, false, ""}, equalsTestCase{float64(1), false, false, ""}, equalsTestCase{float64(-1), false, false, ""}, equalsTestCase{complex64(0 + 2i), false, false, ""}, equalsTestCase{complex128(0 + 2i), false, false, ""}, // Non-numeric types. equalsTestCase{true, false, true, "which is not numeric"}, equalsTestCase{[...]int{}, false, true, "which is not numeric"}, equalsTestCase{make(chan int), false, true, "which is not numeric"}, equalsTestCase{func() {}, false, true, "which is not numeric"}, equalsTestCase{map[int]int{}, false, true, "which is not numeric"}, equalsTestCase{&someInt, false, true, "which is not numeric"}, equalsTestCase{[]int{}, false, true, "which is not numeric"}, equalsTestCase{"taco", false, true, "which is not numeric"}, equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) PositiveIntegralComplex128() { const kExpected = 1 << 20 matcher := Equals(complex128(kExpected)) ExpectEq("(1.048576e+06+0i)", matcher.Description()) cases := []equalsTestCase{ // Various types of 32769. equalsTestCase{1048576.0, true, false, ""}, equalsTestCase{1048576.0 + 0i, true, false, ""}, equalsTestCase{int(kExpected), true, false, ""}, equalsTestCase{int32(kExpected), true, false, ""}, equalsTestCase{int64(kExpected), true, false, ""}, equalsTestCase{uint(kExpected), true, false, ""}, equalsTestCase{uint32(kExpected), true, false, ""}, equalsTestCase{uint64(kExpected), true, false, ""}, equalsTestCase{uintptr(kExpected), true, false, ""}, equalsTestCase{float32(kExpected), true, false, ""}, equalsTestCase{float64(kExpected), true, false, ""}, equalsTestCase{complex64(kExpected), true, false, ""}, equalsTestCase{complex128(kExpected), true, false, ""}, equalsTestCase{interface{}(float64(kExpected)), true, false, ""}, // Non-equal values of numeric type. equalsTestCase{int(kExpected + 1), false, false, ""}, equalsTestCase{int32(kExpected + 1), false, false, ""}, equalsTestCase{int64(kExpected + 1), false, false, ""}, equalsTestCase{uint(kExpected + 1), false, false, ""}, equalsTestCase{uint32(kExpected + 1), false, false, ""}, equalsTestCase{uint64(kExpected + 1), false, false, ""}, equalsTestCase{uintptr(kExpected + 1), false, false, ""}, equalsTestCase{float32(kExpected - (1 << 30)), false, false, ""}, equalsTestCase{float32(kExpected + (1 << 30)), false, false, ""}, equalsTestCase{float64(kExpected - 0.5), false, false, ""}, equalsTestCase{float64(kExpected + 0.5), false, false, ""}, equalsTestCase{complex128(kExpected - 1), false, false, ""}, equalsTestCase{complex128(kExpected + 2i), false, false, ""}, // Non-numeric types. equalsTestCase{true, false, true, "which is not numeric"}, equalsTestCase{[...]int{}, false, true, "which is not numeric"}, equalsTestCase{make(chan int), false, true, "which is not numeric"}, equalsTestCase{func() {}, false, true, "which is not numeric"}, equalsTestCase{map[int]int{}, false, true, "which is not numeric"}, equalsTestCase{&someInt, false, true, "which is not numeric"}, equalsTestCase{[]int{}, false, true, "which is not numeric"}, equalsTestCase{"taco", false, true, "which is not numeric"}, equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) PositiveNonIntegralComplex128() { const kTwoTo20 = 1 << 20 const kExpected = kTwoTo20 + 0.25 matcher := Equals(complex128(kExpected)) ExpectEq("(1.04857625e+06+0i)", matcher.Description()) cases := []equalsTestCase{ // Various types of the expected value. equalsTestCase{kExpected, true, false, ""}, equalsTestCase{kExpected + 0i, true, false, ""}, equalsTestCase{float32(kExpected), true, false, ""}, equalsTestCase{float64(kExpected), true, false, ""}, equalsTestCase{complex64(kExpected), true, false, ""}, equalsTestCase{complex128(kExpected), true, false, ""}, // Non-equal values of numeric type. equalsTestCase{int64(kTwoTo20), false, false, ""}, equalsTestCase{int64(kTwoTo20 - 1), false, false, ""}, equalsTestCase{uint64(kTwoTo20), false, false, ""}, equalsTestCase{uint64(kTwoTo20 - 1), false, false, ""}, equalsTestCase{float32(kExpected - 1), false, false, ""}, equalsTestCase{float32(kExpected + 1), false, false, ""}, equalsTestCase{float64(kExpected - 0.25), false, false, ""}, equalsTestCase{float64(kExpected + 0.25), false, false, ""}, equalsTestCase{complex64(kExpected - 1), false, false, ""}, equalsTestCase{complex64(kExpected - 1i), false, false, ""}, equalsTestCase{complex128(kExpected - 1), false, false, ""}, equalsTestCase{complex128(kExpected - 1i), false, false, ""}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) LargePositiveComplex128() { const kExpected = 1 << 65 matcher := Equals(complex128(kExpected)) ExpectEq("(3.6893488147419103e+19+0i)", matcher.Description()) floatExpected := float64(kExpected) castedInt := uint64(floatExpected) cases := []equalsTestCase{ // Equal values of numeric type. equalsTestCase{kExpected + 0i, true, false, ""}, equalsTestCase{float32(kExpected), true, false, ""}, equalsTestCase{float64(kExpected), true, false, ""}, equalsTestCase{complex64(kExpected), true, false, ""}, equalsTestCase{complex128(kExpected), true, false, ""}, // Non-equal values of numeric type. equalsTestCase{castedInt, false, false, ""}, equalsTestCase{int64(0), false, false, ""}, equalsTestCase{int64(math.MinInt64), false, false, ""}, equalsTestCase{int64(math.MaxInt64), false, false, ""}, equalsTestCase{uint64(0), false, false, ""}, equalsTestCase{uint64(math.MaxUint64), false, false, ""}, equalsTestCase{float32(kExpected / 2), false, false, ""}, equalsTestCase{float64(kExpected / 2), false, false, ""}, equalsTestCase{complex128(kExpected + 2i), false, false, ""}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) Complex128AboveExactIntegerRange() { // Double-precision floats don't have enough bits to represent the integers // near this one distinctly, so [2^54-1, 2^54+2] all receive the same value // and should be treated as equivalent when floats are in the mix. const kTwoTo54 = 1 << 54 matcher := Equals(complex128(kTwoTo54 + 1)) ExpectEq("(1.8014398509481984e+16+0i)", matcher.Description()) cases := []equalsTestCase{ // Integers. equalsTestCase{int64(kTwoTo54 - 2), false, false, ""}, equalsTestCase{int64(kTwoTo54 - 1), true, false, ""}, equalsTestCase{int64(kTwoTo54 + 0), true, false, ""}, equalsTestCase{int64(kTwoTo54 + 1), true, false, ""}, equalsTestCase{int64(kTwoTo54 + 2), true, false, ""}, equalsTestCase{int64(kTwoTo54 + 3), false, false, ""}, equalsTestCase{uint64(kTwoTo54 - 2), false, false, ""}, equalsTestCase{uint64(kTwoTo54 - 1), true, false, ""}, equalsTestCase{uint64(kTwoTo54 + 0), true, false, ""}, equalsTestCase{uint64(kTwoTo54 + 1), true, false, ""}, equalsTestCase{uint64(kTwoTo54 + 2), true, false, ""}, equalsTestCase{uint64(kTwoTo54 + 3), false, false, ""}, // Double-precision floating point. equalsTestCase{float64(kTwoTo54 - 2), false, false, ""}, equalsTestCase{float64(kTwoTo54 - 1), true, false, ""}, equalsTestCase{float64(kTwoTo54 + 0), true, false, ""}, equalsTestCase{float64(kTwoTo54 + 1), true, false, ""}, equalsTestCase{float64(kTwoTo54 + 2), true, false, ""}, equalsTestCase{float64(kTwoTo54 + 3), false, false, ""}, equalsTestCase{complex128(kTwoTo54 - 2), false, false, ""}, equalsTestCase{complex128(kTwoTo54 - 1), true, false, ""}, equalsTestCase{complex128(kTwoTo54 + 0), true, false, ""}, equalsTestCase{complex128(kTwoTo54 + 1), true, false, ""}, equalsTestCase{complex128(kTwoTo54 + 2), true, false, ""}, equalsTestCase{complex128(kTwoTo54 + 3), false, false, ""}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) Complex128WithNonZeroImaginaryPart() { const kRealPart = 17 const kImagPart = 0.25i const kExpected = kRealPart + kImagPart matcher := Equals(complex128(kExpected)) ExpectEq("(17+0.25i)", matcher.Description()) cases := []equalsTestCase{ // Various types of the expected value. equalsTestCase{kExpected, true, false, ""}, equalsTestCase{kRealPart + kImagPart, true, false, ""}, equalsTestCase{complex64(kExpected), true, false, ""}, equalsTestCase{complex128(kExpected), true, false, ""}, // Non-equal values of numeric type. equalsTestCase{int(kRealPart), false, false, ""}, equalsTestCase{int8(kRealPart), false, false, ""}, equalsTestCase{int16(kRealPart), false, false, ""}, equalsTestCase{int32(kRealPart), false, false, ""}, equalsTestCase{int64(kRealPart), false, false, ""}, equalsTestCase{uint(kRealPart), false, false, ""}, equalsTestCase{uint8(kRealPart), false, false, ""}, equalsTestCase{uint16(kRealPart), false, false, ""}, equalsTestCase{uint32(kRealPart), false, false, ""}, equalsTestCase{uint64(kRealPart), false, false, ""}, equalsTestCase{float32(kRealPart), false, false, ""}, equalsTestCase{float64(kRealPart), false, false, ""}, equalsTestCase{complex64(kRealPart), false, false, ""}, equalsTestCase{complex64(kRealPart + kImagPart + 0.5), false, false, ""}, equalsTestCase{complex64(kRealPart + kImagPart + 0.5i), false, false, ""}, equalsTestCase{complex128(kRealPart), false, false, ""}, equalsTestCase{complex128(kRealPart + kImagPart + 0.5), false, false, ""}, equalsTestCase{complex128(kRealPart + kImagPart + 0.5i), false, false, ""}, } t.checkTestCases(matcher, cases) } //////////////////////////////////////////////////////////////////////// // Arrays //////////////////////////////////////////////////////////////////////// func (t *EqualsTest) ArrayOfComparableType() { expected := [3]uint{17, 19, 23} matcher := Equals(expected) ExpectEq("[17 19 23]", matcher.Description()) // To defeat constant de-duping by the compiler. makeArray := func(i, j, k uint) [3]uint { return [3]uint{i, j, k} } type arrayAlias [3]uint type uintAlias uint cases := []equalsTestCase{ // Correct types, equal. equalsTestCase{expected, true, false, ""}, equalsTestCase{[3]uint{17, 19, 23}, true, false, ""}, equalsTestCase{makeArray(17, 19, 23), true, false, ""}, // Correct types, not equal. equalsTestCase{[3]uint{0, 0, 0}, false, false, ""}, equalsTestCase{[3]uint{18, 19, 23}, false, false, ""}, equalsTestCase{[3]uint{17, 20, 23}, false, false, ""}, equalsTestCase{[3]uint{17, 19, 22}, false, false, ""}, // Other types. equalsTestCase{0, false, true, "which is not [3]uint"}, equalsTestCase{bool(false), false, true, "which is not [3]uint"}, equalsTestCase{int(0), false, true, "which is not [3]uint"}, equalsTestCase{int8(0), false, true, "which is not [3]uint"}, equalsTestCase{int16(0), false, true, "which is not [3]uint"}, equalsTestCase{int32(0), false, true, "which is not [3]uint"}, equalsTestCase{int64(0), false, true, "which is not [3]uint"}, equalsTestCase{uint(0), false, true, "which is not [3]uint"}, equalsTestCase{uint8(0), false, true, "which is not [3]uint"}, equalsTestCase{uint16(0), false, true, "which is not [3]uint"}, equalsTestCase{uint32(0), false, true, "which is not [3]uint"}, equalsTestCase{uint64(0), false, true, "which is not [3]uint"}, equalsTestCase{true, false, true, "which is not [3]uint"}, equalsTestCase{[...]int{}, false, true, "which is not [3]uint"}, equalsTestCase{func() {}, false, true, "which is not [3]uint"}, equalsTestCase{map[int]int{}, false, true, "which is not [3]uint"}, equalsTestCase{equalsTestCase{}, false, true, "which is not [3]uint"}, equalsTestCase{[2]uint{17, 19}, false, true, "which is not [3]uint"}, equalsTestCase{[4]uint{17, 19, 23, 0}, false, true, "which is not [3]uint"}, equalsTestCase{arrayAlias{17, 19, 23}, false, true, "which is not [3]uint"}, equalsTestCase{[3]uintAlias{17, 19, 23}, false, true, "which is not [3]uint"}, equalsTestCase{[3]int32{17, 19, 23}, false, true, "which is not [3]uint"}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) ArrayOfNonComparableType() { type nonComparableArray [2]map[string]string f := func() { ExpectEq(nonComparableArray{}, nonComparableArray{}) } ExpectThat(f, Panics(MatchesRegexp("uncomparable.*nonComparableArray"))) } //////////////////////////////////////////////////////////////////////// // chan //////////////////////////////////////////////////////////////////////// func (t *EqualsTest) NilChan() { var nilChan1 chan int var nilChan2 chan int var nilChan3 chan uint var nonNilChan1 chan int = make(chan int) var nonNilChan2 chan uint = make(chan uint) matcher := Equals(nilChan1) ExpectEq("", matcher.Description()) cases := []equalsTestCase{ // int channels equalsTestCase{nilChan1, true, false, ""}, equalsTestCase{nilChan2, true, false, ""}, equalsTestCase{nonNilChan1, false, false, ""}, // uint channels equalsTestCase{nilChan3, false, true, "which is not a chan int"}, equalsTestCase{nonNilChan2, false, true, "which is not a chan int"}, // Other types. equalsTestCase{0, false, true, "which is not a chan int"}, equalsTestCase{bool(false), false, true, "which is not a chan int"}, equalsTestCase{int(0), false, true, "which is not a chan int"}, equalsTestCase{int8(0), false, true, "which is not a chan int"}, equalsTestCase{int16(0), false, true, "which is not a chan int"}, equalsTestCase{int32(0), false, true, "which is not a chan int"}, equalsTestCase{int64(0), false, true, "which is not a chan int"}, equalsTestCase{uint(0), false, true, "which is not a chan int"}, equalsTestCase{uint8(0), false, true, "which is not a chan int"}, equalsTestCase{uint16(0), false, true, "which is not a chan int"}, equalsTestCase{uint32(0), false, true, "which is not a chan int"}, equalsTestCase{uint64(0), false, true, "which is not a chan int"}, equalsTestCase{true, false, true, "which is not a chan int"}, equalsTestCase{[...]int{}, false, true, "which is not a chan int"}, equalsTestCase{func() {}, false, true, "which is not a chan int"}, equalsTestCase{map[int]int{}, false, true, "which is not a chan int"}, equalsTestCase{&someInt, false, true, "which is not a chan int"}, equalsTestCase{[]int{}, false, true, "which is not a chan int"}, equalsTestCase{"taco", false, true, "which is not a chan int"}, equalsTestCase{equalsTestCase{}, false, true, "which is not a chan int"}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) NonNilChan() { var nilChan1 chan int var nilChan2 chan uint var nonNilChan1 chan int = make(chan int) var nonNilChan2 chan int = make(chan int) var nonNilChan3 chan uint = make(chan uint) matcher := Equals(nonNilChan1) ExpectEq(fmt.Sprintf("%v", nonNilChan1), matcher.Description()) cases := []equalsTestCase{ // int channels equalsTestCase{nonNilChan1, true, false, ""}, equalsTestCase{nonNilChan2, false, false, ""}, equalsTestCase{nilChan1, false, false, ""}, // uint channels equalsTestCase{nilChan2, false, true, "which is not a chan int"}, equalsTestCase{nonNilChan3, false, true, "which is not a chan int"}, // Other types. equalsTestCase{0, false, true, "which is not a chan int"}, equalsTestCase{bool(false), false, true, "which is not a chan int"}, equalsTestCase{int(0), false, true, "which is not a chan int"}, equalsTestCase{int8(0), false, true, "which is not a chan int"}, equalsTestCase{int16(0), false, true, "which is not a chan int"}, equalsTestCase{int32(0), false, true, "which is not a chan int"}, equalsTestCase{int64(0), false, true, "which is not a chan int"}, equalsTestCase{uint(0), false, true, "which is not a chan int"}, equalsTestCase{uint8(0), false, true, "which is not a chan int"}, equalsTestCase{uint16(0), false, true, "which is not a chan int"}, equalsTestCase{uint32(0), false, true, "which is not a chan int"}, equalsTestCase{uint64(0), false, true, "which is not a chan int"}, equalsTestCase{true, false, true, "which is not a chan int"}, equalsTestCase{[...]int{}, false, true, "which is not a chan int"}, equalsTestCase{func() {}, false, true, "which is not a chan int"}, equalsTestCase{map[int]int{}, false, true, "which is not a chan int"}, equalsTestCase{&someInt, false, true, "which is not a chan int"}, equalsTestCase{[]int{}, false, true, "which is not a chan int"}, equalsTestCase{"taco", false, true, "which is not a chan int"}, equalsTestCase{equalsTestCase{}, false, true, "which is not a chan int"}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) ChanDirection() { var chan1 chan<- int var chan2 <-chan int var chan3 chan int matcher := Equals(chan1) ExpectEq(fmt.Sprintf("%v", chan1), matcher.Description()) cases := []equalsTestCase{ equalsTestCase{chan1, true, false, ""}, equalsTestCase{chan2, false, true, "which is not a chan<- int"}, equalsTestCase{chan3, false, true, "which is not a chan<- int"}, } t.checkTestCases(matcher, cases) } //////////////////////////////////////////////////////////////////////// // func //////////////////////////////////////////////////////////////////////// func (t *EqualsTest) Functions() { func1 := func() {} func2 := func() {} func3 := func(x int) {} matcher := Equals(func1) ExpectEq(fmt.Sprintf("%v", func1), matcher.Description()) cases := []equalsTestCase{ // Functions. equalsTestCase{func1, true, false, ""}, equalsTestCase{func2, false, false, ""}, equalsTestCase{func3, false, false, ""}, // Other types. equalsTestCase{0, false, true, "which is not a function"}, equalsTestCase{bool(false), false, true, "which is not a function"}, equalsTestCase{int(0), false, true, "which is not a function"}, equalsTestCase{int8(0), false, true, "which is not a function"}, equalsTestCase{int16(0), false, true, "which is not a function"}, equalsTestCase{int32(0), false, true, "which is not a function"}, equalsTestCase{int64(0), false, true, "which is not a function"}, equalsTestCase{uint(0), false, true, "which is not a function"}, equalsTestCase{uint8(0), false, true, "which is not a function"}, equalsTestCase{uint16(0), false, true, "which is not a function"}, equalsTestCase{uint32(0), false, true, "which is not a function"}, equalsTestCase{uint64(0), false, true, "which is not a function"}, equalsTestCase{true, false, true, "which is not a function"}, equalsTestCase{[...]int{}, false, true, "which is not a function"}, equalsTestCase{map[int]int{}, false, true, "which is not a function"}, equalsTestCase{&someInt, false, true, "which is not a function"}, equalsTestCase{[]int{}, false, true, "which is not a function"}, equalsTestCase{"taco", false, true, "which is not a function"}, equalsTestCase{equalsTestCase{}, false, true, "which is not a function"}, } t.checkTestCases(matcher, cases) } //////////////////////////////////////////////////////////////////////// // map //////////////////////////////////////////////////////////////////////// func (t *EqualsTest) NilMap() { var nilMap1 map[int]int var nilMap2 map[int]int var nilMap3 map[int]uint var nonNilMap1 map[int]int = make(map[int]int) var nonNilMap2 map[int]uint = make(map[int]uint) matcher := Equals(nilMap1) ExpectEq("map[]", matcher.Description()) cases := []equalsTestCase{ // Correct type. equalsTestCase{nilMap1, true, false, ""}, equalsTestCase{nilMap2, true, false, ""}, equalsTestCase{nilMap3, true, false, ""}, equalsTestCase{nonNilMap1, false, false, ""}, equalsTestCase{nonNilMap2, false, false, ""}, // Other types. equalsTestCase{0, false, true, "which is not a map"}, equalsTestCase{bool(false), false, true, "which is not a map"}, equalsTestCase{int(0), false, true, "which is not a map"}, equalsTestCase{int8(0), false, true, "which is not a map"}, equalsTestCase{int16(0), false, true, "which is not a map"}, equalsTestCase{int32(0), false, true, "which is not a map"}, equalsTestCase{int64(0), false, true, "which is not a map"}, equalsTestCase{uint(0), false, true, "which is not a map"}, equalsTestCase{uint8(0), false, true, "which is not a map"}, equalsTestCase{uint16(0), false, true, "which is not a map"}, equalsTestCase{uint32(0), false, true, "which is not a map"}, equalsTestCase{uint64(0), false, true, "which is not a map"}, equalsTestCase{true, false, true, "which is not a map"}, equalsTestCase{[...]int{}, false, true, "which is not a map"}, equalsTestCase{func() {}, false, true, "which is not a map"}, equalsTestCase{&someInt, false, true, "which is not a map"}, equalsTestCase{[]int{}, false, true, "which is not a map"}, equalsTestCase{"taco", false, true, "which is not a map"}, equalsTestCase{equalsTestCase{}, false, true, "which is not a map"}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) NonNilMap() { var nilMap1 map[int]int var nilMap2 map[int]uint var nonNilMap1 map[int]int = make(map[int]int) var nonNilMap2 map[int]int = make(map[int]int) var nonNilMap3 map[int]uint = make(map[int]uint) matcher := Equals(nonNilMap1) ExpectEq("map[]", matcher.Description()) cases := []equalsTestCase{ // Correct type. equalsTestCase{nonNilMap1, true, false, ""}, equalsTestCase{nonNilMap2, false, false, ""}, equalsTestCase{nonNilMap3, false, false, ""}, equalsTestCase{nilMap1, false, false, ""}, equalsTestCase{nilMap2, false, false, ""}, // Other types. equalsTestCase{0, false, true, "which is not a map"}, equalsTestCase{bool(false), false, true, "which is not a map"}, equalsTestCase{int(0), false, true, "which is not a map"}, equalsTestCase{int8(0), false, true, "which is not a map"}, equalsTestCase{int16(0), false, true, "which is not a map"}, equalsTestCase{int32(0), false, true, "which is not a map"}, equalsTestCase{int64(0), false, true, "which is not a map"}, equalsTestCase{uint(0), false, true, "which is not a map"}, equalsTestCase{uint8(0), false, true, "which is not a map"}, equalsTestCase{uint16(0), false, true, "which is not a map"}, equalsTestCase{uint32(0), false, true, "which is not a map"}, equalsTestCase{uint64(0), false, true, "which is not a map"}, equalsTestCase{true, false, true, "which is not a map"}, equalsTestCase{[...]int{}, false, true, "which is not a map"}, equalsTestCase{func() {}, false, true, "which is not a map"}, equalsTestCase{&someInt, false, true, "which is not a map"}, equalsTestCase{[]int{}, false, true, "which is not a map"}, equalsTestCase{"taco", false, true, "which is not a map"}, equalsTestCase{equalsTestCase{}, false, true, "which is not a map"}, } t.checkTestCases(matcher, cases) } //////////////////////////////////////////////////////////////////////// // Pointers //////////////////////////////////////////////////////////////////////// func (t *EqualsTest) NilPointer() { var someInt int = 17 var someUint uint = 17 var nilInt1 *int var nilInt2 *int var nilUint *uint var nonNilInt *int = &someInt var nonNilUint *uint = &someUint matcher := Equals(nilInt1) ExpectEq("", matcher.Description()) cases := []equalsTestCase{ // Correct type. equalsTestCase{nilInt1, true, false, ""}, equalsTestCase{nilInt2, true, false, ""}, equalsTestCase{nonNilInt, false, false, ""}, // Incorrect type. equalsTestCase{nilUint, false, true, "which is not a *int"}, equalsTestCase{nonNilUint, false, true, "which is not a *int"}, // Other types. equalsTestCase{0, false, true, "which is not a *int"}, equalsTestCase{bool(false), false, true, "which is not a *int"}, equalsTestCase{int(0), false, true, "which is not a *int"}, equalsTestCase{int8(0), false, true, "which is not a *int"}, equalsTestCase{int16(0), false, true, "which is not a *int"}, equalsTestCase{int32(0), false, true, "which is not a *int"}, equalsTestCase{int64(0), false, true, "which is not a *int"}, equalsTestCase{uint(0), false, true, "which is not a *int"}, equalsTestCase{uint8(0), false, true, "which is not a *int"}, equalsTestCase{uint16(0), false, true, "which is not a *int"}, equalsTestCase{uint32(0), false, true, "which is not a *int"}, equalsTestCase{uint64(0), false, true, "which is not a *int"}, equalsTestCase{true, false, true, "which is not a *int"}, equalsTestCase{[...]int{}, false, true, "which is not a *int"}, equalsTestCase{func() {}, false, true, "which is not a *int"}, equalsTestCase{map[int]int{}, false, true, "which is not a *int"}, equalsTestCase{[]int{}, false, true, "which is not a *int"}, equalsTestCase{"taco", false, true, "which is not a *int"}, equalsTestCase{equalsTestCase{}, false, true, "which is not a *int"}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) NonNilPointer() { var someInt int = 17 var someOtherInt int = 17 var someUint uint = 17 var nilInt *int var nilUint *uint var nonNilInt1 *int = &someInt var nonNilInt2 *int = &someOtherInt var nonNilUint *uint = &someUint matcher := Equals(nonNilInt1) ExpectEq(fmt.Sprintf("%v", nonNilInt1), matcher.Description()) cases := []equalsTestCase{ // Correct type. equalsTestCase{nonNilInt1, true, false, ""}, equalsTestCase{nonNilInt2, false, false, ""}, equalsTestCase{nilInt, false, false, ""}, // Incorrect type. equalsTestCase{nilUint, false, true, "which is not a *int"}, equalsTestCase{nonNilUint, false, true, "which is not a *int"}, // Other types. equalsTestCase{0, false, true, "which is not a *int"}, equalsTestCase{bool(false), false, true, "which is not a *int"}, equalsTestCase{int(0), false, true, "which is not a *int"}, equalsTestCase{int8(0), false, true, "which is not a *int"}, equalsTestCase{int16(0), false, true, "which is not a *int"}, equalsTestCase{int32(0), false, true, "which is not a *int"}, equalsTestCase{int64(0), false, true, "which is not a *int"}, equalsTestCase{uint(0), false, true, "which is not a *int"}, equalsTestCase{uint8(0), false, true, "which is not a *int"}, equalsTestCase{uint16(0), false, true, "which is not a *int"}, equalsTestCase{uint32(0), false, true, "which is not a *int"}, equalsTestCase{uint64(0), false, true, "which is not a *int"}, equalsTestCase{true, false, true, "which is not a *int"}, equalsTestCase{[...]int{}, false, true, "which is not a *int"}, equalsTestCase{func() {}, false, true, "which is not a *int"}, equalsTestCase{map[int]int{}, false, true, "which is not a *int"}, equalsTestCase{[]int{}, false, true, "which is not a *int"}, equalsTestCase{"taco", false, true, "which is not a *int"}, equalsTestCase{equalsTestCase{}, false, true, "which is not a *int"}, } t.checkTestCases(matcher, cases) } //////////////////////////////////////////////////////////////////////// // Slices //////////////////////////////////////////////////////////////////////// func (t *EqualsTest) NilSlice() { var nilInt1 []int var nilInt2 []int var nilUint []uint var nonNilInt []int = make([]int, 0) var nonNilUint []uint = make([]uint, 0) matcher := Equals(nilInt1) ExpectEq("[]", matcher.Description()) cases := []equalsTestCase{ // Correct type. equalsTestCase{nilInt1, true, false, ""}, equalsTestCase{nilInt2, true, false, ""}, equalsTestCase{nonNilInt, false, false, ""}, // Incorrect type. equalsTestCase{nilUint, false, true, "which is not a []int"}, equalsTestCase{nonNilUint, false, true, "which is not a []int"}, // Other types. equalsTestCase{0, false, true, "which is not a []int"}, equalsTestCase{bool(false), false, true, "which is not a []int"}, equalsTestCase{int(0), false, true, "which is not a []int"}, equalsTestCase{int8(0), false, true, "which is not a []int"}, equalsTestCase{int16(0), false, true, "which is not a []int"}, equalsTestCase{int32(0), false, true, "which is not a []int"}, equalsTestCase{int64(0), false, true, "which is not a []int"}, equalsTestCase{uint(0), false, true, "which is not a []int"}, equalsTestCase{uint8(0), false, true, "which is not a []int"}, equalsTestCase{uint16(0), false, true, "which is not a []int"}, equalsTestCase{uint32(0), false, true, "which is not a []int"}, equalsTestCase{uint64(0), false, true, "which is not a []int"}, equalsTestCase{true, false, true, "which is not a []int"}, equalsTestCase{[...]int{}, false, true, "which is not a []int"}, equalsTestCase{func() {}, false, true, "which is not a []int"}, equalsTestCase{map[int]int{}, false, true, "which is not a []int"}, equalsTestCase{"taco", false, true, "which is not a []int"}, equalsTestCase{equalsTestCase{}, false, true, "which is not a []int"}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) NonNilSlice() { nonNil := make([]int, 0) f := func() { Equals(nonNil) } ExpectThat(f, Panics(HasSubstr("non-nil slice"))) } //////////////////////////////////////////////////////////////////////// // string //////////////////////////////////////////////////////////////////////// func (t *EqualsTest) String() { partial := "taco" expected := fmt.Sprintf("%s%d", partial, 1) matcher := Equals(expected) ExpectEq("taco1", matcher.Description()) type stringAlias string cases := []equalsTestCase{ // Correct types. equalsTestCase{"taco1", true, false, ""}, equalsTestCase{"taco" + "1", true, false, ""}, equalsTestCase{expected, true, false, ""}, equalsTestCase{stringAlias("taco1"), true, false, ""}, equalsTestCase{"", false, false, ""}, equalsTestCase{"taco", false, false, ""}, equalsTestCase{"taco1\x00", false, false, ""}, equalsTestCase{"taco2", false, false, ""}, equalsTestCase{stringAlias("taco2"), false, false, ""}, // Other types. equalsTestCase{0, false, true, "which is not a string"}, equalsTestCase{bool(false), false, true, "which is not a string"}, equalsTestCase{int(0), false, true, "which is not a string"}, equalsTestCase{int8(0), false, true, "which is not a string"}, equalsTestCase{int16(0), false, true, "which is not a string"}, equalsTestCase{int32(0), false, true, "which is not a string"}, equalsTestCase{int64(0), false, true, "which is not a string"}, equalsTestCase{uint(0), false, true, "which is not a string"}, equalsTestCase{uint8(0), false, true, "which is not a string"}, equalsTestCase{uint16(0), false, true, "which is not a string"}, equalsTestCase{uint32(0), false, true, "which is not a string"}, equalsTestCase{uint64(0), false, true, "which is not a string"}, equalsTestCase{true, false, true, "which is not a string"}, equalsTestCase{[...]int{}, false, true, "which is not a string"}, equalsTestCase{func() {}, false, true, "which is not a string"}, equalsTestCase{map[int]int{}, false, true, "which is not a string"}, equalsTestCase{equalsTestCase{}, false, true, "which is not a string"}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) StringAlias() { type stringAlias string matcher := Equals(stringAlias("taco")) ExpectEq("taco", matcher.Description()) cases := []equalsTestCase{ // Correct types. equalsTestCase{stringAlias("taco"), true, false, ""}, equalsTestCase{"taco", true, false, ""}, equalsTestCase{"burrito", false, false, ""}, equalsTestCase{stringAlias("burrito"), false, false, ""}, // Other types. equalsTestCase{0, false, true, "which is not a string"}, equalsTestCase{bool(false), false, true, "which is not a string"}, } t.checkTestCases(matcher, cases) } //////////////////////////////////////////////////////////////////////// // struct //////////////////////////////////////////////////////////////////////// func (t *EqualsTest) Struct() { type someStruct struct{ foo uint } f := func() { Equals(someStruct{17}) } ExpectThat(f, Panics(HasSubstr("unsupported kind struct"))) } //////////////////////////////////////////////////////////////////////// // unsafe.Pointer //////////////////////////////////////////////////////////////////////// func (t *EqualsTest) NilUnsafePointer() { someInt := int(17) var nilPtr1 unsafe.Pointer var nilPtr2 unsafe.Pointer var nonNilPtr unsafe.Pointer = unsafe.Pointer(&someInt) matcher := Equals(nilPtr1) ExpectEq("", matcher.Description()) cases := []equalsTestCase{ // Correct type. equalsTestCase{nilPtr1, true, false, ""}, equalsTestCase{nilPtr2, true, false, ""}, equalsTestCase{nonNilPtr, false, false, ""}, // Other types. equalsTestCase{0, false, true, "which is not a unsafe.Pointer"}, equalsTestCase{bool(false), false, true, "which is not a unsafe.Pointer"}, equalsTestCase{int(0), false, true, "which is not a unsafe.Pointer"}, equalsTestCase{int8(0), false, true, "which is not a unsafe.Pointer"}, equalsTestCase{int16(0), false, true, "which is not a unsafe.Pointer"}, equalsTestCase{int32(0), false, true, "which is not a unsafe.Pointer"}, equalsTestCase{int64(0), false, true, "which is not a unsafe.Pointer"}, equalsTestCase{uint(0), false, true, "which is not a unsafe.Pointer"}, equalsTestCase{uint8(0), false, true, "which is not a unsafe.Pointer"}, equalsTestCase{uint16(0), false, true, "which is not a unsafe.Pointer"}, equalsTestCase{uint32(0), false, true, "which is not a unsafe.Pointer"}, equalsTestCase{uint64(0), false, true, "which is not a unsafe.Pointer"}, equalsTestCase{true, false, true, "which is not a unsafe.Pointer"}, equalsTestCase{[...]int{}, false, true, "which is not a unsafe.Pointer"}, equalsTestCase{make(chan int), false, true, "which is not a unsafe.Pointer"}, equalsTestCase{func() {}, false, true, "which is not a unsafe.Pointer"}, equalsTestCase{map[int]int{}, false, true, "which is not a unsafe.Pointer"}, equalsTestCase{&someInt, false, true, "which is not a unsafe.Pointer"}, equalsTestCase{[]int{}, false, true, "which is not a unsafe.Pointer"}, equalsTestCase{"taco", false, true, "which is not a unsafe.Pointer"}, equalsTestCase{equalsTestCase{}, false, true, "which is not a unsafe.Pointer"}, } t.checkTestCases(matcher, cases) } func (t *EqualsTest) NonNilUnsafePointer() { someInt := int(17) someOtherInt := int(17) var nilPtr unsafe.Pointer var nonNilPtr1 unsafe.Pointer = unsafe.Pointer(&someInt) var nonNilPtr2 unsafe.Pointer = unsafe.Pointer(&someOtherInt) matcher := Equals(nonNilPtr1) ExpectEq(fmt.Sprintf("%v", nonNilPtr1), matcher.Description()) cases := []equalsTestCase{ // Correct type. equalsTestCase{nonNilPtr1, true, false, ""}, equalsTestCase{nonNilPtr2, false, false, ""}, equalsTestCase{nilPtr, false, false, ""}, // Other types. equalsTestCase{0, false, true, "which is not a unsafe.Pointer"}, equalsTestCase{bool(false), false, true, "which is not a unsafe.Pointer"}, equalsTestCase{int(0), false, true, "which is not a unsafe.Pointer"}, equalsTestCase{int8(0), false, true, "which is not a unsafe.Pointer"}, equalsTestCase{int16(0), false, true, "which is not a unsafe.Pointer"}, equalsTestCase{int32(0), false, true, "which is not a unsafe.Pointer"}, equalsTestCase{int64(0), false, true, "which is not a unsafe.Pointer"}, equalsTestCase{uint(0), false, true, "which is not a unsafe.Pointer"}, equalsTestCase{uint8(0), false, true, "which is not a unsafe.Pointer"}, equalsTestCase{uint16(0), false, true, "which is not a unsafe.Pointer"}, equalsTestCase{uint32(0), false, true, "which is not a unsafe.Pointer"}, equalsTestCase{uint64(0), false, true, "which is not a unsafe.Pointer"}, equalsTestCase{true, false, true, "which is not a unsafe.Pointer"}, equalsTestCase{[...]int{}, false, true, "which is not a unsafe.Pointer"}, equalsTestCase{make(chan int), false, true, "which is not a unsafe.Pointer"}, equalsTestCase{func() {}, false, true, "which is not a unsafe.Pointer"}, equalsTestCase{map[int]int{}, false, true, "which is not a unsafe.Pointer"}, equalsTestCase{&someInt, false, true, "which is not a unsafe.Pointer"}, equalsTestCase{[]int{}, false, true, "which is not a unsafe.Pointer"}, equalsTestCase{"taco", false, true, "which is not a unsafe.Pointer"}, equalsTestCase{equalsTestCase{}, false, true, "which is not a unsafe.Pointer"}, } t.checkTestCases(matcher, cases) } mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/error.go000066400000000000000000000030371321131462300334000ustar00rootroot00000000000000// Copyright 2011 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers // Error returns a matcher that matches non-nil values implementing the // built-in error interface for whom the return value of Error() matches the // supplied matcher. // // For example: // // err := errors.New("taco burrito") // // Error(Equals("taco burrito")) // matches err // Error(HasSubstr("taco")) // matches err // Error(HasSubstr("enchilada")) // doesn't match err // func Error(m Matcher) Matcher { return &errorMatcher{m} } type errorMatcher struct { wrappedMatcher Matcher } func (m *errorMatcher) Description() string { return "error " + m.wrappedMatcher.Description() } func (m *errorMatcher) Matches(c interface{}) error { // Make sure that c is an error. e, ok := c.(error) if !ok { return NewFatalError("which is not an error") } // Pass on the error text to the wrapped matcher. return m.wrappedMatcher.Matches(e.Error()) } error_test.go000066400000000000000000000047171321131462300343660ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglematchers// Copyright 2011 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers_test import ( "errors" . "github.com/smartystreets/assertions/internal/oglematchers" . "github.com/smartystreets/assertions/internal/ogletest" ) //////////////////////////////////////////////////////////////////////// // Helpers //////////////////////////////////////////////////////////////////////// type ErrorTest struct { matcherCalled bool suppliedCandidate interface{} wrappedError error matcher Matcher } func init() { RegisterTestSuite(&ErrorTest{}) } func (t *ErrorTest) SetUp(i *TestInfo) { wrapped := &fakeMatcher{ func(c interface{}) error { t.matcherCalled = true t.suppliedCandidate = c return t.wrappedError }, "is foo", } t.matcher = Error(wrapped) } func isFatal(err error) bool { _, isFatal := err.(*FatalError) return isFatal } //////////////////////////////////////////////////////////////////////// // Tests //////////////////////////////////////////////////////////////////////// func (t *ErrorTest) Description() { ExpectThat(t.matcher.Description(), Equals("error is foo")) } func (t *ErrorTest) CandidateIsNil() { err := t.matcher.Matches(nil) ExpectThat(t.matcherCalled, Equals(false)) ExpectThat(err.Error(), Equals("which is not an error")) ExpectTrue(isFatal(err)) } func (t *ErrorTest) CandidateIsString() { err := t.matcher.Matches("taco") ExpectThat(t.matcherCalled, Equals(false)) ExpectThat(err.Error(), Equals("which is not an error")) ExpectTrue(isFatal(err)) } func (t *ErrorTest) CallsWrappedMatcher() { candidate := errors.New("taco") t.matcher.Matches(candidate) ExpectThat(t.matcherCalled, Equals(true)) ExpectThat(t.suppliedCandidate, Equals("taco")) } func (t *ErrorTest) ReturnsWrappedMatcherResult() { t.wrappedError = errors.New("burrito") err := t.matcher.Matches(errors.New("")) ExpectThat(err, Equals(t.wrappedError)) } greater_or_equal.go000066400000000000000000000025551321131462300355140ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglematchers// Copyright 2011 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers import ( "fmt" "reflect" ) // GreaterOrEqual returns a matcher that matches integer, floating point, or // strings values v such that v >= x. Comparison is not defined between numeric // and string types, but is defined between all integer and floating point // types. // // x must itself be an integer, floating point, or string type; otherwise, // GreaterOrEqual will panic. func GreaterOrEqual(x interface{}) Matcher { desc := fmt.Sprintf("greater than or equal to %v", x) // Special case: make it clear that strings are strings. if reflect.TypeOf(x).Kind() == reflect.String { desc = fmt.Sprintf("greater than or equal to \"%s\"", x) } return transformDescription(Not(LessThan(x)), desc) } greater_or_equal_test.go000066400000000000000000001131341321131462300365470ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglematchers// Copyright 2011 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers_test import ( "math" . "github.com/smartystreets/assertions/internal/oglematchers" . "github.com/smartystreets/assertions/internal/ogletest" ) //////////////////////////////////////////////////////////////////////// // Helpers //////////////////////////////////////////////////////////////////////// type GreaterOrEqualTest struct { } func init() { RegisterTestSuite(&GreaterOrEqualTest{}) } type geTestCase struct { candidate interface{} expectedResult bool shouldBeFatal bool expectedError string } func (t *GreaterOrEqualTest) checkTestCases(matcher Matcher, cases []geTestCase) { for i, c := range cases { err := matcher.Matches(c.candidate) ExpectThat( (err == nil), Equals(c.expectedResult), "Case %d (candidate %v)", i, c.candidate) if err == nil { continue } _, isFatal := err.(*FatalError) ExpectEq( c.shouldBeFatal, isFatal, "Case %d (candidate %v)", i, c.candidate) ExpectThat( err, Error(Equals(c.expectedError)), "Case %d (candidate %v)", i, c.candidate) } } //////////////////////////////////////////////////////////////////////// // Integer literals //////////////////////////////////////////////////////////////////////// func (t *GreaterOrEqualTest) IntegerCandidateBadTypes() { matcher := GreaterOrEqual(int(-150)) cases := []geTestCase{ geTestCase{true, false, true, "which is not comparable"}, geTestCase{complex64(-151), false, true, "which is not comparable"}, geTestCase{complex128(-151), false, true, "which is not comparable"}, geTestCase{[...]int{-151}, false, true, "which is not comparable"}, geTestCase{make(chan int), false, true, "which is not comparable"}, geTestCase{func() {}, false, true, "which is not comparable"}, geTestCase{map[int]int{}, false, true, "which is not comparable"}, geTestCase{&geTestCase{}, false, true, "which is not comparable"}, geTestCase{make([]int, 0), false, true, "which is not comparable"}, geTestCase{"-151", false, true, "which is not comparable"}, geTestCase{geTestCase{}, false, true, "which is not comparable"}, } t.checkTestCases(matcher, cases) } func (t *GreaterOrEqualTest) FloatCandidateBadTypes() { matcher := GreaterOrEqual(float32(-150)) cases := []geTestCase{ geTestCase{true, false, true, "which is not comparable"}, geTestCase{complex64(-151), false, true, "which is not comparable"}, geTestCase{complex128(-151), false, true, "which is not comparable"}, geTestCase{[...]int{-151}, false, true, "which is not comparable"}, geTestCase{make(chan int), false, true, "which is not comparable"}, geTestCase{func() {}, false, true, "which is not comparable"}, geTestCase{map[int]int{}, false, true, "which is not comparable"}, geTestCase{&geTestCase{}, false, true, "which is not comparable"}, geTestCase{make([]int, 0), false, true, "which is not comparable"}, geTestCase{"-151", false, true, "which is not comparable"}, geTestCase{geTestCase{}, false, true, "which is not comparable"}, } t.checkTestCases(matcher, cases) } func (t *GreaterOrEqualTest) StringCandidateBadTypes() { matcher := GreaterOrEqual("17") cases := []geTestCase{ geTestCase{true, false, true, "which is not comparable"}, geTestCase{int(0), false, true, "which is not comparable"}, geTestCase{int8(0), false, true, "which is not comparable"}, geTestCase{int16(0), false, true, "which is not comparable"}, geTestCase{int32(0), false, true, "which is not comparable"}, geTestCase{int64(0), false, true, "which is not comparable"}, geTestCase{uint(0), false, true, "which is not comparable"}, geTestCase{uint8(0), false, true, "which is not comparable"}, geTestCase{uint16(0), false, true, "which is not comparable"}, geTestCase{uint32(0), false, true, "which is not comparable"}, geTestCase{uint64(0), false, true, "which is not comparable"}, geTestCase{float32(0), false, true, "which is not comparable"}, geTestCase{float64(0), false, true, "which is not comparable"}, geTestCase{complex64(-151), false, true, "which is not comparable"}, geTestCase{complex128(-151), false, true, "which is not comparable"}, geTestCase{[...]int{-151}, false, true, "which is not comparable"}, geTestCase{make(chan int), false, true, "which is not comparable"}, geTestCase{func() {}, false, true, "which is not comparable"}, geTestCase{map[int]int{}, false, true, "which is not comparable"}, geTestCase{&geTestCase{}, false, true, "which is not comparable"}, geTestCase{make([]int, 0), false, true, "which is not comparable"}, geTestCase{geTestCase{}, false, true, "which is not comparable"}, } t.checkTestCases(matcher, cases) } func (t *GreaterOrEqualTest) BadArgument() { panicked := false defer func() { ExpectThat(panicked, Equals(true)) }() defer func() { if r := recover(); r != nil { panicked = true } }() GreaterOrEqual(complex128(0)) } //////////////////////////////////////////////////////////////////////// // Integer literals //////////////////////////////////////////////////////////////////////// func (t *GreaterOrEqualTest) NegativeIntegerLiteral() { matcher := GreaterOrEqual(-150) desc := matcher.Description() expectedDesc := "greater than or equal to -150" ExpectThat(desc, Equals(expectedDesc)) cases := []geTestCase{ // Signed integers. geTestCase{-(1 << 30), false, false, ""}, geTestCase{-151, false, false, ""}, geTestCase{-150, true, false, ""}, geTestCase{0, true, false, ""}, geTestCase{17, true, false, ""}, geTestCase{int(-(1 << 30)), false, false, ""}, geTestCase{int(-151), false, false, ""}, geTestCase{int(-150), true, false, ""}, geTestCase{int(0), true, false, ""}, geTestCase{int(17), true, false, ""}, geTestCase{int8(-127), true, false, ""}, geTestCase{int8(0), true, false, ""}, geTestCase{int8(17), true, false, ""}, geTestCase{int16(-(1 << 14)), false, false, ""}, geTestCase{int16(-151), false, false, ""}, geTestCase{int16(-150), true, false, ""}, geTestCase{int16(0), true, false, ""}, geTestCase{int16(17), true, false, ""}, geTestCase{int32(-(1 << 30)), false, false, ""}, geTestCase{int32(-151), false, false, ""}, geTestCase{int32(-150), true, false, ""}, geTestCase{int32(0), true, false, ""}, geTestCase{int32(17), true, false, ""}, geTestCase{int64(-(1 << 30)), false, false, ""}, geTestCase{int64(-151), false, false, ""}, geTestCase{int64(-150), true, false, ""}, geTestCase{int64(0), true, false, ""}, geTestCase{int64(17), true, false, ""}, // Unsigned integers. geTestCase{uint((1 << 32) - 151), true, false, ""}, geTestCase{uint(0), true, false, ""}, geTestCase{uint(17), true, false, ""}, geTestCase{uint8(0), true, false, ""}, geTestCase{uint8(17), true, false, ""}, geTestCase{uint8(253), true, false, ""}, geTestCase{uint16((1 << 16) - 151), true, false, ""}, geTestCase{uint16(0), true, false, ""}, geTestCase{uint16(17), true, false, ""}, geTestCase{uint32((1 << 32) - 151), true, false, ""}, geTestCase{uint32(0), true, false, ""}, geTestCase{uint32(17), true, false, ""}, geTestCase{uint64((1 << 64) - 151), true, false, ""}, geTestCase{uint64(0), true, false, ""}, geTestCase{uint64(17), true, false, ""}, geTestCase{uintptr((1 << 64) - 151), true, false, ""}, geTestCase{uintptr(0), true, false, ""}, geTestCase{uintptr(17), true, false, ""}, // Floating point. geTestCase{float32(-(1 << 30)), false, false, ""}, geTestCase{float32(-151), false, false, ""}, geTestCase{float32(-150.1), false, false, ""}, geTestCase{float32(-150), true, false, ""}, geTestCase{float32(-149.9), true, false, ""}, geTestCase{float32(0), true, false, ""}, geTestCase{float32(17), true, false, ""}, geTestCase{float32(160), true, false, ""}, geTestCase{float64(-(1 << 30)), false, false, ""}, geTestCase{float64(-151), false, false, ""}, geTestCase{float64(-150.1), false, false, ""}, geTestCase{float64(-150), true, false, ""}, geTestCase{float64(-149.9), true, false, ""}, geTestCase{float64(0), true, false, ""}, geTestCase{float64(17), true, false, ""}, geTestCase{float64(160), true, false, ""}, } t.checkTestCases(matcher, cases) } func (t *GreaterOrEqualTest) ZeroIntegerLiteral() { matcher := GreaterOrEqual(0) desc := matcher.Description() expectedDesc := "greater than or equal to 0" ExpectThat(desc, Equals(expectedDesc)) cases := []geTestCase{ // Signed integers. geTestCase{-(1 << 30), false, false, ""}, geTestCase{-1, false, false, ""}, geTestCase{0, true, false, ""}, geTestCase{1, true, false, ""}, geTestCase{17, true, false, ""}, geTestCase{(1 << 30), true, false, ""}, geTestCase{int(-(1 << 30)), false, false, ""}, geTestCase{int(-1), false, false, ""}, geTestCase{int(0), true, false, ""}, geTestCase{int(1), true, false, ""}, geTestCase{int(17), true, false, ""}, geTestCase{int8(-1), false, false, ""}, geTestCase{int8(0), true, false, ""}, geTestCase{int8(1), true, false, ""}, geTestCase{int16(-(1 << 14)), false, false, ""}, geTestCase{int16(-1), false, false, ""}, geTestCase{int16(0), true, false, ""}, geTestCase{int16(1), true, false, ""}, geTestCase{int16(17), true, false, ""}, geTestCase{int32(-(1 << 30)), false, false, ""}, geTestCase{int32(-1), false, false, ""}, geTestCase{int32(0), true, false, ""}, geTestCase{int32(1), true, false, ""}, geTestCase{int32(17), true, false, ""}, geTestCase{int64(-(1 << 30)), false, false, ""}, geTestCase{int64(-1), false, false, ""}, geTestCase{int64(0), true, false, ""}, geTestCase{int64(1), true, false, ""}, geTestCase{int64(17), true, false, ""}, // Unsigned integers. geTestCase{uint((1 << 32) - 1), true, false, ""}, geTestCase{uint(0), true, false, ""}, geTestCase{uint(17), true, false, ""}, geTestCase{uint8(0), true, false, ""}, geTestCase{uint8(17), true, false, ""}, geTestCase{uint8(253), true, false, ""}, geTestCase{uint16((1 << 16) - 1), true, false, ""}, geTestCase{uint16(0), true, false, ""}, geTestCase{uint16(17), true, false, ""}, geTestCase{uint32((1 << 32) - 1), true, false, ""}, geTestCase{uint32(0), true, false, ""}, geTestCase{uint32(17), true, false, ""}, geTestCase{uint64((1 << 64) - 1), true, false, ""}, geTestCase{uint64(0), true, false, ""}, geTestCase{uint64(17), true, false, ""}, geTestCase{uintptr((1 << 64) - 1), true, false, ""}, geTestCase{uintptr(0), true, false, ""}, geTestCase{uintptr(17), true, false, ""}, // Floating point. geTestCase{float32(-(1 << 30)), false, false, ""}, geTestCase{float32(-1), false, false, ""}, geTestCase{float32(-0.1), false, false, ""}, geTestCase{float32(-0.0), true, false, ""}, geTestCase{float32(0), true, false, ""}, geTestCase{float32(0.1), true, false, ""}, geTestCase{float32(17), true, false, ""}, geTestCase{float32(160), true, false, ""}, geTestCase{float64(-(1 << 30)), false, false, ""}, geTestCase{float64(-1), false, false, ""}, geTestCase{float64(-0.1), false, false, ""}, geTestCase{float64(-0), true, false, ""}, geTestCase{float64(0), true, false, ""}, geTestCase{float64(17), true, false, ""}, geTestCase{float64(160), true, false, ""}, } t.checkTestCases(matcher, cases) } func (t *GreaterOrEqualTest) PositiveIntegerLiteral() { matcher := GreaterOrEqual(150) desc := matcher.Description() expectedDesc := "greater than or equal to 150" ExpectThat(desc, Equals(expectedDesc)) cases := []geTestCase{ // Signed integers. geTestCase{-1, false, false, ""}, geTestCase{149, false, false, ""}, geTestCase{150, true, false, ""}, geTestCase{151, true, false, ""}, geTestCase{int(-1), false, false, ""}, geTestCase{int(149), false, false, ""}, geTestCase{int(150), true, false, ""}, geTestCase{int(151), true, false, ""}, geTestCase{int8(-1), false, false, ""}, geTestCase{int8(0), false, false, ""}, geTestCase{int8(17), false, false, ""}, geTestCase{int8(127), false, false, ""}, geTestCase{int16(-1), false, false, ""}, geTestCase{int16(149), false, false, ""}, geTestCase{int16(150), true, false, ""}, geTestCase{int16(151), true, false, ""}, geTestCase{int32(-1), false, false, ""}, geTestCase{int32(149), false, false, ""}, geTestCase{int32(150), true, false, ""}, geTestCase{int32(151), true, false, ""}, geTestCase{int64(-1), false, false, ""}, geTestCase{int64(149), false, false, ""}, geTestCase{int64(150), true, false, ""}, geTestCase{int64(151), true, false, ""}, // Unsigned integers. geTestCase{uint(0), false, false, ""}, geTestCase{uint(149), false, false, ""}, geTestCase{uint(150), true, false, ""}, geTestCase{uint(151), true, false, ""}, geTestCase{uint8(0), false, false, ""}, geTestCase{uint8(127), false, false, ""}, geTestCase{uint16(0), false, false, ""}, geTestCase{uint16(149), false, false, ""}, geTestCase{uint16(150), true, false, ""}, geTestCase{uint16(151), true, false, ""}, geTestCase{uint32(0), false, false, ""}, geTestCase{uint32(149), false, false, ""}, geTestCase{uint32(150), true, false, ""}, geTestCase{uint32(151), true, false, ""}, geTestCase{uint64(0), false, false, ""}, geTestCase{uint64(149), false, false, ""}, geTestCase{uint64(150), true, false, ""}, geTestCase{uint64(151), true, false, ""}, geTestCase{uintptr(0), false, false, ""}, geTestCase{uintptr(149), false, false, ""}, geTestCase{uintptr(150), true, false, ""}, geTestCase{uintptr(151), true, false, ""}, // Floating point. geTestCase{float32(-1), false, false, ""}, geTestCase{float32(149), false, false, ""}, geTestCase{float32(149.9), false, false, ""}, geTestCase{float32(150), true, false, ""}, geTestCase{float32(150.1), true, false, ""}, geTestCase{float32(151), true, false, ""}, geTestCase{float64(-1), false, false, ""}, geTestCase{float64(149), false, false, ""}, geTestCase{float64(149.9), false, false, ""}, geTestCase{float64(150), true, false, ""}, geTestCase{float64(150.1), true, false, ""}, geTestCase{float64(151), true, false, ""}, } t.checkTestCases(matcher, cases) } //////////////////////////////////////////////////////////////////////// // Float literals //////////////////////////////////////////////////////////////////////// func (t *GreaterOrEqualTest) NegativeFloatLiteral() { matcher := GreaterOrEqual(-150.1) desc := matcher.Description() expectedDesc := "greater than or equal to -150.1" ExpectThat(desc, Equals(expectedDesc)) cases := []geTestCase{ // Signed integers. geTestCase{-(1 << 30), false, false, ""}, geTestCase{-151, false, false, ""}, geTestCase{-150, true, false, ""}, geTestCase{0, true, false, ""}, geTestCase{17, true, false, ""}, geTestCase{int(-(1 << 30)), false, false, ""}, geTestCase{int(-151), false, false, ""}, geTestCase{int(-150), true, false, ""}, geTestCase{int(0), true, false, ""}, geTestCase{int(17), true, false, ""}, geTestCase{int8(-127), true, false, ""}, geTestCase{int8(0), true, false, ""}, geTestCase{int8(17), true, false, ""}, geTestCase{int16(-(1 << 14)), false, false, ""}, geTestCase{int16(-151), false, false, ""}, geTestCase{int16(-150), true, false, ""}, geTestCase{int16(0), true, false, ""}, geTestCase{int16(17), true, false, ""}, geTestCase{int32(-(1 << 30)), false, false, ""}, geTestCase{int32(-151), false, false, ""}, geTestCase{int32(-150), true, false, ""}, geTestCase{int32(0), true, false, ""}, geTestCase{int32(17), true, false, ""}, geTestCase{int64(-(1 << 30)), false, false, ""}, geTestCase{int64(-151), false, false, ""}, geTestCase{int64(-150), true, false, ""}, geTestCase{int64(0), true, false, ""}, geTestCase{int64(17), true, false, ""}, // Unsigned integers. geTestCase{uint((1 << 32) - 151), true, false, ""}, geTestCase{uint(0), true, false, ""}, geTestCase{uint(17), true, false, ""}, geTestCase{uint8(0), true, false, ""}, geTestCase{uint8(17), true, false, ""}, geTestCase{uint8(253), true, false, ""}, geTestCase{uint16((1 << 16) - 151), true, false, ""}, geTestCase{uint16(0), true, false, ""}, geTestCase{uint16(17), true, false, ""}, geTestCase{uint32((1 << 32) - 151), true, false, ""}, geTestCase{uint32(0), true, false, ""}, geTestCase{uint32(17), true, false, ""}, geTestCase{uint64((1 << 64) - 151), true, false, ""}, geTestCase{uint64(0), true, false, ""}, geTestCase{uint64(17), true, false, ""}, geTestCase{uintptr((1 << 64) - 151), true, false, ""}, geTestCase{uintptr(0), true, false, ""}, geTestCase{uintptr(17), true, false, ""}, // Floating point. geTestCase{float32(-(1 << 30)), false, false, ""}, geTestCase{float32(-151), false, false, ""}, geTestCase{float32(-150.2), false, false, ""}, geTestCase{float32(-150.1), true, false, ""}, geTestCase{float32(-150), true, false, ""}, geTestCase{float32(0), true, false, ""}, geTestCase{float32(17), true, false, ""}, geTestCase{float32(160), true, false, ""}, geTestCase{float64(-(1 << 30)), false, false, ""}, geTestCase{float64(-151), false, false, ""}, geTestCase{float64(-150.2), false, false, ""}, geTestCase{float64(-150.1), true, false, ""}, geTestCase{float64(-150), true, false, ""}, geTestCase{float64(0), true, false, ""}, geTestCase{float64(17), true, false, ""}, geTestCase{float64(160), true, false, ""}, } t.checkTestCases(matcher, cases) } func (t *GreaterOrEqualTest) PositiveFloatLiteral() { matcher := GreaterOrEqual(149.9) desc := matcher.Description() expectedDesc := "greater than or equal to 149.9" ExpectThat(desc, Equals(expectedDesc)) cases := []geTestCase{ // Signed integers. geTestCase{-1, false, false, ""}, geTestCase{149, false, false, ""}, geTestCase{150, true, false, ""}, geTestCase{151, true, false, ""}, geTestCase{int(-1), false, false, ""}, geTestCase{int(149), false, false, ""}, geTestCase{int(150), true, false, ""}, geTestCase{int(151), true, false, ""}, geTestCase{int8(-1), false, false, ""}, geTestCase{int8(0), false, false, ""}, geTestCase{int8(17), false, false, ""}, geTestCase{int8(127), false, false, ""}, geTestCase{int16(-1), false, false, ""}, geTestCase{int16(149), false, false, ""}, geTestCase{int16(150), true, false, ""}, geTestCase{int16(151), true, false, ""}, geTestCase{int32(-1), false, false, ""}, geTestCase{int32(149), false, false, ""}, geTestCase{int32(150), true, false, ""}, geTestCase{int32(151), true, false, ""}, geTestCase{int64(-1), false, false, ""}, geTestCase{int64(149), false, false, ""}, geTestCase{int64(150), true, false, ""}, geTestCase{int64(151), true, false, ""}, // Unsigned integers. geTestCase{uint(0), false, false, ""}, geTestCase{uint(149), false, false, ""}, geTestCase{uint(150), true, false, ""}, geTestCase{uint(151), true, false, ""}, geTestCase{uint8(0), false, false, ""}, geTestCase{uint8(127), false, false, ""}, geTestCase{uint16(0), false, false, ""}, geTestCase{uint16(149), false, false, ""}, geTestCase{uint16(150), true, false, ""}, geTestCase{uint16(151), true, false, ""}, geTestCase{uint32(0), false, false, ""}, geTestCase{uint32(149), false, false, ""}, geTestCase{uint32(150), true, false, ""}, geTestCase{uint32(151), true, false, ""}, geTestCase{uint64(0), false, false, ""}, geTestCase{uint64(149), false, false, ""}, geTestCase{uint64(150), true, false, ""}, geTestCase{uint64(151), true, false, ""}, geTestCase{uintptr(0), false, false, ""}, geTestCase{uintptr(149), false, false, ""}, geTestCase{uintptr(150), true, false, ""}, geTestCase{uintptr(151), true, false, ""}, // Floating point. geTestCase{float32(-1), false, false, ""}, geTestCase{float32(149), false, false, ""}, geTestCase{float32(149.8), false, false, ""}, geTestCase{float32(149.9), true, false, ""}, geTestCase{float32(150), true, false, ""}, geTestCase{float32(151), true, false, ""}, geTestCase{float64(-1), false, false, ""}, geTestCase{float64(149), false, false, ""}, geTestCase{float64(149.8), false, false, ""}, geTestCase{float64(149.9), true, false, ""}, geTestCase{float64(150), true, false, ""}, geTestCase{float64(151), true, false, ""}, } t.checkTestCases(matcher, cases) } //////////////////////////////////////////////////////////////////////// // Subtle cases //////////////////////////////////////////////////////////////////////// func (t *GreaterOrEqualTest) Int64NotExactlyRepresentableBySinglePrecision() { // Single-precision floats don't have enough bits to represent the integers // near this one distinctly, so [2^25-1, 2^25+2] all receive the same value // and should be treated as equivalent when floats are in the mix. const kTwoTo25 = 1 << 25 matcher := GreaterOrEqual(int64(kTwoTo25 + 1)) desc := matcher.Description() expectedDesc := "greater than or equal to 33554433" ExpectThat(desc, Equals(expectedDesc)) cases := []geTestCase{ // Signed integers. geTestCase{-1, false, false, ""}, geTestCase{kTwoTo25 + 0, false, false, ""}, geTestCase{kTwoTo25 + 1, true, false, ""}, geTestCase{kTwoTo25 + 2, true, false, ""}, geTestCase{int(-1), false, false, ""}, geTestCase{int(kTwoTo25 + 0), false, false, ""}, geTestCase{int(kTwoTo25 + 1), true, false, ""}, geTestCase{int(kTwoTo25 + 2), true, false, ""}, geTestCase{int8(-1), false, false, ""}, geTestCase{int8(127), false, false, ""}, geTestCase{int16(-1), false, false, ""}, geTestCase{int16(0), false, false, ""}, geTestCase{int16(32767), false, false, ""}, geTestCase{int32(-1), false, false, ""}, geTestCase{int32(kTwoTo25 + 0), false, false, ""}, geTestCase{int32(kTwoTo25 + 1), true, false, ""}, geTestCase{int32(kTwoTo25 + 2), true, false, ""}, geTestCase{int64(-1), false, false, ""}, geTestCase{int64(kTwoTo25 + 0), false, false, ""}, geTestCase{int64(kTwoTo25 + 1), true, false, ""}, geTestCase{int64(kTwoTo25 + 2), true, false, ""}, // Unsigned integers. geTestCase{uint(0), false, false, ""}, geTestCase{uint(kTwoTo25 + 0), false, false, ""}, geTestCase{uint(kTwoTo25 + 1), true, false, ""}, geTestCase{uint(kTwoTo25 + 2), true, false, ""}, geTestCase{uint8(0), false, false, ""}, geTestCase{uint8(255), false, false, ""}, geTestCase{uint16(0), false, false, ""}, geTestCase{uint16(65535), false, false, ""}, geTestCase{uint32(0), false, false, ""}, geTestCase{uint32(kTwoTo25 + 0), false, false, ""}, geTestCase{uint32(kTwoTo25 + 1), true, false, ""}, geTestCase{uint32(kTwoTo25 + 2), true, false, ""}, geTestCase{uint64(0), false, false, ""}, geTestCase{uint64(kTwoTo25 + 0), false, false, ""}, geTestCase{uint64(kTwoTo25 + 1), true, false, ""}, geTestCase{uint64(kTwoTo25 + 2), true, false, ""}, geTestCase{uintptr(0), false, false, ""}, geTestCase{uintptr(kTwoTo25 + 0), false, false, ""}, geTestCase{uintptr(kTwoTo25 + 1), true, false, ""}, geTestCase{uintptr(kTwoTo25 + 2), true, false, ""}, // Floating point. geTestCase{float32(-1), false, false, ""}, geTestCase{float32(kTwoTo25 - 2), false, false, ""}, geTestCase{float32(kTwoTo25 - 1), true, false, ""}, geTestCase{float32(kTwoTo25 + 0), true, false, ""}, geTestCase{float32(kTwoTo25 + 1), true, false, ""}, geTestCase{float32(kTwoTo25 + 2), true, false, ""}, geTestCase{float32(kTwoTo25 + 3), true, false, ""}, geTestCase{float64(-1), false, false, ""}, geTestCase{float64(kTwoTo25 - 2), false, false, ""}, geTestCase{float64(kTwoTo25 - 1), false, false, ""}, geTestCase{float64(kTwoTo25 + 0), false, false, ""}, geTestCase{float64(kTwoTo25 + 1), true, false, ""}, geTestCase{float64(kTwoTo25 + 2), true, false, ""}, geTestCase{float64(kTwoTo25 + 3), true, false, ""}, } t.checkTestCases(matcher, cases) } func (t *GreaterOrEqualTest) Int64NotExactlyRepresentableByDoublePrecision() { // Double-precision floats don't have enough bits to represent the integers // near this one distinctly, so [2^54-1, 2^54+2] all receive the same value // and should be treated as equivalent when floats are in the mix. const kTwoTo54 = 1 << 54 matcher := GreaterOrEqual(int64(kTwoTo54 + 1)) desc := matcher.Description() expectedDesc := "greater than or equal to 18014398509481985" ExpectThat(desc, Equals(expectedDesc)) cases := []geTestCase{ // Signed integers. geTestCase{-1, false, false, ""}, geTestCase{1 << 30, false, false, ""}, geTestCase{int(-1), false, false, ""}, geTestCase{int(math.MaxInt32), false, false, ""}, geTestCase{int8(-1), false, false, ""}, geTestCase{int8(127), false, false, ""}, geTestCase{int16(-1), false, false, ""}, geTestCase{int16(0), false, false, ""}, geTestCase{int16(32767), false, false, ""}, geTestCase{int32(-1), false, false, ""}, geTestCase{int32(math.MaxInt32), false, false, ""}, geTestCase{int64(-1), false, false, ""}, geTestCase{int64(kTwoTo54 - 1), false, false, ""}, geTestCase{int64(kTwoTo54 + 0), false, false, ""}, geTestCase{int64(kTwoTo54 + 1), true, false, ""}, geTestCase{int64(kTwoTo54 + 2), true, false, ""}, // Unsigned integers. geTestCase{uint(0), false, false, ""}, geTestCase{uint(math.MaxUint32), false, false, ""}, geTestCase{uint8(0), false, false, ""}, geTestCase{uint8(255), false, false, ""}, geTestCase{uint16(0), false, false, ""}, geTestCase{uint16(65535), false, false, ""}, geTestCase{uint32(0), false, false, ""}, geTestCase{uint32(math.MaxUint32), false, false, ""}, geTestCase{uint64(0), false, false, ""}, geTestCase{uint64(kTwoTo54 - 1), false, false, ""}, geTestCase{uint64(kTwoTo54 + 0), false, false, ""}, geTestCase{uint64(kTwoTo54 + 1), true, false, ""}, geTestCase{uint64(kTwoTo54 + 2), true, false, ""}, geTestCase{uintptr(0), false, false, ""}, geTestCase{uintptr(kTwoTo54 - 1), false, false, ""}, geTestCase{uintptr(kTwoTo54 + 0), false, false, ""}, geTestCase{uintptr(kTwoTo54 + 1), true, false, ""}, geTestCase{uintptr(kTwoTo54 + 2), true, false, ""}, // Floating point. geTestCase{float64(-1), false, false, ""}, geTestCase{float64(kTwoTo54 - 2), false, false, ""}, geTestCase{float64(kTwoTo54 - 1), true, false, ""}, geTestCase{float64(kTwoTo54 + 0), true, false, ""}, geTestCase{float64(kTwoTo54 + 1), true, false, ""}, geTestCase{float64(kTwoTo54 + 2), true, false, ""}, geTestCase{float64(kTwoTo54 + 3), true, false, ""}, } t.checkTestCases(matcher, cases) } func (t *GreaterOrEqualTest) Uint64NotExactlyRepresentableBySinglePrecision() { // Single-precision floats don't have enough bits to represent the integers // near this one distinctly, so [2^25-1, 2^25+2] all receive the same value // and should be treated as equivalent when floats are in the mix. const kTwoTo25 = 1 << 25 matcher := GreaterOrEqual(uint64(kTwoTo25 + 1)) desc := matcher.Description() expectedDesc := "greater than or equal to 33554433" ExpectThat(desc, Equals(expectedDesc)) cases := []geTestCase{ // Signed integers. geTestCase{-1, false, false, ""}, geTestCase{kTwoTo25 + 0, false, false, ""}, geTestCase{kTwoTo25 + 1, true, false, ""}, geTestCase{kTwoTo25 + 2, true, false, ""}, geTestCase{int(-1), false, false, ""}, geTestCase{int(kTwoTo25 + 0), false, false, ""}, geTestCase{int(kTwoTo25 + 1), true, false, ""}, geTestCase{int(kTwoTo25 + 2), true, false, ""}, geTestCase{int8(-1), false, false, ""}, geTestCase{int8(127), false, false, ""}, geTestCase{int16(-1), false, false, ""}, geTestCase{int16(0), false, false, ""}, geTestCase{int16(32767), false, false, ""}, geTestCase{int32(-1), false, false, ""}, geTestCase{int32(kTwoTo25 + 0), false, false, ""}, geTestCase{int32(kTwoTo25 + 1), true, false, ""}, geTestCase{int32(kTwoTo25 + 2), true, false, ""}, geTestCase{int64(-1), false, false, ""}, geTestCase{int64(kTwoTo25 + 0), false, false, ""}, geTestCase{int64(kTwoTo25 + 1), true, false, ""}, geTestCase{int64(kTwoTo25 + 2), true, false, ""}, // Unsigned integers. geTestCase{uint(0), false, false, ""}, geTestCase{uint(kTwoTo25 + 0), false, false, ""}, geTestCase{uint(kTwoTo25 + 1), true, false, ""}, geTestCase{uint(kTwoTo25 + 2), true, false, ""}, geTestCase{uint8(0), false, false, ""}, geTestCase{uint8(255), false, false, ""}, geTestCase{uint16(0), false, false, ""}, geTestCase{uint16(65535), false, false, ""}, geTestCase{uint32(0), false, false, ""}, geTestCase{uint32(kTwoTo25 + 0), false, false, ""}, geTestCase{uint32(kTwoTo25 + 1), true, false, ""}, geTestCase{uint32(kTwoTo25 + 2), true, false, ""}, geTestCase{uint64(0), false, false, ""}, geTestCase{uint64(kTwoTo25 + 0), false, false, ""}, geTestCase{uint64(kTwoTo25 + 1), true, false, ""}, geTestCase{uint64(kTwoTo25 + 2), true, false, ""}, geTestCase{uintptr(0), false, false, ""}, geTestCase{uintptr(kTwoTo25 + 0), false, false, ""}, geTestCase{uintptr(kTwoTo25 + 1), true, false, ""}, geTestCase{uintptr(kTwoTo25 + 2), true, false, ""}, // Floating point. geTestCase{float32(-1), false, false, ""}, geTestCase{float32(kTwoTo25 - 2), false, false, ""}, geTestCase{float32(kTwoTo25 - 1), true, false, ""}, geTestCase{float32(kTwoTo25 + 0), true, false, ""}, geTestCase{float32(kTwoTo25 + 1), true, false, ""}, geTestCase{float32(kTwoTo25 + 2), true, false, ""}, geTestCase{float32(kTwoTo25 + 3), true, false, ""}, geTestCase{float64(-1), false, false, ""}, geTestCase{float64(kTwoTo25 - 2), false, false, ""}, geTestCase{float64(kTwoTo25 - 1), false, false, ""}, geTestCase{float64(kTwoTo25 + 0), false, false, ""}, geTestCase{float64(kTwoTo25 + 1), true, false, ""}, geTestCase{float64(kTwoTo25 + 2), true, false, ""}, geTestCase{float64(kTwoTo25 + 3), true, false, ""}, } t.checkTestCases(matcher, cases) } func (t *GreaterOrEqualTest) Uint64NotExactlyRepresentableByDoublePrecision() { // Double-precision floats don't have enough bits to represent the integers // near this one distinctly, so [2^54-1, 2^54+2] all receive the same value // and should be treated as equivalent when floats are in the mix. const kTwoTo54 = 1 << 54 matcher := GreaterOrEqual(uint64(kTwoTo54 + 1)) desc := matcher.Description() expectedDesc := "greater than or equal to 18014398509481985" ExpectThat(desc, Equals(expectedDesc)) cases := []geTestCase{ // Signed integers. geTestCase{-1, false, false, ""}, geTestCase{1 << 30, false, false, ""}, geTestCase{int(-1), false, false, ""}, geTestCase{int(math.MaxInt32), false, false, ""}, geTestCase{int8(-1), false, false, ""}, geTestCase{int8(127), false, false, ""}, geTestCase{int16(-1), false, false, ""}, geTestCase{int16(0), false, false, ""}, geTestCase{int16(32767), false, false, ""}, geTestCase{int32(-1), false, false, ""}, geTestCase{int32(math.MaxInt32), false, false, ""}, geTestCase{int64(-1), false, false, ""}, geTestCase{int64(kTwoTo54 - 1), false, false, ""}, geTestCase{int64(kTwoTo54 + 0), false, false, ""}, geTestCase{int64(kTwoTo54 + 1), true, false, ""}, geTestCase{int64(kTwoTo54 + 2), true, false, ""}, // Unsigned integers. geTestCase{uint(0), false, false, ""}, geTestCase{uint(math.MaxUint32), false, false, ""}, geTestCase{uint8(0), false, false, ""}, geTestCase{uint8(255), false, false, ""}, geTestCase{uint16(0), false, false, ""}, geTestCase{uint16(65535), false, false, ""}, geTestCase{uint32(0), false, false, ""}, geTestCase{uint32(math.MaxUint32), false, false, ""}, geTestCase{uint64(0), false, false, ""}, geTestCase{uint64(kTwoTo54 - 1), false, false, ""}, geTestCase{uint64(kTwoTo54 + 0), false, false, ""}, geTestCase{uint64(kTwoTo54 + 1), true, false, ""}, geTestCase{uint64(kTwoTo54 + 2), true, false, ""}, geTestCase{uintptr(0), false, false, ""}, geTestCase{uintptr(kTwoTo54 - 1), false, false, ""}, geTestCase{uintptr(kTwoTo54 + 0), false, false, ""}, geTestCase{uintptr(kTwoTo54 + 1), true, false, ""}, geTestCase{uintptr(kTwoTo54 + 2), true, false, ""}, // Floating point. geTestCase{float64(-1), false, false, ""}, geTestCase{float64(kTwoTo54 - 2), false, false, ""}, geTestCase{float64(kTwoTo54 - 1), true, false, ""}, geTestCase{float64(kTwoTo54 + 0), true, false, ""}, geTestCase{float64(kTwoTo54 + 1), true, false, ""}, geTestCase{float64(kTwoTo54 + 2), true, false, ""}, geTestCase{float64(kTwoTo54 + 3), true, false, ""}, } t.checkTestCases(matcher, cases) } func (t *GreaterOrEqualTest) Float32AboveExactIntegerRange() { // Single-precision floats don't have enough bits to represent the integers // near this one distinctly, so [2^25-1, 2^25+2] all receive the same value // and should be treated as equivalent when floats are in the mix. const kTwoTo25 = 1 << 25 matcher := GreaterOrEqual(float32(kTwoTo25 + 1)) desc := matcher.Description() expectedDesc := "greater than or equal to 3.3554432e+07" ExpectThat(desc, Equals(expectedDesc)) cases := []geTestCase{ // Signed integers. geTestCase{int64(-1), false, false, ""}, geTestCase{int64(kTwoTo25 - 2), false, false, ""}, geTestCase{int64(kTwoTo25 - 1), true, false, ""}, geTestCase{int64(kTwoTo25 + 0), true, false, ""}, geTestCase{int64(kTwoTo25 + 1), true, false, ""}, geTestCase{int64(kTwoTo25 + 2), true, false, ""}, geTestCase{int64(kTwoTo25 + 3), true, false, ""}, // Unsigned integers. geTestCase{uint64(0), false, false, ""}, geTestCase{uint64(kTwoTo25 - 2), false, false, ""}, geTestCase{uint64(kTwoTo25 - 1), true, false, ""}, geTestCase{uint64(kTwoTo25 + 0), true, false, ""}, geTestCase{uint64(kTwoTo25 + 1), true, false, ""}, geTestCase{uint64(kTwoTo25 + 2), true, false, ""}, geTestCase{uint64(kTwoTo25 + 3), true, false, ""}, // Floating point. geTestCase{float32(-1), false, false, ""}, geTestCase{float32(kTwoTo25 - 2), false, false, ""}, geTestCase{float32(kTwoTo25 - 1), true, false, ""}, geTestCase{float32(kTwoTo25 + 0), true, false, ""}, geTestCase{float32(kTwoTo25 + 1), true, false, ""}, geTestCase{float32(kTwoTo25 + 2), true, false, ""}, geTestCase{float32(kTwoTo25 + 3), true, false, ""}, geTestCase{float64(-1), false, false, ""}, geTestCase{float64(kTwoTo25 - 2), false, false, ""}, geTestCase{float64(kTwoTo25 - 1), true, false, ""}, geTestCase{float64(kTwoTo25 + 0), true, false, ""}, geTestCase{float64(kTwoTo25 + 1), true, false, ""}, geTestCase{float64(kTwoTo25 + 2), true, false, ""}, geTestCase{float64(kTwoTo25 + 3), true, false, ""}, } t.checkTestCases(matcher, cases) } func (t *GreaterOrEqualTest) Float64AboveExactIntegerRange() { // Double-precision floats don't have enough bits to represent the integers // near this one distinctly, so [2^54-1, 2^54+2] all receive the same value // and should be treated as equivalent when floats are in the mix. const kTwoTo54 = 1 << 54 matcher := GreaterOrEqual(float64(kTwoTo54 + 1)) desc := matcher.Description() expectedDesc := "greater than or equal to 1.8014398509481984e+16" ExpectThat(desc, Equals(expectedDesc)) cases := []geTestCase{ // Signed integers. geTestCase{int64(-1), false, false, ""}, geTestCase{int64(kTwoTo54 - 2), false, false, ""}, geTestCase{int64(kTwoTo54 - 1), true, false, ""}, geTestCase{int64(kTwoTo54 + 0), true, false, ""}, geTestCase{int64(kTwoTo54 + 1), true, false, ""}, geTestCase{int64(kTwoTo54 + 2), true, false, ""}, geTestCase{int64(kTwoTo54 + 3), true, false, ""}, // Unsigned integers. geTestCase{uint64(0), false, false, ""}, geTestCase{uint64(kTwoTo54 - 2), false, false, ""}, geTestCase{uint64(kTwoTo54 - 1), true, false, ""}, geTestCase{uint64(kTwoTo54 + 0), true, false, ""}, geTestCase{uint64(kTwoTo54 + 1), true, false, ""}, geTestCase{uint64(kTwoTo54 + 2), true, false, ""}, geTestCase{uint64(kTwoTo54 + 3), true, false, ""}, // Floating point. geTestCase{float64(-1), false, false, ""}, geTestCase{float64(kTwoTo54 - 2), false, false, ""}, geTestCase{float64(kTwoTo54 - 1), true, false, ""}, geTestCase{float64(kTwoTo54 + 0), true, false, ""}, geTestCase{float64(kTwoTo54 + 1), true, false, ""}, geTestCase{float64(kTwoTo54 + 2), true, false, ""}, geTestCase{float64(kTwoTo54 + 3), true, false, ""}, } t.checkTestCases(matcher, cases) } //////////////////////////////////////////////////////////////////////// // String literals //////////////////////////////////////////////////////////////////////// func (t *GreaterOrEqualTest) EmptyString() { matcher := GreaterOrEqual("") desc := matcher.Description() expectedDesc := "greater than or equal to \"\"" ExpectThat(desc, Equals(expectedDesc)) cases := []geTestCase{ geTestCase{"", true, false, ""}, geTestCase{"\x00", true, false, ""}, geTestCase{"a", true, false, ""}, geTestCase{"foo", true, false, ""}, } t.checkTestCases(matcher, cases) } func (t *GreaterOrEqualTest) SingleNullByte() { matcher := GreaterOrEqual("\x00") desc := matcher.Description() expectedDesc := "greater than or equal to \"\x00\"" ExpectThat(desc, Equals(expectedDesc)) cases := []geTestCase{ geTestCase{"", false, false, ""}, geTestCase{"\x00", true, false, ""}, geTestCase{"a", true, false, ""}, geTestCase{"foo", true, false, ""}, } t.checkTestCases(matcher, cases) } func (t *GreaterOrEqualTest) LongerString() { matcher := GreaterOrEqual("foo\x00") desc := matcher.Description() expectedDesc := "greater than or equal to \"foo\x00\"" ExpectThat(desc, Equals(expectedDesc)) cases := []geTestCase{ geTestCase{"", false, false, ""}, geTestCase{"\x00", false, false, ""}, geTestCase{"bar", false, false, ""}, geTestCase{"foo", false, false, ""}, geTestCase{"foo\x00", true, false, ""}, geTestCase{"fooa", true, false, ""}, geTestCase{"qux", true, false, ""}, } t.checkTestCases(matcher, cases) } greater_than.go000066400000000000000000000025161321131462300346340ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglematchers// Copyright 2011 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers import ( "fmt" "reflect" ) // GreaterThan returns a matcher that matches integer, floating point, or // strings values v such that v > x. Comparison is not defined between numeric // and string types, but is defined between all integer and floating point // types. // // x must itself be an integer, floating point, or string type; otherwise, // GreaterThan will panic. func GreaterThan(x interface{}) Matcher { desc := fmt.Sprintf("greater than %v", x) // Special case: make it clear that strings are strings. if reflect.TypeOf(x).Kind() == reflect.String { desc = fmt.Sprintf("greater than \"%s\"", x) } return transformDescription(Not(LessOrEqual(x)), desc) } greater_than_test.go000066400000000000000000001110501321131462300356650ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglematchers// Copyright 2011 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers_test import ( "math" . "github.com/smartystreets/assertions/internal/oglematchers" . "github.com/smartystreets/assertions/internal/ogletest" ) //////////////////////////////////////////////////////////////////////// // Helpers //////////////////////////////////////////////////////////////////////// type GreaterThanTest struct { } func init() { RegisterTestSuite(&GreaterThanTest{}) } type gtTestCase struct { candidate interface{} expectedResult bool shouldBeFatal bool expectedError string } func (t *GreaterThanTest) checkTestCases(matcher Matcher, cases []gtTestCase) { for i, c := range cases { err := matcher.Matches(c.candidate) ExpectThat( (err == nil), Equals(c.expectedResult), "Case %d (candidate %v)", i, c.candidate) if err == nil { continue } _, isFatal := err.(*FatalError) ExpectEq( c.shouldBeFatal, isFatal, "Case %d (candidate %v)", i, c.candidate) ExpectThat( err, Error(Equals(c.expectedError)), "Case %d (candidate %v)", i, c.candidate) } } //////////////////////////////////////////////////////////////////////// // Integer literals //////////////////////////////////////////////////////////////////////// func (t *GreaterThanTest) IntegerCandidateBadTypes() { matcher := GreaterThan(int(-150)) cases := []gtTestCase{ gtTestCase{true, false, true, "which is not comparable"}, gtTestCase{complex64(-151), false, true, "which is not comparable"}, gtTestCase{complex128(-151), false, true, "which is not comparable"}, gtTestCase{[...]int{-151}, false, true, "which is not comparable"}, gtTestCase{make(chan int), false, true, "which is not comparable"}, gtTestCase{func() {}, false, true, "which is not comparable"}, gtTestCase{map[int]int{}, false, true, "which is not comparable"}, gtTestCase{>TestCase{}, false, true, "which is not comparable"}, gtTestCase{make([]int, 0), false, true, "which is not comparable"}, gtTestCase{"-151", false, true, "which is not comparable"}, gtTestCase{gtTestCase{}, false, true, "which is not comparable"}, } t.checkTestCases(matcher, cases) } func (t *GreaterThanTest) FloatCandidateBadTypes() { matcher := GreaterThan(float32(-150)) cases := []gtTestCase{ gtTestCase{true, false, true, "which is not comparable"}, gtTestCase{complex64(-151), false, true, "which is not comparable"}, gtTestCase{complex128(-151), false, true, "which is not comparable"}, gtTestCase{[...]int{-151}, false, true, "which is not comparable"}, gtTestCase{make(chan int), false, true, "which is not comparable"}, gtTestCase{func() {}, false, true, "which is not comparable"}, gtTestCase{map[int]int{}, false, true, "which is not comparable"}, gtTestCase{>TestCase{}, false, true, "which is not comparable"}, gtTestCase{make([]int, 0), false, true, "which is not comparable"}, gtTestCase{"-151", false, true, "which is not comparable"}, gtTestCase{gtTestCase{}, false, true, "which is not comparable"}, } t.checkTestCases(matcher, cases) } func (t *GreaterThanTest) StringCandidateBadTypes() { matcher := GreaterThan("17") cases := []gtTestCase{ gtTestCase{true, false, true, "which is not comparable"}, gtTestCase{int(0), false, true, "which is not comparable"}, gtTestCase{int8(0), false, true, "which is not comparable"}, gtTestCase{int16(0), false, true, "which is not comparable"}, gtTestCase{int32(0), false, true, "which is not comparable"}, gtTestCase{int64(0), false, true, "which is not comparable"}, gtTestCase{uint(0), false, true, "which is not comparable"}, gtTestCase{uint8(0), false, true, "which is not comparable"}, gtTestCase{uint16(0), false, true, "which is not comparable"}, gtTestCase{uint32(0), false, true, "which is not comparable"}, gtTestCase{uint64(0), false, true, "which is not comparable"}, gtTestCase{float32(0), false, true, "which is not comparable"}, gtTestCase{float64(0), false, true, "which is not comparable"}, gtTestCase{complex64(-151), false, true, "which is not comparable"}, gtTestCase{complex128(-151), false, true, "which is not comparable"}, gtTestCase{[...]int{-151}, false, true, "which is not comparable"}, gtTestCase{make(chan int), false, true, "which is not comparable"}, gtTestCase{func() {}, false, true, "which is not comparable"}, gtTestCase{map[int]int{}, false, true, "which is not comparable"}, gtTestCase{>TestCase{}, false, true, "which is not comparable"}, gtTestCase{make([]int, 0), false, true, "which is not comparable"}, gtTestCase{gtTestCase{}, false, true, "which is not comparable"}, } t.checkTestCases(matcher, cases) } func (t *GreaterThanTest) BadArgument() { panicked := false defer func() { ExpectThat(panicked, Equals(true)) }() defer func() { if r := recover(); r != nil { panicked = true } }() GreaterThan(complex128(0)) } //////////////////////////////////////////////////////////////////////// // Integer literals //////////////////////////////////////////////////////////////////////// func (t *GreaterThanTest) NegativeIntegerLiteral() { matcher := GreaterThan(-150) desc := matcher.Description() expectedDesc := "greater than -150" ExpectThat(desc, Equals(expectedDesc)) cases := []gtTestCase{ // Signed integers. gtTestCase{-(1 << 30), false, false, ""}, gtTestCase{-151, false, false, ""}, gtTestCase{-150, false, false, ""}, gtTestCase{-149, true, false, ""}, gtTestCase{0, true, false, ""}, gtTestCase{17, true, false, ""}, gtTestCase{int(-(1 << 30)), false, false, ""}, gtTestCase{int(-151), false, false, ""}, gtTestCase{int(-150), false, false, ""}, gtTestCase{int(-149), true, false, ""}, gtTestCase{int(0), true, false, ""}, gtTestCase{int(17), true, false, ""}, gtTestCase{int8(-127), true, false, ""}, gtTestCase{int8(0), true, false, ""}, gtTestCase{int8(17), true, false, ""}, gtTestCase{int16(-(1 << 14)), false, false, ""}, gtTestCase{int16(-151), false, false, ""}, gtTestCase{int16(-150), false, false, ""}, gtTestCase{int16(-149), true, false, ""}, gtTestCase{int16(0), true, false, ""}, gtTestCase{int16(17), true, false, ""}, gtTestCase{int32(-(1 << 30)), false, false, ""}, gtTestCase{int32(-151), false, false, ""}, gtTestCase{int32(-150), false, false, ""}, gtTestCase{int32(-149), true, false, ""}, gtTestCase{int32(0), true, false, ""}, gtTestCase{int32(17), true, false, ""}, gtTestCase{int64(-(1 << 30)), false, false, ""}, gtTestCase{int64(-151), false, false, ""}, gtTestCase{int64(-150), false, false, ""}, gtTestCase{int64(-149), true, false, ""}, gtTestCase{int64(0), true, false, ""}, gtTestCase{int64(17), true, false, ""}, // Unsigned integers. gtTestCase{uint((1 << 32) - 151), true, false, ""}, gtTestCase{uint(0), true, false, ""}, gtTestCase{uint(17), true, false, ""}, gtTestCase{uint8(0), true, false, ""}, gtTestCase{uint8(17), true, false, ""}, gtTestCase{uint8(253), true, false, ""}, gtTestCase{uint16((1 << 16) - 151), true, false, ""}, gtTestCase{uint16(0), true, false, ""}, gtTestCase{uint16(17), true, false, ""}, gtTestCase{uint32((1 << 32) - 151), true, false, ""}, gtTestCase{uint32(0), true, false, ""}, gtTestCase{uint32(17), true, false, ""}, gtTestCase{uint64((1 << 64) - 151), true, false, ""}, gtTestCase{uint64(0), true, false, ""}, gtTestCase{uint64(17), true, false, ""}, // Floating point. gtTestCase{float32(-(1 << 30)), false, false, ""}, gtTestCase{float32(-151), false, false, ""}, gtTestCase{float32(-150.1), false, false, ""}, gtTestCase{float32(-150), false, false, ""}, gtTestCase{float32(-149.9), true, false, ""}, gtTestCase{float32(0), true, false, ""}, gtTestCase{float32(17), true, false, ""}, gtTestCase{float32(160), true, false, ""}, gtTestCase{float64(-(1 << 30)), false, false, ""}, gtTestCase{float64(-151), false, false, ""}, gtTestCase{float64(-150.1), false, false, ""}, gtTestCase{float64(-150), false, false, ""}, gtTestCase{float64(-149.9), true, false, ""}, gtTestCase{float64(0), true, false, ""}, gtTestCase{float64(17), true, false, ""}, gtTestCase{float64(160), true, false, ""}, } t.checkTestCases(matcher, cases) } func (t *GreaterThanTest) ZeroIntegerLiteral() { matcher := GreaterThan(0) desc := matcher.Description() expectedDesc := "greater than 0" ExpectThat(desc, Equals(expectedDesc)) cases := []gtTestCase{ // Signed integers. gtTestCase{-(1 << 30), false, false, ""}, gtTestCase{-1, false, false, ""}, gtTestCase{0, false, false, ""}, gtTestCase{1, true, false, ""}, gtTestCase{17, true, false, ""}, gtTestCase{(1 << 30), true, false, ""}, gtTestCase{int(-(1 << 30)), false, false, ""}, gtTestCase{int(-1), false, false, ""}, gtTestCase{int(0), false, false, ""}, gtTestCase{int(1), true, false, ""}, gtTestCase{int(17), true, false, ""}, gtTestCase{int8(-1), false, false, ""}, gtTestCase{int8(0), false, false, ""}, gtTestCase{int8(1), true, false, ""}, gtTestCase{int16(-(1 << 14)), false, false, ""}, gtTestCase{int16(-1), false, false, ""}, gtTestCase{int16(0), false, false, ""}, gtTestCase{int16(1), true, false, ""}, gtTestCase{int16(17), true, false, ""}, gtTestCase{int32(-(1 << 30)), false, false, ""}, gtTestCase{int32(-1), false, false, ""}, gtTestCase{int32(0), false, false, ""}, gtTestCase{int32(1), true, false, ""}, gtTestCase{int32(17), true, false, ""}, gtTestCase{int64(-(1 << 30)), false, false, ""}, gtTestCase{int64(-1), false, false, ""}, gtTestCase{int64(0), false, false, ""}, gtTestCase{int64(1), true, false, ""}, gtTestCase{int64(17), true, false, ""}, // Unsigned integers. gtTestCase{uint((1 << 32) - 1), true, false, ""}, gtTestCase{uint(0), false, false, ""}, gtTestCase{uint(1), true, false, ""}, gtTestCase{uint(17), true, false, ""}, gtTestCase{uint8(0), false, false, ""}, gtTestCase{uint8(1), true, false, ""}, gtTestCase{uint8(17), true, false, ""}, gtTestCase{uint8(253), true, false, ""}, gtTestCase{uint16((1 << 16) - 1), true, false, ""}, gtTestCase{uint16(0), false, false, ""}, gtTestCase{uint16(1), true, false, ""}, gtTestCase{uint16(17), true, false, ""}, gtTestCase{uint32((1 << 32) - 1), true, false, ""}, gtTestCase{uint32(0), false, false, ""}, gtTestCase{uint32(1), true, false, ""}, gtTestCase{uint32(17), true, false, ""}, gtTestCase{uint64((1 << 64) - 1), true, false, ""}, gtTestCase{uint64(0), false, false, ""}, gtTestCase{uint64(1), true, false, ""}, gtTestCase{uint64(17), true, false, ""}, // Floating point. gtTestCase{float32(-(1 << 30)), false, false, ""}, gtTestCase{float32(-1), false, false, ""}, gtTestCase{float32(-0.1), false, false, ""}, gtTestCase{float32(-0.0), false, false, ""}, gtTestCase{float32(0), false, false, ""}, gtTestCase{float32(0.1), true, false, ""}, gtTestCase{float32(17), true, false, ""}, gtTestCase{float32(160), true, false, ""}, gtTestCase{float64(-(1 << 30)), false, false, ""}, gtTestCase{float64(-1), false, false, ""}, gtTestCase{float64(-0.1), false, false, ""}, gtTestCase{float64(-0), false, false, ""}, gtTestCase{float64(0), false, false, ""}, gtTestCase{float64(0.1), true, false, ""}, gtTestCase{float64(17), true, false, ""}, gtTestCase{float64(160), true, false, ""}, } t.checkTestCases(matcher, cases) } func (t *GreaterThanTest) PositiveIntegerLiteral() { matcher := GreaterThan(150) desc := matcher.Description() expectedDesc := "greater than 150" ExpectThat(desc, Equals(expectedDesc)) cases := []gtTestCase{ // Signed integers. gtTestCase{-1, false, false, ""}, gtTestCase{149, false, false, ""}, gtTestCase{150, false, false, ""}, gtTestCase{151, true, false, ""}, gtTestCase{int(-1), false, false, ""}, gtTestCase{int(149), false, false, ""}, gtTestCase{int(150), false, false, ""}, gtTestCase{int(151), true, false, ""}, gtTestCase{int8(-1), false, false, ""}, gtTestCase{int8(0), false, false, ""}, gtTestCase{int8(17), false, false, ""}, gtTestCase{int8(127), false, false, ""}, gtTestCase{int16(-1), false, false, ""}, gtTestCase{int16(149), false, false, ""}, gtTestCase{int16(150), false, false, ""}, gtTestCase{int16(151), true, false, ""}, gtTestCase{int32(-1), false, false, ""}, gtTestCase{int32(149), false, false, ""}, gtTestCase{int32(150), false, false, ""}, gtTestCase{int32(151), true, false, ""}, gtTestCase{int64(-1), false, false, ""}, gtTestCase{int64(149), false, false, ""}, gtTestCase{int64(150), false, false, ""}, gtTestCase{int64(151), true, false, ""}, // Unsigned integers. gtTestCase{uint(0), false, false, ""}, gtTestCase{uint(149), false, false, ""}, gtTestCase{uint(150), false, false, ""}, gtTestCase{uint(151), true, false, ""}, gtTestCase{uint8(0), false, false, ""}, gtTestCase{uint8(127), false, false, ""}, gtTestCase{uint16(0), false, false, ""}, gtTestCase{uint16(149), false, false, ""}, gtTestCase{uint16(150), false, false, ""}, gtTestCase{uint16(151), true, false, ""}, gtTestCase{uint32(0), false, false, ""}, gtTestCase{uint32(149), false, false, ""}, gtTestCase{uint32(150), false, false, ""}, gtTestCase{uint32(151), true, false, ""}, gtTestCase{uint64(0), false, false, ""}, gtTestCase{uint64(149), false, false, ""}, gtTestCase{uint64(150), false, false, ""}, gtTestCase{uint64(151), true, false, ""}, // Floating point. gtTestCase{float32(-1), false, false, ""}, gtTestCase{float32(149), false, false, ""}, gtTestCase{float32(149.9), false, false, ""}, gtTestCase{float32(150), false, false, ""}, gtTestCase{float32(150.1), true, false, ""}, gtTestCase{float32(151), true, false, ""}, gtTestCase{float64(-1), false, false, ""}, gtTestCase{float64(149), false, false, ""}, gtTestCase{float64(149.9), false, false, ""}, gtTestCase{float64(150), false, false, ""}, gtTestCase{float64(150.1), true, false, ""}, gtTestCase{float64(151), true, false, ""}, } t.checkTestCases(matcher, cases) } //////////////////////////////////////////////////////////////////////// // Float literals //////////////////////////////////////////////////////////////////////// func (t *GreaterThanTest) NegativeFloatLiteral() { matcher := GreaterThan(-150.1) desc := matcher.Description() expectedDesc := "greater than -150.1" ExpectThat(desc, Equals(expectedDesc)) cases := []gtTestCase{ // Signed integers. gtTestCase{-(1 << 30), false, false, ""}, gtTestCase{-151, false, false, ""}, gtTestCase{-150.1, false, false, ""}, gtTestCase{-150, true, false, ""}, gtTestCase{-149, true, false, ""}, gtTestCase{0, true, false, ""}, gtTestCase{17, true, false, ""}, gtTestCase{int(-(1 << 30)), false, false, ""}, gtTestCase{int(-151), false, false, ""}, gtTestCase{int(-150), true, false, ""}, gtTestCase{int(-149), true, false, ""}, gtTestCase{int(0), true, false, ""}, gtTestCase{int(17), true, false, ""}, gtTestCase{int8(-127), true, false, ""}, gtTestCase{int8(0), true, false, ""}, gtTestCase{int8(17), true, false, ""}, gtTestCase{int16(-(1 << 14)), false, false, ""}, gtTestCase{int16(-151), false, false, ""}, gtTestCase{int16(-150), true, false, ""}, gtTestCase{int16(-149), true, false, ""}, gtTestCase{int16(0), true, false, ""}, gtTestCase{int16(17), true, false, ""}, gtTestCase{int32(-(1 << 30)), false, false, ""}, gtTestCase{int32(-151), false, false, ""}, gtTestCase{int32(-150), true, false, ""}, gtTestCase{int32(-149), true, false, ""}, gtTestCase{int32(0), true, false, ""}, gtTestCase{int32(17), true, false, ""}, gtTestCase{int64(-(1 << 30)), false, false, ""}, gtTestCase{int64(-151), false, false, ""}, gtTestCase{int64(-150), true, false, ""}, gtTestCase{int64(-149), true, false, ""}, gtTestCase{int64(0), true, false, ""}, gtTestCase{int64(17), true, false, ""}, // Unsigned integers. gtTestCase{uint((1 << 32) - 151), true, false, ""}, gtTestCase{uint(0), true, false, ""}, gtTestCase{uint(17), true, false, ""}, gtTestCase{uint8(0), true, false, ""}, gtTestCase{uint8(17), true, false, ""}, gtTestCase{uint8(253), true, false, ""}, gtTestCase{uint16((1 << 16) - 151), true, false, ""}, gtTestCase{uint16(0), true, false, ""}, gtTestCase{uint16(17), true, false, ""}, gtTestCase{uint32((1 << 32) - 151), true, false, ""}, gtTestCase{uint32(0), true, false, ""}, gtTestCase{uint32(17), true, false, ""}, gtTestCase{uint64((1 << 64) - 151), true, false, ""}, gtTestCase{uint64(0), true, false, ""}, gtTestCase{uint64(17), true, false, ""}, // Floating point. gtTestCase{float32(-(1 << 30)), false, false, ""}, gtTestCase{float32(-151), false, false, ""}, gtTestCase{float32(-150.2), false, false, ""}, gtTestCase{float32(-150.1), false, false, ""}, gtTestCase{float32(-150), true, false, ""}, gtTestCase{float32(0), true, false, ""}, gtTestCase{float32(17), true, false, ""}, gtTestCase{float32(160), true, false, ""}, gtTestCase{float64(-(1 << 30)), false, false, ""}, gtTestCase{float64(-151), false, false, ""}, gtTestCase{float64(-150.2), false, false, ""}, gtTestCase{float64(-150.1), false, false, ""}, gtTestCase{float64(-150), true, false, ""}, gtTestCase{float64(0), true, false, ""}, gtTestCase{float64(17), true, false, ""}, gtTestCase{float64(160), true, false, ""}, } t.checkTestCases(matcher, cases) } func (t *GreaterThanTest) PositiveFloatLiteral() { matcher := GreaterThan(149.9) desc := matcher.Description() expectedDesc := "greater than 149.9" ExpectThat(desc, Equals(expectedDesc)) cases := []gtTestCase{ // Signed integers. gtTestCase{-1, false, false, ""}, gtTestCase{149, false, false, ""}, gtTestCase{149.9, false, false, ""}, gtTestCase{150, true, false, ""}, gtTestCase{151, true, false, ""}, gtTestCase{int(-1), false, false, ""}, gtTestCase{int(149), false, false, ""}, gtTestCase{int(150), true, false, ""}, gtTestCase{int(151), true, false, ""}, gtTestCase{int8(-1), false, false, ""}, gtTestCase{int8(0), false, false, ""}, gtTestCase{int8(17), false, false, ""}, gtTestCase{int8(127), false, false, ""}, gtTestCase{int16(-1), false, false, ""}, gtTestCase{int16(149), false, false, ""}, gtTestCase{int16(150), true, false, ""}, gtTestCase{int16(151), true, false, ""}, gtTestCase{int32(-1), false, false, ""}, gtTestCase{int32(149), false, false, ""}, gtTestCase{int32(150), true, false, ""}, gtTestCase{int32(151), true, false, ""}, gtTestCase{int64(-1), false, false, ""}, gtTestCase{int64(149), false, false, ""}, gtTestCase{int64(150), true, false, ""}, gtTestCase{int64(151), true, false, ""}, // Unsigned integers. gtTestCase{uint(0), false, false, ""}, gtTestCase{uint(149), false, false, ""}, gtTestCase{uint(150), true, false, ""}, gtTestCase{uint(151), true, false, ""}, gtTestCase{uint8(0), false, false, ""}, gtTestCase{uint8(127), false, false, ""}, gtTestCase{uint16(0), false, false, ""}, gtTestCase{uint16(149), false, false, ""}, gtTestCase{uint16(150), true, false, ""}, gtTestCase{uint16(151), true, false, ""}, gtTestCase{uint32(0), false, false, ""}, gtTestCase{uint32(149), false, false, ""}, gtTestCase{uint32(150), true, false, ""}, gtTestCase{uint32(151), true, false, ""}, gtTestCase{uint64(0), false, false, ""}, gtTestCase{uint64(149), false, false, ""}, gtTestCase{uint64(150), true, false, ""}, gtTestCase{uint64(151), true, false, ""}, // Floating point. gtTestCase{float32(-1), false, false, ""}, gtTestCase{float32(149), false, false, ""}, gtTestCase{float32(149.8), false, false, ""}, gtTestCase{float32(149.9), false, false, ""}, gtTestCase{float32(150), true, false, ""}, gtTestCase{float32(151), true, false, ""}, gtTestCase{float64(-1), false, false, ""}, gtTestCase{float64(149), false, false, ""}, gtTestCase{float64(149.8), false, false, ""}, gtTestCase{float64(149.9), false, false, ""}, gtTestCase{float64(150), true, false, ""}, gtTestCase{float64(151), true, false, ""}, } t.checkTestCases(matcher, cases) } //////////////////////////////////////////////////////////////////////// // Subtle cases //////////////////////////////////////////////////////////////////////// func (t *GreaterThanTest) Int64NotExactlyRepresentableBySinglePrecision() { // Single-precision floats don't have enough bits to represent the integers // near this one distinctly, so [2^25-1, 2^25+2] all receive the same value // and should be treated as equivalent when floats are in the mix. const kTwoTo25 = 1 << 25 matcher := GreaterThan(int64(kTwoTo25 + 1)) desc := matcher.Description() expectedDesc := "greater than 33554433" ExpectThat(desc, Equals(expectedDesc)) cases := []gtTestCase{ // Signed integers. gtTestCase{-1, false, false, ""}, gtTestCase{kTwoTo25 + 0, false, false, ""}, gtTestCase{kTwoTo25 + 1, false, false, ""}, gtTestCase{kTwoTo25 + 2, true, false, ""}, gtTestCase{int(-1), false, false, ""}, gtTestCase{int(kTwoTo25 + 0), false, false, ""}, gtTestCase{int(kTwoTo25 + 1), false, false, ""}, gtTestCase{int(kTwoTo25 + 2), true, false, ""}, gtTestCase{int8(-1), false, false, ""}, gtTestCase{int8(127), false, false, ""}, gtTestCase{int16(-1), false, false, ""}, gtTestCase{int16(0), false, false, ""}, gtTestCase{int16(32767), false, false, ""}, gtTestCase{int32(-1), false, false, ""}, gtTestCase{int32(kTwoTo25 + 0), false, false, ""}, gtTestCase{int32(kTwoTo25 + 1), false, false, ""}, gtTestCase{int32(kTwoTo25 + 2), true, false, ""}, gtTestCase{int64(-1), false, false, ""}, gtTestCase{int64(kTwoTo25 + 0), false, false, ""}, gtTestCase{int64(kTwoTo25 + 1), false, false, ""}, gtTestCase{int64(kTwoTo25 + 2), true, false, ""}, // Unsigned integers. gtTestCase{uint(0), false, false, ""}, gtTestCase{uint(kTwoTo25 + 0), false, false, ""}, gtTestCase{uint(kTwoTo25 + 1), false, false, ""}, gtTestCase{uint(kTwoTo25 + 2), true, false, ""}, gtTestCase{uint8(0), false, false, ""}, gtTestCase{uint8(255), false, false, ""}, gtTestCase{uint16(0), false, false, ""}, gtTestCase{uint16(65535), false, false, ""}, gtTestCase{uint32(0), false, false, ""}, gtTestCase{uint32(kTwoTo25 + 0), false, false, ""}, gtTestCase{uint32(kTwoTo25 + 1), false, false, ""}, gtTestCase{uint32(kTwoTo25 + 2), true, false, ""}, gtTestCase{uint64(0), false, false, ""}, gtTestCase{uint64(kTwoTo25 + 0), false, false, ""}, gtTestCase{uint64(kTwoTo25 + 1), false, false, ""}, gtTestCase{uint64(kTwoTo25 + 2), true, false, ""}, // Floating point. gtTestCase{float32(-1), false, false, ""}, gtTestCase{float32(kTwoTo25 - 2), false, false, ""}, gtTestCase{float32(kTwoTo25 - 1), false, false, ""}, gtTestCase{float32(kTwoTo25 + 0), false, false, ""}, gtTestCase{float32(kTwoTo25 + 1), false, false, ""}, gtTestCase{float32(kTwoTo25 + 2), false, false, ""}, gtTestCase{float32(kTwoTo25 + 3), true, false, ""}, gtTestCase{float64(-1), false, false, ""}, gtTestCase{float64(kTwoTo25 - 2), false, false, ""}, gtTestCase{float64(kTwoTo25 - 1), false, false, ""}, gtTestCase{float64(kTwoTo25 + 0), false, false, ""}, gtTestCase{float64(kTwoTo25 + 1), false, false, ""}, gtTestCase{float64(kTwoTo25 + 2), true, false, ""}, gtTestCase{float64(kTwoTo25 + 3), true, false, ""}, } t.checkTestCases(matcher, cases) } func (t *GreaterThanTest) Int64NotExactlyRepresentableByDoublePrecision() { // Double-precision floats don't have enough bits to represent the integers // near this one distinctly, so [2^54-1, 2^54+2] all receive the same value // and should be treated as equivalent when floats are in the mix. const kTwoTo54 = 1 << 54 matcher := GreaterThan(int64(kTwoTo54 + 1)) desc := matcher.Description() expectedDesc := "greater than 18014398509481985" ExpectThat(desc, Equals(expectedDesc)) cases := []gtTestCase{ // Signed integers. gtTestCase{-1, false, false, ""}, gtTestCase{1 << 30, false, false, ""}, gtTestCase{int(-1), false, false, ""}, gtTestCase{int(math.MaxInt32), false, false, ""}, gtTestCase{int8(-1), false, false, ""}, gtTestCase{int8(127), false, false, ""}, gtTestCase{int16(-1), false, false, ""}, gtTestCase{int16(0), false, false, ""}, gtTestCase{int16(32767), false, false, ""}, gtTestCase{int32(-1), false, false, ""}, gtTestCase{int32(math.MaxInt32), false, false, ""}, gtTestCase{int64(-1), false, false, ""}, gtTestCase{int64(kTwoTo54 - 1), false, false, ""}, gtTestCase{int64(kTwoTo54 + 0), false, false, ""}, gtTestCase{int64(kTwoTo54 + 1), false, false, ""}, gtTestCase{int64(kTwoTo54 + 2), true, false, ""}, // Unsigned integers. gtTestCase{uint(0), false, false, ""}, gtTestCase{uint(math.MaxUint32), false, false, ""}, gtTestCase{uint8(0), false, false, ""}, gtTestCase{uint8(255), false, false, ""}, gtTestCase{uint16(0), false, false, ""}, gtTestCase{uint16(65535), false, false, ""}, gtTestCase{uint32(0), false, false, ""}, gtTestCase{uint32(math.MaxUint32), false, false, ""}, gtTestCase{uint64(0), false, false, ""}, gtTestCase{uint64(kTwoTo54 - 1), false, false, ""}, gtTestCase{uint64(kTwoTo54 + 0), false, false, ""}, gtTestCase{uint64(kTwoTo54 + 1), false, false, ""}, gtTestCase{uint64(kTwoTo54 + 2), true, false, ""}, // Floating point. gtTestCase{float64(-1), false, false, ""}, gtTestCase{float64(kTwoTo54 - 2), false, false, ""}, gtTestCase{float64(kTwoTo54 - 1), false, false, ""}, gtTestCase{float64(kTwoTo54 + 0), false, false, ""}, gtTestCase{float64(kTwoTo54 + 1), false, false, ""}, gtTestCase{float64(kTwoTo54 + 2), false, false, ""}, gtTestCase{float64(kTwoTo54 + 3), true, false, ""}, } t.checkTestCases(matcher, cases) } func (t *GreaterThanTest) Uint64NotExactlyRepresentableBySinglePrecision() { // Single-precision floats don't have enough bits to represent the integers // near this one distinctly, so [2^25-1, 2^25+2] all receive the same value // and should be treated as equivalent when floats are in the mix. const kTwoTo25 = 1 << 25 matcher := GreaterThan(uint64(kTwoTo25 + 1)) desc := matcher.Description() expectedDesc := "greater than 33554433" ExpectThat(desc, Equals(expectedDesc)) cases := []gtTestCase{ // Signed integers. gtTestCase{-1, false, false, ""}, gtTestCase{kTwoTo25 + 0, false, false, ""}, gtTestCase{kTwoTo25 + 1, false, false, ""}, gtTestCase{kTwoTo25 + 2, true, false, ""}, gtTestCase{int(-1), false, false, ""}, gtTestCase{int(kTwoTo25 + 0), false, false, ""}, gtTestCase{int(kTwoTo25 + 1), false, false, ""}, gtTestCase{int(kTwoTo25 + 2), true, false, ""}, gtTestCase{int8(-1), false, false, ""}, gtTestCase{int8(127), false, false, ""}, gtTestCase{int16(-1), false, false, ""}, gtTestCase{int16(0), false, false, ""}, gtTestCase{int16(32767), false, false, ""}, gtTestCase{int32(-1), false, false, ""}, gtTestCase{int32(kTwoTo25 + 0), false, false, ""}, gtTestCase{int32(kTwoTo25 + 1), false, false, ""}, gtTestCase{int32(kTwoTo25 + 2), true, false, ""}, gtTestCase{int64(-1), false, false, ""}, gtTestCase{int64(kTwoTo25 + 0), false, false, ""}, gtTestCase{int64(kTwoTo25 + 1), false, false, ""}, gtTestCase{int64(kTwoTo25 + 2), true, false, ""}, // Unsigned integers. gtTestCase{uint(0), false, false, ""}, gtTestCase{uint(kTwoTo25 + 0), false, false, ""}, gtTestCase{uint(kTwoTo25 + 1), false, false, ""}, gtTestCase{uint(kTwoTo25 + 2), true, false, ""}, gtTestCase{uint8(0), false, false, ""}, gtTestCase{uint8(255), false, false, ""}, gtTestCase{uint16(0), false, false, ""}, gtTestCase{uint16(65535), false, false, ""}, gtTestCase{uint32(0), false, false, ""}, gtTestCase{uint32(kTwoTo25 + 0), false, false, ""}, gtTestCase{uint32(kTwoTo25 + 1), false, false, ""}, gtTestCase{uint32(kTwoTo25 + 2), true, false, ""}, gtTestCase{uint64(0), false, false, ""}, gtTestCase{uint64(kTwoTo25 + 0), false, false, ""}, gtTestCase{uint64(kTwoTo25 + 1), false, false, ""}, gtTestCase{uint64(kTwoTo25 + 2), true, false, ""}, // Floating point. gtTestCase{float32(-1), false, false, ""}, gtTestCase{float32(kTwoTo25 - 2), false, false, ""}, gtTestCase{float32(kTwoTo25 - 1), false, false, ""}, gtTestCase{float32(kTwoTo25 + 0), false, false, ""}, gtTestCase{float32(kTwoTo25 + 1), false, false, ""}, gtTestCase{float32(kTwoTo25 + 2), false, false, ""}, gtTestCase{float32(kTwoTo25 + 3), true, false, ""}, gtTestCase{float64(-1), false, false, ""}, gtTestCase{float64(kTwoTo25 - 2), false, false, ""}, gtTestCase{float64(kTwoTo25 - 1), false, false, ""}, gtTestCase{float64(kTwoTo25 + 0), false, false, ""}, gtTestCase{float64(kTwoTo25 + 1), false, false, ""}, gtTestCase{float64(kTwoTo25 + 2), true, false, ""}, gtTestCase{float64(kTwoTo25 + 3), true, false, ""}, } t.checkTestCases(matcher, cases) } func (t *GreaterThanTest) Uint64NotExactlyRepresentableByDoublePrecision() { // Double-precision floats don't have enough bits to represent the integers // near this one distinctly, so [2^54-1, 2^54+2] all receive the same value // and should be treated as equivalent when floats are in the mix. const kTwoTo54 = 1 << 54 matcher := GreaterThan(uint64(kTwoTo54 + 1)) desc := matcher.Description() expectedDesc := "greater than 18014398509481985" ExpectThat(desc, Equals(expectedDesc)) cases := []gtTestCase{ // Signed integers. gtTestCase{-1, false, false, ""}, gtTestCase{1 << 30, false, false, ""}, gtTestCase{int(-1), false, false, ""}, gtTestCase{int(math.MaxInt32), false, false, ""}, gtTestCase{int8(-1), false, false, ""}, gtTestCase{int8(127), false, false, ""}, gtTestCase{int16(-1), false, false, ""}, gtTestCase{int16(0), false, false, ""}, gtTestCase{int16(32767), false, false, ""}, gtTestCase{int32(-1), false, false, ""}, gtTestCase{int32(math.MaxInt32), false, false, ""}, gtTestCase{int64(-1), false, false, ""}, gtTestCase{int64(kTwoTo54 - 1), false, false, ""}, gtTestCase{int64(kTwoTo54 + 0), false, false, ""}, gtTestCase{int64(kTwoTo54 + 1), false, false, ""}, gtTestCase{int64(kTwoTo54 + 2), true, false, ""}, // Unsigned integers. gtTestCase{uint(0), false, false, ""}, gtTestCase{uint(math.MaxUint32), false, false, ""}, gtTestCase{uint8(0), false, false, ""}, gtTestCase{uint8(255), false, false, ""}, gtTestCase{uint16(0), false, false, ""}, gtTestCase{uint16(65535), false, false, ""}, gtTestCase{uint32(0), false, false, ""}, gtTestCase{uint32(math.MaxUint32), false, false, ""}, gtTestCase{uint64(0), false, false, ""}, gtTestCase{uint64(kTwoTo54 - 1), false, false, ""}, gtTestCase{uint64(kTwoTo54 + 0), false, false, ""}, gtTestCase{uint64(kTwoTo54 + 1), false, false, ""}, gtTestCase{uint64(kTwoTo54 + 2), true, false, ""}, // Floating point. gtTestCase{float64(-1), false, false, ""}, gtTestCase{float64(kTwoTo54 - 2), false, false, ""}, gtTestCase{float64(kTwoTo54 - 1), false, false, ""}, gtTestCase{float64(kTwoTo54 + 0), false, false, ""}, gtTestCase{float64(kTwoTo54 + 1), false, false, ""}, gtTestCase{float64(kTwoTo54 + 2), false, false, ""}, gtTestCase{float64(kTwoTo54 + 3), true, false, ""}, } t.checkTestCases(matcher, cases) } func (t *GreaterThanTest) Float32AboveExactIntegerRange() { // Single-precision floats don't have enough bits to represent the integers // near this one distinctly, so [2^25-1, 2^25+2] all receive the same value // and should be treated as equivalent when floats are in the mix. const kTwoTo25 = 1 << 25 matcher := GreaterThan(float32(kTwoTo25 + 1)) desc := matcher.Description() expectedDesc := "greater than 3.3554432e+07" ExpectThat(desc, Equals(expectedDesc)) cases := []gtTestCase{ // Signed integers. gtTestCase{int64(-1), false, false, ""}, gtTestCase{int64(kTwoTo25 - 2), false, false, ""}, gtTestCase{int64(kTwoTo25 - 1), false, false, ""}, gtTestCase{int64(kTwoTo25 + 0), false, false, ""}, gtTestCase{int64(kTwoTo25 + 1), false, false, ""}, gtTestCase{int64(kTwoTo25 + 2), false, false, ""}, gtTestCase{int64(kTwoTo25 + 3), true, false, ""}, // Unsigned integers. gtTestCase{uint64(0), false, false, ""}, gtTestCase{uint64(kTwoTo25 - 2), false, false, ""}, gtTestCase{uint64(kTwoTo25 - 1), false, false, ""}, gtTestCase{uint64(kTwoTo25 + 0), false, false, ""}, gtTestCase{uint64(kTwoTo25 + 1), false, false, ""}, gtTestCase{uint64(kTwoTo25 + 2), false, false, ""}, gtTestCase{uint64(kTwoTo25 + 3), true, false, ""}, // Floating point. gtTestCase{float32(-1), false, false, ""}, gtTestCase{float32(kTwoTo25 - 2), false, false, ""}, gtTestCase{float32(kTwoTo25 - 1), false, false, ""}, gtTestCase{float32(kTwoTo25 + 0), false, false, ""}, gtTestCase{float32(kTwoTo25 + 1), false, false, ""}, gtTestCase{float32(kTwoTo25 + 2), false, false, ""}, gtTestCase{float32(kTwoTo25 + 3), true, false, ""}, gtTestCase{float64(-1), false, false, ""}, gtTestCase{float64(kTwoTo25 - 2), false, false, ""}, gtTestCase{float64(kTwoTo25 - 1), false, false, ""}, gtTestCase{float64(kTwoTo25 + 0), false, false, ""}, gtTestCase{float64(kTwoTo25 + 1), false, false, ""}, gtTestCase{float64(kTwoTo25 + 2), false, false, ""}, gtTestCase{float64(kTwoTo25 + 3), true, false, ""}, } t.checkTestCases(matcher, cases) } func (t *GreaterThanTest) Float64AboveExactIntegerRange() { // Double-precision floats don't have enough bits to represent the integers // near this one distinctly, so [2^54-1, 2^54+2] all receive the same value // and should be treated as equivalent when floats are in the mix. const kTwoTo54 = 1 << 54 matcher := GreaterThan(float64(kTwoTo54 + 1)) desc := matcher.Description() expectedDesc := "greater than 1.8014398509481984e+16" ExpectThat(desc, Equals(expectedDesc)) cases := []gtTestCase{ // Signed integers. gtTestCase{int64(-1), false, false, ""}, gtTestCase{int64(kTwoTo54 - 2), false, false, ""}, gtTestCase{int64(kTwoTo54 - 1), false, false, ""}, gtTestCase{int64(kTwoTo54 + 0), false, false, ""}, gtTestCase{int64(kTwoTo54 + 1), false, false, ""}, gtTestCase{int64(kTwoTo54 + 2), false, false, ""}, gtTestCase{int64(kTwoTo54 + 3), true, false, ""}, // Unsigned integers. gtTestCase{uint64(0), false, false, ""}, gtTestCase{uint64(kTwoTo54 - 2), false, false, ""}, gtTestCase{uint64(kTwoTo54 - 1), false, false, ""}, gtTestCase{uint64(kTwoTo54 + 0), false, false, ""}, gtTestCase{uint64(kTwoTo54 + 1), false, false, ""}, gtTestCase{uint64(kTwoTo54 + 2), false, false, ""}, gtTestCase{uint64(kTwoTo54 + 3), true, false, ""}, // Floating point. gtTestCase{float64(-1), false, false, ""}, gtTestCase{float64(kTwoTo54 - 2), false, false, ""}, gtTestCase{float64(kTwoTo54 - 1), false, false, ""}, gtTestCase{float64(kTwoTo54 + 0), false, false, ""}, gtTestCase{float64(kTwoTo54 + 1), false, false, ""}, gtTestCase{float64(kTwoTo54 + 2), false, false, ""}, gtTestCase{float64(kTwoTo54 + 3), true, false, ""}, } t.checkTestCases(matcher, cases) } //////////////////////////////////////////////////////////////////////// // String literals //////////////////////////////////////////////////////////////////////// func (t *GreaterThanTest) EmptyString() { matcher := GreaterThan("") desc := matcher.Description() expectedDesc := "greater than \"\"" ExpectThat(desc, Equals(expectedDesc)) cases := []gtTestCase{ gtTestCase{"", false, false, ""}, gtTestCase{"\x00", true, false, ""}, gtTestCase{"a", true, false, ""}, gtTestCase{"foo", true, false, ""}, } t.checkTestCases(matcher, cases) } func (t *GreaterThanTest) SingleNullByte() { matcher := GreaterThan("\x00") desc := matcher.Description() expectedDesc := "greater than \"\x00\"" ExpectThat(desc, Equals(expectedDesc)) cases := []gtTestCase{ gtTestCase{"", false, false, ""}, gtTestCase{"\x00", false, false, ""}, gtTestCase{"\x00\x00", true, false, ""}, gtTestCase{"a", true, false, ""}, gtTestCase{"foo", true, false, ""}, } t.checkTestCases(matcher, cases) } func (t *GreaterThanTest) LongerString() { matcher := GreaterThan("foo\x00") desc := matcher.Description() expectedDesc := "greater than \"foo\x00\"" ExpectThat(desc, Equals(expectedDesc)) cases := []gtTestCase{ gtTestCase{"", false, false, ""}, gtTestCase{"\x00", false, false, ""}, gtTestCase{"bar", false, false, ""}, gtTestCase{"foo", false, false, ""}, gtTestCase{"foo\x00", false, false, ""}, gtTestCase{"foo\x00\x00", true, false, ""}, gtTestCase{"fooa", true, false, ""}, gtTestCase{"qux", true, false, ""}, } t.checkTestCases(matcher, cases) } has_same_type_as.go000066400000000000000000000021521321131462300354710ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglematchers// Copyright 2015 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers import ( "fmt" "reflect" ) // HasSameTypeAs returns a matcher that matches values with exactly the same // type as the supplied prototype. func HasSameTypeAs(p interface{}) Matcher { expected := reflect.TypeOf(p) pred := func(c interface{}) error { actual := reflect.TypeOf(c) if actual != expected { return fmt.Errorf("which has type %v", actual) } return nil } return NewMatcher(pred, fmt.Sprintf("has type %v", expected)) } has_same_type_as_test.go000066400000000000000000000103401321131462300365260ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglematchers// Copyright 2015 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers_test import ( "io" "testing" . "github.com/smartystreets/assertions/internal/oglematchers" . "github.com/smartystreets/assertions/internal/ogletest" ) func TestHasSameTypeAs(t *testing.T) { RunTests(t) } //////////////////////////////////////////////////////////////////////// // Boilerplate //////////////////////////////////////////////////////////////////////// type HasSameTypeAsTest struct { } func init() { RegisterTestSuite(&HasSameTypeAsTest{}) } //////////////////////////////////////////////////////////////////////// // Tests //////////////////////////////////////////////////////////////////////// func (t *HasSameTypeAsTest) CandidateIsLiteralNil() { matcher := HasSameTypeAs(nil) var err error // Description ExpectEq("has type ", matcher.Description()) // Literal nil err = matcher.Matches(nil) ExpectEq(nil, err) // nil in interface variable var r io.Reader err = matcher.Matches(r) ExpectEq(nil, err) // int err = matcher.Matches(17) AssertNe(nil, err) ExpectThat(err, Error(Equals("which has type int"))) // string err = matcher.Matches("") AssertNe(nil, err) ExpectThat(err, Error(Equals("which has type string"))) // nil map var m map[string]string err = matcher.Matches(m) AssertNe(nil, err) ExpectThat(err, Error(Equals("which has type map[string]string"))) // Non-nil map m = make(map[string]string) err = matcher.Matches(m) AssertNe(nil, err) ExpectThat(err, Error(Equals("which has type map[string]string"))) } func (t *HasSameTypeAsTest) CandidateIsNilMap() { var m map[string]string matcher := HasSameTypeAs(m) var err error // Description ExpectEq("has type map[string]string", matcher.Description()) // nil map m = nil err = matcher.Matches(m) ExpectEq(nil, err) // Non-nil map m = make(map[string]string) err = matcher.Matches(m) ExpectEq(nil, err) // Literal nil err = matcher.Matches(nil) AssertNe(nil, err) ExpectThat(err, Error(Equals("which has type "))) // int err = matcher.Matches(17) AssertNe(nil, err) ExpectThat(err, Error(Equals("which has type int"))) // string err = matcher.Matches("") AssertNe(nil, err) ExpectThat(err, Error(Equals("which has type string"))) } func (t *HasSameTypeAsTest) CandidateIsNilInInterfaceVariable() { var r io.Reader matcher := HasSameTypeAs(r) var err error // Description ExpectEq("has type ", matcher.Description()) // nil in interface variable r = nil err = matcher.Matches(r) ExpectEq(nil, err) // Literal nil err = matcher.Matches(nil) ExpectEq(nil, err) // int err = matcher.Matches(17) AssertNe(nil, err) ExpectThat(err, Error(Equals("which has type int"))) } func (t *HasSameTypeAsTest) CandidateIsString() { matcher := HasSameTypeAs("") var err error // Description ExpectEq("has type string", matcher.Description()) // string err = matcher.Matches("taco") ExpectEq(nil, err) // string alias type Foo string err = matcher.Matches(Foo("taco")) ExpectThat(err, Error(MatchesRegexp("which has type .*Foo"))) // Literal nil err = matcher.Matches(nil) AssertNe(nil, err) ExpectThat(err, Error(Equals("which has type "))) // int err = matcher.Matches(17) AssertNe(nil, err) ExpectThat(err, Error(Equals("which has type int"))) } func (t *HasSameTypeAsTest) CandidateIsStringAlias() { type Foo string matcher := HasSameTypeAs(Foo("")) var err error // Description ExpectThat(matcher.Description(), MatchesRegexp("has type .*Foo")) // string alias err = matcher.Matches(Foo("taco")) ExpectEq(nil, err) // string err = matcher.Matches("taco") ExpectThat(err, Error(Equals("which has type string"))) } has_substr.go000066400000000000000000000023761321131462300343520ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglematchers// Copyright 2011 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers import ( "errors" "fmt" "reflect" "strings" ) // HasSubstr returns a matcher that matches strings containing s as a // substring. func HasSubstr(s string) Matcher { return NewMatcher( func(c interface{}) error { return hasSubstr(s, c) }, fmt.Sprintf("has substring \"%s\"", s)) } func hasSubstr(needle string, c interface{}) error { v := reflect.ValueOf(c) if v.Kind() != reflect.String { return NewFatalError("which is not a string") } // Perform the substring search. haystack := v.String() if strings.Contains(haystack, needle) { return nil } return errors.New("") } has_substr_test.go000066400000000000000000000050201321131462300353760ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglematchers// Copyright 2011 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers_test import ( . "github.com/smartystreets/assertions/internal/oglematchers" . "github.com/smartystreets/assertions/internal/ogletest" ) //////////////////////////////////////////////////////////////////////// // Helpers //////////////////////////////////////////////////////////////////////// type HasSubstrTest struct { } func init() { RegisterTestSuite(&HasSubstrTest{}) } //////////////////////////////////////////////////////////////////////// // Tests //////////////////////////////////////////////////////////////////////// func (t *HasSubstrTest) Description() { matcher := HasSubstr("taco") ExpectThat(matcher.Description(), Equals("has substring \"taco\"")) } func (t *HasSubstrTest) CandidateIsNil() { matcher := HasSubstr("") err := matcher.Matches(nil) ExpectThat(err, Error(Equals("which is not a string"))) ExpectTrue(isFatal(err)) } func (t *HasSubstrTest) CandidateIsInteger() { matcher := HasSubstr("") err := matcher.Matches(17) ExpectThat(err, Error(Equals("which is not a string"))) ExpectTrue(isFatal(err)) } func (t *HasSubstrTest) CandidateIsByteSlice() { matcher := HasSubstr("") err := matcher.Matches([]byte{17}) ExpectThat(err, Error(Equals("which is not a string"))) ExpectTrue(isFatal(err)) } func (t *HasSubstrTest) CandidateDoesntHaveSubstring() { matcher := HasSubstr("taco") err := matcher.Matches("tac") ExpectThat(err, Error(Equals(""))) ExpectFalse(isFatal(err)) } func (t *HasSubstrTest) CandidateEqualsArg() { matcher := HasSubstr("taco") err := matcher.Matches("taco") ExpectThat(err, Equals(nil)) } func (t *HasSubstrTest) CandidateHasProperSubstring() { matcher := HasSubstr("taco") err := matcher.Matches("burritos and tacos") ExpectThat(err, Equals(nil)) } func (t *HasSubstrTest) EmptyStringIsAlwaysSubString() { matcher := HasSubstr("") err := matcher.Matches("asdf") ExpectThat(err, Equals(nil)) } identical_to.go000066400000000000000000000066031321131462300346300ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglematchers// Copyright 2012 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers import ( "errors" "fmt" "reflect" ) // Is the type comparable according to the definition here? // // http://weekly.golang.org/doc/go_spec.html#Comparison_operators // func isComparable(t reflect.Type) bool { switch t.Kind() { case reflect.Array: return isComparable(t.Elem()) case reflect.Struct: for i := 0; i < t.NumField(); i++ { if !isComparable(t.Field(i).Type) { return false } } return true case reflect.Slice, reflect.Map, reflect.Func: return false } return true } // Should the supplied type be allowed as an argument to IdenticalTo? func isLegalForIdenticalTo(t reflect.Type) (bool, error) { // Allow the zero type. if t == nil { return true, nil } // Reference types are always okay; we compare pointers. switch t.Kind() { case reflect.Slice, reflect.Map, reflect.Func, reflect.Chan: return true, nil } // Reject other non-comparable types. if !isComparable(t) { return false, errors.New(fmt.Sprintf("%v is not comparable", t)) } return true, nil } // IdenticalTo(x) returns a matcher that matches values v with type identical // to x such that: // // 1. If v and x are of a reference type (slice, map, function, channel), then // they are either both nil or are references to the same object. // // 2. Otherwise, if v and x are not of a reference type but have a valid type, // then v == x. // // If v and x are both the invalid type (which results from the predeclared nil // value, or from nil interface variables), then the matcher is satisfied. // // This function will panic if x is of a value type that is not comparable. For // example, x cannot be an array of functions. func IdenticalTo(x interface{}) Matcher { t := reflect.TypeOf(x) // Reject illegal arguments. if ok, err := isLegalForIdenticalTo(t); !ok { panic("IdenticalTo: " + err.Error()) } return &identicalToMatcher{x} } type identicalToMatcher struct { x interface{} } func (m *identicalToMatcher) Description() string { t := reflect.TypeOf(m.x) return fmt.Sprintf("identical to <%v> %v", t, m.x) } func (m *identicalToMatcher) Matches(c interface{}) error { // Make sure the candidate's type is correct. t := reflect.TypeOf(m.x) if ct := reflect.TypeOf(c); t != ct { return NewFatalError(fmt.Sprintf("which is of type %v", ct)) } // Special case: two values of the invalid type are always identical. if t == nil { return nil } // Handle reference types. switch t.Kind() { case reflect.Slice, reflect.Map, reflect.Func, reflect.Chan: xv := reflect.ValueOf(m.x) cv := reflect.ValueOf(c) if xv.Pointer() == cv.Pointer() { return nil } return errors.New("which is not an identical reference") } // Are the values equal? if m.x == c { return nil } return errors.New("") } identical_to_test.go000066400000000000000000000476671321131462300357060ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglematchers// Copyright 2012 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers_test import ( . "github.com/smartystreets/assertions/internal/oglematchers" . "github.com/smartystreets/assertions/internal/ogletest" "fmt" "io" "unsafe" ) //////////////////////////////////////////////////////////////////////// // Helpers //////////////////////////////////////////////////////////////////////// type IdenticalToTest struct { } func init() { RegisterTestSuite(&IdenticalToTest{}) } //////////////////////////////////////////////////////////////////////// // Tests //////////////////////////////////////////////////////////////////////// func (t *IdenticalToTest) TypesNotIdentical() { var m Matcher var err error type intAlias int // Type alias expected value m = IdenticalTo(intAlias(17)) err = m.Matches(int(17)) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type int"))) // Type alias candidate m = IdenticalTo(int(17)) err = m.Matches(intAlias(17)) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type oglematchers_test.intAlias"))) // int and uint m = IdenticalTo(int(17)) err = m.Matches(uint(17)) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type uint"))) } func (t *IdenticalToTest) PredeclaredNilIdentifier() { var m Matcher var err error // Nil literal m = IdenticalTo(nil) err = m.Matches(nil) ExpectEq(nil, err) // Zero interface var (which is the same as above since IdenticalTo takes an // interface{} as an arg) var nilReader io.Reader var nilWriter io.Writer m = IdenticalTo(nilReader) err = m.Matches(nilWriter) ExpectEq(nil, err) // Typed nil value. m = IdenticalTo(nil) err = m.Matches((chan int)(nil)) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type chan int"))) // Non-nil value. m = IdenticalTo(nil) err = m.Matches("taco") ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type string"))) } func (t *IdenticalToTest) Slices() { var m Matcher var err error // Nil expected value m = IdenticalTo(([]int)(nil)) ExpectEq("identical to <[]int> []", m.Description()) err = m.Matches(([]int)(nil)) ExpectEq(nil, err) err = m.Matches([]int{}) ExpectThat(err, Error(Equals("which is not an identical reference"))) // Non-nil expected value o1 := make([]int, 1) o2 := make([]int, 1) m = IdenticalTo(o1) ExpectEq(fmt.Sprintf("identical to <[]int> %v", o1), m.Description()) err = m.Matches(o1) ExpectEq(nil, err) err = m.Matches(o2) ExpectThat(err, Error(Equals("which is not an identical reference"))) } func (t *IdenticalToTest) Maps() { var m Matcher var err error // Nil expected value m = IdenticalTo((map[int]int)(nil)) ExpectEq("identical to map[]", m.Description()) err = m.Matches((map[int]int)(nil)) ExpectEq(nil, err) err = m.Matches(map[int]int{}) ExpectThat(err, Error(Equals("which is not an identical reference"))) // Non-nil expected value o1 := map[int]int{} o2 := map[int]int{} m = IdenticalTo(o1) ExpectEq(fmt.Sprintf("identical to %v", o1), m.Description()) err = m.Matches(o1) ExpectEq(nil, err) err = m.Matches(o2) ExpectThat(err, Error(Equals("which is not an identical reference"))) } func (t *IdenticalToTest) Functions() { var m Matcher var err error // Nil expected value m = IdenticalTo((func())(nil)) ExpectEq("identical to ", m.Description()) err = m.Matches((func())(nil)) ExpectEq(nil, err) err = m.Matches(func(){}) ExpectThat(err, Error(Equals("which is not an identical reference"))) // Non-nil expected value o1 := func() {} o2 := func() {} m = IdenticalTo(o1) ExpectEq(fmt.Sprintf("identical to %v", o1), m.Description()) err = m.Matches(o1) ExpectEq(nil, err) err = m.Matches(o2) ExpectThat(err, Error(Equals("which is not an identical reference"))) } func (t *IdenticalToTest) Channels() { var m Matcher var err error // Nil expected value m = IdenticalTo((chan int)(nil)) ExpectEq("identical to ", m.Description()) err = m.Matches((chan int)(nil)) ExpectEq(nil, err) err = m.Matches(make(chan int)) ExpectThat(err, Error(Equals("which is not an identical reference"))) // Non-nil expected value o1 := make(chan int) o2 := make(chan int) m = IdenticalTo(o1) ExpectEq(fmt.Sprintf("identical to %v", o1), m.Description()) err = m.Matches(o1) ExpectEq(nil, err) err = m.Matches(o2) ExpectThat(err, Error(Equals("which is not an identical reference"))) } func (t *IdenticalToTest) Bools() { var m Matcher var err error // false m = IdenticalTo(false) ExpectEq("identical to false", m.Description()) err = m.Matches(false) ExpectEq(nil, err) err = m.Matches(true) ExpectThat(err, Error(Equals(""))) // true m = IdenticalTo(true) ExpectEq("identical to true", m.Description()) err = m.Matches(false) ExpectThat(err, Error(Equals(""))) err = m.Matches(true) ExpectEq(nil, err) } func (t *IdenticalToTest) Ints() { var m Matcher var err error m = IdenticalTo(int(17)) ExpectEq("identical to 17", m.Description()) // Identical value err = m.Matches(int(17)) ExpectEq(nil, err) // Type alias type myType int err = m.Matches(myType(17)) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type oglematchers_test.myType"))) // Completely wrong type err = m.Matches(int32(17)) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type int32"))) } func (t *IdenticalToTest) Int8s() { var m Matcher var err error m = IdenticalTo(int8(17)) ExpectEq("identical to 17", m.Description()) // Identical value err = m.Matches(int8(17)) ExpectEq(nil, err) // Type alias type myType int8 err = m.Matches(myType(17)) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type oglematchers_test.myType"))) // Completely wrong type err = m.Matches(int32(17)) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type int32"))) } func (t *IdenticalToTest) Int16s() { var m Matcher var err error m = IdenticalTo(int16(17)) ExpectEq("identical to 17", m.Description()) // Identical value err = m.Matches(int16(17)) ExpectEq(nil, err) // Type alias type myType int16 err = m.Matches(myType(17)) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type oglematchers_test.myType"))) // Completely wrong type err = m.Matches(int32(17)) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type int32"))) } func (t *IdenticalToTest) Int32s() { var m Matcher var err error m = IdenticalTo(int32(17)) ExpectEq("identical to 17", m.Description()) // Identical value err = m.Matches(int32(17)) ExpectEq(nil, err) // Type alias type myType int32 err = m.Matches(myType(17)) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type oglematchers_test.myType"))) // Completely wrong type err = m.Matches(int16(17)) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type int16"))) } func (t *IdenticalToTest) Int64s() { var m Matcher var err error m = IdenticalTo(int64(17)) ExpectEq("identical to 17", m.Description()) // Identical value err = m.Matches(int64(17)) ExpectEq(nil, err) // Type alias type myType int64 err = m.Matches(myType(17)) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type oglematchers_test.myType"))) // Completely wrong type err = m.Matches(int32(17)) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type int32"))) } func (t *IdenticalToTest) Uints() { var m Matcher var err error m = IdenticalTo(uint(17)) ExpectEq("identical to 17", m.Description()) // Identical value err = m.Matches(uint(17)) ExpectEq(nil, err) // Type alias type myType uint err = m.Matches(myType(17)) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type oglematchers_test.myType"))) // Completely wrong type err = m.Matches(int32(17)) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type int32"))) } func (t *IdenticalToTest) Uint8s() { var m Matcher var err error m = IdenticalTo(uint8(17)) ExpectEq("identical to 17", m.Description()) // Identical value err = m.Matches(uint8(17)) ExpectEq(nil, err) // Type alias type myType uint8 err = m.Matches(myType(17)) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type oglematchers_test.myType"))) // Completely wrong type err = m.Matches(int32(17)) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type int32"))) } func (t *IdenticalToTest) Uint16s() { var m Matcher var err error m = IdenticalTo(uint16(17)) ExpectEq("identical to 17", m.Description()) // Identical value err = m.Matches(uint16(17)) ExpectEq(nil, err) // Type alias type myType uint16 err = m.Matches(myType(17)) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type oglematchers_test.myType"))) // Completely wrong type err = m.Matches(int32(17)) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type int32"))) } func (t *IdenticalToTest) Uint32s() { var m Matcher var err error m = IdenticalTo(uint32(17)) ExpectEq("identical to 17", m.Description()) // Identical value err = m.Matches(uint32(17)) ExpectEq(nil, err) // Type alias type myType uint32 err = m.Matches(myType(17)) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type oglematchers_test.myType"))) // Completely wrong type err = m.Matches(int32(17)) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type int32"))) } func (t *IdenticalToTest) Uint64s() { var m Matcher var err error m = IdenticalTo(uint64(17)) ExpectEq("identical to 17", m.Description()) // Identical value err = m.Matches(uint64(17)) ExpectEq(nil, err) // Type alias type myType uint64 err = m.Matches(myType(17)) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type oglematchers_test.myType"))) // Completely wrong type err = m.Matches(int32(17)) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type int32"))) } func (t *IdenticalToTest) Uintptrs() { var m Matcher var err error m = IdenticalTo(uintptr(17)) ExpectEq("identical to 17", m.Description()) // Identical value err = m.Matches(uintptr(17)) ExpectEq(nil, err) // Type alias type myType uintptr err = m.Matches(myType(17)) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type oglematchers_test.myType"))) // Completely wrong type err = m.Matches(int32(17)) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type int32"))) } func (t *IdenticalToTest) Float32s() { var m Matcher var err error m = IdenticalTo(float32(17)) ExpectEq("identical to 17", m.Description()) // Identical value err = m.Matches(float32(17)) ExpectEq(nil, err) // Type alias type myType float32 err = m.Matches(myType(17)) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type oglematchers_test.myType"))) // Completely wrong type err = m.Matches(int32(17)) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type int32"))) } func (t *IdenticalToTest) Float64s() { var m Matcher var err error m = IdenticalTo(float64(17)) ExpectEq("identical to 17", m.Description()) // Identical value err = m.Matches(float64(17)) ExpectEq(nil, err) // Type alias type myType float64 err = m.Matches(myType(17)) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type oglematchers_test.myType"))) // Completely wrong type err = m.Matches(int32(17)) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type int32"))) } func (t *IdenticalToTest) Complex64s() { var m Matcher var err error m = IdenticalTo(complex64(17)) ExpectEq("identical to (17+0i)", m.Description()) // Identical value err = m.Matches(complex64(17)) ExpectEq(nil, err) // Type alias type myType complex64 err = m.Matches(myType(17)) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type oglematchers_test.myType"))) // Completely wrong type err = m.Matches(int32(17)) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type int32"))) } func (t *IdenticalToTest) Complex128s() { var m Matcher var err error m = IdenticalTo(complex128(17)) ExpectEq("identical to (17+0i)", m.Description()) // Identical value err = m.Matches(complex128(17)) ExpectEq(nil, err) // Type alias type myType complex128 err = m.Matches(myType(17)) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type oglematchers_test.myType"))) // Completely wrong type err = m.Matches(int32(17)) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type int32"))) } func (t *IdenticalToTest) EmptyComparableArrays() { var m Matcher var err error m = IdenticalTo([0]int{}) ExpectEq("identical to <[0]int> []", m.Description()) // Identical value err = m.Matches([0]int{}) ExpectEq(nil, err) // Length too long err = m.Matches([1]int{17}) ExpectThat(err, Error(Equals("which is of type [1]int"))) // Element type alias type myType int err = m.Matches([0]myType{}) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type [0]oglematchers_test.myType"))) // Completely wrong element type err = m.Matches([0]int32{}) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type [0]int32"))) } func (t *IdenticalToTest) NonEmptyComparableArrays() { var m Matcher var err error m = IdenticalTo([2]int{17, 19}) ExpectEq("identical to <[2]int> [17 19]", m.Description()) // Identical value err = m.Matches([2]int{17, 19}) ExpectEq(nil, err) // Length too short err = m.Matches([1]int{17}) ExpectThat(err, Error(Equals("which is of type [1]int"))) // Length too long err = m.Matches([3]int{17, 19, 23}) ExpectThat(err, Error(Equals("which is of type [3]int"))) // First element different err = m.Matches([2]int{13, 19}) ExpectThat(err, Error(Equals(""))) // Second element different err = m.Matches([2]int{17, 23}) ExpectThat(err, Error(Equals(""))) // Element type alias type myType int err = m.Matches([2]myType{17, 19}) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type [2]oglematchers_test.myType"))) // Completely wrong element type err = m.Matches([2]int32{17, 19}) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type [2]int32"))) } func (t *IdenticalToTest) NonEmptyArraysOfComparableArrays() { var m Matcher var err error x := [2][2]int{ [2]int{17, 19}, [2]int{23, 29}, } m = IdenticalTo(x) ExpectEq("identical to <[2][2]int> [[17 19] [23 29]]", m.Description()) // Identical value err = m.Matches([2][2]int{[2]int{17, 19}, [2]int{23, 29}}) ExpectEq(nil, err) // Outer length too short err = m.Matches([1][2]int{[2]int{17, 19}}) ExpectThat(err, Error(Equals("which is of type [1][2]int"))) // Inner length too short err = m.Matches([2][1]int{[1]int{17}, [1]int{23}}) ExpectThat(err, Error(Equals("which is of type [2][1]int"))) // First element different err = m.Matches([2][2]int{[2]int{13, 19}, [2]int{23, 29}}) ExpectThat(err, Error(Equals(""))) // Element type alias type myType int err = m.Matches([2][2]myType{[2]myType{17, 19}, [2]myType{23, 29}}) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type [2][2]oglematchers_test.myType"))) } func (t *IdenticalToTest) NonComparableArrays() { x := [0]func(){} f := func() { IdenticalTo(x) } ExpectThat(f, Panics(HasSubstr("is not comparable"))) } func (t *IdenticalToTest) ArraysOfNonComparableArrays() { x := [0][0]func(){} f := func() { IdenticalTo(x) } ExpectThat(f, Panics(HasSubstr("is not comparable"))) } func (t *IdenticalToTest) Strings() { var m Matcher var err error m = IdenticalTo("taco") ExpectEq("identical to taco", m.Description()) // Identical value err = m.Matches("ta" + "co") ExpectEq(nil, err) // Type alias type myType string err = m.Matches(myType("taco")) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type oglematchers_test.myType"))) // Completely wrong type err = m.Matches(int32(17)) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type int32"))) } func (t *IdenticalToTest) ComparableStructs() { var m Matcher var err error type subStruct struct { i int } type myStruct struct { u uint s subStruct } x := myStruct{17, subStruct{19}} m = IdenticalTo(x) ExpectEq("identical to {17 {19}}", m.Description()) // Identical value err = m.Matches(myStruct{17, subStruct{19}}) ExpectEq(nil, err) // Wrong outer field err = m.Matches(myStruct{13, subStruct{19}}) ExpectThat(err, Error(Equals(""))) // Wrong inner field err = m.Matches(myStruct{17, subStruct{23}}) ExpectThat(err, Error(Equals(""))) // Type alias type myType myStruct err = m.Matches(myType{17, subStruct{19}}) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type oglematchers_test.myType"))) // Completely wrong type err = m.Matches(int32(17)) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type int32"))) } func (t *IdenticalToTest) NonComparableStructs() { type subStruct struct { s []int } type myStruct struct { u uint s subStruct } x := myStruct{17, subStruct{[]int{19}}} f := func() { IdenticalTo(x) } ExpectThat(f, Panics(AllOf(HasSubstr("IdenticalTo"), HasSubstr("comparable")))) } func (t *IdenticalToTest) NilUnsafePointer() { var m Matcher var err error x := unsafe.Pointer(nil) m = IdenticalTo(x) ExpectEq(fmt.Sprintf("identical to %v", x), m.Description()) // Identical value err = m.Matches(unsafe.Pointer(nil)) ExpectEq(nil, err) // Wrong value j := 17 err = m.Matches(unsafe.Pointer(&j)) ExpectThat(err, Error(Equals(""))) // Type alias type myType unsafe.Pointer err = m.Matches(myType(unsafe.Pointer(nil))) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type oglematchers_test.myType"))) // Completely wrong type err = m.Matches(int32(17)) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type int32"))) } func (t *IdenticalToTest) NonNilUnsafePointer() { var m Matcher var err error i := 17 x := unsafe.Pointer(&i) m = IdenticalTo(x) ExpectEq(fmt.Sprintf("identical to %v", x), m.Description()) // Identical value err = m.Matches(unsafe.Pointer(&i)) ExpectEq(nil, err) // Nil value err = m.Matches(unsafe.Pointer(nil)) ExpectThat(err, Error(Equals(""))) // Wrong value j := 17 err = m.Matches(unsafe.Pointer(&j)) ExpectThat(err, Error(Equals(""))) // Type alias type myType unsafe.Pointer err = m.Matches(myType(unsafe.Pointer(&i))) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type oglematchers_test.myType"))) // Completely wrong type err = m.Matches(int32(17)) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type int32"))) } func (t *IdenticalToTest) IntAlias() { var m Matcher var err error type intAlias int m = IdenticalTo(intAlias(17)) ExpectEq("identical to 17", m.Description()) // Identical value err = m.Matches(intAlias(17)) ExpectEq(nil, err) // Int err = m.Matches(int(17)) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type int"))) // Completely wrong type err = m.Matches(int32(17)) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("which is of type int32"))) } less_or_equal.go000066400000000000000000000027061321131462300350270ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglematchers// Copyright 2011 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers import ( "fmt" "reflect" ) // LessOrEqual returns a matcher that matches integer, floating point, or // strings values v such that v <= x. Comparison is not defined between numeric // and string types, but is defined between all integer and floating point // types. // // x must itself be an integer, floating point, or string type; otherwise, // LessOrEqual will panic. func LessOrEqual(x interface{}) Matcher { desc := fmt.Sprintf("less than or equal to %v", x) // Special case: make it clear that strings are strings. if reflect.TypeOf(x).Kind() == reflect.String { desc = fmt.Sprintf("less than or equal to \"%s\"", x) } // Put LessThan last so that its error messages will be used in the event of // failure. return transformDescription(AnyOf(Equals(x), LessThan(x)), desc) } less_or_equal_test.go000066400000000000000000001110211321131462300360550ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglematchers// Copyright 2011 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers_test import ( "math" . "github.com/smartystreets/assertions/internal/oglematchers" . "github.com/smartystreets/assertions/internal/ogletest" ) //////////////////////////////////////////////////////////////////////// // Helpers //////////////////////////////////////////////////////////////////////// type LessOrEqualTest struct { } func init() { RegisterTestSuite(&LessOrEqualTest{}) } type leTestCase struct { candidate interface{} expectedResult bool shouldBeFatal bool expectedError string } func (t *LessOrEqualTest) checkTestCases(matcher Matcher, cases []leTestCase) { for i, c := range cases { err := matcher.Matches(c.candidate) ExpectThat( (err == nil), Equals(c.expectedResult), "Case %d (candidate %v)", i, c.candidate) if err == nil { continue } _, isFatal := err.(*FatalError) ExpectEq( c.shouldBeFatal, isFatal, "Case %d (candidate %v)", i, c.candidate) ExpectThat( err, Error(Equals(c.expectedError)), "Case %d (candidate %v)", i, c.candidate) } } //////////////////////////////////////////////////////////////////////// // Integer literals //////////////////////////////////////////////////////////////////////// func (t *LessOrEqualTest) IntegerCandidateBadTypes() { matcher := LessOrEqual(int(-150)) cases := []leTestCase{ leTestCase{true, false, true, "which is not comparable"}, leTestCase{complex64(-151), false, true, "which is not comparable"}, leTestCase{complex128(-151), false, true, "which is not comparable"}, leTestCase{[...]int{-151}, false, true, "which is not comparable"}, leTestCase{make(chan int), false, true, "which is not comparable"}, leTestCase{func() {}, false, true, "which is not comparable"}, leTestCase{map[int]int{}, false, true, "which is not comparable"}, leTestCase{&leTestCase{}, false, true, "which is not comparable"}, leTestCase{make([]int, 0), false, true, "which is not comparable"}, leTestCase{"-151", false, true, "which is not comparable"}, leTestCase{leTestCase{}, false, true, "which is not comparable"}, } t.checkTestCases(matcher, cases) } func (t *LessOrEqualTest) FloatCandidateBadTypes() { matcher := LessOrEqual(float32(-150)) cases := []leTestCase{ leTestCase{true, false, true, "which is not comparable"}, leTestCase{complex64(-151), false, true, "which is not comparable"}, leTestCase{complex128(-151), false, true, "which is not comparable"}, leTestCase{[...]int{-151}, false, true, "which is not comparable"}, leTestCase{make(chan int), false, true, "which is not comparable"}, leTestCase{func() {}, false, true, "which is not comparable"}, leTestCase{map[int]int{}, false, true, "which is not comparable"}, leTestCase{&leTestCase{}, false, true, "which is not comparable"}, leTestCase{make([]int, 0), false, true, "which is not comparable"}, leTestCase{"-151", false, true, "which is not comparable"}, leTestCase{leTestCase{}, false, true, "which is not comparable"}, } t.checkTestCases(matcher, cases) } func (t *LessOrEqualTest) StringCandidateBadTypes() { matcher := LessOrEqual("17") cases := []leTestCase{ leTestCase{true, false, true, "which is not comparable"}, leTestCase{int(0), false, true, "which is not comparable"}, leTestCase{int8(0), false, true, "which is not comparable"}, leTestCase{int16(0), false, true, "which is not comparable"}, leTestCase{int32(0), false, true, "which is not comparable"}, leTestCase{int64(0), false, true, "which is not comparable"}, leTestCase{uint(0), false, true, "which is not comparable"}, leTestCase{uint8(0), false, true, "which is not comparable"}, leTestCase{uint16(0), false, true, "which is not comparable"}, leTestCase{uint32(0), false, true, "which is not comparable"}, leTestCase{uint64(0), false, true, "which is not comparable"}, leTestCase{float32(0), false, true, "which is not comparable"}, leTestCase{float64(0), false, true, "which is not comparable"}, leTestCase{complex64(-151), false, true, "which is not comparable"}, leTestCase{complex128(-151), false, true, "which is not comparable"}, leTestCase{[...]int{-151}, false, true, "which is not comparable"}, leTestCase{make(chan int), false, true, "which is not comparable"}, leTestCase{func() {}, false, true, "which is not comparable"}, leTestCase{map[int]int{}, false, true, "which is not comparable"}, leTestCase{&leTestCase{}, false, true, "which is not comparable"}, leTestCase{make([]int, 0), false, true, "which is not comparable"}, leTestCase{leTestCase{}, false, true, "which is not comparable"}, } t.checkTestCases(matcher, cases) } func (t *LessOrEqualTest) BadArgument() { panicked := false defer func() { ExpectThat(panicked, Equals(true)) }() defer func() { if r := recover(); r != nil { panicked = true } }() LessOrEqual(complex128(0)) } //////////////////////////////////////////////////////////////////////// // Integer literals //////////////////////////////////////////////////////////////////////// func (t *LessOrEqualTest) NegativeIntegerLiteral() { matcher := LessOrEqual(-150) desc := matcher.Description() expectedDesc := "less than or equal to -150" ExpectThat(desc, Equals(expectedDesc)) cases := []leTestCase{ // Signed integers. leTestCase{-(1 << 30), true, false, ""}, leTestCase{-151, true, false, ""}, leTestCase{-150, true, false, ""}, leTestCase{-149, false, false, ""}, leTestCase{0, false, false, ""}, leTestCase{17, false, false, ""}, leTestCase{int(-(1 << 30)), true, false, ""}, leTestCase{int(-151), true, false, ""}, leTestCase{int(-150), true, false, ""}, leTestCase{int(-149), false, false, ""}, leTestCase{int(0), false, false, ""}, leTestCase{int(17), false, false, ""}, leTestCase{int8(-127), false, false, ""}, leTestCase{int8(0), false, false, ""}, leTestCase{int8(17), false, false, ""}, leTestCase{int16(-(1 << 14)), true, false, ""}, leTestCase{int16(-151), true, false, ""}, leTestCase{int16(-150), true, false, ""}, leTestCase{int16(-149), false, false, ""}, leTestCase{int16(0), false, false, ""}, leTestCase{int16(17), false, false, ""}, leTestCase{int32(-(1 << 30)), true, false, ""}, leTestCase{int32(-151), true, false, ""}, leTestCase{int32(-150), true, false, ""}, leTestCase{int32(-149), false, false, ""}, leTestCase{int32(0), false, false, ""}, leTestCase{int32(17), false, false, ""}, leTestCase{int64(-(1 << 30)), true, false, ""}, leTestCase{int64(-151), true, false, ""}, leTestCase{int64(-150), true, false, ""}, leTestCase{int64(-149), false, false, ""}, leTestCase{int64(0), false, false, ""}, leTestCase{int64(17), false, false, ""}, // Unsigned integers. leTestCase{uint((1 << 32) - 151), false, false, ""}, leTestCase{uint(0), false, false, ""}, leTestCase{uint(17), false, false, ""}, leTestCase{uint8(0), false, false, ""}, leTestCase{uint8(17), false, false, ""}, leTestCase{uint8(253), false, false, ""}, leTestCase{uint16((1 << 16) - 151), false, false, ""}, leTestCase{uint16(0), false, false, ""}, leTestCase{uint16(17), false, false, ""}, leTestCase{uint32((1 << 32) - 151), false, false, ""}, leTestCase{uint32(0), false, false, ""}, leTestCase{uint32(17), false, false, ""}, leTestCase{uint64((1 << 64) - 151), false, false, ""}, leTestCase{uint64(0), false, false, ""}, leTestCase{uint64(17), false, false, ""}, // Floating point. leTestCase{float32(-(1 << 30)), true, false, ""}, leTestCase{float32(-151), true, false, ""}, leTestCase{float32(-150.1), true, false, ""}, leTestCase{float32(-150), true, false, ""}, leTestCase{float32(-149.9), false, false, ""}, leTestCase{float32(0), false, false, ""}, leTestCase{float32(17), false, false, ""}, leTestCase{float32(160), false, false, ""}, leTestCase{float64(-(1 << 30)), true, false, ""}, leTestCase{float64(-151), true, false, ""}, leTestCase{float64(-150.1), true, false, ""}, leTestCase{float64(-150), true, false, ""}, leTestCase{float64(-149.9), false, false, ""}, leTestCase{float64(0), false, false, ""}, leTestCase{float64(17), false, false, ""}, leTestCase{float64(160), false, false, ""}, } t.checkTestCases(matcher, cases) } func (t *LessOrEqualTest) ZeroIntegerLiteral() { matcher := LessOrEqual(0) desc := matcher.Description() expectedDesc := "less than or equal to 0" ExpectThat(desc, Equals(expectedDesc)) cases := []leTestCase{ // Signed integers. leTestCase{-(1 << 30), true, false, ""}, leTestCase{-1, true, false, ""}, leTestCase{0, true, false, ""}, leTestCase{1, false, false, ""}, leTestCase{17, false, false, ""}, leTestCase{(1 << 30), false, false, ""}, leTestCase{int(-(1 << 30)), true, false, ""}, leTestCase{int(-1), true, false, ""}, leTestCase{int(0), true, false, ""}, leTestCase{int(1), false, false, ""}, leTestCase{int(17), false, false, ""}, leTestCase{int8(-1), true, false, ""}, leTestCase{int8(0), true, false, ""}, leTestCase{int8(1), false, false, ""}, leTestCase{int16(-(1 << 14)), true, false, ""}, leTestCase{int16(-1), true, false, ""}, leTestCase{int16(0), true, false, ""}, leTestCase{int16(1), false, false, ""}, leTestCase{int16(17), false, false, ""}, leTestCase{int32(-(1 << 30)), true, false, ""}, leTestCase{int32(-1), true, false, ""}, leTestCase{int32(0), true, false, ""}, leTestCase{int32(1), false, false, ""}, leTestCase{int32(17), false, false, ""}, leTestCase{int64(-(1 << 30)), true, false, ""}, leTestCase{int64(-1), true, false, ""}, leTestCase{int64(0), true, false, ""}, leTestCase{int64(1), false, false, ""}, leTestCase{int64(17), false, false, ""}, // Unsigned integers. leTestCase{uint((1 << 32) - 1), false, false, ""}, leTestCase{uint(0), true, false, ""}, leTestCase{uint(1), false, false, ""}, leTestCase{uint(17), false, false, ""}, leTestCase{uint8(0), true, false, ""}, leTestCase{uint8(1), false, false, ""}, leTestCase{uint8(17), false, false, ""}, leTestCase{uint8(253), false, false, ""}, leTestCase{uint16((1 << 16) - 1), false, false, ""}, leTestCase{uint16(0), true, false, ""}, leTestCase{uint16(1), false, false, ""}, leTestCase{uint16(17), false, false, ""}, leTestCase{uint32((1 << 32) - 1), false, false, ""}, leTestCase{uint32(0), true, false, ""}, leTestCase{uint32(1), false, false, ""}, leTestCase{uint32(17), false, false, ""}, leTestCase{uint64((1 << 64) - 1), false, false, ""}, leTestCase{uint64(0), true, false, ""}, leTestCase{uint64(1), false, false, ""}, leTestCase{uint64(17), false, false, ""}, // Floating point. leTestCase{float32(-(1 << 30)), true, false, ""}, leTestCase{float32(-1), true, false, ""}, leTestCase{float32(-0.1), true, false, ""}, leTestCase{float32(-0.0), true, false, ""}, leTestCase{float32(0), true, false, ""}, leTestCase{float32(0.1), false, false, ""}, leTestCase{float32(17), false, false, ""}, leTestCase{float32(160), false, false, ""}, leTestCase{float64(-(1 << 30)), true, false, ""}, leTestCase{float64(-1), true, false, ""}, leTestCase{float64(-0.1), true, false, ""}, leTestCase{float64(-0), true, false, ""}, leTestCase{float64(0), true, false, ""}, leTestCase{float64(0.1), false, false, ""}, leTestCase{float64(17), false, false, ""}, leTestCase{float64(160), false, false, ""}, } t.checkTestCases(matcher, cases) } func (t *LessOrEqualTest) PositiveIntegerLiteral() { matcher := LessOrEqual(150) desc := matcher.Description() expectedDesc := "less than or equal to 150" ExpectThat(desc, Equals(expectedDesc)) cases := []leTestCase{ // Signed integers. leTestCase{-1, true, false, ""}, leTestCase{149, true, false, ""}, leTestCase{150, true, false, ""}, leTestCase{151, false, false, ""}, leTestCase{int(-1), true, false, ""}, leTestCase{int(149), true, false, ""}, leTestCase{int(150), true, false, ""}, leTestCase{int(151), false, false, ""}, leTestCase{int8(-1), true, false, ""}, leTestCase{int8(0), true, false, ""}, leTestCase{int8(17), true, false, ""}, leTestCase{int8(127), true, false, ""}, leTestCase{int16(-1), true, false, ""}, leTestCase{int16(149), true, false, ""}, leTestCase{int16(150), true, false, ""}, leTestCase{int16(151), false, false, ""}, leTestCase{int32(-1), true, false, ""}, leTestCase{int32(149), true, false, ""}, leTestCase{int32(150), true, false, ""}, leTestCase{int32(151), false, false, ""}, leTestCase{int64(-1), true, false, ""}, leTestCase{int64(149), true, false, ""}, leTestCase{int64(150), true, false, ""}, leTestCase{int64(151), false, false, ""}, // Unsigned integers. leTestCase{uint(0), true, false, ""}, leTestCase{uint(149), true, false, ""}, leTestCase{uint(150), true, false, ""}, leTestCase{uint(151), false, false, ""}, leTestCase{uint8(0), true, false, ""}, leTestCase{uint8(127), true, false, ""}, leTestCase{uint16(0), true, false, ""}, leTestCase{uint16(149), true, false, ""}, leTestCase{uint16(150), true, false, ""}, leTestCase{uint16(151), false, false, ""}, leTestCase{uint32(0), true, false, ""}, leTestCase{uint32(149), true, false, ""}, leTestCase{uint32(150), true, false, ""}, leTestCase{uint32(151), false, false, ""}, leTestCase{uint64(0), true, false, ""}, leTestCase{uint64(149), true, false, ""}, leTestCase{uint64(150), true, false, ""}, leTestCase{uint64(151), false, false, ""}, // Floating point. leTestCase{float32(-1), true, false, ""}, leTestCase{float32(149), true, false, ""}, leTestCase{float32(149.9), true, false, ""}, leTestCase{float32(150), true, false, ""}, leTestCase{float32(150.1), false, false, ""}, leTestCase{float32(151), false, false, ""}, leTestCase{float64(-1), true, false, ""}, leTestCase{float64(149), true, false, ""}, leTestCase{float64(149.9), true, false, ""}, leTestCase{float64(150), true, false, ""}, leTestCase{float64(150.1), false, false, ""}, leTestCase{float64(151), false, false, ""}, } t.checkTestCases(matcher, cases) } //////////////////////////////////////////////////////////////////////// // Float literals //////////////////////////////////////////////////////////////////////// func (t *LessOrEqualTest) NegativeFloatLiteral() { matcher := LessOrEqual(-150.1) desc := matcher.Description() expectedDesc := "less than or equal to -150.1" ExpectThat(desc, Equals(expectedDesc)) cases := []leTestCase{ // Signed integers. leTestCase{-(1 << 30), true, false, ""}, leTestCase{-151, true, false, ""}, leTestCase{-150.1, true, false, ""}, leTestCase{-150, false, false, ""}, leTestCase{-149, false, false, ""}, leTestCase{0, false, false, ""}, leTestCase{17, false, false, ""}, leTestCase{int(-(1 << 30)), true, false, ""}, leTestCase{int(-151), true, false, ""}, leTestCase{int(-150), false, false, ""}, leTestCase{int(-149), false, false, ""}, leTestCase{int(0), false, false, ""}, leTestCase{int(17), false, false, ""}, leTestCase{int8(-127), false, false, ""}, leTestCase{int8(0), false, false, ""}, leTestCase{int8(17), false, false, ""}, leTestCase{int16(-(1 << 14)), true, false, ""}, leTestCase{int16(-151), true, false, ""}, leTestCase{int16(-150), false, false, ""}, leTestCase{int16(-149), false, false, ""}, leTestCase{int16(0), false, false, ""}, leTestCase{int16(17), false, false, ""}, leTestCase{int32(-(1 << 30)), true, false, ""}, leTestCase{int32(-151), true, false, ""}, leTestCase{int32(-150), false, false, ""}, leTestCase{int32(-149), false, false, ""}, leTestCase{int32(0), false, false, ""}, leTestCase{int32(17), false, false, ""}, leTestCase{int64(-(1 << 30)), true, false, ""}, leTestCase{int64(-151), true, false, ""}, leTestCase{int64(-150), false, false, ""}, leTestCase{int64(-149), false, false, ""}, leTestCase{int64(0), false, false, ""}, leTestCase{int64(17), false, false, ""}, // Unsigned integers. leTestCase{uint((1 << 32) - 151), false, false, ""}, leTestCase{uint(0), false, false, ""}, leTestCase{uint(17), false, false, ""}, leTestCase{uint8(0), false, false, ""}, leTestCase{uint8(17), false, false, ""}, leTestCase{uint8(253), false, false, ""}, leTestCase{uint16((1 << 16) - 151), false, false, ""}, leTestCase{uint16(0), false, false, ""}, leTestCase{uint16(17), false, false, ""}, leTestCase{uint32((1 << 32) - 151), false, false, ""}, leTestCase{uint32(0), false, false, ""}, leTestCase{uint32(17), false, false, ""}, leTestCase{uint64((1 << 64) - 151), false, false, ""}, leTestCase{uint64(0), false, false, ""}, leTestCase{uint64(17), false, false, ""}, // Floating point. leTestCase{float32(-(1 << 30)), true, false, ""}, leTestCase{float32(-151), true, false, ""}, leTestCase{float32(-150.2), true, false, ""}, leTestCase{float32(-150.1), true, false, ""}, leTestCase{float32(-150), false, false, ""}, leTestCase{float32(0), false, false, ""}, leTestCase{float32(17), false, false, ""}, leTestCase{float32(160), false, false, ""}, leTestCase{float64(-(1 << 30)), true, false, ""}, leTestCase{float64(-151), true, false, ""}, leTestCase{float64(-150.2), true, false, ""}, leTestCase{float64(-150.1), true, false, ""}, leTestCase{float64(-150), false, false, ""}, leTestCase{float64(0), false, false, ""}, leTestCase{float64(17), false, false, ""}, leTestCase{float64(160), false, false, ""}, } t.checkTestCases(matcher, cases) } func (t *LessOrEqualTest) PositiveFloatLiteral() { matcher := LessOrEqual(149.9) desc := matcher.Description() expectedDesc := "less than or equal to 149.9" ExpectThat(desc, Equals(expectedDesc)) cases := []leTestCase{ // Signed integers. leTestCase{-1, true, false, ""}, leTestCase{149, true, false, ""}, leTestCase{149.9, true, false, ""}, leTestCase{150, false, false, ""}, leTestCase{151, false, false, ""}, leTestCase{int(-1), true, false, ""}, leTestCase{int(149), true, false, ""}, leTestCase{int(150), false, false, ""}, leTestCase{int(151), false, false, ""}, leTestCase{int8(-1), true, false, ""}, leTestCase{int8(0), true, false, ""}, leTestCase{int8(17), true, false, ""}, leTestCase{int8(127), true, false, ""}, leTestCase{int16(-1), true, false, ""}, leTestCase{int16(149), true, false, ""}, leTestCase{int16(150), false, false, ""}, leTestCase{int16(151), false, false, ""}, leTestCase{int32(-1), true, false, ""}, leTestCase{int32(149), true, false, ""}, leTestCase{int32(150), false, false, ""}, leTestCase{int32(151), false, false, ""}, leTestCase{int64(-1), true, false, ""}, leTestCase{int64(149), true, false, ""}, leTestCase{int64(150), false, false, ""}, leTestCase{int64(151), false, false, ""}, // Unsigned integers. leTestCase{uint(0), true, false, ""}, leTestCase{uint(149), true, false, ""}, leTestCase{uint(150), false, false, ""}, leTestCase{uint(151), false, false, ""}, leTestCase{uint8(0), true, false, ""}, leTestCase{uint8(127), true, false, ""}, leTestCase{uint16(0), true, false, ""}, leTestCase{uint16(149), true, false, ""}, leTestCase{uint16(150), false, false, ""}, leTestCase{uint16(151), false, false, ""}, leTestCase{uint32(0), true, false, ""}, leTestCase{uint32(149), true, false, ""}, leTestCase{uint32(150), false, false, ""}, leTestCase{uint32(151), false, false, ""}, leTestCase{uint64(0), true, false, ""}, leTestCase{uint64(149), true, false, ""}, leTestCase{uint64(150), false, false, ""}, leTestCase{uint64(151), false, false, ""}, // Floating point. leTestCase{float32(-1), true, false, ""}, leTestCase{float32(149), true, false, ""}, leTestCase{float32(149.8), true, false, ""}, leTestCase{float32(149.9), true, false, ""}, leTestCase{float32(150), false, false, ""}, leTestCase{float32(151), false, false, ""}, leTestCase{float64(-1), true, false, ""}, leTestCase{float64(149), true, false, ""}, leTestCase{float64(149.8), true, false, ""}, leTestCase{float64(149.9), true, false, ""}, leTestCase{float64(150), false, false, ""}, leTestCase{float64(151), false, false, ""}, } t.checkTestCases(matcher, cases) } //////////////////////////////////////////////////////////////////////// // Subtle cases //////////////////////////////////////////////////////////////////////// func (t *LessOrEqualTest) Int64NotExactlyRepresentableBySinglePrecision() { // Single-precision floats don't have enough bits to represent the integers // near this one distinctly, so [2^25-1, 2^25+2] all receive the same value // and should be treated as equivalent when floats are in the mix. const kTwoTo25 = 1 << 25 matcher := LessOrEqual(int64(kTwoTo25 + 1)) desc := matcher.Description() expectedDesc := "less than or equal to 33554433" ExpectThat(desc, Equals(expectedDesc)) cases := []leTestCase{ // Signed integers. leTestCase{-1, true, false, ""}, leTestCase{kTwoTo25 + 0, true, false, ""}, leTestCase{kTwoTo25 + 1, true, false, ""}, leTestCase{kTwoTo25 + 2, false, false, ""}, leTestCase{int(-1), true, false, ""}, leTestCase{int(kTwoTo25 + 0), true, false, ""}, leTestCase{int(kTwoTo25 + 1), true, false, ""}, leTestCase{int(kTwoTo25 + 2), false, false, ""}, leTestCase{int8(-1), true, false, ""}, leTestCase{int8(127), true, false, ""}, leTestCase{int16(-1), true, false, ""}, leTestCase{int16(0), true, false, ""}, leTestCase{int16(32767), true, false, ""}, leTestCase{int32(-1), true, false, ""}, leTestCase{int32(kTwoTo25 + 0), true, false, ""}, leTestCase{int32(kTwoTo25 + 1), true, false, ""}, leTestCase{int32(kTwoTo25 + 2), false, false, ""}, leTestCase{int64(-1), true, false, ""}, leTestCase{int64(kTwoTo25 + 0), true, false, ""}, leTestCase{int64(kTwoTo25 + 1), true, false, ""}, leTestCase{int64(kTwoTo25 + 2), false, false, ""}, // Unsigned integers. leTestCase{uint(0), true, false, ""}, leTestCase{uint(kTwoTo25 + 0), true, false, ""}, leTestCase{uint(kTwoTo25 + 1), true, false, ""}, leTestCase{uint(kTwoTo25 + 2), false, false, ""}, leTestCase{uint8(0), true, false, ""}, leTestCase{uint8(255), true, false, ""}, leTestCase{uint16(0), true, false, ""}, leTestCase{uint16(65535), true, false, ""}, leTestCase{uint32(0), true, false, ""}, leTestCase{uint32(kTwoTo25 + 0), true, false, ""}, leTestCase{uint32(kTwoTo25 + 1), true, false, ""}, leTestCase{uint32(kTwoTo25 + 2), false, false, ""}, leTestCase{uint64(0), true, false, ""}, leTestCase{uint64(kTwoTo25 + 0), true, false, ""}, leTestCase{uint64(kTwoTo25 + 1), true, false, ""}, leTestCase{uint64(kTwoTo25 + 2), false, false, ""}, // Floating point. leTestCase{float32(-1), true, false, ""}, leTestCase{float32(kTwoTo25 - 2), true, false, ""}, leTestCase{float32(kTwoTo25 - 1), true, false, ""}, leTestCase{float32(kTwoTo25 + 0), true, false, ""}, leTestCase{float32(kTwoTo25 + 1), true, false, ""}, leTestCase{float32(kTwoTo25 + 2), true, false, ""}, leTestCase{float32(kTwoTo25 + 3), false, false, ""}, leTestCase{float64(-1), true, false, ""}, leTestCase{float64(kTwoTo25 - 2), true, false, ""}, leTestCase{float64(kTwoTo25 - 1), true, false, ""}, leTestCase{float64(kTwoTo25 + 0), true, false, ""}, leTestCase{float64(kTwoTo25 + 1), true, false, ""}, leTestCase{float64(kTwoTo25 + 2), false, false, ""}, leTestCase{float64(kTwoTo25 + 3), false, false, ""}, } t.checkTestCases(matcher, cases) } func (t *LessOrEqualTest) Int64NotExactlyRepresentableByDoublePrecision() { // Double-precision floats don't have enough bits to represent the integers // near this one distinctly, so [2^54-1, 2^54+2] all receive the same value // and should be treated as equivalent when floats are in the mix. const kTwoTo54 = 1 << 54 matcher := LessOrEqual(int64(kTwoTo54 + 1)) desc := matcher.Description() expectedDesc := "less than or equal to 18014398509481985" ExpectThat(desc, Equals(expectedDesc)) cases := []leTestCase{ // Signed integers. leTestCase{-1, true, false, ""}, leTestCase{1 << 30, true, false, ""}, leTestCase{int(-1), true, false, ""}, leTestCase{int(math.MaxInt32), true, false, ""}, leTestCase{int8(-1), true, false, ""}, leTestCase{int8(127), true, false, ""}, leTestCase{int16(-1), true, false, ""}, leTestCase{int16(0), true, false, ""}, leTestCase{int16(32767), true, false, ""}, leTestCase{int32(-1), true, false, ""}, leTestCase{int32(math.MaxInt32), true, false, ""}, leTestCase{int64(-1), true, false, ""}, leTestCase{int64(kTwoTo54 - 1), true, false, ""}, leTestCase{int64(kTwoTo54 + 0), true, false, ""}, leTestCase{int64(kTwoTo54 + 1), true, false, ""}, leTestCase{int64(kTwoTo54 + 2), false, false, ""}, // Unsigned integers. leTestCase{uint(0), true, false, ""}, leTestCase{uint(math.MaxUint32), true, false, ""}, leTestCase{uint8(0), true, false, ""}, leTestCase{uint8(255), true, false, ""}, leTestCase{uint16(0), true, false, ""}, leTestCase{uint16(65535), true, false, ""}, leTestCase{uint32(0), true, false, ""}, leTestCase{uint32(math.MaxUint32), true, false, ""}, leTestCase{uint64(0), true, false, ""}, leTestCase{uint64(kTwoTo54 - 1), true, false, ""}, leTestCase{uint64(kTwoTo54 + 0), true, false, ""}, leTestCase{uint64(kTwoTo54 + 1), true, false, ""}, leTestCase{uint64(kTwoTo54 + 2), false, false, ""}, // Floating point. leTestCase{float64(-1), true, false, ""}, leTestCase{float64(kTwoTo54 - 2), true, false, ""}, leTestCase{float64(kTwoTo54 - 1), true, false, ""}, leTestCase{float64(kTwoTo54 + 0), true, false, ""}, leTestCase{float64(kTwoTo54 + 1), true, false, ""}, leTestCase{float64(kTwoTo54 + 2), true, false, ""}, leTestCase{float64(kTwoTo54 + 3), false, false, ""}, } t.checkTestCases(matcher, cases) } func (t *LessOrEqualTest) Uint64NotExactlyRepresentableBySinglePrecision() { // Single-precision floats don't have enough bits to represent the integers // near this one distinctly, so [2^25-1, 2^25+2] all receive the same value // and should be treated as equivalent when floats are in the mix. const kTwoTo25 = 1 << 25 matcher := LessOrEqual(uint64(kTwoTo25 + 1)) desc := matcher.Description() expectedDesc := "less than or equal to 33554433" ExpectThat(desc, Equals(expectedDesc)) cases := []leTestCase{ // Signed integers. leTestCase{-1, true, false, ""}, leTestCase{kTwoTo25 + 0, true, false, ""}, leTestCase{kTwoTo25 + 1, true, false, ""}, leTestCase{kTwoTo25 + 2, false, false, ""}, leTestCase{int(-1), true, false, ""}, leTestCase{int(kTwoTo25 + 0), true, false, ""}, leTestCase{int(kTwoTo25 + 1), true, false, ""}, leTestCase{int(kTwoTo25 + 2), false, false, ""}, leTestCase{int8(-1), true, false, ""}, leTestCase{int8(127), true, false, ""}, leTestCase{int16(-1), true, false, ""}, leTestCase{int16(0), true, false, ""}, leTestCase{int16(32767), true, false, ""}, leTestCase{int32(-1), true, false, ""}, leTestCase{int32(kTwoTo25 + 0), true, false, ""}, leTestCase{int32(kTwoTo25 + 1), true, false, ""}, leTestCase{int32(kTwoTo25 + 2), false, false, ""}, leTestCase{int64(-1), true, false, ""}, leTestCase{int64(kTwoTo25 + 0), true, false, ""}, leTestCase{int64(kTwoTo25 + 1), true, false, ""}, leTestCase{int64(kTwoTo25 + 2), false, false, ""}, // Unsigned integers. leTestCase{uint(0), true, false, ""}, leTestCase{uint(kTwoTo25 + 0), true, false, ""}, leTestCase{uint(kTwoTo25 + 1), true, false, ""}, leTestCase{uint(kTwoTo25 + 2), false, false, ""}, leTestCase{uint8(0), true, false, ""}, leTestCase{uint8(255), true, false, ""}, leTestCase{uint16(0), true, false, ""}, leTestCase{uint16(65535), true, false, ""}, leTestCase{uint32(0), true, false, ""}, leTestCase{uint32(kTwoTo25 + 0), true, false, ""}, leTestCase{uint32(kTwoTo25 + 1), true, false, ""}, leTestCase{uint32(kTwoTo25 + 2), false, false, ""}, leTestCase{uint64(0), true, false, ""}, leTestCase{uint64(kTwoTo25 + 0), true, false, ""}, leTestCase{uint64(kTwoTo25 + 1), true, false, ""}, leTestCase{uint64(kTwoTo25 + 2), false, false, ""}, // Floating point. leTestCase{float32(-1), true, false, ""}, leTestCase{float32(kTwoTo25 - 2), true, false, ""}, leTestCase{float32(kTwoTo25 - 1), true, false, ""}, leTestCase{float32(kTwoTo25 + 0), true, false, ""}, leTestCase{float32(kTwoTo25 + 1), true, false, ""}, leTestCase{float32(kTwoTo25 + 2), true, false, ""}, leTestCase{float32(kTwoTo25 + 3), false, false, ""}, leTestCase{float64(-1), true, false, ""}, leTestCase{float64(kTwoTo25 - 2), true, false, ""}, leTestCase{float64(kTwoTo25 - 1), true, false, ""}, leTestCase{float64(kTwoTo25 + 0), true, false, ""}, leTestCase{float64(kTwoTo25 + 1), true, false, ""}, leTestCase{float64(kTwoTo25 + 2), false, false, ""}, leTestCase{float64(kTwoTo25 + 3), false, false, ""}, } t.checkTestCases(matcher, cases) } func (t *LessOrEqualTest) Uint64NotExactlyRepresentableByDoublePrecision() { // Double-precision floats don't have enough bits to represent the integers // near this one distinctly, so [2^54-1, 2^54+2] all receive the same value // and should be treated as equivalent when floats are in the mix. const kTwoTo54 = 1 << 54 matcher := LessOrEqual(uint64(kTwoTo54 + 1)) desc := matcher.Description() expectedDesc := "less than or equal to 18014398509481985" ExpectThat(desc, Equals(expectedDesc)) cases := []leTestCase{ // Signed integers. leTestCase{-1, true, false, ""}, leTestCase{1 << 30, true, false, ""}, leTestCase{int(-1), true, false, ""}, leTestCase{int(math.MaxInt32), true, false, ""}, leTestCase{int8(-1), true, false, ""}, leTestCase{int8(127), true, false, ""}, leTestCase{int16(-1), true, false, ""}, leTestCase{int16(0), true, false, ""}, leTestCase{int16(32767), true, false, ""}, leTestCase{int32(-1), true, false, ""}, leTestCase{int32(math.MaxInt32), true, false, ""}, leTestCase{int64(-1), true, false, ""}, leTestCase{int64(kTwoTo54 - 1), true, false, ""}, leTestCase{int64(kTwoTo54 + 0), true, false, ""}, leTestCase{int64(kTwoTo54 + 1), true, false, ""}, leTestCase{int64(kTwoTo54 + 2), false, false, ""}, // Unsigned integers. leTestCase{uint(0), true, false, ""}, leTestCase{uint(math.MaxUint32), true, false, ""}, leTestCase{uint8(0), true, false, ""}, leTestCase{uint8(255), true, false, ""}, leTestCase{uint16(0), true, false, ""}, leTestCase{uint16(65535), true, false, ""}, leTestCase{uint32(0), true, false, ""}, leTestCase{uint32(math.MaxUint32), true, false, ""}, leTestCase{uint64(0), true, false, ""}, leTestCase{uint64(kTwoTo54 - 1), true, false, ""}, leTestCase{uint64(kTwoTo54 + 0), true, false, ""}, leTestCase{uint64(kTwoTo54 + 1), true, false, ""}, leTestCase{uint64(kTwoTo54 + 2), false, false, ""}, // Floating point. leTestCase{float64(-1), true, false, ""}, leTestCase{float64(kTwoTo54 - 2), true, false, ""}, leTestCase{float64(kTwoTo54 - 1), true, false, ""}, leTestCase{float64(kTwoTo54 + 0), true, false, ""}, leTestCase{float64(kTwoTo54 + 1), true, false, ""}, leTestCase{float64(kTwoTo54 + 2), true, false, ""}, leTestCase{float64(kTwoTo54 + 3), false, false, ""}, } t.checkTestCases(matcher, cases) } func (t *LessOrEqualTest) Float32AboveExactIntegerRange() { // Single-precision floats don't have enough bits to represent the integers // near this one distinctly, so [2^25-1, 2^25+2] all receive the same value // and should be treated as equivalent when floats are in the mix. const kTwoTo25 = 1 << 25 matcher := LessOrEqual(float32(kTwoTo25 + 1)) desc := matcher.Description() expectedDesc := "less than or equal to 3.3554432e+07" ExpectThat(desc, Equals(expectedDesc)) cases := []leTestCase{ // Signed integers. leTestCase{int64(-1), true, false, ""}, leTestCase{int64(kTwoTo25 - 2), true, false, ""}, leTestCase{int64(kTwoTo25 - 1), true, false, ""}, leTestCase{int64(kTwoTo25 + 0), true, false, ""}, leTestCase{int64(kTwoTo25 + 1), true, false, ""}, leTestCase{int64(kTwoTo25 + 2), true, false, ""}, leTestCase{int64(kTwoTo25 + 3), false, false, ""}, // Unsigned integers. leTestCase{uint64(0), true, false, ""}, leTestCase{uint64(kTwoTo25 - 2), true, false, ""}, leTestCase{uint64(kTwoTo25 - 1), true, false, ""}, leTestCase{uint64(kTwoTo25 + 0), true, false, ""}, leTestCase{uint64(kTwoTo25 + 1), true, false, ""}, leTestCase{uint64(kTwoTo25 + 2), true, false, ""}, leTestCase{uint64(kTwoTo25 + 3), false, false, ""}, // Floating point. leTestCase{float32(-1), true, false, ""}, leTestCase{float32(kTwoTo25 - 2), true, false, ""}, leTestCase{float32(kTwoTo25 - 1), true, false, ""}, leTestCase{float32(kTwoTo25 + 0), true, false, ""}, leTestCase{float32(kTwoTo25 + 1), true, false, ""}, leTestCase{float32(kTwoTo25 + 2), true, false, ""}, leTestCase{float32(kTwoTo25 + 3), false, false, ""}, leTestCase{float64(-1), true, false, ""}, leTestCase{float64(kTwoTo25 - 2), true, false, ""}, leTestCase{float64(kTwoTo25 - 1), true, false, ""}, leTestCase{float64(kTwoTo25 + 0), true, false, ""}, leTestCase{float64(kTwoTo25 + 1), true, false, ""}, leTestCase{float64(kTwoTo25 + 2), true, false, ""}, leTestCase{float64(kTwoTo25 + 3), false, false, ""}, } t.checkTestCases(matcher, cases) } func (t *LessOrEqualTest) Float64AboveExactIntegerRange() { // Double-precision floats don't have enough bits to represent the integers // near this one distinctly, so [2^54-1, 2^54+2] all receive the same value // and should be treated as equivalent when floats are in the mix. const kTwoTo54 = 1 << 54 matcher := LessOrEqual(float64(kTwoTo54 + 1)) desc := matcher.Description() expectedDesc := "less than or equal to 1.8014398509481984e+16" ExpectThat(desc, Equals(expectedDesc)) cases := []leTestCase{ // Signed integers. leTestCase{int64(-1), true, false, ""}, leTestCase{int64(kTwoTo54 - 2), true, false, ""}, leTestCase{int64(kTwoTo54 - 1), true, false, ""}, leTestCase{int64(kTwoTo54 + 0), true, false, ""}, leTestCase{int64(kTwoTo54 + 1), true, false, ""}, leTestCase{int64(kTwoTo54 + 2), true, false, ""}, leTestCase{int64(kTwoTo54 + 3), false, false, ""}, // Unsigned integers. leTestCase{uint64(0), true, false, ""}, leTestCase{uint64(kTwoTo54 - 2), true, false, ""}, leTestCase{uint64(kTwoTo54 - 1), true, false, ""}, leTestCase{uint64(kTwoTo54 + 0), true, false, ""}, leTestCase{uint64(kTwoTo54 + 1), true, false, ""}, leTestCase{uint64(kTwoTo54 + 2), true, false, ""}, leTestCase{uint64(kTwoTo54 + 3), false, false, ""}, // Floating point. leTestCase{float64(-1), true, false, ""}, leTestCase{float64(kTwoTo54 - 2), true, false, ""}, leTestCase{float64(kTwoTo54 - 1), true, false, ""}, leTestCase{float64(kTwoTo54 + 0), true, false, ""}, leTestCase{float64(kTwoTo54 + 1), true, false, ""}, leTestCase{float64(kTwoTo54 + 2), true, false, ""}, leTestCase{float64(kTwoTo54 + 3), false, false, ""}, } t.checkTestCases(matcher, cases) } //////////////////////////////////////////////////////////////////////// // String literals //////////////////////////////////////////////////////////////////////// func (t *LessOrEqualTest) EmptyString() { matcher := LessOrEqual("") desc := matcher.Description() expectedDesc := "less than or equal to \"\"" ExpectThat(desc, Equals(expectedDesc)) cases := []leTestCase{ leTestCase{"", true, false, ""}, leTestCase{"\x00", false, false, ""}, leTestCase{"a", false, false, ""}, leTestCase{"foo", false, false, ""}, } t.checkTestCases(matcher, cases) } func (t *LessOrEqualTest) SingleNullByte() { matcher := LessOrEqual("\x00") desc := matcher.Description() expectedDesc := "less than or equal to \"\x00\"" ExpectThat(desc, Equals(expectedDesc)) cases := []leTestCase{ leTestCase{"", true, false, ""}, leTestCase{"\x00", true, false, ""}, leTestCase{"\x00\x00", false, false, ""}, leTestCase{"a", false, false, ""}, leTestCase{"foo", false, false, ""}, } t.checkTestCases(matcher, cases) } func (t *LessOrEqualTest) LongerString() { matcher := LessOrEqual("foo\x00") desc := matcher.Description() expectedDesc := "less than or equal to \"foo\x00\"" ExpectThat(desc, Equals(expectedDesc)) cases := []leTestCase{ leTestCase{"", true, false, ""}, leTestCase{"\x00", true, false, ""}, leTestCase{"bar", true, false, ""}, leTestCase{"foo", true, false, ""}, leTestCase{"foo\x00", true, false, ""}, leTestCase{"foo\x00\x00", false, false, ""}, leTestCase{"fooa", false, false, ""}, leTestCase{"qux", false, false, ""}, } t.checkTestCases(matcher, cases) } mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/less_than.go000066400000000000000000000071141321131462300342270ustar00rootroot00000000000000// Copyright 2011 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers import ( "errors" "fmt" "math" "reflect" ) // LessThan returns a matcher that matches integer, floating point, or strings // values v such that v < x. Comparison is not defined between numeric and // string types, but is defined between all integer and floating point types. // // x must itself be an integer, floating point, or string type; otherwise, // LessThan will panic. func LessThan(x interface{}) Matcher { v := reflect.ValueOf(x) kind := v.Kind() switch { case isInteger(v): case isFloat(v): case kind == reflect.String: default: panic(fmt.Sprintf("LessThan: unexpected kind %v", kind)) } return &lessThanMatcher{v} } type lessThanMatcher struct { limit reflect.Value } func (m *lessThanMatcher) Description() string { // Special case: make it clear that strings are strings. if m.limit.Kind() == reflect.String { return fmt.Sprintf("less than \"%s\"", m.limit.String()) } return fmt.Sprintf("less than %v", m.limit.Interface()) } func compareIntegers(v1, v2 reflect.Value) (err error) { err = errors.New("") switch { case isSignedInteger(v1) && isSignedInteger(v2): if v1.Int() < v2.Int() { err = nil } return case isSignedInteger(v1) && isUnsignedInteger(v2): if v1.Int() < 0 || uint64(v1.Int()) < v2.Uint() { err = nil } return case isUnsignedInteger(v1) && isSignedInteger(v2): if v1.Uint() <= math.MaxInt64 && int64(v1.Uint()) < v2.Int() { err = nil } return case isUnsignedInteger(v1) && isUnsignedInteger(v2): if v1.Uint() < v2.Uint() { err = nil } return } panic(fmt.Sprintf("compareIntegers: %v %v", v1, v2)) } func getFloat(v reflect.Value) float64 { switch { case isSignedInteger(v): return float64(v.Int()) case isUnsignedInteger(v): return float64(v.Uint()) case isFloat(v): return v.Float() } panic(fmt.Sprintf("getFloat: %v", v)) } func (m *lessThanMatcher) Matches(c interface{}) (err error) { v1 := reflect.ValueOf(c) v2 := m.limit err = errors.New("") // Handle strings as a special case. if v1.Kind() == reflect.String && v2.Kind() == reflect.String { if v1.String() < v2.String() { err = nil } return } // If we get here, we require that we are dealing with integers or floats. v1Legal := isInteger(v1) || isFloat(v1) v2Legal := isInteger(v2) || isFloat(v2) if !v1Legal || !v2Legal { err = NewFatalError("which is not comparable") return } // Handle the various comparison cases. switch { // Both integers case isInteger(v1) && isInteger(v2): return compareIntegers(v1, v2) // At least one float32 case v1.Kind() == reflect.Float32 || v2.Kind() == reflect.Float32: if float32(getFloat(v1)) < float32(getFloat(v2)) { err = nil } return // At least one float64 case v1.Kind() == reflect.Float64 || v2.Kind() == reflect.Float64: if getFloat(v1) < getFloat(v2) { err = nil } return } // We shouldn't get here. panic(fmt.Sprintf("lessThanMatcher.Matches: Shouldn't get here: %v %v", v1, v2)) } less_than_test.go000066400000000000000000001070021321131462300352040ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglematchers// Copyright 2011 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers_test import ( "math" . "github.com/smartystreets/assertions/internal/oglematchers" . "github.com/smartystreets/assertions/internal/ogletest" ) //////////////////////////////////////////////////////////////////////// // Helpers //////////////////////////////////////////////////////////////////////// type LessThanTest struct { } func init() { RegisterTestSuite(&LessThanTest{}) } type ltTestCase struct { candidate interface{} expectedResult bool shouldBeFatal bool expectedError string } func (t *LessThanTest) checkTestCases(matcher Matcher, cases []ltTestCase) { for i, c := range cases { err := matcher.Matches(c.candidate) ExpectThat( (err == nil), Equals(c.expectedResult), "Case %d (candidate %v)", i, c.candidate) if err == nil { continue } _, isFatal := err.(*FatalError) ExpectEq( c.shouldBeFatal, isFatal, "Case %d (candidate %v)", i, c.candidate) ExpectThat( err, Error(Equals(c.expectedError)), "Case %d (candidate %v)", i, c.candidate) } } //////////////////////////////////////////////////////////////////////// // Integer literals //////////////////////////////////////////////////////////////////////// func (t *LessThanTest) IntegerCandidateBadTypes() { matcher := LessThan(int(-150)) cases := []ltTestCase{ ltTestCase{true, false, true, "which is not comparable"}, ltTestCase{complex64(-151), false, true, "which is not comparable"}, ltTestCase{complex128(-151), false, true, "which is not comparable"}, ltTestCase{[...]int{-151}, false, true, "which is not comparable"}, ltTestCase{make(chan int), false, true, "which is not comparable"}, ltTestCase{func() {}, false, true, "which is not comparable"}, ltTestCase{map[int]int{}, false, true, "which is not comparable"}, ltTestCase{<TestCase{}, false, true, "which is not comparable"}, ltTestCase{make([]int, 0), false, true, "which is not comparable"}, ltTestCase{"-151", false, true, "which is not comparable"}, ltTestCase{ltTestCase{}, false, true, "which is not comparable"}, } t.checkTestCases(matcher, cases) } func (t *LessThanTest) FloatCandidateBadTypes() { matcher := LessThan(float32(-150)) cases := []ltTestCase{ ltTestCase{true, false, true, "which is not comparable"}, ltTestCase{complex64(-151), false, true, "which is not comparable"}, ltTestCase{complex128(-151), false, true, "which is not comparable"}, ltTestCase{[...]int{-151}, false, true, "which is not comparable"}, ltTestCase{make(chan int), false, true, "which is not comparable"}, ltTestCase{func() {}, false, true, "which is not comparable"}, ltTestCase{map[int]int{}, false, true, "which is not comparable"}, ltTestCase{<TestCase{}, false, true, "which is not comparable"}, ltTestCase{make([]int, 0), false, true, "which is not comparable"}, ltTestCase{"-151", false, true, "which is not comparable"}, ltTestCase{ltTestCase{}, false, true, "which is not comparable"}, } t.checkTestCases(matcher, cases) } func (t *LessThanTest) StringCandidateBadTypes() { matcher := LessThan("17") cases := []ltTestCase{ ltTestCase{true, false, true, "which is not comparable"}, ltTestCase{int(0), false, true, "which is not comparable"}, ltTestCase{int8(0), false, true, "which is not comparable"}, ltTestCase{int16(0), false, true, "which is not comparable"}, ltTestCase{int32(0), false, true, "which is not comparable"}, ltTestCase{int64(0), false, true, "which is not comparable"}, ltTestCase{uint(0), false, true, "which is not comparable"}, ltTestCase{uint8(0), false, true, "which is not comparable"}, ltTestCase{uint16(0), false, true, "which is not comparable"}, ltTestCase{uint32(0), false, true, "which is not comparable"}, ltTestCase{uint64(0), false, true, "which is not comparable"}, ltTestCase{float32(0), false, true, "which is not comparable"}, ltTestCase{float64(0), false, true, "which is not comparable"}, ltTestCase{complex64(-151), false, true, "which is not comparable"}, ltTestCase{complex128(-151), false, true, "which is not comparable"}, ltTestCase{[...]int{-151}, false, true, "which is not comparable"}, ltTestCase{make(chan int), false, true, "which is not comparable"}, ltTestCase{func() {}, false, true, "which is not comparable"}, ltTestCase{map[int]int{}, false, true, "which is not comparable"}, ltTestCase{<TestCase{}, false, true, "which is not comparable"}, ltTestCase{make([]int, 0), false, true, "which is not comparable"}, ltTestCase{ltTestCase{}, false, true, "which is not comparable"}, } t.checkTestCases(matcher, cases) } func (t *LessThanTest) BadArgument() { panicked := false defer func() { ExpectThat(panicked, Equals(true)) }() defer func() { if r := recover(); r != nil { panicked = true } }() LessThan(complex128(0)) } //////////////////////////////////////////////////////////////////////// // Integer literals //////////////////////////////////////////////////////////////////////// func (t *LessThanTest) NegativeIntegerLiteral() { matcher := LessThan(-150) desc := matcher.Description() expectedDesc := "less than -150" ExpectThat(desc, Equals(expectedDesc)) cases := []ltTestCase{ // Signed integers. ltTestCase{-(1 << 30), true, false, ""}, ltTestCase{-151, true, false, ""}, ltTestCase{-150, false, false, ""}, ltTestCase{0, false, false, ""}, ltTestCase{17, false, false, ""}, ltTestCase{int(-(1 << 30)), true, false, ""}, ltTestCase{int(-151), true, false, ""}, ltTestCase{int(-150), false, false, ""}, ltTestCase{int(0), false, false, ""}, ltTestCase{int(17), false, false, ""}, ltTestCase{int8(-127), false, false, ""}, ltTestCase{int8(0), false, false, ""}, ltTestCase{int8(17), false, false, ""}, ltTestCase{int16(-(1 << 14)), true, false, ""}, ltTestCase{int16(-151), true, false, ""}, ltTestCase{int16(-150), false, false, ""}, ltTestCase{int16(0), false, false, ""}, ltTestCase{int16(17), false, false, ""}, ltTestCase{int32(-(1 << 30)), true, false, ""}, ltTestCase{int32(-151), true, false, ""}, ltTestCase{int32(-150), false, false, ""}, ltTestCase{int32(0), false, false, ""}, ltTestCase{int32(17), false, false, ""}, ltTestCase{int64(-(1 << 30)), true, false, ""}, ltTestCase{int64(-151), true, false, ""}, ltTestCase{int64(-150), false, false, ""}, ltTestCase{int64(0), false, false, ""}, ltTestCase{int64(17), false, false, ""}, // Unsigned integers. ltTestCase{uint((1 << 32) - 151), false, false, ""}, ltTestCase{uint(0), false, false, ""}, ltTestCase{uint(17), false, false, ""}, ltTestCase{uint8(0), false, false, ""}, ltTestCase{uint8(17), false, false, ""}, ltTestCase{uint8(253), false, false, ""}, ltTestCase{uint16((1 << 16) - 151), false, false, ""}, ltTestCase{uint16(0), false, false, ""}, ltTestCase{uint16(17), false, false, ""}, ltTestCase{uint32((1 << 32) - 151), false, false, ""}, ltTestCase{uint32(0), false, false, ""}, ltTestCase{uint32(17), false, false, ""}, ltTestCase{uint64((1 << 64) - 151), false, false, ""}, ltTestCase{uint64(0), false, false, ""}, ltTestCase{uint64(17), false, false, ""}, // Floating point. ltTestCase{float32(-(1 << 30)), true, false, ""}, ltTestCase{float32(-151), true, false, ""}, ltTestCase{float32(-150.1), true, false, ""}, ltTestCase{float32(-150), false, false, ""}, ltTestCase{float32(-149.9), false, false, ""}, ltTestCase{float32(0), false, false, ""}, ltTestCase{float32(17), false, false, ""}, ltTestCase{float32(160), false, false, ""}, ltTestCase{float64(-(1 << 30)), true, false, ""}, ltTestCase{float64(-151), true, false, ""}, ltTestCase{float64(-150.1), true, false, ""}, ltTestCase{float64(-150), false, false, ""}, ltTestCase{float64(-149.9), false, false, ""}, ltTestCase{float64(0), false, false, ""}, ltTestCase{float64(17), false, false, ""}, ltTestCase{float64(160), false, false, ""}, } t.checkTestCases(matcher, cases) } func (t *LessThanTest) ZeroIntegerLiteral() { matcher := LessThan(0) desc := matcher.Description() expectedDesc := "less than 0" ExpectThat(desc, Equals(expectedDesc)) cases := []ltTestCase{ // Signed integers. ltTestCase{-(1 << 30), true, false, ""}, ltTestCase{-1, true, false, ""}, ltTestCase{0, false, false, ""}, ltTestCase{1, false, false, ""}, ltTestCase{17, false, false, ""}, ltTestCase{(1 << 30), false, false, ""}, ltTestCase{int(-(1 << 30)), true, false, ""}, ltTestCase{int(-1), true, false, ""}, ltTestCase{int(0), false, false, ""}, ltTestCase{int(1), false, false, ""}, ltTestCase{int(17), false, false, ""}, ltTestCase{int8(-1), true, false, ""}, ltTestCase{int8(0), false, false, ""}, ltTestCase{int8(1), false, false, ""}, ltTestCase{int16(-(1 << 14)), true, false, ""}, ltTestCase{int16(-1), true, false, ""}, ltTestCase{int16(0), false, false, ""}, ltTestCase{int16(1), false, false, ""}, ltTestCase{int16(17), false, false, ""}, ltTestCase{int32(-(1 << 30)), true, false, ""}, ltTestCase{int32(-1), true, false, ""}, ltTestCase{int32(0), false, false, ""}, ltTestCase{int32(1), false, false, ""}, ltTestCase{int32(17), false, false, ""}, ltTestCase{int64(-(1 << 30)), true, false, ""}, ltTestCase{int64(-1), true, false, ""}, ltTestCase{int64(0), false, false, ""}, ltTestCase{int64(1), false, false, ""}, ltTestCase{int64(17), false, false, ""}, // Unsigned integers. ltTestCase{uint((1 << 32) - 1), false, false, ""}, ltTestCase{uint(0), false, false, ""}, ltTestCase{uint(17), false, false, ""}, ltTestCase{uint8(0), false, false, ""}, ltTestCase{uint8(17), false, false, ""}, ltTestCase{uint8(253), false, false, ""}, ltTestCase{uint16((1 << 16) - 1), false, false, ""}, ltTestCase{uint16(0), false, false, ""}, ltTestCase{uint16(17), false, false, ""}, ltTestCase{uint32((1 << 32) - 1), false, false, ""}, ltTestCase{uint32(0), false, false, ""}, ltTestCase{uint32(17), false, false, ""}, ltTestCase{uint64((1 << 64) - 1), false, false, ""}, ltTestCase{uint64(0), false, false, ""}, ltTestCase{uint64(17), false, false, ""}, // Floating point. ltTestCase{float32(-(1 << 30)), true, false, ""}, ltTestCase{float32(-1), true, false, ""}, ltTestCase{float32(-0.1), true, false, ""}, ltTestCase{float32(-0.0), false, false, ""}, ltTestCase{float32(0), false, false, ""}, ltTestCase{float32(0.1), false, false, ""}, ltTestCase{float32(17), false, false, ""}, ltTestCase{float32(160), false, false, ""}, ltTestCase{float64(-(1 << 30)), true, false, ""}, ltTestCase{float64(-1), true, false, ""}, ltTestCase{float64(-0.1), true, false, ""}, ltTestCase{float64(-0), false, false, ""}, ltTestCase{float64(0), false, false, ""}, ltTestCase{float64(17), false, false, ""}, ltTestCase{float64(160), false, false, ""}, } t.checkTestCases(matcher, cases) } func (t *LessThanTest) PositiveIntegerLiteral() { matcher := LessThan(150) desc := matcher.Description() expectedDesc := "less than 150" ExpectThat(desc, Equals(expectedDesc)) cases := []ltTestCase{ // Signed integers. ltTestCase{-1, true, false, ""}, ltTestCase{149, true, false, ""}, ltTestCase{150, false, false, ""}, ltTestCase{151, false, false, ""}, ltTestCase{int(-1), true, false, ""}, ltTestCase{int(149), true, false, ""}, ltTestCase{int(150), false, false, ""}, ltTestCase{int(151), false, false, ""}, ltTestCase{int8(-1), true, false, ""}, ltTestCase{int8(0), true, false, ""}, ltTestCase{int8(17), true, false, ""}, ltTestCase{int8(127), true, false, ""}, ltTestCase{int16(-1), true, false, ""}, ltTestCase{int16(149), true, false, ""}, ltTestCase{int16(150), false, false, ""}, ltTestCase{int16(151), false, false, ""}, ltTestCase{int32(-1), true, false, ""}, ltTestCase{int32(149), true, false, ""}, ltTestCase{int32(150), false, false, ""}, ltTestCase{int32(151), false, false, ""}, ltTestCase{int64(-1), true, false, ""}, ltTestCase{int64(149), true, false, ""}, ltTestCase{int64(150), false, false, ""}, ltTestCase{int64(151), false, false, ""}, // Unsigned integers. ltTestCase{uint(0), true, false, ""}, ltTestCase{uint(149), true, false, ""}, ltTestCase{uint(150), false, false, ""}, ltTestCase{uint(151), false, false, ""}, ltTestCase{uint8(0), true, false, ""}, ltTestCase{uint8(127), true, false, ""}, ltTestCase{uint16(0), true, false, ""}, ltTestCase{uint16(149), true, false, ""}, ltTestCase{uint16(150), false, false, ""}, ltTestCase{uint16(151), false, false, ""}, ltTestCase{uint32(0), true, false, ""}, ltTestCase{uint32(149), true, false, ""}, ltTestCase{uint32(150), false, false, ""}, ltTestCase{uint32(151), false, false, ""}, ltTestCase{uint64(0), true, false, ""}, ltTestCase{uint64(149), true, false, ""}, ltTestCase{uint64(150), false, false, ""}, ltTestCase{uint64(151), false, false, ""}, // Floating point. ltTestCase{float32(-1), true, false, ""}, ltTestCase{float32(149), true, false, ""}, ltTestCase{float32(149.9), true, false, ""}, ltTestCase{float32(150), false, false, ""}, ltTestCase{float32(150.1), false, false, ""}, ltTestCase{float32(151), false, false, ""}, ltTestCase{float64(-1), true, false, ""}, ltTestCase{float64(149), true, false, ""}, ltTestCase{float64(149.9), true, false, ""}, ltTestCase{float64(150), false, false, ""}, ltTestCase{float64(150.1), false, false, ""}, ltTestCase{float64(151), false, false, ""}, } t.checkTestCases(matcher, cases) } //////////////////////////////////////////////////////////////////////// // Float literals //////////////////////////////////////////////////////////////////////// func (t *LessThanTest) NegativeFloatLiteral() { matcher := LessThan(-150.1) desc := matcher.Description() expectedDesc := "less than -150.1" ExpectThat(desc, Equals(expectedDesc)) cases := []ltTestCase{ // Signed integers. ltTestCase{-(1 << 30), true, false, ""}, ltTestCase{-151, true, false, ""}, ltTestCase{-150, false, false, ""}, ltTestCase{0, false, false, ""}, ltTestCase{17, false, false, ""}, ltTestCase{int(-(1 << 30)), true, false, ""}, ltTestCase{int(-151), true, false, ""}, ltTestCase{int(-150), false, false, ""}, ltTestCase{int(0), false, false, ""}, ltTestCase{int(17), false, false, ""}, ltTestCase{int8(-127), false, false, ""}, ltTestCase{int8(0), false, false, ""}, ltTestCase{int8(17), false, false, ""}, ltTestCase{int16(-(1 << 14)), true, false, ""}, ltTestCase{int16(-151), true, false, ""}, ltTestCase{int16(-150), false, false, ""}, ltTestCase{int16(0), false, false, ""}, ltTestCase{int16(17), false, false, ""}, ltTestCase{int32(-(1 << 30)), true, false, ""}, ltTestCase{int32(-151), true, false, ""}, ltTestCase{int32(-150), false, false, ""}, ltTestCase{int32(0), false, false, ""}, ltTestCase{int32(17), false, false, ""}, ltTestCase{int64(-(1 << 30)), true, false, ""}, ltTestCase{int64(-151), true, false, ""}, ltTestCase{int64(-150), false, false, ""}, ltTestCase{int64(0), false, false, ""}, ltTestCase{int64(17), false, false, ""}, // Unsigned integers. ltTestCase{uint((1 << 32) - 151), false, false, ""}, ltTestCase{uint(0), false, false, ""}, ltTestCase{uint(17), false, false, ""}, ltTestCase{uint8(0), false, false, ""}, ltTestCase{uint8(17), false, false, ""}, ltTestCase{uint8(253), false, false, ""}, ltTestCase{uint16((1 << 16) - 151), false, false, ""}, ltTestCase{uint16(0), false, false, ""}, ltTestCase{uint16(17), false, false, ""}, ltTestCase{uint32((1 << 32) - 151), false, false, ""}, ltTestCase{uint32(0), false, false, ""}, ltTestCase{uint32(17), false, false, ""}, ltTestCase{uint64((1 << 64) - 151), false, false, ""}, ltTestCase{uint64(0), false, false, ""}, ltTestCase{uint64(17), false, false, ""}, // Floating point. ltTestCase{float32(-(1 << 30)), true, false, ""}, ltTestCase{float32(-151), true, false, ""}, ltTestCase{float32(-150.2), true, false, ""}, ltTestCase{float32(-150.1), false, false, ""}, ltTestCase{float32(-150), false, false, ""}, ltTestCase{float32(0), false, false, ""}, ltTestCase{float32(17), false, false, ""}, ltTestCase{float32(160), false, false, ""}, ltTestCase{float64(-(1 << 30)), true, false, ""}, ltTestCase{float64(-151), true, false, ""}, ltTestCase{float64(-150.2), true, false, ""}, ltTestCase{float64(-150.1), false, false, ""}, ltTestCase{float64(-150), false, false, ""}, ltTestCase{float64(0), false, false, ""}, ltTestCase{float64(17), false, false, ""}, ltTestCase{float64(160), false, false, ""}, } t.checkTestCases(matcher, cases) } func (t *LessThanTest) PositiveFloatLiteral() { matcher := LessThan(149.9) desc := matcher.Description() expectedDesc := "less than 149.9" ExpectThat(desc, Equals(expectedDesc)) cases := []ltTestCase{ // Signed integers. ltTestCase{-1, true, false, ""}, ltTestCase{149, true, false, ""}, ltTestCase{150, false, false, ""}, ltTestCase{151, false, false, ""}, ltTestCase{int(-1), true, false, ""}, ltTestCase{int(149), true, false, ""}, ltTestCase{int(150), false, false, ""}, ltTestCase{int(151), false, false, ""}, ltTestCase{int8(-1), true, false, ""}, ltTestCase{int8(0), true, false, ""}, ltTestCase{int8(17), true, false, ""}, ltTestCase{int8(127), true, false, ""}, ltTestCase{int16(-1), true, false, ""}, ltTestCase{int16(149), true, false, ""}, ltTestCase{int16(150), false, false, ""}, ltTestCase{int16(151), false, false, ""}, ltTestCase{int32(-1), true, false, ""}, ltTestCase{int32(149), true, false, ""}, ltTestCase{int32(150), false, false, ""}, ltTestCase{int32(151), false, false, ""}, ltTestCase{int64(-1), true, false, ""}, ltTestCase{int64(149), true, false, ""}, ltTestCase{int64(150), false, false, ""}, ltTestCase{int64(151), false, false, ""}, // Unsigned integers. ltTestCase{uint(0), true, false, ""}, ltTestCase{uint(149), true, false, ""}, ltTestCase{uint(150), false, false, ""}, ltTestCase{uint(151), false, false, ""}, ltTestCase{uint8(0), true, false, ""}, ltTestCase{uint8(127), true, false, ""}, ltTestCase{uint16(0), true, false, ""}, ltTestCase{uint16(149), true, false, ""}, ltTestCase{uint16(150), false, false, ""}, ltTestCase{uint16(151), false, false, ""}, ltTestCase{uint32(0), true, false, ""}, ltTestCase{uint32(149), true, false, ""}, ltTestCase{uint32(150), false, false, ""}, ltTestCase{uint32(151), false, false, ""}, ltTestCase{uint64(0), true, false, ""}, ltTestCase{uint64(149), true, false, ""}, ltTestCase{uint64(150), false, false, ""}, ltTestCase{uint64(151), false, false, ""}, // Floating point. ltTestCase{float32(-1), true, false, ""}, ltTestCase{float32(149), true, false, ""}, ltTestCase{float32(149.8), true, false, ""}, ltTestCase{float32(149.9), false, false, ""}, ltTestCase{float32(150), false, false, ""}, ltTestCase{float32(151), false, false, ""}, ltTestCase{float64(-1), true, false, ""}, ltTestCase{float64(149), true, false, ""}, ltTestCase{float64(149.8), true, false, ""}, ltTestCase{float64(149.9), false, false, ""}, ltTestCase{float64(150), false, false, ""}, ltTestCase{float64(151), false, false, ""}, } t.checkTestCases(matcher, cases) } //////////////////////////////////////////////////////////////////////// // Subtle cases //////////////////////////////////////////////////////////////////////// func (t *LessThanTest) Int64NotExactlyRepresentableBySinglePrecision() { // Single-precision floats don't have enough bits to represent the integers // near this one distinctly, so [2^25-1, 2^25+2] all receive the same value // and should be treated as equivalent when floats are in the mix. const kTwoTo25 = 1 << 25 matcher := LessThan(int64(kTwoTo25 + 1)) desc := matcher.Description() expectedDesc := "less than 33554433" ExpectThat(desc, Equals(expectedDesc)) cases := []ltTestCase{ // Signed integers. ltTestCase{-1, true, false, ""}, ltTestCase{kTwoTo25 + 0, true, false, ""}, ltTestCase{kTwoTo25 + 1, false, false, ""}, ltTestCase{kTwoTo25 + 2, false, false, ""}, ltTestCase{int(-1), true, false, ""}, ltTestCase{int(kTwoTo25 + 0), true, false, ""}, ltTestCase{int(kTwoTo25 + 1), false, false, ""}, ltTestCase{int(kTwoTo25 + 2), false, false, ""}, ltTestCase{int8(-1), true, false, ""}, ltTestCase{int8(127), true, false, ""}, ltTestCase{int16(-1), true, false, ""}, ltTestCase{int16(0), true, false, ""}, ltTestCase{int16(32767), true, false, ""}, ltTestCase{int32(-1), true, false, ""}, ltTestCase{int32(kTwoTo25 + 0), true, false, ""}, ltTestCase{int32(kTwoTo25 + 1), false, false, ""}, ltTestCase{int32(kTwoTo25 + 2), false, false, ""}, ltTestCase{int64(-1), true, false, ""}, ltTestCase{int64(kTwoTo25 + 0), true, false, ""}, ltTestCase{int64(kTwoTo25 + 1), false, false, ""}, ltTestCase{int64(kTwoTo25 + 2), false, false, ""}, // Unsigned integers. ltTestCase{uint(0), true, false, ""}, ltTestCase{uint(kTwoTo25 + 0), true, false, ""}, ltTestCase{uint(kTwoTo25 + 1), false, false, ""}, ltTestCase{uint(kTwoTo25 + 2), false, false, ""}, ltTestCase{uint8(0), true, false, ""}, ltTestCase{uint8(255), true, false, ""}, ltTestCase{uint16(0), true, false, ""}, ltTestCase{uint16(65535), true, false, ""}, ltTestCase{uint32(0), true, false, ""}, ltTestCase{uint32(kTwoTo25 + 0), true, false, ""}, ltTestCase{uint32(kTwoTo25 + 1), false, false, ""}, ltTestCase{uint32(kTwoTo25 + 2), false, false, ""}, ltTestCase{uint64(0), true, false, ""}, ltTestCase{uint64(kTwoTo25 + 0), true, false, ""}, ltTestCase{uint64(kTwoTo25 + 1), false, false, ""}, ltTestCase{uint64(kTwoTo25 + 2), false, false, ""}, // Floating point. ltTestCase{float32(-1), true, false, ""}, ltTestCase{float32(kTwoTo25 - 2), true, false, ""}, ltTestCase{float32(kTwoTo25 - 1), false, false, ""}, ltTestCase{float32(kTwoTo25 + 0), false, false, ""}, ltTestCase{float32(kTwoTo25 + 1), false, false, ""}, ltTestCase{float32(kTwoTo25 + 2), false, false, ""}, ltTestCase{float32(kTwoTo25 + 3), false, false, ""}, ltTestCase{float64(-1), true, false, ""}, ltTestCase{float64(kTwoTo25 - 2), true, false, ""}, ltTestCase{float64(kTwoTo25 - 1), true, false, ""}, ltTestCase{float64(kTwoTo25 + 0), true, false, ""}, ltTestCase{float64(kTwoTo25 + 1), false, false, ""}, ltTestCase{float64(kTwoTo25 + 2), false, false, ""}, ltTestCase{float64(kTwoTo25 + 3), false, false, ""}, } t.checkTestCases(matcher, cases) } func (t *LessThanTest) Int64NotExactlyRepresentableByDoublePrecision() { // Double-precision floats don't have enough bits to represent the integers // near this one distinctly, so [2^54-1, 2^54+2] all receive the same value // and should be treated as equivalent when floats are in the mix. const kTwoTo54 = 1 << 54 matcher := LessThan(int64(kTwoTo54 + 1)) desc := matcher.Description() expectedDesc := "less than 18014398509481985" ExpectThat(desc, Equals(expectedDesc)) cases := []ltTestCase{ // Signed integers. ltTestCase{-1, true, false, ""}, ltTestCase{1 << 30, true, false, ""}, ltTestCase{int(-1), true, false, ""}, ltTestCase{int(math.MaxInt32), true, false, ""}, ltTestCase{int8(-1), true, false, ""}, ltTestCase{int8(127), true, false, ""}, ltTestCase{int16(-1), true, false, ""}, ltTestCase{int16(0), true, false, ""}, ltTestCase{int16(32767), true, false, ""}, ltTestCase{int32(-1), true, false, ""}, ltTestCase{int32(math.MaxInt32), true, false, ""}, ltTestCase{int64(-1), true, false, ""}, ltTestCase{int64(kTwoTo54 - 1), true, false, ""}, ltTestCase{int64(kTwoTo54 + 0), true, false, ""}, ltTestCase{int64(kTwoTo54 + 1), false, false, ""}, ltTestCase{int64(kTwoTo54 + 2), false, false, ""}, // Unsigned integers. ltTestCase{uint(0), true, false, ""}, ltTestCase{uint(math.MaxUint32), true, false, ""}, ltTestCase{uint8(0), true, false, ""}, ltTestCase{uint8(255), true, false, ""}, ltTestCase{uint16(0), true, false, ""}, ltTestCase{uint16(65535), true, false, ""}, ltTestCase{uint32(0), true, false, ""}, ltTestCase{uint32(math.MaxUint32), true, false, ""}, ltTestCase{uint64(0), true, false, ""}, ltTestCase{uint64(kTwoTo54 - 1), true, false, ""}, ltTestCase{uint64(kTwoTo54 + 0), true, false, ""}, ltTestCase{uint64(kTwoTo54 + 1), false, false, ""}, ltTestCase{uint64(kTwoTo54 + 2), false, false, ""}, // Floating point. ltTestCase{float64(-1), true, false, ""}, ltTestCase{float64(kTwoTo54 - 2), true, false, ""}, ltTestCase{float64(kTwoTo54 - 1), false, false, ""}, ltTestCase{float64(kTwoTo54 + 0), false, false, ""}, ltTestCase{float64(kTwoTo54 + 1), false, false, ""}, ltTestCase{float64(kTwoTo54 + 2), false, false, ""}, ltTestCase{float64(kTwoTo54 + 3), false, false, ""}, } t.checkTestCases(matcher, cases) } func (t *LessThanTest) Uint64NotExactlyRepresentableBySinglePrecision() { // Single-precision floats don't have enough bits to represent the integers // near this one distinctly, so [2^25-1, 2^25+2] all receive the same value // and should be treated as equivalent when floats are in the mix. const kTwoTo25 = 1 << 25 matcher := LessThan(uint64(kTwoTo25 + 1)) desc := matcher.Description() expectedDesc := "less than 33554433" ExpectThat(desc, Equals(expectedDesc)) cases := []ltTestCase{ // Signed integers. ltTestCase{-1, true, false, ""}, ltTestCase{kTwoTo25 + 0, true, false, ""}, ltTestCase{kTwoTo25 + 1, false, false, ""}, ltTestCase{kTwoTo25 + 2, false, false, ""}, ltTestCase{int(-1), true, false, ""}, ltTestCase{int(kTwoTo25 + 0), true, false, ""}, ltTestCase{int(kTwoTo25 + 1), false, false, ""}, ltTestCase{int(kTwoTo25 + 2), false, false, ""}, ltTestCase{int8(-1), true, false, ""}, ltTestCase{int8(127), true, false, ""}, ltTestCase{int16(-1), true, false, ""}, ltTestCase{int16(0), true, false, ""}, ltTestCase{int16(32767), true, false, ""}, ltTestCase{int32(-1), true, false, ""}, ltTestCase{int32(kTwoTo25 + 0), true, false, ""}, ltTestCase{int32(kTwoTo25 + 1), false, false, ""}, ltTestCase{int32(kTwoTo25 + 2), false, false, ""}, ltTestCase{int64(-1), true, false, ""}, ltTestCase{int64(kTwoTo25 + 0), true, false, ""}, ltTestCase{int64(kTwoTo25 + 1), false, false, ""}, ltTestCase{int64(kTwoTo25 + 2), false, false, ""}, // Unsigned integers. ltTestCase{uint(0), true, false, ""}, ltTestCase{uint(kTwoTo25 + 0), true, false, ""}, ltTestCase{uint(kTwoTo25 + 1), false, false, ""}, ltTestCase{uint(kTwoTo25 + 2), false, false, ""}, ltTestCase{uint8(0), true, false, ""}, ltTestCase{uint8(255), true, false, ""}, ltTestCase{uint16(0), true, false, ""}, ltTestCase{uint16(65535), true, false, ""}, ltTestCase{uint32(0), true, false, ""}, ltTestCase{uint32(kTwoTo25 + 0), true, false, ""}, ltTestCase{uint32(kTwoTo25 + 1), false, false, ""}, ltTestCase{uint32(kTwoTo25 + 2), false, false, ""}, ltTestCase{uint64(0), true, false, ""}, ltTestCase{uint64(kTwoTo25 + 0), true, false, ""}, ltTestCase{uint64(kTwoTo25 + 1), false, false, ""}, ltTestCase{uint64(kTwoTo25 + 2), false, false, ""}, // Floating point. ltTestCase{float32(-1), true, false, ""}, ltTestCase{float32(kTwoTo25 - 2), true, false, ""}, ltTestCase{float32(kTwoTo25 - 1), false, false, ""}, ltTestCase{float32(kTwoTo25 + 0), false, false, ""}, ltTestCase{float32(kTwoTo25 + 1), false, false, ""}, ltTestCase{float32(kTwoTo25 + 2), false, false, ""}, ltTestCase{float32(kTwoTo25 + 3), false, false, ""}, ltTestCase{float64(-1), true, false, ""}, ltTestCase{float64(kTwoTo25 - 2), true, false, ""}, ltTestCase{float64(kTwoTo25 - 1), true, false, ""}, ltTestCase{float64(kTwoTo25 + 0), true, false, ""}, ltTestCase{float64(kTwoTo25 + 1), false, false, ""}, ltTestCase{float64(kTwoTo25 + 2), false, false, ""}, ltTestCase{float64(kTwoTo25 + 3), false, false, ""}, } t.checkTestCases(matcher, cases) } func (t *LessThanTest) Uint64NotExactlyRepresentableByDoublePrecision() { // Double-precision floats don't have enough bits to represent the integers // near this one distinctly, so [2^54-1, 2^54+2] all receive the same value // and should be treated as equivalent when floats are in the mix. const kTwoTo54 = 1 << 54 matcher := LessThan(uint64(kTwoTo54 + 1)) desc := matcher.Description() expectedDesc := "less than 18014398509481985" ExpectThat(desc, Equals(expectedDesc)) cases := []ltTestCase{ // Signed integers. ltTestCase{-1, true, false, ""}, ltTestCase{1 << 30, true, false, ""}, ltTestCase{int(-1), true, false, ""}, ltTestCase{int(math.MaxInt32), true, false, ""}, ltTestCase{int8(-1), true, false, ""}, ltTestCase{int8(127), true, false, ""}, ltTestCase{int16(-1), true, false, ""}, ltTestCase{int16(0), true, false, ""}, ltTestCase{int16(32767), true, false, ""}, ltTestCase{int32(-1), true, false, ""}, ltTestCase{int32(math.MaxInt32), true, false, ""}, ltTestCase{int64(-1), true, false, ""}, ltTestCase{int64(kTwoTo54 - 1), true, false, ""}, ltTestCase{int64(kTwoTo54 + 0), true, false, ""}, ltTestCase{int64(kTwoTo54 + 1), false, false, ""}, ltTestCase{int64(kTwoTo54 + 2), false, false, ""}, // Unsigned integers. ltTestCase{uint(0), true, false, ""}, ltTestCase{uint(math.MaxUint32), true, false, ""}, ltTestCase{uint8(0), true, false, ""}, ltTestCase{uint8(255), true, false, ""}, ltTestCase{uint16(0), true, false, ""}, ltTestCase{uint16(65535), true, false, ""}, ltTestCase{uint32(0), true, false, ""}, ltTestCase{uint32(math.MaxUint32), true, false, ""}, ltTestCase{uint64(0), true, false, ""}, ltTestCase{uint64(kTwoTo54 - 1), true, false, ""}, ltTestCase{uint64(kTwoTo54 + 0), true, false, ""}, ltTestCase{uint64(kTwoTo54 + 1), false, false, ""}, ltTestCase{uint64(kTwoTo54 + 2), false, false, ""}, // Floating point. ltTestCase{float64(-1), true, false, ""}, ltTestCase{float64(kTwoTo54 - 2), true, false, ""}, ltTestCase{float64(kTwoTo54 - 1), false, false, ""}, ltTestCase{float64(kTwoTo54 + 0), false, false, ""}, ltTestCase{float64(kTwoTo54 + 1), false, false, ""}, ltTestCase{float64(kTwoTo54 + 2), false, false, ""}, ltTestCase{float64(kTwoTo54 + 3), false, false, ""}, } t.checkTestCases(matcher, cases) } func (t *LessThanTest) Float32AboveExactIntegerRange() { // Single-precision floats don't have enough bits to represent the integers // near this one distinctly, so [2^25-1, 2^25+2] all receive the same value // and should be treated as equivalent when floats are in the mix. const kTwoTo25 = 1 << 25 matcher := LessThan(float32(kTwoTo25 + 1)) desc := matcher.Description() expectedDesc := "less than 3.3554432e+07" ExpectThat(desc, Equals(expectedDesc)) cases := []ltTestCase{ // Signed integers. ltTestCase{int64(-1), true, false, ""}, ltTestCase{int64(kTwoTo25 - 2), true, false, ""}, ltTestCase{int64(kTwoTo25 - 1), false, false, ""}, ltTestCase{int64(kTwoTo25 + 0), false, false, ""}, ltTestCase{int64(kTwoTo25 + 1), false, false, ""}, ltTestCase{int64(kTwoTo25 + 2), false, false, ""}, ltTestCase{int64(kTwoTo25 + 3), false, false, ""}, // Unsigned integers. ltTestCase{uint64(0), true, false, ""}, ltTestCase{uint64(kTwoTo25 - 2), true, false, ""}, ltTestCase{uint64(kTwoTo25 - 1), false, false, ""}, ltTestCase{uint64(kTwoTo25 + 0), false, false, ""}, ltTestCase{uint64(kTwoTo25 + 1), false, false, ""}, ltTestCase{uint64(kTwoTo25 + 2), false, false, ""}, ltTestCase{uint64(kTwoTo25 + 3), false, false, ""}, // Floating point. ltTestCase{float32(-1), true, false, ""}, ltTestCase{float32(kTwoTo25 - 2), true, false, ""}, ltTestCase{float32(kTwoTo25 - 1), false, false, ""}, ltTestCase{float32(kTwoTo25 + 0), false, false, ""}, ltTestCase{float32(kTwoTo25 + 1), false, false, ""}, ltTestCase{float32(kTwoTo25 + 2), false, false, ""}, ltTestCase{float32(kTwoTo25 + 3), false, false, ""}, ltTestCase{float64(-1), true, false, ""}, ltTestCase{float64(kTwoTo25 - 2), true, false, ""}, ltTestCase{float64(kTwoTo25 - 1), false, false, ""}, ltTestCase{float64(kTwoTo25 + 0), false, false, ""}, ltTestCase{float64(kTwoTo25 + 1), false, false, ""}, ltTestCase{float64(kTwoTo25 + 2), false, false, ""}, ltTestCase{float64(kTwoTo25 + 3), false, false, ""}, } t.checkTestCases(matcher, cases) } func (t *LessThanTest) Float64AboveExactIntegerRange() { // Double-precision floats don't have enough bits to represent the integers // near this one distinctly, so [2^54-1, 2^54+2] all receive the same value // and should be treated as equivalent when floats are in the mix. const kTwoTo54 = 1 << 54 matcher := LessThan(float64(kTwoTo54 + 1)) desc := matcher.Description() expectedDesc := "less than 1.8014398509481984e+16" ExpectThat(desc, Equals(expectedDesc)) cases := []ltTestCase{ // Signed integers. ltTestCase{int64(-1), true, false, ""}, ltTestCase{int64(kTwoTo54 - 2), true, false, ""}, ltTestCase{int64(kTwoTo54 - 1), false, false, ""}, ltTestCase{int64(kTwoTo54 + 0), false, false, ""}, ltTestCase{int64(kTwoTo54 + 1), false, false, ""}, ltTestCase{int64(kTwoTo54 + 2), false, false, ""}, ltTestCase{int64(kTwoTo54 + 3), false, false, ""}, // Unsigned integers. ltTestCase{uint64(0), true, false, ""}, ltTestCase{uint64(kTwoTo54 - 2), true, false, ""}, ltTestCase{uint64(kTwoTo54 - 1), false, false, ""}, ltTestCase{uint64(kTwoTo54 + 0), false, false, ""}, ltTestCase{uint64(kTwoTo54 + 1), false, false, ""}, ltTestCase{uint64(kTwoTo54 + 2), false, false, ""}, ltTestCase{uint64(kTwoTo54 + 3), false, false, ""}, // Floating point. ltTestCase{float64(-1), true, false, ""}, ltTestCase{float64(kTwoTo54 - 2), true, false, ""}, ltTestCase{float64(kTwoTo54 - 1), false, false, ""}, ltTestCase{float64(kTwoTo54 + 0), false, false, ""}, ltTestCase{float64(kTwoTo54 + 1), false, false, ""}, ltTestCase{float64(kTwoTo54 + 2), false, false, ""}, ltTestCase{float64(kTwoTo54 + 3), false, false, ""}, } t.checkTestCases(matcher, cases) } //////////////////////////////////////////////////////////////////////// // String literals //////////////////////////////////////////////////////////////////////// func (t *LessThanTest) EmptyString() { matcher := LessThan("") desc := matcher.Description() expectedDesc := "less than \"\"" ExpectThat(desc, Equals(expectedDesc)) cases := []ltTestCase{ ltTestCase{"", false, false, ""}, ltTestCase{"\x00", false, false, ""}, ltTestCase{"a", false, false, ""}, ltTestCase{"foo", false, false, ""}, } t.checkTestCases(matcher, cases) } func (t *LessThanTest) SingleNullByte() { matcher := LessThan("\x00") desc := matcher.Description() expectedDesc := "less than \"\x00\"" ExpectThat(desc, Equals(expectedDesc)) cases := []ltTestCase{ ltTestCase{"", true, false, ""}, ltTestCase{"\x00", false, false, ""}, ltTestCase{"a", false, false, ""}, ltTestCase{"foo", false, false, ""}, } t.checkTestCases(matcher, cases) } func (t *LessThanTest) LongerString() { matcher := LessThan("foo\x00") desc := matcher.Description() expectedDesc := "less than \"foo\x00\"" ExpectThat(desc, Equals(expectedDesc)) cases := []ltTestCase{ ltTestCase{"", true, false, ""}, ltTestCase{"\x00", true, false, ""}, ltTestCase{"bar", true, false, ""}, ltTestCase{"foo", true, false, ""}, ltTestCase{"foo\x00", false, false, ""}, ltTestCase{"fooa", false, false, ""}, ltTestCase{"qux", false, false, ""}, } t.checkTestCases(matcher, cases) } mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/matcher.go000066400000000000000000000071551321131462300336770ustar00rootroot00000000000000// Copyright 2011 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers provides a set of matchers useful in a testing or // mocking framework. These matchers are inspired by and mostly compatible with // Google Test for C++ and Google JS Test. // // This package is used by github.com/smartystreets/assertions/internal/ogletest and // github.com/smartystreets/assertions/internal/oglemock, which may be more directly useful if you're not // writing your own testing package or defining your own matchers. package oglematchers // A Matcher is some predicate implicitly defining a set of values that it // matches. For example, GreaterThan(17) matches all numeric values greater // than 17, and HasSubstr("taco") matches all strings with the substring // "taco". // // Matchers are typically exposed to tests via constructor functions like // HasSubstr. In order to implement such a function you can either define your // own matcher type or use NewMatcher. type Matcher interface { // Check whether the supplied value belongs to the the set defined by the // matcher. Return a non-nil error if and only if it does not. // // The error describes why the value doesn't match. The error text is a // relative clause that is suitable for being placed after the value. For // example, a predicate that matches strings with a particular substring may, // when presented with a numerical value, return the following error text: // // "which is not a string" // // Then the failure message may look like: // // Expected: has substring "taco" // Actual: 17, which is not a string // // If the error is self-apparent based on the description of the matcher, the // error text may be empty (but the error still non-nil). For example: // // Expected: 17 // Actual: 19 // // If you are implementing a new matcher, see also the documentation on // FatalError. Matches(candidate interface{}) error // Description returns a string describing the property that values matching // this matcher have, as a verb phrase where the subject is the value. For // example, "is greather than 17" or "has substring "taco"". Description() string } // FatalError is an implementation of the error interface that may be returned // from matchers, indicating the error should be propagated. Returning a // *FatalError indicates that the matcher doesn't process values of the // supplied type, or otherwise doesn't know how to handle the value. // // For example, if GreaterThan(17) returned false for the value "taco" without // a fatal error, then Not(GreaterThan(17)) would return true. This is // technically correct, but is surprising and may mask failures where the wrong // sort of matcher is accidentally used. Instead, GreaterThan(17) can return a // fatal error, which will be propagated by Not(). type FatalError struct { errorText string } // NewFatalError creates a FatalError struct with the supplied error text. func NewFatalError(s string) *FatalError { return &FatalError{s} } func (e *FatalError) Error() string { return e.errorText } matches_regexp.go000066400000000000000000000035061321131462300351670ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglematchers// Copyright 2011 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers import ( "errors" "fmt" "reflect" "regexp" ) // MatchesRegexp returns a matcher that matches strings and byte slices whose // contents match the supplied regular expression. The semantics are those of // regexp.Match. In particular, that means the match is not implicitly anchored // to the ends of the string: MatchesRegexp("bar") will match "foo bar baz". func MatchesRegexp(pattern string) Matcher { re, err := regexp.Compile(pattern) if err != nil { panic("MatchesRegexp: " + err.Error()) } return &matchesRegexpMatcher{re} } type matchesRegexpMatcher struct { re *regexp.Regexp } func (m *matchesRegexpMatcher) Description() string { return fmt.Sprintf("matches regexp \"%s\"", m.re.String()) } func (m *matchesRegexpMatcher) Matches(c interface{}) (err error) { v := reflect.ValueOf(c) isString := v.Kind() == reflect.String isByteSlice := v.Kind() == reflect.Slice && v.Elem().Kind() == reflect.Uint8 err = errors.New("") switch { case isString: if m.re.MatchString(v.String()) { err = nil } case isByteSlice: if m.re.Match(v.Bytes()) { err = nil } default: err = NewFatalError("which is not a string or []byte") } return } matches_regexp_test.go000066400000000000000000000047471321131462300362360ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglematchers// Copyright 2011 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers_test import ( . "github.com/smartystreets/assertions/internal/oglematchers" . "github.com/smartystreets/assertions/internal/ogletest" ) //////////////////////////////////////////////////////////////////////// // Helpers //////////////////////////////////////////////////////////////////////// type MatchesRegexpTest struct { } func init() { RegisterTestSuite(&MatchesRegexpTest{}) } //////////////////////////////////////////////////////////////////////// // Tests //////////////////////////////////////////////////////////////////////// func (t *MatchesRegexpTest) Description() { m := MatchesRegexp("foo.*bar") ExpectEq("matches regexp \"foo.*bar\"", m.Description()) } func (t *MatchesRegexpTest) InvalidRegexp() { ExpectThat( func() { MatchesRegexp("(foo") }, Panics(HasSubstr("missing closing )"))) } func (t *MatchesRegexpTest) CandidateIsNil() { m := MatchesRegexp("") err := m.Matches(nil) ExpectThat(err, Error(Equals("which is not a string or []byte"))) ExpectTrue(isFatal(err)) } func (t *MatchesRegexpTest) CandidateIsInteger() { m := MatchesRegexp("") err := m.Matches(17) ExpectThat(err, Error(Equals("which is not a string or []byte"))) ExpectTrue(isFatal(err)) } func (t *MatchesRegexpTest) NonMatchingCandidates() { m := MatchesRegexp("fo[op]\\s+x") var err error err = m.Matches("fon x") ExpectThat(err, Error(Equals(""))) ExpectFalse(isFatal(err)) err = m.Matches("fopx") ExpectThat(err, Error(Equals(""))) ExpectFalse(isFatal(err)) err = m.Matches("fop ") ExpectThat(err, Error(Equals(""))) ExpectFalse(isFatal(err)) } func (t *MatchesRegexpTest) MatchingCandidates() { m := MatchesRegexp("fo[op]\\s+x") var err error err = m.Matches("foo x") ExpectEq(nil, err) err = m.Matches("fop x") ExpectEq(nil, err) err = m.Matches("blah blah foo x blah blah") ExpectEq(nil, err) } new_matcher.go000066400000000000000000000025621321131462300344660ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglematchers// Copyright 2015 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers // Create a matcher with the given description and predicate function, which // will be invoked to handle calls to Matchers. // // Using this constructor may be a convenience over defining your own type that // implements Matcher if you do not need any logic in your Description method. func NewMatcher( predicate func(interface{}) error, description string) Matcher { return &predicateMatcher{ predicate: predicate, description: description, } } type predicateMatcher struct { predicate func(interface{}) error description string } func (pm *predicateMatcher) Matches(c interface{}) error { return pm.predicate(c) } func (pm *predicateMatcher) Description() string { return pm.description } mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/not.go000066400000000000000000000026601321131462300330500ustar00rootroot00000000000000// Copyright 2011 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers import ( "errors" "fmt" ) // Not returns a matcher that inverts the set of values matched by the wrapped // matcher. It does not transform the result for values for which the wrapped // matcher returns a fatal error. func Not(m Matcher) Matcher { return ¬Matcher{m} } type notMatcher struct { wrapped Matcher } func (m *notMatcher) Matches(c interface{}) (err error) { err = m.wrapped.Matches(c) // Did the wrapped matcher say yes? if err == nil { return errors.New("") } // Did the wrapped matcher return a fatal error? if _, isFatal := err.(*FatalError); isFatal { return err } // The wrapped matcher returned a non-fatal error. return nil } func (m *notMatcher) Description() string { return fmt.Sprintf("not(%s)", m.wrapped.Description()) } mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/not_test.go000066400000000000000000000052111321131462300341020ustar00rootroot00000000000000// Copyright 2011 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers_test import ( "errors" . "github.com/smartystreets/assertions/internal/oglematchers" . "github.com/smartystreets/assertions/internal/ogletest" "testing" ) //////////////////////////////////////////////////////////////////////// // Helpers //////////////////////////////////////////////////////////////////////// type fakeMatcher struct { matchFunc func(interface{}) error description string } func (m *fakeMatcher) Matches(c interface{}) error { return m.matchFunc(c) } func (m *fakeMatcher) Description() string { return m.description } type NotTest struct { } func init() { RegisterTestSuite(&NotTest{}) } func TestOgletest(t *testing.T) { RunTests(t) } //////////////////////////////////////////////////////////////////////// // Tests //////////////////////////////////////////////////////////////////////// func (t *NotTest) CallsWrapped() { var suppliedCandidate interface{} matchFunc := func(c interface{}) error { suppliedCandidate = c return nil } wrapped := &fakeMatcher{matchFunc, ""} matcher := Not(wrapped) matcher.Matches(17) ExpectThat(suppliedCandidate, Equals(17)) } func (t *NotTest) WrappedReturnsTrue() { matchFunc := func(c interface{}) error { return nil } wrapped := &fakeMatcher{matchFunc, ""} matcher := Not(wrapped) err := matcher.Matches(0) ExpectThat(err, Error(Equals(""))) } func (t *NotTest) WrappedReturnsNonFatalError() { matchFunc := func(c interface{}) error { return errors.New("taco") } wrapped := &fakeMatcher{matchFunc, ""} matcher := Not(wrapped) err := matcher.Matches(0) ExpectEq(nil, err) } func (t *NotTest) WrappedReturnsFatalError() { matchFunc := func(c interface{}) error { return NewFatalError("taco") } wrapped := &fakeMatcher{matchFunc, ""} matcher := Not(wrapped) err := matcher.Matches(0) ExpectThat(err, Error(Equals("taco"))) } func (t *NotTest) Description() { wrapped := &fakeMatcher{nil, "taco"} matcher := Not(wrapped) ExpectEq("not(taco)", matcher.Description()) } mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/panics.go000066400000000000000000000037631321131462300335320ustar00rootroot00000000000000// Copyright 2011 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers import ( "errors" "fmt" "reflect" ) // Panics matches zero-arg functions which, when invoked, panic with an error // that matches the supplied matcher. // // NOTE(jacobsa): This matcher cannot detect the case where the function panics // using panic(nil), by design of the language. See here for more info: // // http://goo.gl/9aIQL // func Panics(m Matcher) Matcher { return &panicsMatcher{m} } type panicsMatcher struct { wrappedMatcher Matcher } func (m *panicsMatcher) Description() string { return "panics with: " + m.wrappedMatcher.Description() } func (m *panicsMatcher) Matches(c interface{}) (err error) { // Make sure c is a zero-arg function. v := reflect.ValueOf(c) if v.Kind() != reflect.Func || v.Type().NumIn() != 0 { err = NewFatalError("which is not a zero-arg function") return } // Call the function and check its panic error. defer func() { if e := recover(); e != nil { err = m.wrappedMatcher.Matches(e) // Set a clearer error message if the matcher said no. if err != nil { wrappedClause := "" if err.Error() != "" { wrappedClause = ", " + err.Error() } err = errors.New(fmt.Sprintf("which panicked with: %v%s", e, wrappedClause)) } } }() v.Call([]reflect.Value{}) // If we get here, the function didn't panic. err = errors.New("which didn't panic") return } panics_test.go000066400000000000000000000073451321131462300345120ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglematchers// Copyright 2011 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers_test import ( "errors" . "github.com/smartystreets/assertions/internal/oglematchers" . "github.com/smartystreets/assertions/internal/ogletest" ) //////////////////////////////////////////////////////////////////////// // Helpers //////////////////////////////////////////////////////////////////////// type PanicsTest struct { matcherCalled bool suppliedCandidate interface{} wrappedError error matcher Matcher } func init() { RegisterTestSuite(&PanicsTest{}) } func (t *PanicsTest) SetUp(i *TestInfo) { wrapped := &fakeMatcher{ func(c interface{}) error { t.matcherCalled = true t.suppliedCandidate = c return t.wrappedError }, "foo", } t.matcher = Panics(wrapped) } //////////////////////////////////////////////////////////////////////// // Tests //////////////////////////////////////////////////////////////////////// func (t *PanicsTest) Description() { ExpectThat(t.matcher.Description(), Equals("panics with: foo")) } func (t *PanicsTest) CandidateIsNil() { err := t.matcher.Matches(nil) ExpectThat(err, Error(Equals("which is not a zero-arg function"))) ExpectTrue(isFatal(err)) } func (t *PanicsTest) CandidateIsString() { err := t.matcher.Matches("taco") ExpectThat(err, Error(Equals("which is not a zero-arg function"))) ExpectTrue(isFatal(err)) } func (t *PanicsTest) CandidateTakesArgs() { err := t.matcher.Matches(func(i int) string { return "" }) ExpectThat(err, Error(Equals("which is not a zero-arg function"))) ExpectTrue(isFatal(err)) } func (t *PanicsTest) CallsFunction() { callCount := 0 t.matcher.Matches(func() string { callCount++ return "" }) ExpectThat(callCount, Equals(1)) } func (t *PanicsTest) FunctionDoesntPanic() { err := t.matcher.Matches(func() {}) ExpectThat(err, Error(Equals("which didn't panic"))) ExpectFalse(isFatal(err)) } func (t *PanicsTest) CallsWrappedMatcher() { expectedErr := 17 t.wrappedError = errors.New("") t.matcher.Matches(func() { panic(expectedErr) }) ExpectThat(t.suppliedCandidate, Equals(expectedErr)) } func (t *PanicsTest) WrappedReturnsTrue() { err := t.matcher.Matches(func() { panic("") }) ExpectEq(nil, err) } func (t *PanicsTest) WrappedReturnsFatalErrorWithoutText() { t.wrappedError = NewFatalError("") err := t.matcher.Matches(func() { panic(17) }) ExpectThat(err, Error(Equals("which panicked with: 17"))) ExpectFalse(isFatal(err)) } func (t *PanicsTest) WrappedReturnsFatalErrorWithText() { t.wrappedError = NewFatalError("which blah") err := t.matcher.Matches(func() { panic(17) }) ExpectThat(err, Error(Equals("which panicked with: 17, which blah"))) ExpectFalse(isFatal(err)) } func (t *PanicsTest) WrappedReturnsNonFatalErrorWithoutText() { t.wrappedError = errors.New("") err := t.matcher.Matches(func() { panic(17) }) ExpectThat(err, Error(Equals("which panicked with: 17"))) ExpectFalse(isFatal(err)) } func (t *PanicsTest) WrappedReturnsNonFatalErrorWithText() { t.wrappedError = errors.New("which blah") err := t.matcher.Matches(func() { panic(17) }) ExpectThat(err, Error(Equals("which panicked with: 17, which blah"))) ExpectFalse(isFatal(err)) } mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglematchers/pointee.go000066400000000000000000000034051321131462300337110ustar00rootroot00000000000000// Copyright 2012 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers import ( "errors" "fmt" "reflect" ) // Return a matcher that matches non-nil pointers whose pointee matches the // wrapped matcher. func Pointee(m Matcher) Matcher { return &pointeeMatcher{m} } type pointeeMatcher struct { wrapped Matcher } func (m *pointeeMatcher) Matches(c interface{}) (err error) { // Make sure the candidate is of the appropriate type. cv := reflect.ValueOf(c) if !cv.IsValid() || cv.Kind() != reflect.Ptr { return NewFatalError("which is not a pointer") } // Make sure the candidate is non-nil. if cv.IsNil() { return NewFatalError("") } // Defer to the wrapped matcher. Fix up empty errors so that failure messages // are more helpful than just printing a pointer for "Actual". pointee := cv.Elem().Interface() err = m.wrapped.Matches(pointee) if err != nil && err.Error() == "" { s := fmt.Sprintf("whose pointee is %v", pointee) if _, ok := err.(*FatalError); ok { err = NewFatalError(s) } else { err = errors.New(s) } } return err } func (m *pointeeMatcher) Description() string { return fmt.Sprintf("pointee(%s)", m.wrapped.Description()) } pointee_test.go000066400000000000000000000075751321131462300347050ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglematchers// Copyright 2012 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers_test import ( "errors" . "github.com/smartystreets/assertions/internal/oglematchers" . "github.com/smartystreets/assertions/internal/ogletest" "testing" ) //////////////////////////////////////////////////////////////////////// // Helpers //////////////////////////////////////////////////////////////////////// type PointeeTest struct {} func init() { RegisterTestSuite(&PointeeTest{}) } func TestPointee(t *testing.T) { RunTests(t) } //////////////////////////////////////////////////////////////////////// // Tests //////////////////////////////////////////////////////////////////////// func (t *PointeeTest) Description() { wrapped := &fakeMatcher{nil, "taco"} matcher := Pointee(wrapped) ExpectEq("pointee(taco)", matcher.Description()) } func (t *PointeeTest) CandidateIsNotAPointer() { matcher := Pointee(HasSubstr("")) err := matcher.Matches([]byte{}) ExpectThat(err, Error(Equals("which is not a pointer"))) ExpectTrue(isFatal(err)) } func (t *PointeeTest) CandidateIsANilLiteral() { matcher := Pointee(HasSubstr("")) err := matcher.Matches(nil) ExpectThat(err, Error(Equals("which is not a pointer"))) ExpectTrue(isFatal(err)) } func (t *PointeeTest) CandidateIsANilPointer() { matcher := Pointee(HasSubstr("")) err := matcher.Matches((*int)(nil)) ExpectThat(err, Error(Equals(""))) ExpectTrue(isFatal(err)) } func (t *PointeeTest) CallsWrapped() { var suppliedCandidate interface{} matchFunc := func(c interface{}) error { suppliedCandidate = c return nil } wrapped := &fakeMatcher{matchFunc, ""} matcher := Pointee(wrapped) someSlice := []byte{} matcher.Matches(&someSlice) ExpectThat(suppliedCandidate, IdenticalTo(someSlice)) } func (t *PointeeTest) WrappedReturnsOkay() { matchFunc := func(c interface{}) error { return nil } wrapped := &fakeMatcher{matchFunc, ""} matcher := Pointee(wrapped) err := matcher.Matches(new(int)) ExpectEq(nil, err) } func (t *PointeeTest) WrappedReturnsNonFatalNonEmptyError() { matchFunc := func(c interface{}) error { return errors.New("taco") } wrapped := &fakeMatcher{matchFunc, ""} matcher := Pointee(wrapped) i := 17 err := matcher.Matches(&i) ExpectFalse(isFatal(err)) ExpectThat(err, Error(Equals("taco"))) } func (t *PointeeTest) WrappedReturnsNonFatalEmptyError() { matchFunc := func(c interface{}) error { return errors.New("") } wrapped := &fakeMatcher{matchFunc, ""} matcher := Pointee(wrapped) i := 17 err := matcher.Matches(&i) ExpectFalse(isFatal(err)) ExpectThat(err, Error(HasSubstr("whose pointee"))) ExpectThat(err, Error(HasSubstr("17"))) } func (t *PointeeTest) WrappedReturnsFatalNonEmptyError() { matchFunc := func(c interface{}) error { return NewFatalError("taco") } wrapped := &fakeMatcher{matchFunc, ""} matcher := Pointee(wrapped) i := 17 err := matcher.Matches(&i) ExpectTrue(isFatal(err)) ExpectThat(err, Error(Equals("taco"))) } func (t *PointeeTest) WrappedReturnsFatalEmptyError() { matchFunc := func(c interface{}) error { return NewFatalError("") } wrapped := &fakeMatcher{matchFunc, ""} matcher := Pointee(wrapped) i := 17 err := matcher.Matches(&i) ExpectTrue(isFatal(err)) ExpectThat(err, Error(HasSubstr("whose pointee"))) ExpectThat(err, Error(HasSubstr("17"))) } transform_description.go000066400000000000000000000023431321131462300366050ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglematchers// Copyright 2011 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers // transformDescription returns a matcher that is equivalent to the supplied // one, except that it has the supplied description instead of the one attached // to the existing matcher. func transformDescription(m Matcher, newDesc string) Matcher { return &transformDescriptionMatcher{newDesc, m} } type transformDescriptionMatcher struct { desc string wrappedMatcher Matcher } func (m *transformDescriptionMatcher) Description() string { return m.desc } func (m *transformDescriptionMatcher) Matches(c interface{}) error { return m.wrappedMatcher.Matches(c) } mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglemock/000077500000000000000000000000001321131462300310405ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglemock/.gitignore000066400000000000000000000000441321131462300330260ustar00rootroot00000000000000*.6 6.out _obj/ _test/ _testmain.go mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglemock/.travis.yml000066400000000000000000000001671321131462300331550ustar00rootroot00000000000000# Cf. http://docs.travis-ci.com/user/getting-started/ # Cf. http://docs.travis-ci.com/user/languages/go/ language: go mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglemock/LICENSE000066400000000000000000000261361321131462300320550ustar00rootroot00000000000000 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. mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglemock/README.md000066400000000000000000000101721321131462300323200ustar00rootroot00000000000000[![GoDoc](https://godoc.org/github.com/smartystreets/assertions/internal/oglemock?status.svg)](https://godoc.org/github.com/smartystreets/assertions/internal/oglemock) `oglemock` is a mocking framework for the Go programming language with the following features: * An extensive and extensible set of matchers for expressing call expectations (provided by the [oglematchers][] package). * Clean, readable output that tells you exactly what you need to know. * Style and semantics similar to [Google Mock][googlemock] and [Google JS Test][google-js-test]. * Seamless integration with the [ogletest][] unit testing framework. It can be integrated into any testing framework (including Go's `testing` package), but out of the box support is built in to [ogletest][] and that is the easiest place to use it. Installation ------------ First, make sure you have installed Go 1.0.2 or newer. See [here][golang-install] for instructions. Use the following command to install `oglemock` and its dependencies, and to keep them up to date: go get -u github.com/smartystreets/assertions/internal/oglemock go get -u github.com/smartystreets/assertions/internal/oglemock/createmock Those commands will install the `oglemock` package itself, along with the `createmock` tool that is used to auto-generate mock types. Generating and using mock types ------------------------------- Automatically generating a mock implementation of an interface is easy. If you want to mock interfaces `Bar` and `Baz` from package `foo`, simply run the following: createmock foo Bar Baz That will print source code that can be saved to a file and used in your tests. For example, to create a `mock_io` package containing mock implementations of `io.Reader` and `io.Writer`: mkdir mock_io createmock io Reader Writer > mock_io/mock_io.go The new package will be named `mock_io`, and contain types called `MockReader` and `MockWriter`, which implement `io.Reader` and `io.Writer` respectively. For each generated mock type, there is a corresponding function for creating an instance of that type given a `Controller` object (see below). For example, to create a mock reader: ```go someController := [...] // See next section. someReader := mock_io.NewMockReader(someController, "Mock file reader") ``` The snippet above creates a mock `io.Reader` that reports failures to `someController`. The reader can subsequently have expectations set up and be passed to your code under test that uses an `io.Reader`. Getting ahold of a controller ----------------------------- [oglemock.Controller][controller-ref] is used to create mock objects, and to set up and verify expectations for them. You can create one by calling `NewController` with an `ErrorReporter`, which is the basic type used to interface between `oglemock` and the testing framework within which it is being used. If you are using [ogletest][] you don't need to worry about any of this, since the `TestInfo` struct provided to your test's `SetUp` function already contains a working `Controller` that you can use to create mock object, and you can use the built-in `ExpectCall` function for setting expectations. (See the [ogletest documentation][ogletest-docs] for more info.) Otherwise, you will need to implement the simple [ErrorReporter interface][reporter-ref] for your test environment. Documentation ------------- For thorough documentation, including information on how to set up expectations, see [here][oglemock-docs]. [controller-ref]: http://godoc.org/github.com/smartystreets/assertions/internal/oglemock#Controller [reporter-ref]: http://godoc.org/github.com/smartystreets/assertions/internal/oglemock#ErrorReporter [golang-install]: http://golang.org/doc/install.html [google-js-test]: http://code.google.com/p/google-js-test/ [googlemock]: http://code.google.com/p/googlemock/ [oglematchers]: https://github.com/smartystreets/assertions/internal/oglematchers [oglemock-docs]: http://godoc.org/github.com/smartystreets/assertions/internal/oglemock [ogletest]: https://github.com/smartystreets/assertions/internal/ogletest [ogletest-docs]: http://godoc.org/github.com/smartystreets/assertions/internal/ogletest mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglemock/action.go000066400000000000000000000024711321131462300326500ustar00rootroot00000000000000// Copyright 2011 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglemock import ( "reflect" ) // Action represents an action to be taken in response to a call to a mock // method. type Action interface { // Set the signature of the function with which this action is being used. // This must be called before Invoke is called. SetSignature(signature reflect.Type) error // Invoke runs the specified action, given the arguments to the mock method. // It returns zero or more values that may be treated as the return values of // the method. If the action doesn't return any values, it may return the nil // slice. // // You must call SetSignature before calling Invoke. Invoke(methodArgs []interface{}) []interface{} } mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglemock/controller.go000066400000000000000000000321141321131462300335530ustar00rootroot00000000000000// Copyright 2011 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglemock import ( "errors" "fmt" "log" "math" "reflect" "sync" ) // PartialExpecation is a function that should be called exactly once with // expected arguments or matchers in order to set up an expected method call. // See Controller.ExpectMethodCall below. It returns an expectation that can be // further modified (e.g. by calling WillOnce). // // If the arguments are of the wrong type, the function reports a fatal error // and returns nil. type PartialExpecation func(...interface{}) Expectation // Controller represents an object that implements the central logic of // oglemock: recording and verifying expectations, responding to mock method // calls, and so on. type Controller interface { // ExpectCall expresses an expectation that the method of the given name // should be called on the supplied mock object. It returns a function that // should be called with the expected arguments, matchers for the arguments, // or a mix of both. // // fileName and lineNumber should indicate the line on which the expectation // was made, if known. // // For example: // // mockWriter := [...] // controller.ExpectCall(mockWriter, "Write", "foo.go", 17)(ElementsAre(0x1)) // .WillOnce(Return(1, nil)) // // If the mock object doesn't have a method of the supplied name, the // function reports a fatal error and returns nil. ExpectCall( o MockObject, methodName string, fileName string, lineNumber int) PartialExpecation // Finish causes the controller to check for any unsatisfied expectations, // and report them as errors if they exist. // // The controller may panic if any of its methods (including this one) are // called after Finish is called. Finish() // HandleMethodCall looks for a registered expectation matching the call of // the given method on mock object o, invokes the appropriate action (if // any), and returns the values returned by that action (if any). // // If the action returns nothing, the controller returns zero values. If // there is no matching expectation, the controller reports an error and // returns zero values. // // If the mock object doesn't have a method of the supplied name, the // arguments are of the wrong type, or the action returns the wrong types, // the function reports a fatal error. // // HandleMethodCall is exported for the sake of mock implementations, and // should not be used directly. HandleMethodCall( o MockObject, methodName string, fileName string, lineNumber int, args []interface{}) []interface{} } // methodMap represents a map from method name to set of expectations for that // method. type methodMap map[string][]*InternalExpectation // objectMap represents a map from mock object ID to a methodMap for that object. type objectMap map[uintptr]methodMap // NewController sets up a fresh controller, without any expectations set, and // configures the controller to use the supplied error reporter. func NewController(reporter ErrorReporter) Controller { return &controllerImpl{reporter, sync.RWMutex{}, objectMap{}} } type controllerImpl struct { reporter ErrorReporter mutex sync.RWMutex expectationsByObject objectMap // Protected by mutex } // Return the list of registered expectations for the named method of the // supplied object, or an empty slice if none have been registered. When this // method returns, it is guaranteed that c.expectationsByObject has an entry // for the object. // // c.mutex must be held for reading. func (c *controllerImpl) getExpectationsLocked( o MockObject, methodName string) []*InternalExpectation { id := o.Oglemock_Id() // Look up the mock object. expectationsByMethod, ok := c.expectationsByObject[id] if !ok { expectationsByMethod = methodMap{} c.expectationsByObject[id] = expectationsByMethod } result, ok := expectationsByMethod[methodName] if !ok { return []*InternalExpectation{} } return result } // Add an expectation to the list registered for the named method of the // supplied mock object. // // c.mutex must be held for writing. func (c *controllerImpl) addExpectationLocked( o MockObject, methodName string, exp *InternalExpectation) { // Get the existing list. existing := c.getExpectationsLocked(o, methodName) // Store a modified list. id := o.Oglemock_Id() c.expectationsByObject[id][methodName] = append(existing, exp) } func (c *controllerImpl) ExpectCall( o MockObject, methodName string, fileName string, lineNumber int) PartialExpecation { // Find the signature for the requested method. ov := reflect.ValueOf(o) method := ov.MethodByName(methodName) if method.Kind() == reflect.Invalid { c.reporter.ReportFatalError( fileName, lineNumber, errors.New("Unknown method: "+methodName)) return nil } partialAlreadyCalled := false // Protected by c.mutex return func(args ...interface{}) Expectation { c.mutex.Lock() defer c.mutex.Unlock() // This function should only be called once. if partialAlreadyCalled { c.reporter.ReportFatalError( fileName, lineNumber, errors.New("Partial expectation called more than once.")) return nil } partialAlreadyCalled = true // Make sure that the number of args is legal. Keep in mind that the // method's type has an extra receiver arg. if len(args) != method.Type().NumIn() { c.reporter.ReportFatalError( fileName, lineNumber, errors.New( fmt.Sprintf( "Expectation for %s given wrong number of arguments: "+ "expected %d, got %d.", methodName, method.Type().NumIn(), len(args)))) return nil } // Create an expectation and insert it into the controller's map. exp := InternalNewExpectation( c.reporter, method.Type(), args, fileName, lineNumber) c.addExpectationLocked(o, methodName, exp) // Return the expectation to the user. return exp } } func (c *controllerImpl) Finish() { c.mutex.Lock() defer c.mutex.Unlock() // Check whether the minimum cardinality for each registered expectation has // been satisfied. for _, expectationsByMethod := range c.expectationsByObject { for methodName, expectations := range expectationsByMethod { for _, exp := range expectations { exp.mutex.Lock() defer exp.mutex.Unlock() minCardinality, _ := computeCardinalityLocked(exp) if exp.NumMatches < minCardinality { c.reporter.ReportError( exp.FileName, exp.LineNumber, errors.New( fmt.Sprintf( "Unsatisfied expectation; expected %s to be called "+ "at least %d times; called %d times.", methodName, minCardinality, exp.NumMatches))) } } } } } // expectationMatches checks the matchers for the expectation against the // supplied arguments. func expectationMatches(exp *InternalExpectation, args []interface{}) bool { matchers := exp.ArgMatchers if len(args) != len(matchers) { panic("expectationMatches: len(args)") } // Check each matcher. for i, matcher := range matchers { if err := matcher.Matches(args[i]); err != nil { return false } } return true } // Return the expectation that matches the supplied arguments. If there is more // than one such expectation, the one furthest along in the list for the method // is returned. If there is no such expectation, nil is returned. // // c.mutex must be held for reading. func (c *controllerImpl) chooseExpectationLocked( o MockObject, methodName string, args []interface{}) *InternalExpectation { // Do we have any expectations for this method? expectations := c.getExpectationsLocked(o, methodName) if len(expectations) == 0 { return nil } for i := len(expectations) - 1; i >= 0; i-- { if expectationMatches(expectations[i], args) { return expectations[i] } } return nil } // makeZeroReturnValues creates a []interface{} containing appropriate zero // values for returning from the supplied method type. func makeZeroReturnValues(signature reflect.Type) []interface{} { result := make([]interface{}, signature.NumOut()) for i, _ := range result { outType := signature.Out(i) zeroVal := reflect.Zero(outType) result[i] = zeroVal.Interface() } return result } // computeCardinality decides on the [min, max] range of the number of expected // matches for the supplied expectations, according to the rules documented in // expectation.go. // // exp.mutex must be held for reading. func computeCardinalityLocked(exp *InternalExpectation) (min, max uint) { // Explicit cardinality. if exp.ExpectedNumMatches >= 0 { min = uint(exp.ExpectedNumMatches) max = min return } // Implicit count based on one-time actions. if len(exp.OneTimeActions) != 0 { min = uint(len(exp.OneTimeActions)) max = min // If there is a fallback action, this is only a lower bound. if exp.FallbackAction != nil { max = math.MaxUint32 } return } // Implicit lack of restriction based on a fallback action being configured. if exp.FallbackAction != nil { min = 0 max = math.MaxUint32 return } // Implicit cardinality of one. min = 1 max = 1 return } // chooseAction returns the action that should be invoked for the i'th match to // the supplied expectation (counting from zero). If the implicit "return zero // values" action should be used, it returns nil. // // exp.mutex must be held for reading. func chooseActionLocked(i uint, exp *InternalExpectation) Action { // Exhaust one-time actions first. if i < uint(len(exp.OneTimeActions)) { return exp.OneTimeActions[i] } // Fallback action (or nil if none is configured). return exp.FallbackAction } // Find an action for the method call, updating expectation match state in the // process. Return either an action that should be invoked or a set of zero // values to return immediately. // // This is split out from HandleMethodCall in order to more easily avoid // invoking the action with locks held. func (c *controllerImpl) chooseActionAndUpdateExpectations( o MockObject, methodName string, fileName string, lineNumber int, args []interface{}, ) (action Action, zeroVals []interface{}) { c.mutex.Lock() defer c.mutex.Unlock() // Find the signature for the requested method. ov := reflect.ValueOf(o) method := ov.MethodByName(methodName) if method.Kind() == reflect.Invalid { c.reporter.ReportFatalError( fileName, lineNumber, errors.New("Unknown method: "+methodName), ) // Should never get here in real code. log.Println("ReportFatalError unexpectedly returned.") return } // HACK(jacobsa): Make sure we got the correct number of arguments. This will // need to be refined when issue #5 (variadic methods) is handled. if len(args) != method.Type().NumIn() { c.reporter.ReportFatalError( fileName, lineNumber, errors.New( fmt.Sprintf( "Wrong number of arguments: expected %d; got %d", method.Type().NumIn(), len(args), ), ), ) // Should never get here in real code. log.Println("ReportFatalError unexpectedly returned.") return } // Find an expectation matching this call. expectation := c.chooseExpectationLocked(o, methodName, args) if expectation == nil { c.reporter.ReportError( fileName, lineNumber, errors.New( fmt.Sprintf("Unexpected call to %s with args: %v", methodName, args), ), ) zeroVals = makeZeroReturnValues(method.Type()) return } expectation.mutex.Lock() defer expectation.mutex.Unlock() // Increase the number of matches recorded, and check whether we're over the // number expected. expectation.NumMatches++ _, maxCardinality := computeCardinalityLocked(expectation) if expectation.NumMatches > maxCardinality { c.reporter.ReportError( expectation.FileName, expectation.LineNumber, errors.New( fmt.Sprintf( "Unexpected call to %s: "+ "expected to be called at most %d times; called %d times.", methodName, maxCardinality, expectation.NumMatches, ), ), ) zeroVals = makeZeroReturnValues(method.Type()) return } // Choose an action to invoke. If there is none, just return zero values. action = chooseActionLocked(expectation.NumMatches-1, expectation) if action == nil { zeroVals = makeZeroReturnValues(method.Type()) return } // Let the action take over. return } func (c *controllerImpl) HandleMethodCall( o MockObject, methodName string, fileName string, lineNumber int, args []interface{}, ) []interface{} { // Figure out whether to invoke an action or return zero values. action, zeroVals := c.chooseActionAndUpdateExpectations( o, methodName, fileName, lineNumber, args, ) if action != nil { return action.Invoke(args) } return zeroVals } controller_test.go000066400000000000000000000665431321131462300345500ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglemock// Copyright 2011 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglemock_test import ( . "github.com/smartystreets/assertions/internal/oglematchers" . "github.com/smartystreets/assertions/internal/oglemock" . "github.com/smartystreets/assertions/internal/ogletest" "reflect" ) //////////////////////////////////////////////////////////// // Helpers //////////////////////////////////////////////////////////// type errorReport struct { fileName string lineNumber int err error } type fakeErrorReporter struct { errors []errorReport fatalErrors []errorReport } func (r *fakeErrorReporter) ReportError(fileName string, lineNumber int, err error) { report := errorReport{fileName, lineNumber, err} r.errors = append(r.errors, report) } func (r *fakeErrorReporter) ReportFatalError(fileName string, lineNumber int, err error) { report := errorReport{fileName, lineNumber, err} r.fatalErrors = append(r.fatalErrors, report) } type trivialMockObject struct { id uintptr desc string } func (o *trivialMockObject) Oglemock_Id() uintptr { return o.id } func (o *trivialMockObject) Oglemock_Description() string { return o.desc } // Method being mocked func (o *trivialMockObject) StringToInt(s string) int { return 0 } // Method being mocked func (o *trivialMockObject) TwoIntsToString(i, j int) string { return "" } type ControllerTest struct { reporter fakeErrorReporter controller Controller mock1 MockObject mock2 MockObject } func (t *ControllerTest) SetUp(c *TestInfo) { t.reporter.errors = make([]errorReport, 0) t.reporter.fatalErrors = make([]errorReport, 0) t.controller = NewController(&t.reporter) t.mock1 = &trivialMockObject{17, "taco"} t.mock2 = &trivialMockObject{19, "burrito"} } func init() { RegisterTestSuite(&ControllerTest{}) } //////////////////////////////////////////////////////////// // Tests //////////////////////////////////////////////////////////// func (t *ControllerTest) FinishWithoutAnyEvents() { t.controller.Finish() ExpectEq(0, len(t.reporter.errors)) ExpectEq(0, len(t.reporter.fatalErrors)) } func (t *ControllerTest) HandleCallForUnknownObject() { p := []byte{255} t.controller.HandleMethodCall( t.mock1, "StringToInt", "taco.go", 112, []interface{}{p}) // The error should be reported immediately. AssertEq(1, len(t.reporter.errors)) AssertEq(0, len(t.reporter.fatalErrors)) ExpectEq("taco.go", t.reporter.errors[0].fileName) ExpectEq(112, t.reporter.errors[0].lineNumber) ExpectThat(t.reporter.errors[0].err, Error(HasSubstr("Unexpected"))) ExpectThat(t.reporter.errors[0].err, Error(HasSubstr("StringToInt"))) ExpectThat(t.reporter.errors[0].err, Error(HasSubstr("[255]"))) // Finish should change nothing. t.controller.Finish() ExpectEq(1, len(t.reporter.errors)) ExpectEq(0, len(t.reporter.fatalErrors)) } func (t *ControllerTest) ExpectCallForUnknownMethod() { ExpectEq( nil, t.controller.ExpectCall(t.mock1, "Frobnicate", "burrito.go", 117)) // A fatal error should be reported immediately. AssertEq(0, len(t.reporter.errors)) AssertEq(1, len(t.reporter.fatalErrors)) report := t.reporter.fatalErrors[0] ExpectEq("burrito.go", report.fileName) ExpectEq(117, report.lineNumber) ExpectThat(report.err, Error(HasSubstr("Unknown method"))) ExpectThat(report.err, Error(HasSubstr("Frobnicate"))) } func (t *ControllerTest) PartialExpectationGivenWrongNumberOfArgs() { ExpectEq( nil, t.controller.ExpectCall(t.mock1, "TwoIntsToString", "burrito.go", 117)( 17, 19, 23)) // A fatal error should be reported immediately. AssertEq(0, len(t.reporter.errors)) AssertEq(1, len(t.reporter.fatalErrors)) report := t.reporter.fatalErrors[0] ExpectEq("burrito.go", report.fileName) ExpectEq(117, report.lineNumber) ExpectThat(report.err, Error(HasSubstr("TwoIntsToString"))) ExpectThat(report.err, Error(HasSubstr("arguments"))) ExpectThat(report.err, Error(HasSubstr("expected 2"))) ExpectThat(report.err, Error(HasSubstr("got 3"))) } func (t *ControllerTest) PartialExpectationCalledTwice() { partial := t.controller.ExpectCall(t.mock1, "StringToInt", "burrito.go", 117) AssertNe(nil, partial("taco")) ExpectEq(nil, partial("taco")) // A fatal error should be reported immediately. AssertEq(0, len(t.reporter.errors)) AssertEq(1, len(t.reporter.fatalErrors)) report := t.reporter.fatalErrors[0] ExpectEq("burrito.go", report.fileName) ExpectEq(117, report.lineNumber) ExpectThat(report.err, Error(HasSubstr("called more than once"))) } func (t *ControllerTest) HandleMethodCallForUnknownMethod() { ExpectEq( nil, t.controller.HandleMethodCall( t.mock1, "Frobnicate", "burrito.go", 117, []interface{}{})) // A fatal error should be reported immediately. AssertEq(0, len(t.reporter.errors)) AssertEq(1, len(t.reporter.fatalErrors)) report := t.reporter.fatalErrors[0] ExpectEq("burrito.go", report.fileName) ExpectEq(117, report.lineNumber) ExpectThat(report.err, Error(HasSubstr("Unknown method"))) ExpectThat(report.err, Error(HasSubstr("Frobnicate"))) } func (t *ControllerTest) HandleMethodCallGivenWrongNumberOfArgs() { t.controller.ExpectCall(t.mock1, "TwoIntsToString", "", 0)(17, 19) ExpectEq( nil, t.controller.HandleMethodCall( t.mock1, "TwoIntsToString", "burrito.go", 117, []interface{}{17, 19, 23})) // A fatal error should be reported immediately. AssertEq(0, len(t.reporter.errors)) AssertEq(1, len(t.reporter.fatalErrors)) report := t.reporter.fatalErrors[0] ExpectEq("burrito.go", report.fileName) ExpectEq(117, report.lineNumber) ExpectThat(report.err, Error(HasSubstr("arguments"))) ExpectThat(report.err, Error(HasSubstr("expected 2"))) ExpectThat(report.err, Error(HasSubstr("got 3"))) } func (t *ControllerTest) ExpectThenNonMatchingCall() { // Expectation -- set up a fallback action to make it optional. partial := t.controller.ExpectCall( t.mock1, "TwoIntsToString", "burrito.go", 117) exp := partial(LessThan(10), Equals(2)) exp.WillRepeatedly(Return("")) // Call t.controller.HandleMethodCall( t.mock1, "TwoIntsToString", "taco.go", 112, []interface{}{8, 1}) // The error should be reported immediately. AssertEq(1, len(t.reporter.errors)) AssertEq(0, len(t.reporter.fatalErrors)) ExpectEq("taco.go", t.reporter.errors[0].fileName) ExpectEq(112, t.reporter.errors[0].lineNumber) ExpectThat(t.reporter.errors[0].err, Error(HasSubstr("Unexpected"))) ExpectThat(t.reporter.errors[0].err, Error(HasSubstr("TwoIntsToString"))) ExpectThat(t.reporter.errors[0].err, Error(HasSubstr("[8 1]"))) // Finish should change nothing. t.controller.Finish() ExpectEq(1, len(t.reporter.errors)) ExpectEq(0, len(t.reporter.fatalErrors)) } func (t *ControllerTest) ExplicitCardinalityNotSatisfied() { // Expectation -- set up an explicit cardinality of three. partial := t.controller.ExpectCall( t.mock1, "StringToInt", "burrito.go", 117) exp := partial(HasSubstr("")) exp.Times(3) // Call twice. t.controller.HandleMethodCall( t.mock1, "StringToInt", "", 0, []interface{}{""}) t.controller.HandleMethodCall( t.mock1, "StringToInt", "", 0, []interface{}{""}) // The error should not yet be reported. ExpectEq(0, len(t.reporter.errors)) ExpectEq(0, len(t.reporter.fatalErrors)) // Finish should cause the error to be reported. t.controller.Finish() AssertEq(1, len(t.reporter.errors)) AssertEq(0, len(t.reporter.fatalErrors)) ExpectEq("burrito.go", t.reporter.errors[0].fileName) ExpectEq(117, t.reporter.errors[0].lineNumber) ExpectThat(t.reporter.errors[0].err, Error(HasSubstr("Unsatisfied"))) ExpectThat(t.reporter.errors[0].err, Error(HasSubstr("StringToInt"))) ExpectThat(t.reporter.errors[0].err, Error(HasSubstr("at least 3 times"))) ExpectThat(t.reporter.errors[0].err, Error(HasSubstr("called 2 times"))) } func (t *ControllerTest) ImplicitOneTimeActionCountNotSatisfied() { // Expectation -- add three one-time actions. partial := t.controller.ExpectCall( t.mock1, "StringToInt", "burrito.go", 117) exp := partial(HasSubstr("")) exp.WillOnce(Return(0)) exp.WillOnce(Return(1)) exp.WillOnce(Return(2)) // Call twice. t.controller.HandleMethodCall( t.mock1, "StringToInt", "", 0, []interface{}{""}) t.controller.HandleMethodCall( t.mock1, "StringToInt", "", 0, []interface{}{""}) // The error should not yet be reported. ExpectEq(0, len(t.reporter.errors)) ExpectEq(0, len(t.reporter.fatalErrors)) // Finish should cause the error to be reported. t.controller.Finish() AssertEq(1, len(t.reporter.errors)) AssertEq(0, len(t.reporter.fatalErrors)) ExpectEq("burrito.go", t.reporter.errors[0].fileName) ExpectEq(117, t.reporter.errors[0].lineNumber) ExpectThat(t.reporter.errors[0].err, Error(HasSubstr("Unsatisfied"))) ExpectThat(t.reporter.errors[0].err, Error(HasSubstr("StringToInt"))) ExpectThat(t.reporter.errors[0].err, Error(HasSubstr("at least 3 times"))) ExpectThat(t.reporter.errors[0].err, Error(HasSubstr("called 2 times"))) } func (t *ControllerTest) ImplicitOneTimeActionLowerBoundNotSatisfied() { // Expectation -- add three one-time actions and a fallback. partial := t.controller.ExpectCall( t.mock1, "StringToInt", "burrito.go", 117) exp := partial(HasSubstr("")) exp.WillOnce(Return(0)) exp.WillOnce(Return(1)) exp.WillOnce(Return(2)) exp.WillRepeatedly(Return(3)) // Call twice. t.controller.HandleMethodCall( t.mock1, "StringToInt", "", 0, []interface{}{""}) t.controller.HandleMethodCall( t.mock1, "StringToInt", "", 0, []interface{}{""}) // The error should not yet be reported. ExpectEq(0, len(t.reporter.errors)) ExpectEq(0, len(t.reporter.fatalErrors)) // Finish should cause the error to be reported. t.controller.Finish() AssertEq(1, len(t.reporter.errors)) AssertEq(0, len(t.reporter.fatalErrors)) ExpectEq("burrito.go", t.reporter.errors[0].fileName) ExpectEq(117, t.reporter.errors[0].lineNumber) ExpectThat(t.reporter.errors[0].err, Error(HasSubstr("Unsatisfied"))) ExpectThat(t.reporter.errors[0].err, Error(HasSubstr("StringToInt"))) ExpectThat(t.reporter.errors[0].err, Error(HasSubstr("at least 3 times"))) ExpectThat(t.reporter.errors[0].err, Error(HasSubstr("called 2 times"))) } func (t *ControllerTest) ImplicitCardinalityOfOneNotSatisfied() { // Expectation -- add no actions. partial := t.controller.ExpectCall( t.mock1, "StringToInt", "burrito.go", 117) partial(HasSubstr("")) // Don't call. // The error should not yet be reported. ExpectEq(0, len(t.reporter.errors)) ExpectEq(0, len(t.reporter.fatalErrors)) // Finish should cause the error to be reported. t.controller.Finish() AssertEq(1, len(t.reporter.errors)) AssertEq(0, len(t.reporter.fatalErrors)) ExpectEq("burrito.go", t.reporter.errors[0].fileName) ExpectEq(117, t.reporter.errors[0].lineNumber) ExpectThat(t.reporter.errors[0].err, Error(HasSubstr("Unsatisfied"))) ExpectThat(t.reporter.errors[0].err, Error(HasSubstr("StringToInt"))) ExpectThat(t.reporter.errors[0].err, Error(HasSubstr("at least 1 time"))) ExpectThat(t.reporter.errors[0].err, Error(HasSubstr("called 0 times"))) } func (t *ControllerTest) ExplicitCardinalityOverrun() { // Expectation -- call times(2). partial := t.controller.ExpectCall( t.mock1, "StringToInt", "burrito.go", 117) exp := partial(HasSubstr("")) exp.Times(2) // Call three times. t.controller.HandleMethodCall( t.mock1, "StringToInt", "", 0, []interface{}{""}) t.controller.HandleMethodCall( t.mock1, "StringToInt", "", 0, []interface{}{""}) t.controller.HandleMethodCall( t.mock1, "StringToInt", "", 0, []interface{}{""}) // The error should be reported immediately. AssertEq(1, len(t.reporter.errors)) AssertEq(0, len(t.reporter.fatalErrors)) ExpectEq("burrito.go", t.reporter.errors[0].fileName) ExpectEq(117, t.reporter.errors[0].lineNumber) ExpectThat(t.reporter.errors[0].err, Error(HasSubstr("Unexpected"))) ExpectThat(t.reporter.errors[0].err, Error(HasSubstr("StringToInt"))) ExpectThat(t.reporter.errors[0].err, Error(HasSubstr("at most 2 times"))) ExpectThat(t.reporter.errors[0].err, Error(HasSubstr("called 3 times"))) // Finish should change nothing. t.controller.Finish() ExpectEq(1, len(t.reporter.errors)) ExpectEq(0, len(t.reporter.fatalErrors)) } func (t *ControllerTest) ImplicitOneTimeActionCountOverrun() { // Expectation -- add a one-time action. partial := t.controller.ExpectCall( t.mock1, "StringToInt", "burrito.go", 117) exp := partial(HasSubstr("")) exp.WillOnce(Return(0)) // Call twice. t.controller.HandleMethodCall( t.mock1, "StringToInt", "", 0, []interface{}{""}) t.controller.HandleMethodCall( t.mock1, "StringToInt", "", 0, []interface{}{""}) // The error should be reported immediately. AssertEq(1, len(t.reporter.errors)) AssertEq(0, len(t.reporter.fatalErrors)) ExpectEq("burrito.go", t.reporter.errors[0].fileName) ExpectEq(117, t.reporter.errors[0].lineNumber) ExpectThat(t.reporter.errors[0].err, Error(HasSubstr("Unexpected"))) ExpectThat(t.reporter.errors[0].err, Error(HasSubstr("StringToInt"))) ExpectThat(t.reporter.errors[0].err, Error(HasSubstr("at most 1 time"))) ExpectThat(t.reporter.errors[0].err, Error(HasSubstr("called 2 times"))) // Finish should change nothing. t.controller.Finish() ExpectEq(1, len(t.reporter.errors)) ExpectEq(0, len(t.reporter.fatalErrors)) } func (t *ControllerTest) ImplicitCardinalityOfOneOverrun() { // Expectation -- don't add any actions. partial := t.controller.ExpectCall( t.mock1, "StringToInt", "burrito.go", 117) partial(HasSubstr("")) // Call twice. t.controller.HandleMethodCall( t.mock1, "StringToInt", "", 0, []interface{}{""}) t.controller.HandleMethodCall( t.mock1, "StringToInt", "", 0, []interface{}{""}) // The error should be reported immediately. AssertEq(1, len(t.reporter.errors)) AssertEq(0, len(t.reporter.fatalErrors)) ExpectEq("burrito.go", t.reporter.errors[0].fileName) ExpectEq(117, t.reporter.errors[0].lineNumber) ExpectThat(t.reporter.errors[0].err, Error(HasSubstr("Unexpected"))) ExpectThat(t.reporter.errors[0].err, Error(HasSubstr("StringToInt"))) ExpectThat(t.reporter.errors[0].err, Error(HasSubstr("at most 1 time"))) ExpectThat(t.reporter.errors[0].err, Error(HasSubstr("called 2 times"))) // Finish should change nothing. t.controller.Finish() ExpectEq(1, len(t.reporter.errors)) ExpectEq(0, len(t.reporter.fatalErrors)) } func (t *ControllerTest) ExplicitCardinalitySatisfied() { // Expectation -- set up an explicit cardinality of two. partial := t.controller.ExpectCall( t.mock1, "StringToInt", "burrito.go", 117) exp := partial(HasSubstr("")) exp.Times(2) // Call twice. t.controller.HandleMethodCall( t.mock1, "StringToInt", "", 0, []interface{}{""}) t.controller.HandleMethodCall( t.mock1, "StringToInt", "", 0, []interface{}{""}) // There should be no errors. t.controller.Finish() ExpectEq(0, len(t.reporter.errors)) ExpectEq(0, len(t.reporter.fatalErrors)) } func (t *ControllerTest) ImplicitOneTimeActionCountSatisfied() { // Expectation -- set up two one-time actions. partial := t.controller.ExpectCall( t.mock1, "StringToInt", "burrito.go", 117) exp := partial(HasSubstr("")) exp.WillOnce(Return(0)) exp.WillOnce(Return(1)) // Call twice. t.controller.HandleMethodCall( t.mock1, "StringToInt", "", 0, []interface{}{""}) t.controller.HandleMethodCall( t.mock1, "StringToInt", "", 0, []interface{}{""}) // There should be no errors. t.controller.Finish() ExpectEq(0, len(t.reporter.errors)) ExpectEq(0, len(t.reporter.fatalErrors)) } func (t *ControllerTest) ImplicitOneTimeActionLowerBoundJustSatisfied() { // Expectation -- set up two one-time actions and a fallback. partial := t.controller.ExpectCall( t.mock1, "StringToInt", "burrito.go", 117) exp := partial(HasSubstr("")) exp.WillOnce(Return(0)) exp.WillOnce(Return(1)) exp.WillRepeatedly(Return(2)) // Call twice. t.controller.HandleMethodCall( t.mock1, "StringToInt", "", 0, []interface{}{""}) t.controller.HandleMethodCall( t.mock1, "StringToInt", "", 0, []interface{}{""}) // There should be no errors. t.controller.Finish() ExpectEq(0, len(t.reporter.errors)) ExpectEq(0, len(t.reporter.fatalErrors)) } func (t *ControllerTest) ImplicitOneTimeActionLowerBoundMoreThanSatisfied() { // Expectation -- set up two one-time actions and a fallback. partial := t.controller.ExpectCall( t.mock1, "StringToInt", "burrito.go", 117) exp := partial(HasSubstr("")) exp.WillOnce(Return(0)) exp.WillOnce(Return(1)) exp.WillRepeatedly(Return(2)) // Call four times. t.controller.HandleMethodCall( t.mock1, "StringToInt", "", 0, []interface{}{""}) t.controller.HandleMethodCall( t.mock1, "StringToInt", "", 0, []interface{}{""}) t.controller.HandleMethodCall( t.mock1, "StringToInt", "", 0, []interface{}{""}) t.controller.HandleMethodCall( t.mock1, "StringToInt", "", 0, []interface{}{""}) // There should be no errors. t.controller.Finish() ExpectEq(0, len(t.reporter.errors)) ExpectEq(0, len(t.reporter.fatalErrors)) } func (t *ControllerTest) FallbackActionConfiguredWithZeroCalls() { // Expectation -- set up a fallback action. partial := t.controller.ExpectCall( t.mock1, "StringToInt", "burrito.go", 117) exp := partial(HasSubstr("")) exp.WillRepeatedly(Return(0)) // Don't call. // There should be no errors. t.controller.Finish() ExpectEq(0, len(t.reporter.errors)) ExpectEq(0, len(t.reporter.fatalErrors)) } func (t *ControllerTest) FallbackActionConfiguredWithMultipleCalls() { // Expectation -- set up a fallback action. partial := t.controller.ExpectCall( t.mock1, "StringToInt", "burrito.go", 117) exp := partial(HasSubstr("")) exp.WillRepeatedly(Return(0)) // Call twice. t.controller.HandleMethodCall( t.mock1, "StringToInt", "", 0, []interface{}{""}) t.controller.HandleMethodCall( t.mock1, "StringToInt", "", 0, []interface{}{""}) // There should be no errors. t.controller.Finish() ExpectEq(0, len(t.reporter.errors)) ExpectEq(0, len(t.reporter.fatalErrors)) } func (t *ControllerTest) ImplicitCardinalityOfOneSatisfied() { // Expectation -- don't add actions. partial := t.controller.ExpectCall( t.mock1, "StringToInt", "burrito.go", 117) partial(HasSubstr("")) // Call once. t.controller.HandleMethodCall( t.mock1, "StringToInt", "", 0, []interface{}{""}) // There should be no errors. t.controller.Finish() ExpectEq(0, len(t.reporter.errors)) ExpectEq(0, len(t.reporter.fatalErrors)) } func (t *ControllerTest) InvokesOneTimeActions() { var res []interface{} // Expectation -- set up two one-time actions. partial := t.controller.ExpectCall( t.mock1, "StringToInt", "burrito.go", 117) suppliedArg := "" expectedReturn := 17 f := func(s string) int { suppliedArg = s return expectedReturn } exp := partial(HasSubstr("")) exp.WillOnce(Invoke(f)) exp.WillOnce(Return(1)) AssertThat(t.reporter.fatalErrors, ElementsAre()) // Call 0 res = t.controller.HandleMethodCall( t.mock1, "StringToInt", "", 0, []interface{}{"taco"}) ExpectEq("taco", suppliedArg) ExpectThat(res, ElementsAre(IdenticalTo(expectedReturn))) // Call 1 res = t.controller.HandleMethodCall( t.mock1, "StringToInt", "", 0, []interface{}{""}) ExpectThat(len(res), Equals(1)) ExpectThat(res[0], Equals(1)) } func (t *ControllerTest) InvokesFallbackActionAfterOneTimeActions() { var res []interface{} // Expectation -- set up two one-time actions and a fallback. partial := t.controller.ExpectCall( t.mock1, "StringToInt", "burrito.go", 117) exp := partial(HasSubstr("")) exp.WillOnce(Return(0)) exp.WillOnce(Return(1)) exp.WillRepeatedly(Return(2)) // Call 0 res = t.controller.HandleMethodCall( t.mock1, "StringToInt", "", 0, []interface{}{""}) ExpectThat(len(res), Equals(1)) ExpectThat(res[0], Equals(0)) // Call 1 res = t.controller.HandleMethodCall( t.mock1, "StringToInt", "", 0, []interface{}{""}) ExpectThat(len(res), Equals(1)) ExpectThat(res[0], Equals(1)) // Call 2 res = t.controller.HandleMethodCall( t.mock1, "StringToInt", "", 0, []interface{}{""}) ExpectThat(len(res), Equals(1)) ExpectThat(res[0], Equals(2)) // Call 3 res = t.controller.HandleMethodCall( t.mock1, "StringToInt", "", 0, []interface{}{""}) ExpectThat(len(res), Equals(1)) ExpectThat(res[0], Equals(2)) } func (t *ControllerTest) InvokesFallbackActionWithoutOneTimeActions() { var res []interface{} // Expectation -- set up only a fallback action. partial := t.controller.ExpectCall( t.mock1, "StringToInt", "burrito.go", 117) exp := partial(HasSubstr("")) exp.WillRepeatedly(Return(2)) // Call 0 res = t.controller.HandleMethodCall( t.mock1, "StringToInt", "", 0, []interface{}{""}) ExpectThat(len(res), Equals(1)) ExpectThat(res[0], Equals(2)) // Call 1 res = t.controller.HandleMethodCall( t.mock1, "StringToInt", "", 0, []interface{}{""}) ExpectThat(len(res), Equals(1)) ExpectThat(res[0], Equals(2)) // Call 2 res = t.controller.HandleMethodCall( t.mock1, "StringToInt", "", 0, []interface{}{""}) ExpectThat(len(res), Equals(1)) ExpectThat(res[0], Equals(2)) } func (t *ControllerTest) ImplicitActionReturnsZeroInts() { var res []interface{} // Expectation -- set up a cardinality of two. partial := t.controller.ExpectCall( t.mock1, "StringToInt", "burrito.go", 117) exp := partial(HasSubstr("")) exp.Times(2) // Call 0 res = t.controller.HandleMethodCall( t.mock1, "StringToInt", "", 0, []interface{}{""}) ExpectThat(len(res), Equals(1)) ExpectThat(reflect.TypeOf(res[0]), Equals(reflect.TypeOf(int(0)))) ExpectThat(res[0], Equals(0)) // Call 1 res = t.controller.HandleMethodCall( t.mock1, "StringToInt", "", 0, []interface{}{""}) ExpectThat(len(res), Equals(1)) ExpectThat(reflect.TypeOf(res[0]), Equals(reflect.TypeOf(int(0)))) ExpectThat(res[0], Equals(0)) } func (t *ControllerTest) ImplicitActionReturnsEmptyStrings() { var res []interface{} // Expectation -- set up a cardinality of two. partial := t.controller.ExpectCall( t.mock1, "TwoIntsToString", "burrito.go", 117) exp := partial(LessThan(100), LessThan(100)) exp.Times(2) // Call 0 res = t.controller.HandleMethodCall( t.mock1, "TwoIntsToString", "", 0, []interface{}{0, 0}) ExpectThat(len(res), Equals(1)) ExpectThat(res[0], Equals("")) // Call 1 res = t.controller.HandleMethodCall( t.mock1, "TwoIntsToString", "", 0, []interface{}{0, 0}) ExpectThat(len(res), Equals(1)) ExpectThat(res[0], Equals("")) } func (t *ControllerTest) ExpectationsAreMatchedLastToFirst() { var res []interface{} // General expectation partial := t.controller.ExpectCall( t.mock1, "StringToInt", "burrito.go", 117) exp := partial(HasSubstr("")) exp.WillRepeatedly(Return(17)) // More specific expectation partial = t.controller.ExpectCall( t.mock1, "StringToInt", "burrito.go", 117) exp = partial(Equals("taco")) exp.WillRepeatedly(Return(19)) // Call -- the second expectation should match. res = t.controller.HandleMethodCall( t.mock1, "StringToInt", "", 0, []interface{}{"taco"}) ExpectThat(len(res), Equals(1)) ExpectThat(res[0], Equals(19)) // Call -- the first expectation should match because the second doesn't. res = t.controller.HandleMethodCall( t.mock1, "StringToInt", "", 0, []interface{}{"burrito"}) ExpectThat(len(res), Equals(1)) ExpectThat(res[0], Equals(17)) } func (t *ControllerTest) ExpectationsAreSegregatedByMockObject() { var res []interface{} // Expectation for mock1 -- return 17. partial := t.controller.ExpectCall( t.mock1, "StringToInt", "burrito.go", 117) exp := partial(HasSubstr("")) exp.WillRepeatedly(Return(17)) // Expectation for mock2 -- return 19. partial = t.controller.ExpectCall( t.mock2, "StringToInt", "burrito.go", 117) exp = partial(HasSubstr("")) exp.WillRepeatedly(Return(19)) // Call mock1. res = t.controller.HandleMethodCall( t.mock1, "StringToInt", "", 0, []interface{}{""}) ExpectThat(len(res), Equals(1)) ExpectThat(res[0], Equals(17)) // Call mock2. res = t.controller.HandleMethodCall( t.mock2, "StringToInt", "", 0, []interface{}{""}) ExpectThat(len(res), Equals(1)) ExpectThat(res[0], Equals(19)) } func (t *ControllerTest) ExpectationsAreSegregatedByMethodName() { var res []interface{} // Expectation for StringToInt partial := t.controller.ExpectCall( t.mock1, "StringToInt", "burrito.go", 117) exp := partial(HasSubstr("")) exp.WillRepeatedly(Return(17)) // Expectation for TwoIntsToString partial = t.controller.ExpectCall( t.mock1, "TwoIntsToString", "burrito.go", 117) exp = partial(1, 2) exp.WillRepeatedly(Return("taco")) // Call StringToInt. res = t.controller.HandleMethodCall( t.mock1, "StringToInt", "", 0, []interface{}{""}) ExpectThat(len(res), Equals(1)) ExpectThat(res[0], Equals(17)) // Call TwoIntsToString. res = t.controller.HandleMethodCall( t.mock1, "TwoIntsToString", "", 0, []interface{}{1, 2}) ExpectThat(len(res), Equals(1)) ExpectThat(res[0], Equals("taco")) } func (t *ControllerTest) ActionCallsAgainMatchingDifferentExpectation() { var res []interface{} // Expectation for StringToInt partial := t.controller.ExpectCall( t.mock1, "StringToInt", "burrito.go", 117) exp := partial(HasSubstr("")) exp.WillOnce(Return(17)) // Expectation for TwoIntsToString -- pretend we call StringToInt. partial = t.controller.ExpectCall( t.mock1, "TwoIntsToString", "burrito.go", 117) exp = partial(1, 2) exp.WillOnce(Invoke(func(int, int) string { t.controller.HandleMethodCall( t.mock1, "StringToInt", "taco.go", 112, []interface{}{""}) return "queso" })) // Call TwoIntsToString. res = t.controller.HandleMethodCall( t.mock1, "TwoIntsToString", "", 0, []interface{}{1, 2}) AssertThat(res, ElementsAre("queso")) // Finish. Everything should be satisfied. t.controller.Finish() ExpectThat(t.reporter.errors, ElementsAre()) ExpectThat(t.reporter.fatalErrors, ElementsAre()) } func (t *ControllerTest) ActionCallsAgainMatchingSameExpectation() { var res []interface{} // Expectation for StringToInt -- should be called twice. The first time it // should call itself. partial := t.controller.ExpectCall( t.mock1, "StringToInt", "burrito.go", 117) exp := partial(HasSubstr("")) exp.Times(2) exp.WillOnce(Invoke(func(string) int { subCallRes := t.controller.HandleMethodCall( t.mock1, "StringToInt", "taco.go", 112, []interface{}{""}) return subCallRes[0].(int) + 19 })) exp.WillOnce(Return(17)) // Call. res = t.controller.HandleMethodCall( t.mock1, "StringToInt", "", 0, []interface{}{""}) AssertThat(res, ElementsAre(17+19)) // Finish. Everything should be satisfied. t.controller.Finish() ExpectThat(t.reporter.errors, ElementsAre()) ExpectThat(t.reporter.fatalErrors, ElementsAre()) } mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglemock/createmock/000077500000000000000000000000001321131462300331555ustar00rootroot00000000000000createmock.go000066400000000000000000000147741321131462300355570ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglemock/createmock// Copyright 2012 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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. // createmock is used to generate source code for mock versions of interfaces // from installed packages. package main import ( "errors" "flag" "fmt" "go/build" "io/ioutil" "log" "os" "os/exec" "path" "regexp" "text/template" // Ensure that the generate package, which is used by the generated code, is // installed by goinstall. _ "github.com/smartystreets/assertions/internal/oglemock/generate" ) var fSamePackage = flag.Bool( "same_package", false, "Generate output appropriate for including in the same package as the "+ "mocked interfaces.") // A template for generated code that is used to print the result. const tmplStr = ` {{$interfacePkgPath := .InterfacePkgPath}} package main import ( {{range $identifier, $import := .Imports}} {{$identifier}} "{{$import}}" {{end}} ) func getTypeForPtr(ptr interface{}) reflect.Type { return reflect.TypeOf(ptr).Elem() } func main() { // Reduce noise in logging output. log.SetFlags(0) interfaces := []reflect.Type{ {{range $typeName := .TypeNames}} getTypeForPtr((*{{pathBase $interfacePkgPath}}.{{$typeName}})(nil)), {{end}} } err := generate.GenerateMockSource( os.Stdout, "{{.OutputPkgPath}}", interfaces) if err != nil { log.Fatalf("Error generating mock source: %v", err) } } ` // A map from import identifier to package to use that identifier for, // containing elements for each import needed by the generated code. type importMap map[string]string type tmplArg struct { // The full path of the package from which the interfaces come. InterfacePkgPath string // The package path to assume for the generated code. OutputPkgPath string // Imports needed by the generated code. Imports importMap // Types to be mocked, relative to their package's name. TypeNames []string } var unknownPackageRegexp = regexp.MustCompile( `tool\.go:\d+:\d+: cannot find package "([^"]+)"`) var undefinedInterfaceRegexp = regexp.MustCompile(`tool\.go:\d+: undefined: [\pL_0-9]+\.([\pL_0-9]+)`) // Does the 'go build' output indicate that a package wasn't found? If so, // return the name of the package. func findUnknownPackage(output []byte) *string { if match := unknownPackageRegexp.FindSubmatch(output); match != nil { res := string(match[1]) return &res } return nil } // Does the 'go build' output indicate that an interface wasn't found? If so, // return the name of the interface. func findUndefinedInterface(output []byte) *string { if match := undefinedInterfaceRegexp.FindSubmatch(output); match != nil { res := string(match[1]) return &res } return nil } // Split out from main so that deferred calls are executed even in the event of // an error. func run() error { // Reduce noise in logging output. log.SetFlags(0) // Check the command-line arguments. flag.Parse() cmdLineArgs := flag.Args() if len(cmdLineArgs) < 2 { return errors.New("Usage: createmock [package] [interface ...]") } // Create a temporary directory inside of $GOPATH to hold generated code. buildPkg, err := build.Import("github.com/smartystreets/assertions/internal/oglemock", "", build.FindOnly) if err != nil { return errors.New(fmt.Sprintf("Couldn't find oglemock in $GOPATH: %v", err)) } tmpDir, err := ioutil.TempDir(buildPkg.SrcRoot, "tmp-createmock-") if err != nil { return errors.New(fmt.Sprintf("Creating temp dir: %v", err)) } defer os.RemoveAll(tmpDir) // Create a file to hold generated code. codeFile, err := os.Create(path.Join(tmpDir, "tool.go")) if err != nil { return errors.New(fmt.Sprintf("Couldn't create a file to hold code: %v", err)) } // Create an appropriate path for the built binary. binaryPath := path.Join(tmpDir, "tool") // Create an appropriate template argument. arg := tmplArg{ InterfacePkgPath: cmdLineArgs[0], TypeNames: cmdLineArgs[1:], } if *fSamePackage { arg.OutputPkgPath = arg.InterfacePkgPath } else { arg.OutputPkgPath = "mock_" + path.Base(arg.InterfacePkgPath) } arg.Imports = make(importMap) arg.Imports[path.Base(arg.InterfacePkgPath)] = arg.InterfacePkgPath arg.Imports["generate"] = "github.com/smartystreets/assertions/internal/oglemock/generate" arg.Imports["log"] = "log" arg.Imports["os"] = "os" arg.Imports["reflect"] = "reflect" // Execute the template to generate code that will itself generate the mock // code. Write the code to the temp file. tmpl := template.Must( template.New("code").Funcs( template.FuncMap{ "pathBase": path.Base, }).Parse(tmplStr)) if err := tmpl.Execute(codeFile, arg); err != nil { return errors.New(fmt.Sprintf("Error executing template: %v", err)) } codeFile.Close() // Attempt to build the code. cmd := exec.Command("go", "build", "-o", binaryPath) cmd.Dir = tmpDir buildOutput, err := cmd.CombinedOutput() if err != nil { // Did the compilation fail due to the user-specified package not being found? pkg := findUnknownPackage(buildOutput) if pkg != nil && *pkg == arg.InterfacePkgPath { return errors.New(fmt.Sprintf("Unknown package: %s", *pkg)) } // Did the compilation fail due to an unknown interface? if in := findUndefinedInterface(buildOutput); in != nil { return errors.New(fmt.Sprintf("Unknown interface: %s", *in)) } // Otherwise return a generic error. return errors.New(fmt.Sprintf( "%s\n\nError building generated code:\n\n"+ " %v\n\nPlease report this oglemock bug.", buildOutput, err)) } // Run the binary. cmd = exec.Command(binaryPath) binaryOutput, err := cmd.CombinedOutput() if err != nil { return errors.New(fmt.Sprintf( "%s\n\nError running generated code:\n\n"+ " %v\n\n Please report this oglemock bug.", binaryOutput, err)) } // Copy its output. _, err = os.Stdout.Write(binaryOutput) if err != nil { return errors.New(fmt.Sprintf("Error copying binary output: %v", err)) } return nil } func main() { if err := run(); err != nil { fmt.Fprintf(os.Stderr, "%s\n", err.Error()) os.Exit(1) } } createmock_test.go000066400000000000000000000141031321131462300366000ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglemock/createmock// Copyright 2012 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 main import ( "bytes" "flag" "fmt" "go/build" "io/ioutil" "os" "os/exec" "path" "syscall" "testing" . "github.com/smartystreets/assertions/internal/ogletest" ) var dumpNew = flag.Bool("dump_new", false, "Dump new golden files.") //////////////////////////////////////////////////////////// // Helpers //////////////////////////////////////////////////////////// var tempDir string var createmockPath string type CreateMockTest struct { } func TestOgletest(t *testing.T) { RunTests(t) } func init() { RegisterTestSuite(&CreateMockTest{}) } func (t *CreateMockTest) SetUpTestSuite() { // Create a temporary file to hold the built createmock binary. tempDir, err := ioutil.TempDir("", "createmock-") if err != nil { panic("Creating temporary directory: " + err.Error()) } createmockPath = path.Join(tempDir, "createmock") // Build the createmock tool so that it can be used in the tests below. cmd := exec.Command("go", "build", "-o", createmockPath, "github.com/smartystreets/assertions/internal/oglemock/createmock") if output, err := cmd.CombinedOutput(); err != nil { panic(fmt.Sprintf("Error building createmock: %v\n\n%s", err, output)) } } func (t *CreateMockTest) TearDownTestSuite() { // Delete the createmock binary we built above. os.RemoveAll(tempDir) tempDir = "" createmockPath = "" } func (t *CreateMockTest) runGoldenTest( caseName string, expectedReturnCode int, createmockArgs ...string) { // Run createmock. cmd := exec.Command(createmockPath, createmockArgs...) output, err := cmd.CombinedOutput() // Make sure the process actually exited. exitError, ok := err.(*exec.ExitError) if err != nil && (!ok || !exitError.Exited()) { panic("exec.Command.CombinedOutput: " + err.Error()) } // Extract a return code. var actualReturnCode int if exitError != nil { actualReturnCode = exitError.Sys().(syscall.WaitStatus).ExitStatus() } // Make sure the return code is correct. ExpectEq(expectedReturnCode, actualReturnCode) // Read the golden file. goldenPath := path.Join("testdata", "golden."+caseName) goldenData := readFileOrDie(goldenPath) // Compare the two. identical := (string(output) == string(goldenData)) ExpectTrue(identical, "Output doesn't match for case '%s'.", caseName) // Write out a new golden file if requested. if !identical && *dumpNew { writeContentsToFileOrDie(output, goldenPath) } } // Ensure that when createmock is run with the supplied args, it produces // output that can be compiled. func (t *CreateMockTest) runCompilationTest(createmockArgs ...string) { // Create a temporary directory inside of $GOPATH to hold generated code. buildPkg, err := build.Import("github.com/smartystreets/assertions/internal/oglemock", "", build.FindOnly) AssertEq(nil, err) tmpDir, err := ioutil.TempDir(buildPkg.SrcRoot, "tmp-createmock_test-") AssertEq(nil, err) defer os.RemoveAll(tmpDir) // Create a file to hold the mock code. codeFile, err := os.Create(path.Join(tmpDir, "mock.go")) AssertEq(nil, err) // Run createmock and save its output to the file created above. stdErrBuf := new(bytes.Buffer) cmd := exec.Command(createmockPath, createmockArgs...) cmd.Stdout = codeFile cmd.Stderr = stdErrBuf err = cmd.Run() AssertEq(nil, err, "createmock stderr output:\n\n%s", stdErrBuf.String()) codeFile.Close() // Run 'go build' in the directory and make sure it exits with return code // zero. cmd = exec.Command("go", "build") cmd.Dir = tmpDir output, err := cmd.CombinedOutput() ExpectEq(nil, err, "go build output:\n\n%s", output) } func writeContentsToFileOrDie(contents []byte, path string) { if err := ioutil.WriteFile(path, contents, 0600); err != nil { panic("ioutil.WriteFile: " + err.Error()) } } func readFileOrDie(path string) []byte { contents, err := ioutil.ReadFile(path) if err != nil { panic("ioutil.ReadFile: " + err.Error()) } return contents } //////////////////////////////////////////////////////////// // Tests //////////////////////////////////////////////////////////// func (t *CreateMockTest) NoPackage() { t.runGoldenTest( "no_package", 1) } func (t *CreateMockTest) NoInterfaces() { t.runGoldenTest( "no_interfaces", 1, "io") } func (t *CreateMockTest) UnknownPackage() { t.runGoldenTest( "unknown_package", 1, "foo/bar", "Reader") } func (t *CreateMockTest) UnknownInterface() { t.runGoldenTest( "unknown_interface", 1, "io", "Frobnicator") } func (t *CreateMockTest) GCSBucket() { t.runGoldenTest( "gcs_bucket", 0, "github.com/smartystreets/assertions/internal/oglemock/createmock/testdata/gcs", "Bucket") } func (t *CreateMockTest) GCSBucket_SamePackage() { t.runGoldenTest( "gcs_bucket_same_package", 0, "--same_package", "github.com/smartystreets/assertions/internal/oglemock/createmock/testdata/gcs", "Bucket") } func (t *CreateMockTest) IoReaderAndWriter() { t.runCompilationTest( "io", "Reader", "Writer") } func (t *CreateMockTest) OsFileInfo() { // Note that os is also used by the code that createmock generates; there // should be no conflict. t.runCompilationTest( "os", "FileInfo") } func (t *CreateMockTest) ComplicatedSamplePackage() { t.runCompilationTest( "github.com/smartystreets/assertions/internal/oglemock/generate/testdata/complicated_pkg", "ComplicatedThing") } func (t *CreateMockTest) RenamedSamplePackage() { t.runCompilationTest( "github.com/smartystreets/assertions/internal/oglemock/generate/testdata/renamed_pkg", "SomeInterface") } testdata/000077500000000000000000000000001321131462300347075ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglemock/createmockgcs/000077500000000000000000000000001321131462300354635ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglemock/createmock/testdatabucket.go000066400000000000000000000006211321131462300372660ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglemock/createmock/testdata/gcspackage gcs import "golang.org/x/net/context" type Bucket interface { Name() string CreateObject(context.Context, *CreateObjectRequest) (*Object, error) CopyObject(ctx context.Context, req *CopyObjectRequest) (o *Object, err error) } type Object struct { } type CreateObjectRequest struct { } type CopyObjectRequest struct { } type Int int type Array []int type Chan <-chan int type Ptr *int golden.gcs_bucket000066400000000000000000000051401321131462300402120ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglemock/createmock/testdata// This file was auto-generated using createmock. See the following page for // more information: // // https://github.com/smartystreets/assertions/internal/oglemock // package mock_gcs import ( fmt "fmt" oglemock "github.com/smartystreets/assertions/internal/oglemock" gcs "github.com/smartystreets/assertions/internal/oglemock/createmock/testdata/gcs" context "golang.org/x/net/context" runtime "runtime" unsafe "unsafe" ) type MockBucket interface { gcs.Bucket oglemock.MockObject } type mockBucket struct { controller oglemock.Controller description string } func NewMockBucket( c oglemock.Controller, desc string) MockBucket { return &mockBucket{ controller: c, description: desc, } } func (m *mockBucket) Oglemock_Id() uintptr { return uintptr(unsafe.Pointer(m)) } func (m *mockBucket) Oglemock_Description() string { return m.description } func (m *mockBucket) CopyObject(p0 context.Context, p1 *gcs.CopyObjectRequest) (o0 *gcs.Object, o1 error) { // Get a file name and line number for the caller. _, file, line, _ := runtime.Caller(1) // Hand the call off to the controller, which does most of the work. retVals := m.controller.HandleMethodCall( m, "CopyObject", file, line, []interface{}{p0, p1}) if len(retVals) != 2 { panic(fmt.Sprintf("mockBucket.CopyObject: invalid return values: %v", retVals)) } // o0 *gcs.Object if retVals[0] != nil { o0 = retVals[0].(*gcs.Object) } // o1 error if retVals[1] != nil { o1 = retVals[1].(error) } return } func (m *mockBucket) CreateObject(p0 context.Context, p1 *gcs.CreateObjectRequest) (o0 *gcs.Object, o1 error) { // Get a file name and line number for the caller. _, file, line, _ := runtime.Caller(1) // Hand the call off to the controller, which does most of the work. retVals := m.controller.HandleMethodCall( m, "CreateObject", file, line, []interface{}{p0, p1}) if len(retVals) != 2 { panic(fmt.Sprintf("mockBucket.CreateObject: invalid return values: %v", retVals)) } // o0 *gcs.Object if retVals[0] != nil { o0 = retVals[0].(*gcs.Object) } // o1 error if retVals[1] != nil { o1 = retVals[1].(error) } return } func (m *mockBucket) Name() (o0 string) { // Get a file name and line number for the caller. _, file, line, _ := runtime.Caller(1) // Hand the call off to the controller, which does most of the work. retVals := m.controller.HandleMethodCall( m, "Name", file, line, []interface{}{}) if len(retVals) != 1 { panic(fmt.Sprintf("mockBucket.Name: invalid return values: %v", retVals)) } // o0 string if retVals[0] != nil { o0 = retVals[0].(string) } return } golden.gcs_bucket_same_package000066400000000000000000000047421321131462300427010ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglemock/createmock/testdata// This file was auto-generated using createmock. See the following page for // more information: // // https://github.com/smartystreets/assertions/internal/oglemock // package gcs import ( fmt "fmt" oglemock "github.com/smartystreets/assertions/internal/oglemock" context "golang.org/x/net/context" runtime "runtime" unsafe "unsafe" ) type MockBucket interface { Bucket oglemock.MockObject } type mockBucket struct { controller oglemock.Controller description string } func NewMockBucket( c oglemock.Controller, desc string) MockBucket { return &mockBucket{ controller: c, description: desc, } } func (m *mockBucket) Oglemock_Id() uintptr { return uintptr(unsafe.Pointer(m)) } func (m *mockBucket) Oglemock_Description() string { return m.description } func (m *mockBucket) CopyObject(p0 context.Context, p1 *CopyObjectRequest) (o0 *Object, o1 error) { // Get a file name and line number for the caller. _, file, line, _ := runtime.Caller(1) // Hand the call off to the controller, which does most of the work. retVals := m.controller.HandleMethodCall( m, "CopyObject", file, line, []interface{}{p0, p1}) if len(retVals) != 2 { panic(fmt.Sprintf("mockBucket.CopyObject: invalid return values: %v", retVals)) } // o0 *Object if retVals[0] != nil { o0 = retVals[0].(*Object) } // o1 error if retVals[1] != nil { o1 = retVals[1].(error) } return } func (m *mockBucket) CreateObject(p0 context.Context, p1 *CreateObjectRequest) (o0 *Object, o1 error) { // Get a file name and line number for the caller. _, file, line, _ := runtime.Caller(1) // Hand the call off to the controller, which does most of the work. retVals := m.controller.HandleMethodCall( m, "CreateObject", file, line, []interface{}{p0, p1}) if len(retVals) != 2 { panic(fmt.Sprintf("mockBucket.CreateObject: invalid return values: %v", retVals)) } // o0 *Object if retVals[0] != nil { o0 = retVals[0].(*Object) } // o1 error if retVals[1] != nil { o1 = retVals[1].(error) } return } func (m *mockBucket) Name() (o0 string) { // Get a file name and line number for the caller. _, file, line, _ := runtime.Caller(1) // Hand the call off to the controller, which does most of the work. retVals := m.controller.HandleMethodCall( m, "Name", file, line, []interface{}{}) if len(retVals) != 1 { panic(fmt.Sprintf("mockBucket.Name: invalid return values: %v", retVals)) } // o0 string if retVals[0] != nil { o0 = retVals[0].(string) } return } golden.no_interfaces000066400000000000000000000000541321131462300407170ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglemock/createmock/testdataUsage: createmock [package] [interface ...] golden.no_package000066400000000000000000000000541321131462300401670ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglemock/createmock/testdataUsage: createmock [package] [interface ...] golden.unknown_interface000066400000000000000000000000371321131462300416200ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglemock/createmock/testdataUnknown interface: Frobnicator golden.unknown_package000066400000000000000000000000311321131462300412450ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglemock/createmock/testdataUnknown package: foo/bar mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglemock/do_all.go000066400000000000000000000025541321131462300326270ustar00rootroot00000000000000// Copyright 2015 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglemock import ( "fmt" "reflect" ) // Create an Action that invokes the supplied actions one after another. The // return values from the final action are used; others are ignored. func DoAll(first Action, others ...Action) Action { return &doAll{ wrapped: append([]Action{first}, others...), } } type doAll struct { wrapped []Action } func (a *doAll) SetSignature(signature reflect.Type) (err error) { for i, w := range a.wrapped { err = w.SetSignature(signature) if err != nil { err = fmt.Errorf("Action %v: %v", i, err) return } } return } func (a *doAll) Invoke(methodArgs []interface{}) (rets []interface{}) { for _, w := range a.wrapped { rets = w.Invoke(methodArgs) } return } mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglemock/do_all_test.go000066400000000000000000000050601321131462300336610ustar00rootroot00000000000000// Copyright 2015 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglemock_test import ( "reflect" "testing" . "github.com/smartystreets/assertions/internal/oglematchers" "github.com/smartystreets/assertions/internal/oglemock" . "github.com/smartystreets/assertions/internal/ogletest" ) func TestDoAll(t *testing.T) { RunTests(t) } //////////////////////////////////////////////////////////// // Boilerplate //////////////////////////////////////////////////////////// type DoAllTest struct { } func init() { RegisterTestSuite(&DoAllTest{}) } //////////////////////////////////////////////////////////// // Test functions //////////////////////////////////////////////////////////// func (t *DoAllTest) FirstActionDoesntLikeSignature() { f := func(a int, b string) {} a0 := oglemock.Invoke(func() {}) a1 := oglemock.Invoke(f) a2 := oglemock.Return() err := oglemock.DoAll(a0, a1, a2).SetSignature(reflect.TypeOf(f)) ExpectThat(err, Error(HasSubstr("Action 0"))) ExpectThat(err, Error(HasSubstr("func()"))) } func (t *DoAllTest) LastActionDoesntLikeSignature() { f := func(a int, b string) {} a0 := oglemock.Invoke(f) a1 := oglemock.Invoke(f) a2 := oglemock.Return(17) err := oglemock.DoAll(a0, a1, a2).SetSignature(reflect.TypeOf(f)) ExpectThat(err, Error(HasSubstr("Action 2"))) ExpectThat(err, Error(HasSubstr("1 vals; expected 0"))) } func (t *DoAllTest) SingleAction() { f := func(a int) string { return "" } a0 := oglemock.Return("taco") action := oglemock.DoAll(a0) AssertEq(nil, action.SetSignature(reflect.TypeOf(f))) rets := action.Invoke([]interface{}{17}) ExpectThat(rets, ElementsAre("taco")) } func (t *DoAllTest) MultipleActions() { f := func(a int) string { return "" } var saved int a0 := oglemock.SaveArg(0, &saved) a1 := oglemock.Return("taco") action := oglemock.DoAll(a0, a1) AssertEq(nil, action.SetSignature(reflect.TypeOf(f))) rets := action.Invoke([]interface{}{17}) ExpectEq(17, saved) ExpectThat(rets, ElementsAre("taco")) } mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglemock/doc.go000066400000000000000000000022051321131462300321330ustar00rootroot00000000000000// Copyright 2015 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglemock provides a mocking framework for unit tests. // // Among its features are the following: // // * An extensive and extensible set of matchers for expressing call // expectations (provided by the oglematchers package). // // * Style and semantics similar to Google Mock and Google JS Test. // // * Easy integration with the ogletest unit testing framework. // // See https://github.com/smartystreets/assertions/internal/oglemock for more information. package oglemock error_reporter.go000066400000000000000000000024021321131462300343610ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglemock// Copyright 2011 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglemock // ErrorReporter is an interface that wraps methods for reporting errors that // should cause test failures. type ErrorReporter interface { // Report that some failure (e.g. an unsatisfied expectation) occurred. If // known, fileName and lineNumber should contain information about where it // occurred. The test may continue if the test framework supports it. ReportError(fileName string, lineNumber int, err error) // Like ReportError, but the test should be halted immediately. It is assumed // that this method does not return. ReportFatalError(fileName string, lineNumber int, err error) } mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglemock/expectation.go000066400000000000000000000051041321131462300337120ustar00rootroot00000000000000// Copyright 2011 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglemock // Expectation is an expectation for zero or more calls to a mock method with // particular arguments or sets of arguments. type Expectation interface { // Times expresses that a matching method call should happen exactly N times. // Times must not be called more than once, and must not be called after // WillOnce or WillRepeatedly. // // The full rules for the cardinality of an expectation are as follows: // // 1. If an explicit cardinality is set with Times(N), then anything other // than exactly N matching calls will cause a test failure. // // 2. Otherwise, if there are any one-time actions set up, then it is // expected there will be at least that many matching calls. If there is // not also a fallback action, then it is expected that there will be // exactly that many. // // 3. Otherwise, if there is a fallback action configured, any number of // matching calls (including zero) is allowed. // // 4. Otherwise, the implicit cardinality is one. // Times(n uint) Expectation // WillOnce configures a "one-time action". WillOnce can be called zero or // more times, but must be called after any call to Times and before any call // to WillRepeatedly. // // When matching method calls are made on the mock object, one-time actions // are invoked one per matching call in the order that they were set up until // they are exhausted. Afterward the fallback action, if any, will be used. WillOnce(a Action) Expectation // WillRepeatedly configures a "fallback action". WillRepeatedly can be // called zero or one times, and must not be called before Times or WillOnce. // // Once all one-time actions are exhausted (see above), the fallback action // will be invoked for any further method calls. If WillRepeatedly is not // called, the fallback action is implicitly an action that returns zero // values for the method's return values. WillRepeatedly(a Action) Expectation } mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglemock/generate/000077500000000000000000000000001321131462300326325ustar00rootroot00000000000000generate.go000066400000000000000000000224621321131462300347020ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglemock/generate// Copyright 2012 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 generate implements code generation for mock classes. This is an // implementation detail of the createmock command, which you probably want to // use directly instead. package generate import ( "bytes" "errors" "fmt" "go/ast" "go/parser" "go/printer" "go/token" "io" "path" "reflect" "regexp" "text/template" ) const gTmplStr = ` // This file was auto-generated using createmock. See the following page for // more information: // // https://github.com/smartystreets/assertions/internal/oglemock // package {{pathBase .OutputPkgPath}} import ( {{range $identifier, $import := .Imports}}{{$identifier}} "{{$import}}" {{end}} ) {{range .Interfaces}} {{$interfaceName := printf "Mock%s" .Name}} {{$structName := printf "mock%s" .Name}} type {{$interfaceName}} interface { {{getTypeString .}} oglemock.MockObject } type {{$structName}} struct { controller oglemock.Controller description string } func New{{printf "Mock%s" .Name}}( c oglemock.Controller, desc string) {{$interfaceName}} { return &{{$structName}}{ controller: c, description: desc, } } func (m *{{$structName}}) Oglemock_Id() uintptr { return uintptr(unsafe.Pointer(m)) } func (m *{{$structName}}) Oglemock_Description() string { return m.description } {{range getMethods .}} {{$funcType := .Type}} {{$inputTypes := getInputs $funcType}} {{$outputTypes := getOutputs $funcType}} func (m *{{$structName}}) {{.Name}}({{range $i, $type := $inputTypes}}p{{$i}} {{getInputTypeString $i $funcType}}, {{end}}) ({{range $i, $type := $outputTypes}}o{{$i}} {{getTypeString $type}}, {{end}}) { // Get a file name and line number for the caller. _, file, line, _ := runtime.Caller(1) // Hand the call off to the controller, which does most of the work. retVals := m.controller.HandleMethodCall( m, "{{.Name}}", file, line, []interface{}{ {{range $i, $type := $inputTypes}}p{{$i}}, {{end}} }) if len(retVals) != {{len $outputTypes}} { panic(fmt.Sprintf("{{$structName}}.{{.Name}}: invalid return values: %v", retVals)) } {{range $i, $type := $outputTypes}} // o{{$i}} {{getTypeString $type}} if retVals[{{$i}}] != nil { o{{$i}} = retVals[{{$i}}].({{getTypeString $type}}) } {{end}} return } {{end}} {{end}} ` type tmplArg struct { // The set of interfaces to mock, and the full name of the package from which // they all come. Interfaces []reflect.Type InterfacePkgPath string // The package path for the generate code. OutputPkgPath string // Imports needed by the interfaces. Imports importMap } func (a *tmplArg) getInputTypeString(i int, ft reflect.Type) string { numInputs := ft.NumIn() if i == numInputs-1 && ft.IsVariadic() { return "..." + a.getTypeString(ft.In(i).Elem()) } return a.getTypeString(ft.In(i)) } func (a *tmplArg) getTypeString(t reflect.Type) string { return typeString(t, a.OutputPkgPath) } func getMethods(it reflect.Type) []reflect.Method { numMethods := it.NumMethod() methods := make([]reflect.Method, numMethods) for i := 0; i < numMethods; i++ { methods[i] = it.Method(i) } return methods } func getInputs(ft reflect.Type) []reflect.Type { numIn := ft.NumIn() inputs := make([]reflect.Type, numIn) for i := 0; i < numIn; i++ { inputs[i] = ft.In(i) } return inputs } func getOutputs(ft reflect.Type) []reflect.Type { numOut := ft.NumOut() outputs := make([]reflect.Type, numOut) for i := 0; i < numOut; i++ { outputs[i] = ft.Out(i) } return outputs } // A map from import identifier to package to use that identifier for, // containing elements for each import needed by a set of mocked interfaces. type importMap map[string]string var typePackageIdentifierRegexp = regexp.MustCompile(`^([\pL_0-9]+)\.[\pL_0-9]+$`) // Add an import for the supplied type, without recursing. func addImportForType(imports importMap, t reflect.Type) { // If there is no package path, this is a built-in type and we don't need an // import. pkgPath := t.PkgPath() if pkgPath == "" { return } // Work around a bug in Go: // // http://code.google.com/p/go/issues/detail?id=2660 // var errorPtr *error if t == reflect.TypeOf(errorPtr).Elem() { return } // Use the identifier that's part of the type's string representation as the // import identifier. This means that we'll do the right thing for package // "foo/bar" with declaration "package baz". match := typePackageIdentifierRegexp.FindStringSubmatch(t.String()) if match == nil { return } imports[match[1]] = pkgPath } // Add all necessary imports for the type, recursing as appropriate. func addImportsForType(imports importMap, t reflect.Type) { // Add any import needed for the type itself. addImportForType(imports, t) // Handle special cases where recursion is needed. switch t.Kind() { case reflect.Array, reflect.Chan, reflect.Ptr, reflect.Slice: addImportsForType(imports, t.Elem()) case reflect.Func: // Input parameters. for i := 0; i < t.NumIn(); i++ { addImportsForType(imports, t.In(i)) } // Return values. for i := 0; i < t.NumOut(); i++ { addImportsForType(imports, t.Out(i)) } case reflect.Map: addImportsForType(imports, t.Key()) addImportsForType(imports, t.Elem()) } } // Add imports for each of the methods of the interface, but not the interface // itself. func addImportsForInterfaceMethods(imports importMap, it reflect.Type) { // Handle each method. for i := 0; i < it.NumMethod(); i++ { m := it.Method(i) addImportsForType(imports, m.Type) } } // Given a set of interfaces, return a map from import identifier to package to // use that identifier for, containing elements for each import needed by the // mock versions of those interfaces in a package with the given path. func getImports( interfaces []reflect.Type, pkgPath string) importMap { imports := make(importMap) for _, it := range interfaces { addImportForType(imports, it) addImportsForInterfaceMethods(imports, it) } // Make sure there are imports for other types used by the generated code // itself. imports["fmt"] = "fmt" imports["oglemock"] = "github.com/smartystreets/assertions/internal/oglemock" imports["runtime"] = "runtime" imports["unsafe"] = "unsafe" // Remove any self-imports generated above. for k, v := range imports { if v == pkgPath { delete(imports, k) } } return imports } // Given a set of interfaces to mock, write out source code suitable for // inclusion in a package with the supplied full package path containing mock // implementations of those interfaces. func GenerateMockSource( w io.Writer, outputPkgPath string, interfaces []reflect.Type) (err error) { // Sanity-check arguments. if outputPkgPath == "" { return errors.New("Package path must be non-empty.") } if len(interfaces) == 0 { return errors.New("List of interfaces must be non-empty.") } // Make sure each type is indeed an interface. for _, it := range interfaces { if it.Kind() != reflect.Interface { return errors.New("Invalid type: " + it.String()) } } // Make sure each interface is from the same package. interfacePkgPath := interfaces[0].PkgPath() for _, t := range interfaces { if t.PkgPath() != interfacePkgPath { err = fmt.Errorf( "Package path mismatch: %q vs. %q", interfacePkgPath, t.PkgPath()) return } } // Set up an appropriate template arg. arg := tmplArg{ Interfaces: interfaces, InterfacePkgPath: interfacePkgPath, OutputPkgPath: outputPkgPath, Imports: getImports(interfaces, outputPkgPath), } // Configure and parse the template. tmpl := template.New("code") tmpl.Funcs(template.FuncMap{ "pathBase": path.Base, "getMethods": getMethods, "getInputs": getInputs, "getOutputs": getOutputs, "getInputTypeString": arg.getInputTypeString, "getTypeString": arg.getTypeString, }) _, err = tmpl.Parse(gTmplStr) if err != nil { err = fmt.Errorf("Parse: %v", err) return } // Execute the template, collecting the raw output into a buffer. buf := new(bytes.Buffer) if err := tmpl.Execute(buf, arg); err != nil { return err } // Parse the output. fset := token.NewFileSet() astFile, err := parser.ParseFile( fset, path.Base(outputPkgPath+".go"), buf, parser.ParseComments) if err != nil { err = fmt.Errorf("parser.ParseFile: %v", err) return } // Sort the import lines in the AST in the same way that gofmt does. ast.SortImports(fset, astFile) // Pretty-print the AST, using the same options that gofmt does by default. cfg := &printer.Config{ Mode: printer.UseSpaces | printer.TabIndent, Tabwidth: 8, } if err = cfg.Fprint(w, fset, astFile); err != nil { return errors.New("Error pretty printing: " + err.Error()) } return nil } generate_test.go000066400000000000000000000105561321131462300357420ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglemock/generate// Copyright 2012 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 generate_test import ( "bytes" "flag" "image" "io" "io/ioutil" "path" "reflect" "testing" . "github.com/smartystreets/assertions/internal/oglematchers" "github.com/smartystreets/assertions/internal/oglemock/generate" "github.com/smartystreets/assertions/internal/oglemock/generate/testdata/complicated_pkg" "github.com/smartystreets/assertions/internal/oglemock/generate/testdata/renamed_pkg" . "github.com/smartystreets/assertions/internal/ogletest" ) var dumpNew = flag.Bool("dump_new", false, "Dump new golden files.") //////////////////////////////////////////////////////////// // Helpers //////////////////////////////////////////////////////////// type GenerateTest struct { } func TestOgletest(t *testing.T) { RunTests(t) } func init() { RegisterTestSuite(&GenerateTest{}) } func (t *GenerateTest) runGoldenTest( caseName string, outputPkgPath string, nilPtrs ...interface{}) { // Make a slice of interface types to give to GenerateMockSource. interfaces := make([]reflect.Type, len(nilPtrs)) for i, ptr := range nilPtrs { interfaces[i] = reflect.TypeOf(ptr).Elem() } // Create the mock source. buf := new(bytes.Buffer) err := generate.GenerateMockSource(buf, outputPkgPath, interfaces) AssertEq(nil, err, "Error from GenerateMockSource: %v", err) // Read the golden file. goldenPath := path.Join("testdata", "golden."+caseName+".go") goldenData := readFileOrDie(goldenPath) // Compare the two. identical := (buf.String() == string(goldenData)) ExpectTrue(identical, "Output doesn't match for case '%s'.", caseName) // Write out a new golden file if requested. if !identical && *dumpNew { writeContentsToFileOrDie(buf.Bytes(), goldenPath) } } func writeContentsToFileOrDie(contents []byte, path string) { if err := ioutil.WriteFile(path, contents, 0600); err != nil { panic("ioutil.WriteFile: " + err.Error()) } } func readFileOrDie(path string) []byte { contents, err := ioutil.ReadFile(path) if err != nil { panic("ioutil.ReadFile: " + err.Error()) } return contents } //////////////////////////////////////////////////////////// // Tests //////////////////////////////////////////////////////////// func (t *GenerateTest) EmptyOutputPackagePath() { err := generate.GenerateMockSource( new(bytes.Buffer), "", []reflect.Type{ reflect.TypeOf((*io.Reader)(nil)).Elem(), }) ExpectThat(err, Error(HasSubstr("Package path"))) ExpectThat(err, Error(HasSubstr("non-empty"))) } func (t *GenerateTest) EmptySetOfInterfaces() { err := generate.GenerateMockSource( new(bytes.Buffer), "foo", []reflect.Type{}) ExpectThat(err, Error(HasSubstr("interfaces"))) ExpectThat(err, Error(HasSubstr("non-empty"))) } func (t *GenerateTest) NonInterfaceType() { err := generate.GenerateMockSource( new(bytes.Buffer), "foo", []reflect.Type{ reflect.TypeOf((*io.Reader)(nil)).Elem(), reflect.TypeOf(17), reflect.TypeOf((*io.Writer)(nil)).Elem(), }) ExpectThat(err, Error(HasSubstr("Invalid type"))) } func (t *GenerateTest) IoReaderAndWriter() { // Mock io.Reader and io.Writer. t.runGoldenTest( "io_reader_writer", "some/pkg", (*io.Reader)(nil), (*io.Writer)(nil)) } func (t *GenerateTest) IoReaderAndWriter_SamePackage() { // Mock io.Reader and io.Writer. t.runGoldenTest( "io_reader_writer_same_package", "io", (*io.Reader)(nil), (*io.Writer)(nil)) } func (t *GenerateTest) Image() { t.runGoldenTest( "image", "some/pkg", (*image.Image)(nil), (*image.PalettedImage)(nil)) } func (t *GenerateTest) ComplicatedPackage() { t.runGoldenTest( "complicated_pkg", "some/pkg", (*complicated_pkg.ComplicatedThing)(nil)) } func (t *GenerateTest) RenamedPackage() { t.runGoldenTest( "renamed_pkg", "some/pkg", (*tony.SomeInterface)(nil)) } testdata/000077500000000000000000000000001321131462300343645ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglemock/generatecomplicated_pkg/000077500000000000000000000000001321131462300375115ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglemock/generate/testdatacomplicated_pkg.go000066400000000000000000000026451321131462300431740ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglemock/generate/testdata/complicated_pkg// Copyright 2012 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 complicated_pkg contains an interface with lots of interesting // cases, for use in integration testing. package complicated_pkg import ( "image" "io" "net" "github.com/smartystreets/assertions/internal/oglemock/generate/testdata/renamed_pkg" ) type Byte uint8 type ComplicatedThing interface { Channels(a chan chan<- <-chan net.Conn) chan int Pointers(a *int, b *net.Conn, c **io.Reader) (*int, error) Functions(a func(int, image.Image) int) func(string, int) net.Conn Maps(a map[string]*int) (map[int]*string, error) Arrays(a [3]string) ([3]int, error) Slices(a []string) ([]int, error) NamedScalarType(a Byte) ([]Byte, error) EmptyInterface(a interface{}) (interface{}, error) RenamedPackage(a tony.SomeUint8Alias) Variadic(a int, b ...net.Conn) int } golden.complicated_pkg.go000066400000000000000000000155661321131462300413240ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglemock/generate/testdata// This file was auto-generated using createmock. See the following page for // more information: // // https://github.com/smartystreets/assertions/internal/oglemock // package pkg import ( fmt "fmt" oglemock "github.com/smartystreets/assertions/internal/oglemock" complicated_pkg "github.com/smartystreets/assertions/internal/oglemock/generate/testdata/complicated_pkg" tony "github.com/smartystreets/assertions/internal/oglemock/generate/testdata/renamed_pkg" image "image" io "io" net "net" runtime "runtime" unsafe "unsafe" ) type MockComplicatedThing interface { complicated_pkg.ComplicatedThing oglemock.MockObject } type mockComplicatedThing struct { controller oglemock.Controller description string } func NewMockComplicatedThing( c oglemock.Controller, desc string) MockComplicatedThing { return &mockComplicatedThing{ controller: c, description: desc, } } func (m *mockComplicatedThing) Oglemock_Id() uintptr { return uintptr(unsafe.Pointer(m)) } func (m *mockComplicatedThing) Oglemock_Description() string { return m.description } func (m *mockComplicatedThing) Arrays(p0 [3]string) (o0 [3]int, o1 error) { // Get a file name and line number for the caller. _, file, line, _ := runtime.Caller(1) // Hand the call off to the controller, which does most of the work. retVals := m.controller.HandleMethodCall( m, "Arrays", file, line, []interface{}{p0}) if len(retVals) != 2 { panic(fmt.Sprintf("mockComplicatedThing.Arrays: invalid return values: %v", retVals)) } // o0 [3]int if retVals[0] != nil { o0 = retVals[0].([3]int) } // o1 error if retVals[1] != nil { o1 = retVals[1].(error) } return } func (m *mockComplicatedThing) Channels(p0 chan chan<- <-chan net.Conn) (o0 chan int) { // Get a file name and line number for the caller. _, file, line, _ := runtime.Caller(1) // Hand the call off to the controller, which does most of the work. retVals := m.controller.HandleMethodCall( m, "Channels", file, line, []interface{}{p0}) if len(retVals) != 1 { panic(fmt.Sprintf("mockComplicatedThing.Channels: invalid return values: %v", retVals)) } // o0 chan int if retVals[0] != nil { o0 = retVals[0].(chan int) } return } func (m *mockComplicatedThing) EmptyInterface(p0 interface{}) (o0 interface{}, o1 error) { // Get a file name and line number for the caller. _, file, line, _ := runtime.Caller(1) // Hand the call off to the controller, which does most of the work. retVals := m.controller.HandleMethodCall( m, "EmptyInterface", file, line, []interface{}{p0}) if len(retVals) != 2 { panic(fmt.Sprintf("mockComplicatedThing.EmptyInterface: invalid return values: %v", retVals)) } // o0 interface { } if retVals[0] != nil { o0 = retVals[0].(interface{}) } // o1 error if retVals[1] != nil { o1 = retVals[1].(error) } return } func (m *mockComplicatedThing) Functions(p0 func(int, image.Image) int) (o0 func(string, int) net.Conn) { // Get a file name and line number for the caller. _, file, line, _ := runtime.Caller(1) // Hand the call off to the controller, which does most of the work. retVals := m.controller.HandleMethodCall( m, "Functions", file, line, []interface{}{p0}) if len(retVals) != 1 { panic(fmt.Sprintf("mockComplicatedThing.Functions: invalid return values: %v", retVals)) } // o0 func(string, int) (net.Conn) if retVals[0] != nil { o0 = retVals[0].(func(string, int) net.Conn) } return } func (m *mockComplicatedThing) Maps(p0 map[string]*int) (o0 map[int]*string, o1 error) { // Get a file name and line number for the caller. _, file, line, _ := runtime.Caller(1) // Hand the call off to the controller, which does most of the work. retVals := m.controller.HandleMethodCall( m, "Maps", file, line, []interface{}{p0}) if len(retVals) != 2 { panic(fmt.Sprintf("mockComplicatedThing.Maps: invalid return values: %v", retVals)) } // o0 map[int]*string if retVals[0] != nil { o0 = retVals[0].(map[int]*string) } // o1 error if retVals[1] != nil { o1 = retVals[1].(error) } return } func (m *mockComplicatedThing) NamedScalarType(p0 complicated_pkg.Byte) (o0 []complicated_pkg.Byte, o1 error) { // Get a file name and line number for the caller. _, file, line, _ := runtime.Caller(1) // Hand the call off to the controller, which does most of the work. retVals := m.controller.HandleMethodCall( m, "NamedScalarType", file, line, []interface{}{p0}) if len(retVals) != 2 { panic(fmt.Sprintf("mockComplicatedThing.NamedScalarType: invalid return values: %v", retVals)) } // o0 []complicated_pkg.Byte if retVals[0] != nil { o0 = retVals[0].([]complicated_pkg.Byte) } // o1 error if retVals[1] != nil { o1 = retVals[1].(error) } return } func (m *mockComplicatedThing) Pointers(p0 *int, p1 *net.Conn, p2 **io.Reader) (o0 *int, o1 error) { // Get a file name and line number for the caller. _, file, line, _ := runtime.Caller(1) // Hand the call off to the controller, which does most of the work. retVals := m.controller.HandleMethodCall( m, "Pointers", file, line, []interface{}{p0, p1, p2}) if len(retVals) != 2 { panic(fmt.Sprintf("mockComplicatedThing.Pointers: invalid return values: %v", retVals)) } // o0 *int if retVals[0] != nil { o0 = retVals[0].(*int) } // o1 error if retVals[1] != nil { o1 = retVals[1].(error) } return } func (m *mockComplicatedThing) RenamedPackage(p0 tony.SomeUint8Alias) { // Get a file name and line number for the caller. _, file, line, _ := runtime.Caller(1) // Hand the call off to the controller, which does most of the work. retVals := m.controller.HandleMethodCall( m, "RenamedPackage", file, line, []interface{}{p0}) if len(retVals) != 0 { panic(fmt.Sprintf("mockComplicatedThing.RenamedPackage: invalid return values: %v", retVals)) } return } func (m *mockComplicatedThing) Slices(p0 []string) (o0 []int, o1 error) { // Get a file name and line number for the caller. _, file, line, _ := runtime.Caller(1) // Hand the call off to the controller, which does most of the work. retVals := m.controller.HandleMethodCall( m, "Slices", file, line, []interface{}{p0}) if len(retVals) != 2 { panic(fmt.Sprintf("mockComplicatedThing.Slices: invalid return values: %v", retVals)) } // o0 []int if retVals[0] != nil { o0 = retVals[0].([]int) } // o1 error if retVals[1] != nil { o1 = retVals[1].(error) } return } func (m *mockComplicatedThing) Variadic(p0 int, p1 ...net.Conn) (o0 int) { // Get a file name and line number for the caller. _, file, line, _ := runtime.Caller(1) // Hand the call off to the controller, which does most of the work. retVals := m.controller.HandleMethodCall( m, "Variadic", file, line, []interface{}{p0, p1}) if len(retVals) != 1 { panic(fmt.Sprintf("mockComplicatedThing.Variadic: invalid return values: %v", retVals)) } // o0 int if retVals[0] != nil { o0 = retVals[0].(int) } return } golden.image.go000066400000000000000000000115141321131462300372460ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglemock/generate/testdata// This file was auto-generated using createmock. See the following page for // more information: // // https://github.com/smartystreets/assertions/internal/oglemock // package pkg import ( fmt "fmt" oglemock "github.com/smartystreets/assertions/internal/oglemock" image "image" color "image/color" runtime "runtime" unsafe "unsafe" ) type MockImage interface { image.Image oglemock.MockObject } type mockImage struct { controller oglemock.Controller description string } func NewMockImage( c oglemock.Controller, desc string) MockImage { return &mockImage{ controller: c, description: desc, } } func (m *mockImage) Oglemock_Id() uintptr { return uintptr(unsafe.Pointer(m)) } func (m *mockImage) Oglemock_Description() string { return m.description } func (m *mockImage) At(p0 int, p1 int) (o0 color.Color) { // Get a file name and line number for the caller. _, file, line, _ := runtime.Caller(1) // Hand the call off to the controller, which does most of the work. retVals := m.controller.HandleMethodCall( m, "At", file, line, []interface{}{p0, p1}) if len(retVals) != 1 { panic(fmt.Sprintf("mockImage.At: invalid return values: %v", retVals)) } // o0 color.Color if retVals[0] != nil { o0 = retVals[0].(color.Color) } return } func (m *mockImage) Bounds() (o0 image.Rectangle) { // Get a file name and line number for the caller. _, file, line, _ := runtime.Caller(1) // Hand the call off to the controller, which does most of the work. retVals := m.controller.HandleMethodCall( m, "Bounds", file, line, []interface{}{}) if len(retVals) != 1 { panic(fmt.Sprintf("mockImage.Bounds: invalid return values: %v", retVals)) } // o0 image.Rectangle if retVals[0] != nil { o0 = retVals[0].(image.Rectangle) } return } func (m *mockImage) ColorModel() (o0 color.Model) { // Get a file name and line number for the caller. _, file, line, _ := runtime.Caller(1) // Hand the call off to the controller, which does most of the work. retVals := m.controller.HandleMethodCall( m, "ColorModel", file, line, []interface{}{}) if len(retVals) != 1 { panic(fmt.Sprintf("mockImage.ColorModel: invalid return values: %v", retVals)) } // o0 color.Model if retVals[0] != nil { o0 = retVals[0].(color.Model) } return } type MockPalettedImage interface { image.PalettedImage oglemock.MockObject } type mockPalettedImage struct { controller oglemock.Controller description string } func NewMockPalettedImage( c oglemock.Controller, desc string) MockPalettedImage { return &mockPalettedImage{ controller: c, description: desc, } } func (m *mockPalettedImage) Oglemock_Id() uintptr { return uintptr(unsafe.Pointer(m)) } func (m *mockPalettedImage) Oglemock_Description() string { return m.description } func (m *mockPalettedImage) At(p0 int, p1 int) (o0 color.Color) { // Get a file name and line number for the caller. _, file, line, _ := runtime.Caller(1) // Hand the call off to the controller, which does most of the work. retVals := m.controller.HandleMethodCall( m, "At", file, line, []interface{}{p0, p1}) if len(retVals) != 1 { panic(fmt.Sprintf("mockPalettedImage.At: invalid return values: %v", retVals)) } // o0 color.Color if retVals[0] != nil { o0 = retVals[0].(color.Color) } return } func (m *mockPalettedImage) Bounds() (o0 image.Rectangle) { // Get a file name and line number for the caller. _, file, line, _ := runtime.Caller(1) // Hand the call off to the controller, which does most of the work. retVals := m.controller.HandleMethodCall( m, "Bounds", file, line, []interface{}{}) if len(retVals) != 1 { panic(fmt.Sprintf("mockPalettedImage.Bounds: invalid return values: %v", retVals)) } // o0 image.Rectangle if retVals[0] != nil { o0 = retVals[0].(image.Rectangle) } return } func (m *mockPalettedImage) ColorIndexAt(p0 int, p1 int) (o0 uint8) { // Get a file name and line number for the caller. _, file, line, _ := runtime.Caller(1) // Hand the call off to the controller, which does most of the work. retVals := m.controller.HandleMethodCall( m, "ColorIndexAt", file, line, []interface{}{p0, p1}) if len(retVals) != 1 { panic(fmt.Sprintf("mockPalettedImage.ColorIndexAt: invalid return values: %v", retVals)) } // o0 uint8 if retVals[0] != nil { o0 = retVals[0].(uint8) } return } func (m *mockPalettedImage) ColorModel() (o0 color.Model) { // Get a file name and line number for the caller. _, file, line, _ := runtime.Caller(1) // Hand the call off to the controller, which does most of the work. retVals := m.controller.HandleMethodCall( m, "ColorModel", file, line, []interface{}{}) if len(retVals) != 1 { panic(fmt.Sprintf("mockPalettedImage.ColorModel: invalid return values: %v", retVals)) } // o0 color.Model if retVals[0] != nil { o0 = retVals[0].(color.Model) } return } golden.io_reader_writer.go000066400000000000000000000044331321131462300415130ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglemock/generate/testdata// This file was auto-generated using createmock. See the following page for // more information: // // https://github.com/smartystreets/assertions/internal/oglemock // package pkg import ( fmt "fmt" oglemock "github.com/smartystreets/assertions/internal/oglemock" io "io" runtime "runtime" unsafe "unsafe" ) type MockReader interface { io.Reader oglemock.MockObject } type mockReader struct { controller oglemock.Controller description string } func NewMockReader( c oglemock.Controller, desc string) MockReader { return &mockReader{ controller: c, description: desc, } } func (m *mockReader) Oglemock_Id() uintptr { return uintptr(unsafe.Pointer(m)) } func (m *mockReader) Oglemock_Description() string { return m.description } func (m *mockReader) Read(p0 []uint8) (o0 int, o1 error) { // Get a file name and line number for the caller. _, file, line, _ := runtime.Caller(1) // Hand the call off to the controller, which does most of the work. retVals := m.controller.HandleMethodCall( m, "Read", file, line, []interface{}{p0}) if len(retVals) != 2 { panic(fmt.Sprintf("mockReader.Read: invalid return values: %v", retVals)) } // o0 int if retVals[0] != nil { o0 = retVals[0].(int) } // o1 error if retVals[1] != nil { o1 = retVals[1].(error) } return } type MockWriter interface { io.Writer oglemock.MockObject } type mockWriter struct { controller oglemock.Controller description string } func NewMockWriter( c oglemock.Controller, desc string) MockWriter { return &mockWriter{ controller: c, description: desc, } } func (m *mockWriter) Oglemock_Id() uintptr { return uintptr(unsafe.Pointer(m)) } func (m *mockWriter) Oglemock_Description() string { return m.description } func (m *mockWriter) Write(p0 []uint8) (o0 int, o1 error) { // Get a file name and line number for the caller. _, file, line, _ := runtime.Caller(1) // Hand the call off to the controller, which does most of the work. retVals := m.controller.HandleMethodCall( m, "Write", file, line, []interface{}{p0}) if len(retVals) != 2 { panic(fmt.Sprintf("mockWriter.Write: invalid return values: %v", retVals)) } // o0 int if retVals[0] != nil { o0 = retVals[0].(int) } // o1 error if retVals[1] != nil { o1 = retVals[1].(error) } return } golden.io_reader_writer_same_package.go000066400000000000000000000044131321131462300441710ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglemock/generate/testdata// This file was auto-generated using createmock. See the following page for // more information: // // https://github.com/smartystreets/assertions/internal/oglemock // package io import ( fmt "fmt" oglemock "github.com/smartystreets/assertions/internal/oglemock" runtime "runtime" unsafe "unsafe" ) type MockReader interface { Reader oglemock.MockObject } type mockReader struct { controller oglemock.Controller description string } func NewMockReader( c oglemock.Controller, desc string) MockReader { return &mockReader{ controller: c, description: desc, } } func (m *mockReader) Oglemock_Id() uintptr { return uintptr(unsafe.Pointer(m)) } func (m *mockReader) Oglemock_Description() string { return m.description } func (m *mockReader) Read(p0 []uint8) (o0 int, o1 error) { // Get a file name and line number for the caller. _, file, line, _ := runtime.Caller(1) // Hand the call off to the controller, which does most of the work. retVals := m.controller.HandleMethodCall( m, "Read", file, line, []interface{}{p0}) if len(retVals) != 2 { panic(fmt.Sprintf("mockReader.Read: invalid return values: %v", retVals)) } // o0 int if retVals[0] != nil { o0 = retVals[0].(int) } // o1 error if retVals[1] != nil { o1 = retVals[1].(error) } return } type MockWriter interface { Writer oglemock.MockObject } type mockWriter struct { controller oglemock.Controller description string } func NewMockWriter( c oglemock.Controller, desc string) MockWriter { return &mockWriter{ controller: c, description: desc, } } func (m *mockWriter) Oglemock_Id() uintptr { return uintptr(unsafe.Pointer(m)) } func (m *mockWriter) Oglemock_Description() string { return m.description } func (m *mockWriter) Write(p0 []uint8) (o0 int, o1 error) { // Get a file name and line number for the caller. _, file, line, _ := runtime.Caller(1) // Hand the call off to the controller, which does most of the work. retVals := m.controller.HandleMethodCall( m, "Write", file, line, []interface{}{p0}) if len(retVals) != 2 { panic(fmt.Sprintf("mockWriter.Write: invalid return values: %v", retVals)) } // o0 int if retVals[0] != nil { o0 = retVals[0].(int) } // o1 error if retVals[1] != nil { o1 = retVals[1].(error) } return } golden.renamed_pkg.go000066400000000000000000000025711321131462300404430ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglemock/generate/testdata// This file was auto-generated using createmock. See the following page for // more information: // // https://github.com/smartystreets/assertions/internal/oglemock // package pkg import ( fmt "fmt" oglemock "github.com/smartystreets/assertions/internal/oglemock" tony "github.com/smartystreets/assertions/internal/oglemock/generate/testdata/renamed_pkg" runtime "runtime" unsafe "unsafe" ) type MockSomeInterface interface { tony.SomeInterface oglemock.MockObject } type mockSomeInterface struct { controller oglemock.Controller description string } func NewMockSomeInterface( c oglemock.Controller, desc string) MockSomeInterface { return &mockSomeInterface{ controller: c, description: desc, } } func (m *mockSomeInterface) Oglemock_Id() uintptr { return uintptr(unsafe.Pointer(m)) } func (m *mockSomeInterface) Oglemock_Description() string { return m.description } func (m *mockSomeInterface) DoFoo(p0 int) (o0 int) { // Get a file name and line number for the caller. _, file, line, _ := runtime.Caller(1) // Hand the call off to the controller, which does most of the work. retVals := m.controller.HandleMethodCall( m, "DoFoo", file, line, []interface{}{p0}) if len(retVals) != 1 { panic(fmt.Sprintf("mockSomeInterface.DoFoo: invalid return values: %v", retVals)) } // o0 int if retVals[0] != nil { o0 = retVals[0].(int) } return } renamed_pkg/000077500000000000000000000000001321131462300366405ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglemock/generate/testdatarenamed_pkg.go000066400000000000000000000015251321131462300414460ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglemock/generate/testdata/renamed_pkg// Copyright 2012 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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. // A package that calls itself something different than its package path would // have you believe. package tony type SomeUint8Alias uint8 type SomeInterface interface { DoFoo(a int) int } type_string.go000066400000000000000000000066111321131462300354550ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglemock/generate// Copyright 2015 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 generate import ( "fmt" "log" "reflect" "strings" ) // Return the string that should be used to refer to the supplied type within // the given package. The output is not guaranteed to be pretty, and should be // run through a tool like gofmt afterward. // // For example, a pointer to an io.Reader may be rendered as "*Reader" or // "*io.Reader" depending on whether the package path is "io" or not. func typeString( t reflect.Type, pkgPath string) (s string) { // Is this type named? If so we use its name, possibly with a package prefix. // // Examples: // // int // string // error // gcs.Bucket // if t.Name() != "" { if t.PkgPath() == pkgPath { s = t.Name() } else { s = t.String() } return } // This type is unnamed. Recurse. switch t.Kind() { case reflect.Array: s = fmt.Sprintf("[%d]%s", t.Len(), typeString(t.Elem(), pkgPath)) case reflect.Chan: s = fmt.Sprintf("%s %s", t.ChanDir(), typeString(t.Elem(), pkgPath)) case reflect.Func: s = typeString_Func(t, pkgPath) case reflect.Interface: s = typeString_Interface(t, pkgPath) case reflect.Map: s = fmt.Sprintf( "map[%s]%s", typeString(t.Key(), pkgPath), typeString(t.Elem(), pkgPath)) case reflect.Ptr: s = fmt.Sprintf("*%s", typeString(t.Elem(), pkgPath)) case reflect.Slice: s = fmt.Sprintf("[]%s", typeString(t.Elem(), pkgPath)) case reflect.Struct: s = typeString_Struct(t, pkgPath) default: log.Panicf("Unhandled kind %v for type: %v", t.Kind(), t) } return } func typeString_FuncOrMethod( name string, t reflect.Type, pkgPath string) (s string) { // Deal with input types. var in []string for i := 0; i < t.NumIn(); i++ { in = append(in, typeString(t.In(i), pkgPath)) } // And output types. var out []string for i := 0; i < t.NumOut(); i++ { out = append(out, typeString(t.Out(i), pkgPath)) } // Put it all together. s = fmt.Sprintf( "%s(%s) (%s)", name, strings.Join(in, ", "), strings.Join(out, ", ")) return } func typeString_Func( t reflect.Type, pkgPath string) (s string) { return typeString_FuncOrMethod("func", t, pkgPath) } func typeString_Struct( t reflect.Type, pkgPath string) (s string) { var fields []string for i := 0; i < t.NumField(); i++ { f := t.Field(i) fString := fmt.Sprintf("%s %s", f.Name, typeString(f.Type, pkgPath)) fields = append(fields, fString) } s = fmt.Sprintf("struct { %s }", strings.Join(fields, "; ")) return } func typeString_Interface( t reflect.Type, pkgPath string) (s string) { var methods []string for i := 0; i < t.NumMethod(); i++ { m := t.Method(i) mString := typeString_FuncOrMethod(m.Name, m.Type, pkgPath) methods = append(methods, mString) } s = fmt.Sprintf("interface { %s }", strings.Join(methods, "; ")) return } type_string_test.go000066400000000000000000000125331321131462300365140ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglemock/generate// Copyright 2015 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 generate import ( "io" "reflect" "testing" "unsafe" "github.com/smartystreets/assertions/internal/oglemock/createmock/testdata/gcs" . "github.com/smartystreets/assertions/internal/ogletest" ) func TestTypeString(t *testing.T) { RunTests(t) } //////////////////////////////////////////////////////////////////////// // Boilerplate //////////////////////////////////////////////////////////////////////// type TypeStringTest struct { } func init() { RegisterTestSuite(&TypeStringTest{}) } //////////////////////////////////////////////////////////////////////// // Test functions //////////////////////////////////////////////////////////////////////// func (t *TypeStringTest) TestCases() { const gcsPkgPath = "github.com/smartystreets/assertions/internal/oglemock/createmock/testdata/gcs" to := reflect.TypeOf testCases := []struct { t reflect.Type pkgPath string expected string }{ ///////////////////////// // Scalar types ///////////////////////// 0: {to(true), "", "bool"}, 1: {to(true), "some/pkg", "bool"}, 2: {to(int(17)), "some/pkg", "int"}, 3: {to(int32(17)), "some/pkg", "int32"}, 4: {to(uint(17)), "some/pkg", "uint"}, 5: {to(uint32(17)), "some/pkg", "uint32"}, 6: {to(uintptr(17)), "some/pkg", "uintptr"}, 7: {to(float32(17)), "some/pkg", "float32"}, 8: {to(complex64(17)), "some/pkg", "complex64"}, ///////////////////////// // Structs ///////////////////////// 9: {to(gcs.Object{}), "some/pkg", "gcs.Object"}, 10: {to(gcs.Object{}), gcsPkgPath, "Object"}, 11: { to(struct { a int b gcs.Object }{}), "some/pkg", "struct { a int; b gcs.Object }", }, 12: { to(struct { a int b gcs.Object }{}), gcsPkgPath, "struct { a int; b Object }", }, ///////////////////////// // Pointers ///////////////////////// 13: {to((*int)(nil)), gcsPkgPath, "*int"}, 14: {to((*gcs.Object)(nil)), "some/pkg", "*gcs.Object"}, 15: {to((*gcs.Object)(nil)), gcsPkgPath, "*Object"}, ///////////////////////// // Arrays ///////////////////////// 16: {to([3]int{}), "some/pkg", "[3]int"}, 17: {to([3]gcs.Object{}), gcsPkgPath, "[3]Object"}, ///////////////////////// // Channels ///////////////////////// 18: {to((chan int)(nil)), "some/pkg", "chan int"}, 19: {to((<-chan int)(nil)), "some/pkg", "<-chan int"}, 20: {to((chan<- int)(nil)), "some/pkg", "chan<- int"}, 21: {to((<-chan gcs.Object)(nil)), gcsPkgPath, "<-chan Object"}, ///////////////////////// // Functions ///////////////////////// 22: { to(func(int, gcs.Object) {}), gcsPkgPath, "func(int, Object) ()", }, 23: { to(func() (*gcs.Object, error) { return nil, nil }), gcsPkgPath, "func() (*Object, error)", }, 24: { to(func(int, gcs.Object) (*gcs.Object, error) { return nil, nil }), gcsPkgPath, "func(int, Object) (*Object, error)", }, ///////////////////////// // Interfaces ///////////////////////// 25: {to((*error)(nil)).Elem(), "some/pkg", "error"}, 26: {to((*io.Reader)(nil)).Elem(), "some/pkg", "io.Reader"}, 27: {to((*io.Reader)(nil)).Elem(), "io", "Reader"}, 28: { to((*interface{})(nil)).Elem(), "some/pkg", "interface { }", }, 29: { to((*interface { Foo(int) Bar(gcs.Object) })(nil)).Elem(), "some/pkg", "interface { Bar(gcs.Object) (); Foo(int) () }", }, 30: { to((*interface { Foo(int) Bar(gcs.Object) })(nil)).Elem(), gcsPkgPath, "interface { Bar(Object) (); Foo(int) () }", }, ///////////////////////// // Maps ///////////////////////// 31: {to(map[*gcs.Object]gcs.Object{}), gcsPkgPath, "map[*Object]Object"}, ///////////////////////// // Slices ///////////////////////// 32: {to([]int{}), "some/pkg", "[]int"}, 33: {to([]gcs.Object{}), gcsPkgPath, "[]Object"}, ///////////////////////// // Strings ///////////////////////// 34: {to(""), gcsPkgPath, "string"}, ///////////////////////// // Unsafe pointer ///////////////////////// 35: {to(unsafe.Pointer(nil)), gcsPkgPath, "unsafe.Pointer"}, ///////////////////////// // Other named types ///////////////////////// 36: {to(gcs.Int(17)), "some/pkg", "gcs.Int"}, 37: {to(gcs.Int(17)), gcsPkgPath, "Int"}, 38: {to(gcs.Array{}), "some/pkg", "gcs.Array"}, 39: {to(gcs.Array{}), gcsPkgPath, "Array"}, 40: {to(gcs.Chan(nil)), "some/pkg", "gcs.Chan"}, 41: {to(gcs.Chan(nil)), gcsPkgPath, "Chan"}, 42: {to(gcs.Ptr(nil)), "some/pkg", "gcs.Ptr"}, 43: {to(gcs.Ptr(nil)), gcsPkgPath, "Ptr"}, 44: {to((*gcs.Int)(nil)), "some/pkg", "*gcs.Int"}, 45: {to((*gcs.Int)(nil)), gcsPkgPath, "*Int"}, } for i, tc := range testCases { ExpectEq( tc.expected, typeString(tc.t, tc.pkgPath), "Case %d: %v, %q", i, tc.t, tc.pkgPath) } } integration_test.go000066400000000000000000000074121321131462300346760ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglemock// Copyright 2012 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglemock_test import ( "errors" . "github.com/smartystreets/assertions/internal/oglematchers" "github.com/smartystreets/assertions/internal/oglemock" "github.com/smartystreets/assertions/internal/oglemock/sample/mock_io" . "github.com/smartystreets/assertions/internal/ogletest" "path" "runtime" ) //////////////////////////////////////////////////////////// // Helpers //////////////////////////////////////////////////////////// func getLineNumber() int { _, _, line, _ := runtime.Caller(1) return line } type IntegrationTest struct { reporter fakeErrorReporter controller oglemock.Controller reader mock_io.MockReader } func init() { RegisterTestSuite(&IntegrationTest{}) } func (t *IntegrationTest) SetUp(c *TestInfo) { t.reporter.errors = make([]errorReport, 0) t.reporter.fatalErrors = make([]errorReport, 0) t.controller = oglemock.NewController(&t.reporter) t.reader = mock_io.NewMockReader(t.controller, "") } //////////////////////////////////////////////////////////// // Tests //////////////////////////////////////////////////////////// func (t *IntegrationTest) UnexpectedCall() { t.reader.Read([]uint8{1, 2, 3}) expectedLine := getLineNumber() - 1 // An error should have been reported. AssertEq(1, len(t.reporter.errors), "%v", t.reporter.errors) AssertEq(0, len(t.reporter.fatalErrors), "%v", t.reporter.fatalErrors) r := t.reporter.errors[0] ExpectEq("integration_test.go", path.Base(r.fileName)) ExpectEq(expectedLine, r.lineNumber) ExpectThat(r.err, Error(HasSubstr("Unexpected"))) ExpectThat(r.err, Error(HasSubstr("Read"))) ExpectThat(r.err, Error(HasSubstr("[1 2 3]"))) } func (t *IntegrationTest) ZeroValues() { // Make an unexpected call. n, err := t.reader.Read([]uint8{}) // Check the return values. ExpectEq(0, n) ExpectEq(nil, err) } func (t *IntegrationTest) ExpectedCalls() { // Expectations t.controller.ExpectCall(t.reader, "Read", "", 112)(nil). WillOnce(oglemock.Return(17, nil)). WillOnce(oglemock.Return(19, nil)) t.controller.ExpectCall(t.reader, "Read", "", 112)(Not(Equals(nil))). WillOnce(oglemock.Return(23, errors.New("taco"))) // Calls var n int var err error n, err = t.reader.Read(nil) ExpectEq(17, n) ExpectEq(nil, err) n, err = t.reader.Read([]byte{}) ExpectEq(23, n) ExpectThat(err, Error(Equals("taco"))) n, err = t.reader.Read(nil) ExpectEq(19, n) ExpectEq(nil, err) // Errors AssertEq(0, len(t.reporter.errors), "%v", t.reporter.errors) AssertEq(0, len(t.reporter.fatalErrors), "%v", t.reporter.fatalErrors) } func (t *IntegrationTest) WrongTypeForReturn() { t.controller.ExpectCall(t.reader, "Read", "foo.go", 112)(nil). WillOnce(oglemock.Return(0, errors.New(""))). WillOnce(oglemock.Return("taco", errors.New(""))) // Errors AssertEq(0, len(t.reporter.errors), "%v", t.reporter.errors) AssertEq(1, len(t.reporter.fatalErrors), "%v", t.reporter.fatalErrors) r := t.reporter.fatalErrors[0] ExpectEq("foo.go", r.fileName) ExpectEq(112, r.lineNumber) ExpectThat(r.err, Error(HasSubstr("Return"))) ExpectThat(r.err, Error(HasSubstr("arg 0"))) ExpectThat(r.err, Error(HasSubstr("int"))) ExpectThat(r.err, Error(HasSubstr("string"))) } internal_expectation.go000066400000000000000000000117771321131462300355440ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglemock// Copyright 2011 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglemock import ( "errors" "fmt" "github.com/smartystreets/assertions/internal/oglematchers" "reflect" "sync" ) // InternalExpectation is exported for purposes of testing only. You should not // touch it. // // InternalExpectation represents an expectation for zero or more calls to a // mock method, and a set of actions to be taken when those calls are received. type InternalExpectation struct { // The signature of the method to which this expectation is bound, for // checking action types. methodSignature reflect.Type // An error reporter to use for reporting errors in the way that expectations // are set. errorReporter ErrorReporter // A mutex protecting mutable fields of the struct. mutex sync.Mutex // Matchers that the arguments to the mock method must satisfy in order to // match this expectation. ArgMatchers []oglematchers.Matcher // The name of the file in which this expectation was expressed. FileName string // The line number at which this expectation was expressed. LineNumber int // The number of times this expectation should be matched, as explicitly // listed by the user. If there was no explicit number expressed, this is -1. ExpectedNumMatches int // Actions to be taken for the first N calls, one per call in order, where N // is the length of this slice. OneTimeActions []Action // An action to be taken when the one-time actions have expired, or nil if // there is no such action. FallbackAction Action // The number of times this expectation has been matched so far. NumMatches uint } // InternalNewExpectation is exported for purposes of testing only. You should // not touch it. func InternalNewExpectation( reporter ErrorReporter, methodSignature reflect.Type, args []interface{}, fileName string, lineNumber int) *InternalExpectation { result := &InternalExpectation{} // Store fields that can be stored directly. result.methodSignature = methodSignature result.errorReporter = reporter result.FileName = fileName result.LineNumber = lineNumber // Set up defaults. result.ExpectedNumMatches = -1 result.OneTimeActions = make([]Action, 0) // Set up the ArgMatchers slice, using Equals(x) for each x that is not a // matcher itself. result.ArgMatchers = make([]oglematchers.Matcher, len(args)) for i, x := range args { if matcher, ok := x.(oglematchers.Matcher); ok { result.ArgMatchers[i] = matcher } else { result.ArgMatchers[i] = oglematchers.Equals(x) } } return result } func (e *InternalExpectation) Times(n uint) Expectation { e.mutex.Lock() defer e.mutex.Unlock() // It is illegal to call this more than once. if e.ExpectedNumMatches != -1 { e.reportFatalError("Times called more than once.") return nil } // It is illegal to call this after any actions are configured. if len(e.OneTimeActions) != 0 { e.reportFatalError("Times called after WillOnce.") return nil } if e.FallbackAction != nil { e.reportFatalError("Times called after WillRepeatedly.") return nil } // Make sure the number is reasonable (and will fit in an int). if n > 1000 { e.reportFatalError("Expectation.Times: N must be at most 1000") return nil } e.ExpectedNumMatches = int(n) return e } func (e *InternalExpectation) WillOnce(a Action) Expectation { e.mutex.Lock() defer e.mutex.Unlock() // It is illegal to call this after WillRepeatedly. if e.FallbackAction != nil { e.reportFatalError("WillOnce called after WillRepeatedly.") return nil } // Tell the action about the method's signature. if err := a.SetSignature(e.methodSignature); err != nil { e.reportFatalError(fmt.Sprintf("WillOnce given invalid action: %v", err)) return nil } // Store the action. e.OneTimeActions = append(e.OneTimeActions, a) return e } func (e *InternalExpectation) WillRepeatedly(a Action) Expectation { e.mutex.Lock() defer e.mutex.Unlock() // It is illegal to call this twice. if e.FallbackAction != nil { e.reportFatalError("WillRepeatedly called more than once.") return nil } // Tell the action about the method's signature. if err := a.SetSignature(e.methodSignature); err != nil { e.reportFatalError(fmt.Sprintf("WillRepeatedly given invalid action: %v", err)) return nil } // Store the action. e.FallbackAction = a return e } func (e *InternalExpectation) reportFatalError(errorText string) { e.errorReporter.ReportFatalError(e.FileName, e.LineNumber, errors.New(errorText)) } internal_expectation_test.go000066400000000000000000000200071321131462300365650ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglemock// Copyright 2011 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglemock_test import ( . "github.com/smartystreets/assertions/internal/oglematchers" . "github.com/smartystreets/assertions/internal/oglemock" . "github.com/smartystreets/assertions/internal/ogletest" "reflect" ) //////////////////////////////////////////////////////////// // Helpers //////////////////////////////////////////////////////////// var emptyReturnSig reflect.Type = reflect.TypeOf(func(i int) {}) var float64ReturnSig reflect.Type = reflect.TypeOf(func(i int) float64 { return 17.0 }) type InternalExpectationTest struct { reporter fakeErrorReporter } func init() { RegisterTestSuite(&InternalExpectationTest{}) } func (t *InternalExpectationTest) SetUp(c *TestInfo) { t.reporter.errors = make([]errorReport, 0) t.reporter.fatalErrors = make([]errorReport, 0) } func (t *InternalExpectationTest) makeExpectation( sig reflect.Type, args []interface{}, fileName string, lineNumber int) *InternalExpectation { return InternalNewExpectation(&t.reporter, sig, args, fileName, lineNumber) } //////////////////////////////////////////////////////////// // Tests //////////////////////////////////////////////////////////// func (t *InternalExpectationTest) StoresFileNameAndLineNumber() { args := []interface{}{} exp := t.makeExpectation(emptyReturnSig, args, "taco", 17) ExpectThat(exp.FileName, Equals("taco")) ExpectThat(exp.LineNumber, Equals(17)) } func (t *InternalExpectationTest) NoArgs() { args := []interface{}{} exp := t.makeExpectation(emptyReturnSig, args, "", 0) ExpectThat(len(exp.ArgMatchers), Equals(0)) } func (t *InternalExpectationTest) MixOfMatchersAndNonMatchers() { args := []interface{}{Equals(17), 19, Equals(23)} exp := t.makeExpectation(emptyReturnSig, args, "", 0) // Matcher args ExpectThat(len(exp.ArgMatchers), Equals(3)) ExpectThat(exp.ArgMatchers[0], Equals(args[0])) ExpectThat(exp.ArgMatchers[2], Equals(args[2])) // Non-matcher arg var err error matcher1 := exp.ArgMatchers[1] err = matcher1.Matches(17) ExpectNe(nil, err) err = matcher1.Matches(19) ExpectEq(nil, err) err = matcher1.Matches(23) ExpectNe(nil, err) } func (t *InternalExpectationTest) NoTimes() { exp := t.makeExpectation(emptyReturnSig, []interface{}{}, "", 0) ExpectThat(exp.ExpectedNumMatches, Equals(-1)) } func (t *InternalExpectationTest) TimesN() { exp := t.makeExpectation(emptyReturnSig, []interface{}{}, "", 0) exp.Times(17) ExpectThat(exp.ExpectedNumMatches, Equals(17)) } func (t *InternalExpectationTest) NoActions() { exp := t.makeExpectation(emptyReturnSig, []interface{}{}, "", 0) ExpectThat(len(exp.OneTimeActions), Equals(0)) ExpectThat(exp.FallbackAction, Equals(nil)) } func (t *InternalExpectationTest) WillOnce() { action0 := Return(17.0) action1 := Return(19.0) exp := t.makeExpectation(float64ReturnSig, []interface{}{}, "", 0) exp.WillOnce(action0).WillOnce(action1) ExpectThat(len(exp.OneTimeActions), Equals(2)) ExpectThat(exp.OneTimeActions[0], Equals(action0)) ExpectThat(exp.OneTimeActions[1], Equals(action1)) } func (t *InternalExpectationTest) WillRepeatedly() { action := Return(17.0) exp := t.makeExpectation(float64ReturnSig, []interface{}{}, "", 0) exp.WillRepeatedly(action) ExpectThat(exp.FallbackAction, Equals(action)) } func (t *InternalExpectationTest) BothKindsOfAction() { action0 := Return(17.0) action1 := Return(19.0) action2 := Return(23.0) exp := t.makeExpectation(float64ReturnSig, []interface{}{}, "", 0) exp.WillOnce(action0).WillOnce(action1).WillRepeatedly(action2) ExpectThat(len(exp.OneTimeActions), Equals(2)) ExpectThat(exp.OneTimeActions[0], Equals(action0)) ExpectThat(exp.OneTimeActions[1], Equals(action1)) ExpectThat(exp.FallbackAction, Equals(action2)) } func (t *InternalExpectationTest) TimesCalledWithHugeNumber() { exp := t.makeExpectation(emptyReturnSig, []interface{}{}, "taco.go", 112) exp.Times(1 << 30) AssertEq(1, len(t.reporter.fatalErrors)) AssertEq(0, len(t.reporter.errors)) r := t.reporter.fatalErrors[0] ExpectEq("taco.go", r.fileName) ExpectEq(112, r.lineNumber) ExpectThat(r.err, Error(HasSubstr("Times"))) ExpectThat(r.err, Error(HasSubstr("N must be at most 1000"))) } func (t *InternalExpectationTest) TimesCalledTwice() { exp := t.makeExpectation(emptyReturnSig, []interface{}{}, "taco.go", 112) exp.Times(17) exp.Times(17) AssertEq(1, len(t.reporter.fatalErrors)) AssertEq(0, len(t.reporter.errors)) r := t.reporter.fatalErrors[0] ExpectEq("taco.go", r.fileName) ExpectEq(112, r.lineNumber) ExpectThat(r.err, Error(HasSubstr("Times"))) ExpectThat(r.err, Error(HasSubstr("more than once"))) } func (t *InternalExpectationTest) TimesCalledAfterWillOnce() { exp := t.makeExpectation(emptyReturnSig, []interface{}{}, "taco.go", 112) exp.WillOnce(Return()) exp.Times(17) AssertEq(1, len(t.reporter.fatalErrors)) AssertEq(0, len(t.reporter.errors)) r := t.reporter.fatalErrors[0] ExpectEq("taco.go", r.fileName) ExpectEq(112, r.lineNumber) ExpectThat(r.err, Error(HasSubstr("Times"))) ExpectThat(r.err, Error(HasSubstr("after WillOnce"))) } func (t *InternalExpectationTest) TimesCalledAfterWillRepeatedly() { exp := t.makeExpectation(emptyReturnSig, []interface{}{}, "taco.go", 112) exp.WillRepeatedly(Return()) exp.Times(17) AssertEq(1, len(t.reporter.fatalErrors)) AssertEq(0, len(t.reporter.errors)) r := t.reporter.fatalErrors[0] ExpectEq("taco.go", r.fileName) ExpectEq(112, r.lineNumber) ExpectThat(r.err, Error(HasSubstr("Times"))) ExpectThat(r.err, Error(HasSubstr("after WillRepeatedly"))) } func (t *InternalExpectationTest) WillOnceCalledAfterWillRepeatedly() { exp := t.makeExpectation(emptyReturnSig, []interface{}{}, "taco.go", 112) exp.WillRepeatedly(Return()) exp.WillOnce(Return()) AssertEq(1, len(t.reporter.fatalErrors)) AssertEq(0, len(t.reporter.errors)) r := t.reporter.fatalErrors[0] ExpectEq("taco.go", r.fileName) ExpectEq(112, r.lineNumber) ExpectThat(r.err, Error(HasSubstr("WillOnce"))) ExpectThat(r.err, Error(HasSubstr("after WillRepeatedly"))) } func (t *InternalExpectationTest) OneTimeActionRejectsSignature() { exp := t.makeExpectation(float64ReturnSig, []interface{}{}, "taco.go", 112) exp.WillOnce(Return("taco")) AssertEq(1, len(t.reporter.fatalErrors)) AssertEq(0, len(t.reporter.errors)) r := t.reporter.fatalErrors[0] ExpectEq("taco.go", r.fileName) ExpectEq(112, r.lineNumber) ExpectThat(r.err, Error(HasSubstr("arg 0"))) ExpectThat(r.err, Error(HasSubstr("expected float64"))) ExpectThat(r.err, Error(HasSubstr("given string"))) } func (t *InternalExpectationTest) WillRepeatedlyCalledTwice() { exp := t.makeExpectation(emptyReturnSig, []interface{}{}, "taco.go", 112) exp.WillRepeatedly(Return()) exp.WillRepeatedly(Return()) AssertEq(1, len(t.reporter.fatalErrors)) AssertEq(0, len(t.reporter.errors)) r := t.reporter.fatalErrors[0] ExpectEq("taco.go", r.fileName) ExpectEq(112, r.lineNumber) ExpectThat(r.err, Error(HasSubstr("WillRepeatedly"))) ExpectThat(r.err, Error(HasSubstr("once"))) } func (t *InternalExpectationTest) FallbackActionRejectsSignature() { exp := t.makeExpectation(float64ReturnSig, []interface{}{}, "taco.go", 112) exp.WillRepeatedly(Return("taco")) AssertEq(1, len(t.reporter.fatalErrors)) AssertEq(0, len(t.reporter.errors)) r := t.reporter.fatalErrors[0] ExpectEq("taco.go", r.fileName) ExpectEq(112, r.lineNumber) ExpectThat(r.err, Error(HasSubstr("arg 0"))) ExpectThat(r.err, Error(HasSubstr("expected float64"))) ExpectThat(r.err, Error(HasSubstr("given string"))) } mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglemock/invoke.go000066400000000000000000000035431321131462300326670ustar00rootroot00000000000000// Copyright 2012 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglemock import ( "errors" "fmt" "reflect" ) // Create an Action that invokes the supplied function, returning whatever it // returns. The signature of the function must match that of the mocked method // exactly. func Invoke(f interface{}) Action { // Make sure f is a function. fv := reflect.ValueOf(f) fk := fv.Kind() if fk != reflect.Func { desc := "" if fk != reflect.Invalid { desc = fv.Type().String() } panic(fmt.Sprintf("Invoke: expected function, got %s", desc)) } return &invokeAction{fv} } type invokeAction struct { f reflect.Value } func (a *invokeAction) SetSignature(signature reflect.Type) error { // The signature must match exactly. ft := a.f.Type() if ft != signature { return errors.New(fmt.Sprintf("Invoke: expected %v, got %v", signature, ft)) } return nil } func (a *invokeAction) Invoke(vals []interface{}) []interface{} { // Create a slice of args for the function. in := make([]reflect.Value, len(vals)) for i, x := range vals { in[i] = reflect.ValueOf(x) } // Call the function and return its return values. out := a.f.Call(in) result := make([]interface{}, len(out)) for i, v := range out { result[i] = v.Interface() } return result } mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglemock/invoke_test.go000066400000000000000000000060131321131462300337210ustar00rootroot00000000000000// Copyright 2012 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglemock_test import ( . "github.com/smartystreets/assertions/internal/oglematchers" "github.com/smartystreets/assertions/internal/oglemock" . "github.com/smartystreets/assertions/internal/ogletest" "reflect" ) //////////////////////////////////////////////////////////// // Helpers //////////////////////////////////////////////////////////// type InvokeTest struct { } func init() { RegisterTestSuite(&InvokeTest{}) } //////////////////////////////////////////////////////////// // Tests //////////////////////////////////////////////////////////// func (t *InvokeTest) ArgumentIsNil() { f := func() { oglemock.Invoke(nil) } ExpectThat(f, Panics(MatchesRegexp("Invoke.*function.*"))) } func (t *InvokeTest) ArgumentIsInt() { f := func() { oglemock.Invoke(17) } ExpectThat(f, Panics(MatchesRegexp("Invoke.*function.*int"))) } func (t *InvokeTest) FunctionHasOneWrongInputType() { f := func(a int, b int32, c string) {} g := func(a int, b int, c string) {} err := oglemock.Invoke(f).SetSignature(reflect.TypeOf(g)) ExpectThat(err, Error(HasSubstr("func(int, int32, string)"))) ExpectThat(err, Error(HasSubstr("func(int, int, string)"))) } func (t *InvokeTest) FunctionHasOneWrongOutputType() { f := func() (int32, string) { return 0, "" } g := func() (int, string) { return 0, "" } err := oglemock.Invoke(f).SetSignature(reflect.TypeOf(g)) ExpectThat(err, Error(HasSubstr("func() (int32, string)"))) ExpectThat(err, Error(HasSubstr("func() (int, string)"))) } func (t *InvokeTest) CallsFunction() { var actualArg0, actualArg1 interface{} f := func(a uintptr, b int8) { actualArg0 = a actualArg1 = b } a := oglemock.Invoke(f) // Set signature. AssertEq(nil, a.SetSignature(reflect.TypeOf(f))) // Call the action. expectedArg0 := uintptr(17) expectedArg1 := int8(-7) a.Invoke([]interface{}{expectedArg0, expectedArg1}) ExpectThat(actualArg0, IdenticalTo(expectedArg0)) ExpectThat(actualArg1, IdenticalTo(expectedArg1)) } func (t *InvokeTest) ReturnsFunctionResult() { expectedReturn0 := int16(3) expectedReturn1 := "taco" f := func() (int16, string) { return expectedReturn0, expectedReturn1 } a := oglemock.Invoke(f) // Set signature. AssertEq(nil, a.SetSignature(reflect.TypeOf(f))) // Call the action. res := a.Invoke([]interface{}{}) ExpectThat( res, ElementsAre( IdenticalTo(expectedReturn0), IdenticalTo(expectedReturn1))) } mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglemock/mock_object.go000066400000000000000000000023661321131462300336550ustar00rootroot00000000000000// Copyright 2011 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglemock // MockObject is an interface that mock object implementations must conform to // in order to register expectations with and hand off calls to a // MockController. Users should not interact with this interface directly. type MockObject interface { // Oglemock_Id returns an identifier for the mock object that is guaranteed // to be unique within the process at least until the mock object is garbage // collected. Oglemock_Id() uintptr // Oglemock_Description returns a description of the mock object that may be // helpful in test failure messages. Oglemock_Description() string } mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglemock/return.go000066400000000000000000000150011321131462300327030ustar00rootroot00000000000000// Copyright 2011 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglemock import ( "errors" "fmt" "math" "reflect" ) var intType = reflect.TypeOf(int(0)) var float64Type = reflect.TypeOf(float64(0)) var complex128Type = reflect.TypeOf(complex128(0)) // Return creates an Action that returns the values passed to Return as // arguments, after suitable legal type conversions. The following rules apply. // Given an argument x to Return and a corresponding type T in the method's // signature, at least one of the following must hold: // // * x is assignable to T. (See "Assignability" in the language spec.) Note // that this in particular applies that x may be a type that implements an // interface T. It also implies that the nil literal can be used if T is a // pointer, function, interface, slice, channel, or map type. // // * T is any numeric type, and x is an int that is in-range for that type. // This facilities using raw integer constants: Return(17). // // * T is a floating-point or complex number type, and x is a float64. This // facilities using raw floating-point constants: Return(17.5). // // * T is a complex number type, and x is a complex128. This facilities using // raw complex constants: Return(17+2i). // func Return(vals ...interface{}) Action { return &returnAction{vals, nil} } type returnAction struct { returnVals []interface{} signature reflect.Type } func (a *returnAction) Invoke(vals []interface{}) []interface{} { if a.signature == nil { panic("You must first call SetSignature with a valid signature.") } res, err := a.buildInvokeResult(a.signature) if err != nil { panic(err) } return res } func (a *returnAction) SetSignature(signature reflect.Type) error { if _, err := a.buildInvokeResult(signature); err != nil { return err } a.signature = signature return nil } // A version of Invoke that does error checking, used by both public methods. func (a *returnAction) buildInvokeResult( sig reflect.Type) (res []interface{}, err error) { // Check the length of the return value. numOut := sig.NumOut() numVals := len(a.returnVals) if numOut != numVals { err = errors.New( fmt.Sprintf("Return given %d vals; expected %d.", numVals, numOut)) return } // Attempt to coerce each return value. res = make([]interface{}, numOut) for i, val := range a.returnVals { resType := sig.Out(i) res[i], err = a.coerce(val, resType) if err != nil { res = nil err = errors.New(fmt.Sprintf("Return: arg %d: %v", i, err)) return } } return } func (a *returnAction) coerce(x interface{}, t reflect.Type) (interface{}, error) { xv := reflect.ValueOf(x) rv := reflect.New(t).Elem() // Special case: the language spec says that the predeclared identifier nil // is assignable to pointers, functions, interface, slices, channels, and map // types. However, reflect.ValueOf(nil) returns an invalid value that will // not cooperate below. So handle invalid values here, assuming that they // resulted from Return(nil). if !xv.IsValid() { switch t.Kind() { case reflect.Ptr, reflect.Func, reflect.Interface, reflect.Chan, reflect.Slice, reflect.Map, reflect.UnsafePointer: return rv.Interface(), nil } return nil, errors.New(fmt.Sprintf("expected %v, given ", t)) } // If x is assignable to type t, let the reflect package do the heavy // lifting. if reflect.TypeOf(x).AssignableTo(t) { rv.Set(xv) return rv.Interface(), nil } // Handle numeric types as described in the documentation on Return. switch { case xv.Type() == intType && a.isNumeric(t): return a.coerceInt(xv.Int(), t) case xv.Type() == float64Type && (a.isFloatingPoint(t) || a.isComplex(t)): return a.coerceFloat(xv.Float(), t) case xv.Type() == complex128Type && a.isComplex(t): return a.coerceComplex(xv.Complex(), t) } // The value wasn't of a legal type. return nil, errors.New(fmt.Sprintf("expected %v, given %v", t, xv.Type())) } func (a *returnAction) isNumeric(t reflect.Type) bool { return (t.Kind() >= reflect.Int && t.Kind() <= reflect.Uint64) || a.isFloatingPoint(t) || a.isComplex(t) } func (a *returnAction) isFloatingPoint(t reflect.Type) bool { return t.Kind() == reflect.Float32 || t.Kind() == reflect.Float64 } func (a *returnAction) isComplex(t reflect.Type) bool { return t.Kind() == reflect.Complex64 || t.Kind() == reflect.Complex128 } func (a *returnAction) coerceInt(x int64, t reflect.Type) (interface{}, error) { k := t.Kind() // Floating point and complex numbers: promote appropriately. if a.isFloatingPoint(t) || a.isComplex(t) { return a.coerceFloat(float64(x), t) } // Integers: range check. var min, max int64 unsigned := false switch k { case reflect.Int8: min = math.MinInt8 max = math.MaxInt8 case reflect.Int16: min = math.MinInt16 max = math.MaxInt16 case reflect.Int32: min = math.MinInt32 max = math.MaxInt32 case reflect.Int64: min = math.MinInt64 max = math.MaxInt64 case reflect.Uint: unsigned = true min = 0 max = math.MaxUint32 case reflect.Uint8: unsigned = true min = 0 max = math.MaxUint8 case reflect.Uint16: unsigned = true min = 0 max = math.MaxUint16 case reflect.Uint32: unsigned = true min = 0 max = math.MaxUint32 case reflect.Uint64: unsigned = true min = 0 max = math.MaxInt64 default: panic(fmt.Sprintf("Unexpected type: %v", t)) } if x < min || x > max { return nil, errors.New("int value out of range") } rv := reflect.New(t).Elem() if unsigned { rv.SetUint(uint64(x)) } else { rv.SetInt(x) } return rv.Interface(), nil } func (a *returnAction) coerceFloat(x float64, t reflect.Type) (interface{}, error) { // Promote complex numbers. if a.isComplex(t) { return a.coerceComplex(complex(x, 0), t) } rv := reflect.New(t).Elem() rv.SetFloat(x) return rv.Interface(), nil } func (a *returnAction) coerceComplex(x complex128, t reflect.Type) (interface{}, error) { rv := reflect.New(t).Elem() rv.SetComplex(x) return rv.Interface(), nil } mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglemock/return_test.go000066400000000000000000000614501321131462300337530ustar00rootroot00000000000000// Copyright 2011 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglemock_test import ( "bytes" . "github.com/smartystreets/assertions/internal/oglematchers" "github.com/smartystreets/assertions/internal/oglemock" . "github.com/smartystreets/assertions/internal/ogletest" "io" "math" "reflect" "testing" "unsafe" ) //////////////////////////////////////////////////////////// // Helpers //////////////////////////////////////////////////////////// var someInt int = 17 type ReturnTest struct { } func init() { RegisterTestSuite(&ReturnTest{}) } func TestOgletest(t *testing.T) { RunTests(t) } type returnTestCase struct { suppliedVal interface{} expectedVal interface{} expectedSetSignatureErrorSubstring string } func (t *ReturnTest) runTestCases(signature reflect.Type, cases []returnTestCase) { for i, c := range cases { a := oglemock.Return(c.suppliedVal) // SetSignature err := a.SetSignature(signature) if c.expectedSetSignatureErrorSubstring == "" { ExpectEq(nil, err, "Test case %d: %v", i, c) if err != nil { continue } } else { ExpectThat(err, Error(HasSubstr(c.expectedSetSignatureErrorSubstring)), "Test case %d: %v", i, c) continue } // Invoke res := a.Invoke([]interface{}{}) AssertThat(res, ElementsAre(Any())) ExpectThat(res[0], IdenticalTo(c.expectedVal), "Test case %d: %v", i, c) } } //////////////////////////////////////////////////////////// // Tests //////////////////////////////////////////////////////////// func (t *ReturnTest) SetSignatureNotCalled() { a := oglemock.Return() f := func() { a.Invoke([]interface{}{}) } ExpectThat(f, Panics(MatchesRegexp("first call SetSignature"))) } func (t *ReturnTest) NoReturnValues() { sig := reflect.TypeOf(func() {}) var a oglemock.Action var err error var vals []interface{} // No values. a = oglemock.Return() err = a.SetSignature(sig) AssertEq(nil, err) vals = a.Invoke([]interface{}{}) ExpectThat(vals, ElementsAre()) // One value. a = oglemock.Return(17) err = a.SetSignature(sig) ExpectThat(err, Error(HasSubstr("given 1 val"))) ExpectThat(err, Error(HasSubstr("expected 0"))) // Two values. a = oglemock.Return(17, 19) err = a.SetSignature(sig) ExpectThat(err, Error(HasSubstr("given 2 vals"))) ExpectThat(err, Error(HasSubstr("expected 0"))) } func (t *ReturnTest) MultipleReturnValues() { sig := reflect.TypeOf(func() (int, string) { return 0, "" }) var a oglemock.Action var err error var vals []interface{} // No values. a = oglemock.Return() err = a.SetSignature(sig) ExpectThat(err, Error(HasSubstr("given 0 vals"))) ExpectThat(err, Error(HasSubstr("expected 2"))) // One value. a = oglemock.Return(17) err = a.SetSignature(sig) ExpectThat(err, Error(HasSubstr("given 1 val"))) ExpectThat(err, Error(HasSubstr("expected 2"))) // Two values. a = oglemock.Return(17, "taco") err = a.SetSignature(sig) AssertEq(nil, err) vals = a.Invoke([]interface{}{}) ExpectThat(vals, ElementsAre(IdenticalTo(int(17)), "taco")) } func (t *ReturnTest) Bool() { sig := reflect.TypeOf(func() bool { return false }) cases := []returnTestCase{ // Identical types. {bool(true), bool(true), ""}, {bool(false), bool(false), ""}, // Wrong types. {nil, nil, "given "}, {int(1), nil, "given int"}, {float64(1), nil, "given float64"}, {complex128(1), nil, "given complex128"}, {&someInt, nil, "given *int"}, {make(chan int), nil, "given chan int"}, } t.runTestCases(sig, cases) } func (t *ReturnTest) Int() { sig := reflect.TypeOf(func() int { return 0 }) cases := []returnTestCase{ // Identical types. {int(math.MinInt32), int(math.MinInt32), ""}, {int(math.MaxInt32), int(math.MaxInt32), ""}, // Wrong types. {nil, nil, "given "}, {int16(1), nil, "given int16"}, {float64(1), nil, "given float64"}, {complex128(1), nil, "given complex128"}, {&someInt, nil, "given *int"}, {make(chan int), nil, "given chan int"}, } t.runTestCases(sig, cases) } func (t *ReturnTest) Int8() { sig := reflect.TypeOf(func() int8 { return 0 }) cases := []returnTestCase{ // Identical types. {int8(math.MinInt8), int8(math.MinInt8), ""}, {int8(math.MaxInt8), int8(math.MaxInt8), ""}, // In-range ints. {int(math.MinInt8), int8(math.MinInt8), ""}, {int(math.MaxInt8), int8(math.MaxInt8), ""}, // Out of range ints. {int(math.MinInt8 - 1), nil, "out of range"}, {int(math.MaxInt8 + 1), nil, "out of range"}, // Wrong types. {nil, nil, "given "}, {int16(1), nil, "given int16"}, {float64(1), nil, "given float64"}, {complex128(1), nil, "given complex128"}, {&someInt, nil, "given *int"}, {make(chan int), nil, "given chan int"}, } t.runTestCases(sig, cases) } func (t *ReturnTest) Int16() { sig := reflect.TypeOf(func() int16 { return 0 }) cases := []returnTestCase{ // Identical types. {int16(math.MinInt16), int16(math.MinInt16), ""}, {int16(math.MaxInt16), int16(math.MaxInt16), ""}, // In-range ints. {int(math.MinInt16), int16(math.MinInt16), ""}, {int(math.MaxInt16), int16(math.MaxInt16), ""}, // Out of range ints. {int(math.MinInt16 - 1), nil, "out of range"}, {int(math.MaxInt16 + 1), nil, "out of range"}, // Wrong types. {nil, nil, "given "}, {int8(1), nil, "given int8"}, {float64(1), nil, "given float64"}, {complex128(1), nil, "given complex128"}, {&someInt, nil, "given *int"}, {make(chan int), nil, "given chan int"}, } t.runTestCases(sig, cases) } func (t *ReturnTest) Int32() { sig := reflect.TypeOf(func() int32 { return 0 }) cases := []returnTestCase{ // Identical types. {int32(math.MinInt32), int32(math.MinInt32), ""}, {int32(math.MaxInt32), int32(math.MaxInt32), ""}, // Aliased version of type. {rune(17), int32(17), ""}, // In-range ints. {int(math.MinInt32), int32(math.MinInt32), ""}, {int(math.MaxInt32), int32(math.MaxInt32), ""}, // Wrong types. {nil, nil, "given "}, {int16(1), nil, "given int16"}, {float64(1), nil, "given float64"}, {complex128(1), nil, "given complex128"}, {&someInt, nil, "given *int"}, {make(chan int), nil, "given chan int"}, } t.runTestCases(sig, cases) } func (t *ReturnTest) Rune() { sig := reflect.TypeOf(func() rune { return 0 }) cases := []returnTestCase{ // Identical types. {rune(math.MinInt32), rune(math.MinInt32), ""}, {rune(math.MaxInt32), rune(math.MaxInt32), ""}, // Aliased version of type. {int32(17), rune(17), ""}, // In-range ints. {int(math.MinInt32), rune(math.MinInt32), ""}, {int(math.MaxInt32), rune(math.MaxInt32), ""}, // Wrong types. {nil, nil, "given "}, {int16(1), nil, "given int16"}, {float64(1), nil, "given float64"}, {complex128(1), nil, "given complex128"}, {&someInt, nil, "given *int"}, {make(chan int), nil, "given chan int"}, } t.runTestCases(sig, cases) } func (t *ReturnTest) Int64() { sig := reflect.TypeOf(func() int64 { return 0 }) cases := []returnTestCase{ // Identical types. {int64(math.MinInt64), int64(math.MinInt64), ""}, {int64(math.MaxInt64), int64(math.MaxInt64), ""}, // In-range ints. {int(math.MinInt32), int64(math.MinInt32), ""}, {int(math.MaxInt32), int64(math.MaxInt32), ""}, // Wrong types. {nil, nil, "given "}, {int16(1), nil, "given int16"}, {float64(1), nil, "given float64"}, {complex128(1), nil, "given complex128"}, {&someInt, nil, "given *int"}, {make(chan int), nil, "given chan int"}, } t.runTestCases(sig, cases) } func (t *ReturnTest) Uint() { sig := reflect.TypeOf(func() uint { return 0 }) cases := []returnTestCase{ // Identical types. {uint(0), uint(0), ""}, {uint(math.MaxUint32), uint(math.MaxUint32), ""}, // In-range ints. {int(0), uint(0), ""}, {int(math.MaxInt32), uint(math.MaxInt32), ""}, // Out of range ints. {int(-1), nil, "out of range"}, // Wrong types. {nil, nil, "given "}, {int16(1), nil, "given int16"}, {float64(1), nil, "given float64"}, {complex128(1), nil, "given complex128"}, {&someInt, nil, "given *int"}, {make(chan int), nil, "given chan int"}, } t.runTestCases(sig, cases) } func (t *ReturnTest) Uint8() { sig := reflect.TypeOf(func() uint8 { return 0 }) cases := []returnTestCase{ // Identical types. {uint8(0), uint8(0), ""}, {uint8(math.MaxUint8), uint8(math.MaxUint8), ""}, // Aliased version of type. {byte(17), uint8(17), ""}, // In-range ints. {int(0), uint8(0), ""}, {int(math.MaxUint8), uint8(math.MaxUint8), ""}, // Out of range ints. {int(-1), nil, "out of range"}, {int(math.MaxUint8 + 1), nil, "out of range"}, // Wrong types. {nil, nil, "given "}, {int16(1), nil, "given int16"}, {float64(1), nil, "given float64"}, {complex128(1), nil, "given complex128"}, {&someInt, nil, "given *int"}, {make(chan int), nil, "given chan int"}, } t.runTestCases(sig, cases) } func (t *ReturnTest) Byte() { sig := reflect.TypeOf(func() byte { return 0 }) cases := []returnTestCase{ // Identical types. {byte(0), byte(0), ""}, {byte(math.MaxUint8), byte(math.MaxUint8), ""}, // Aliased version of type. {uint8(17), byte(17), ""}, // In-range ints. {int(0), byte(0), ""}, {int(math.MaxUint8), byte(math.MaxUint8), ""}, // Out of range ints. {int(-1), nil, "out of range"}, {int(math.MaxUint8 + 1), nil, "out of range"}, // Wrong types. {nil, nil, "given "}, {int16(1), nil, "given int16"}, {float64(1), nil, "given float64"}, {complex128(1), nil, "given complex128"}, {&someInt, nil, "given *int"}, {make(chan int), nil, "given chan int"}, } t.runTestCases(sig, cases) } func (t *ReturnTest) Uint16() { sig := reflect.TypeOf(func() uint16 { return 0 }) cases := []returnTestCase{ // Identical types. {uint16(0), uint16(0), ""}, {uint16(math.MaxUint16), uint16(math.MaxUint16), ""}, // In-range ints. {int(0), uint16(0), ""}, {int(math.MaxUint16), uint16(math.MaxUint16), ""}, // Out of range ints. {int(-1), nil, "out of range"}, {int(math.MaxUint16 + 1), nil, "out of range"}, // Wrong types. {nil, nil, "given "}, {int16(1), nil, "given int16"}, {float64(1), nil, "given float64"}, {complex128(1), nil, "given complex128"}, {&someInt, nil, "given *int"}, {make(chan int), nil, "given chan int"}, } t.runTestCases(sig, cases) } func (t *ReturnTest) Uint32() { sig := reflect.TypeOf(func() uint32 { return 0 }) cases := []returnTestCase{ // Identical types. {uint32(0), uint32(0), ""}, {uint32(math.MaxUint32), uint32(math.MaxUint32), ""}, // In-range ints. {int(0), uint32(0), ""}, {int(math.MaxInt32), uint32(math.MaxInt32), ""}, // Out of range ints. {int(-1), nil, "out of range"}, // Wrong types. {nil, nil, "given "}, {int16(1), nil, "given int16"}, {float64(1), nil, "given float64"}, {complex128(1), nil, "given complex128"}, {&someInt, nil, "given *int"}, {make(chan int), nil, "given chan int"}, } t.runTestCases(sig, cases) } func (t *ReturnTest) Uint64() { sig := reflect.TypeOf(func() uint64 { return 0 }) cases := []returnTestCase{ // Identical types. {uint64(0), uint64(0), ""}, {uint64(math.MaxUint64), uint64(math.MaxUint64), ""}, // In-range ints. {int(0), uint64(0), ""}, {int(math.MaxInt32), uint64(math.MaxInt32), ""}, // Out of range ints. {int(-1), nil, "out of range"}, // Wrong types. {nil, nil, "given "}, {int16(1), nil, "given int16"}, {float64(1), nil, "given float64"}, {complex128(1), nil, "given complex128"}, {&someInt, nil, "given *int"}, {make(chan int), nil, "given chan int"}, } t.runTestCases(sig, cases) } func (t *ReturnTest) Uintptr() { sig := reflect.TypeOf(func() uintptr { return 0 }) cases := []returnTestCase{ // Identical types. {uintptr(17), uintptr(17), ""}, // Wrong types. {nil, nil, "given "}, {int(1), nil, "given int"}, {float64(1), nil, "given float64"}, {complex128(1), nil, "given complex128"}, {&someInt, nil, "given *int"}, {make(chan int), nil, "given chan int"}, } t.runTestCases(sig, cases) } func (t *ReturnTest) Float32() { sig := reflect.TypeOf(func() float32 { return 0 }) cases := []returnTestCase{ // Identical types. {float32(-17.5), float32(-17.5), ""}, {float32(17.5), float32(17.5), ""}, // In-range ints. {int(-17), float32(-17), ""}, {int(17), float32(17), ""}, // Float64s {float64(-17.5), float32(-17.5), ""}, {float64(17.5), float32(17.5), ""}, // Wrong types. {nil, nil, "given "}, {int16(1), nil, "given int16"}, {complex128(1), nil, "given complex128"}, {&someInt, nil, "given *int"}, {make(chan int), nil, "given chan int"}, } t.runTestCases(sig, cases) } func (t *ReturnTest) Float64() { sig := reflect.TypeOf(func() float64 { return 0 }) cases := []returnTestCase{ // Identical types. {float64(-17.5), float64(-17.5), ""}, {float64(17.5), float64(17.5), ""}, // In-range ints. {int(-17), float64(-17), ""}, {int(17), float64(17), ""}, // Wrong types. {nil, nil, "given "}, {int16(1), nil, "given int16"}, {float32(1), nil, "given float32"}, {complex128(1), nil, "given complex128"}, {&someInt, nil, "given *int"}, {make(chan int), nil, "given chan int"}, } t.runTestCases(sig, cases) } func (t *ReturnTest) Complex64() { sig := reflect.TypeOf(func() complex64 { return 0 }) cases := []returnTestCase{ // Identical types. {complex64(-17.5 - 1i), complex64(-17.5 - 1i), ""}, {complex64(17.5 + 1i), complex64(17.5 + 1i), ""}, // In-range ints. {int(-17), complex64(-17), ""}, {int(17), complex64(17), ""}, // Float64s {float64(-17.5), complex64(-17.5), ""}, {float64(17.5), complex64(17.5), ""}, // Complex128s {complex128(-17.5 - 1i), complex64(-17.5 - 1i), ""}, {complex128(17.5 + 1i), complex64(17.5 + 1i), ""}, // Wrong types. {nil, nil, "given "}, {int16(1), nil, "given int16"}, {float32(1), nil, "given float32"}, {&someInt, nil, "given *int"}, {make(chan int), nil, "given chan int"}, } t.runTestCases(sig, cases) } func (t *ReturnTest) Complex128() { sig := reflect.TypeOf(func() complex128 { return 0 }) cases := []returnTestCase{ // Identical types. {complex128(-17.5 - 1i), complex128(-17.5 - 1i), ""}, {complex128(17.5 + 1i), complex128(17.5 + 1i), ""}, // In-range ints. {int(-17), complex128(-17), ""}, {int(17), complex128(17), ""}, // Float64s {float64(-17.5), complex128(-17.5), ""}, {float64(17.5), complex128(17.5), ""}, // Wrong types. {nil, nil, "given "}, {int16(1), nil, "given int16"}, {float32(1), nil, "given float32"}, {complex64(1), nil, "given complex64"}, {&someInt, nil, "given *int"}, {make(chan int), nil, "given chan int"}, } t.runTestCases(sig, cases) } func (t *ReturnTest) ArrayOfInt() { type namedElemType int sig := reflect.TypeOf(func() [2]int { return [2]int{0, 0} }) cases := []returnTestCase{ // Identical types. {[2]int{19, 23}, [2]int{19, 23}, ""}, // Wrong length. {[1]int{17}, nil, "given [1]int"}, // Wrong element types. {[2]namedElemType{19, 23}, nil, "given [2]oglemock_test.namedElemType"}, {[2]string{"", ""}, nil, "given [2]string"}, // Wrong types. {nil, nil, "given "}, {int(1), nil, "given int"}, {float64(1), nil, "given float64"}, {complex128(1), nil, "given complex128"}, {&someInt, nil, "given *int"}, {make(chan int), nil, "given chan int"}, } t.runTestCases(sig, cases) } func (t *ReturnTest) ChanOfInt() { type namedElemType int someChan := make(chan int) sig := reflect.TypeOf(func() chan int { return nil }) cases := []returnTestCase{ // Identical types. {someChan, someChan, ""}, // Nil values. {(interface{})(nil), (chan int)(nil), ""}, {(chan int)(nil), (chan int)(nil), ""}, // Wrong element types. {make(chan string), nil, "given chan string"}, {make(chan namedElemType), nil, "given chan oglemock_test.namedElemType"}, // Wrong direction {(<-chan int)(someChan), nil, "given <-chan int"}, {(chan<- int)(someChan), nil, "given chan<- int"}, // Wrong types. {(func())(nil), nil, "given func()"}, {int(1), nil, "given int"}, {float64(1), nil, "given float64"}, {complex128(1), nil, "given complex128"}, {&someInt, nil, "given *int"}, } t.runTestCases(sig, cases) } func (t *ReturnTest) SendChanOfInt() { type namedElemType int someChan := make(chan<- int) someBidirectionalChannel := make(chan int) sig := reflect.TypeOf(func() chan<- int { return nil }) cases := []returnTestCase{ // Identical types. {someChan, someChan, ""}, // Nil values. {(interface{})(nil), (chan<- int)(nil), ""}, {(chan int)(nil), (chan<- int)(nil), ""}, // Bidirectional channel {someBidirectionalChannel, (chan<- int)(someBidirectionalChannel), ""}, // Wrong direction {(<-chan int)(someBidirectionalChannel), nil, "given <-chan int"}, // Wrong element types. {make(chan string), nil, "given chan string"}, {make(chan namedElemType), nil, "given chan oglemock_test.namedElemType"}, // Wrong types. {(func())(nil), nil, "given func()"}, {int(1), nil, "given int"}, {float64(1), nil, "given float64"}, {complex128(1), nil, "given complex128"}, {&someInt, nil, "given *int"}, } t.runTestCases(sig, cases) } func (t *ReturnTest) RecvChanOfInt() { type namedElemType int someChan := make(<-chan int) someBidirectionalChannel := make(chan int) sig := reflect.TypeOf(func() <-chan int { return nil }) cases := []returnTestCase{ // Identical types. {someChan, someChan, ""}, // Nil values. {(interface{})(nil), (<-chan int)(nil), ""}, {(chan int)(nil), (<-chan int)(nil), ""}, // Bidirectional channel {someBidirectionalChannel, (<-chan int)(someBidirectionalChannel), ""}, // Wrong direction {(chan<- int)(someBidirectionalChannel), nil, "given chan<- int"}, // Wrong element types. {make(chan string), nil, "given chan string"}, {make(chan namedElemType), nil, "given chan oglemock_test.namedElemType"}, // Wrong types. {(func())(nil), nil, "given func()"}, {int(1), nil, "given int"}, {float64(1), nil, "given float64"}, {complex128(1), nil, "given complex128"}, {&someInt, nil, "given *int"}, } t.runTestCases(sig, cases) } func (t *ReturnTest) Func() { someFunc := func(string) int { return 0 } sig := reflect.TypeOf(func() func(string) int { return nil }) cases := []returnTestCase{ // Identical types. {someFunc, someFunc, ""}, // Nil values. {(interface{})(nil), (func(string) int)(nil), ""}, {(func(string) int)(nil), (func(string) int)(nil), ""}, // Wrong parameter and return types. {func(int) int { return 0 }, nil, "given func(int) int"}, {func(string) string { return "" }, nil, "given func(string) string"}, // Wrong types. {int(1), nil, "given int"}, {float64(1), nil, "given float64"}, {complex128(1), nil, "given complex128"}, {&someInt, nil, "given *int"}, {(chan int)(nil), nil, "given chan int"}, } t.runTestCases(sig, cases) } func (t *ReturnTest) Interface() { sig := reflect.TypeOf(func() io.Reader { return nil }) someBuffer := new(bytes.Buffer) cases := []returnTestCase{ // Type that implements interface. {someBuffer, someBuffer, ""}, // Nil value. {(interface{})(nil), (interface{})(nil), ""}, // Non-implementing types. {(chan int)(nil), nil, "given chan int"}, {int(1), nil, "given int"}, {float64(1), nil, "given float64"}, {complex128(1), nil, "given complex128"}, {&someInt, nil, "given *int"}, } t.runTestCases(sig, cases) } func (t *ReturnTest) MapFromStringToInt() { type namedElemType string someMap := make(map[string]int) sig := reflect.TypeOf(func() map[string]int { return nil }) cases := []returnTestCase{ // Identical types. {someMap, someMap, ""}, // Nil values. {(interface{})(nil), (map[string]int)(nil), ""}, {(map[string]int)(nil), (map[string]int)(nil), ""}, // Wrong element types. {make(map[int]int), nil, "given map[int]int"}, {make(map[namedElemType]int), nil, "given map[oglemock_test.namedElemType]int"}, {make(map[string]string), nil, "given map[string]string"}, // Wrong types. {(func())(nil), nil, "given func()"}, {int(1), nil, "given int"}, {float64(1), nil, "given float64"}, {complex128(1), nil, "given complex128"}, {&someInt, nil, "given *int"}, } t.runTestCases(sig, cases) } func (t *ReturnTest) PointerToString() { type namedElemType string someStr := "" sig := reflect.TypeOf(func() *string { return nil }) cases := []returnTestCase{ // Identical types. {(*string)(&someStr), (*string)(&someStr), ""}, // Nil values. {(interface{})(nil), (*string)(nil), ""}, {(*string)(nil), (*string)(nil), ""}, // Wrong element types. {&someInt, nil, "given *int"}, // Wrong types. {(func())(nil), nil, "given func()"}, {int(1), nil, "given int"}, {float64(1), nil, "given float64"}, {complex128(1), nil, "given complex128"}, {unsafe.Pointer(&someStr), nil, "given unsafe.Pointer"}, } t.runTestCases(sig, cases) } func (t *ReturnTest) SliceOfInts() { type namedElemType int someSlice := make([]int, 1) sig := reflect.TypeOf(func() []int { return nil }) cases := []returnTestCase{ // Identical types. {someSlice, someSlice, ""}, // Nil values. {(interface{})(nil), ([]int)(nil), ""}, {([]int)(nil), ([]int)(nil), ""}, // Wrong element types. {make([]string, 1), nil, "given []string"}, {make([]namedElemType, 1), nil, "given []oglemock_test.namedElemType"}, // Wrong types. {(func())(nil), nil, "given func()"}, {int(1), nil, "given int"}, {float64(1), nil, "given float64"}, {complex128(1), nil, "given complex128"}, {&someInt, nil, "given *int"}, } t.runTestCases(sig, cases) } func (t *ReturnTest) String() { sig := reflect.TypeOf(func() string { return "" }) cases := []returnTestCase{ // Identical types. {string(""), string(""), ""}, {string("taco"), string("taco"), ""}, // Wrong types. {nil, nil, "given "}, {int(1), nil, "given int"}, {float64(1), nil, "given float64"}, {complex128(1), nil, "given complex128"}, {&someInt, nil, "given *int"}, {make(chan int), nil, "given chan int"}, } t.runTestCases(sig, cases) } func (t *ReturnTest) Struct() { type myStruct struct { a int } type otherStruct struct{} sig := reflect.TypeOf(func() myStruct { return myStruct{0} }) cases := []returnTestCase{ // Identical types. {myStruct{17}, myStruct{17}, ""}, // Wrong field types. {otherStruct{}, nil, "given oglemock_test.otherStruct"}, // Wrong types. {nil, nil, "given "}, {int(1), nil, "given int"}, {float64(1), nil, "given float64"}, {complex128(1), nil, "given complex128"}, {&someInt, nil, "given *int"}, {make(chan int), nil, "given chan int"}, } t.runTestCases(sig, cases) } func (t *ReturnTest) UnsafePointer() { someStr := "" sig := reflect.TypeOf(func() unsafe.Pointer { return nil }) cases := []returnTestCase{ // Identical types. {unsafe.Pointer(&someStr), unsafe.Pointer(&someStr), ""}, // Nil values. {(interface{})(nil), unsafe.Pointer(nil), ""}, {unsafe.Pointer(nil), unsafe.Pointer(nil), ""}, // Wrong types. {(func())(nil), nil, "given func()"}, {int(1), nil, "given int"}, {float64(1), nil, "given float64"}, {complex128(1), nil, "given complex128"}, {(*string)(&someStr), nil, "given *string"}, } t.runTestCases(sig, cases) } func (t *ReturnTest) UserDefinedNumericType() { type myType int16 sig := reflect.TypeOf(func() myType { return 0 }) cases := []returnTestCase{ // Identical types. {myType(math.MinInt16), myType(math.MinInt16), ""}, {myType(math.MaxInt16), myType(math.MaxInt16), ""}, // In-range ints. {int(math.MinInt16), myType(math.MinInt16), ""}, {int(math.MaxInt16), myType(math.MaxInt16), ""}, // Out of range ints. {int(math.MinInt16 - 1), nil, "out of range"}, {int(math.MaxInt16 + 1), nil, "out of range"}, // Wrong types. {nil, nil, "given "}, {int16(1), nil, "given int16"}, {float64(1), nil, "given float64"}, {complex128(1), nil, "given complex128"}, {&someInt, nil, "given *int"}, {make(chan int), nil, "given chan int"}, } t.runTestCases(sig, cases) } func (t *ReturnTest) UserDefinedNonNumericType() { type myType string sig := reflect.TypeOf(func() myType { return "" }) cases := []returnTestCase{ // Identical types. {myType("taco"), myType("taco"), ""}, // Wrong types. {nil, nil, "given "}, {int(1), nil, "given int"}, {float64(1), nil, "given float64"}, {complex128(1), nil, "given complex128"}, {string(""), nil, "given string"}, {&someInt, nil, "given *int"}, {make(chan int), nil, "given chan int"}, } t.runTestCases(sig, cases) } mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglemock/sample/000077500000000000000000000000001321131462300323215ustar00rootroot00000000000000README.markdown000066400000000000000000000003621321131462300347440ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglemock/sampleThis directory contains sample code generated with the `createmock` command. For example, the file `mock_io.go` can be regenerated with: createmock io Reader > sample/mock_io/mock_io.go The files are also used by `integration_test.go`. mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglemock/sample/mock_io/000077500000000000000000000000001321131462300337415ustar00rootroot00000000000000mock_io.go000066400000000000000000000024601321131462300356330ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglemock/sample/mock_io// This file was auto-generated using createmock. See the following page for // more information: // // https://github.com/smartystreets/assertions/internal/oglemock // package mock_io import ( fmt "fmt" oglemock "github.com/smartystreets/assertions/internal/oglemock" io "io" runtime "runtime" unsafe "unsafe" ) type MockReader interface { io.Reader oglemock.MockObject } type mockReader struct { controller oglemock.Controller description string } func NewMockReader( c oglemock.Controller, desc string) MockReader { return &mockReader{ controller: c, description: desc, } } func (m *mockReader) Oglemock_Id() uintptr { return uintptr(unsafe.Pointer(m)) } func (m *mockReader) Oglemock_Description() string { return m.description } func (m *mockReader) Read(p0 []uint8) (o0 int, o1 error) { // Get a file name and line number for the caller. _, file, line, _ := runtime.Caller(1) // Hand the call off to the controller, which does most of the work. retVals := m.controller.HandleMethodCall( m, "Read", file, line, []interface{}{p0}) if len(retVals) != 2 { panic(fmt.Sprintf("mockReader.Read: invalid return values: %v", retVals)) } // o0 int if retVals[0] != nil { o0 = retVals[0].(int) } // o1 error if retVals[1] != nil { o1 = retVals[1].(error) } return } mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglemock/save_arg.go000066400000000000000000000040441321131462300331600ustar00rootroot00000000000000// Copyright 2015 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglemock import ( "fmt" "reflect" ) // Create an Action that saves the argument at the given zero-based index to // the supplied destination, which must be a pointer to a type that is // assignable from the argument type. func SaveArg(index int, dst interface{}) Action { return &saveArg{ index: index, dstPointer: dst, } } type saveArg struct { index int dstPointer interface{} // Set by SetSignature. dstValue reflect.Value } func (a *saveArg) SetSignature(signature reflect.Type) (err error) { // Extract the source type. if a.index >= signature.NumIn() { err = fmt.Errorf( "Out of range argument index %v for function type %v", a.index, signature) return } srcType := signature.In(a.index) // The destination must be a pointer. v := reflect.ValueOf(a.dstPointer) if v.Kind() != reflect.Ptr { err = fmt.Errorf("Destination is %v, not a pointer", v.Kind()) return } // Dereference the pointer. if v.IsNil() { err = fmt.Errorf("Destination pointer must be non-nil") return } a.dstValue = v.Elem() // The destination must be assignable from the source. if !srcType.AssignableTo(a.dstValue.Type()) { err = fmt.Errorf( "%v is not assignable to %v", srcType, a.dstValue.Type()) return } return } func (a *saveArg) Invoke(methodArgs []interface{}) (rets []interface{}) { a.dstValue.Set(reflect.ValueOf(methodArgs[a.index])) return } mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/oglemock/save_arg_test.go000066400000000000000000000071751321131462300342270ustar00rootroot00000000000000// Copyright 2015 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglemock_test import ( "io" "os" "reflect" "testing" . "github.com/smartystreets/assertions/internal/oglematchers" "github.com/smartystreets/assertions/internal/oglemock" . "github.com/smartystreets/assertions/internal/ogletest" ) func TestSaveArg(t *testing.T) { RunTests(t) } //////////////////////////////////////////////////////////// // Boilerplate //////////////////////////////////////////////////////////// type SaveArgTest struct { } func init() { RegisterTestSuite(&SaveArgTest{}) } //////////////////////////////////////////////////////////// // Test functions //////////////////////////////////////////////////////////// func (t *SaveArgTest) FunctionHasNoArguments() { const index = 0 var dst int f := func() (int, string) { return 0, "" } err := oglemock.SaveArg(index, &dst).SetSignature(reflect.TypeOf(f)) ExpectThat(err, Error(HasSubstr("index 0"))) ExpectThat(err, Error(HasSubstr("Out of range"))) ExpectThat(err, Error(HasSubstr("func() (int, string)"))) } func (t *SaveArgTest) ArgumentIndexOutOfRange() { const index = 2 var dst int f := func(a int, b int) {} err := oglemock.SaveArg(index, &dst).SetSignature(reflect.TypeOf(f)) ExpectThat(err, Error(HasSubstr("index 2"))) ExpectThat(err, Error(HasSubstr("Out of range"))) ExpectThat(err, Error(HasSubstr("func(int, int)"))) } func (t *SaveArgTest) DestinationIsLiteralNil() { const index = 0 f := func(a int, b int) {} err := oglemock.SaveArg(index, nil).SetSignature(reflect.TypeOf(f)) ExpectThat(err, Error(HasSubstr("not a pointer"))) } func (t *SaveArgTest) DestinationIsNotAPointer() { const index = 0 f := func(a int, b int) {} err := oglemock.SaveArg(index, uint(17)).SetSignature(reflect.TypeOf(f)) ExpectThat(err, Error(HasSubstr("pointer"))) ExpectThat(err, Error(HasSubstr("uint"))) } func (t *SaveArgTest) DestinationIsNilPointer() { const index = 1 var dst *int f := func(a int, b int) {} err := oglemock.SaveArg(index, dst).SetSignature(reflect.TypeOf(f)) ExpectThat(err, Error(HasSubstr("pointer"))) ExpectThat(err, Error(HasSubstr("non-nil"))) } func (t *SaveArgTest) DestinationNotAssignableFromSource() { const index = 1 var dst int f := func(a int, b string) {} err := oglemock.SaveArg(index, &dst).SetSignature(reflect.TypeOf(f)) ExpectThat(err, Error(HasSubstr("int"))) ExpectThat(err, Error(HasSubstr("assignable"))) ExpectThat(err, Error(HasSubstr("string"))) } func (t *SaveArgTest) ExactTypeMatch() { const index = 1 var dst int f := func(a int, b int) {} action := oglemock.SaveArg(index, &dst) AssertEq(nil, action.SetSignature(reflect.TypeOf(f))) var a int = 17 var b int = 19 _ = action.Invoke([]interface{}{a, b}) ExpectEq(19, dst) } func (t *SaveArgTest) AssignableTypeMatch() { const index = 1 var dst io.Reader f := func(a int, b *os.File) {} action := oglemock.SaveArg(index, &dst) AssertEq(nil, action.SetSignature(reflect.TypeOf(f))) var a int = 17 var b *os.File = os.Stdout _ = action.Invoke([]interface{}{a, b}) ExpectEq(os.Stdout, dst) } mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/ogletest/000077500000000000000000000000001321131462300310665ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/ogletest/.gitignore000066400000000000000000000000441321131462300330540ustar00rootroot00000000000000*.6 6.out _obj/ _test/ _testmain.go mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/ogletest/.travis.yml000066400000000000000000000001671321131462300332030ustar00rootroot00000000000000# Cf. http://docs.travis-ci.com/user/getting-started/ # Cf. http://docs.travis-ci.com/user/languages/go/ language: go mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/ogletest/LICENSE000066400000000000000000000261361321131462300321030ustar00rootroot00000000000000 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. mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/ogletest/README.md000066400000000000000000000124171321131462300323520ustar00rootroot00000000000000[![GoDoc](https://godoc.org/github.com/smartystreets/assertions/internal/ogletest?status.svg)](https://godoc.org/github.com/smartystreets/assertions/internal/ogletest) `ogletest` is a unit testing framework for Go with the following features: * An extensive and extensible set of matchers for expressing expectations. * Automatic failure messages; no need to say `t.Errorf("Expected %v, got %v"...)`. * Clean, readable output that tells you exactly what you need to know. * Built-in support for mocking through the [oglemock][] package. * Style and semantics similar to [Google Test][googletest] and [Google JS Test][google-js-test]. It integrates with Go's built-in `testing` package, so it works with the `go test` command, and even with other types of test within your package. Unlike the `testing` package which offers only basic capabilities for signalling failures, it offers ways to express expectations and get nice failure messages automatically. Installation ------------ First, make sure you have installed Go 1.0.2 or newer. See [here][golang-install] for instructions. Use the following command to install `ogletest` and its dependencies, and to keep them up to date: go get -u github.com/smartystreets/assertions/internal/ogletest Documentation ------------- See [here][reference] for package documentation containing an exhaustive list of exported symbols. Alternatively, you can install the package and then use `godoc`: godoc github.com/smartystreets/assertions/internal/ogletest An important part of `ogletest` is its use of matchers provided by the [oglematchers][matcher-reference] package. See that package's documentation for information on the built-in matchers available, and check out the `oglematchers.Matcher` interface if you want to define your own. Example ------- Let's say you have a function in your package `people` with the following signature: ```go // GetRandomPerson returns the name and phone number of Tony, Dennis, or Scott. func GetRandomPerson() (name, phone string) { [...] } ``` A silly function, but it will do for an example. You can write a couple of tests for it as follows: ```go package people import ( "github.com/smartystreets/assertions/internal/oglematchers" "github.com/smartystreets/assertions/internal/ogletest" "testing" ) // Give ogletest a chance to run your tests when invoked by 'go test'. func TestOgletest(t *testing.T) { ogletest.RunTests(t) } // Create a test suite, which groups together logically related test methods // (defined below). You can share common setup and teardown code here; see the // package docs for more info. type PeopleTest struct {} func init() { ogletest.RegisterTestSuite(&PeopleTest{}) } func (t *PeopleTest) ReturnsCorrectNames() { // Call the function a few times, and make sure it never strays from the set // of expected names. for i := 0; i < 25; i++ { name, _ := GetRandomPerson() ogletest.ExpectThat(name, oglematchers.AnyOf("Tony", "Dennis", "Scott")) } } func (t *PeopleTest) FormatsPhoneNumbersCorrectly() { // Call the function a few times, and make sure it returns phone numbers in a // standard US format. for i := 0; i < 25; i++ { _, phone := GetRandomPerson() ogletest.ExpectThat(phone, oglematchers.MatchesRegexp(`^\(\d{3}\) \d{3}-\d{4}$`)) } ``` Note that test control functions (`RunTests`, `ExpectThat`, and so on) are part of the `ogletest` package, whereas built-in matchers (`AnyOf`, `MatchesRegexp`, and more) are part of the [oglematchers][matcher-reference] library. You can of course use dot imports so that you don't need to prefix each function with its package name: ```go import ( . "github.com/smartystreets/assertions/internal/oglematchers" . "github.com/smartystreets/assertions/internal/ogletest" ) ``` If you save the test in a file whose name ends in `_test.go`, you can run your tests by simply invoking the following in your package directory: go test Here's what the failure output of ogletest looks like, if your function's implementation is bad. [----------] Running tests from PeopleTest [ RUN ] PeopleTest.FormatsPhoneNumbersCorrectly people_test.go:32: Expected: matches regexp "^\(\d{3}\) \d{3}-\d{4}$" Actual: +1 800 555 5555 [ FAILED ] PeopleTest.FormatsPhoneNumbersCorrectly [ RUN ] PeopleTest.ReturnsCorrectNames people_test.go:23: Expected: or(Tony, Dennis, Scott) Actual: Bart [ FAILED ] PeopleTest.ReturnsCorrectNames [----------] Finished with tests from PeopleTest And if the test passes: [----------] Running tests from PeopleTest [ RUN ] PeopleTest.FormatsPhoneNumbersCorrectly [ OK ] PeopleTest.FormatsPhoneNumbersCorrectly [ RUN ] PeopleTest.ReturnsCorrectNames [ OK ] PeopleTest.ReturnsCorrectNames [----------] Finished with tests from PeopleTest [reference]: http://godoc.org/github.com/smartystreets/assertions/internal/ogletest [matcher-reference]: http://godoc.org/github.com/smartystreets/assertions/internal/oglematchers [golang-install]: http://golang.org/doc/install.html [googletest]: http://code.google.com/p/googletest/ [google-js-test]: http://code.google.com/p/google-js-test/ [howtowrite]: http://golang.org/doc/code.html [oglemock]: https://github.com/smartystreets/assertions/internal/oglemock assert_aliases.go000066400000000000000000000046171321131462300343500ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/ogletest// Copyright 2011 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 ogletest import ( "github.com/smartystreets/assertions/internal/oglematchers" ) // AssertEq(e, a) is equivalent to AssertThat(a, oglematchers.Equals(e)). func AssertEq(expected, actual interface{}, errorParts ...interface{}) { assertThat( actual, oglematchers.Equals(expected), 1, errorParts) } // AssertNe(e, a) is equivalent to // AssertThat(a, oglematchers.Not(oglematchers.Equals(e))). func AssertNe(expected, actual interface{}, errorParts ...interface{}) { assertThat( actual, oglematchers.Not(oglematchers.Equals(expected)), 1, errorParts) } // AssertLt(x, y) is equivalent to AssertThat(x, oglematchers.LessThan(y)). func AssertLt(x, y interface{}, errorParts ...interface{}) { assertThat(x, oglematchers.LessThan(y), 1, errorParts) } // AssertLe(x, y) is equivalent to AssertThat(x, oglematchers.LessOrEqual(y)). func AssertLe(x, y interface{}, errorParts ...interface{}) { assertThat(x, oglematchers.LessOrEqual(y), 1, errorParts) } // AssertGt(x, y) is equivalent to AssertThat(x, oglematchers.GreaterThan(y)). func AssertGt(x, y interface{}, errorParts ...interface{}) { assertThat(x, oglematchers.GreaterThan(y), 1, errorParts) } // AssertGe(x, y) is equivalent to // AssertThat(x, oglematchers.GreaterOrEqual(y)). func AssertGe(x, y interface{}, errorParts ...interface{}) { assertThat(x, oglematchers.GreaterOrEqual(y), 1, errorParts) } // AssertTrue(b) is equivalent to AssertThat(b, oglematchers.Equals(true)). func AssertTrue(b interface{}, errorParts ...interface{}) { assertThat(b, oglematchers.Equals(true), 1, errorParts) } // AssertFalse(b) is equivalent to AssertThat(b, oglematchers.Equals(false)). func AssertFalse(b interface{}, errorParts ...interface{}) { assertThat(b, oglematchers.Equals(false), 1, errorParts) } mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/ogletest/assert_that.go000066400000000000000000000025511321131462300337410ustar00rootroot00000000000000// Copyright 2011 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 ogletest import ( "github.com/smartystreets/assertions/internal/oglematchers" ) func assertThat( x interface{}, m oglematchers.Matcher, depth int, errorParts []interface{}) { passed := expectThat(x, m, depth+1, errorParts) if !passed { AbortTest() } } // AssertThat is identical to ExpectThat, except that in the event of failure // it halts the currently running test immediately. It is thus useful for // things like bounds checking: // // someSlice := [...] // AssertEq(1, len(someSlice)) // Protects next line from panicking. // ExpectEq("taco", someSlice[0]) // func AssertThat( x interface{}, m oglematchers.Matcher, errorParts ...interface{}) { assertThat(x, m, 1, errorParts) } mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/ogletest/doc.go000066400000000000000000000037221321131462300321660ustar00rootroot00000000000000// Copyright 2011 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 ogletest provides a framework for writing expressive unit tests. It // integrates with the builtin testing package, so it works with the gotest // command. Unlike the testing package which offers only basic capabilities for // signalling failures, it offers ways to express expectations and get nice // failure messages automatically. // // For example: // // //////////////////////////////////////////////////////////////////////// // // testing package test // //////////////////////////////////////////////////////////////////////// // // someStr, err := ComputeSomeString() // if err != nil { // t.Errorf("ComputeSomeString: expected nil error, got %v", err) // } // // !strings.Contains(someStr, "foo") { // t.Errorf("ComputeSomeString: expected substring foo, got %v", someStr) // } // // //////////////////////////////////////////////////////////////////////// // // ogletest test // //////////////////////////////////////////////////////////////////////// // // someStr, err := ComputeSomeString() // ExpectEq(nil, err) // ExpectThat(someStr, HasSubstr("foo") // // Failure messages require no work from the user, and look like the following: // // foo_test.go:103: // Expected: has substring "foo" // Actual: "bar baz" // package ogletest expect_aliases.go000066400000000000000000000046011321131462300343300ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/ogletest// Copyright 2011 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 ogletest import "github.com/smartystreets/assertions/internal/oglematchers" // ExpectEq(e, a) is equivalent to ExpectThat(a, oglematchers.Equals(e)). func ExpectEq(expected, actual interface{}, errorParts ...interface{}) { expectThat(actual, oglematchers.Equals(expected), 1, errorParts) } // ExpectNe(e, a) is equivalent to // ExpectThat(a, oglematchers.Not(oglematchers.Equals(e))). func ExpectNe(expected, actual interface{}, errorParts ...interface{}) { expectThat( actual, oglematchers.Not(oglematchers.Equals(expected)), 1, errorParts) } // ExpectLt(x, y) is equivalent to ExpectThat(x, oglematchers.LessThan(y)). func ExpectLt(x, y interface{}, errorParts ...interface{}) { expectThat(x, oglematchers.LessThan(y), 1, errorParts) } // ExpectLe(x, y) is equivalent to ExpectThat(x, oglematchers.LessOrEqual(y)). func ExpectLe(x, y interface{}, errorParts ...interface{}) { expectThat(x, oglematchers.LessOrEqual(y), 1, errorParts) } // ExpectGt(x, y) is equivalent to ExpectThat(x, oglematchers.GreaterThan(y)). func ExpectGt(x, y interface{}, errorParts ...interface{}) { expectThat(x, oglematchers.GreaterThan(y), 1, errorParts) } // ExpectGe(x, y) is equivalent to // ExpectThat(x, oglematchers.GreaterOrEqual(y)). func ExpectGe(x, y interface{}, errorParts ...interface{}) { expectThat(x, oglematchers.GreaterOrEqual(y), 1, errorParts) } // ExpectTrue(b) is equivalent to ExpectThat(b, oglematchers.Equals(true)). func ExpectTrue(b interface{}, errorParts ...interface{}) { expectThat(b, oglematchers.Equals(true), 1, errorParts) } // ExpectFalse(b) is equivalent to ExpectThat(b, oglematchers.Equals(false)). func ExpectFalse(b interface{}, errorParts ...interface{}) { expectThat(b, oglematchers.Equals(false), 1, errorParts) } mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/ogletest/expect_call.go000066400000000000000000000037471321131462300337130ustar00rootroot00000000000000// Copyright 2012 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 ogletest import ( "github.com/smartystreets/assertions/internal/oglemock" "runtime" ) // ExpectCall expresses an expectation that the method of the given name // should be called on the supplied mock object. It returns a function that // should be called with the expected arguments, matchers for the arguments, // or a mix of both. // // For example: // // mockWriter := [...] // ogletest.ExpectCall(mockWriter, "Write")(oglematchers.ElementsAre(0x1)) // .WillOnce(oglemock.Return(1, nil)) // // This is a shortcut for calling i.MockController.ExpectCall, where i is the // TestInfo struct for the currently-running test. Unlike that direct approach, // this function automatically sets the correct file name and line number for // the expectation. func ExpectCall(o oglemock.MockObject, method string) oglemock.PartialExpecation { // Get information about the call site. _, file, lineNumber, ok := runtime.Caller(1) if !ok { panic("ExpectCall: runtime.Caller") } // Grab the current test info. info := currentlyRunningTest if info == nil { panic("ExpectCall: no test info.") } // Grab the mock controller. controller := currentlyRunningTest.MockController if controller == nil { panic("ExpectCall: no mock controller.") } // Report the expectation. return controller.ExpectCall(o, method, file, lineNumber) } mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/ogletest/expect_that.go000066400000000000000000000053141321131462300337300ustar00rootroot00000000000000// Copyright 2011 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 ogletest import ( "fmt" "path" "reflect" "runtime" "github.com/smartystreets/assertions/internal/oglematchers" ) // ExpectThat confirms that the supplied matcher matches the value x, adding a // failure record to the currently running test if it does not. If additional // parameters are supplied, the first will be used as a format string for the // later ones, and the user-supplied error message will be added to the test // output in the event of a failure. // // For example: // // ExpectThat(userName, Equals("jacobsa")) // ExpectThat(users[i], Equals("jacobsa"), "while processing user %d", i) // func ExpectThat( x interface{}, m oglematchers.Matcher, errorParts ...interface{}) { expectThat(x, m, 1, errorParts) } // The generalized form of ExpectThat. depth is the distance on the stack // between the caller's frame and the user's frame. Returns passed iff the // match succeeded. func expectThat( x interface{}, m oglematchers.Matcher, depth int, errorParts []interface{}) (passed bool) { // Check whether the value matches. If it does, we are finished. matcherErr := m.Matches(x) if matcherErr == nil { passed = true return } var r FailureRecord // Get information about the call site. var ok bool if _, r.FileName, r.LineNumber, ok = runtime.Caller(depth + 1); !ok { panic("expectThat: runtime.Caller") } r.FileName = path.Base(r.FileName) // Create an appropriate failure message. Make sure that the expected and // actual values align properly. relativeClause := "" if matcherErr.Error() != "" { relativeClause = fmt.Sprintf(", %s", matcherErr.Error()) } r.Error = fmt.Sprintf( "Expected: %s\nActual: %v%s", m.Description(), x, relativeClause) // Add the user error, if any. if len(errorParts) != 0 { v := reflect.ValueOf(errorParts[0]) if v.Kind() != reflect.String { panic(fmt.Sprintf("ExpectThat: invalid format string type %v", v.Kind())) } r.Error = fmt.Sprintf( "%s\n%s", r.Error, fmt.Sprintf(v.String(), errorParts[1:]...)) } // Report the failure. AddFailureRecord(r) return } expect_that_test.go000066400000000000000000000101501321131462300347020ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/ogletest// Copyright 2011 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 ogletest import ( "errors" "testing" . "github.com/smartystreets/assertions/internal/oglematchers" ) //////////////////////////////////////////////////////////////////////// // Helpers //////////////////////////////////////////////////////////////////////// // Set up a new test state with empty fields. func setUpCurrentTest() { currentlyRunningTest = newTestInfo() } type fakeExpectThatMatcher struct { desc string err error } func (m *fakeExpectThatMatcher) Matches(c interface{}) error { return m.err } func (m *fakeExpectThatMatcher) Description() string { return m.desc } func assertEqInt(t *testing.T, e, c int) { if e != c { t.Fatalf("Expected %d, got %d", e, c) } } func expectEqInt(t *testing.T, e, c int) { if e != c { t.Errorf("Expected %v, got %v", e, c) } } func expectEqStr(t *testing.T, e, c string) { if e != c { t.Errorf("Expected %s, got %s", e, c) } } //////////////////////////////////////////////////////////////////////// // Tests //////////////////////////////////////////////////////////////////////// func TestNoCurrentTest(t *testing.T) { panicked := false defer func() { if !panicked { t.Errorf("Expected panic; got none.") } }() defer func() { if r := recover(); r != nil { panicked = true } }() currentlyRunningTest = nil ExpectThat(17, Equals(19)) } func TestNoFailure(t *testing.T) { setUpCurrentTest() matcher := &fakeExpectThatMatcher{"", nil} ExpectThat(17, matcher) assertEqInt(t, 0, len(currentlyRunningTest.failureRecords)) } func TestInvalidFormatString(t *testing.T) { panicked := false defer func() { if !panicked { t.Errorf("Expected panic; got none.") } }() defer func() { if r := recover(); r != nil { panicked = true } }() setUpCurrentTest() matcher := &fakeExpectThatMatcher{"", errors.New("")} ExpectThat(17, matcher, 19, "blah") } func TestNoMatchWithoutErrorText(t *testing.T) { setUpCurrentTest() matcher := &fakeExpectThatMatcher{"taco", errors.New("")} ExpectThat(17, matcher) assertEqInt(t, 1, len(currentlyRunningTest.failureRecords)) record := currentlyRunningTest.failureRecords[0] expectEqStr(t, "expect_that_test.go", record.FileName) expectEqInt(t, 119, record.LineNumber) expectEqStr(t, "Expected: taco\nActual: 17", record.Error) } func TestNoMatchWithErrorTExt(t *testing.T) { setUpCurrentTest() matcher := &fakeExpectThatMatcher{"taco", errors.New("which is foo")} ExpectThat(17, matcher) assertEqInt(t, 1, len(currentlyRunningTest.failureRecords)) record := currentlyRunningTest.failureRecords[0] expectEqStr( t, "Expected: taco\nActual: 17, which is foo", record.Error) } func TestFailureWithUserMessage(t *testing.T) { setUpCurrentTest() matcher := &fakeExpectThatMatcher{"taco", errors.New("")} ExpectThat(17, matcher, "Asd: %d %s", 19, "taco") assertEqInt(t, 1, len(currentlyRunningTest.failureRecords)) record := currentlyRunningTest.failureRecords[0] expectEqStr(t, "Expected: taco\nActual: 17\nAsd: 19 taco", record.Error) } func TestAdditionalFailure(t *testing.T) { setUpCurrentTest() matcher := &fakeExpectThatMatcher{"", errors.New("")} // Fail twice. ExpectThat(17, matcher, "taco") ExpectThat(19, matcher, "burrito") assertEqInt(t, 2, len(currentlyRunningTest.failureRecords)) record1 := currentlyRunningTest.failureRecords[0] record2 := currentlyRunningTest.failureRecords[1] expectEqStr(t, "Expected: \nActual: 17\ntaco", record1.Error) expectEqStr(t, "Expected: \nActual: 19\nburrito", record2.Error) } mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/ogletest/failure.go000066400000000000000000000054301321131462300330460ustar00rootroot00000000000000// Copyright 2015 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 ogletest import ( "fmt" "path" "runtime" ) // FailureRecord represents a single failed expectation or assertion for a // test. Most users don't want to interact with these directly; they are // generated implicitly using ExpectThat, AssertThat, ExpectLt, etc. type FailureRecord struct { // The file name within which the expectation failed, e.g. "foo_test.go". FileName string // The line number at which the expectation failed. LineNumber int // The error associated with the file:line pair above. For example, the // following expectation: // // ExpectEq(17, "taco")" // // May cause this error: // // Expected: 17 // Actual: "taco", which is not numeric // Error string } // Record a failure for the currently running test (and continue running it). // Most users will want to use ExpectThat, ExpectEq, etc. instead of this // function. Those that do want to report arbitrary errors will probably be // satisfied with AddFailure, which is easier to use. func AddFailureRecord(r FailureRecord) { currentlyRunningTest.mu.Lock() defer currentlyRunningTest.mu.Unlock() currentlyRunningTest.failureRecords = append( currentlyRunningTest.failureRecords, r) } // Call AddFailureRecord with a record whose file name and line number come // from the caller of this function, and whose error string is created by // calling fmt.Sprintf using the arguments to this function. func AddFailure(format string, a ...interface{}) { r := FailureRecord{ Error: fmt.Sprintf(format, a...), } // Get information about the call site. var ok bool if _, r.FileName, r.LineNumber, ok = runtime.Caller(1); !ok { panic("Can't find caller") } r.FileName = path.Base(r.FileName) AddFailureRecord(r) } // A sentinel type that is used in a conspiracy between AbortTest and runTests. // If runTests sees an abortError as the value given to a panic() call, it will // avoid printing the panic error. type abortError struct { } // Immediately stop executing the running test, causing it to fail with the // failures previously recorded. Behavior is undefined if no failures have been // recorded. func AbortTest() { panic(abortError{}) } integration_test.go000066400000000000000000000201511321131462300347170ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/ogletest// Copyright 2011 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 ogletest_test import ( "errors" "flag" "fmt" "go/build" "io/ioutil" "os" "os/exec" "path" "regexp" "strings" "syscall" "testing" ) const ogletestPkg = "github.com/smartystreets/assertions/internal/ogletest" var dumpNew = flag.Bool("dump_new", false, "Dump new golden files.") var objDir string //////////////////////////////////////////////////////////////////////// // Helpers //////////////////////////////////////////////////////////////////////// // Install the possibly locally-modified copy of ogletest, so that these // integration tests run using the package currently being worked on by the // programmer. Also install other dependencies needed by the test cases, so // that `go test` complaining about non-up-to-date packages doesn't make it // into the golden files. func installLocalPackages() error { cmd := exec.Command( "go", "install", ogletestPkg, "github.com/smartystreets/assertions/internal/oglemock", "github.com/smartystreets/assertions/internal/ogletest/test_cases/mock_image") output, err := cmd.CombinedOutput() if err != nil { return errors.New(fmt.Sprintf("%v:\n%s", err, output)) } return nil } // getCaseNames looks for integration test cases as files in the test_cases // directory. func getCaseNames() ([]string, error) { // Open the test cases directory. dir, err := os.Open("test_cases") if err != nil { return nil, errors.New(fmt.Sprintf("Opening dir: %v", err)) } // Get a list of the names in the directory. names, err := dir.Readdirnames(0) if err != nil { return nil, errors.New(fmt.Sprintf("Readdirnames: %v", err)) } // Filter the names. result := make([]string, len(names)) resultLen := 0 for _, name := range names { // Skip golden files and hidden files. if strings.HasPrefix(name, "golden.") || strings.HasPrefix(name, ".") { continue } // Check for the right format. if !strings.HasSuffix(name, ".test.go") { continue } // Store the name minus the extension. result[resultLen] = name[:len(name)-8] resultLen++ } return result[:resultLen], nil } func writeContentsToFileOrDie(contents []byte, path string) { if err := ioutil.WriteFile(path, contents, 0600); err != nil { panic("ioutil.WriteFile: " + err.Error()) } } func readFileOrDie(path string) []byte { contents, err := ioutil.ReadFile(path) if err != nil { panic("ioutil.ReadFile: " + err.Error()) } return contents } // cleanOutput transforms the supplied output so that it no longer contains // information that changes from run to run, making the golden tests less // flaky. func cleanOutput(o []byte, testPkg string) []byte { // Replace references to the last component of the test package name, which // contains a unique number. o = []byte(strings.Replace(string(o), path.Base(testPkg), "somepkg", -1)) // Replace things that look like line numbers and process counters in stack // traces. stackFrameRe := regexp.MustCompile(`\t\S+\.(c|go):\d+`) o = stackFrameRe.ReplaceAll(o, []byte("\tsome_file.txt:0")) // Replace full paths in failure messages with fake paths. pathRe := regexp.MustCompile(`/\S+/(\w+\.(?:go|s):\d+)`) o = pathRe.ReplaceAll(o, []byte("/some/path/$1")) // Replace unstable timings in gotest fail messages. timingRe1 := regexp.MustCompile(`--- FAIL: .* \(\d\.\d{2}s\)`) o = timingRe1.ReplaceAll(o, []byte("--- FAIL: TestSomething (1.23s)")) timingRe2 := regexp.MustCompile(`FAIL.*somepkg\s*\d\.\d{2,}s`) o = timingRe2.ReplaceAll(o, []byte("FAIL somepkg 1.234s")) timingRe3 := regexp.MustCompile(`ok.*somepkg\s*\d\.\d{2,}s`) o = timingRe3.ReplaceAll(o, []byte("ok somepkg 1.234s")) timingRe4 := regexp.MustCompile(`SlowTest \([0-9.]+ms\)`) o = timingRe4.ReplaceAll(o, []byte("SlowTest (1234ms)")) return o } // Create a temporary package directory somewhere that 'go test' can find, and // return the directory and package name. func createTempPackageDir(caseName string) (dir, pkg string) { // Figure out where the local source code for ogletest is. buildPkg, err := build.Import(ogletestPkg, "", build.FindOnly) if err != nil { panic("Finding ogletest tree: " + err.Error()) } // Create a temporary directory underneath this. ogletestPkgDir := buildPkg.Dir prefix := fmt.Sprintf("tmp-%s-", caseName) dir, err = ioutil.TempDir(ogletestPkgDir, prefix) if err != nil { panic("ioutil.TempDir: " + err.Error()) } pkg = path.Join("github.com/smartystreets/assertions/internal/ogletest", dir[len(ogletestPkgDir):]) return } // runTestCase runs the case with the supplied name (e.g. "passing"), and // returns its output and exit code. func runTestCase(name string) ([]byte, int, error) { // Create a temporary directory for the test files. testDir, testPkg := createTempPackageDir(name) defer os.RemoveAll(testDir) // Create the test source file. sourceFile := name + ".test.go" testContents := readFileOrDie(path.Join("test_cases", sourceFile)) writeContentsToFileOrDie(testContents, path.Join(testDir, name+"_test.go")) // Invoke 'go test'. Use the package directory as working dir instead of // giving the package name as an argument so that 'go test' prints passing // test output. Special case: pass a test filter to the filtered case. cmd := exec.Command("go", "test") if name == "filtered" { cmd.Args = append(cmd.Args, "--ogletest.run=Test(Bar|Baz)") } cmd.Dir = testDir output, err := cmd.CombinedOutput() // Clean up the process's output. output = cleanOutput(output, testPkg) // Did the process exist with zero code? if err == nil { return output, 0, nil } // Make sure the process actually exited. exitError, ok := err.(*exec.ExitError) if !ok || !exitError.Exited() { return nil, 0, errors.New("exec.Command.Output: " + err.Error()) } return output, exitError.Sys().(syscall.WaitStatus).ExitStatus(), nil } // checkGolden file checks the supplied actual output for the named test case // against the golden file for that case. If requested by the user, it rewrites // the golden file on failure. func checkAgainstGoldenFile(caseName string, output []byte) bool { goldenFile := path.Join("test_cases", "golden."+caseName+"_test") goldenContents := readFileOrDie(goldenFile) result := string(output) == string(goldenContents) if !result && *dumpNew { writeContentsToFileOrDie(output, goldenFile) } return result } //////////////////////////////////////////////////////////////////////// // Tests //////////////////////////////////////////////////////////////////////// func TestGoldenFiles(t *testing.T) { // Ensure the local package is installed. This will prevent the test cases // from using the installed version, which may be out of date. err := installLocalPackages() if err != nil { t.Fatalf("Error installing local ogletest: %v", err) } // We expect there to be at least one case. caseNames, err := getCaseNames() if err != nil || len(caseNames) == 0 { t.Fatalf("Error getting cases: %v", err) } // Run each test case. for _, caseName := range caseNames { // Run the test case. output, exitCode, err := runTestCase(caseName) if err != nil { t.Fatalf("Running test case %s: %v", caseName, err) } // Check the status code. We assume all test cases fail except for the // passing one. shouldPass := (caseName == "passing" || caseName == "no_cases") didPass := exitCode == 0 if shouldPass != didPass { t.Errorf("Bad exit code for test case %s: %d", caseName, exitCode) } // Check the output against the golden file. if !checkAgainstGoldenFile(caseName, output) { t.Errorf("Output for test case %s doesn't match golden file.", caseName) } } } mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/ogletest/register.go000066400000000000000000000052551321131462300332500ustar00rootroot00000000000000// Copyright 2015 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 ogletest // The input to ogletest.Register. Most users will want to use // ogletest.RegisterTestSuite. // // A test suite is the basic unit of registration in ogletest. It consists of // zero or more named test functions which will be run in sequence, along with // optional setup and tear-down functions. type TestSuite struct { // The name of the overall suite, e.g. "MyPackageTest". Name string // If non-nil, a function that will be run exactly once, before any of the // test functions are run. SetUp func() // The test functions comprising this suite. TestFunctions []TestFunction // If non-nil, a function that will be run exactly once, after all of the // test functions have run. TearDown func() } type TestFunction struct { // The name of this test function, relative to the suite in which it resides. // If the name is "TweaksFrobnicator", then the function might be presented // in the ogletest UI as "FooTest.TweaksFrobnicator". Name string // If non-nil, a function that is run before Run, passed a pointer to a // struct containing information about the test run. SetUp func(*TestInfo) // The function to invoke for the test body. Must be non-nil. Will not be run // if SetUp panics. Run func() // If non-nil, a function that is run after Run. TearDown func() } // Register a test suite for execution by RunTests. // // This is the most general registration mechanism. Most users will want // RegisterTestSuite, which is a wrapper around this function that requires // less boilerplate. // // Panics on invalid input. func Register(suite TestSuite) { // Make sure the suite is legal. if suite.Name == "" { panic("Test suites must have names.") } for _, tf := range suite.TestFunctions { if tf.Name == "" { panic("Test functions must have names.") } if tf.Run == nil { panic("Test functions must have non-nil run fields.") } } // Save the suite for later. registeredSuites = append(registeredSuites, suite) } // The list of test suites previously registered. var registeredSuites []TestSuite register_test_suite.go000066400000000000000000000140661321131462300354410ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/ogletest// Copyright 2011 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 ogletest import ( "fmt" "reflect" "github.com/smartystreets/assertions/internal/ogletest/srcutil" ) // Test suites that implement this interface have special meaning to // RegisterTestSuite. type SetUpTestSuiteInterface interface { // This method will be called exactly once, before the first test method is // run. The receiver of this method will be a zero value of the test suite // type, and is not shared with any other methods. Use this method to set up // any necessary global state shared by all of the test methods. SetUpTestSuite() } // Test suites that implement this interface have special meaning to // RegisterTestSuite. type TearDownTestSuiteInterface interface { // This method will be called exactly once, after the last test method is // run. The receiver of this method will be a zero value of the test suite // type, and is not shared with any other methods. Use this method to clean // up after any necessary global state shared by all of the test methods. TearDownTestSuite() } // Test suites that implement this interface have special meaning to // Register. type SetUpInterface interface { // This method is called before each test method is invoked, with the same // receiver as that test method. At the time this method is invoked, the // receiver is a zero value for the test suite type. Use this method for // common setup code that works on data not shared across tests. SetUp(*TestInfo) } // Test suites that implement this interface have special meaning to // Register. type TearDownInterface interface { // This method is called after each test method is invoked, with the same // receiver as that test method. Use this method for common cleanup code that // works on data not shared across tests. TearDown() } // RegisterTestSuite tells ogletest about a test suite containing tests that it // should run. Any exported method on the type pointed to by the supplied // prototype value will be treated as test methods, with the exception of the // methods defined by the following interfaces, which when present are treated // as described in the documentation for those interfaces: // // * SetUpTestSuiteInterface // * SetUpInterface // * TearDownInterface // * TearDownTestSuiteInterface // // Each test method is invoked on a different receiver, which is initially a // zero value of the test suite type. // // Example: // // // Some value that is needed by the tests but is expensive to compute. // var someExpensiveThing uint // // type FooTest struct { // // Path to a temporary file used by the tests. Each test gets a // // different temporary file. // tempFile string // } // func init() { ogletest.RegisterTestSuite(&FooTest{}) } // // func (t *FooTest) SetUpTestSuite() { // someExpensiveThing = ComputeSomeExpensiveThing() // } // // func (t *FooTest) SetUp(ti *ogletest.TestInfo) { // t.tempFile = CreateTempFile() // } // // func (t *FooTest) TearDown() { // DeleteTempFile(t.tempFile) // } // // func (t *FooTest) FrobinicatorIsSuccessfullyTweaked() { // res := DoSomethingWithExpensiveThing(someExpensiveThing, t.tempFile) // ExpectThat(res, Equals(true)) // } // func RegisterTestSuite(p interface{}) { if p == nil { panic("RegisterTestSuite called with nil suite.") } val := reflect.ValueOf(p) typ := val.Type() var zeroInstance reflect.Value // We will transform to a TestSuite struct. suite := TestSuite{} suite.Name = typ.Elem().Name() zeroInstance = reflect.New(typ.Elem()) if i, ok := zeroInstance.Interface().(SetUpTestSuiteInterface); ok { suite.SetUp = func() { i.SetUpTestSuite() } } zeroInstance = reflect.New(typ.Elem()) if i, ok := zeroInstance.Interface().(TearDownTestSuiteInterface); ok { suite.TearDown = func() { i.TearDownTestSuite() } } // Transform a list of test methods for the suite, filtering them to just the // ones that we don't need to skip. for _, method := range filterMethods(suite.Name, srcutil.GetMethodsInSourceOrder(typ)) { var tf TestFunction tf.Name = method.Name // Create an instance to be operated on by all of the TestFunction's // internal functions. instance := reflect.New(typ.Elem()) // Bind the functions to the instance. if i, ok := instance.Interface().(SetUpInterface); ok { tf.SetUp = func(ti *TestInfo) { i.SetUp(ti) } } methodCopy := method tf.Run = func() { runTestMethod(instance, methodCopy) } if i, ok := instance.Interface().(TearDownInterface); ok { tf.TearDown = func() { i.TearDown() } } // Save the TestFunction. suite.TestFunctions = append(suite.TestFunctions, tf) } // Register the suite. Register(suite) } func runTestMethod(suite reflect.Value, method reflect.Method) { if method.Func.Type().NumIn() != 1 { panic(fmt.Sprintf( "%s: expected 1 args, actually %d.", method.Name, method.Func.Type().NumIn())) } method.Func.Call([]reflect.Value{suite}) } func filterMethods(suiteName string, in []reflect.Method) (out []reflect.Method) { for _, m := range in { // Skip set up, tear down, and unexported methods. if isSpecialMethod(m.Name) || !isExportedMethod(m.Name) { continue } out = append(out, m) } return } func isSpecialMethod(name string) bool { return (name == "SetUpTestSuite") || (name == "TearDownTestSuite") || (name == "SetUp") || (name == "TearDown") } func isExportedMethod(name string) bool { return len(name) > 0 && name[0] >= 'A' && name[0] <= 'Z' } mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/ogletest/run_tests.go000066400000000000000000000217511321131462300334510ustar00rootroot00000000000000// Copyright 2011 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 ogletest import ( "bytes" "flag" "fmt" "os" "path" "regexp" "runtime" "sync" "sync/atomic" "testing" "time" "github.com/smartystreets/assertions/internal/reqtrace" ) var fTestFilter = flag.String( "ogletest.run", "", "Regexp for matching tests to run.") var fStopEarly = flag.Bool( "ogletest.stop_early", false, "If true, stop after the first failure.") // runTestsOnce protects RunTests from executing multiple times. var runTestsOnce sync.Once func isAbortError(x interface{}) bool { _, ok := x.(abortError) return ok } // Run a single test function, returning a slice of failure records. func runTestFunction(tf TestFunction) (failures []FailureRecord) { // Set up a clean slate for this test. Make sure to reset it after everything // below is finished, so we don't accidentally use it elsewhere. currentlyRunningTest = newTestInfo() defer func() { currentlyRunningTest = nil }() ti := currentlyRunningTest // Start a trace. var reportOutcome reqtrace.ReportFunc ti.Ctx, reportOutcome = reqtrace.Trace(ti.Ctx, tf.Name) // Run the SetUp function, if any, paying attention to whether it panics. setUpPanicked := false if tf.SetUp != nil { setUpPanicked = runWithProtection(func() { tf.SetUp(ti) }) } // Run the test function itself, but only if the SetUp function didn't panic. // (This includes AssertThat errors.) if !setUpPanicked { runWithProtection(tf.Run) } // Run the TearDown function, if any. if tf.TearDown != nil { runWithProtection(tf.TearDown) } // Tell the mock controller for the tests to report any errors it's sitting // on. ti.MockController.Finish() // Report the outcome to reqtrace. if len(ti.failureRecords) == 0 { reportOutcome(nil) } else { reportOutcome(fmt.Errorf("%v failure records", len(ti.failureRecords))) } return ti.failureRecords } // Run everything registered with Register (including via the wrapper // RegisterTestSuite). // // Failures are communicated to the supplied testing.T object. This is the // bridge between ogletest and the testing package (and `go test`); you should // ensure that it's called at least once by creating a test function compatible // with `go test` and calling it there. // // For example: // // import ( // "github.com/smartystreets/assertions/internal/ogletest" // "testing" // ) // // func TestOgletest(t *testing.T) { // ogletest.RunTests(t) // } // func RunTests(t *testing.T) { runTestsOnce.Do(func() { runTestsInternal(t) }) } // Signalling between RunTests and StopRunningTests. var gStopRunning uint64 // Request that RunTests stop what it's doing. After the currently running test // is finished, including tear-down, the program will exit with an error code. func StopRunningTests() { atomic.StoreUint64(&gStopRunning, 1) } // runTestsInternal does the real work of RunTests, which simply wraps it in a // sync.Once. func runTestsInternal(t *testing.T) { // Process each registered suite. for _, suite := range registeredSuites { // Stop now if we've already seen a failure and we've been told to stop // early. if t.Failed() && *fStopEarly { break } // Print a banner. fmt.Printf("[----------] Running tests from %s\n", suite.Name) // Run the SetUp function, if any. if suite.SetUp != nil { suite.SetUp() } // Run each test function that the user has not told us to skip. stoppedEarly := false for _, tf := range filterTestFunctions(suite) { // Did the user request that we stop running tests? If so, skip the rest // of this suite (and exit after tearing it down). if atomic.LoadUint64(&gStopRunning) != 0 { stoppedEarly = true break } // Print a banner for the start of this test function. fmt.Printf("[ RUN ] %s.%s\n", suite.Name, tf.Name) // Run the test function. startTime := time.Now() failures := runTestFunction(tf) runDuration := time.Since(startTime) // Print any failures, and mark the test as having failed if there are any. for _, record := range failures { t.Fail() fmt.Printf( "%s:%d:\n%s\n\n", record.FileName, record.LineNumber, record.Error) } // Print a banner for the end of the test. bannerMessage := "[ OK ]" if len(failures) != 0 { bannerMessage = "[ FAILED ]" } // Print a summary of the time taken, if long enough. var timeMessage string if runDuration >= 25*time.Millisecond { timeMessage = fmt.Sprintf(" (%s)", runDuration.String()) } fmt.Printf( "%s %s.%s%s\n", bannerMessage, suite.Name, tf.Name, timeMessage) // Stop running tests from this suite if we've been told to stop early // and this test failed. if t.Failed() && *fStopEarly { break } } // Run the suite's TearDown function, if any. if suite.TearDown != nil { suite.TearDown() } // Were we told to exit early? if stoppedEarly { fmt.Println("Exiting early due to user request.") os.Exit(1) } fmt.Printf("[----------] Finished with tests from %s\n", suite.Name) } } // Return true iff the supplied program counter appears to lie within panic(). func isPanic(pc uintptr) bool { f := runtime.FuncForPC(pc) if f == nil { return false } return f.Name() == "runtime.gopanic" || f.Name() == "runtime.sigpanic" } // Find the deepest stack frame containing something that appears to be a // panic. Return the 'skip' value that a caller to this function would need // to supply to runtime.Caller for that frame, or a negative number if not found. func findPanic() int { localSkip := -1 for i := 0; ; i++ { // Stop if we've passed the base of the stack. pc, _, _, ok := runtime.Caller(i) if !ok { break } // Is this a panic? if isPanic(pc) { localSkip = i } } return localSkip - 1 } // Attempt to find the file base name and line number for the ultimate source // of a panic, on the panicking stack. Return a human-readable sentinel if // unsuccessful. func findPanicFileLine() (string, int) { panicSkip := findPanic() if panicSkip < 0 { return "(unknown)", 0 } // Find the trigger of the panic. _, file, line, ok := runtime.Caller(panicSkip + 1) if !ok { return "(unknown)", 0 } return path.Base(file), line } // Run the supplied function, catching panics (including AssertThat errors) and // reporting them to the currently-running test as appropriate. Return true iff // the function panicked. func runWithProtection(f func()) (panicked bool) { defer func() { // If the test didn't panic, we're done. r := recover() if r == nil { return } panicked = true // We modify the currently running test below. currentlyRunningTest.mu.Lock() defer currentlyRunningTest.mu.Unlock() // If the function panicked (and the panic was not due to an AssertThat // failure), add a failure for the panic. if !isAbortError(r) { var panicRecord FailureRecord panicRecord.FileName, panicRecord.LineNumber = findPanicFileLine() panicRecord.Error = fmt.Sprintf( "panic: %v\n\n%s", r, formatPanicStack()) currentlyRunningTest.failureRecords = append( currentlyRunningTest.failureRecords, panicRecord) } }() f() return } func formatPanicStack() string { buf := new(bytes.Buffer) // Find the panic. If successful, we'll skip to below it. Otherwise, we'll // format everything. var initialSkip int if panicSkip := findPanic(); panicSkip >= 0 { initialSkip = panicSkip + 1 } for i := initialSkip; ; i++ { pc, file, line, ok := runtime.Caller(i) if !ok { break } // Choose a function name to display. funcName := "(unknown)" if f := runtime.FuncForPC(pc); f != nil { funcName = f.Name() } // Stop if we've gotten as far as the test runner code. if funcName == "github.com/smartystreets/assertions/internal/ogletest.runTestMethod" || funcName == "github.com/smartystreets/assertions/internal/ogletest.runWithProtection" { break } // Add an entry for this frame. fmt.Fprintf(buf, "%s\n\t%s:%d\n", funcName, file, line) } return buf.String() } // Filter test functions according to the user-supplied filter flag. func filterTestFunctions(suite TestSuite) (out []TestFunction) { re, err := regexp.Compile(*fTestFilter) if err != nil { panic("Invalid value for --ogletest.run: " + err.Error()) } for _, tf := range suite.TestFunctions { fullName := fmt.Sprintf("%s.%s", suite.Name, tf.Name) if !re.MatchString(fullName) { continue } out = append(out, tf) } return } mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/ogletest/srcutil/000077500000000000000000000000001321131462300325535ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/ogletest/srcutil/docs.go000066400000000000000000000002421321131462300340300ustar00rootroot00000000000000// Copyright 2015 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // Functions for working with source code. package srcutil methods.go000066400000000000000000000031641321131462300344720ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/ogletest/srcutil// Copyright 2012 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 srcutil import ( "fmt" "reflect" "runtime" "sort" ) func getLine(m reflect.Method) int { pc := m.Func.Pointer() f := runtime.FuncForPC(pc) if f == nil { panic(fmt.Sprintf("Couldn't get runtime func for method (pc=%d): %v", pc, m)) } _, line := f.FileLine(pc) return line } type sortableMethodSet []reflect.Method func (s sortableMethodSet) Len() int { return len(s) } func (s sortableMethodSet) Less(i, j int) bool { return getLine(s[i]) < getLine(s[j]) } func (s sortableMethodSet) Swap(i, j int) { s[i], s[j] = s[j], s[i] } // Given a type t, return all of the methods of t sorted such that source file // order is preserved. Order across files is undefined. Order within lines is // undefined. func GetMethodsInSourceOrder(t reflect.Type) []reflect.Method { // Build the list of methods. methods := sortableMethodSet{} for i := 0; i < t.NumMethod(); i++ { methods = append(methods, t.Method(i)) } // Sort it. sort.Sort(methods) return methods } methods_test.go000066400000000000000000000052211321131462300355250ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/ogletest/srcutil// Copyright 2012 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 srcutil_test import ( "fmt" "reflect" "testing" . "github.com/smartystreets/assertions/internal/oglematchers" . "github.com/smartystreets/assertions/internal/ogletest" "github.com/smartystreets/assertions/internal/ogletest/srcutil" ) func TestRegisterMethodsTest(t *testing.T) { RunTests(t) } //////////////////////////////////////////////////////////////////////// // Helpers //////////////////////////////////////////////////////////////////////// type MethodsTest struct { } func init() { RegisterTestSuite(&MethodsTest{}) } type OneMethodType int func (x OneMethodType) Foo() {} type MultipleMethodsType int func (x MultipleMethodsType) Foo() {} func (x MultipleMethodsType) Bar() {} func (x MultipleMethodsType) Baz() {} type methodNameMatcher struct { expected string } func (m *methodNameMatcher) Description() string { return fmt.Sprintf("method named %s", m.expected) } func (m *methodNameMatcher) Matches(x interface{}) error { method, ok := x.(reflect.Method) if !ok { panic("Invalid argument.") } if method.Name != m.expected { return fmt.Errorf("whose name is %s", method.Name) } return nil } func NameIs(name string) Matcher { return &methodNameMatcher{name} } //////////////////////////////////////////////////////////////////////// // Tests //////////////////////////////////////////////////////////////////////// func (t *MethodsTest) NoMethods() { type foo int methods := srcutil.GetMethodsInSourceOrder(reflect.TypeOf(foo(17))) ExpectThat(methods, ElementsAre()) } func (t *MethodsTest) OneMethod() { methods := srcutil.GetMethodsInSourceOrder(reflect.TypeOf(OneMethodType(17))) ExpectThat( methods, ElementsAre( NameIs("Foo"), )) } func (t *MethodsTest) MultipleMethods() { methods := srcutil.GetMethodsInSourceOrder(reflect.TypeOf(MultipleMethodsType(17))) ExpectThat( methods, ElementsAre( NameIs("Foo"), NameIs("Bar"), NameIs("Baz"), )) ExpectEq("Foo", methods[0].Name) ExpectEq("Bar", methods[1].Name) ExpectEq("Baz", methods[2].Name) } mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/ogletest/test_cases/000077500000000000000000000000001321131462300332235ustar00rootroot00000000000000failing.test.go000066400000000000000000000136571321131462300360760ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/ogletest/test_cases// Copyright 2011 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers_test import ( "fmt" "testing" . "github.com/smartystreets/assertions/internal/oglematchers" . "github.com/smartystreets/assertions/internal/ogletest" ) func TestFailingTest(t *testing.T) { RunTests(t) } //////////////////////////////////////////////////////////////////////// // Usual failures //////////////////////////////////////////////////////////////////////// type FailingTest struct { } var _ TearDownInterface = &FailingTest{} var _ TearDownTestSuiteInterface = &FailingTest{} func init() { RegisterTestSuite(&FailingTest{}) } func (t *FailingTest) TearDown() { fmt.Println("TearDown running.") } func (t *FailingTest) TearDownTestSuite() { fmt.Println("TearDownTestSuite running.") } func (t *FailingTest) PassingMethod() { } func (t *FailingTest) Equals() { ExpectThat(17, Equals(17.5)) ExpectThat(17, Equals("taco")) } func (t *FailingTest) LessThan() { ExpectThat(18, LessThan(17)) ExpectThat(18, LessThan("taco")) } func (t *FailingTest) HasSubstr() { ExpectThat("taco", HasSubstr("ac")) ExpectThat(17, HasSubstr("ac")) } func (t *FailingTest) ExpectWithUserErrorMessages() { ExpectThat(17, Equals(19), "foo bar: %d", 112) ExpectEq(17, 17.5, "foo bar: %d", 112) ExpectLe(17, 16.9, "foo bar: %d", 112) ExpectLt(17, 16.9, "foo bar: %d", 112) ExpectGe(17, 17.1, "foo bar: %d", 112) ExpectGt(17, "taco", "foo bar: %d", 112) ExpectNe(17, 17.0, "foo bar: %d", 112) ExpectFalse(true, "foo bar: %d", 112) ExpectTrue(false, "foo bar: %d", 112) } func (t *FailingTest) AssertWithUserErrorMessages() { AssertThat(17, Equals(19), "foo bar: %d", 112) } func (t *FailingTest) ExpectationAliases() { ExpectEq(17, 17.5) ExpectEq("taco", 17.5) ExpectLe(17, 16.9) ExpectLt(17, 16.9) ExpectLt(17, "taco") ExpectGe(17, 17.1) ExpectGt(17, 17.1) ExpectGt(17, "taco") ExpectNe(17, 17.0) ExpectNe(17, "taco") ExpectFalse(true) ExpectFalse("taco") ExpectTrue(false) ExpectTrue("taco") } func (t *FailingTest) AssertThatFailure() { AssertThat(17, Equals(19)) panic("Shouldn't get here.") } func (t *FailingTest) AssertEqFailure() { AssertEq(19, 17) panic("Shouldn't get here.") } func (t *FailingTest) AssertNeFailure() { AssertNe(19, 19) panic("Shouldn't get here.") } func (t *FailingTest) AssertLeFailure() { AssertLe(19, 17) panic("Shouldn't get here.") } func (t *FailingTest) AssertLtFailure() { AssertLt(19, 17) panic("Shouldn't get here.") } func (t *FailingTest) AssertGeFailure() { AssertGe(17, 19) panic("Shouldn't get here.") } func (t *FailingTest) AssertGtFailure() { AssertGt(17, 19) panic("Shouldn't get here.") } func (t *FailingTest) AssertTrueFailure() { AssertTrue("taco") panic("Shouldn't get here.") } func (t *FailingTest) AssertFalseFailure() { AssertFalse("taco") panic("Shouldn't get here.") } func (t *FailingTest) AddFailureRecord() { r := FailureRecord{ FileName: "foo.go", LineNumber: 17, Error: "taco\nburrito", } AddFailureRecord(r) } func (t *FailingTest) AddFailure() { AddFailure("taco") AddFailure("burrito: %d", 17) } func (t *FailingTest) AddFailureThenAbortTest() { AddFailure("enchilada") AbortTest() fmt.Println("Shouldn't get here.") } //////////////////////////////////////////////////////////////////////// // Expectation failure during SetUp //////////////////////////////////////////////////////////////////////// type ExpectFailDuringSetUpTest struct { } func init() { RegisterTestSuite(&ExpectFailDuringSetUpTest{}) } func (t *ExpectFailDuringSetUpTest) SetUp(i *TestInfo) { ExpectFalse(true) } func (t *ExpectFailDuringSetUpTest) TearDown() { fmt.Println("TearDown running.") } func (t *ExpectFailDuringSetUpTest) PassingMethod() { fmt.Println("Method running.") } //////////////////////////////////////////////////////////////////////// // Assertion failure during SetUp //////////////////////////////////////////////////////////////////////// type AssertFailDuringSetUpTest struct { } func init() { RegisterTestSuite(&AssertFailDuringSetUpTest{}) } func (t *AssertFailDuringSetUpTest) SetUp(i *TestInfo) { AssertFalse(true) } func (t *AssertFailDuringSetUpTest) TearDown() { fmt.Println("TearDown running.") } func (t *AssertFailDuringSetUpTest) PassingMethod() { fmt.Println("Method running.") } //////////////////////////////////////////////////////////////////////// // Expectation failure during TearDown //////////////////////////////////////////////////////////////////////// type ExpectFailDuringTearDownTest struct { } func init() { RegisterTestSuite(&ExpectFailDuringTearDownTest{}) } func (t *ExpectFailDuringTearDownTest) SetUp(i *TestInfo) { fmt.Println("SetUp running.") } func (t *ExpectFailDuringTearDownTest) TearDown() { ExpectFalse(true) } func (t *ExpectFailDuringTearDownTest) PassingMethod() { fmt.Println("Method running.") } //////////////////////////////////////////////////////////////////////// // Assertion failure during TearDown //////////////////////////////////////////////////////////////////////// type AssertFailDuringTearDownTest struct { } func init() { RegisterTestSuite(&AssertFailDuringTearDownTest{}) } func (t *AssertFailDuringTearDownTest) SetUp(i *TestInfo) { fmt.Println("SetUp running.") } func (t *AssertFailDuringTearDownTest) TearDown() { AssertFalse(true) } func (t *AssertFailDuringTearDownTest) PassingMethod() { fmt.Println("Method running.") } filtered.test.go000066400000000000000000000043061321131462300362520ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/ogletest/test_cases// Copyright 2011 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers_test import ( "fmt" . "github.com/smartystreets/assertions/internal/oglematchers" . "github.com/smartystreets/assertions/internal/ogletest" "testing" ) func TestFiltered(t *testing.T) { RunTests(t) } //////////////////////////////////////////////////////////////////////// // Partially filtered out //////////////////////////////////////////////////////////////////////// type PartiallyFilteredTest struct { } func init() { RegisterTestSuite(&PartiallyFilteredTest{}) } func (t *PartiallyFilteredTest) PassingTestFoo() { ExpectThat(19, Equals(19)) } func (t *PartiallyFilteredTest) PassingTestBar() { ExpectThat(17, Equals(17)) } func (t *PartiallyFilteredTest) PartiallyFilteredTestFoo() { ExpectThat(18, LessThan(17)) } func (t *PartiallyFilteredTest) PartiallyFilteredTestBar() { ExpectThat("taco", HasSubstr("blah")) } func (t *PartiallyFilteredTest) PartiallyFilteredTestBaz() { ExpectThat(18, LessThan(17)) } //////////////////////////////////////////////////////////////////////// // Completely filtered out //////////////////////////////////////////////////////////////////////// type CompletelyFilteredTest struct { } func init() { RegisterTestSuite(&CompletelyFilteredTest{}) } func (t *CompletelyFilteredTest) SetUpTestSuite() { fmt.Println("SetUpTestSuite run!") } func (t *CompletelyFilteredTest) TearDownTestSuite() { fmt.Println("TearDownTestSuite run!") } func (t *PartiallyFilteredTest) SomePassingTest() { ExpectThat(19, Equals(19)) } func (t *PartiallyFilteredTest) SomeFailingTest() { ExpectThat(19, Equals(17)) } golden.failing_test000066400000000000000000000136711321131462300370160ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/ogletest/test_cases[----------] Running tests from FailingTest [ RUN ] FailingTest.PassingMethod TearDown running. [ OK ] FailingTest.PassingMethod [ RUN ] FailingTest.Equals TearDown running. failing_test.go:52: Expected: 17.5 Actual: 17 failing_test.go:53: Expected: taco Actual: 17, which is not a string [ FAILED ] FailingTest.Equals [ RUN ] FailingTest.LessThan TearDown running. failing_test.go:57: Expected: less than 17 Actual: 18 failing_test.go:58: Expected: less than "taco" Actual: 18, which is not comparable [ FAILED ] FailingTest.LessThan [ RUN ] FailingTest.HasSubstr TearDown running. failing_test.go:63: Expected: has substring "ac" Actual: 17, which is not a string [ FAILED ] FailingTest.HasSubstr [ RUN ] FailingTest.ExpectWithUserErrorMessages TearDown running. failing_test.go:67: Expected: 19 Actual: 17 foo bar: 112 failing_test.go:68: Expected: 17 Actual: 17.5 foo bar: 112 failing_test.go:69: Expected: less than or equal to 16.9 Actual: 17 foo bar: 112 failing_test.go:70: Expected: less than 16.9 Actual: 17 foo bar: 112 failing_test.go:71: Expected: greater than or equal to 17.1 Actual: 17 foo bar: 112 failing_test.go:72: Expected: greater than "taco" Actual: 17, which is not comparable foo bar: 112 failing_test.go:73: Expected: not(17) Actual: 17 foo bar: 112 failing_test.go:74: Expected: false Actual: true foo bar: 112 failing_test.go:75: Expected: true Actual: false foo bar: 112 [ FAILED ] FailingTest.ExpectWithUserErrorMessages [ RUN ] FailingTest.AssertWithUserErrorMessages TearDown running. failing_test.go:79: Expected: 19 Actual: 17 foo bar: 112 [ FAILED ] FailingTest.AssertWithUserErrorMessages [ RUN ] FailingTest.ExpectationAliases TearDown running. failing_test.go:83: Expected: 17 Actual: 17.5 failing_test.go:84: Expected: taco Actual: 17.5, which is not a string failing_test.go:86: Expected: less than or equal to 16.9 Actual: 17 failing_test.go:87: Expected: less than 16.9 Actual: 17 failing_test.go:88: Expected: less than "taco" Actual: 17, which is not comparable failing_test.go:90: Expected: greater than or equal to 17.1 Actual: 17 failing_test.go:91: Expected: greater than 17.1 Actual: 17 failing_test.go:92: Expected: greater than "taco" Actual: 17, which is not comparable failing_test.go:94: Expected: not(17) Actual: 17 failing_test.go:95: Expected: not(17) Actual: taco, which is not numeric failing_test.go:97: Expected: false Actual: true failing_test.go:98: Expected: false Actual: taco, which is not a bool failing_test.go:100: Expected: true Actual: false failing_test.go:101: Expected: true Actual: taco, which is not a bool [ FAILED ] FailingTest.ExpectationAliases [ RUN ] FailingTest.AssertThatFailure TearDown running. failing_test.go:105: Expected: 19 Actual: 17 [ FAILED ] FailingTest.AssertThatFailure [ RUN ] FailingTest.AssertEqFailure TearDown running. failing_test.go:110: Expected: 19 Actual: 17 [ FAILED ] FailingTest.AssertEqFailure [ RUN ] FailingTest.AssertNeFailure TearDown running. failing_test.go:115: Expected: not(19) Actual: 19 [ FAILED ] FailingTest.AssertNeFailure [ RUN ] FailingTest.AssertLeFailure TearDown running. failing_test.go:120: Expected: less than or equal to 17 Actual: 19 [ FAILED ] FailingTest.AssertLeFailure [ RUN ] FailingTest.AssertLtFailure TearDown running. failing_test.go:125: Expected: less than 17 Actual: 19 [ FAILED ] FailingTest.AssertLtFailure [ RUN ] FailingTest.AssertGeFailure TearDown running. failing_test.go:130: Expected: greater than or equal to 19 Actual: 17 [ FAILED ] FailingTest.AssertGeFailure [ RUN ] FailingTest.AssertGtFailure TearDown running. failing_test.go:135: Expected: greater than 19 Actual: 17 [ FAILED ] FailingTest.AssertGtFailure [ RUN ] FailingTest.AssertTrueFailure TearDown running. failing_test.go:140: Expected: true Actual: taco, which is not a bool [ FAILED ] FailingTest.AssertTrueFailure [ RUN ] FailingTest.AssertFalseFailure TearDown running. failing_test.go:145: Expected: false Actual: taco, which is not a bool [ FAILED ] FailingTest.AssertFalseFailure [ RUN ] FailingTest.AddFailureRecord TearDown running. foo.go:17: taco burrito [ FAILED ] FailingTest.AddFailureRecord [ RUN ] FailingTest.AddFailure TearDown running. failing_test.go:160: taco failing_test.go:161: burrito: 17 [ FAILED ] FailingTest.AddFailure [ RUN ] FailingTest.AddFailureThenAbortTest TearDown running. failing_test.go:165: enchilada [ FAILED ] FailingTest.AddFailureThenAbortTest TearDownTestSuite running. [----------] Finished with tests from FailingTest [----------] Running tests from ExpectFailDuringSetUpTest [ RUN ] ExpectFailDuringSetUpTest.PassingMethod Method running. TearDown running. failing_test.go:180: Expected: false Actual: true [ FAILED ] ExpectFailDuringSetUpTest.PassingMethod [----------] Finished with tests from ExpectFailDuringSetUpTest [----------] Running tests from AssertFailDuringSetUpTest [ RUN ] AssertFailDuringSetUpTest.PassingMethod TearDown running. failing_test.go:201: Expected: false Actual: true [ FAILED ] AssertFailDuringSetUpTest.PassingMethod [----------] Finished with tests from AssertFailDuringSetUpTest [----------] Running tests from ExpectFailDuringTearDownTest [ RUN ] ExpectFailDuringTearDownTest.PassingMethod SetUp running. Method running. failing_test.go:226: Expected: false Actual: true [ FAILED ] ExpectFailDuringTearDownTest.PassingMethod [----------] Finished with tests from ExpectFailDuringTearDownTest [----------] Running tests from AssertFailDuringTearDownTest [ RUN ] AssertFailDuringTearDownTest.PassingMethod SetUp running. Method running. failing_test.go:247: Expected: false Actual: true [ FAILED ] AssertFailDuringTearDownTest.PassingMethod [----------] Finished with tests from AssertFailDuringTearDownTest --- FAIL: TestSomething (1.23s) FAIL exit status 1 FAIL somepkg 1.234s golden.filtered_test000066400000000000000000000014521321131462300371750ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/ogletest/test_cases[----------] Running tests from PartiallyFilteredTest [ RUN ] PartiallyFilteredTest.PassingTestBar [ OK ] PartiallyFilteredTest.PassingTestBar [ RUN ] PartiallyFilteredTest.PartiallyFilteredTestBar filtered_test.go:49: Expected: has substring "blah" Actual: taco [ FAILED ] PartiallyFilteredTest.PartiallyFilteredTestBar [ RUN ] PartiallyFilteredTest.PartiallyFilteredTestBaz filtered_test.go:53: Expected: less than 17 Actual: 18 [ FAILED ] PartiallyFilteredTest.PartiallyFilteredTestBaz [----------] Finished with tests from PartiallyFilteredTest [----------] Running tests from CompletelyFilteredTest SetUpTestSuite run! TearDownTestSuite run! [----------] Finished with tests from CompletelyFilteredTest --- FAIL: TestSomething (1.23s) FAIL exit status 1 FAIL somepkg 1.234s golden.mock_test000066400000000000000000000014721321131462300363320ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/ogletest/test_cases[----------] Running tests from MockTest [ RUN ] MockTest.ExpectationSatisfied [ OK ] MockTest.ExpectationSatisfied [ RUN ] MockTest.MockExpectationNotSatisfied /some/path/mock_test.go:56: Unsatisfied expectation; expected At to be called at least 1 times; called 0 times. [ FAILED ] MockTest.MockExpectationNotSatisfied [ RUN ] MockTest.ExpectCallForUnknownMethod /some/path/mock_test.go:61: Unknown method: FooBar [ FAILED ] MockTest.ExpectCallForUnknownMethod [ RUN ] MockTest.UnexpectedCall /some/path/mock_test.go:65: Unexpected call to At with args: [11 23] [ FAILED ] MockTest.UnexpectedCall [ RUN ] MockTest.InvokeFunction [ OK ] MockTest.InvokeFunction [----------] Finished with tests from MockTest --- FAIL: TestSomething (1.23s) FAIL exit status 1 FAIL somepkg 1.234s golden.no_cases_test000066400000000000000000000002401321131462300371630ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/ogletest/test_cases[----------] Running tests from NoCasesTest SetUpTestSuite run! TearDownTestSuite run! [----------] Finished with tests from NoCasesTest PASS ok somepkg 1.234s golden.panicking_test000066400000000000000000000051311321131462300373400ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/ogletest/test_cases[----------] Running tests from PanickingTest [ RUN ] PanickingTest.ExplicitPanic TearDown running. panicking_test.go:47: panic: Panic in ExplicitPanic github.com/smartystreets/assertions/internal/ogletest/somepkg_test.(*PanickingTest).ExplicitPanic some_file.txt:0 runtime.call16 /some/path/asm_amd64.s:401 reflect.Value.call some_file.txt:0 reflect.Value.Call some_file.txt:0 [ FAILED ] PanickingTest.ExplicitPanic [ RUN ] PanickingTest.ExplicitPanicInHelperFunction TearDown running. panicking_test.go:34: panic: Panic in someFuncThatPanics github.com/smartystreets/assertions/internal/ogletest/somepkg_test.someFuncThatPanics some_file.txt:0 github.com/smartystreets/assertions/internal/ogletest/somepkg_test.(*PanickingTest).ExplicitPanicInHelperFunction some_file.txt:0 runtime.call16 /some/path/asm_amd64.s:401 reflect.Value.call some_file.txt:0 reflect.Value.Call some_file.txt:0 [ FAILED ] PanickingTest.ExplicitPanicInHelperFunction [ RUN ] PanickingTest.NilPointerDerefence TearDown running. panicking_test.go:56: panic: runtime error: invalid memory address or nil pointer dereference github.com/smartystreets/assertions/internal/ogletest/somepkg_test.(*PanickingTest).NilPointerDerefence some_file.txt:0 runtime.call16 /some/path/asm_amd64.s:401 reflect.Value.call some_file.txt:0 reflect.Value.Call some_file.txt:0 [ FAILED ] PanickingTest.NilPointerDerefence [ RUN ] PanickingTest.ZzzSomeOtherTest TearDown running. [ OK ] PanickingTest.ZzzSomeOtherTest [----------] Finished with tests from PanickingTest [----------] Running tests from SetUpPanicTest [ RUN ] SetUpPanicTest.SomeTestCase SetUp about to panic. TearDown running. panicking_test.go:74: panic: Panic in SetUp github.com/smartystreets/assertions/internal/ogletest/somepkg_test.(*SetUpPanicTest).SetUp some_file.txt:0 github.com/smartystreets/assertions/internal/ogletest.func·003 some_file.txt:0 github.com/smartystreets/assertions/internal/ogletest.func·007 some_file.txt:0 [ FAILED ] SetUpPanicTest.SomeTestCase [----------] Finished with tests from SetUpPanicTest [----------] Running tests from TearDownPanicTest [ RUN ] TearDownPanicTest.SomeTestCase TearDown about to panic. panicking_test.go:95: panic: Panic in TearDown github.com/smartystreets/assertions/internal/ogletest/somepkg_test.(*TearDownPanicTest).TearDown some_file.txt:0 github.com/smartystreets/assertions/internal/ogletest.func·005 some_file.txt:0 [ FAILED ] TearDownPanicTest.SomeTestCase [----------] Finished with tests from TearDownPanicTest --- FAIL: TestSomething (1.23s) FAIL exit status 1 FAIL somepkg 1.234s golden.passing_test000066400000000000000000000014501321131462300370410ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/ogletest/test_cases[----------] Running tests from PassingTest [ RUN ] PassingTest.EmptyTestMethod [ OK ] PassingTest.EmptyTestMethod [ RUN ] PassingTest.SuccessfullMatches [ OK ] PassingTest.SuccessfullMatches [ RUN ] PassingTest.ExpectAliases [ OK ] PassingTest.ExpectAliases [ RUN ] PassingTest.AssertAliases [ OK ] PassingTest.AssertAliases [ RUN ] PassingTest.SlowTest [ OK ] PassingTest.SlowTest (1234ms) [----------] Finished with tests from PassingTest [----------] Running tests from PassingTestWithHelpers SetUpTestSuite ran. [ RUN ] PassingTestWithHelpers.EmptyTestMethod SetUp ran. TearDown ran. [ OK ] PassingTestWithHelpers.EmptyTestMethod TearDownTestSuite ran. [----------] Finished with tests from PassingTestWithHelpers PASS ok somepkg 1.234s golden.run_twice_test000066400000000000000000000005721321131462300374000ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/ogletest/test_cases[----------] Running tests from RunTwiceTest [ RUN ] RunTwiceTest.PassingMethod [ OK ] RunTwiceTest.PassingMethod [ RUN ] RunTwiceTest.FailingMethod run_twice_test.go:46: Expected: 17.5 Actual: 17 [ FAILED ] RunTwiceTest.FailingMethod [----------] Finished with tests from RunTwiceTest --- FAIL: TestSomething (1.23s) FAIL exit status 1 FAIL somepkg 1.234s golden.stop_test000066400000000000000000000005301321131462300363600ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/ogletest/test_cases[----------] Running tests from StopTest [ RUN ] StopTest.First TearDown running. [ OK ] StopTest.First [ RUN ] StopTest.Second About to call StopRunningTests. Called StopRunningTests. TearDown running. [ OK ] StopTest.Second TearDownTestSuite running. Exiting early due to user request. exit status 1 FAIL somepkg 1.234s golden.unexported_test000066400000000000000000000004451321131462300375750ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/ogletest/test_cases[----------] Running tests from UnexportedTest [ RUN ] UnexportedTest.SomeTest unexported_test.go:42: Expected: 4 Actual: 3 [ FAILED ] UnexportedTest.SomeTest [----------] Finished with tests from UnexportedTest --- FAIL: TestSomething (1.23s) FAIL exit status 1 FAIL somepkg 1.234s mock.test.go000066400000000000000000000046761321131462300354170ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/ogletest/test_cases// Copyright 2011 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers_test import ( . "github.com/smartystreets/assertions/internal/oglematchers" "github.com/smartystreets/assertions/internal/oglemock" . "github.com/smartystreets/assertions/internal/ogletest" "github.com/smartystreets/assertions/internal/ogletest/test_cases/mock_image" "image/color" "testing" ) //////////////////////////////////////////////////////////////////////// // Helpers //////////////////////////////////////////////////////////////////////// type MockTest struct { controller oglemock.Controller image mock_image.MockImage } func init() { RegisterTestSuite(&MockTest{}) } func TestMockTest(t *testing.T) { RunTests(t) } func (t *MockTest) SetUp(i *TestInfo) { t.controller = i.MockController t.image = mock_image.NewMockImage(t.controller, "some mock image") } //////////////////////////////////////////////////////////////////////// // Tests //////////////////////////////////////////////////////////////////////// func (t *MockTest) ExpectationSatisfied() { ExpectCall(t.image, "At")(11, GreaterThan(19)). WillOnce(oglemock.Return(color.Gray{0})) ExpectThat(t.image.At(11, 23), IdenticalTo(color.Gray{0})) } func (t *MockTest) MockExpectationNotSatisfied() { ExpectCall(t.image, "At")(11, GreaterThan(19)). WillOnce(oglemock.Return(color.Gray{0})) } func (t *MockTest) ExpectCallForUnknownMethod() { ExpectCall(t.image, "FooBar")(11) } func (t *MockTest) UnexpectedCall() { t.image.At(11, 23) } func (t *MockTest) InvokeFunction() { var suppliedX, suppliedY int f := func(x, y int) color.Color { suppliedX = x suppliedY = y return color.Gray{17} } ExpectCall(t.image, "At")(Any(), Any()). WillOnce(oglemock.Invoke(f)) ExpectThat(t.image.At(-1, 12), IdenticalTo(color.Gray{17})) ExpectEq(-1, suppliedX) ExpectEq(12, suppliedY) } mock_image/000077500000000000000000000000001321131462300352375ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/ogletest/test_casesmock_image.go000066400000000000000000000044261321131462300376670ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/ogletest/test_cases/mock_image// This file was auto-generated using createmock. See the following page for // more information: // // https://github.com/smartystreets/assertions/internal/oglemock // package mock_image import ( fmt "fmt" oglemock "github.com/smartystreets/assertions/internal/oglemock" image "image" color "image/color" runtime "runtime" unsafe "unsafe" ) type MockImage interface { image.Image oglemock.MockObject } type mockImage struct { controller oglemock.Controller description string } func NewMockImage( c oglemock.Controller, desc string) MockImage { return &mockImage{ controller: c, description: desc, } } func (m *mockImage) Oglemock_Id() uintptr { return uintptr(unsafe.Pointer(m)) } func (m *mockImage) Oglemock_Description() string { return m.description } func (m *mockImage) At(p0 int, p1 int) (o0 color.Color) { // Get a file name and line number for the caller. _, file, line, _ := runtime.Caller(1) // Hand the call off to the controller, which does most of the work. retVals := m.controller.HandleMethodCall( m, "At", file, line, []interface{}{p0, p1}) if len(retVals) != 1 { panic(fmt.Sprintf("mockImage.At: invalid return values: %v", retVals)) } // o0 color.Color if retVals[0] != nil { o0 = retVals[0].(color.Color) } return } func (m *mockImage) Bounds() (o0 image.Rectangle) { // Get a file name and line number for the caller. _, file, line, _ := runtime.Caller(1) // Hand the call off to the controller, which does most of the work. retVals := m.controller.HandleMethodCall( m, "Bounds", file, line, []interface{}{}) if len(retVals) != 1 { panic(fmt.Sprintf("mockImage.Bounds: invalid return values: %v", retVals)) } // o0 image.Rectangle if retVals[0] != nil { o0 = retVals[0].(image.Rectangle) } return } func (m *mockImage) ColorModel() (o0 color.Model) { // Get a file name and line number for the caller. _, file, line, _ := runtime.Caller(1) // Hand the call off to the controller, which does most of the work. retVals := m.controller.HandleMethodCall( m, "ColorModel", file, line, []interface{}{}) if len(retVals) != 1 { panic(fmt.Sprintf("mockImage.ColorModel: invalid return values: %v", retVals)) } // o0 color.Model if retVals[0] != nil { o0 = retVals[0].(color.Model) } return } no_cases.test.go000066400000000000000000000023141321131462300362430ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/ogletest/test_cases// Copyright 2012 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers_test import ( "fmt" . "github.com/smartystreets/assertions/internal/ogletest" "testing" ) func TestNoCases(t *testing.T) { RunTests(t) } //////////////////////////////////////////////////////////////////////// // Helpers //////////////////////////////////////////////////////////////////////// type NoCasesTest struct { } func init() { RegisterTestSuite(&NoCasesTest{}) } func (t *NoCasesTest) SetUpTestSuite() { fmt.Println("SetUpTestSuite run!") } func (t *NoCasesTest) TearDownTestSuite() { fmt.Println("TearDownTestSuite run!") } panicking.test.go000066400000000000000000000047241321131462300364230ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/ogletest/test_cases// Copyright 2011 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers_test import ( "fmt" "log" "testing" . "github.com/smartystreets/assertions/internal/oglematchers" . "github.com/smartystreets/assertions/internal/ogletest" ) func TestPanickingTest(t *testing.T) { RunTests(t) } //////////////////////////////////////////////////////////////////////// // PanickingTest //////////////////////////////////////////////////////////////////////// func someFuncThatPanics() { panic("Panic in someFuncThatPanics") } type PanickingTest struct { } func init() { RegisterTestSuite(&PanickingTest{}) } func (t *PanickingTest) TearDown() { fmt.Println("TearDown running.") } func (t *PanickingTest) ExplicitPanic() { panic("Panic in ExplicitPanic") } func (t *PanickingTest) ExplicitPanicInHelperFunction() { someFuncThatPanics() } func (t *PanickingTest) NilPointerDerefence() { var p *int log.Println(*p) } func (t *PanickingTest) ZzzSomeOtherTest() { ExpectThat(17, Equals(17.0)) } //////////////////////////////////////////////////////////////////////// // SetUpPanicTest //////////////////////////////////////////////////////////////////////// type SetUpPanicTest struct { } func init() { RegisterTestSuite(&SetUpPanicTest{}) } func (t *SetUpPanicTest) SetUp(ti *TestInfo) { fmt.Println("SetUp about to panic.") panic("Panic in SetUp") } func (t *SetUpPanicTest) TearDown() { fmt.Println("TearDown running.") } func (t *SetUpPanicTest) SomeTestCase() { } //////////////////////////////////////////////////////////////////////// // TearDownPanicTest //////////////////////////////////////////////////////////////////////// type TearDownPanicTest struct { } func init() { RegisterTestSuite(&TearDownPanicTest{}) } func (t *TearDownPanicTest) TearDown() { fmt.Println("TearDown about to panic.") panic("Panic in TearDown") } func (t *TearDownPanicTest) SomeTestCase() { } passing.test.go000066400000000000000000000055251321131462300361240ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/ogletest/test_cases// Copyright 2011 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers_test import ( "fmt" "testing" "time" . "github.com/smartystreets/assertions/internal/oglematchers" . "github.com/smartystreets/assertions/internal/ogletest" ) func TestPassingTest(t *testing.T) { RunTests(t) } //////////////////////////////////////////////////////////////////////// // PassingTest //////////////////////////////////////////////////////////////////////// type PassingTest struct { } func init() { RegisterTestSuite(&PassingTest{}) } func (t *PassingTest) EmptyTestMethod() { } func (t *PassingTest) SuccessfullMatches() { ExpectThat(17, Equals(17.0)) ExpectThat(16.9, LessThan(17)) ExpectThat("taco", HasSubstr("ac")) AssertThat(17, Equals(17.0)) AssertThat(16.9, LessThan(17)) AssertThat("taco", HasSubstr("ac")) } func (t *PassingTest) ExpectAliases() { ExpectEq(17, 17.0) ExpectLe(17, 17.0) ExpectLe(17, 18.0) ExpectLt(17, 18.0) ExpectGe(17, 17.0) ExpectGe(17, 16.0) ExpectGt(17, 16.0) ExpectNe(17, 18.0) ExpectTrue(true) ExpectFalse(false) } func (t *PassingTest) AssertAliases() { AssertEq(17, 17.0) AssertLe(17, 17.0) AssertLe(17, 18.0) AssertLt(17, 18.0) AssertGe(17, 17.0) AssertGe(17, 16.0) AssertGt(17, 16.0) AssertNe(17, 18.0) AssertTrue(true) AssertFalse(false) } func (t *PassingTest) SlowTest() { time.Sleep(37 * time.Millisecond) } //////////////////////////////////////////////////////////////////////// // PassingTestWithHelpers //////////////////////////////////////////////////////////////////////// type PassingTestWithHelpers struct { } var _ SetUpTestSuiteInterface = &PassingTestWithHelpers{} var _ SetUpInterface = &PassingTestWithHelpers{} var _ TearDownInterface = &PassingTestWithHelpers{} var _ TearDownTestSuiteInterface = &PassingTestWithHelpers{} func init() { RegisterTestSuite(&PassingTestWithHelpers{}) } func (t *PassingTestWithHelpers) SetUpTestSuite() { fmt.Println("SetUpTestSuite ran.") } func (t *PassingTestWithHelpers) SetUp(ti *TestInfo) { fmt.Println("SetUp ran.") } func (t *PassingTestWithHelpers) TearDown() { fmt.Println("TearDown ran.") } func (t *PassingTestWithHelpers) TearDownTestSuite() { fmt.Println("TearDownTestSuite ran.") } func (t *PassingTestWithHelpers) EmptyTestMethod() { } run_twice.test.go000066400000000000000000000027721321131462300364600ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/ogletest/test_cases// Copyright 2011 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers_test import ( . "github.com/smartystreets/assertions/internal/oglematchers" . "github.com/smartystreets/assertions/internal/ogletest" "testing" ) //////////////////////////////////////////////////////////////////////// // Helpers //////////////////////////////////////////////////////////////////////// type RunTwiceTest struct { } func init() { RegisterTestSuite(&RunTwiceTest{}) } // Set up two helpers that call RunTests. The test should still only be run // once. func TestOgletest(t *testing.T) { RunTests(t) } func TestOgletest2(t *testing.T) { RunTests(t) } //////////////////////////////////////////////////////////////////////// // Tests //////////////////////////////////////////////////////////////////////// func (t *RunTwiceTest) PassingMethod() { } func (t *RunTwiceTest) FailingMethod() { ExpectThat(17, Equals(17.5)) } stop.test.go000066400000000000000000000031761321131462300354450ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/ogletest/test_cases// Copyright 2015 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers_test import ( "fmt" "testing" . "github.com/smartystreets/assertions/internal/ogletest" ) func TestStop(t *testing.T) { RunTests(t) } //////////////////////////////////////////////////////////////////////// // Boilerplate //////////////////////////////////////////////////////////////////////// type StopTest struct { } var _ TearDownInterface = &StopTest{} var _ TearDownTestSuiteInterface = &StopTest{} func init() { RegisterTestSuite(&StopTest{}) } func (t *StopTest) TearDown() { fmt.Println("TearDown running.") } func (t *StopTest) TearDownTestSuite() { fmt.Println("TearDownTestSuite running.") } //////////////////////////////////////////////////////////////////////// // Tests //////////////////////////////////////////////////////////////////////// func (t *StopTest) First() { } func (t *StopTest) Second() { fmt.Println("About to call StopRunningTests.") StopRunningTests() fmt.Println("Called StopRunningTests.") } func (t *StopTest) Third() { } unexported.test.go000066400000000000000000000026301321131462300366470ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/ogletest/test_cases// Copyright 2011 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 oglematchers_test import ( . "github.com/smartystreets/assertions/internal/oglematchers" . "github.com/smartystreets/assertions/internal/ogletest" "testing" ) //////////////////////////////////////////////////////////////////////// // Helpers //////////////////////////////////////////////////////////////////////// type UnexportedTest struct { } func init() { RegisterTestSuite(&UnexportedTest{}) } func TestUnexportedTest(t *testing.T) { RunTests(t) } func (t *UnexportedTest) someUnexportedMethod() { } //////////////////////////////////////////////////////////////////////// // Tests //////////////////////////////////////////////////////////////////////// func (t *UnexportedTest) SomeTest() { ExpectThat(3, Equals(4)) } mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/ogletest/test_info.go000066400000000000000000000051671321131462300334200ustar00rootroot00000000000000// Copyright 2011 Aaron Jacobs. All Rights Reserved. // Author: aaronjjacobs@gmail.com (Aaron Jacobs) // // 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 ogletest import ( "sync" "golang.org/x/net/context" "github.com/smartystreets/assertions/internal/oglemock" ) // TestInfo represents information about a currently running or previously-run // test. type TestInfo struct { // A mock controller that is set up to report errors to the ogletest test // runner. This can be used for setting up mock expectations and handling // mock calls. The Finish method should not be run by the user; ogletest will // do that automatically after the test's TearDown method is run. // // Note that this feature is still experimental, and is subject to change. MockController oglemock.Controller // A context that can be used by tests for long-running operations. In // particular, this enables conveniently tracing the execution of a test // function with reqtrace. Ctx context.Context // A mutex protecting shared state. mu sync.RWMutex // A set of failure records that the test has produced. // // GUARDED_BY(mu) failureRecords []FailureRecord } // currentlyRunningTest is the state for the currently running test, if any. var currentlyRunningTest *TestInfo // newTestInfo creates a valid but empty TestInfo struct. func newTestInfo() (info *TestInfo) { info = &TestInfo{} info.MockController = oglemock.NewController(&testInfoErrorReporter{info}) info.Ctx = context.Background() return } // testInfoErrorReporter is an oglemock.ErrorReporter that writes failure // records into a test info struct. type testInfoErrorReporter struct { testInfo *TestInfo } func (r *testInfoErrorReporter) ReportError( fileName string, lineNumber int, err error) { r.testInfo.mu.Lock() defer r.testInfo.mu.Unlock() record := FailureRecord{ FileName: fileName, LineNumber: lineNumber, Error: err.Error(), } r.testInfo.failureRecords = append(r.testInfo.failureRecords, record) } func (r *testInfoErrorReporter) ReportFatalError( fileName string, lineNumber int, err error) { r.ReportError(fileName, lineNumber, err) AbortTest() } mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/reqtrace/000077500000000000000000000000001321131462300310465ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/reqtrace/.gitignore000066400000000000000000000004121321131462300330330ustar00rootroot00000000000000# Compiled Object files, Static and Dynamic libs (Shared Objects) *.o *.a *.so # Folders _obj _test # Architecture specific extensions/prefixes *.[568vq] [568vq].out *.cgo1.go *.cgo2.c _cgo_defun.c _cgo_gotypes.go _cgo_export.* _testmain.go *.exe *.test *.prof mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/reqtrace/LICENSE000066400000000000000000000261361321131462300320630ustar00rootroot00000000000000 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. mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/reqtrace/README.md000066400000000000000000000035411321131462300323300ustar00rootroot00000000000000[![GoDoc](https://godoc.org/github.com/smartystreets/assertions/internal/reqtrace?status.svg)](https://godoc.org/github.com/smartystreets/assertions/internal/reqtrace) reqtrace is a package for simple request tracing. It requires nothing of its user except: * They must use [golang.org/x/net/context][context]. * They must add a single line to each function they want to be visible in traces. [context]: http://godoc.org/golang.org/x/net/context In particular, reqtrace is console-based and doesn't require an HTTP server. **Warning**: This package is still barebones and in its early days. I reserve the right to make backwards-incompatible changes to its API. But if it's useful to you in your current form, have at it. ## Use Call reqtrace.Trace anywhere you want to start a new root trace. (This is probably where you create your root context.) This returns a new context that you should pass to child operations, and a reporting function that you must use to inform reqtrace when the trace is complete. For example: ```Go func HandleRequest(r *someRequest) (err error) { ctx, report := reqtrace.Trace(context.Background(), "HandleRequest") defer func() { report(err) }() // Do two things for this request. DoSomething(ctx, r) DoSomethingElse(ctx, r) } ``` Within other functions that you want to show up in the trace, you reqtrace.StartSpan (or its more convenient sibling reqtrace.StartSpanWithError): ```Go func DoSomething(ctx context.Context, r *someRequest) (err error) { defer reqtrace.StartSpanWithError(&ctx, &err, "DoSomething")() // Process the request somehow using ctx. If downstream code also annotes // using reqtrace, reqtrace will know that its spans are descendants of // this one. CallAnotherLibrary(ctx, r.Param) } ``` When `--reqtrace.enable` is set, the completion of a trace will cause helpful ASCII art to be spit out. mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/reqtrace/reqtrace.go000066400000000000000000000072241321131462300332100ustar00rootroot00000000000000// Copyright 2015 Google Inc. All Rights Reserved. // // 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 reqtrace contains a very simple request tracing framework. package reqtrace import ( "flag" "golang.org/x/net/context" ) type contextKey int var fEnabled = flag.Bool("reqtrace.enable", false, "Collect and print traces.") // The key used to associate a *traceState with a context. const traceStateKey contextKey = 0 // A function that must be called exactly once to report the outcome of an // operation represented by a span. type ReportFunc func(error) // Return false only if traces are disabled, i.e. Trace will never cause a // trace to be initiated. // // REQUIRES: flag.Parsed() func Enabled() (enabled bool) { enabled = *fEnabled return } // Begin a span within the current trace. Return a new context that should be // used for operations that logically occur within the span, and a report // function that must be called with the outcome of the logical operation // represented by the span. // // If no trace is active, no span will be created but ctx and report will still // be valid. func StartSpan( parent context.Context, desc string) (ctx context.Context, report ReportFunc) { // Look for the trace state. val := parent.Value(traceStateKey) if val == nil { // Nothing to do. ctx = parent report = func(err error) {} return } ts := val.(*traceState) // Set up the report function. report = ts.CreateSpan(desc) // For now we don't do anything interesting with the context. In the future, // we may use it to record span hierarchy. ctx = parent return } // A wrapper around StartSpan that can be more convenient to use when the // lifetime of a span matches the lifetime of a function. Intended to be used // in a defer statement within a function using a named error return parameter. // // Equivalent to calling StartSpan with *ctx, replacing *ctx with the resulting // new context, then setting f to a function that will invoke the report // function with the contents of *error at the time that it is called. // // Example: // // func DoSomething(ctx context.Context) (err error) { // defer reqtrace.StartSpanWithError(&ctx, &err, "DoSomething")() // [...] // } // func StartSpanWithError( ctx *context.Context, err *error, desc string) (f func()) { var report ReportFunc *ctx, report = StartSpan(*ctx, desc) f = func() { report(*err) } return } // Like StartSpan, but begins a root span for a new trace if no trace is active // in the supplied context and tracing is enabled for the process. func Trace( parent context.Context, desc string) (ctx context.Context, report ReportFunc) { // If tracing is disabled, this is a no-op. if !*fEnabled { ctx = parent report = func(err error) {} return } // Is this context already being traced? If so, simply add a span. if parent.Value(traceStateKey) != nil { ctx, report = StartSpan(parent, desc) return } // Set up a new trace state. ts := new(traceState) baseReport := ts.CreateSpan(desc) // Log when finished. report = func(err error) { baseReport(err) ts.Log() } // Set up the context. ctx = context.WithValue(parent, traceStateKey, ts) return } mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/internal/reqtrace/trace_state.go000066400000000000000000000101611321131462300336720ustar00rootroot00000000000000// Copyright 2015 Google Inc. All Rights Reserved. // // 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 reqtrace import ( "log" "math" "os" "strings" "sync" "time" ) const logFlags = 0 var gLogger = log.New(os.Stderr, "reqtrace: ", logFlags) type span struct { // Fixed at creation. desc string start time.Time // Updated by report functions. finished bool end time.Time err error } // All of the state for a particular trace root. The zero value is usable. type traceState struct { mu sync.Mutex // The list of spans associated with this state. Append-only. // // GUARDED_BY(mu) spans []*span } func (ts *traceState) report(spanIndex int, err error) { ts.mu.Lock() defer ts.mu.Unlock() s := ts.spans[spanIndex] s.finished = true s.end = time.Now() s.err = err } // Associate a new span with the trace. Return a function that will report its // completion. func (ts *traceState) CreateSpan(desc string) (report ReportFunc) { ts.mu.Lock() defer ts.mu.Unlock() index := len(ts.spans) ts.spans = append(ts.spans, &span{desc: desc, start: time.Now()}) report = func(err error) { ts.report(index, err) } return } func round(x float64) float64 { if x < 0 { return math.Ceil(x - 0.5) } return math.Floor(x + 0.5) } // Log information about the spans in this trace. func (ts *traceState) Log() { ts.mu.Lock() defer ts.mu.Unlock() gLogger.Println() // Special case: we require at least one span. if len(ts.spans) == 0 { return } // Print a banner for this trace. const bannerHalfLength = 45 gLogger.Println() gLogger.Printf( "%s %s %s", strings.Repeat("=", bannerHalfLength), ts.spans[0].desc, strings.Repeat("=", bannerHalfLength)) gLogger.Printf("Start time: %v", ts.spans[0].start.Format(time.RFC3339Nano)) gLogger.Println() // Find the minimum start time and maximum end time of all durations. var minStart time.Time var maxEnd time.Time for _, s := range ts.spans { if !s.finished { continue } if minStart.IsZero() || s.start.Before(minStart) { minStart = s.start } if maxEnd.Before(s.end) { maxEnd = s.end } } // Bail out if something weird happened. // // TODO(jacobsa): Be more graceful. totalDuration := maxEnd.Sub(minStart) if minStart.IsZero() || maxEnd.IsZero() || totalDuration <= 0 { gLogger.Println("(Weird trace)") return } // Calculate the number of nanoseconds elapsed, as a floating point number. totalNs := float64(totalDuration / time.Nanosecond) // Log each span with some ASCII art showing its length relative to the // total. const totalNumCols float64 = 120 for _, s := range ts.spans { if !s.finished { gLogger.Printf("(Unfinished: %s)", s.desc) gLogger.Println() continue } // Calculate the duration of the span, and its width relative to the // longest span. d := s.end.Sub(s.start) if d <= 0 { gLogger.Println("(Weird duration)") gLogger.Println() continue } durationRatio := float64(d/time.Nanosecond) / totalNs // We will offset the label and banner proportional to the time since the // start of the earliest span. offsetRatio := float64(s.start.Sub(minStart)/time.Nanosecond) / totalNs offsetChars := int(round(offsetRatio * totalNumCols)) offsetStr := strings.Repeat(" ", offsetChars) // Print the description and duration. gLogger.Printf("%s%v", offsetStr, s.desc) gLogger.Printf("%s%v", offsetStr, d) // Print a banner showing the duration graphically. bannerChars := int(round(durationRatio * totalNumCols)) var dashes string if bannerChars > 2 { dashes = strings.Repeat("-", bannerChars-2) } gLogger.Printf("%s|%s|", offsetStr, dashes) gLogger.Println() } } mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/messages.go000066400000000000000000000155051321131462300275700ustar00rootroot00000000000000package assertions const ( // equality shouldHaveBeenEqual = "Expected: '%v'\nActual: '%v'\n(Should be equal)" shouldNotHaveBeenEqual = "Expected '%v'\nto NOT equal '%v'\n(but it did)!" shouldHaveBeenEqualTypeMismatch = "Expected: '%v' (%T)\nActual: '%v' (%T)\n(Should be equal, type mismatch)" shouldHaveBeenAlmostEqual = "Expected '%v' to almost equal '%v' (but it didn't)!" shouldHaveNotBeenAlmostEqual = "Expected '%v' to NOT almost equal '%v' (but it did)!" shouldHaveResembled = "Expected: '%#v'\nActual: '%#v'\n(Should resemble)!" shouldHaveResembledTypeMismatch = "Expected: '%#v' (%T)\nActual: '%#v' (%T)\n(Should resemble, type mismatch)" shouldNotHaveResembled = "Expected '%#v'\nto NOT resemble '%#v'\n(but it did)!" shouldBePointers = "Both arguments should be pointers " shouldHaveBeenNonNilPointer = shouldBePointers + "(the %s was %s)!" shouldHavePointedTo = "Expected '%+v' (address: '%v') and '%+v' (address: '%v') to be the same address (but their weren't)!" shouldNotHavePointedTo = "Expected '%+v' and '%+v' to be different references (but they matched: '%v')!" shouldHaveBeenNil = "Expected: nil\nActual: '%v'" shouldNotHaveBeenNil = "Expected '%+v' to NOT be nil (but it was)!" shouldHaveBeenTrue = "Expected: true\nActual: %v" shouldHaveBeenFalse = "Expected: false\nActual: %v" shouldHaveBeenZeroValue = "'%+v' should have been the zero value" //"Expected: (zero value)\nActual: %v" ) const ( // quantity comparisons shouldHaveBeenGreater = "Expected '%v' to be greater than '%v' (but it wasn't)!" shouldHaveBeenGreaterOrEqual = "Expected '%v' to be greater than or equal to '%v' (but it wasn't)!" shouldHaveBeenLess = "Expected '%v' to be less than '%v' (but it wasn't)!" shouldHaveBeenLessOrEqual = "Expected '%v' to be less than or equal to '%v' (but it wasn't)!" shouldHaveBeenBetween = "Expected '%v' to be between '%v' and '%v' (but it wasn't)!" shouldNotHaveBeenBetween = "Expected '%v' NOT to be between '%v' and '%v' (but it was)!" shouldHaveDifferentUpperAndLower = "The lower and upper bounds must be different values (they were both '%v')." shouldHaveBeenBetweenOrEqual = "Expected '%v' to be between '%v' and '%v' or equal to one of them (but it wasn't)!" shouldNotHaveBeenBetweenOrEqual = "Expected '%v' NOT to be between '%v' and '%v' or equal to one of them (but it was)!" ) const ( // collections shouldHaveContained = "Expected the container (%v) to contain: '%v' (but it didn't)!" shouldNotHaveContained = "Expected the container (%v) NOT to contain: '%v' (but it did)!" shouldHaveContainedKey = "Expected the %v to contain the key: %v (but it didn't)!" shouldNotHaveContainedKey = "Expected the %v NOT to contain the key: %v (but it did)!" shouldHaveBeenIn = "Expected '%v' to be in the container (%v), but it wasn't!" shouldNotHaveBeenIn = "Expected '%v' NOT to be in the container (%v), but it was!" shouldHaveBeenAValidCollection = "You must provide a valid container (was %v)!" shouldHaveBeenAValidMap = "You must provide a valid map type (was %v)!" shouldHaveBeenEmpty = "Expected %+v to be empty (but it wasn't)!" shouldNotHaveBeenEmpty = "Expected %+v to NOT be empty (but it was)!" shouldHaveBeenAValidInteger = "You must provide a valid integer (was %v)!" shouldHaveBeenAValidLength = "You must provide a valid positive integer (was %v)!" shouldHaveHadLength = "Expected %+v (length: %v) to have length equal to '%v', but it wasn't!" ) const ( // strings shouldHaveStartedWith = "Expected '%v'\nto start with '%v'\n(but it didn't)!" shouldNotHaveStartedWith = "Expected '%v'\nNOT to start with '%v'\n(but it did)!" shouldHaveEndedWith = "Expected '%v'\nto end with '%v'\n(but it didn't)!" shouldNotHaveEndedWith = "Expected '%v'\nNOT to end with '%v'\n(but it did)!" shouldAllBeStrings = "All arguments to this assertion must be strings (you provided: %v)." shouldBothBeStrings = "Both arguments to this assertion must be strings (you provided %v and %v)." shouldBeString = "The argument to this assertion must be a string (you provided %v)." shouldHaveContainedSubstring = "Expected '%s' to contain substring '%s' (but it didn't)!" shouldNotHaveContainedSubstring = "Expected '%s' NOT to contain substring '%s' (but it did)!" shouldHaveBeenBlank = "Expected '%s' to be blank (but it wasn't)!" shouldNotHaveBeenBlank = "Expected value to NOT be blank (but it was)!" ) const ( // panics shouldUseVoidNiladicFunction = "You must provide a void, niladic function as the first argument!" shouldHavePanickedWith = "Expected func() to panic with '%v' (but it panicked with '%v')!" shouldHavePanicked = "Expected func() to panic (but it didn't)!" shouldNotHavePanicked = "Expected func() NOT to panic (error: '%+v')!" shouldNotHavePanickedWith = "Expected func() NOT to panic with '%v' (but it did)!" ) const ( // type checking shouldHaveBeenA = "Expected '%v' to be: '%v' (but was: '%v')!" shouldNotHaveBeenA = "Expected '%v' to NOT be: '%v' (but it was)!" shouldHaveImplemented = "Expected: '%v interface support'\nActual: '%v' does not implement the interface!" shouldNotHaveImplemented = "Expected '%v'\nto NOT implement '%v'\n(but it did)!" shouldCompareWithInterfacePointer = "The expected value must be a pointer to an interface type (eg. *fmt.Stringer)" shouldNotBeNilActual = "The actual value was 'nil' and should be a value or a pointer to a value!" ) const ( // time comparisons shouldUseTimes = "You must provide time instances as arguments to this assertion." shouldUseTimeSlice = "You must provide a slice of time instances as the first argument to this assertion." shouldUseDurationAndTime = "You must provide a duration and a time as arguments to this assertion." shouldHaveHappenedBefore = "Expected '%v' to happen before '%v' (it happened '%v' after)!" shouldHaveHappenedAfter = "Expected '%v' to happen after '%v' (it happened '%v' before)!" shouldHaveHappenedBetween = "Expected '%v' to happen between '%v' and '%v' (it happened '%v' outside threshold)!" shouldNotHaveHappenedOnOrBetween = "Expected '%v' to NOT happen on or between '%v' and '%v' (but it did)!" // format params: incorrect-index, previous-index, previous-time, incorrect-index, incorrect-time shouldHaveBeenChronological = "The 'Time' at index [%d] should have happened after the previous one (but it didn't!):\n [%d]: %s\n [%d]: %s (see, it happened before!)" ) mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/panic.go000066400000000000000000000047371321131462300270600ustar00rootroot00000000000000package assertions import "fmt" // ShouldPanic receives a void, niladic function and expects to recover a panic. func ShouldPanic(actual interface{}, expected ...interface{}) (message string) { if fail := need(0, expected); fail != success { return fail } action, _ := actual.(func()) if action == nil { message = shouldUseVoidNiladicFunction return } defer func() { recovered := recover() if recovered == nil { message = shouldHavePanicked } else { message = success } }() action() return } // ShouldNotPanic receives a void, niladic function and expects to execute the function without any panic. func ShouldNotPanic(actual interface{}, expected ...interface{}) (message string) { if fail := need(0, expected); fail != success { return fail } action, _ := actual.(func()) if action == nil { message = shouldUseVoidNiladicFunction return } defer func() { recovered := recover() if recovered != nil { message = fmt.Sprintf(shouldNotHavePanicked, recovered) } else { message = success } }() action() return } // ShouldPanicWith receives a void, niladic function and expects to recover a panic with the second argument as the content. func ShouldPanicWith(actual interface{}, expected ...interface{}) (message string) { if fail := need(1, expected); fail != success { return fail } action, _ := actual.(func()) if action == nil { message = shouldUseVoidNiladicFunction return } defer func() { recovered := recover() if recovered == nil { message = shouldHavePanicked } else { if equal := ShouldEqual(recovered, expected[0]); equal != success { message = serializer.serialize(expected[0], recovered, fmt.Sprintf(shouldHavePanickedWith, expected[0], recovered)) } else { message = success } } }() action() return } // ShouldNotPanicWith receives a void, niladic function and expects to recover a panic whose content differs from the second argument. func ShouldNotPanicWith(actual interface{}, expected ...interface{}) (message string) { if fail := need(1, expected); fail != success { return fail } action, _ := actual.(func()) if action == nil { message = shouldUseVoidNiladicFunction return } defer func() { recovered := recover() if recovered == nil { message = success } else { if equal := ShouldEqual(recovered, expected[0]); equal == success { message = fmt.Sprintf(shouldNotHavePanickedWith, expected[0]) } else { message = success } } }() action() return } mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/panic_test.go000066400000000000000000000050171321131462300301070ustar00rootroot00000000000000package assertions import ( "fmt" "testing" ) func TestShouldPanic(t *testing.T) { fail(t, so(func() {}, ShouldPanic, 1), "This assertion requires exactly 0 comparison values (you provided 1).") fail(t, so(func() {}, ShouldPanic, 1, 2, 3), "This assertion requires exactly 0 comparison values (you provided 3).") fail(t, so(1, ShouldPanic), shouldUseVoidNiladicFunction) fail(t, so(func(i int) {}, ShouldPanic), shouldUseVoidNiladicFunction) fail(t, so(func() int { panic("hi") }, ShouldPanic), shouldUseVoidNiladicFunction) fail(t, so(func() {}, ShouldPanic), shouldHavePanicked) pass(t, so(func() { panic("hi") }, ShouldPanic)) } func TestShouldNotPanic(t *testing.T) { fail(t, so(func() {}, ShouldNotPanic, 1), "This assertion requires exactly 0 comparison values (you provided 1).") fail(t, so(func() {}, ShouldNotPanic, 1, 2, 3), "This assertion requires exactly 0 comparison values (you provided 3).") fail(t, so(1, ShouldNotPanic), shouldUseVoidNiladicFunction) fail(t, so(func(i int) {}, ShouldNotPanic), shouldUseVoidNiladicFunction) fail(t, so(func() { panic("hi") }, ShouldNotPanic), fmt.Sprintf(shouldNotHavePanicked, "hi")) pass(t, so(func() {}, ShouldNotPanic)) } func TestShouldPanicWith(t *testing.T) { fail(t, so(func() {}, ShouldPanicWith), "This assertion requires exactly 1 comparison values (you provided 0).") fail(t, so(func() {}, ShouldPanicWith, 1, 2, 3), "This assertion requires exactly 1 comparison values (you provided 3).") fail(t, so(1, ShouldPanicWith, 1), shouldUseVoidNiladicFunction) fail(t, so(func(i int) {}, ShouldPanicWith, "hi"), shouldUseVoidNiladicFunction) fail(t, so(func() {}, ShouldPanicWith, "bye"), shouldHavePanicked) fail(t, so(func() { panic("hi") }, ShouldPanicWith, "bye"), "bye|hi|Expected func() to panic with 'bye' (but it panicked with 'hi')!") pass(t, so(func() { panic("hi") }, ShouldPanicWith, "hi")) } func TestShouldNotPanicWith(t *testing.T) { fail(t, so(func() {}, ShouldNotPanicWith), "This assertion requires exactly 1 comparison values (you provided 0).") fail(t, so(func() {}, ShouldNotPanicWith, 1, 2, 3), "This assertion requires exactly 1 comparison values (you provided 3).") fail(t, so(1, ShouldNotPanicWith, 1), shouldUseVoidNiladicFunction) fail(t, so(func(i int) {}, ShouldNotPanicWith, "hi"), shouldUseVoidNiladicFunction) fail(t, so(func() { panic("hi") }, ShouldNotPanicWith, "hi"), "Expected func() NOT to panic with 'hi' (but it did)!") pass(t, so(func() {}, ShouldNotPanicWith, "bye")) pass(t, so(func() { panic("hi") }, ShouldNotPanicWith, "bye")) } mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/quantity.go000066400000000000000000000115441321131462300276360ustar00rootroot00000000000000package assertions import ( "fmt" "github.com/smartystreets/assertions/internal/oglematchers" ) // ShouldBeGreaterThan receives exactly two parameters and ensures that the first is greater than the second. func ShouldBeGreaterThan(actual interface{}, expected ...interface{}) string { if fail := need(1, expected); fail != success { return fail } if matchError := oglematchers.GreaterThan(expected[0]).Matches(actual); matchError != nil { return fmt.Sprintf(shouldHaveBeenGreater, actual, expected[0]) } return success } // ShouldBeGreaterThanOrEqualTo receives exactly two parameters and ensures that the first is greater than or equal to the second. func ShouldBeGreaterThanOrEqualTo(actual interface{}, expected ...interface{}) string { if fail := need(1, expected); fail != success { return fail } else if matchError := oglematchers.GreaterOrEqual(expected[0]).Matches(actual); matchError != nil { return fmt.Sprintf(shouldHaveBeenGreaterOrEqual, actual, expected[0]) } return success } // ShouldBeLessThan receives exactly two parameters and ensures that the first is less than the second. func ShouldBeLessThan(actual interface{}, expected ...interface{}) string { if fail := need(1, expected); fail != success { return fail } else if matchError := oglematchers.LessThan(expected[0]).Matches(actual); matchError != nil { return fmt.Sprintf(shouldHaveBeenLess, actual, expected[0]) } return success } // ShouldBeLessThan receives exactly two parameters and ensures that the first is less than or equal to the second. func ShouldBeLessThanOrEqualTo(actual interface{}, expected ...interface{}) string { if fail := need(1, expected); fail != success { return fail } else if matchError := oglematchers.LessOrEqual(expected[0]).Matches(actual); matchError != nil { return fmt.Sprintf(shouldHaveBeenLess, actual, expected[0]) } return success } // ShouldBeBetween receives exactly three parameters: an actual value, a lower bound, and an upper bound. // It ensures that the actual value is between both bounds (but not equal to either of them). func ShouldBeBetween(actual interface{}, expected ...interface{}) string { if fail := need(2, expected); fail != success { return fail } lower, upper, fail := deriveBounds(expected) if fail != success { return fail } else if !isBetween(actual, lower, upper) { return fmt.Sprintf(shouldHaveBeenBetween, actual, lower, upper) } return success } // ShouldNotBeBetween receives exactly three parameters: an actual value, a lower bound, and an upper bound. // It ensures that the actual value is NOT between both bounds. func ShouldNotBeBetween(actual interface{}, expected ...interface{}) string { if fail := need(2, expected); fail != success { return fail } lower, upper, fail := deriveBounds(expected) if fail != success { return fail } else if isBetween(actual, lower, upper) { return fmt.Sprintf(shouldNotHaveBeenBetween, actual, lower, upper) } return success } func deriveBounds(values []interface{}) (lower interface{}, upper interface{}, fail string) { lower = values[0] upper = values[1] if ShouldNotEqual(lower, upper) != success { return nil, nil, fmt.Sprintf(shouldHaveDifferentUpperAndLower, lower) } else if ShouldBeLessThan(lower, upper) != success { lower, upper = upper, lower } return lower, upper, success } func isBetween(value, lower, upper interface{}) bool { if ShouldBeGreaterThan(value, lower) != success { return false } else if ShouldBeLessThan(value, upper) != success { return false } return true } // ShouldBeBetweenOrEqual receives exactly three parameters: an actual value, a lower bound, and an upper bound. // It ensures that the actual value is between both bounds or equal to one of them. func ShouldBeBetweenOrEqual(actual interface{}, expected ...interface{}) string { if fail := need(2, expected); fail != success { return fail } lower, upper, fail := deriveBounds(expected) if fail != success { return fail } else if !isBetweenOrEqual(actual, lower, upper) { return fmt.Sprintf(shouldHaveBeenBetweenOrEqual, actual, lower, upper) } return success } // ShouldNotBeBetweenOrEqual receives exactly three parameters: an actual value, a lower bound, and an upper bound. // It ensures that the actual value is nopt between the bounds nor equal to either of them. func ShouldNotBeBetweenOrEqual(actual interface{}, expected ...interface{}) string { if fail := need(2, expected); fail != success { return fail } lower, upper, fail := deriveBounds(expected) if fail != success { return fail } else if isBetweenOrEqual(actual, lower, upper) { return fmt.Sprintf(shouldNotHaveBeenBetweenOrEqual, actual, lower, upper) } return success } func isBetweenOrEqual(value, lower, upper interface{}) bool { if ShouldBeGreaterThanOrEqualTo(value, lower) != success { return false } else if ShouldBeLessThanOrEqualTo(value, upper) != success { return false } return true } mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/quantity_test.go000066400000000000000000000205611321131462300306740ustar00rootroot00000000000000package assertions import "testing" func TestShouldBeGreaterThan(t *testing.T) { fail(t, so(1, ShouldBeGreaterThan), "This assertion requires exactly 1 comparison values (you provided 0).") fail(t, so(1, ShouldBeGreaterThan, 0, 0), "This assertion requires exactly 1 comparison values (you provided 2).") pass(t, so(1, ShouldBeGreaterThan, 0)) pass(t, so(1.1, ShouldBeGreaterThan, 1)) pass(t, so(1, ShouldBeGreaterThan, uint(0))) pass(t, so("b", ShouldBeGreaterThan, "a")) fail(t, so(0, ShouldBeGreaterThan, 1), "Expected '0' to be greater than '1' (but it wasn't)!") fail(t, so(1, ShouldBeGreaterThan, 1.1), "Expected '1' to be greater than '1.1' (but it wasn't)!") fail(t, so(uint(0), ShouldBeGreaterThan, 1.1), "Expected '0' to be greater than '1.1' (but it wasn't)!") fail(t, so("a", ShouldBeGreaterThan, "b"), "Expected 'a' to be greater than 'b' (but it wasn't)!") } func TestShouldBeGreaterThanOrEqual(t *testing.T) { fail(t, so(1, ShouldBeGreaterThanOrEqualTo), "This assertion requires exactly 1 comparison values (you provided 0).") fail(t, so(1, ShouldBeGreaterThanOrEqualTo, 0, 0), "This assertion requires exactly 1 comparison values (you provided 2).") pass(t, so(1, ShouldBeGreaterThanOrEqualTo, 1)) pass(t, so(1.1, ShouldBeGreaterThanOrEqualTo, 1.1)) pass(t, so(1, ShouldBeGreaterThanOrEqualTo, uint(1))) pass(t, so("b", ShouldBeGreaterThanOrEqualTo, "b")) pass(t, so(1, ShouldBeGreaterThanOrEqualTo, 0)) pass(t, so(1.1, ShouldBeGreaterThanOrEqualTo, 1)) pass(t, so(1, ShouldBeGreaterThanOrEqualTo, uint(0))) pass(t, so("b", ShouldBeGreaterThanOrEqualTo, "a")) fail(t, so(0, ShouldBeGreaterThanOrEqualTo, 1), "Expected '0' to be greater than or equal to '1' (but it wasn't)!") fail(t, so(1, ShouldBeGreaterThanOrEqualTo, 1.1), "Expected '1' to be greater than or equal to '1.1' (but it wasn't)!") fail(t, so(uint(0), ShouldBeGreaterThanOrEqualTo, 1.1), "Expected '0' to be greater than or equal to '1.1' (but it wasn't)!") fail(t, so("a", ShouldBeGreaterThanOrEqualTo, "b"), "Expected 'a' to be greater than or equal to 'b' (but it wasn't)!") } func TestShouldBeLessThan(t *testing.T) { fail(t, so(1, ShouldBeLessThan), "This assertion requires exactly 1 comparison values (you provided 0).") fail(t, so(1, ShouldBeLessThan, 0, 0), "This assertion requires exactly 1 comparison values (you provided 2).") pass(t, so(0, ShouldBeLessThan, 1)) pass(t, so(1, ShouldBeLessThan, 1.1)) pass(t, so(uint(0), ShouldBeLessThan, 1)) pass(t, so("a", ShouldBeLessThan, "b")) fail(t, so(1, ShouldBeLessThan, 0), "Expected '1' to be less than '0' (but it wasn't)!") fail(t, so(1.1, ShouldBeLessThan, 1), "Expected '1.1' to be less than '1' (but it wasn't)!") fail(t, so(1.1, ShouldBeLessThan, uint(0)), "Expected '1.1' to be less than '0' (but it wasn't)!") fail(t, so("b", ShouldBeLessThan, "a"), "Expected 'b' to be less than 'a' (but it wasn't)!") } func TestShouldBeLessThanOrEqualTo(t *testing.T) { fail(t, so(1, ShouldBeLessThanOrEqualTo), "This assertion requires exactly 1 comparison values (you provided 0).") fail(t, so(1, ShouldBeLessThanOrEqualTo, 0, 0), "This assertion requires exactly 1 comparison values (you provided 2).") pass(t, so(1, ShouldBeLessThanOrEqualTo, 1)) pass(t, so(1.1, ShouldBeLessThanOrEqualTo, 1.1)) pass(t, so(uint(1), ShouldBeLessThanOrEqualTo, 1)) pass(t, so("b", ShouldBeLessThanOrEqualTo, "b")) pass(t, so(0, ShouldBeLessThanOrEqualTo, 1)) pass(t, so(1, ShouldBeLessThanOrEqualTo, 1.1)) pass(t, so(uint(0), ShouldBeLessThanOrEqualTo, 1)) pass(t, so("a", ShouldBeLessThanOrEqualTo, "b")) fail(t, so(1, ShouldBeLessThanOrEqualTo, 0), "Expected '1' to be less than '0' (but it wasn't)!") fail(t, so(1.1, ShouldBeLessThanOrEqualTo, 1), "Expected '1.1' to be less than '1' (but it wasn't)!") fail(t, so(1.1, ShouldBeLessThanOrEqualTo, uint(0)), "Expected '1.1' to be less than '0' (but it wasn't)!") fail(t, so("b", ShouldBeLessThanOrEqualTo, "a"), "Expected 'b' to be less than 'a' (but it wasn't)!") } func TestShouldBeBetween(t *testing.T) { fail(t, so(1, ShouldBeBetween), "This assertion requires exactly 2 comparison values (you provided 0).") fail(t, so(1, ShouldBeBetween, 1, 2, 3), "This assertion requires exactly 2 comparison values (you provided 3).") fail(t, so(4, ShouldBeBetween, 1, 1), "The lower and upper bounds must be different values (they were both '1').") fail(t, so(7, ShouldBeBetween, 8, 12), "Expected '7' to be between '8' and '12' (but it wasn't)!") fail(t, so(8, ShouldBeBetween, 8, 12), "Expected '8' to be between '8' and '12' (but it wasn't)!") pass(t, so(9, ShouldBeBetween, 8, 12)) pass(t, so(10, ShouldBeBetween, 8, 12)) pass(t, so(11, ShouldBeBetween, 8, 12)) fail(t, so(12, ShouldBeBetween, 8, 12), "Expected '12' to be between '8' and '12' (but it wasn't)!") fail(t, so(13, ShouldBeBetween, 8, 12), "Expected '13' to be between '8' and '12' (but it wasn't)!") pass(t, so(1, ShouldBeBetween, 2, 0)) fail(t, so(-1, ShouldBeBetween, 2, 0), "Expected '-1' to be between '0' and '2' (but it wasn't)!") } func TestShouldNotBeBetween(t *testing.T) { fail(t, so(1, ShouldNotBeBetween), "This assertion requires exactly 2 comparison values (you provided 0).") fail(t, so(1, ShouldNotBeBetween, 1, 2, 3), "This assertion requires exactly 2 comparison values (you provided 3).") fail(t, so(4, ShouldNotBeBetween, 1, 1), "The lower and upper bounds must be different values (they were both '1').") pass(t, so(7, ShouldNotBeBetween, 8, 12)) pass(t, so(8, ShouldNotBeBetween, 8, 12)) fail(t, so(9, ShouldNotBeBetween, 8, 12), "Expected '9' NOT to be between '8' and '12' (but it was)!") fail(t, so(10, ShouldNotBeBetween, 8, 12), "Expected '10' NOT to be between '8' and '12' (but it was)!") fail(t, so(11, ShouldNotBeBetween, 8, 12), "Expected '11' NOT to be between '8' and '12' (but it was)!") pass(t, so(12, ShouldNotBeBetween, 8, 12)) pass(t, so(13, ShouldNotBeBetween, 8, 12)) pass(t, so(-1, ShouldNotBeBetween, 2, 0)) fail(t, so(1, ShouldNotBeBetween, 2, 0), "Expected '1' NOT to be between '0' and '2' (but it was)!") } func TestShouldBeBetweenOrEqual(t *testing.T) { fail(t, so(1, ShouldBeBetweenOrEqual), "This assertion requires exactly 2 comparison values (you provided 0).") fail(t, so(1, ShouldBeBetweenOrEqual, 1, 2, 3), "This assertion requires exactly 2 comparison values (you provided 3).") fail(t, so(4, ShouldBeBetweenOrEqual, 1, 1), "The lower and upper bounds must be different values (they were both '1').") fail(t, so(7, ShouldBeBetweenOrEqual, 8, 12), "Expected '7' to be between '8' and '12' or equal to one of them (but it wasn't)!") pass(t, so(8, ShouldBeBetweenOrEqual, 8, 12)) pass(t, so(9, ShouldBeBetweenOrEqual, 8, 12)) pass(t, so(10, ShouldBeBetweenOrEqual, 8, 12)) pass(t, so(11, ShouldBeBetweenOrEqual, 8, 12)) pass(t, so(12, ShouldBeBetweenOrEqual, 8, 12)) fail(t, so(13, ShouldBeBetweenOrEqual, 8, 12), "Expected '13' to be between '8' and '12' or equal to one of them (but it wasn't)!") pass(t, so(1, ShouldBeBetweenOrEqual, 2, 0)) fail(t, so(-1, ShouldBeBetweenOrEqual, 2, 0), "Expected '-1' to be between '0' and '2' or equal to one of them (but it wasn't)!") } func TestShouldNotBeBetweenOrEqual(t *testing.T) { fail(t, so(1, ShouldNotBeBetweenOrEqual), "This assertion requires exactly 2 comparison values (you provided 0).") fail(t, so(1, ShouldNotBeBetweenOrEqual, 1, 2, 3), "This assertion requires exactly 2 comparison values (you provided 3).") fail(t, so(4, ShouldNotBeBetweenOrEqual, 1, 1), "The lower and upper bounds must be different values (they were both '1').") pass(t, so(7, ShouldNotBeBetweenOrEqual, 8, 12)) fail(t, so(8, ShouldNotBeBetweenOrEqual, 8, 12), "Expected '8' NOT to be between '8' and '12' or equal to one of them (but it was)!") fail(t, so(9, ShouldNotBeBetweenOrEqual, 8, 12), "Expected '9' NOT to be between '8' and '12' or equal to one of them (but it was)!") fail(t, so(10, ShouldNotBeBetweenOrEqual, 8, 12), "Expected '10' NOT to be between '8' and '12' or equal to one of them (but it was)!") fail(t, so(11, ShouldNotBeBetweenOrEqual, 8, 12), "Expected '11' NOT to be between '8' and '12' or equal to one of them (but it was)!") fail(t, so(12, ShouldNotBeBetweenOrEqual, 8, 12), "Expected '12' NOT to be between '8' and '12' or equal to one of them (but it was)!") pass(t, so(13, ShouldNotBeBetweenOrEqual, 8, 12)) pass(t, so(-1, ShouldNotBeBetweenOrEqual, 2, 0)) fail(t, so(1, ShouldNotBeBetweenOrEqual, 2, 0), "Expected '1' NOT to be between '0' and '2' or equal to one of them (but it was)!") } mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/serializer.go000066400000000000000000000036341321131462300301320ustar00rootroot00000000000000package assertions import ( "encoding/json" "fmt" "github.com/smartystreets/assertions/internal/go-render/render" ) type Serializer interface { serialize(expected, actual interface{}, message string) string serializeDetailed(expected, actual interface{}, message string) string } type failureSerializer struct{} func (self *failureSerializer) serializeDetailed(expected, actual interface{}, message string) string { view := FailureView{ Message: message, Expected: render.Render(expected), Actual: render.Render(actual), } serialized, err := json.Marshal(view) if err != nil { return message } return string(serialized) } func (self *failureSerializer) serialize(expected, actual interface{}, message string) string { view := FailureView{ Message: message, Expected: fmt.Sprintf("%+v", expected), Actual: fmt.Sprintf("%+v", actual), } serialized, err := json.Marshal(view) if err != nil { return message } return string(serialized) } func newSerializer() *failureSerializer { return &failureSerializer{} } /////////////////////////////////////////////////////////////////////////////// // This struct is also declared in github.com/smartystreets/goconvey/convey/reporting. // The json struct tags should be equal in both declarations. type FailureView struct { Message string `json:"Message"` Expected string `json:"Expected"` Actual string `json:"Actual"` } /////////////////////////////////////////////////////// // noopSerializer just gives back the original message. This is useful when we are using // the assertions from a context other than the web UI, that requires the JSON structure // provided by the failureSerializer. type noopSerializer struct{} func (self *noopSerializer) serialize(expected, actual interface{}, message string) string { return message } func (self *noopSerializer) serializeDetailed(expected, actual interface{}, message string) string { return message } mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/serializer_test.go000066400000000000000000000017071321131462300311700ustar00rootroot00000000000000package assertions import ( "encoding/json" "fmt" "testing" ) func TestSerializerCreatesSerializedVersionOfAssertionResult(t *testing.T) { thing1 := Thing1{"Hi"} thing2 := Thing2{"Bye"} message := "Super-hip failure message." serializer := newSerializer() actualResult := serializer.serialize(thing1, thing2, message) expectedResult, _ := json.Marshal(FailureView{ Message: message, Expected: fmt.Sprintf("%+v", thing1), Actual: fmt.Sprintf("%+v", thing2), }) if actualResult != string(expectedResult) { t.Errorf("\nExpected: %s\nActual: %s", string(expectedResult), actualResult) } actualResult = serializer.serializeDetailed(thing1, thing2, message) expectedResult, _ = json.Marshal(FailureView{ Message: message, Expected: fmt.Sprintf("%#v", thing1), Actual: fmt.Sprintf("%#v", thing2), }) if actualResult != string(expectedResult) { t.Errorf("\nExpected: %s\nActual: %s", string(expectedResult), actualResult) } } mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/should/000077500000000000000000000000001321131462300267225ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/should/should.go000066400000000000000000000060061321131462300305510ustar00rootroot00000000000000// package should is simply a rewording of the assertion // functions in the assertions package. package should import "github.com/smartystreets/assertions" var ( Equal = assertions.ShouldEqual NotEqual = assertions.ShouldNotEqual AlmostEqual = assertions.ShouldAlmostEqual NotAlmostEqual = assertions.ShouldNotAlmostEqual Resemble = assertions.ShouldResemble NotResemble = assertions.ShouldNotResemble PointTo = assertions.ShouldPointTo NotPointTo = assertions.ShouldNotPointTo BeNil = assertions.ShouldBeNil NotBeNil = assertions.ShouldNotBeNil BeTrue = assertions.ShouldBeTrue BeFalse = assertions.ShouldBeFalse BeZeroValue = assertions.ShouldBeZeroValue BeGreaterThan = assertions.ShouldBeGreaterThan BeGreaterThanOrEqualTo = assertions.ShouldBeGreaterThanOrEqualTo BeLessThan = assertions.ShouldBeLessThan BeLessThanOrEqualTo = assertions.ShouldBeLessThanOrEqualTo BeBetween = assertions.ShouldBeBetween NotBeBetween = assertions.ShouldNotBeBetween BeBetweenOrEqual = assertions.ShouldBeBetweenOrEqual NotBeBetweenOrEqual = assertions.ShouldNotBeBetweenOrEqual Contain = assertions.ShouldContain NotContain = assertions.ShouldNotContain ContainKey = assertions.ShouldContainKey NotContainKey = assertions.ShouldNotContainKey BeIn = assertions.ShouldBeIn NotBeIn = assertions.ShouldNotBeIn BeEmpty = assertions.ShouldBeEmpty NotBeEmpty = assertions.ShouldNotBeEmpty HaveLength = assertions.ShouldHaveLength StartWith = assertions.ShouldStartWith NotStartWith = assertions.ShouldNotStartWith EndWith = assertions.ShouldEndWith NotEndWith = assertions.ShouldNotEndWith BeBlank = assertions.ShouldBeBlank NotBeBlank = assertions.ShouldNotBeBlank ContainSubstring = assertions.ShouldContainSubstring NotContainSubstring = assertions.ShouldNotContainSubstring EqualWithout = assertions.ShouldEqualWithout EqualTrimSpace = assertions.ShouldEqualTrimSpace Panic = assertions.ShouldPanic NotPanic = assertions.ShouldNotPanic PanicWith = assertions.ShouldPanicWith NotPanicWith = assertions.ShouldNotPanicWith HaveSameTypeAs = assertions.ShouldHaveSameTypeAs NotHaveSameTypeAs = assertions.ShouldNotHaveSameTypeAs Implement = assertions.ShouldImplement NotImplement = assertions.ShouldNotImplement HappenBefore = assertions.ShouldHappenBefore HappenOnOrBefore = assertions.ShouldHappenOnOrBefore HappenAfter = assertions.ShouldHappenAfter HappenOnOrAfter = assertions.ShouldHappenOnOrAfter HappenBetween = assertions.ShouldHappenBetween HappenOnOrBetween = assertions.ShouldHappenOnOrBetween NotHappenOnOrBetween = assertions.ShouldNotHappenOnOrBetween HappenWithin = assertions.ShouldHappenWithin NotHappenWithin = assertions.ShouldNotHappenWithin BeChronological = assertions.ShouldBeChronological ) mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/strings.go000066400000000000000000000155551321131462300274570ustar00rootroot00000000000000package assertions import ( "fmt" "reflect" "strings" ) // ShouldStartWith receives exactly 2 string parameters and ensures that the first starts with the second. func ShouldStartWith(actual interface{}, expected ...interface{}) string { if fail := need(1, expected); fail != success { return fail } value, valueIsString := actual.(string) prefix, prefixIsString := expected[0].(string) if !valueIsString || !prefixIsString { return fmt.Sprintf(shouldBothBeStrings, reflect.TypeOf(actual), reflect.TypeOf(expected[0])) } return shouldStartWith(value, prefix) } func shouldStartWith(value, prefix string) string { if !strings.HasPrefix(value, prefix) { shortval := value if len(shortval) > len(prefix) { shortval = shortval[:len(prefix)] + "..." } return serializer.serialize(prefix, shortval, fmt.Sprintf(shouldHaveStartedWith, value, prefix)) } return success } // ShouldNotStartWith receives exactly 2 string parameters and ensures that the first does not start with the second. func ShouldNotStartWith(actual interface{}, expected ...interface{}) string { if fail := need(1, expected); fail != success { return fail } value, valueIsString := actual.(string) prefix, prefixIsString := expected[0].(string) if !valueIsString || !prefixIsString { return fmt.Sprintf(shouldBothBeStrings, reflect.TypeOf(actual), reflect.TypeOf(expected[0])) } return shouldNotStartWith(value, prefix) } func shouldNotStartWith(value, prefix string) string { if strings.HasPrefix(value, prefix) { if value == "" { value = "" } if prefix == "" { prefix = "" } return fmt.Sprintf(shouldNotHaveStartedWith, value, prefix) } return success } // ShouldEndWith receives exactly 2 string parameters and ensures that the first ends with the second. func ShouldEndWith(actual interface{}, expected ...interface{}) string { if fail := need(1, expected); fail != success { return fail } value, valueIsString := actual.(string) suffix, suffixIsString := expected[0].(string) if !valueIsString || !suffixIsString { return fmt.Sprintf(shouldBothBeStrings, reflect.TypeOf(actual), reflect.TypeOf(expected[0])) } return shouldEndWith(value, suffix) } func shouldEndWith(value, suffix string) string { if !strings.HasSuffix(value, suffix) { shortval := value if len(shortval) > len(suffix) { shortval = "..." + shortval[len(shortval)-len(suffix):] } return serializer.serialize(suffix, shortval, fmt.Sprintf(shouldHaveEndedWith, value, suffix)) } return success } // ShouldEndWith receives exactly 2 string parameters and ensures that the first does not end with the second. func ShouldNotEndWith(actual interface{}, expected ...interface{}) string { if fail := need(1, expected); fail != success { return fail } value, valueIsString := actual.(string) suffix, suffixIsString := expected[0].(string) if !valueIsString || !suffixIsString { return fmt.Sprintf(shouldBothBeStrings, reflect.TypeOf(actual), reflect.TypeOf(expected[0])) } return shouldNotEndWith(value, suffix) } func shouldNotEndWith(value, suffix string) string { if strings.HasSuffix(value, suffix) { if value == "" { value = "" } if suffix == "" { suffix = "" } return fmt.Sprintf(shouldNotHaveEndedWith, value, suffix) } return success } // ShouldContainSubstring receives exactly 2 string parameters and ensures that the first contains the second as a substring. func ShouldContainSubstring(actual interface{}, expected ...interface{}) string { if fail := need(1, expected); fail != success { return fail } long, longOk := actual.(string) short, shortOk := expected[0].(string) if !longOk || !shortOk { return fmt.Sprintf(shouldBothBeStrings, reflect.TypeOf(actual), reflect.TypeOf(expected[0])) } if !strings.Contains(long, short) { return serializer.serialize(expected[0], actual, fmt.Sprintf(shouldHaveContainedSubstring, long, short)) } return success } // ShouldNotContainSubstring receives exactly 2 string parameters and ensures that the first does NOT contain the second as a substring. func ShouldNotContainSubstring(actual interface{}, expected ...interface{}) string { if fail := need(1, expected); fail != success { return fail } long, longOk := actual.(string) short, shortOk := expected[0].(string) if !longOk || !shortOk { return fmt.Sprintf(shouldBothBeStrings, reflect.TypeOf(actual), reflect.TypeOf(expected[0])) } if strings.Contains(long, short) { return fmt.Sprintf(shouldNotHaveContainedSubstring, long, short) } return success } // ShouldBeBlank receives exactly 1 string parameter and ensures that it is equal to "". func ShouldBeBlank(actual interface{}, expected ...interface{}) string { if fail := need(0, expected); fail != success { return fail } value, ok := actual.(string) if !ok { return fmt.Sprintf(shouldBeString, reflect.TypeOf(actual)) } if value != "" { return serializer.serialize("", value, fmt.Sprintf(shouldHaveBeenBlank, value)) } return success } // ShouldNotBeBlank receives exactly 1 string parameter and ensures that it is equal to "". func ShouldNotBeBlank(actual interface{}, expected ...interface{}) string { if fail := need(0, expected); fail != success { return fail } value, ok := actual.(string) if !ok { return fmt.Sprintf(shouldBeString, reflect.TypeOf(actual)) } if value == "" { return shouldNotHaveBeenBlank } return success } // ShouldEqualWithout receives exactly 3 string parameters and ensures that the first is equal to the second // after removing all instances of the third from the first using strings.Replace(first, third, "", -1). func ShouldEqualWithout(actual interface{}, expected ...interface{}) string { if fail := need(2, expected); fail != success { return fail } actualString, ok1 := actual.(string) expectedString, ok2 := expected[0].(string) replace, ok3 := expected[1].(string) if !ok1 || !ok2 || !ok3 { return fmt.Sprintf(shouldAllBeStrings, []reflect.Type{ reflect.TypeOf(actual), reflect.TypeOf(expected[0]), reflect.TypeOf(expected[1]), }) } replaced := strings.Replace(actualString, replace, "", -1) if replaced == expectedString { return "" } return fmt.Sprintf("Expected '%s' to equal '%s' but without any '%s' (but it didn't).", actualString, expectedString, replace) } // ShouldEqualTrimSpace receives exactly 2 string parameters and ensures that the first is equal to the second // after removing all leading and trailing whitespace using strings.TrimSpace(first). func ShouldEqualTrimSpace(actual interface{}, expected ...interface{}) string { if fail := need(1, expected); fail != success { return fail } actualString, valueIsString := actual.(string) _, value2IsString := expected[0].(string) if !valueIsString || !value2IsString { return fmt.Sprintf(shouldBothBeStrings, reflect.TypeOf(actual), reflect.TypeOf(expected[0])) } actualString = strings.TrimSpace(actualString) return ShouldEqual(actualString, expected[0]) } mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/strings_test.go000066400000000000000000000143311321131462300305050ustar00rootroot00000000000000package assertions import "testing" func TestShouldStartWith(t *testing.T) { serializer = newFakeSerializer() fail(t, so("", ShouldStartWith), "This assertion requires exactly 1 comparison values (you provided 0).") fail(t, so("", ShouldStartWith, "asdf", "asdf"), "This assertion requires exactly 1 comparison values (you provided 2).") pass(t, so("", ShouldStartWith, "")) fail(t, so("", ShouldStartWith, "x"), "x||Expected '' to start with 'x' (but it didn't)!") pass(t, so("abc", ShouldStartWith, "abc")) fail(t, so("abc", ShouldStartWith, "abcd"), "abcd|abc|Expected 'abc' to start with 'abcd' (but it didn't)!") pass(t, so("superman", ShouldStartWith, "super")) fail(t, so("superman", ShouldStartWith, "bat"), "bat|sup...|Expected 'superman' to start with 'bat' (but it didn't)!") fail(t, so("superman", ShouldStartWith, "man"), "man|sup...|Expected 'superman' to start with 'man' (but it didn't)!") fail(t, so(1, ShouldStartWith, 2), "Both arguments to this assertion must be strings (you provided int and int).") } func TestShouldNotStartWith(t *testing.T) { fail(t, so("", ShouldNotStartWith), "This assertion requires exactly 1 comparison values (you provided 0).") fail(t, so("", ShouldNotStartWith, "asdf", "asdf"), "This assertion requires exactly 1 comparison values (you provided 2).") fail(t, so("", ShouldNotStartWith, ""), "Expected '' NOT to start with '' (but it did)!") fail(t, so("superman", ShouldNotStartWith, "super"), "Expected 'superman' NOT to start with 'super' (but it did)!") pass(t, so("superman", ShouldNotStartWith, "bat")) pass(t, so("superman", ShouldNotStartWith, "man")) fail(t, so(1, ShouldNotStartWith, 2), "Both arguments to this assertion must be strings (you provided int and int).") } func TestShouldEndWith(t *testing.T) { serializer = newFakeSerializer() fail(t, so("", ShouldEndWith), "This assertion requires exactly 1 comparison values (you provided 0).") fail(t, so("", ShouldEndWith, "", ""), "This assertion requires exactly 1 comparison values (you provided 2).") pass(t, so("", ShouldEndWith, "")) fail(t, so("", ShouldEndWith, "z"), "z||Expected '' to end with 'z' (but it didn't)!") pass(t, so("xyz", ShouldEndWith, "xyz")) fail(t, so("xyz", ShouldEndWith, "wxyz"), "wxyz|xyz|Expected 'xyz' to end with 'wxyz' (but it didn't)!") pass(t, so("superman", ShouldEndWith, "man")) fail(t, so("superman", ShouldEndWith, "super"), "super|...erman|Expected 'superman' to end with 'super' (but it didn't)!") fail(t, so("superman", ShouldEndWith, "blah"), "blah|...rman|Expected 'superman' to end with 'blah' (but it didn't)!") fail(t, so(1, ShouldEndWith, 2), "Both arguments to this assertion must be strings (you provided int and int).") } func TestShouldNotEndWith(t *testing.T) { fail(t, so("", ShouldNotEndWith), "This assertion requires exactly 1 comparison values (you provided 0).") fail(t, so("", ShouldNotEndWith, "", ""), "This assertion requires exactly 1 comparison values (you provided 2).") fail(t, so("", ShouldNotEndWith, ""), "Expected '' NOT to end with '' (but it did)!") fail(t, so("superman", ShouldNotEndWith, "man"), "Expected 'superman' NOT to end with 'man' (but it did)!") pass(t, so("superman", ShouldNotEndWith, "super")) fail(t, so(1, ShouldNotEndWith, 2), "Both arguments to this assertion must be strings (you provided int and int).") } func TestShouldContainSubstring(t *testing.T) { serializer = newFakeSerializer() fail(t, so("asdf", ShouldContainSubstring), "This assertion requires exactly 1 comparison values (you provided 0).") fail(t, so("asdf", ShouldContainSubstring, 1, 2, 3), "This assertion requires exactly 1 comparison values (you provided 3).") fail(t, so(123, ShouldContainSubstring, 23), "Both arguments to this assertion must be strings (you provided int and int).") pass(t, so("asdf", ShouldContainSubstring, "sd")) fail(t, so("qwer", ShouldContainSubstring, "sd"), "sd|qwer|Expected 'qwer' to contain substring 'sd' (but it didn't)!") } func TestShouldNotContainSubstring(t *testing.T) { fail(t, so("asdf", ShouldNotContainSubstring), "This assertion requires exactly 1 comparison values (you provided 0).") fail(t, so("asdf", ShouldNotContainSubstring, 1, 2, 3), "This assertion requires exactly 1 comparison values (you provided 3).") fail(t, so(123, ShouldNotContainSubstring, 23), "Both arguments to this assertion must be strings (you provided int and int).") pass(t, so("qwer", ShouldNotContainSubstring, "sd")) fail(t, so("asdf", ShouldNotContainSubstring, "sd"), "Expected 'asdf' NOT to contain substring 'sd' (but it did)!") } func TestShouldBeBlank(t *testing.T) { serializer = newFakeSerializer() fail(t, so("", ShouldBeBlank, "adsf"), "This assertion requires exactly 0 comparison values (you provided 1).") fail(t, so(1, ShouldBeBlank), "The argument to this assertion must be a string (you provided int).") fail(t, so("asdf", ShouldBeBlank), "|asdf|Expected 'asdf' to be blank (but it wasn't)!") pass(t, so("", ShouldBeBlank)) } func TestShouldNotBeBlank(t *testing.T) { fail(t, so("", ShouldNotBeBlank, "adsf"), "This assertion requires exactly 0 comparison values (you provided 1).") fail(t, so(1, ShouldNotBeBlank), "The argument to this assertion must be a string (you provided int).") fail(t, so("", ShouldNotBeBlank), "Expected value to NOT be blank (but it was)!") pass(t, so("asdf", ShouldNotBeBlank)) } func TestShouldEqualWithout(t *testing.T) { fail(t, so("", ShouldEqualWithout, ""), "This assertion requires exactly 2 comparison values (you provided 1).") fail(t, so(1, ShouldEqualWithout, 2, 3), "All arguments to this assertion must be strings (you provided: [int int int]).") fail(t, so("asdf", ShouldEqualWithout, "qwer", "q"), "Expected 'asdf' to equal 'qwer' but without any 'q' (but it didn't).") pass(t, so("asdf", ShouldEqualWithout, "df", "as")) } func TestShouldEqualTrimSpace(t *testing.T) { fail(t, so(" asdf ", ShouldEqualTrimSpace), "This assertion requires exactly 1 comparison values (you provided 0).") fail(t, so(1, ShouldEqualTrimSpace, 2), "Both arguments to this assertion must be strings (you provided int and int).") fail(t, so("asdf", ShouldEqualTrimSpace, "qwer"), "qwer|asdf|Expected: 'qwer' Actual: 'asdf' (Should be equal)") pass(t, so(" asdf\t\n", ShouldEqualTrimSpace, "asdf")) } mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/time.go000066400000000000000000000144351321131462300267200ustar00rootroot00000000000000package assertions import ( "fmt" "time" ) // ShouldHappenBefore receives exactly 2 time.Time arguments and asserts that the first happens before the second. func ShouldHappenBefore(actual interface{}, expected ...interface{}) string { if fail := need(1, expected); fail != success { return fail } actualTime, firstOk := actual.(time.Time) expectedTime, secondOk := expected[0].(time.Time) if !firstOk || !secondOk { return shouldUseTimes } if !actualTime.Before(expectedTime) { return fmt.Sprintf(shouldHaveHappenedBefore, actualTime, expectedTime, actualTime.Sub(expectedTime)) } return success } // ShouldHappenOnOrBefore receives exactly 2 time.Time arguments and asserts that the first happens on or before the second. func ShouldHappenOnOrBefore(actual interface{}, expected ...interface{}) string { if fail := need(1, expected); fail != success { return fail } actualTime, firstOk := actual.(time.Time) expectedTime, secondOk := expected[0].(time.Time) if !firstOk || !secondOk { return shouldUseTimes } if actualTime.Equal(expectedTime) { return success } return ShouldHappenBefore(actualTime, expectedTime) } // ShouldHappenAfter receives exactly 2 time.Time arguments and asserts that the first happens after the second. func ShouldHappenAfter(actual interface{}, expected ...interface{}) string { if fail := need(1, expected); fail != success { return fail } actualTime, firstOk := actual.(time.Time) expectedTime, secondOk := expected[0].(time.Time) if !firstOk || !secondOk { return shouldUseTimes } if !actualTime.After(expectedTime) { return fmt.Sprintf(shouldHaveHappenedAfter, actualTime, expectedTime, expectedTime.Sub(actualTime)) } return success } // ShouldHappenOnOrAfter receives exactly 2 time.Time arguments and asserts that the first happens on or after the second. func ShouldHappenOnOrAfter(actual interface{}, expected ...interface{}) string { if fail := need(1, expected); fail != success { return fail } actualTime, firstOk := actual.(time.Time) expectedTime, secondOk := expected[0].(time.Time) if !firstOk || !secondOk { return shouldUseTimes } if actualTime.Equal(expectedTime) { return success } return ShouldHappenAfter(actualTime, expectedTime) } // ShouldHappenBetween receives exactly 3 time.Time arguments and asserts that the first happens between (not on) the second and third. func ShouldHappenBetween(actual interface{}, expected ...interface{}) string { if fail := need(2, expected); fail != success { return fail } actualTime, firstOk := actual.(time.Time) min, secondOk := expected[0].(time.Time) max, thirdOk := expected[1].(time.Time) if !firstOk || !secondOk || !thirdOk { return shouldUseTimes } if !actualTime.After(min) { return fmt.Sprintf(shouldHaveHappenedBetween, actualTime, min, max, min.Sub(actualTime)) } if !actualTime.Before(max) { return fmt.Sprintf(shouldHaveHappenedBetween, actualTime, min, max, actualTime.Sub(max)) } return success } // ShouldHappenOnOrBetween receives exactly 3 time.Time arguments and asserts that the first happens between or on the second and third. func ShouldHappenOnOrBetween(actual interface{}, expected ...interface{}) string { if fail := need(2, expected); fail != success { return fail } actualTime, firstOk := actual.(time.Time) min, secondOk := expected[0].(time.Time) max, thirdOk := expected[1].(time.Time) if !firstOk || !secondOk || !thirdOk { return shouldUseTimes } if actualTime.Equal(min) || actualTime.Equal(max) { return success } return ShouldHappenBetween(actualTime, min, max) } // ShouldNotHappenOnOrBetween receives exactly 3 time.Time arguments and asserts that the first // does NOT happen between or on the second or third. func ShouldNotHappenOnOrBetween(actual interface{}, expected ...interface{}) string { if fail := need(2, expected); fail != success { return fail } actualTime, firstOk := actual.(time.Time) min, secondOk := expected[0].(time.Time) max, thirdOk := expected[1].(time.Time) if !firstOk || !secondOk || !thirdOk { return shouldUseTimes } if actualTime.Equal(min) || actualTime.Equal(max) { return fmt.Sprintf(shouldNotHaveHappenedOnOrBetween, actualTime, min, max) } if actualTime.After(min) && actualTime.Before(max) { return fmt.Sprintf(shouldNotHaveHappenedOnOrBetween, actualTime, min, max) } return success } // ShouldHappenWithin receives a time.Time, a time.Duration, and a time.Time (3 arguments) // and asserts that the first time.Time happens within or on the duration specified relative to // the other time.Time. func ShouldHappenWithin(actual interface{}, expected ...interface{}) string { if fail := need(2, expected); fail != success { return fail } actualTime, firstOk := actual.(time.Time) tolerance, secondOk := expected[0].(time.Duration) threshold, thirdOk := expected[1].(time.Time) if !firstOk || !secondOk || !thirdOk { return shouldUseDurationAndTime } min := threshold.Add(-tolerance) max := threshold.Add(tolerance) return ShouldHappenOnOrBetween(actualTime, min, max) } // ShouldNotHappenWithin receives a time.Time, a time.Duration, and a time.Time (3 arguments) // and asserts that the first time.Time does NOT happen within or on the duration specified relative to // the other time.Time. func ShouldNotHappenWithin(actual interface{}, expected ...interface{}) string { if fail := need(2, expected); fail != success { return fail } actualTime, firstOk := actual.(time.Time) tolerance, secondOk := expected[0].(time.Duration) threshold, thirdOk := expected[1].(time.Time) if !firstOk || !secondOk || !thirdOk { return shouldUseDurationAndTime } min := threshold.Add(-tolerance) max := threshold.Add(tolerance) return ShouldNotHappenOnOrBetween(actualTime, min, max) } // ShouldBeChronological receives a []time.Time slice and asserts that the are // in chronological order starting with the first time.Time as the earliest. func ShouldBeChronological(actual interface{}, expected ...interface{}) string { if fail := need(0, expected); fail != success { return fail } times, ok := actual.([]time.Time) if !ok { return shouldUseTimeSlice } var previous time.Time for i, current := range times { if i > 0 && current.Before(previous) { return fmt.Sprintf(shouldHaveBeenChronological, i, i-1, previous.String(), i, current.String()) } previous = current } return "" } mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/time_test.go000066400000000000000000000247661321131462300277670ustar00rootroot00000000000000package assertions import ( "fmt" "testing" "time" ) func TestShouldHappenBefore(t *testing.T) { fail(t, so(0, ShouldHappenBefore), "This assertion requires exactly 1 comparison values (you provided 0).") fail(t, so(0, ShouldHappenBefore, 1, 2, 3), "This assertion requires exactly 1 comparison values (you provided 3).") fail(t, so(0, ShouldHappenBefore, 1), shouldUseTimes) fail(t, so(0, ShouldHappenBefore, time.Now()), shouldUseTimes) fail(t, so(time.Now(), ShouldHappenBefore, 0), shouldUseTimes) fail(t, so(january3, ShouldHappenBefore, january1), fmt.Sprintf("Expected '%s' to happen before '%s' (it happened '48h0m0s' after)!", pretty(january3), pretty(january1))) fail(t, so(january3, ShouldHappenBefore, january3), fmt.Sprintf("Expected '%s' to happen before '%s' (it happened '0' after)!", pretty(january3), pretty(january3))) pass(t, so(january1, ShouldHappenBefore, january3)) } func TestShouldHappenOnOrBefore(t *testing.T) { fail(t, so(0, ShouldHappenOnOrBefore), "This assertion requires exactly 1 comparison values (you provided 0).") fail(t, so(0, ShouldHappenOnOrBefore, 1, 2, 3), "This assertion requires exactly 1 comparison values (you provided 3).") fail(t, so(0, ShouldHappenOnOrBefore, 1), shouldUseTimes) fail(t, so(0, ShouldHappenOnOrBefore, time.Now()), shouldUseTimes) fail(t, so(time.Now(), ShouldHappenOnOrBefore, 0), shouldUseTimes) fail(t, so(january3, ShouldHappenOnOrBefore, january1), fmt.Sprintf("Expected '%s' to happen before '%s' (it happened '48h0m0s' after)!", pretty(january3), pretty(january1))) pass(t, so(january3, ShouldHappenOnOrBefore, january3)) pass(t, so(january1, ShouldHappenOnOrBefore, january3)) } func TestShouldHappenAfter(t *testing.T) { fail(t, so(0, ShouldHappenAfter), "This assertion requires exactly 1 comparison values (you provided 0).") fail(t, so(0, ShouldHappenAfter, 1, 2, 3), "This assertion requires exactly 1 comparison values (you provided 3).") fail(t, so(0, ShouldHappenAfter, 1), shouldUseTimes) fail(t, so(0, ShouldHappenAfter, time.Now()), shouldUseTimes) fail(t, so(time.Now(), ShouldHappenAfter, 0), shouldUseTimes) fail(t, so(january1, ShouldHappenAfter, january2), fmt.Sprintf("Expected '%s' to happen after '%s' (it happened '24h0m0s' before)!", pretty(january1), pretty(january2))) fail(t, so(january1, ShouldHappenAfter, january1), fmt.Sprintf("Expected '%s' to happen after '%s' (it happened '0' before)!", pretty(january1), pretty(january1))) pass(t, so(january3, ShouldHappenAfter, january1)) } func TestShouldHappenOnOrAfter(t *testing.T) { fail(t, so(0, ShouldHappenOnOrAfter), "This assertion requires exactly 1 comparison values (you provided 0).") fail(t, so(0, ShouldHappenOnOrAfter, 1, 2, 3), "This assertion requires exactly 1 comparison values (you provided 3).") fail(t, so(0, ShouldHappenOnOrAfter, 1), shouldUseTimes) fail(t, so(0, ShouldHappenOnOrAfter, time.Now()), shouldUseTimes) fail(t, so(time.Now(), ShouldHappenOnOrAfter, 0), shouldUseTimes) fail(t, so(january1, ShouldHappenOnOrAfter, january2), fmt.Sprintf("Expected '%s' to happen after '%s' (it happened '24h0m0s' before)!", pretty(january1), pretty(january2))) pass(t, so(january1, ShouldHappenOnOrAfter, january1)) pass(t, so(january3, ShouldHappenOnOrAfter, january1)) } func TestShouldHappenBetween(t *testing.T) { fail(t, so(0, ShouldHappenBetween), "This assertion requires exactly 2 comparison values (you provided 0).") fail(t, so(0, ShouldHappenBetween, 1, 2, 3), "This assertion requires exactly 2 comparison values (you provided 3).") fail(t, so(0, ShouldHappenBetween, 1, 2), shouldUseTimes) fail(t, so(0, ShouldHappenBetween, time.Now(), time.Now()), shouldUseTimes) fail(t, so(time.Now(), ShouldHappenBetween, 0, time.Now()), shouldUseTimes) fail(t, so(time.Now(), ShouldHappenBetween, time.Now(), 9), shouldUseTimes) fail(t, so(january1, ShouldHappenBetween, january2, january4), fmt.Sprintf("Expected '%s' to happen between '%s' and '%s' (it happened '24h0m0s' outside threshold)!", pretty(january1), pretty(january2), pretty(january4))) fail(t, so(january2, ShouldHappenBetween, january2, january4), fmt.Sprintf("Expected '%s' to happen between '%s' and '%s' (it happened '0' outside threshold)!", pretty(january2), pretty(january2), pretty(january4))) pass(t, so(january3, ShouldHappenBetween, january2, january4)) fail(t, so(january4, ShouldHappenBetween, january2, january4), fmt.Sprintf("Expected '%s' to happen between '%s' and '%s' (it happened '0' outside threshold)!", pretty(january4), pretty(january2), pretty(january4))) fail(t, so(january5, ShouldHappenBetween, january2, january4), fmt.Sprintf("Expected '%s' to happen between '%s' and '%s' (it happened '24h0m0s' outside threshold)!", pretty(january5), pretty(january2), pretty(january4))) } func TestShouldHappenOnOrBetween(t *testing.T) { fail(t, so(0, ShouldHappenOnOrBetween), "This assertion requires exactly 2 comparison values (you provided 0).") fail(t, so(0, ShouldHappenOnOrBetween, 1, 2, 3), "This assertion requires exactly 2 comparison values (you provided 3).") fail(t, so(0, ShouldHappenOnOrBetween, 1, time.Now()), shouldUseTimes) fail(t, so(0, ShouldHappenOnOrBetween, time.Now(), 1), shouldUseTimes) fail(t, so(time.Now(), ShouldHappenOnOrBetween, 0, 1), shouldUseTimes) fail(t, so(january1, ShouldHappenOnOrBetween, january2, january4), fmt.Sprintf("Expected '%s' to happen between '%s' and '%s' (it happened '24h0m0s' outside threshold)!", pretty(january1), pretty(january2), pretty(january4))) pass(t, so(january2, ShouldHappenOnOrBetween, january2, january4)) pass(t, so(january3, ShouldHappenOnOrBetween, january2, january4)) pass(t, so(january4, ShouldHappenOnOrBetween, january2, january4)) fail(t, so(january5, ShouldHappenOnOrBetween, january2, january4), fmt.Sprintf("Expected '%s' to happen between '%s' and '%s' (it happened '24h0m0s' outside threshold)!", pretty(january5), pretty(january2), pretty(january4))) } func TestShouldNotHappenOnOrBetween(t *testing.T) { fail(t, so(0, ShouldNotHappenOnOrBetween), "This assertion requires exactly 2 comparison values (you provided 0).") fail(t, so(0, ShouldNotHappenOnOrBetween, 1, 2, 3), "This assertion requires exactly 2 comparison values (you provided 3).") fail(t, so(0, ShouldNotHappenOnOrBetween, 1, time.Now()), shouldUseTimes) fail(t, so(0, ShouldNotHappenOnOrBetween, time.Now(), 1), shouldUseTimes) fail(t, so(time.Now(), ShouldNotHappenOnOrBetween, 0, 1), shouldUseTimes) pass(t, so(january1, ShouldNotHappenOnOrBetween, january2, january4)) fail(t, so(january2, ShouldNotHappenOnOrBetween, january2, january4), fmt.Sprintf("Expected '%s' to NOT happen on or between '%s' and '%s' (but it did)!", pretty(january2), pretty(january2), pretty(january4))) fail(t, so(january3, ShouldNotHappenOnOrBetween, january2, january4), fmt.Sprintf("Expected '%s' to NOT happen on or between '%s' and '%s' (but it did)!", pretty(january3), pretty(january2), pretty(january4))) fail(t, so(january4, ShouldNotHappenOnOrBetween, january2, january4), fmt.Sprintf("Expected '%s' to NOT happen on or between '%s' and '%s' (but it did)!", pretty(january4), pretty(january2), pretty(january4))) pass(t, so(january5, ShouldNotHappenOnOrBetween, january2, january4)) } func TestShouldHappenWithin(t *testing.T) { fail(t, so(0, ShouldHappenWithin), "This assertion requires exactly 2 comparison values (you provided 0).") fail(t, so(0, ShouldHappenWithin, 1, 2, 3), "This assertion requires exactly 2 comparison values (you provided 3).") fail(t, so(0, ShouldHappenWithin, 1, 2), shouldUseDurationAndTime) fail(t, so(0, ShouldHappenWithin, oneDay, time.Now()), shouldUseDurationAndTime) fail(t, so(time.Now(), ShouldHappenWithin, 0, time.Now()), shouldUseDurationAndTime) fail(t, so(january1, ShouldHappenWithin, oneDay, january3), fmt.Sprintf("Expected '%s' to happen between '%s' and '%s' (it happened '24h0m0s' outside threshold)!", pretty(january1), pretty(january2), pretty(january4))) pass(t, so(january2, ShouldHappenWithin, oneDay, january3)) pass(t, so(january3, ShouldHappenWithin, oneDay, january3)) pass(t, so(january4, ShouldHappenWithin, oneDay, january3)) fail(t, so(january5, ShouldHappenWithin, oneDay, january3), fmt.Sprintf("Expected '%s' to happen between '%s' and '%s' (it happened '24h0m0s' outside threshold)!", pretty(january5), pretty(january2), pretty(january4))) } func TestShouldNotHappenWithin(t *testing.T) { fail(t, so(0, ShouldNotHappenWithin), "This assertion requires exactly 2 comparison values (you provided 0).") fail(t, so(0, ShouldNotHappenWithin, 1, 2, 3), "This assertion requires exactly 2 comparison values (you provided 3).") fail(t, so(0, ShouldNotHappenWithin, 1, 2), shouldUseDurationAndTime) fail(t, so(0, ShouldNotHappenWithin, oneDay, time.Now()), shouldUseDurationAndTime) fail(t, so(time.Now(), ShouldNotHappenWithin, 0, time.Now()), shouldUseDurationAndTime) pass(t, so(january1, ShouldNotHappenWithin, oneDay, january3)) fail(t, so(january2, ShouldNotHappenWithin, oneDay, january3), fmt.Sprintf("Expected '%s' to NOT happen on or between '%s' and '%s' (but it did)!", pretty(january2), pretty(january2), pretty(january4))) fail(t, so(january3, ShouldNotHappenWithin, oneDay, january3), fmt.Sprintf("Expected '%s' to NOT happen on or between '%s' and '%s' (but it did)!", pretty(january3), pretty(january2), pretty(january4))) fail(t, so(january4, ShouldNotHappenWithin, oneDay, january3), fmt.Sprintf("Expected '%s' to NOT happen on or between '%s' and '%s' (but it did)!", pretty(january4), pretty(january2), pretty(january4))) pass(t, so(january5, ShouldNotHappenWithin, oneDay, january3)) } func TestShouldBeChronological(t *testing.T) { fail(t, so(0, ShouldBeChronological, 1, 2, 3), "This assertion requires exactly 0 comparison values (you provided 3).") fail(t, so(0, ShouldBeChronological), shouldUseTimeSlice) fail(t, so([]time.Time{january5, january1}, ShouldBeChronological), "The 'Time' at index [1] should have happened after the previous one (but it didn't!):\n [0]: 2013-01-05 00:00:00 +0000 UTC\n [1]: 2013-01-01 00:00:00 +0000 UTC (see, it happened before!)") pass(t, so([]time.Time{january1, january2, january3, january4, january5}, ShouldBeChronological)) } const layout = "2006-01-02 15:04" var january1, _ = time.Parse(layout, "2013-01-01 00:00") var january2, _ = time.Parse(layout, "2013-01-02 00:00") var january3, _ = time.Parse(layout, "2013-01-03 00:00") var january4, _ = time.Parse(layout, "2013-01-04 00:00") var january5, _ = time.Parse(layout, "2013-01-05 00:00") var oneDay, _ = time.ParseDuration("24h0m0s") var twoDays, _ = time.ParseDuration("48h0m0s") func pretty(t time.Time) string { return fmt.Sprintf("%v", t) } mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/type.go000066400000000000000000000061451321131462300267420ustar00rootroot00000000000000package assertions import ( "fmt" "reflect" ) // ShouldHaveSameTypeAs receives exactly two parameters and compares their underlying types for equality. func ShouldHaveSameTypeAs(actual interface{}, expected ...interface{}) string { if fail := need(1, expected); fail != success { return fail } first := reflect.TypeOf(actual) second := reflect.TypeOf(expected[0]) if equal := ShouldEqual(first, second); equal != success { return serializer.serialize(second, first, fmt.Sprintf(shouldHaveBeenA, actual, second, first)) } return success } // ShouldNotHaveSameTypeAs receives exactly two parameters and compares their underlying types for inequality. func ShouldNotHaveSameTypeAs(actual interface{}, expected ...interface{}) string { if fail := need(1, expected); fail != success { return fail } first := reflect.TypeOf(actual) second := reflect.TypeOf(expected[0]) if equal := ShouldEqual(first, second); equal == success { return fmt.Sprintf(shouldNotHaveBeenA, actual, second) } return success } // ShouldImplement receives exactly two parameters and ensures // that the first implements the interface type of the second. func ShouldImplement(actual interface{}, expectedList ...interface{}) string { if fail := need(1, expectedList); fail != success { return fail } expected := expectedList[0] if fail := ShouldBeNil(expected); fail != success { return shouldCompareWithInterfacePointer } if fail := ShouldNotBeNil(actual); fail != success { return shouldNotBeNilActual } var actualType reflect.Type if reflect.TypeOf(actual).Kind() != reflect.Ptr { actualType = reflect.PtrTo(reflect.TypeOf(actual)) } else { actualType = reflect.TypeOf(actual) } expectedType := reflect.TypeOf(expected) if fail := ShouldNotBeNil(expectedType); fail != success { return shouldCompareWithInterfacePointer } expectedInterface := expectedType.Elem() if actualType == nil { return fmt.Sprintf(shouldHaveImplemented, expectedInterface, actual) } if !actualType.Implements(expectedInterface) { return fmt.Sprintf(shouldHaveImplemented, expectedInterface, actualType) } return success } // ShouldNotImplement receives exactly two parameters and ensures // that the first does NOT implement the interface type of the second. func ShouldNotImplement(actual interface{}, expectedList ...interface{}) string { if fail := need(1, expectedList); fail != success { return fail } expected := expectedList[0] if fail := ShouldBeNil(expected); fail != success { return shouldCompareWithInterfacePointer } if fail := ShouldNotBeNil(actual); fail != success { return shouldNotBeNilActual } var actualType reflect.Type if reflect.TypeOf(actual).Kind() != reflect.Ptr { actualType = reflect.PtrTo(reflect.TypeOf(actual)) } else { actualType = reflect.TypeOf(actual) } expectedType := reflect.TypeOf(expected) if fail := ShouldNotBeNil(expectedType); fail != success { return shouldCompareWithInterfacePointer } expectedInterface := expectedType.Elem() if actualType.Implements(expectedInterface) { return fmt.Sprintf(shouldNotHaveImplemented, actualType, expectedInterface) } return success } mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/type_test.go000066400000000000000000000075501321131462300300020ustar00rootroot00000000000000package assertions import ( "bytes" "io" "net/http" "testing" ) func TestShouldHaveSameTypeAs(t *testing.T) { serializer = newFakeSerializer() fail(t, so(1, ShouldHaveSameTypeAs), "This assertion requires exactly 1 comparison values (you provided 0).") fail(t, so(1, ShouldHaveSameTypeAs, 1, 2, 3), "This assertion requires exactly 1 comparison values (you provided 3).") fail(t, so(nil, ShouldHaveSameTypeAs, 0), "int||Expected '' to be: 'int' (but was: '')!") fail(t, so(1, ShouldHaveSameTypeAs, "asdf"), "string|int|Expected '1' to be: 'string' (but was: 'int')!") pass(t, so(1, ShouldHaveSameTypeAs, 0)) pass(t, so(nil, ShouldHaveSameTypeAs, nil)) } func TestShouldNotHaveSameTypeAs(t *testing.T) { fail(t, so(1, ShouldNotHaveSameTypeAs), "This assertion requires exactly 1 comparison values (you provided 0).") fail(t, so(1, ShouldNotHaveSameTypeAs, 1, 2, 3), "This assertion requires exactly 1 comparison values (you provided 3).") fail(t, so(1, ShouldNotHaveSameTypeAs, 0), "Expected '1' to NOT be: 'int' (but it was)!") fail(t, so(nil, ShouldNotHaveSameTypeAs, nil), "Expected '' to NOT be: '' (but it was)!") pass(t, so(nil, ShouldNotHaveSameTypeAs, 0)) pass(t, so(1, ShouldNotHaveSameTypeAs, "asdf")) } func TestShouldImplement(t *testing.T) { var ioReader *io.Reader = nil var response http.Response = http.Response{} var responsePtr *http.Response = new(http.Response) var reader = bytes.NewBufferString("") fail(t, so(reader, ShouldImplement), "This assertion requires exactly 1 comparison values (you provided 0).") fail(t, so(reader, ShouldImplement, ioReader, ioReader), "This assertion requires exactly 1 comparison values (you provided 2).") fail(t, so(reader, ShouldImplement, ioReader, ioReader, ioReader), "This assertion requires exactly 1 comparison values (you provided 3).") fail(t, so(reader, ShouldImplement, "foo"), shouldCompareWithInterfacePointer) fail(t, so(reader, ShouldImplement, 1), shouldCompareWithInterfacePointer) fail(t, so(reader, ShouldImplement, nil), shouldCompareWithInterfacePointer) fail(t, so(nil, ShouldImplement, ioReader), shouldNotBeNilActual) fail(t, so(1, ShouldImplement, ioReader), "Expected: 'io.Reader interface support'\nActual: '*int' does not implement the interface!") fail(t, so(response, ShouldImplement, ioReader), "Expected: 'io.Reader interface support'\nActual: '*http.Response' does not implement the interface!") fail(t, so(responsePtr, ShouldImplement, ioReader), "Expected: 'io.Reader interface support'\nActual: '*http.Response' does not implement the interface!") pass(t, so(reader, ShouldImplement, ioReader)) pass(t, so(reader, ShouldImplement, (*io.Reader)(nil))) } func TestShouldNotImplement(t *testing.T) { var ioReader *io.Reader = nil var response http.Response = http.Response{} var responsePtr *http.Response = new(http.Response) var reader io.Reader = bytes.NewBufferString("") fail(t, so(reader, ShouldNotImplement), "This assertion requires exactly 1 comparison values (you provided 0).") fail(t, so(reader, ShouldNotImplement, ioReader, ioReader), "This assertion requires exactly 1 comparison values (you provided 2).") fail(t, so(reader, ShouldNotImplement, ioReader, ioReader, ioReader), "This assertion requires exactly 1 comparison values (you provided 3).") fail(t, so(reader, ShouldNotImplement, "foo"), shouldCompareWithInterfacePointer) fail(t, so(reader, ShouldNotImplement, 1), shouldCompareWithInterfacePointer) fail(t, so(reader, ShouldNotImplement, nil), shouldCompareWithInterfacePointer) fail(t, so(reader, ShouldNotImplement, ioReader), "Expected '*bytes.Buffer'\nto NOT implement 'io.Reader' (but it did)!") fail(t, so(nil, ShouldNotImplement, ioReader), shouldNotBeNilActual) pass(t, so(1, ShouldNotImplement, ioReader)) pass(t, so(response, ShouldNotImplement, ioReader)) pass(t, so(responsePtr, ShouldNotImplement, ioReader)) } mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/assertions/utilities_for_test.go000066400000000000000000000031451321131462300316760ustar00rootroot00000000000000package assertions import ( "fmt" "path" "runtime" "strings" "testing" ) func pass(t *testing.T, result string) { if result != success { _, file, line, _ := runtime.Caller(1) base := path.Base(file) t.Errorf("Expectation should have passed but failed (see %s: line %d): '%s'", base, line, result) } } func fail(t *testing.T, actual string, expected string) { actual = format(actual) expected = format(expected) if actual != expected { if actual == "" { actual = "(empty)" } _, file, line, _ := runtime.Caller(1) base := path.Base(file) t.Errorf("Expectation should have failed but passed (see %s: line %d). \nExpected: %s\nActual: %s\n", base, line, expected, actual) } } func format(message string) string { message = strings.Replace(message, "\n", " ", -1) for strings.Contains(message, " ") { message = strings.Replace(message, " ", " ", -1) } return message } type Thing1 struct { a string } type Thing2 struct { a string } type Thinger interface { Hi() } type Thing struct{} func (self *Thing) Hi() {} type IntAlias int type StringAlias string type StringSliceAlias []string type StringStringMapAlias map[string]string /******** FakeSerialzier ********/ type fakeSerializer struct{} func (self *fakeSerializer) serialize(expected, actual interface{}, message string) string { return fmt.Sprintf("%v|%v|%s", expected, actual, message) } func (self *fakeSerializer) serializeDetailed(expected, actual interface{}, message string) string { return fmt.Sprintf("%v|%v|%s", expected, actual, message) } func newFakeSerializer() *fakeSerializer { return new(fakeSerializer) } mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/000077500000000000000000000000001321131462300250635ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/.gitignore000066400000000000000000000001031321131462300270450ustar00rootroot00000000000000.DS_Store Thumbs.db examples/output.json web/client/reports/ /.ideamongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/.travis.yml000066400000000000000000000001761321131462300272000ustar00rootroot00000000000000language: go go: - 1.2 - 1.3 - 1.4 - 1.5 install: - go get -t ./... script: go test -short -v ./... sudo: false mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/CONTRIBUTING.md000066400000000000000000000031701321131462300273150ustar00rootroot00000000000000# Subject: GoConvey maintainers wanted We'd like to open the project up to additional maintainers who want to move the project forward in a meaningful way. We've spent significant time at SmartyStreets building GoConvey and it has perfectly met (and exceeded) all of our initial design specifications. We've used it to great effect. Being so well-matched to our development workflows at SmartyStreets, we haven't had a need to hack on it lately. This had been frustrating to many in the community who have ideas for the project and would like to see new features released (and some old bugs fixed). The release of Go 1.5 and the new vendoring experiment has been a source of confusion and hassle for those who have already upgraded and find that GoConvey needs to be brought up to speed. Comment below if you're interested. Preference will be given to those that have already contributed to the project. Checkout the issues listing if you need some ideas for contributing. GoConvey is a popular 2-pronged, open-source github project (1,600+ stargazers, 100+ forks): - A package you import in your test code that allows you to write BDD-style tests. - An executable that runs a local web server which displays auto-updating test results in a web browser. ---- - http://goconvey.co/ - https://github.com/smartystreets/goconvey - https://github.com/smartystreets/goconvey/wiki _I should mention that the [assertions package](https://github.com/smartystreets/assertions) imported by the convey package is used by other projects at SmartyStreets and so we will be continuing to maintain that project internally._ We hope to hear from you soon. Thanks! mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/LICENSE.md000066400000000000000000000024051321131462300264700ustar00rootroot00000000000000Copyright (c) 2014 SmartyStreets, LLC 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. NOTE: Various optional and subordinate components carry their own licensing requirements and restrictions. Use of those components is subject to the terms and conditions outlined the respective license of each component. mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/README.md000066400000000000000000000071771321131462300263560ustar00rootroot00000000000000GoConvey is awesome Go testing ============================== [![Build Status](https://travis-ci.org/smartystreets/goconvey.png)](https://travis-ci.org/smartystreets/goconvey) [![GoDoc](https://godoc.org/github.com/smartystreets/goconvey?status.svg)](http://godoc.org/github.com/smartystreets/goconvey) Welcome to GoConvey, a yummy Go testing tool for gophers. Works with `go test`. Use it in the terminal or browser according to your viewing pleasure. **[View full feature tour.](http://goconvey.co)** **Features:** - Directly integrates with `go test` - Fully-automatic web UI (works with native Go tests, too) - Huge suite of regression tests - Shows test coverage (Go 1.2+) - Readable, colorized console output (understandable by any manager, IT or not) - Test code generator - Desktop notifications (optional) - Immediately open problem lines in [Sublime Text](http://www.sublimetext.com) ([some assembly required](https://github.com/asuth/subl-handler)) You can ask questions about how to use GoConvey on [StackOverflow](http://stackoverflow.com/questions/ask?tags=goconvey,go&title=GoConvey%3A%20). Use the tags `go` and `goconvey`. **Menu:** - [Installation](#installation) - [Quick start](#quick-start) - [Documentation](#documentation) - [Screenshots](#screenshots) - [Contributors](#contributors-thanks) Installation ------------ $ go get github.com/smartystreets/goconvey [Quick start](https://github.com/smartystreets/goconvey/wiki#get-going-in-25-seconds) ----------- Make a test, for example: ```go package package_name import ( "testing" . "github.com/smartystreets/goconvey/convey" ) func TestSpec(t *testing.T) { // Only pass t into top-level Convey calls Convey("Given some integer with a starting value", t, func() { x := 1 Convey("When the integer is incremented", func() { x++ Convey("The value should be greater by one", func() { So(x, ShouldEqual, 2) }) }) }) } ``` #### [In the browser](https://github.com/smartystreets/goconvey/wiki/Web-UI) Start up the GoConvey web server at your project's path: $ $GOPATH/bin/goconvey Then watch the test results display in your browser at: http://localhost:8080 If the browser doesn't open automatically, please click [http://localhost:8080](http://localhost:8080) to open manually. There you have it. ![](http://d79i1fxsrar4t.cloudfront.net/goconvey.co/gc-1-dark.png) As long as GoConvey is running, test results will automatically update in your browser window. ![](http://d79i1fxsrar4t.cloudfront.net/goconvey.co/gc-5-dark.png) The design is responsive, so you can squish the browser real tight if you need to put it beside your code. The [web UI](https://github.com/smartystreets/goconvey/wiki/Web-UI) supports traditional Go tests, so use it even if you're not using GoConvey tests. #### [In the terminal](https://github.com/smartystreets/goconvey/wiki/Execution) Just do what you do best: $ go test Or if you want the output to include the story: $ go test -v [Documentation](https://github.com/smartystreets/goconvey/wiki) ----------- Check out the - [GoConvey wiki](https://github.com/smartystreets/goconvey/wiki), - [![GoDoc](https://godoc.org/github.com/smartystreets/goconvey?status.png)](http://godoc.org/github.com/smartystreets/goconvey) - and the *_test.go files scattered throughout this project. [Screenshots](http://goconvey.co) ----------- For web UI and terminal screenshots, check out [the full feature tour](http://goconvey.co). ---------------------- GoConvey is brought to you by [SmartyStreets](https://github.com/smartystreets) and [several contributors](https://github.com/smartystreets/goconvey/graphs/contributors) (Thanks!). mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/convey/000077500000000000000000000000001321131462300263665ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/convey/assertions.go000066400000000000000000000062221321131462300311110ustar00rootroot00000000000000package convey import "github.com/smartystreets/assertions" var ( ShouldEqual = assertions.ShouldEqual ShouldNotEqual = assertions.ShouldNotEqual ShouldAlmostEqual = assertions.ShouldAlmostEqual ShouldNotAlmostEqual = assertions.ShouldNotAlmostEqual ShouldResemble = assertions.ShouldResemble ShouldNotResemble = assertions.ShouldNotResemble ShouldPointTo = assertions.ShouldPointTo ShouldNotPointTo = assertions.ShouldNotPointTo ShouldBeNil = assertions.ShouldBeNil ShouldNotBeNil = assertions.ShouldNotBeNil ShouldBeTrue = assertions.ShouldBeTrue ShouldBeFalse = assertions.ShouldBeFalse ShouldBeZeroValue = assertions.ShouldBeZeroValue ShouldBeGreaterThan = assertions.ShouldBeGreaterThan ShouldBeGreaterThanOrEqualTo = assertions.ShouldBeGreaterThanOrEqualTo ShouldBeLessThan = assertions.ShouldBeLessThan ShouldBeLessThanOrEqualTo = assertions.ShouldBeLessThanOrEqualTo ShouldBeBetween = assertions.ShouldBeBetween ShouldNotBeBetween = assertions.ShouldNotBeBetween ShouldBeBetweenOrEqual = assertions.ShouldBeBetweenOrEqual ShouldNotBeBetweenOrEqual = assertions.ShouldNotBeBetweenOrEqual ShouldContain = assertions.ShouldContain ShouldNotContain = assertions.ShouldNotContain ShouldContainKey = assertions.ShouldContainKey ShouldNotContainKey = assertions.ShouldNotContainKey ShouldBeIn = assertions.ShouldBeIn ShouldNotBeIn = assertions.ShouldNotBeIn ShouldBeEmpty = assertions.ShouldBeEmpty ShouldNotBeEmpty = assertions.ShouldNotBeEmpty ShouldHaveLength = assertions.ShouldHaveLength ShouldStartWith = assertions.ShouldStartWith ShouldNotStartWith = assertions.ShouldNotStartWith ShouldEndWith = assertions.ShouldEndWith ShouldNotEndWith = assertions.ShouldNotEndWith ShouldBeBlank = assertions.ShouldBeBlank ShouldNotBeBlank = assertions.ShouldNotBeBlank ShouldContainSubstring = assertions.ShouldContainSubstring ShouldNotContainSubstring = assertions.ShouldNotContainSubstring ShouldPanic = assertions.ShouldPanic ShouldNotPanic = assertions.ShouldNotPanic ShouldPanicWith = assertions.ShouldPanicWith ShouldNotPanicWith = assertions.ShouldNotPanicWith ShouldHaveSameTypeAs = assertions.ShouldHaveSameTypeAs ShouldNotHaveSameTypeAs = assertions.ShouldNotHaveSameTypeAs ShouldImplement = assertions.ShouldImplement ShouldNotImplement = assertions.ShouldNotImplement ShouldHappenBefore = assertions.ShouldHappenBefore ShouldHappenOnOrBefore = assertions.ShouldHappenOnOrBefore ShouldHappenAfter = assertions.ShouldHappenAfter ShouldHappenOnOrAfter = assertions.ShouldHappenOnOrAfter ShouldHappenBetween = assertions.ShouldHappenBetween ShouldHappenOnOrBetween = assertions.ShouldHappenOnOrBetween ShouldNotHappenOnOrBetween = assertions.ShouldNotHappenOnOrBetween ShouldHappenWithin = assertions.ShouldHappenWithin ShouldNotHappenWithin = assertions.ShouldNotHappenWithin ShouldBeChronological = assertions.ShouldBeChronological ) mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/convey/context.go000066400000000000000000000160101321131462300303770ustar00rootroot00000000000000package convey import ( "fmt" "github.com/jtolds/gls" "github.com/smartystreets/goconvey/convey/reporting" ) type conveyErr struct { fmt string params []interface{} } func (e *conveyErr) Error() string { return fmt.Sprintf(e.fmt, e.params...) } func conveyPanic(fmt string, params ...interface{}) { panic(&conveyErr{fmt, params}) } const ( missingGoTest = `Top-level calls to Convey(...) need a reference to the *testing.T. Hint: Convey("description here", t, func() { /* notice that the second argument was the *testing.T (t)! */ }) ` extraGoTest = `Only the top-level call to Convey(...) needs a reference to the *testing.T.` noStackContext = "Convey operation made without context on goroutine stack.\n" + "Hint: Perhaps you meant to use `Convey(..., func(c C){...})` ?" differentConveySituations = "Different set of Convey statements on subsequent pass!\nDid not expect %#v." multipleIdenticalConvey = "Multiple convey suites with identical names: %#v" ) const ( failureHalt = "___FAILURE_HALT___" nodeKey = "node" ) ///////////////////////////////// Stack Context ///////////////////////////////// func getCurrentContext() *context { ctx, ok := ctxMgr.GetValue(nodeKey) if ok { return ctx.(*context) } return nil } func mustGetCurrentContext() *context { ctx := getCurrentContext() if ctx == nil { conveyPanic(noStackContext) } return ctx } //////////////////////////////////// Context //////////////////////////////////// // context magically handles all coordination of Convey's and So assertions. // // It is tracked on the stack as goroutine-local-storage with the gls package, // or explicitly if the user decides to call convey like: // // Convey(..., func(c C) { // c.So(...) // }) // // This implements the `C` interface. type context struct { reporter reporting.Reporter children map[string]*context resets []func() executedOnce bool expectChildRun *bool complete bool focus bool failureMode FailureMode } // rootConvey is the main entry point to a test suite. This is called when // there's no context in the stack already, and items must contain a `t` object, // or this panics. func rootConvey(items ...interface{}) { entry := discover(items) if entry.Test == nil { conveyPanic(missingGoTest) } expectChildRun := true ctx := &context{ reporter: buildReporter(), children: make(map[string]*context), expectChildRun: &expectChildRun, focus: entry.Focus, failureMode: defaultFailureMode.combine(entry.FailMode), } ctxMgr.SetValues(gls.Values{nodeKey: ctx}, func() { ctx.reporter.BeginStory(reporting.NewStoryReport(entry.Test)) defer ctx.reporter.EndStory() for ctx.shouldVisit() { ctx.conveyInner(entry.Situation, entry.Func) expectChildRun = true } }) } //////////////////////////////////// Methods //////////////////////////////////// func (ctx *context) SkipConvey(items ...interface{}) { ctx.Convey(items, skipConvey) } func (ctx *context) FocusConvey(items ...interface{}) { ctx.Convey(items, focusConvey) } func (ctx *context) Convey(items ...interface{}) { entry := discover(items) // we're a branch, or leaf (on the wind) if entry.Test != nil { conveyPanic(extraGoTest) } if ctx.focus && !entry.Focus { return } var inner_ctx *context if ctx.executedOnce { var ok bool inner_ctx, ok = ctx.children[entry.Situation] if !ok { conveyPanic(differentConveySituations, entry.Situation) } } else { if _, ok := ctx.children[entry.Situation]; ok { conveyPanic(multipleIdenticalConvey, entry.Situation) } inner_ctx = &context{ reporter: ctx.reporter, children: make(map[string]*context), expectChildRun: ctx.expectChildRun, focus: entry.Focus, failureMode: ctx.failureMode.combine(entry.FailMode), } ctx.children[entry.Situation] = inner_ctx } if inner_ctx.shouldVisit() { ctxMgr.SetValues(gls.Values{nodeKey: inner_ctx}, func() { inner_ctx.conveyInner(entry.Situation, entry.Func) }) } } func (ctx *context) SkipSo(stuff ...interface{}) { ctx.assertionReport(reporting.NewSkipReport()) } func (ctx *context) So(actual interface{}, assert assertion, expected ...interface{}) { if result := assert(actual, expected...); result == assertionSuccess { ctx.assertionReport(reporting.NewSuccessReport()) } else { ctx.assertionReport(reporting.NewFailureReport(result)) } } func (ctx *context) Reset(action func()) { /* TODO: Failure mode configuration */ ctx.resets = append(ctx.resets, action) } func (ctx *context) Print(items ...interface{}) (int, error) { fmt.Fprint(ctx.reporter, items...) return fmt.Print(items...) } func (ctx *context) Println(items ...interface{}) (int, error) { fmt.Fprintln(ctx.reporter, items...) return fmt.Println(items...) } func (ctx *context) Printf(format string, items ...interface{}) (int, error) { fmt.Fprintf(ctx.reporter, format, items...) return fmt.Printf(format, items...) } //////////////////////////////////// Private //////////////////////////////////// // shouldVisit returns true iff we should traverse down into a Convey. Note // that just because we don't traverse a Convey this time, doesn't mean that // we may not traverse it on a subsequent pass. func (c *context) shouldVisit() bool { return !c.complete && *c.expectChildRun } // conveyInner is the function which actually executes the user's anonymous test // function body. At this point, Convey or RootConvey has decided that this // function should actually run. func (ctx *context) conveyInner(situation string, f func(C)) { // Record/Reset state for next time. defer func() { ctx.executedOnce = true // This is only needed at the leaves, but there's no harm in also setting it // when returning from branch Convey's *ctx.expectChildRun = false }() // Set up+tear down our scope for the reporter ctx.reporter.Enter(reporting.NewScopeReport(situation)) defer ctx.reporter.Exit() // Recover from any panics in f, and assign the `complete` status for this // node of the tree. defer func() { ctx.complete = true if problem := recover(); problem != nil { if problem, ok := problem.(*conveyErr); ok { panic(problem) } if problem != failureHalt { ctx.reporter.Report(reporting.NewErrorReport(problem)) } } else { for _, child := range ctx.children { if !child.complete { ctx.complete = false return } } } }() // Resets are registered as the `f` function executes, so nil them here. // All resets are run in registration order (FIFO). ctx.resets = []func(){} defer func() { for _, r := range ctx.resets { // panics handled by the previous defer r() } }() if f == nil { // if f is nil, this was either a Convey(..., nil), or a SkipConvey ctx.reporter.Report(reporting.NewSkipReport()) } else { f(ctx) } } // assertionReport is a helper for So and SkipSo which makes the report and // then possibly panics, depending on the current context's failureMode. func (ctx *context) assertionReport(r *reporting.AssertionResult) { ctx.reporter.Report(r) if r.Failure != "" && ctx.failureMode == FailureHalts { panic(failureHalt) } } mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/convey/convey.goconvey000066400000000000000000000002741321131462300314470ustar00rootroot00000000000000#ignore -timeout=1s #-covermode=count #-coverpkg=github.com/smartystreets/goconvey/convey,github.com/smartystreets/goconvey/convey/gotest,github.com/smartystreets/goconvey/convey/reportingmongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/convey/discovery.go000066400000000000000000000046231321131462300307310ustar00rootroot00000000000000package convey type actionSpecifier uint8 const ( noSpecifier actionSpecifier = iota skipConvey focusConvey ) type suite struct { Situation string Test t Focus bool Func func(C) // nil means skipped FailMode FailureMode } func newSuite(situation string, failureMode FailureMode, f func(C), test t, specifier actionSpecifier) *suite { ret := &suite{ Situation: situation, Test: test, Func: f, FailMode: failureMode, } switch specifier { case skipConvey: ret.Func = nil case focusConvey: ret.Focus = true } return ret } func discover(items []interface{}) *suite { name, items := parseName(items) test, items := parseGoTest(items) failure, items := parseFailureMode(items) action, items := parseAction(items) specifier, items := parseSpecifier(items) if len(items) != 0 { conveyPanic(parseError) } return newSuite(name, failure, action, test, specifier) } func item(items []interface{}) interface{} { if len(items) == 0 { conveyPanic(parseError) } return items[0] } func parseName(items []interface{}) (string, []interface{}) { if name, parsed := item(items).(string); parsed { return name, items[1:] } conveyPanic(parseError) panic("never get here") } func parseGoTest(items []interface{}) (t, []interface{}) { if test, parsed := item(items).(t); parsed { return test, items[1:] } return nil, items } func parseFailureMode(items []interface{}) (FailureMode, []interface{}) { if mode, parsed := item(items).(FailureMode); parsed { return mode, items[1:] } return FailureInherits, items } func parseAction(items []interface{}) (func(C), []interface{}) { switch x := item(items).(type) { case nil: return nil, items[1:] case func(C): return x, items[1:] case func(): return func(C) { x() }, items[1:] } conveyPanic(parseError) panic("never get here") } func parseSpecifier(items []interface{}) (actionSpecifier, []interface{}) { if len(items) == 0 { return noSpecifier, items } if spec, ok := items[0].(actionSpecifier); ok { return spec, items[1:] } conveyPanic(parseError) panic("never get here") } // This interface allows us to pass the *testing.T struct // throughout the internals of this package without ever // having to import the "testing" package. type t interface { Fail() } const parseError = "You must provide a name (string), then a *testing.T (if in outermost scope), an optional FailureMode, and then an action (func())." mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/convey/doc.go000066400000000000000000000207421321131462300274670ustar00rootroot00000000000000// Package convey contains all of the public-facing entry points to this project. // This means that it should never be required of the user to import any other // packages from this project as they serve internal purposes. package convey import "github.com/smartystreets/goconvey/convey/reporting" ////////////////////////////////// suite ////////////////////////////////// // C is the Convey context which you can optionally obtain in your action // by calling Convey like: // // Convey(..., func(c C) { // ... // }) // // See the documentation on Convey for more details. // // All methods in this context behave identically to the global functions of the // same name in this package. type C interface { Convey(items ...interface{}) SkipConvey(items ...interface{}) FocusConvey(items ...interface{}) So(actual interface{}, assert assertion, expected ...interface{}) SkipSo(stuff ...interface{}) Reset(action func()) Println(items ...interface{}) (int, error) Print(items ...interface{}) (int, error) Printf(format string, items ...interface{}) (int, error) } // Convey is the method intended for use when declaring the scopes of // a specification. Each scope has a description and a func() which may contain // other calls to Convey(), Reset() or Should-style assertions. Convey calls can // be nested as far as you see fit. // // IMPORTANT NOTE: The top-level Convey() within a Test method // must conform to the following signature: // // Convey(description string, t *testing.T, action func()) // // All other calls should look like this (no need to pass in *testing.T): // // Convey(description string, action func()) // // Don't worry, goconvey will panic if you get it wrong so you can fix it. // // Additionally, you may explicitly obtain access to the Convey context by doing: // // Convey(description string, action func(c C)) // // You may need to do this if you want to pass the context through to a // goroutine, or to close over the context in a handler to a library which // calls your handler in a goroutine (httptest comes to mind). // // All Convey()-blocks also accept an optional parameter of FailureMode which sets // how goconvey should treat failures for So()-assertions in the block and // nested blocks. See the constants in this file for the available options. // // By default it will inherit from its parent block and the top-level blocks // default to the FailureHalts setting. // // This parameter is inserted before the block itself: // // Convey(description string, t *testing.T, mode FailureMode, action func()) // Convey(description string, mode FailureMode, action func()) // // See the examples package for, well, examples. func Convey(items ...interface{}) { if ctx := getCurrentContext(); ctx == nil { rootConvey(items...) } else { ctx.Convey(items...) } } // SkipConvey is analagous to Convey except that the scope is not executed // (which means that child scopes defined within this scope are not run either). // The reporter will be notified that this step was skipped. func SkipConvey(items ...interface{}) { Convey(append(items, skipConvey)...) } // FocusConvey is has the inverse effect of SkipConvey. If the top-level // Convey is changed to `FocusConvey`, only nested scopes that are defined // with FocusConvey will be run. The rest will be ignored completely. This // is handy when debugging a large suite that runs a misbehaving function // repeatedly as you can disable all but one of that function // without swaths of `SkipConvey` calls, just a targeted chain of calls // to FocusConvey. func FocusConvey(items ...interface{}) { Convey(append(items, focusConvey)...) } // Reset registers a cleanup function to be run after each Convey() // in the same scope. See the examples package for a simple use case. func Reset(action func()) { mustGetCurrentContext().Reset(action) } /////////////////////////////////// Assertions /////////////////////////////////// // assertion is an alias for a function with a signature that the convey.So() // method can handle. Any future or custom assertions should conform to this // method signature. The return value should be an empty string if the assertion // passes and a well-formed failure message if not. type assertion func(actual interface{}, expected ...interface{}) string const assertionSuccess = "" // So is the means by which assertions are made against the system under test. // The majority of exported names in the assertions package begin with the word // 'Should' and describe how the first argument (actual) should compare with any // of the final (expected) arguments. How many final arguments are accepted // depends on the particular assertion that is passed in as the assert argument. // See the examples package for use cases and the assertions package for // documentation on specific assertion methods. A failing assertion will // cause t.Fail() to be invoked--you should never call this method (or other // failure-inducing methods) in your test code. Leave that to GoConvey. func So(actual interface{}, assert assertion, expected ...interface{}) { mustGetCurrentContext().So(actual, assert, expected...) } // SkipSo is analagous to So except that the assertion that would have been passed // to So is not executed and the reporter is notified that the assertion was skipped. func SkipSo(stuff ...interface{}) { mustGetCurrentContext().SkipSo() } // FailureMode is a type which determines how the So() blocks should fail // if their assertion fails. See constants further down for acceptable values type FailureMode string const ( // FailureContinues is a failure mode which prevents failing // So()-assertions from halting Convey-block execution, instead // allowing the test to continue past failing So()-assertions. FailureContinues FailureMode = "continue" // FailureHalts is the default setting for a top-level Convey()-block // and will cause all failing So()-assertions to halt further execution // in that test-arm and continue on to the next arm. FailureHalts FailureMode = "halt" // FailureInherits is the default setting for failure-mode, it will // default to the failure-mode of the parent block. You should never // need to specify this mode in your tests.. FailureInherits FailureMode = "inherits" ) func (f FailureMode) combine(other FailureMode) FailureMode { if other == FailureInherits { return f } return other } var defaultFailureMode FailureMode = FailureHalts // SetDefaultFailureMode allows you to specify the default failure mode // for all Convey blocks. It is meant to be used in an init function to // allow the default mode to be changdd across all tests for an entire packgae // but it can be used anywhere. func SetDefaultFailureMode(mode FailureMode) { if mode == FailureContinues || mode == FailureHalts { defaultFailureMode = mode } else { panic("You may only use the constants named 'FailureContinues' and 'FailureHalts' as default failure modes.") } } //////////////////////////////////// Print functions //////////////////////////////////// // Print is analogous to fmt.Print (and it even calls fmt.Print). It ensures that // output is aligned with the corresponding scopes in the web UI. func Print(items ...interface{}) (written int, err error) { return mustGetCurrentContext().Print(items...) } // Print is analogous to fmt.Println (and it even calls fmt.Println). It ensures that // output is aligned with the corresponding scopes in the web UI. func Println(items ...interface{}) (written int, err error) { return mustGetCurrentContext().Println(items...) } // Print is analogous to fmt.Printf (and it even calls fmt.Printf). It ensures that // output is aligned with the corresponding scopes in the web UI. func Printf(format string, items ...interface{}) (written int, err error) { return mustGetCurrentContext().Printf(format, items...) } /////////////////////////////////////////////////////////////////////////////// // SuppressConsoleStatistics prevents automatic printing of console statistics. // Calling PrintConsoleStatistics explicitly will force printing of statistics. func SuppressConsoleStatistics() { reporting.SuppressConsoleStatistics() } // ConsoleStatistics may be called at any time to print assertion statistics. // Generally, the best place to do this would be in a TestMain function, // after all tests have been run. Something like this: // // func TestMain(m *testing.M) { // convey.SuppressConsoleStatistics() // result := m.Run() // convey.PrintConsoleStatistics() // os.Exit(result) // } // func PrintConsoleStatistics() { reporting.PrintConsoleStatistics() } mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/convey/focused_execution_test.go000066400000000000000000000021131321131462300334640ustar00rootroot00000000000000package convey import "testing" func TestFocusOnlyAtTopLevel(t *testing.T) { output := prepare() FocusConvey("hi", t, func() { output += "done" }) expectEqual(t, "done", output) } func TestFocus(t *testing.T) { output := prepare() FocusConvey("hi", t, func() { output += "1" Convey("bye", func() { output += "2" }) }) expectEqual(t, "1", output) } func TestNestedFocus(t *testing.T) { output := prepare() FocusConvey("hi", t, func() { output += "1" Convey("This shouldn't run", func() { output += "boink!" }) FocusConvey("This should run", func() { output += "2" FocusConvey("The should run too", func() { output += "3" }) Convey("The should NOT run", func() { output += "blah blah blah!" }) }) }) expectEqual(t, "123", output) } func TestForgotTopLevelFocus(t *testing.T) { output := prepare() Convey("1", t, func() { output += "1" FocusConvey("This will be run because the top-level lacks Focus", func() { output += "2" }) Convey("3", func() { output += "3" }) }) expectEqual(t, "1213", output) } mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/convey/gotest/000077500000000000000000000000001321131462300276735ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/convey/gotest/doc_test.go000066400000000000000000000000171321131462300320240ustar00rootroot00000000000000package gotest mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/convey/gotest/utils.go000066400000000000000000000014771321131462300313730ustar00rootroot00000000000000// Package gotest contains internal functionality. Although this package // contains one or more exported names it is not intended for public // consumption. See the examples package for how to use this project. package gotest import ( "runtime" "strings" ) func ResolveExternalCaller() (file string, line int, name string) { var caller_id uintptr callers := runtime.Callers(0, callStack) for x := 0; x < callers; x++ { caller_id, file, line, _ = runtime.Caller(x) if strings.HasSuffix(file, "_test.go") || strings.HasSuffix(file, "_tests.go") { name = runtime.FuncForPC(caller_id).Name() return } } file, line, name = "", -1, "" return // panic? } const maxStackDepth = 100 // This had better be enough... var callStack []uintptr = make([]uintptr, maxStackDepth, maxStackDepth) mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/convey/init.go000066400000000000000000000036551321131462300276710ustar00rootroot00000000000000package convey import ( "flag" "os" "github.com/jtolds/gls" "github.com/smartystreets/assertions" "github.com/smartystreets/goconvey/convey/reporting" ) func init() { assertions.GoConveyMode(true) declareFlags() ctxMgr = gls.NewContextManager() } func declareFlags() { flag.BoolVar(&json, "json", false, "When true, emits results in JSON blocks. Default: 'false'") flag.BoolVar(&silent, "silent", false, "When true, all output from GoConvey is suppressed.") flag.BoolVar(&story, "story", false, "When true, emits story output, otherwise emits dot output. When not provided, this flag mirros the value of the '-test.v' flag") if noStoryFlagProvided() { story = verboseEnabled } // FYI: flag.Parse() is called from the testing package. } func noStoryFlagProvided() bool { return !story && !storyDisabled } func buildReporter() reporting.Reporter { selectReporter := os.Getenv("GOCONVEY_REPORTER") switch { case testReporter != nil: return testReporter case json || selectReporter == "json": return reporting.BuildJsonReporter() case silent || selectReporter == "silent": return reporting.BuildSilentReporter() case selectReporter == "dot": // Story is turned on when verbose is set, so we need to check for dot reporter first. return reporting.BuildDotReporter() case story || selectReporter == "story": return reporting.BuildStoryReporter() default: return reporting.BuildDotReporter() } } var ( ctxMgr *gls.ContextManager // only set by internal tests testReporter reporting.Reporter ) var ( json bool silent bool story bool verboseEnabled = flagFound("-test.v=true") storyDisabled = flagFound("-story=false") ) // flagFound parses the command line args manually for flags defined in other // packages. Like the '-v' flag from the "testing" package, for instance. func flagFound(flagValue string) bool { for _, arg := range os.Args { if arg == flagValue { return true } } return false } mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/convey/isolated_execution_test.go000066400000000000000000000312561321131462300336520ustar00rootroot00000000000000package convey import ( "strconv" "testing" "time" ) func TestSingleScope(t *testing.T) { output := prepare() Convey("hi", t, func() { output += "done" }) expectEqual(t, "done", output) } func TestSingleScopeWithMultipleConveys(t *testing.T) { output := prepare() Convey("1", t, func() { output += "1" }) Convey("2", t, func() { output += "2" }) expectEqual(t, "12", output) } func TestNestedScopes(t *testing.T) { output := prepare() Convey("a", t, func() { output += "a " Convey("bb", func() { output += "bb " Convey("ccc", func() { output += "ccc | " }) }) }) expectEqual(t, "a bb ccc | ", output) } func TestNestedScopesWithIsolatedExecution(t *testing.T) { output := prepare() Convey("a", t, func() { output += "a " Convey("aa", func() { output += "aa " Convey("aaa", func() { output += "aaa | " }) Convey("aaa1", func() { output += "aaa1 | " }) }) Convey("ab", func() { output += "ab " Convey("abb", func() { output += "abb | " }) }) }) expectEqual(t, "a aa aaa | a aa aaa1 | a ab abb | ", output) } func TestSingleScopeWithConveyAndNestedReset(t *testing.T) { output := prepare() Convey("1", t, func() { output += "1" Reset(func() { output += "a" }) }) expectEqual(t, "1a", output) } func TestPanicingReset(t *testing.T) { output := prepare() Convey("1", t, func() { output += "1" Reset(func() { panic("nooo") }) Convey("runs since the reset hasn't yet", func() { output += "a" }) Convey("but this doesnt", func() { output += "nope" }) }) expectEqual(t, "1a", output) } func TestSingleScopeWithMultipleRegistrationsAndReset(t *testing.T) { output := prepare() Convey("reset after each nested convey", t, func() { Convey("first output", func() { output += "1" }) Convey("second output", func() { output += "2" }) Reset(func() { output += "a" }) }) expectEqual(t, "1a2a", output) } func TestSingleScopeWithMultipleRegistrationsAndMultipleResets(t *testing.T) { output := prepare() Convey("each reset is run at end of each nested convey", t, func() { Convey("1", func() { output += "1" }) Convey("2", func() { output += "2" }) Reset(func() { output += "a" }) Reset(func() { output += "b" }) }) expectEqual(t, "1ab2ab", output) } func Test_Failure_AtHigherLevelScopePreventsChildScopesFromRunning(t *testing.T) { output := prepare() Convey("This step fails", t, func() { So(1, ShouldEqual, 2) Convey("this should NOT be executed", func() { output += "a" }) }) expectEqual(t, "", output) } func Test_Panic_AtHigherLevelScopePreventsChildScopesFromRunning(t *testing.T) { output := prepare() Convey("This step panics", t, func() { Convey("this happens, because the panic didn't happen yet", func() { output += "1" }) output += "a" Convey("this should NOT be executed", func() { output += "2" }) output += "b" panic("Hi") output += "nope" }) expectEqual(t, "1ab", output) } func Test_Panic_InChildScopeDoes_NOT_PreventExecutionOfSiblingScopes(t *testing.T) { output := prepare() Convey("This is the parent", t, func() { Convey("This step panics", func() { panic("Hi") output += "1" }) Convey("This sibling should execute", func() { output += "2" }) }) expectEqual(t, "2", output) } func Test_Failure_InChildScopeDoes_NOT_PreventExecutionOfSiblingScopes(t *testing.T) { output := prepare() Convey("This is the parent", t, func() { Convey("This step fails", func() { So(1, ShouldEqual, 2) output += "1" }) Convey("This sibling should execute", func() { output += "2" }) }) expectEqual(t, "2", output) } func TestResetsAreAlwaysExecutedAfterScope_Panics(t *testing.T) { output := prepare() Convey("This is the parent", t, func() { Convey("This step panics", func() { panic("Hi") output += "1" }) Convey("This sibling step does not panic", func() { output += "a" Reset(func() { output += "b" }) }) Reset(func() { output += "2" }) }) expectEqual(t, "2ab2", output) } func TestResetsAreAlwaysExecutedAfterScope_Failures(t *testing.T) { output := prepare() Convey("This is the parent", t, func() { Convey("This step fails", func() { So(1, ShouldEqual, 2) output += "1" }) Convey("This sibling step does not fail", func() { output += "a" Reset(func() { output += "b" }) }) Reset(func() { output += "2" }) }) expectEqual(t, "2ab2", output) } func TestSkipTopLevel(t *testing.T) { output := prepare() SkipConvey("hi", t, func() { output += "This shouldn't be executed!" }) expectEqual(t, "", output) } func TestSkipNestedLevel(t *testing.T) { output := prepare() Convey("hi", t, func() { output += "yes" SkipConvey("bye", func() { output += "no" }) }) expectEqual(t, "yes", output) } func TestSkipNestedLevelSkipsAllChildLevels(t *testing.T) { output := prepare() Convey("hi", t, func() { output += "yes" SkipConvey("bye", func() { output += "no" Convey("byebye", func() { output += "no-no" }) }) }) expectEqual(t, "yes", output) } func TestIterativeConveys(t *testing.T) { output := prepare() Convey("Test", t, func() { for x := 0; x < 10; x++ { y := strconv.Itoa(x) Convey(y, func() { output += y }) } }) expectEqual(t, "0123456789", output) } func TestClosureVariables(t *testing.T) { output := prepare() i := 0 Convey("A", t, func() { i = i + 1 j := i output += "A" + strconv.Itoa(i) + " " Convey("B", func() { k := j j = j + 1 output += "B" + strconv.Itoa(k) + " " Convey("C", func() { output += "C" + strconv.Itoa(k) + strconv.Itoa(j) + " " }) Convey("D", func() { output += "D" + strconv.Itoa(k) + strconv.Itoa(j) + " " }) }) Convey("C", func() { output += "C" + strconv.Itoa(j) + " " }) }) output += "D" + strconv.Itoa(i) + " " expectEqual(t, "A1 B1 C12 A2 B2 D23 A3 C3 D3 ", output) } func TestClosureVariablesWithReset(t *testing.T) { output := prepare() i := 0 Convey("A", t, func() { i = i + 1 j := i output += "A" + strconv.Itoa(i) + " " Reset(func() { output += "R" + strconv.Itoa(i) + strconv.Itoa(j) + " " }) Convey("B", func() { output += "B" + strconv.Itoa(j) + " " }) Convey("C", func() { output += "C" + strconv.Itoa(j) + " " }) }) output += "D" + strconv.Itoa(i) + " " expectEqual(t, "A1 B1 R11 A2 C2 R22 D2 ", output) } func TestWrappedSimple(t *testing.T) { prepare() output := resetTestString{""} Convey("A", t, func() { func() { output.output += "A " Convey("B", func() { output.output += "B " Convey("C", func() { output.output += "C " }) }) Convey("D", func() { output.output += "D " }) }() }) expectEqual(t, "A B C A D ", output.output) } type resetTestString struct { output string } func addReset(o *resetTestString, f func()) func() { return func() { Reset(func() { o.output += "R " }) f() } } func TestWrappedReset(t *testing.T) { prepare() output := resetTestString{""} Convey("A", t, addReset(&output, func() { output.output += "A " Convey("B", func() { output.output += "B " }) Convey("C", func() { output.output += "C " }) })) expectEqual(t, "A B R A C R ", output.output) } func TestWrappedReset2(t *testing.T) { prepare() output := resetTestString{""} Convey("A", t, func() { Reset(func() { output.output += "R " }) func() { output.output += "A " Convey("B", func() { output.output += "B " Convey("C", func() { output.output += "C " }) }) Convey("D", func() { output.output += "D " }) }() }) expectEqual(t, "A B C R A D R ", output.output) } func TestInfiniteLoopWithTrailingFail(t *testing.T) { done := make(chan int) go func() { Convey("This fails", t, func() { Convey("and this is run", func() { So(true, ShouldEqual, true) }) /* And this prevents the whole block to be marked as run */ So(false, ShouldEqual, true) }) done <- 1 }() select { case <-done: return case <-time.After(1 * time.Millisecond): t.Fail() } } func TestOutermostResetInvokedForGrandchildren(t *testing.T) { output := prepare() Convey("A", t, func() { output += "A " Reset(func() { output += "rA " }) Convey("B", func() { output += "B " Reset(func() { output += "rB " }) Convey("C", func() { output += "C " Reset(func() { output += "rC " }) }) Convey("D", func() { output += "D " Reset(func() { output += "rD " }) }) }) }) expectEqual(t, "A B C rC rB rA A B D rD rB rA ", output) } func TestFailureOption(t *testing.T) { output := prepare() Convey("A", t, FailureHalts, func() { output += "A " So(true, ShouldEqual, true) output += "B " So(false, ShouldEqual, true) output += "C " }) expectEqual(t, "A B ", output) } func TestFailureOption2(t *testing.T) { output := prepare() Convey("A", t, func() { output += "A " So(true, ShouldEqual, true) output += "B " So(false, ShouldEqual, true) output += "C " }) expectEqual(t, "A B ", output) } func TestFailureOption3(t *testing.T) { output := prepare() Convey("A", t, FailureContinues, func() { output += "A " So(true, ShouldEqual, true) output += "B " So(false, ShouldEqual, true) output += "C " }) expectEqual(t, "A B C ", output) } func TestFailureOptionInherit(t *testing.T) { output := prepare() Convey("A", t, FailureContinues, func() { output += "A1 " So(false, ShouldEqual, true) output += "A2 " Convey("B", func() { output += "B1 " So(true, ShouldEqual, true) output += "B2 " So(false, ShouldEqual, true) output += "B3 " }) }) expectEqual(t, "A1 A2 B1 B2 B3 ", output) } func TestFailureOptionInherit2(t *testing.T) { output := prepare() Convey("A", t, FailureHalts, func() { output += "A1 " So(false, ShouldEqual, true) output += "A2 " Convey("B", func() { output += "A1 " So(true, ShouldEqual, true) output += "A2 " So(false, ShouldEqual, true) output += "A3 " }) }) expectEqual(t, "A1 ", output) } func TestFailureOptionInherit3(t *testing.T) { output := prepare() Convey("A", t, FailureHalts, func() { output += "A1 " So(true, ShouldEqual, true) output += "A2 " Convey("B", func() { output += "B1 " So(true, ShouldEqual, true) output += "B2 " So(false, ShouldEqual, true) output += "B3 " }) }) expectEqual(t, "A1 A2 B1 B2 ", output) } func TestFailureOptionNestedOverride(t *testing.T) { output := prepare() Convey("A", t, FailureContinues, func() { output += "A " So(false, ShouldEqual, true) output += "B " Convey("C", FailureHalts, func() { output += "C " So(true, ShouldEqual, true) output += "D " So(false, ShouldEqual, true) output += "E " }) }) expectEqual(t, "A B C D ", output) } func TestFailureOptionNestedOverride2(t *testing.T) { output := prepare() Convey("A", t, FailureHalts, func() { output += "A " So(true, ShouldEqual, true) output += "B " Convey("C", FailureContinues, func() { output += "C " So(true, ShouldEqual, true) output += "D " So(false, ShouldEqual, true) output += "E " }) }) expectEqual(t, "A B C D E ", output) } func TestMultipleInvocationInheritance(t *testing.T) { output := prepare() Convey("A", t, FailureHalts, func() { output += "A1 " So(true, ShouldEqual, true) output += "A2 " Convey("B", FailureContinues, func() { output += "B1 " So(true, ShouldEqual, true) output += "B2 " So(false, ShouldEqual, true) output += "B3 " }) Convey("C", func() { output += "C1 " So(true, ShouldEqual, true) output += "C2 " So(false, ShouldEqual, true) output += "C3 " }) }) expectEqual(t, "A1 A2 B1 B2 B3 A1 A2 C1 C2 ", output) } func TestMultipleInvocationInheritance2(t *testing.T) { output := prepare() Convey("A", t, FailureContinues, func() { output += "A1 " So(true, ShouldEqual, true) output += "A2 " So(false, ShouldEqual, true) output += "A3 " Convey("B", FailureHalts, func() { output += "B1 " So(true, ShouldEqual, true) output += "B2 " So(false, ShouldEqual, true) output += "B3 " }) Convey("C", func() { output += "C1 " So(true, ShouldEqual, true) output += "C2 " So(false, ShouldEqual, true) output += "C3 " }) }) expectEqual(t, "A1 A2 A3 B1 B2 A1 A2 A3 C1 C2 C3 ", output) } func TestSetDefaultFailureMode(t *testing.T) { output := prepare() SetDefaultFailureMode(FailureContinues) // the default is normally FailureHalts defer SetDefaultFailureMode(FailureHalts) Convey("A", t, func() { output += "A1 " So(true, ShouldBeFalse) output += "A2 " }) expectEqual(t, "A1 A2 ", output) } func prepare() string { testReporter = newNilReporter() return "" } mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/convey/nilReporter.go000066400000000000000000000012021321131462300312150ustar00rootroot00000000000000package convey import ( "github.com/smartystreets/goconvey/convey/reporting" ) type nilReporter struct{} func (self *nilReporter) BeginStory(story *reporting.StoryReport) {} func (self *nilReporter) Enter(scope *reporting.ScopeReport) {} func (self *nilReporter) Report(report *reporting.AssertionResult) {} func (self *nilReporter) Exit() {} func (self *nilReporter) EndStory() {} func (self *nilReporter) Write(p []byte) (int, error) { return len(p), nil } func newNilReporter() *nilReporter { return &nilReporter{} } mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/convey/reporting/000077500000000000000000000000001321131462300303775ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/convey/reporting/console.go000066400000000000000000000003221321131462300323650ustar00rootroot00000000000000package reporting import ( "fmt" "io" ) type console struct{} func (self *console) Write(p []byte) (n int, err error) { return fmt.Print(string(p)) } func NewConsole() io.Writer { return new(console) } mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/convey/reporting/doc.go000066400000000000000000000004001321131462300314650ustar00rootroot00000000000000// Package reporting contains internal functionality related // to console reporting and output. Although this package has // exported names is not intended for public consumption. See the // examples package for how to use this project. package reporting mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/convey/reporting/dot.go000066400000000000000000000014501321131462300315140ustar00rootroot00000000000000package reporting import "fmt" type dot struct{ out *Printer } func (self *dot) BeginStory(story *StoryReport) {} func (self *dot) Enter(scope *ScopeReport) {} func (self *dot) Report(report *AssertionResult) { if report.Error != nil { fmt.Print(redColor) self.out.Insert(dotError) } else if report.Failure != "" { fmt.Print(yellowColor) self.out.Insert(dotFailure) } else if report.Skipped { fmt.Print(yellowColor) self.out.Insert(dotSkip) } else { fmt.Print(greenColor) self.out.Insert(dotSuccess) } fmt.Print(resetColor) } func (self *dot) Exit() {} func (self *dot) EndStory() {} func (self *dot) Write(content []byte) (written int, err error) { return len(content), nil // no-op } func NewDotReporter(out *Printer) *dot { self := new(dot) self.out = out return self } mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/convey/reporting/dot_test.go000066400000000000000000000015721321131462300325600ustar00rootroot00000000000000package reporting import ( "errors" "testing" ) func TestDotReporterAssertionPrinting(t *testing.T) { monochrome() file := newMemoryFile() printer := NewPrinter(file) reporter := NewDotReporter(printer) reporter.Report(NewSuccessReport()) reporter.Report(NewFailureReport("failed")) reporter.Report(NewErrorReport(errors.New("error"))) reporter.Report(NewSkipReport()) expected := dotSuccess + dotFailure + dotError + dotSkip if file.buffer != expected { t.Errorf("\nExpected: '%s'\nActual: '%s'", expected, file.buffer) } } func TestDotReporterOnlyReportsAssertions(t *testing.T) { monochrome() file := newMemoryFile() printer := NewPrinter(file) reporter := NewDotReporter(printer) reporter.BeginStory(nil) reporter.Enter(nil) reporter.Exit() reporter.EndStory() if file.buffer != "" { t.Errorf("\nExpected: '(blank)'\nActual: '%s'", file.buffer) } } mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/convey/reporting/gotest.go000066400000000000000000000012421321131462300322320ustar00rootroot00000000000000package reporting type gotestReporter struct{ test T } func (self *gotestReporter) BeginStory(story *StoryReport) { self.test = story.Test } func (self *gotestReporter) Enter(scope *ScopeReport) {} func (self *gotestReporter) Report(r *AssertionResult) { if !passed(r) { self.test.Fail() } } func (self *gotestReporter) Exit() {} func (self *gotestReporter) EndStory() { self.test = nil } func (self *gotestReporter) Write(content []byte) (written int, err error) { return len(content), nil // no-op } func NewGoTestReporter() *gotestReporter { return new(gotestReporter) } func passed(r *AssertionResult) bool { return r.Error == nil && r.Failure == "" } mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/convey/reporting/gotest_test.go000066400000000000000000000030471321131462300332760ustar00rootroot00000000000000package reporting import "testing" func TestReporterReceivesSuccessfulReport(t *testing.T) { reporter := NewGoTestReporter() test := new(fakeTest) reporter.BeginStory(NewStoryReport(test)) reporter.Report(NewSuccessReport()) if test.failed { t.Errorf("Should have have marked test as failed--the report reflected success.") } } func TestReporterReceivesFailureReport(t *testing.T) { reporter := NewGoTestReporter() test := new(fakeTest) reporter.BeginStory(NewStoryReport(test)) reporter.Report(NewFailureReport("This is a failure.")) if !test.failed { t.Errorf("Test should have been marked as failed (but it wasn't).") } } func TestReporterReceivesErrorReport(t *testing.T) { reporter := NewGoTestReporter() test := new(fakeTest) reporter.BeginStory(NewStoryReport(test)) reporter.Report(NewErrorReport("This is an error.")) if !test.failed { t.Errorf("Test should have been marked as failed (but it wasn't).") } } func TestReporterIsResetAtTheEndOfTheStory(t *testing.T) { defer catch(t) reporter := NewGoTestReporter() test := new(fakeTest) reporter.BeginStory(NewStoryReport(test)) reporter.EndStory() reporter.Report(NewSuccessReport()) } func TestReporterNoopMethods(t *testing.T) { reporter := NewGoTestReporter() reporter.Enter(NewScopeReport("title")) reporter.Exit() } func catch(t *testing.T) { if r := recover(); r != nil { t.Log("Getting to this point means we've passed (because we caught a panic appropriately).") } } type fakeTest struct { failed bool } func (self *fakeTest) Fail() { self.failed = true } mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/convey/reporting/init.go000066400000000000000000000042561321131462300317000ustar00rootroot00000000000000package reporting import ( "os" "runtime" "strings" ) func init() { if !isColorableTerminal() { monochrome() } if runtime.GOOS == "windows" { success, failure, error_ = dotSuccess, dotFailure, dotError } } func BuildJsonReporter() Reporter { out := NewPrinter(NewConsole()) return NewReporters( NewGoTestReporter(), NewJsonReporter(out)) } func BuildDotReporter() Reporter { out := NewPrinter(NewConsole()) return NewReporters( NewGoTestReporter(), NewDotReporter(out), NewProblemReporter(out), consoleStatistics) } func BuildStoryReporter() Reporter { out := NewPrinter(NewConsole()) return NewReporters( NewGoTestReporter(), NewStoryReporter(out), NewProblemReporter(out), consoleStatistics) } func BuildSilentReporter() Reporter { out := NewPrinter(NewConsole()) return NewReporters( NewGoTestReporter(), NewSilentProblemReporter(out)) } var ( newline = "\n" success = "✔" failure = "✘" error_ = "🔥" skip = "âš " dotSuccess = "." dotFailure = "x" dotError = "E" dotSkip = "S" errorTemplate = "* %s \nLine %d: - %v \n%s\n" failureTemplate = "* %s \nLine %d:\n%s\n" ) var ( greenColor = "\033[32m" yellowColor = "\033[33m" redColor = "\033[31m" resetColor = "\033[0m" ) var consoleStatistics = NewStatisticsReporter(NewPrinter(NewConsole())) func SuppressConsoleStatistics() { consoleStatistics.Suppress() } func PrintConsoleStatistics() { consoleStatistics.PrintSummary() } // QuiteMode disables all console output symbols. This is only meant to be used // for tests that are internal to goconvey where the output is distracting or // otherwise not needed in the test output. func QuietMode() { success, failure, error_, skip, dotSuccess, dotFailure, dotError, dotSkip = "", "", "", "", "", "", "", "" } func monochrome() { greenColor, yellowColor, redColor, resetColor = "", "", "", "" } func isColorableTerminal() bool { return strings.Contains(os.Getenv("TERM"), "color") } // This interface allows us to pass the *testing.T struct // throughout the internals of this tool without ever // having to import the "testing" package. type T interface { Fail() } mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/convey/reporting/json.go000066400000000000000000000042671321131462300317100ustar00rootroot00000000000000// TODO: under unit test package reporting import ( "bytes" "encoding/json" "fmt" "strings" ) type JsonReporter struct { out *Printer currentKey []string current *ScopeResult index map[string]*ScopeResult scopes []*ScopeResult } func (self *JsonReporter) depth() int { return len(self.currentKey) } func (self *JsonReporter) BeginStory(story *StoryReport) {} func (self *JsonReporter) Enter(scope *ScopeReport) { self.currentKey = append(self.currentKey, scope.Title) ID := strings.Join(self.currentKey, "|") if _, found := self.index[ID]; !found { next := newScopeResult(scope.Title, self.depth(), scope.File, scope.Line) self.scopes = append(self.scopes, next) self.index[ID] = next } self.current = self.index[ID] } func (self *JsonReporter) Report(report *AssertionResult) { self.current.Assertions = append(self.current.Assertions, report) } func (self *JsonReporter) Exit() { self.currentKey = self.currentKey[:len(self.currentKey)-1] } func (self *JsonReporter) EndStory() { self.report() self.reset() } func (self *JsonReporter) report() { scopes := []string{} for _, scope := range self.scopes { serialized, err := json.Marshal(scope) if err != nil { self.out.Println(jsonMarshalFailure) panic(err) } var buffer bytes.Buffer json.Indent(&buffer, serialized, "", " ") scopes = append(scopes, buffer.String()) } self.out.Print(fmt.Sprintf("%s\n%s,\n%s\n", OpenJson, strings.Join(scopes, ","), CloseJson)) } func (self *JsonReporter) reset() { self.scopes = []*ScopeResult{} self.index = map[string]*ScopeResult{} self.currentKey = nil } func (self *JsonReporter) Write(content []byte) (written int, err error) { self.current.Output += string(content) return len(content), nil } func NewJsonReporter(out *Printer) *JsonReporter { self := new(JsonReporter) self.out = out self.reset() return self } const OpenJson = ">->->OPEN-JSON->->->" // "⌦" const CloseJson = "<-<-<-CLOSE-JSON<-<-<" // "⌫" const jsonMarshalFailure = ` GOCONVEY_JSON_MARSHALL_FAILURE: There was an error when attempting to convert test results to JSON. Please file a bug report and reference the code that caused this failure if possible. Here's the panic: ` mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/convey/reporting/printer.go000066400000000000000000000022701321131462300324120ustar00rootroot00000000000000package reporting import ( "fmt" "io" "strings" ) type Printer struct { out io.Writer prefix string } func (self *Printer) Println(message string, values ...interface{}) { formatted := self.format(message, values...) + newline self.out.Write([]byte(formatted)) } func (self *Printer) Print(message string, values ...interface{}) { formatted := self.format(message, values...) self.out.Write([]byte(formatted)) } func (self *Printer) Insert(text string) { self.out.Write([]byte(text)) } func (self *Printer) format(message string, values ...interface{}) string { var formatted string if len(values) == 0 { formatted = self.prefix + message } else { formatted = self.prefix + fmt.Sprintf(message, values...) } indented := strings.Replace(formatted, newline, newline+self.prefix, -1) return strings.TrimRight(indented, space) } func (self *Printer) Indent() { self.prefix += pad } func (self *Printer) Dedent() { if len(self.prefix) >= padLength { self.prefix = self.prefix[:len(self.prefix)-padLength] } } func NewPrinter(out io.Writer) *Printer { self := new(Printer) self.out = out return self } const space = " " const pad = space + space const padLength = len(pad) mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/convey/reporting/printer_test.go000066400000000000000000000075331321131462300334600ustar00rootroot00000000000000package reporting import "testing" func TestPrint(t *testing.T) { file := newMemoryFile() printer := NewPrinter(file) const expected = "Hello, World!" printer.Print(expected) if file.buffer != expected { t.Errorf("Expected '%s' to equal '%s'.", expected, file.buffer) } } func TestPrintFormat(t *testing.T) { file := newMemoryFile() printer := NewPrinter(file) template := "Hi, %s" name := "Ralph" expected := "Hi, Ralph" printer.Print(template, name) if file.buffer != expected { t.Errorf("Expected '%s' to equal '%s'.", expected, file.buffer) } } func TestPrintPreservesEncodedStrings(t *testing.T) { file := newMemoryFile() printer := NewPrinter(file) const expected = "= -> %3D" printer.Print(expected) if file.buffer != expected { t.Errorf("Expected '%s' to equal '%s'.", expected, file.buffer) } } func TestPrintln(t *testing.T) { file := newMemoryFile() printer := NewPrinter(file) const expected = "Hello, World!" printer.Println(expected) if file.buffer != expected+"\n" { t.Errorf("Expected '%s' to equal '%s'.", expected, file.buffer) } } func TestPrintlnFormat(t *testing.T) { file := newMemoryFile() printer := NewPrinter(file) template := "Hi, %s" name := "Ralph" expected := "Hi, Ralph\n" printer.Println(template, name) if file.buffer != expected { t.Errorf("Expected '%s' to equal '%s'.", expected, file.buffer) } } func TestPrintlnPreservesEncodedStrings(t *testing.T) { file := newMemoryFile() printer := NewPrinter(file) const expected = "= -> %3D" printer.Println(expected) if file.buffer != expected+"\n" { t.Errorf("Expected '%s' to equal '%s'.", expected, file.buffer) } } func TestPrintIndented(t *testing.T) { file := newMemoryFile() printer := NewPrinter(file) const message = "Hello, World!\nGoodbye, World!" const expected = " Hello, World!\n Goodbye, World!" printer.Indent() printer.Print(message) if file.buffer != expected { t.Errorf("Expected '%s' to equal '%s'.", expected, file.buffer) } } func TestPrintDedented(t *testing.T) { file := newMemoryFile() printer := NewPrinter(file) const expected = "Hello, World!\nGoodbye, World!" printer.Indent() printer.Dedent() printer.Print(expected) if file.buffer != expected { t.Errorf("Expected '%s' to equal '%s'.", expected, file.buffer) } } func TestPrintlnIndented(t *testing.T) { file := newMemoryFile() printer := NewPrinter(file) const message = "Hello, World!\nGoodbye, World!" const expected = " Hello, World!\n Goodbye, World!\n" printer.Indent() printer.Println(message) if file.buffer != expected { t.Errorf("Expected '%s' to equal '%s'.", expected, file.buffer) } } func TestPrintlnDedented(t *testing.T) { file := newMemoryFile() printer := NewPrinter(file) const expected = "Hello, World!\nGoodbye, World!" printer.Indent() printer.Dedent() printer.Println(expected) if file.buffer != expected+"\n" { t.Errorf("Expected '%s' to equal '%s'.", expected, file.buffer) } } func TestDedentTooFarShouldNotPanic(t *testing.T) { defer func() { if r := recover(); r != nil { t.Error("Should not have panicked!") } }() file := newMemoryFile() printer := NewPrinter(file) printer.Dedent() t.Log("Getting to this point without panicking means we passed.") } func TestInsert(t *testing.T) { file := newMemoryFile() printer := NewPrinter(file) printer.Indent() printer.Print("Hi") printer.Insert(" there") printer.Dedent() expected := " Hi there" if file.buffer != expected { t.Errorf("Should have written '%s' but instead wrote '%s'.", expected, file.buffer) } } ////////////////// memoryFile //////////////////// type memoryFile struct { buffer string } func (self *memoryFile) Write(p []byte) (n int, err error) { self.buffer += string(p) return len(p), nil } func (self *memoryFile) String() string { return self.buffer } func newMemoryFile() *memoryFile { return new(memoryFile) } mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/convey/reporting/problems.go000066400000000000000000000033231321131462300325520ustar00rootroot00000000000000package reporting import "fmt" type problem struct { silent bool out *Printer errors []*AssertionResult failures []*AssertionResult } func (self *problem) BeginStory(story *StoryReport) {} func (self *problem) Enter(scope *ScopeReport) {} func (self *problem) Report(report *AssertionResult) { if report.Error != nil { self.errors = append(self.errors, report) } else if report.Failure != "" { self.failures = append(self.failures, report) } } func (self *problem) Exit() {} func (self *problem) EndStory() { self.show(self.showErrors, redColor) self.show(self.showFailures, yellowColor) self.prepareForNextStory() } func (self *problem) show(display func(), color string) { if !self.silent { fmt.Print(color) } display() if !self.silent { fmt.Print(resetColor) } self.out.Dedent() } func (self *problem) showErrors() { for i, e := range self.errors { if i == 0 { self.out.Println("\nErrors:\n") self.out.Indent() } self.out.Println(errorTemplate, e.File, e.Line, e.Error, e.StackTrace) } } func (self *problem) showFailures() { for i, f := range self.failures { if i == 0 { self.out.Println("\nFailures:\n") self.out.Indent() } self.out.Println(failureTemplate, f.File, f.Line, f.Failure) } } func (self *problem) Write(content []byte) (written int, err error) { return len(content), nil // no-op } func NewProblemReporter(out *Printer) *problem { self := new(problem) self.out = out self.prepareForNextStory() return self } func NewSilentProblemReporter(out *Printer) *problem { self := NewProblemReporter(out) self.silent = true return self } func (self *problem) prepareForNextStory() { self.errors = []*AssertionResult{} self.failures = []*AssertionResult{} } mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/convey/reporting/problems_test.go000066400000000000000000000025311321131462300336110ustar00rootroot00000000000000package reporting import ( "strings" "testing" ) func TestNoopProblemReporterActions(t *testing.T) { file, reporter := setup() reporter.BeginStory(nil) reporter.Enter(nil) reporter.Exit() expected := "" actual := file.String() if expected != actual { t.Errorf("Expected: '(blank)'\nActual: '%s'", actual) } } func TestReporterPrintsFailuresAndErrorsAtTheEndOfTheStory(t *testing.T) { file, reporter := setup() reporter.Report(NewFailureReport("failed")) reporter.Report(NewErrorReport("error")) reporter.Report(NewSuccessReport()) reporter.EndStory() result := file.String() if !strings.Contains(result, "Errors:\n") { t.Errorf("Expected errors, found none.") } if !strings.Contains(result, "Failures:\n") { t.Errorf("Expected failures, found none.") } // Each stack trace looks like: `* /path/to/file.go`, so look for `* `. // With go 1.4+ there is a line in some stack traces that looks like this: // `testing.(*M).Run(0x2082d60a0, 0x25b7c0)` // So we can't just look for "*" anymore. problemCount := strings.Count(result, "* ") if problemCount != 2 { t.Errorf("Expected one failure and one error (total of 2 '*' characters). Got %d", problemCount) } } func setup() (file *memoryFile, reporter *problem) { monochrome() file = newMemoryFile() printer := NewPrinter(file) reporter = NewProblemReporter(printer) return } mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/convey/reporting/reporter.go000066400000000000000000000021621321131462300325710ustar00rootroot00000000000000package reporting import "io" type Reporter interface { BeginStory(story *StoryReport) Enter(scope *ScopeReport) Report(r *AssertionResult) Exit() EndStory() io.Writer } type reporters struct{ collection []Reporter } func (self *reporters) BeginStory(s *StoryReport) { self.foreach(func(r Reporter) { r.BeginStory(s) }) } func (self *reporters) Enter(s *ScopeReport) { self.foreach(func(r Reporter) { r.Enter(s) }) } func (self *reporters) Report(a *AssertionResult) { self.foreach(func(r Reporter) { r.Report(a) }) } func (self *reporters) Exit() { self.foreach(func(r Reporter) { r.Exit() }) } func (self *reporters) EndStory() { self.foreach(func(r Reporter) { r.EndStory() }) } func (self *reporters) Write(contents []byte) (written int, err error) { self.foreach(func(r Reporter) { written, err = r.Write(contents) }) return written, err } func (self *reporters) foreach(action func(Reporter)) { for _, r := range self.collection { action(r) } } func NewReporters(collection ...Reporter) *reporters { self := new(reporters) self.collection = collection return self } mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/convey/reporting/reporter_test.go000066400000000000000000000040511321131462300336270ustar00rootroot00000000000000package reporting import ( "runtime" "testing" ) func TestEachNestedReporterReceivesTheCallFromTheContainingReporter(t *testing.T) { fake1 := newFakeReporter() fake2 := newFakeReporter() reporter := NewReporters(fake1, fake2) reporter.BeginStory(nil) assertTrue(t, fake1.begun) assertTrue(t, fake2.begun) reporter.Enter(NewScopeReport("scope")) assertTrue(t, fake1.entered) assertTrue(t, fake2.entered) reporter.Report(NewSuccessReport()) assertTrue(t, fake1.reported) assertTrue(t, fake2.reported) reporter.Exit() assertTrue(t, fake1.exited) assertTrue(t, fake2.exited) reporter.EndStory() assertTrue(t, fake1.ended) assertTrue(t, fake2.ended) content := []byte("hi") written, err := reporter.Write(content) assertTrue(t, fake1.written) assertTrue(t, fake2.written) assertEqual(t, written, len(content)) assertNil(t, err) } func assertTrue(t *testing.T, value bool) { if !value { _, _, line, _ := runtime.Caller(1) t.Errorf("Value should have been true (but was false). See line %d", line) } } func assertEqual(t *testing.T, expected, actual int) { if actual != expected { _, _, line, _ := runtime.Caller(1) t.Errorf("Value should have been %d (but was %d). See line %d", expected, actual, line) } } func assertNil(t *testing.T, err error) { if err != nil { _, _, line, _ := runtime.Caller(1) t.Errorf("Error should have been (but wasn't). See line %d", err, line) } } type fakeReporter struct { begun bool entered bool reported bool exited bool ended bool written bool } func newFakeReporter() *fakeReporter { return &fakeReporter{} } func (self *fakeReporter) BeginStory(story *StoryReport) { self.begun = true } func (self *fakeReporter) Enter(scope *ScopeReport) { self.entered = true } func (self *fakeReporter) Report(report *AssertionResult) { self.reported = true } func (self *fakeReporter) Exit() { self.exited = true } func (self *fakeReporter) EndStory() { self.ended = true } func (self *fakeReporter) Write(content []byte) (int, error) { self.written = true return len(content), nil } mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/convey/reporting/reporting.goconvey000066400000000000000000000000241321131462300341570ustar00rootroot00000000000000#ignore -timeout=1s mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/convey/reporting/reports.go000066400000000000000000000102131321131462300324210ustar00rootroot00000000000000package reporting import ( "encoding/json" "fmt" "runtime" "strings" "github.com/smartystreets/goconvey/convey/gotest" ) ////////////////// ScopeReport //////////////////// type ScopeReport struct { Title string File string Line int } func NewScopeReport(title string) *ScopeReport { file, line, _ := gotest.ResolveExternalCaller() self := new(ScopeReport) self.Title = title self.File = file self.Line = line return self } ////////////////// ScopeResult //////////////////// type ScopeResult struct { Title string File string Line int Depth int Assertions []*AssertionResult Output string } func newScopeResult(title string, depth int, file string, line int) *ScopeResult { self := new(ScopeResult) self.Title = title self.Depth = depth self.File = file self.Line = line self.Assertions = []*AssertionResult{} return self } /////////////////// StoryReport ///////////////////// type StoryReport struct { Test T Name string File string Line int } func NewStoryReport(test T) *StoryReport { file, line, name := gotest.ResolveExternalCaller() name = removePackagePath(name) self := new(StoryReport) self.Test = test self.Name = name self.File = file self.Line = line return self } // name comes in looking like "github.com/smartystreets/goconvey/examples.TestName". // We only want the stuff after the last '.', which is the name of the test function. func removePackagePath(name string) string { parts := strings.Split(name, ".") return parts[len(parts)-1] } /////////////////// FailureView //////////////////////// // This struct is also declared in github.com/smartystreets/assertions. // The json struct tags should be equal in both declarations. type FailureView struct { Message string `json:"Message"` Expected string `json:"Expected"` Actual string `json:"Actual"` } ////////////////////AssertionResult ////////////////////// type AssertionResult struct { File string Line int Expected string Actual string Failure string Error interface{} StackTrace string Skipped bool } func NewFailureReport(failure string) *AssertionResult { report := new(AssertionResult) report.File, report.Line = caller() report.StackTrace = stackTrace() parseFailure(failure, report) return report } func parseFailure(failure string, report *AssertionResult) { view := new(FailureView) err := json.Unmarshal([]byte(failure), view) if err == nil { report.Failure = view.Message report.Expected = view.Expected report.Actual = view.Actual } else { report.Failure = failure } } func NewErrorReport(err interface{}) *AssertionResult { report := new(AssertionResult) report.File, report.Line = caller() report.StackTrace = fullStackTrace() report.Error = fmt.Sprintf("%v", err) return report } func NewSuccessReport() *AssertionResult { return new(AssertionResult) } func NewSkipReport() *AssertionResult { report := new(AssertionResult) report.File, report.Line = caller() report.StackTrace = fullStackTrace() report.Skipped = true return report } func caller() (file string, line int) { file, line, _ = gotest.ResolveExternalCaller() return } func stackTrace() string { buffer := make([]byte, 1024*64) n := runtime.Stack(buffer, false) return removeInternalEntries(string(buffer[:n])) } func fullStackTrace() string { buffer := make([]byte, 1024*64) n := runtime.Stack(buffer, true) return removeInternalEntries(string(buffer[:n])) } func removeInternalEntries(stack string) string { lines := strings.Split(stack, newline) filtered := []string{} for _, line := range lines { if !isExternal(line) { filtered = append(filtered, line) } } return strings.Join(filtered, newline) } func isExternal(line string) bool { for _, p := range internalPackages { if strings.Contains(line, p) { return true } } return false } // NOTE: any new packages that host goconvey packages will need to be added here! // An alternative is to scan the goconvey directory and then exclude stuff like // the examples package but that's nasty too. var internalPackages = []string{ "goconvey/assertions", "goconvey/convey", "goconvey/execution", "goconvey/gotest", "goconvey/reporting", } mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/convey/reporting/statistics.go000066400000000000000000000033631321131462300331250ustar00rootroot00000000000000package reporting import "fmt" func (self *statistics) BeginStory(story *StoryReport) {} func (self *statistics) Enter(scope *ScopeReport) {} func (self *statistics) Report(report *AssertionResult) { if !self.failing && report.Failure != "" { self.failing = true } if !self.erroring && report.Error != nil { self.erroring = true } if report.Skipped { self.skipped += 1 } else { self.total++ } } func (self *statistics) Exit() {} func (self *statistics) EndStory() { if !self.suppressed { self.PrintSummary() } } func (self *statistics) Suppress() { self.suppressed = true } func (self *statistics) PrintSummary() { self.reportAssertions() self.reportSkippedSections() self.completeReport() } func (self *statistics) reportAssertions() { self.decideColor() self.out.Print("\n%d total %s", self.total, plural("assertion", self.total)) } func (self *statistics) decideColor() { if self.failing && !self.erroring { fmt.Print(yellowColor) } else if self.erroring { fmt.Print(redColor) } else { fmt.Print(greenColor) } } func (self *statistics) reportSkippedSections() { if self.skipped > 0 { fmt.Print(yellowColor) self.out.Print(" (one or more sections skipped)") } } func (self *statistics) completeReport() { fmt.Print(resetColor) self.out.Print("\n") self.out.Print("\n") } func (self *statistics) Write(content []byte) (written int, err error) { return len(content), nil // no-op } func NewStatisticsReporter(out *Printer) *statistics { self := statistics{} self.out = out return &self } type statistics struct { out *Printer total int failing bool erroring bool skipped int suppressed bool } func plural(word string, count int) string { if count == 1 { return word } return word + "s" } mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/convey/reporting/story.go000066400000000000000000000032331321131462300321070ustar00rootroot00000000000000// TODO: in order for this reporter to be completely honest // we need to retrofit to be more like the json reporter such that: // 1. it maintains ScopeResult collections, which count assertions // 2. it reports only after EndStory(), so that all tick marks // are placed near the appropriate title. // 3. Under unit test package reporting import ( "fmt" "strings" ) type story struct { out *Printer titlesById map[string]string currentKey []string } func (self *story) BeginStory(story *StoryReport) {} func (self *story) Enter(scope *ScopeReport) { self.out.Indent() self.currentKey = append(self.currentKey, scope.Title) ID := strings.Join(self.currentKey, "|") if _, found := self.titlesById[ID]; !found { self.out.Println("") self.out.Print(scope.Title) self.out.Insert(" ") self.titlesById[ID] = scope.Title } } func (self *story) Report(report *AssertionResult) { if report.Error != nil { fmt.Print(redColor) self.out.Insert(error_) } else if report.Failure != "" { fmt.Print(yellowColor) self.out.Insert(failure) } else if report.Skipped { fmt.Print(yellowColor) self.out.Insert(skip) } else { fmt.Print(greenColor) self.out.Insert(success) } fmt.Print(resetColor) } func (self *story) Exit() { self.out.Dedent() self.currentKey = self.currentKey[:len(self.currentKey)-1] } func (self *story) EndStory() { self.titlesById = make(map[string]string) self.out.Println("\n") } func (self *story) Write(content []byte) (written int, err error) { return len(content), nil // no-op } func NewStoryReporter(out *Printer) *story { self := new(story) self.out = out self.titlesById = make(map[string]string) return self } mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/convey/reporting_hooks_test.go000066400000000000000000000165001321131462300331720ustar00rootroot00000000000000package convey import ( "fmt" "net/http" "net/http/httptest" "path" "runtime" "strconv" "strings" "testing" "github.com/smartystreets/goconvey/convey/reporting" ) func TestSingleScopeReported(t *testing.T) { myReporter, test := setupFakeReporter() Convey("A", test, func() { So(1, ShouldEqual, 1) }) expectEqual(t, "Begin|A|Success|Exit|End", myReporter.wholeStory()) } func TestNestedScopeReported(t *testing.T) { myReporter, test := setupFakeReporter() Convey("A", test, func() { Convey("B", func() { So(1, ShouldEqual, 1) }) }) expectEqual(t, "Begin|A|B|Success|Exit|Exit|End", myReporter.wholeStory()) } func TestFailureReported(t *testing.T) { myReporter, test := setupFakeReporter() Convey("A", test, func() { So(1, ShouldBeNil) }) expectEqual(t, "Begin|A|Failure|Exit|End", myReporter.wholeStory()) } func TestFirstFailureEndsScopeExecution(t *testing.T) { myReporter, test := setupFakeReporter() Convey("A", test, func() { So(1, ShouldBeNil) So(nil, ShouldBeNil) }) expectEqual(t, "Begin|A|Failure|Exit|End", myReporter.wholeStory()) } func TestComparisonFailureDeserializedAndReported(t *testing.T) { myReporter, test := setupFakeReporter() Convey("A", test, func() { So("hi", ShouldEqual, "bye") }) expectEqual(t, "Begin|A|Failure(bye/hi)|Exit|End", myReporter.wholeStory()) } func TestNestedFailureReported(t *testing.T) { myReporter, test := setupFakeReporter() Convey("A", test, func() { Convey("B", func() { So(2, ShouldBeNil) }) }) expectEqual(t, "Begin|A|B|Failure|Exit|Exit|End", myReporter.wholeStory()) } func TestSuccessAndFailureReported(t *testing.T) { myReporter, test := setupFakeReporter() Convey("A", test, func() { So(nil, ShouldBeNil) So(1, ShouldBeNil) }) expectEqual(t, "Begin|A|Success|Failure|Exit|End", myReporter.wholeStory()) } func TestIncompleteActionReportedAsSkipped(t *testing.T) { myReporter, test := setupFakeReporter() Convey("A", test, func() { Convey("B", nil) }) expectEqual(t, "Begin|A|B|Skipped|Exit|Exit|End", myReporter.wholeStory()) } func TestSkippedConveyReportedAsSkipped(t *testing.T) { myReporter, test := setupFakeReporter() Convey("A", test, func() { SkipConvey("B", func() { So(1, ShouldEqual, 1) }) }) expectEqual(t, "Begin|A|B|Skipped|Exit|Exit|End", myReporter.wholeStory()) } func TestMultipleSkipsAreReported(t *testing.T) { myReporter, test := setupFakeReporter() Convey("A", test, func() { Convey("0", func() { So(nil, ShouldBeNil) }) SkipConvey("1", func() {}) SkipConvey("2", func() {}) Convey("3", nil) Convey("4", nil) Convey("5", func() { So(nil, ShouldBeNil) }) }) expected := "Begin" + "|A|0|Success|Exit|Exit" + "|A|1|Skipped|Exit|Exit" + "|A|2|Skipped|Exit|Exit" + "|A|3|Skipped|Exit|Exit" + "|A|4|Skipped|Exit|Exit" + "|A|5|Success|Exit|Exit" + "|End" expectEqual(t, expected, myReporter.wholeStory()) } func TestSkippedAssertionIsNotReported(t *testing.T) { myReporter, test := setupFakeReporter() Convey("A", test, func() { SkipSo(1, ShouldEqual, 1) }) expectEqual(t, "Begin|A|Skipped|Exit|End", myReporter.wholeStory()) } func TestMultipleSkippedAssertionsAreNotReported(t *testing.T) { myReporter, test := setupFakeReporter() Convey("A", test, func() { SkipSo(1, ShouldEqual, 1) So(1, ShouldEqual, 1) SkipSo(1, ShouldEqual, 1) }) expectEqual(t, "Begin|A|Skipped|Success|Skipped|Exit|End", myReporter.wholeStory()) } func TestErrorByManualPanicReported(t *testing.T) { myReporter, test := setupFakeReporter() Convey("A", test, func() { panic("Gopher alert!") }) expectEqual(t, "Begin|A|Error|Exit|End", myReporter.wholeStory()) } func TestIterativeConveysReported(t *testing.T) { myReporter, test := setupFakeReporter() Convey("A", test, func() { for x := 0; x < 3; x++ { Convey(strconv.Itoa(x), func() { So(x, ShouldEqual, x) }) } }) expectEqual(t, "Begin|A|0|Success|Exit|Exit|A|1|Success|Exit|Exit|A|2|Success|Exit|Exit|End", myReporter.wholeStory()) } func TestNestedIterativeConveysReported(t *testing.T) { myReporter, test := setupFakeReporter() Convey("A", test, func() { for x := 0; x < 3; x++ { Convey(strconv.Itoa(x), func() { for y := 0; y < 3; y++ { Convey("< "+strconv.Itoa(y), func() { So(x, ShouldBeLessThan, y) }) } }) } }) expectEqual(t, ("Begin|" + "A|0|< 0|Failure|Exit|Exit|Exit|" + "A|0|< 1|Success|Exit|Exit|Exit|" + "A|0|< 2|Success|Exit|Exit|Exit|" + "A|1|< 0|Failure|Exit|Exit|Exit|" + "A|1|< 1|Failure|Exit|Exit|Exit|" + "A|1|< 2|Success|Exit|Exit|Exit|" + "A|2|< 0|Failure|Exit|Exit|Exit|" + "A|2|< 1|Failure|Exit|Exit|Exit|" + "A|2|< 2|Failure|Exit|Exit|Exit|" + "End"), myReporter.wholeStory()) } func TestEmbeddedAssertionReported(t *testing.T) { myReporter, test := setupFakeReporter() Convey("A", test, func(c C) { ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { c.So(r.FormValue("msg"), ShouldEqual, "ping") })) http.DefaultClient.Get(ts.URL + "?msg=ping") }) expectEqual(t, "Begin|A|Success|Exit|End", myReporter.wholeStory()) } func TestEmbeddedContextHelperReported(t *testing.T) { myReporter, test := setupFakeReporter() helper := func(c C) http.HandlerFunc { return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { c.Convey("Embedded", func() { So(r.FormValue("msg"), ShouldEqual, "ping") }) }) } Convey("A", test, func(c C) { ts := httptest.NewServer(helper(c)) http.DefaultClient.Get(ts.URL + "?msg=ping") }) expectEqual(t, "Begin|A|Embedded|Success|Exit|Exit|End", myReporter.wholeStory()) } func expectEqual(t *testing.T, expected interface{}, actual interface{}) { if expected != actual { _, file, line, _ := runtime.Caller(1) t.Errorf("Expected '%v' to be '%v' but it wasn't. See '%s' at line %d.", actual, expected, path.Base(file), line) } } func setupFakeReporter() (*fakeReporter, *fakeGoTest) { myReporter := new(fakeReporter) myReporter.calls = []string{} testReporter = myReporter return myReporter, new(fakeGoTest) } type fakeReporter struct { calls []string } func (self *fakeReporter) BeginStory(story *reporting.StoryReport) { self.calls = append(self.calls, "Begin") } func (self *fakeReporter) Enter(scope *reporting.ScopeReport) { self.calls = append(self.calls, scope.Title) } func (self *fakeReporter) Report(report *reporting.AssertionResult) { if report.Error != nil { self.calls = append(self.calls, "Error") } else if report.Failure != "" { message := "Failure" if report.Expected != "" || report.Actual != "" { message += fmt.Sprintf("(%s/%s)", report.Expected, report.Actual) } self.calls = append(self.calls, message) } else if report.Skipped { self.calls = append(self.calls, "Skipped") } else { self.calls = append(self.calls, "Success") } } func (self *fakeReporter) Exit() { self.calls = append(self.calls, "Exit") } func (self *fakeReporter) EndStory() { self.calls = append(self.calls, "End") } func (self *fakeReporter) Write(content []byte) (int, error) { return len(content), nil // no-op } func (self *fakeReporter) wholeStory() string { return strings.Join(self.calls, "|") } //////////////////////////////// type fakeGoTest struct{} func (self *fakeGoTest) Fail() {} func (self *fakeGoTest) Fatalf(format string, args ...interface{}) {} var test t = new(fakeGoTest) mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/convey/story_conventions_test.go000066400000000000000000000067101321131462300335650ustar00rootroot00000000000000package convey import ( "reflect" "testing" ) func expectPanic(t *testing.T, f string) interface{} { r := recover() if r != nil { if cp, ok := r.(*conveyErr); ok { if cp.fmt != f { t.Error("Incorrect panic message.") } } else { t.Errorf("Incorrect panic type. %s", reflect.TypeOf(r)) } } else { t.Error("Expected panic but none occured") } return r } func TestMissingTopLevelGoTestReferenceCausesPanic(t *testing.T) { output := map[string]bool{} defer expectEqual(t, false, output["good"]) defer expectPanic(t, missingGoTest) Convey("Hi", func() { output["bad"] = true // this shouldn't happen }) } func TestMissingTopLevelGoTestReferenceAfterGoodExample(t *testing.T) { output := map[string]bool{} defer func() { expectEqual(t, true, output["good"]) expectEqual(t, false, output["bad"]) }() defer expectPanic(t, missingGoTest) Convey("Good example", t, func() { output["good"] = true }) Convey("Bad example", func() { output["bad"] = true // shouldn't happen }) } func TestExtraReferencePanics(t *testing.T) { output := map[string]bool{} defer expectEqual(t, false, output["bad"]) defer expectPanic(t, extraGoTest) Convey("Good example", t, func() { Convey("Bad example - passing in *testing.T a second time!", t, func() { output["bad"] = true // shouldn't happen }) }) } func TestParseRegistrationMissingRequiredElements(t *testing.T) { defer expectPanic(t, parseError) Convey() } func TestParseRegistration_MissingNameString(t *testing.T) { defer expectPanic(t, parseError) Convey(func() {}) } func TestParseRegistration_MissingActionFunc(t *testing.T) { defer expectPanic(t, parseError) Convey("Hi there", 12345) } func TestFailureModeNoContext(t *testing.T) { Convey("Foo", t, func() { done := make(chan int, 1) go func() { defer func() { done <- 1 }() defer expectPanic(t, noStackContext) So(len("I have no context"), ShouldBeGreaterThan, 0) }() <-done }) } func TestFailureModeDuplicateSuite(t *testing.T) { Convey("cool", t, func() { defer expectPanic(t, multipleIdenticalConvey) Convey("dup", nil) Convey("dup", nil) }) } func TestFailureModeIndeterminentSuiteNames(t *testing.T) { defer expectPanic(t, differentConveySituations) name := "bob" Convey("cool", t, func() { for i := 0; i < 3; i++ { Convey(name, func() {}) name += "bob" } }) } func TestFailureModeNestedIndeterminentSuiteNames(t *testing.T) { defer expectPanic(t, differentConveySituations) name := "bob" Convey("cool", t, func() { Convey("inner", func() { for i := 0; i < 3; i++ { Convey(name, func() {}) name += "bob" } }) }) } func TestFailureModeParameterButMissing(t *testing.T) { defer expectPanic(t, parseError) prepare() Convey("Foobar", t, FailureHalts) } func TestFailureModeParameterWithAction(t *testing.T) { prepare() Convey("Foobar", t, FailureHalts, func() {}) } func TestExtraConveyParameters(t *testing.T) { defer expectPanic(t, parseError) prepare() Convey("Foobar", t, FailureHalts, func() {}, "This is not supposed to be here") } func TestExtraConveyParameters2(t *testing.T) { defer expectPanic(t, parseError) prepare() Convey("Foobar", t, func() {}, "This is not supposed to be here") } func TestExtraConveyParameters3(t *testing.T) { defer expectPanic(t, parseError) output := prepare() Convey("A", t, func() { output += "A " Convey("B", func() { output += "B " }, "This is not supposed to be here") }) expectEqual(t, "A ", output) } mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/dependencies.go000066400000000000000000000001361321131462300300400ustar00rootroot00000000000000package main import _ "github.com/jtolds/gls" import _ "github.com/smartystreets/assertions" mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/doc_test.go000066400000000000000000000000151321131462300272120ustar00rootroot00000000000000package main mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/examples/000077500000000000000000000000001321131462300267015ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/examples/assertion_examples_test.go000066400000000000000000000100051321131462300341700ustar00rootroot00000000000000package examples import ( "bytes" "io" "testing" "time" . "github.com/smartystreets/goconvey/convey" ) func TestAssertionsAreAvailableFromConveyPackage(t *testing.T) { SetDefaultFailureMode(FailureContinues) defer SetDefaultFailureMode(FailureHalts) Convey("Equality assertions should be accessible", t, func() { thing1a := thing{a: "asdf"} thing1b := thing{a: "asdf"} thing2 := thing{a: "qwer"} So(1, ShouldEqual, 1) So(1, ShouldNotEqual, 2) So(1, ShouldAlmostEqual, 1.000000000000001) So(1, ShouldNotAlmostEqual, 2, 0.5) So(thing1a, ShouldResemble, thing1b) So(thing1a, ShouldNotResemble, thing2) So(&thing1a, ShouldPointTo, &thing1a) So(&thing1a, ShouldNotPointTo, &thing1b) So(nil, ShouldBeNil) So(1, ShouldNotBeNil) So(true, ShouldBeTrue) So(false, ShouldBeFalse) So(0, ShouldBeZeroValue) }) Convey("Numeric comparison assertions should be accessible", t, func() { So(1, ShouldBeGreaterThan, 0) So(1, ShouldBeGreaterThanOrEqualTo, 1) So(1, ShouldBeLessThan, 2) So(1, ShouldBeLessThanOrEqualTo, 1) So(1, ShouldBeBetween, 0, 2) So(1, ShouldNotBeBetween, 2, 4) So(1, ShouldBeBetweenOrEqual, 1, 2) So(1, ShouldNotBeBetweenOrEqual, 2, 4) }) Convey("Container assertions should be accessible", t, func() { So([]int{1, 2, 3}, ShouldContain, 2) So([]int{1, 2, 3}, ShouldNotContain, 4) So(map[int]int{1: 1, 2: 2, 3: 3}, ShouldContainKey, 2) So(map[int]int{1: 1, 2: 2, 3: 3}, ShouldNotContainKey, 4) So(1, ShouldBeIn, []int{1, 2, 3}) So(4, ShouldNotBeIn, []int{1, 2, 3}) So([]int{}, ShouldBeEmpty) So([]int{1}, ShouldNotBeEmpty) So([]int{1, 2}, ShouldHaveLength, 2) }) Convey("String assertions should be accessible", t, func() { So("asdf", ShouldStartWith, "a") So("asdf", ShouldNotStartWith, "z") So("asdf", ShouldEndWith, "df") So("asdf", ShouldNotEndWith, "as") So("", ShouldBeBlank) So("asdf", ShouldNotBeBlank) So("asdf", ShouldContainSubstring, "sd") So("asdf", ShouldNotContainSubstring, "af") }) Convey("Panic recovery assertions should be accessible", t, func() { So(panics, ShouldPanic) So(func() {}, ShouldNotPanic) So(panics, ShouldPanicWith, "Goofy Gophers!") So(panics, ShouldNotPanicWith, "Guileless Gophers!") }) Convey("Type-checking assertions should be accessible", t, func() { // NOTE: Values or pointers may be checked. If a value is passed, // it will be cast as a pointer to the value to avoid cases where // the struct being tested takes pointer receivers. Go allows values // or pointers to be passed as receivers on methods with a value // receiver, but only pointers on methods with pointer receivers. // See: // http://golang.org/doc/effective_go.html#pointers_vs_values // http://golang.org/doc/effective_go.html#blank_implements // http://blog.golang.org/laws-of-reflection So(1, ShouldHaveSameTypeAs, 0) So(1, ShouldNotHaveSameTypeAs, "1") So(bytes.NewBufferString(""), ShouldImplement, (*io.Reader)(nil)) So("string", ShouldNotImplement, (*io.Reader)(nil)) }) Convey("Time assertions should be accessible", t, func() { january1, _ := time.Parse(timeLayout, "2013-01-01 00:00") january2, _ := time.Parse(timeLayout, "2013-01-02 00:00") january3, _ := time.Parse(timeLayout, "2013-01-03 00:00") january4, _ := time.Parse(timeLayout, "2013-01-04 00:00") january5, _ := time.Parse(timeLayout, "2013-01-05 00:00") oneDay, _ := time.ParseDuration("24h0m0s") So(january1, ShouldHappenBefore, january4) So(january1, ShouldHappenOnOrBefore, january1) So(january2, ShouldHappenAfter, january1) So(january2, ShouldHappenOnOrAfter, january2) So(january3, ShouldHappenBetween, january2, january5) So(january3, ShouldHappenOnOrBetween, january3, january5) So(january1, ShouldNotHappenOnOrBetween, january2, january5) So(january2, ShouldHappenWithin, oneDay, january3) So(january5, ShouldNotHappenWithin, oneDay, january1) So([]time.Time{january1, january2}, ShouldBeChronological) }) } type thing struct { a string } func panics() { panic("Goofy Gophers!") } const timeLayout = "2006-01-02 15:04" mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/examples/bowling_game.go000066400000000000000000000037751321131462300316760ustar00rootroot00000000000000package examples // Game contains the state of a bowling game. type Game struct { rolls []int current int } // NewGame allocates and starts a new game of bowling. func NewGame() *Game { game := new(Game) game.rolls = make([]int, maxThrowsPerGame) return game } // Roll rolls the ball and knocks down the number of pins specified by pins. func (self *Game) Roll(pins int) { self.rolls[self.current] = pins self.current++ } // Score calculates and returns the player's current score. func (self *Game) Score() (sum int) { for throw, frame := 0, 0; frame < framesPerGame; frame++ { if self.isStrike(throw) { sum += self.strikeBonusFor(throw) throw += 1 } else if self.isSpare(throw) { sum += self.spareBonusFor(throw) throw += 2 } else { sum += self.framePointsAt(throw) throw += 2 } } return sum } // isStrike determines if a given throw is a strike or not. A strike is knocking // down all pins in one throw. func (self *Game) isStrike(throw int) bool { return self.rolls[throw] == allPins } // strikeBonusFor calculates and returns the strike bonus for a throw. func (self *Game) strikeBonusFor(throw int) int { return allPins + self.framePointsAt(throw+1) } // isSpare determines if a given frame is a spare or not. A spare is knocking // down all pins in one frame with two throws. func (self *Game) isSpare(throw int) bool { return self.framePointsAt(throw) == allPins } // spareBonusFor calculates and returns the spare bonus for a throw. func (self *Game) spareBonusFor(throw int) int { return allPins + self.rolls[throw+2] } // framePointsAt computes and returns the score in a frame specified by throw. func (self *Game) framePointsAt(throw int) int { return self.rolls[throw] + self.rolls[throw+1] } const ( // allPins is the number of pins allocated per fresh throw. allPins = 10 // framesPerGame is the number of frames per bowling game. framesPerGame = 10 // maxThrowsPerGame is the maximum number of throws possible in a single game. maxThrowsPerGame = 21 ) mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/examples/bowling_game_test.go000066400000000000000000000030761321131462300327270ustar00rootroot00000000000000/* Reference: http://butunclebob.com/ArticleS.UncleBob.TheBowlingGameKata See the very first link (which happens to be the very first word of the first paragraph) on the page for a tutorial. */ package examples import ( "testing" . "github.com/smartystreets/goconvey/convey" ) func TestBowlingGameScoring(t *testing.T) { Convey("Given a fresh score card", t, func() { game := NewGame() Convey("When all gutter balls are thrown", func() { game.rollMany(20, 0) Convey("The score should be zero", func() { So(game.Score(), ShouldEqual, 0) }) }) Convey("When all throws knock down only one pin", func() { game.rollMany(20, 1) Convey("The score should be 20", func() { So(game.Score(), ShouldEqual, 20) }) }) Convey("When a spare is thrown", func() { game.rollSpare() game.Roll(3) game.rollMany(17, 0) Convey("The score should include a spare bonus.", func() { So(game.Score(), ShouldEqual, 16) }) }) Convey("When a strike is thrown", func() { game.rollStrike() game.Roll(3) game.Roll(4) game.rollMany(16, 0) Convey("The score should include a strike bonus.", func() { So(game.Score(), ShouldEqual, 24) }) }) Convey("When all strikes are thrown", func() { game.rollMany(21, 10) Convey("The score should be 300.", func() { So(game.Score(), ShouldEqual, 300) }) }) }) } func (self *Game) rollMany(times, pins int) { for x := 0; x < times; x++ { self.Roll(pins) } } func (self *Game) rollSpare() { self.Roll(5) self.Roll(5) } func (self *Game) rollStrike() { self.Roll(10) } mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/examples/doc.go000066400000000000000000000004701321131462300277760ustar00rootroot00000000000000// Package examples contains, well, examples of how to use goconvey to // specify behavior of a system under test. It contains a well-known example // by Robert C. Martin called "Bowling Game Kata" as well as another very // trivial example that demonstrates Reset() and some of the assertions. package examples mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/examples/examples.goconvey000066400000000000000000000006661321131462300323020ustar00rootroot00000000000000// Uncomment the next line to disable the package when running the GoConvey UI: //IGNORE // Uncomment the next line to limit testing to the specified test function name pattern: //-run=TestAssertionsAreAvailableFromConveyPackage // Uncomment the next line to limit testing to those tests that don't bail when testing.Short() is true: //-short // include any additional `go test` flags or application-specific flags below: -timeout=1s mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/examples/simple_example_test.go000066400000000000000000000012761321131462300333010ustar00rootroot00000000000000package examples import ( "testing" . "github.com/smartystreets/goconvey/convey" ) func TestIntegerManipulation(t *testing.T) { t.Parallel() Convey("Given a starting integer value", t, func() { x := 42 Convey("When incremented", func() { x++ Convey("The value should be greater by one", func() { So(x, ShouldEqual, 43) }) Convey("The value should NOT be what it used to be", func() { So(x, ShouldNotEqual, 42) }) }) Convey("When decremented", func() { x-- Convey("The value should be lesser by one", func() { So(x, ShouldEqual, 41) }) Convey("The value should NOT be what it used to be", func() { So(x, ShouldNotEqual, 42) }) }) }) } mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/goconvey.go000066400000000000000000000210531321131462300272440ustar00rootroot00000000000000// This executable provides an HTTP server that watches for file system changes // to .go files within the working directory (and all nested go packages). // Navigating to the configured host and port in a web browser will display the // latest results of running `go test` in each go package. package main import ( "flag" "fmt" "log" "net/http" "os" "os/exec" "path/filepath" "runtime" "strings" "time" "go/build" "github.com/smartystreets/goconvey/web/server/api" "github.com/smartystreets/goconvey/web/server/contract" "github.com/smartystreets/goconvey/web/server/executor" "github.com/smartystreets/goconvey/web/server/messaging" "github.com/smartystreets/goconvey/web/server/parser" "github.com/smartystreets/goconvey/web/server/system" "github.com/smartystreets/goconvey/web/server/watch" ) func init() { flags() folders() } func flags() { flag.IntVar(&port, "port", 8080, "The port at which to serve http.") flag.StringVar(&host, "host", "127.0.0.1", "The host at which to serve http.") flag.DurationVar(&nap, "poll", quarterSecond, "The interval to wait between polling the file system for changes (default: 250ms).") flag.IntVar(&packages, "packages", 10, "The number of packages to test in parallel. Higher == faster but more costly in terms of computing. (default: 10)") flag.StringVar(&gobin, "gobin", "go", "The path to the 'go' binary (default: search on the PATH).") flag.BoolVar(&cover, "cover", true, "Enable package-level coverage statistics. Requires Go 1.2+ and the go cover tool. (default: true)") flag.IntVar(&depth, "depth", -1, "The directory scanning depth. If -1, scan infinitely deep directory structures. 0: scan working directory. 1+: Scan into nested directories, limited to value. (default: -1)") flag.StringVar(&timeout, "timeout", "0", "The test execution timeout if none is specified in the *.goconvey file (default is '0', which is the same as not providing this option).") flag.StringVar(&watchedSuffixes, "watchedSuffixes", ".go", "A comma separated list of file suffixes to watch for modifications (default: .go).") flag.StringVar(&excludedDirs, "excludedDirs", "vendor,node_modules", "A comma separated list of directories that will be excluded from being watched") flag.StringVar(&workDir, "workDir", "", "set goconvey working directory (default current directory)") log.SetOutput(os.Stdout) log.SetFlags(log.LstdFlags | log.Lshortfile) } func folders() { _, file, _, _ := runtime.Caller(0) here := filepath.Dir(file) static = filepath.Join(here, "/web/client") reports = filepath.Join(static, "reports") } func main() { flag.Parse() log.Printf(initialConfiguration, host, port, nap, cover) working := getWorkDir() cover = coverageEnabled(cover, reports) shell := system.NewShell(gobin, reports, cover, timeout) watcherInput := make(chan messaging.WatcherCommand) watcherOutput := make(chan messaging.Folders) excludedDirItems := strings.Split(excludedDirs, `,`) watcher := watch.NewWatcher(working, depth, nap, watcherInput, watcherOutput, watchedSuffixes, excludedDirItems) parser := parser.NewParser(parser.ParsePackageResults) tester := executor.NewConcurrentTester(shell) tester.SetBatchSize(packages) longpollChan := make(chan chan string) executor := executor.NewExecutor(tester, parser, longpollChan) server := api.NewHTTPServer(working, watcherInput, executor, longpollChan) go runTestOnUpdates(watcherOutput, executor, server) go watcher.Listen() go launchBrowser(host, port) serveHTTP(server) } func browserCmd() (string, bool) { browser := map[string]string{ "darwin": "open", "linux": "xdg-open", "win32": "start", } cmd, ok := browser[runtime.GOOS] return cmd, ok } func launchBrowser(host string, port int) { browser, ok := browserCmd() if !ok { log.Printf("Skipped launching browser for this OS: %s", runtime.GOOS) return } log.Printf("Launching browser on %s:%d", host, port) url := fmt.Sprintf("http://%s:%d", host, port) cmd := exec.Command(browser, url) output, err := cmd.CombinedOutput() if err != nil { log.Println(err) } log.Println(string(output)) } func runTestOnUpdates(queue chan messaging.Folders, executor contract.Executor, server contract.Server) { for update := range queue { log.Println("Received request from watcher to execute tests...") packages := extractPackages(update) output := executor.ExecuteTests(packages) root := extractRoot(update, packages) server.ReceiveUpdate(root, output) } } func extractPackages(folderList messaging.Folders) []*contract.Package { packageList := []*contract.Package{} for _, folder := range folderList { hasImportCycle := testFilesImportTheirOwnPackage(folder.Path) packageList = append(packageList, contract.NewPackage(folder, hasImportCycle)) } return packageList } func extractRoot(folderList messaging.Folders, packageList []*contract.Package) string { path := packageList[0].Path folder := folderList[path] return folder.Root } // This method exists because of a bug in the go cover tool that // causes an infinite loop when you try to run `go test -cover` // on a package that has an import cycle defined in one of it's // test files. Yuck. func testFilesImportTheirOwnPackage(packagePath string) bool { meta, err := build.ImportDir(packagePath, build.AllowBinary) if err != nil { return false } for _, dependency := range meta.TestImports { if dependency == meta.ImportPath { return true } } return false } func serveHTTP(server contract.Server) { serveStaticResources() serveAjaxMethods(server) activateServer() } func serveStaticResources() { http.Handle("/", http.FileServer(http.Dir(static))) } func serveAjaxMethods(server contract.Server) { http.HandleFunc("/watch", server.Watch) http.HandleFunc("/ignore", server.Ignore) http.HandleFunc("/reinstate", server.Reinstate) http.HandleFunc("/latest", server.Results) http.HandleFunc("/execute", server.Execute) http.HandleFunc("/status", server.Status) http.HandleFunc("/status/poll", server.LongPollStatus) http.HandleFunc("/pause", server.TogglePause) } func activateServer() { log.Printf("Serving HTTP at: http://%s:%d\n", host, port) err := http.ListenAndServe(fmt.Sprintf("%s:%d", host, port), nil) if err != nil { log.Println(err) } } func coverageEnabled(cover bool, reports string) bool { return (cover && goVersion_1_2_orGreater() && coverToolInstalled() && ensureReportDirectoryExists(reports)) } func goVersion_1_2_orGreater() bool { version := runtime.Version() // 'go1.2....' major, minor := version[2], version[4] version_1_2 := major >= byte('1') && minor >= byte('2') if !version_1_2 { log.Printf(pleaseUpgradeGoVersion, version) return false } return true } func coverToolInstalled() bool { working := getWorkDir() command := system.NewCommand(working, "go", "tool", "cover").Execute() installed := strings.Contains(command.Output, "Usage of 'go tool cover':") if !installed { log.Print(coverToolMissing) return false } return true } func ensureReportDirectoryExists(reports string) bool { result, err := exists(reports) if err != nil { log.Fatal(err) } if result { return true } if err := os.Mkdir(reports, 0755); err == nil { return true } log.Printf(reportDirectoryUnavailable, reports) return false } func exists(path string) (bool, error) { _, err := os.Stat(path) if err == nil { return true, nil } if os.IsNotExist(err) { return false, nil } return false, err } func getWorkDir() string { working := "" var err error if workDir != "" { working = workDir } else { working, err = os.Getwd() if err != nil { log.Fatal(err) } } result, err := exists(working) if err != nil { log.Fatal(err) } if !result { log.Fatalf("Path:%s does not exists", working) } return working } var ( port int host string gobin string nap time.Duration packages int cover bool depth int timeout string watchedSuffixes string excludedDirs string static string reports string quarterSecond = time.Millisecond * 250 workDir string ) const ( initialConfiguration = "Initial configuration: [host: %s] [port: %d] [poll: %v] [cover: %v]\n" pleaseUpgradeGoVersion = "Go version is less that 1.2 (%s), please upgrade to the latest stable version to enable coverage reporting.\n" coverToolMissing = "Go cover tool is not installed or not accessible: for Go < 1.5 run`go get golang.org/x/tools/cmd/cover`\n For >= Go 1.5 run `go install $GOROOT/src/cmd/cover`\n" reportDirectoryUnavailable = "Could not find or create the coverage report directory (at: '%s'). You probably won't see any coverage statistics...\n" ) mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/web/000077500000000000000000000000001321131462300256405ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/web/client/000077500000000000000000000000001321131462300271165ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/web/client/composer.html000066400000000000000000000021151321131462300316320ustar00rootroot00000000000000 GoConvey Composer

mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/web/client/favicon.ico000066400000000000000000000353561321131462300312530ustar00rootroot00000000000000 h6  ¨ž00 ¨%F(  × × /šš0 }} ¥/.¦ /T‚2V$e€3//}†òÈõSzì´ô}/íq:ÿS¹žÿIÿEÿSÁ™ ÿPœšÿ@F¶ÿSÁ™ ÿPššÿ@NN·¡ÿFšÿ@oóÇîœÿH!ü7Ol$0}Òbø}0.=êùûr. ¦/&.¥ }} /œ™™œ0ðÃÃñ€ D@@G‚ |€ùñÃÃð( @ × × W™ÈéøøéÈ™W $šôç¤nK::Kn¤çô›$ ‰ù¹GG¹ù‰ #ÐÛCCÚÐ#/è« ªè/#è——è# Ы  «Ð ‰Û w×þþ·xß‘¡òÿ÷¯ Û‰$ùC¸ÿÿÿÿÿ Øÿ¥»ÿÿÿÿÿÓDù$š¹_ÿÿÉC3‡ûÿÿ¥.ÿÿµ5ŸÿÿM¸š ôG¾ÿõŸÿÿ¥gÿÿG(ÿÿ†Eô Wç÷ÿ´Hÿÿ¥~ÿÿ4ÿÿœæW™¤ÿÿ‘#ÿÿ¥„ÿÿ3ÿÿ¡£™Èp0ÿÿƒÿÿ¥„ÿÿ3ÿÿ¡nÈéK7ÿÿQhrÿÿ¥„ÿÿ3ÿÿ¡Jêø:8ÿÿÇÿÿÿÿ¥„ÿÿ3ÿÿ¡:ùø:8ÿÿy››››e|ÿÿ5ÿÿš:ùéK8ÿÿ`ÿÿP1ÿÿJêÈp8ÿÿ!þÿÏ_¾ÿÿ>nÈ™¤6ÿÿÿÿÿÿÿº£™Wç+ÿÿ„:ùùvuÈà΃ æW ôGþÿIÿÿdEô ›¹Óÿàyÿÿ9¸›$ùCwÿÿ‘ ,äÿäDù$‰Ú Ôÿÿúìÿÿÿ^ Û‰ Ъ®ýÿÿÿîjªÐ #è—GQ:•è#/è« ªè0#ÐÛDDÛÐ# ‰ù¸EE¸ù‰ $šôæ£nJ::Jn£æô›$ W™ÈéøøéÈ™W ÿÀÿÿÿüð?øþðÿÿáÿÿ‡ÃÏøÃÆ`#Œ`œ@8BxB8xB8xB8`B8`B8`B8Â8À8à<x`8xøœ8ùŒñÄÿãÂÿÃáƒÿ‡ðÿÿøþüð?ÿÿÿÀÿ(0` $× × #W¶ÚëùùëÚ¶W#kÄñÿþóçßÔÔßçóþÿñÅlŒêÿýÌ…I))I…ÌýÿëŒ tóÿã%%ãÿót -ÆþèvvèþÆ-Oìþ® ®þìOjøñkiñøjjøìDCìøkOøì;<ìùO-ìñDDñì- ÆþkS€‡>MPH AyŠm+kþÆ tþ® ”îÿÿÿÿú†Zþÿå&Êþÿÿÿÿø› ¯þtóè ÎÿÿÿÿÿÿÿûU±ÿÿåÜÿÿÿÿÿÿÿÿ !éóŒÿv¦ÿÿÿþãÆÐôÿÑöÿÿå€ÿÿÿ÷ÏÜýÿÿü0vÿŒêã4öÿÿü‰1ÈÿÿÿÿåÔÿÿüd «ÿÿÿ‡âêkÿŒÿÿÿ³êÿÿÿå!ðÿÿæEÿÿÿ¾~ÿkÄý%ÒÿÿþAžÿÿÿå7ûÿÿÔ(ÿÿÿÕ "üÄ#ñÌ ûÿÿì_ÿÿÿåBÿÿÿÍ!ÿÿÿÞÉñ#Wÿ†(ÿÿÿÔ 9ÿÿÿåFÿÿÿÍÿÿÿá„ÿWþJ>ÿÿÿÇ*ÿÿÿåFÿÿÿÍÿÿÿáHþ¶ô*JÿÿÿÁÿÿÿåFÿÿÿÍÿÿÿá(ó¶ÚçQÿÿÿ¿(((>ÿÿÿåFÿÿÿÍÿÿÿáæÜëßTÿÿÿ¿)óóóôÿÿÿåFÿÿÿÍÿÿÿáßíùÔTÿÿÿ¿+ÿÿÿÿÿÿÿåFÿÿÿÍÿÿÿáÔùùÔTÿÿÿ¿%ÛÛÛÛÛÛÛÅ?þÿÿÍ#ÿÿÿÜÔùëßTÿÿÿ¿ 4ùÿÿØ,ÿÿÿÒ ßíÚçTÿÿÿ¿ìÿÿëVÿÿÿ´æܶô*Tÿÿÿ¿Ãÿÿÿ“0Íÿÿÿs(ó¶þJTÿÿÿ¿cþÿÿÿïõÿÿÿòHþWÿ…Pÿÿÿ¿ ¹ÿÿÿÿÿÿÿüs„ÿW#ñÌEÿÿÿÂTööö³ ‘èÿÿÿýÕ_Éñ#Åý%/ÿÿÿÌ`ÿÿÿ©;QL/ "üÅlÿ ýÿÿãrÿÿÿ‘~ÿlëãÏÿÿþ=¦ÿÿÿbâëŒÿv‚ÿÿÿ®âÿÿý&vÿŒóè 'ñÿÿü™#³ÿÿÿÄ!éótþ®}þÿÿÿüæäÿÿÿÿö@®þt Æþi ›ýÿÿÿÿÿÿÿÿù|iþÆ -ìñChÞÿÿÿÿÿÿÙSBñì-Oøì<3dyya/9ëùOjøìDBëøkkùñkiñùkOìþ¯!!®þìO-ÆþévvéþÆ- tóÿâ~$"~âÿót ŒêÿýÊ„H((H„ÉüÿëŒkÄñÿþóæßÔÔßæóþÿñÅl#W¶ÚëùùëÚ¶W#ÿÿÿÿÿøÿÿð€ÿÿÀþÿÿÿÿÿÿÿÿàÿüÿÿð?üÿÿø?øÿÿþðÿÿÿÿàð<áà8‡ÃÀ0Ç€0ᇀÀ @áà `qƒà àpð àxð àxð àxð àx àx àx? à|? à| `xÿà`xÿàøÿðøÿðøðxøð|ððÿñ‡ƒðÿá‡àÿáÀÀÿÿÃáÀÿÿ‡àÀÿÿðàÿÿøxÿþüÿÿø?üÿÿð?ÿÿÿàÿÿÿÿÿÿÀþÿÿð€ÿÿøÿÿÿÿÿmongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/web/client/index.html000066400000000000000000000416741321131462300311270ustar00rootroot00000000000000 GoConvey
PASS
Controls
NOTICE:
Coverage
Ignored
No Test Functions
No Test Files
No Go Files
Build Failures
Panics
Failures
Stories
LOG
Last test : / /
LIVE REPLAY PAUSED
mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/web/client/resources/000077500000000000000000000000001321131462300311305ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/web/client/resources/css/000077500000000000000000000000001321131462300317205ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/web/client/resources/css/common.css000066400000000000000000000326131321131462300337270ustar00rootroot00000000000000/* Eric Meyer's Reset CSS v2.0 */ html,body,div,span,applet,object,iframe,h1,h2,h3,h4,h5,h6,p,blockquote,pre,a,abbr,acronym,address,big,cite,code,del,dfn,em,img,ins,kbd,q,s,samp,small,strike,strong,sub,sup,tt,var,b,u,i,center,dl,dt,dd,ol,ul,li,fieldset,form,label,legend,table,caption,tbody,tfoot,thead,tr,th,td,article,aside,canvas,details,embed,figure,figcaption,footer,header,hgroup,menu,nav,output,ruby,section,summary,time,mark,audio,video{border:0;font-size:100%;font:inherit;vertical-align:baseline;margin:0;padding:0}article,aside,details,figcaption,figure,footer,header,hgroup,menu,nav,section{display:block}body{line-height:1}ol,ul{list-style:none}blockquote,q{quotes:none}blockquote:before,blockquote:after,q:before,q:after{content:none}table{border-collapse:collapse;border-spacing:0} @font-face { font-family: 'Open Sans'; src: local("Open Sans"), url("../fonts/Open_Sans/OpenSans-Regular.ttf"); } @font-face { font-family: 'Orbitron'; src: local("Orbitron"), url("../fonts/Orbitron/Orbitron-Regular.ttf"); } @font-face { font-family: 'Oswald'; src: local("Oswald"), url("../fonts/Oswald/Oswald-Regular.ttf"); } ::selection { background: #87AFBC; color: #FFF; text-shadow: none; } ::-moz-selection { background: #87AFBC; color: #FFF; text-shadow: none; } ::-webkit-input-placeholder { font-style: italic; } :-moz-placeholder { font-style: italic; } ::-moz-placeholder { font-style: italic; } :-ms-input-placeholder { font-style: italic; } html, body { height: 100%; min-height: 100%; } body { -webkit-transform: translate3d(0, 0, 0); /* attempts to fix Chrome glitching on Mac */ background-position: fixed; background-repeat: no-repeat; font-family: Menlo, Monaco, 'Courier New', monospace; line-height: 1.5em; font-size: 14px; overflow: hidden; display: none; } a { text-decoration: none; } a:hover { text-decoration: underline; } a.fa { text-decoration: none; } b { font-weight: bold; } i { font-style: italic; } hr { border: 0; background: 0; height: 0; margin: 0; padding: 0; } input[type=text] { -webkit-box-sizing: border-box; -moz-box-sizing: border-box; box-sizing: border-box; background: none; border: none; border-bottom-width: 1px; border-bottom-style: solid; outline: none; padding-bottom: .1em; font: 300 18px/1.5em 'Open Sans', sans-serif; } .overall { padding: 30px 0 15px; position: relative; z-index: 50; } .status { line-height: 1em; font-family: 'Orbitron', monospace; text-align: center; } .overall .status { font-size: 46px; letter-spacing: 5px; text-transform: uppercase; white-space: nowrap; } .toggler { font-size: 10px; padding: 3px 5px; text-decoration: none; text-transform: uppercase; cursor: pointer; line-height: 1.5em; } .toggler.narrow { display: none; } .togglable { overflow-x: auto; } .controls { font-size: 18px; line-height: 1em; } .controls li { text-decoration: none; display: block; float: left; padding: .75em; cursor: pointer; } .server-down { display: none; text-align: center; padding: 10px 0; } footer .server-down { padding: 8px 15px; text-transform: uppercase; } #logo { font-family: 'Oswald', 'Impact', 'Arial Black', sans-serif; } #path-container { margin-top: .4em; } #path { width: 100%; text-align: center; border-bottom-width: 0; } #path:hover, #path:focus { border-bottom-width: 1px; } .expandable { -webkit-box-sizing: border-box; -moz-box-sizing: border-box; box-sizing: border-box; border-top-width: 1px; border-top-style: solid; overflow-y: hidden; overflow-x: auto; text-align: center; white-space: nowrap; display: none; } .settings { white-space: normal; overflow-x: auto; white-space: nowrap; } .settings .setting-meta, .settings .setting-val { display: inline-block; } .settings .container { padding: 15px 0; } .settings .setting { font-size: 13px; display: inline-block; margin-right: 5%; } .settings .setting:first-child { margin-left: 5%; } .settings .setting .setting-meta { text-align: right; padding-right: 1em; vertical-align: middle; max-width: 150px; } .settings .setting .setting-meta small { font-size: 8px; text-transform: uppercase; display: block; line-height: 1.25em; } .history .container { padding: 15px 0 15px 25%; } .history .item { -webkit-box-sizing: border-box; -moz-box-sizing: border-box; box-sizing: border-box; transition: all .1s linear; -moz-transition: all .1s linear; -webkit-transition: all .1s linear; -o-transition: all .1s linear; display: inline-block; text-align: left; margin: 0 20px; padding: 20px; height: 100%; width: 175px; opacity: .7; cursor: pointer; } .history .item:hover { opacity: 1; } .history .item:nth-child(odd):hover { -webkit-transform: scale(1.1) rotate(5deg); -moz-transform: scale(1.1) rotate(5deg); } .history .item:nth-child(even):hover { -webkit-transform: scale(1.1) rotate(-5deg); -moz-transform: scale(1.1) rotate(-5deg); } .history .item .summary { font: 14px/1.5em 'Monaco', 'Menlo', 'Courier New', monospace; } .history .item.selected { opacity: 1; } .history .status { font-size: 13px; } .frame { position: relative; z-index: 0; width: 100%; } .frame .col { -webkit-box-sizing: border-box; -moz-box-sizing: border-box; box-sizing: border-box; border-right-width: 1px; border-right-style: solid; float: left; height: 100%; overflow-y: auto; } .frame .col:first-child { border-left: none; } .frame .col:last-child { border-right: none; } #col-1 { width: 15%; } #col-2 { width: 60%; } #col-3 { width: 25%; } #coverage { font-size: 10px; white-space: nowrap; } #coverage-color-template { display: none; } .rtl { direction: rtl; } .pkg-cover { position: relative; } .pkg-cover a { color: inherit !important; text-decoration: none; } .pkg-cover-bar { position: absolute; top: 0; left: 0; height: 100%; z-index: 1; } .pkg-cover-name { position: relative; z-index: 2; } .pkg-cover-name, .pkg-list { font-family: 'Menlo', monospace; font-size: 10px; padding-right: 2%; white-space: nowrap; } .buildfail-pkg, .panic-pkg, .failure-pkg { padding: 5px 10px; font: 14px 'Open Sans', sans-serif; } .buildfail-output, .panic-output, .failure-output { padding: 10px; font-size: 12px; line-height: 1.25em; overflow-y: auto; white-space: pre-wrap; font-family: 'Menlo', monospace; } .panic-story, .failure-story { font-size: 10px; line-height: 1.25em; font-family: 'Open Sans', sans-serif; } .panic-summary { font-size: 14px; font-weight: bold; line-height: 1.5em; } .panic-file, .failure-file { font-size: 13px; line-height: 1.5em; } .diffviewer { border-collapse: collapse; width: 100%; } .diffviewer td { border-bottom-width: 1px; border-bottom-style: solid; padding: 2px 5px; font-size: 14px; } .diffviewer .original, .diffviewer .changed, .diffviewer .diff { white-space: pre-wrap; } .diffviewer tr:first-child td { border-top-width: 1px; border-top-style: solid; } .diffviewer td:first-child { width: 65px; font-size: 10px; border-right-width: 1px; border-right-style: solid; text-transform: uppercase; } .diff ins { text-decoration: none; } #stories table { width: 100%; } .story-pkg { cursor: pointer; } .story-pkg td { font: 16px 'Open Sans', sans-serif; white-space: nowrap; padding: 10px; } .story-pkg td:first-child { width: 1em; } .story-line { font: 12px 'Open Sans', sans-serif; cursor: default; } .story-line td { padding-top: 7px; padding-bottom: 7px; } .pkg-toggle-container { position: relative; display: inline-block; } .toggle-all-pkg { font-size: 10px; text-transform: uppercase; position: absolute; padding: 5px; font-family: 'Menlo', 'Open Sans', sans-serif; display: none; } .story-line-summary-container { padding: 0 10px 0 10px; white-space: nowrap; width: 35px; text-align: center; } .story-line-status { width: 6px; min-width: 6px; height: 100%; } .story-line-desc { padding: 5px; } .story-line-desc .message { font-family: 'Menlo', monospace; white-space: pre-wrap; } .statusicon { font: 14px 'Open Sans', sans-serif; } .statusicon.skip { font-size: 16px; } .depth-0 { padding-left: 1.5em !important; } .depth-1 { padding-left: 3em !important; } .depth-2 { padding-left: 4.5em !important; } .depth-3 { padding-left: 6em !important; } .depth-4 { padding-left: 7.5em !important; } .depth-5 { padding-left: 9em !important; } .depth-6 { padding-left: 10.5em !important; } .depth-7 { padding-left: 11em !important; } .log { font-size: 11px; line-height: 1.5em; padding: 5px; padding-bottom: .5em; } .log .line { white-space: pre-wrap; padding-left: 2em; text-indent: -2em; } footer { -webkit-box-sizing: border-box; -moz-box-sizing: border-box; box-sizing: border-box; position: absolute; bottom: 0; left: 0; padding: 5px 15px; width: 100%; border-top-width: 1px; border-top-style: solid; font-size: 12px; } footer section { float: left; } footer section:first-child { width: 80%; } footer section:last-child { text-align: right; width: 20%; } footer .info { padding: 0 10px; } footer .info:first-child { padding-left: 0; } #narrow-summary { display: none; } footer .replay, footer .paused { display: none; } footer .replay { cursor: pointer; } footer .server-down .notice-message { font-size: 10px; } .rel { position: relative; } .text-right { text-align: right; } .text-center { text-align: center; } .text-left { text-align: left; } .float-left { float: left; } .float-right { float: right; } .clear { clear: both; } .nowrap { white-space: nowrap; } .clr-blue { color: #2B597F; } .show { display: block; } .hide { display: none; } .enum { cursor: pointer; display: inline-block; font-size: 12px; border-width: 1px; border-style: solid; border-radius: 9px; vertical-align: middle; } .enum > li { display: block; float: left; padding: 5px 12px; border-left-width: 1px; border-left-style: solid; } .enum > li:first-child { border-left: 0px; border-top-left-radius: 8px; border-bottom-left-radius: 8px; } .enum > li:last-child { border-top-right-radius: 8px; border-bottom-right-radius: 8px; } .disabled { cursor: default !important; background: transparent !important; } .spin-once { -webkit-animation: spin 0.5s 1 ease; animation: spin 0.5s 1 ease; } .spin-slowly { -webkit-animation: spin .75s infinite linear; animation: spin .75s infinite linear; } .throb { -webkit-animation: throb 2.5s ease-in-out infinite; -moz-animation: throb 2.5s ease-in-out infinite; -o-animation: throb 2.5s ease-in-out infinite; animation: throb 2.5s ease-in-out infinite; } .flash { -webkit-animation: flash 4s linear infinite; -moz-animation: flash 4s linear infinite; -o-animation: flash 4s linear infinite; animation: flash 4s linear infinite; } /* Clearfix */ .cf:before, .cf:after { content: " "; display: table; } .cf:after { clear: both; } @media (max-width: 1099px) { #col-1 { width: 25%; } #col-2 { width: 75%; border-right: none; } #col-3 { display: none; } footer #duration { display: none; } } @media (max-width: 900px) { footer #last-test-container { display: none; } } @media (min-width: 850px) and (max-width: 1220px) { #path { font-size: 14px; margin-top: 5px; } } @media (min-width: 700px) and (max-width: 849px) { #path { font-size: 12px; margin-top: 8px; } } @media (max-width: 799px) { #col-1 { display: none; } #col-2 { width: 100%; } #stories .story-pkg-name { font-size: 14px; } #stories .story-pkg-watch-td { display: none; } } @media (max-width: 700px) { #path-container { display: none; } footer #time { display: none; } footer .info { padding: 0 5px; } footer .server-down .notice-message { display: none; } } @media (max-width: 499px) { .toggler.narrow { display: block; } #show-gen { display: none; } .hide-narrow { display: none; } .show-narrow { display: block; } .overall .status { font-size: 28px; letter-spacing: 1px; } .toggler { display: block; } .controls ul { text-align: center; float: none; } .controls li { display: inline-block; float: none; } .enum > li { float: left; display: block; } #logo { display: none; } .history .item { margin: 0 5px; } .history .item .summary { display: none; } .server-down { font-size: 14px; } #stories .story-pkg-name { font-size: 16px; } #stories .not-pkg-name { display: none; } footer #duration { display: none; } footer #summary { display: none; } footer #narrow-summary { display: inline; } } /** Custom CSS Animations **/ @-webkit-keyframes throb { 0% { opacity: 1; } 50% { opacity: .35; } 100% { opacity: 1; } } @-moz-keyframes throb { 0% { opacity: 1; } 50% { opacity: .35; } 100% { opacity: 1; } } @-o-keyframes throb { 0% { opacity: 1; } 50% { opacity: .35; } 100% { opacity: 1; } } @keyframes throb { 0% { opacity: 1; } 50% { opacity: .35; } 100% { opacity: 1; } } @-webkit-keyframes flash { 70% { opacity: 1; } 90% { opacity: 0; } 98% { opacity: 0; } 100% { opacity: 1; } } @-moz-keyframes flash { 70% { opacity: 1; } 90% { opacity: 0; } 98% { opacity: 0; } 100% { opacity: 1; } } @-o-keyframes flash { 70% { opacity: 1; } 90% { opacity: 0; } 98% { opacity: 0; } 100% { opacity: 1; } } @keyframes flash { 70% { opacity: 1; } 90% { opacity: 0; } 98% { opacity: 0; } 100% { opacity: 1; } } /* #coverage { perspective: 1000; } #coverage .pkg-cover { -webkit-transition: .7s; transform-style: preserve-3d; position: relative; } #coverage:hover .pkg-cover { -webkit-transform: rotateX(180deg); }*/ composer.css000066400000000000000000000034371321131462300342110ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/web/client/resources/css/* Eric Meyer's Reset CSS v2.0 */ html,body,div,span,applet,object,iframe,h1,h2,h3,h4,h5,h6,p,blockquote,pre,a,abbr,acronym,address,big,cite,code,del,dfn,em,img,ins,kbd,q,s,samp,small,strike,strong,sub,sup,tt,var,b,u,i,center,dl,dt,dd,ol,ul,li,fieldset,form,label,legend,table,caption,tbody,tfoot,thead,tr,th,td,article,aside,canvas,details,embed,figure,figcaption,footer,header,hgroup,menu,nav,output,ruby,section,summary,time,mark,audio,video{border:0;font-size:100%;font:inherit;vertical-align:baseline;margin:0;padding:0}article,aside,details,figcaption,figure,footer,header,hgroup,menu,nav,section{display:block}body{line-height:1}ol,ul{list-style:none}blockquote,q{quotes:none}blockquote:before,blockquote:after,q:before,q:after{content:none}table{border-collapse:collapse;border-spacing:0} @font-face { font-family: 'Open Sans'; src: local("Open Sans"), url("../fonts/Open_Sans/OpenSans-Regular.ttf"); } @font-face { font-family: 'Oswald'; src: local("Oswald"), url("../fonts/Oswald/Oswald-Regular.ttf"); } body { font-family: 'Open Sans', 'Helvetica Neue', sans-serif; font-size: 16px; } header { background: #2C3F49; padding: 10px; } .logo { font-family: Oswald, sans-serif; font-size: 24px; margin-right: 5px; color: #DDD; } .afterlogo { font-size: 12px; text-transform: uppercase; position: relative; top: -3px; color: #999; } #input, #output { -webkit-box-sizing: border-box; -moz-box-sizing: border-box; box-sizing: border-box; padding: 15px; height: 80%; float: left; overflow: auto; } #input { border: 0; font: 300 18px/1.5em 'Open Sans'; resize: none; outline: none; width: 50%; } #output { width: 50%; display: inline-block; background: #F0F0F0; font: 14px/1.25em 'Menlo', 'Monaco', 'Courier New', monospace; border-left: 1px solid #CCC; white-space: pre-wrap; }font-awesome.min.css000066400000000000000000000505341321131462300355500ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/web/client/resources/css/*! * Font Awesome 4.1.0 by @davegandy - http://fontawesome.io - @fontawesome * License - http://fontawesome.io/license (Font: SIL OFL 1.1, CSS: MIT License) */ @font-face{font-family:'FontAwesome';src:url('../fonts/FontAwesome/fontawesome-webfont.eot?v=4.1.0');src:url('../fonts/FontAwesome/fontawesome-webfont.eot?#iefix&v=4.1.0') format('embedded-opentype'),url('../fonts/FontAwesome/fontawesome-webfont.woff?v=4.1.0') format('woff'),url('../fonts/FontAwesome/fontawesome-webfont.ttf?v=4.1.0') format('truetype'),url('../fonts/FontAwesome/fontawesome-webfont.svg?v=4.1.0#fontawesomeregular') format('svg');font-weight:normal;font-style:normal}.fa{display:inline-block;font-family:FontAwesome;font-style:normal;font-weight:normal;line-height:1;-webkit-font-smoothing:antialiased;-moz-osx-font-smoothing:grayscale}.fa-lg{font-size:1.33333333em;line-height:.75em;vertical-align:-15%}.fa-2x{font-size:2em}.fa-3x{font-size:3em}.fa-4x{font-size:4em}.fa-5x{font-size:5em}.fa-fw{width:1.28571429em;text-align:center}.fa-ul{padding-left:0;margin-left:2.14285714em;list-style-type:none}.fa-ul>li{position:relative}.fa-li{position:absolute;left:-2.14285714em;width:2.14285714em;top:.14285714em;text-align:center}.fa-li.fa-lg{left:-1.85714286em}.fa-border{padding:.2em .25em .15em;border:solid .08em #eee;border-radius:.1em}.pull-right{float:right}.pull-left{float:left}.fa.pull-left{margin-right:.3em}.fa.pull-right{margin-left:.3em}.fa-spin{-webkit-animation:spin 2s infinite linear;-moz-animation:spin 2s infinite linear;-o-animation:spin 2s infinite linear;animation:spin 2s infinite linear}@-moz-keyframes spin{0%{-moz-transform:rotate(0deg)}100%{-moz-transform:rotate(359deg)}}@-webkit-keyframes spin{0%{-webkit-transform:rotate(0deg)}100%{-webkit-transform:rotate(359deg)}}@-o-keyframes spin{0%{-o-transform:rotate(0deg)}100%{-o-transform:rotate(359deg)}}@keyframes spin{0%{-webkit-transform:rotate(0deg);transform:rotate(0deg)}100%{-webkit-transform:rotate(359deg);transform:rotate(359deg)}}.fa-rotate-90{filter:progid:DXImageTransform.Microsoft.BasicImage(rotation=1);-webkit-transform:rotate(90deg);-moz-transform:rotate(90deg);-ms-transform:rotate(90deg);-o-transform:rotate(90deg);transform:rotate(90deg)}.fa-rotate-180{filter:progid:DXImageTransform.Microsoft.BasicImage(rotation=2);-webkit-transform:rotate(180deg);-moz-transform:rotate(180deg);-ms-transform:rotate(180deg);-o-transform:rotate(180deg);transform:rotate(180deg)}.fa-rotate-270{filter:progid:DXImageTransform.Microsoft.BasicImage(rotation=3);-webkit-transform:rotate(270deg);-moz-transform:rotate(270deg);-ms-transform:rotate(270deg);-o-transform:rotate(270deg);transform:rotate(270deg)}.fa-flip-horizontal{filter:progid:DXImageTransform.Microsoft.BasicImage(rotation=0, mirror=1);-webkit-transform:scale(-1, 1);-moz-transform:scale(-1, 1);-ms-transform:scale(-1, 1);-o-transform:scale(-1, 1);transform:scale(-1, 1)}.fa-flip-vertical{filter:progid:DXImageTransform.Microsoft.BasicImage(rotation=2, mirror=1);-webkit-transform:scale(1, -1);-moz-transform:scale(1, -1);-ms-transform:scale(1, -1);-o-transform:scale(1, -1);transform:scale(1, -1)}.fa-stack{position:relative;display:inline-block;width:2em;height:2em;line-height:2em;vertical-align:middle}.fa-stack-1x,.fa-stack-2x{position:absolute;left:0;width:100%;text-align:center}.fa-stack-1x{line-height:inherit}.fa-stack-2x{font-size:2em}.fa-inverse{color:#fff}.fa-glass:before{content:"\f000"}.fa-music:before{content:"\f001"}.fa-search:before{content:"\f002"}.fa-envelope-o:before{content:"\f003"}.fa-heart:before{content:"\f004"}.fa-star:before{content:"\f005"}.fa-star-o:before{content:"\f006"}.fa-user:before{content:"\f007"}.fa-film:before{content:"\f008"}.fa-th-large:before{content:"\f009"}.fa-th:before{content:"\f00a"}.fa-th-list:before{content:"\f00b"}.fa-check:before{content:"\f00c"}.fa-times:before{content:"\f00d"}.fa-search-plus:before{content:"\f00e"}.fa-search-minus:before{content:"\f010"}.fa-power-off:before{content:"\f011"}.fa-signal:before{content:"\f012"}.fa-gear:before,.fa-cog:before{content:"\f013"}.fa-trash-o:before{content:"\f014"}.fa-home:before{content:"\f015"}.fa-file-o:before{content:"\f016"}.fa-clock-o:before{content:"\f017"}.fa-road:before{content:"\f018"}.fa-download:before{content:"\f019"}.fa-arrow-circle-o-down:before{content:"\f01a"}.fa-arrow-circle-o-up:before{content:"\f01b"}.fa-inbox:before{content:"\f01c"}.fa-play-circle-o:before{content:"\f01d"}.fa-rotate-right:before,.fa-repeat:before{content:"\f01e"}.fa-refresh:before{content:"\f021"}.fa-list-alt:before{content:"\f022"}.fa-lock:before{content:"\f023"}.fa-flag:before{content:"\f024"}.fa-headphones:before{content:"\f025"}.fa-volume-off:before{content:"\f026"}.fa-volume-down:before{content:"\f027"}.fa-volume-up:before{content:"\f028"}.fa-qrcode:before{content:"\f029"}.fa-barcode:before{content:"\f02a"}.fa-tag:before{content:"\f02b"}.fa-tags:before{content:"\f02c"}.fa-book:before{content:"\f02d"}.fa-bookmark:before{content:"\f02e"}.fa-print:before{content:"\f02f"}.fa-camera:before{content:"\f030"}.fa-font:before{content:"\f031"}.fa-bold:before{content:"\f032"}.fa-italic:before{content:"\f033"}.fa-text-height:before{content:"\f034"}.fa-text-width:before{content:"\f035"}.fa-align-left:before{content:"\f036"}.fa-align-center:before{content:"\f037"}.fa-align-right:before{content:"\f038"}.fa-align-justify:before{content:"\f039"}.fa-list:before{content:"\f03a"}.fa-dedent:before,.fa-outdent:before{content:"\f03b"}.fa-indent:before{content:"\f03c"}.fa-video-camera:before{content:"\f03d"}.fa-photo:before,.fa-image:before,.fa-picture-o:before{content:"\f03e"}.fa-pencil:before{content:"\f040"}.fa-map-marker:before{content:"\f041"}.fa-adjust:before{content:"\f042"}.fa-tint:before{content:"\f043"}.fa-edit:before,.fa-pencil-square-o:before{content:"\f044"}.fa-share-square-o:before{content:"\f045"}.fa-check-square-o:before{content:"\f046"}.fa-arrows:before{content:"\f047"}.fa-step-backward:before{content:"\f048"}.fa-fast-backward:before{content:"\f049"}.fa-backward:before{content:"\f04a"}.fa-play:before{content:"\f04b"}.fa-pause:before{content:"\f04c"}.fa-stop:before{content:"\f04d"}.fa-forward:before{content:"\f04e"}.fa-fast-forward:before{content:"\f050"}.fa-step-forward:before{content:"\f051"}.fa-eject:before{content:"\f052"}.fa-chevron-left:before{content:"\f053"}.fa-chevron-right:before{content:"\f054"}.fa-plus-circle:before{content:"\f055"}.fa-minus-circle:before{content:"\f056"}.fa-times-circle:before{content:"\f057"}.fa-check-circle:before{content:"\f058"}.fa-question-circle:before{content:"\f059"}.fa-info-circle:before{content:"\f05a"}.fa-crosshairs:before{content:"\f05b"}.fa-times-circle-o:before{content:"\f05c"}.fa-check-circle-o:before{content:"\f05d"}.fa-ban:before{content:"\f05e"}.fa-arrow-left:before{content:"\f060"}.fa-arrow-right:before{content:"\f061"}.fa-arrow-up:before{content:"\f062"}.fa-arrow-down:before{content:"\f063"}.fa-mail-forward:before,.fa-share:before{content:"\f064"}.fa-expand:before{content:"\f065"}.fa-compress:before{content:"\f066"}.fa-plus:before{content:"\f067"}.fa-minus:before{content:"\f068"}.fa-asterisk:before{content:"\f069"}.fa-exclamation-circle:before{content:"\f06a"}.fa-gift:before{content:"\f06b"}.fa-leaf:before{content:"\f06c"}.fa-fire:before{content:"\f06d"}.fa-eye:before{content:"\f06e"}.fa-eye-slash:before{content:"\f070"}.fa-warning:before,.fa-exclamation-triangle:before{content:"\f071"}.fa-plane:before{content:"\f072"}.fa-calendar:before{content:"\f073"}.fa-random:before{content:"\f074"}.fa-comment:before{content:"\f075"}.fa-magnet:before{content:"\f076"}.fa-chevron-up:before{content:"\f077"}.fa-chevron-down:before{content:"\f078"}.fa-retweet:before{content:"\f079"}.fa-shopping-cart:before{content:"\f07a"}.fa-folder:before{content:"\f07b"}.fa-folder-open:before{content:"\f07c"}.fa-arrows-v:before{content:"\f07d"}.fa-arrows-h:before{content:"\f07e"}.fa-bar-chart-o:before{content:"\f080"}.fa-twitter-square:before{content:"\f081"}.fa-facebook-square:before{content:"\f082"}.fa-camera-retro:before{content:"\f083"}.fa-key:before{content:"\f084"}.fa-gears:before,.fa-cogs:before{content:"\f085"}.fa-comments:before{content:"\f086"}.fa-thumbs-o-up:before{content:"\f087"}.fa-thumbs-o-down:before{content:"\f088"}.fa-star-half:before{content:"\f089"}.fa-heart-o:before{content:"\f08a"}.fa-sign-out:before{content:"\f08b"}.fa-linkedin-square:before{content:"\f08c"}.fa-thumb-tack:before{content:"\f08d"}.fa-external-link:before{content:"\f08e"}.fa-sign-in:before{content:"\f090"}.fa-trophy:before{content:"\f091"}.fa-github-square:before{content:"\f092"}.fa-upload:before{content:"\f093"}.fa-lemon-o:before{content:"\f094"}.fa-phone:before{content:"\f095"}.fa-square-o:before{content:"\f096"}.fa-bookmark-o:before{content:"\f097"}.fa-phone-square:before{content:"\f098"}.fa-twitter:before{content:"\f099"}.fa-facebook:before{content:"\f09a"}.fa-github:before{content:"\f09b"}.fa-unlock:before{content:"\f09c"}.fa-credit-card:before{content:"\f09d"}.fa-rss:before{content:"\f09e"}.fa-hdd-o:before{content:"\f0a0"}.fa-bullhorn:before{content:"\f0a1"}.fa-bell:before{content:"\f0f3"}.fa-certificate:before{content:"\f0a3"}.fa-hand-o-right:before{content:"\f0a4"}.fa-hand-o-left:before{content:"\f0a5"}.fa-hand-o-up:before{content:"\f0a6"}.fa-hand-o-down:before{content:"\f0a7"}.fa-arrow-circle-left:before{content:"\f0a8"}.fa-arrow-circle-right:before{content:"\f0a9"}.fa-arrow-circle-up:before{content:"\f0aa"}.fa-arrow-circle-down:before{content:"\f0ab"}.fa-globe:before{content:"\f0ac"}.fa-wrench:before{content:"\f0ad"}.fa-tasks:before{content:"\f0ae"}.fa-filter:before{content:"\f0b0"}.fa-briefcase:before{content:"\f0b1"}.fa-arrows-alt:before{content:"\f0b2"}.fa-group:before,.fa-users:before{content:"\f0c0"}.fa-chain:before,.fa-link:before{content:"\f0c1"}.fa-cloud:before{content:"\f0c2"}.fa-flask:before{content:"\f0c3"}.fa-cut:before,.fa-scissors:before{content:"\f0c4"}.fa-copy:before,.fa-files-o:before{content:"\f0c5"}.fa-paperclip:before{content:"\f0c6"}.fa-save:before,.fa-floppy-o:before{content:"\f0c7"}.fa-square:before{content:"\f0c8"}.fa-navicon:before,.fa-reorder:before,.fa-bars:before{content:"\f0c9"}.fa-list-ul:before{content:"\f0ca"}.fa-list-ol:before{content:"\f0cb"}.fa-strikethrough:before{content:"\f0cc"}.fa-underline:before{content:"\f0cd"}.fa-table:before{content:"\f0ce"}.fa-magic:before{content:"\f0d0"}.fa-truck:before{content:"\f0d1"}.fa-pinterest:before{content:"\f0d2"}.fa-pinterest-square:before{content:"\f0d3"}.fa-google-plus-square:before{content:"\f0d4"}.fa-google-plus:before{content:"\f0d5"}.fa-money:before{content:"\f0d6"}.fa-caret-down:before{content:"\f0d7"}.fa-caret-up:before{content:"\f0d8"}.fa-caret-left:before{content:"\f0d9"}.fa-caret-right:before{content:"\f0da"}.fa-columns:before{content:"\f0db"}.fa-unsorted:before,.fa-sort:before{content:"\f0dc"}.fa-sort-down:before,.fa-sort-desc:before{content:"\f0dd"}.fa-sort-up:before,.fa-sort-asc:before{content:"\f0de"}.fa-envelope:before{content:"\f0e0"}.fa-linkedin:before{content:"\f0e1"}.fa-rotate-left:before,.fa-undo:before{content:"\f0e2"}.fa-legal:before,.fa-gavel:before{content:"\f0e3"}.fa-dashboard:before,.fa-tachometer:before{content:"\f0e4"}.fa-comment-o:before{content:"\f0e5"}.fa-comments-o:before{content:"\f0e6"}.fa-flash:before,.fa-bolt:before{content:"\f0e7"}.fa-sitemap:before{content:"\f0e8"}.fa-umbrella:before{content:"\f0e9"}.fa-paste:before,.fa-clipboard:before{content:"\f0ea"}.fa-lightbulb-o:before{content:"\f0eb"}.fa-exchange:before{content:"\f0ec"}.fa-cloud-download:before{content:"\f0ed"}.fa-cloud-upload:before{content:"\f0ee"}.fa-user-md:before{content:"\f0f0"}.fa-stethoscope:before{content:"\f0f1"}.fa-suitcase:before{content:"\f0f2"}.fa-bell-o:before{content:"\f0a2"}.fa-coffee:before{content:"\f0f4"}.fa-cutlery:before{content:"\f0f5"}.fa-file-text-o:before{content:"\f0f6"}.fa-building-o:before{content:"\f0f7"}.fa-hospital-o:before{content:"\f0f8"}.fa-ambulance:before{content:"\f0f9"}.fa-medkit:before{content:"\f0fa"}.fa-fighter-jet:before{content:"\f0fb"}.fa-beer:before{content:"\f0fc"}.fa-h-square:before{content:"\f0fd"}.fa-plus-square:before{content:"\f0fe"}.fa-angle-double-left:before{content:"\f100"}.fa-angle-double-right:before{content:"\f101"}.fa-angle-double-up:before{content:"\f102"}.fa-angle-double-down:before{content:"\f103"}.fa-angle-left:before{content:"\f104"}.fa-angle-right:before{content:"\f105"}.fa-angle-up:before{content:"\f106"}.fa-angle-down:before{content:"\f107"}.fa-desktop:before{content:"\f108"}.fa-laptop:before{content:"\f109"}.fa-tablet:before{content:"\f10a"}.fa-mobile-phone:before,.fa-mobile:before{content:"\f10b"}.fa-circle-o:before{content:"\f10c"}.fa-quote-left:before{content:"\f10d"}.fa-quote-right:before{content:"\f10e"}.fa-spinner:before{content:"\f110"}.fa-circle:before{content:"\f111"}.fa-mail-reply:before,.fa-reply:before{content:"\f112"}.fa-github-alt:before{content:"\f113"}.fa-folder-o:before{content:"\f114"}.fa-folder-open-o:before{content:"\f115"}.fa-smile-o:before{content:"\f118"}.fa-frown-o:before{content:"\f119"}.fa-meh-o:before{content:"\f11a"}.fa-gamepad:before{content:"\f11b"}.fa-keyboard-o:before{content:"\f11c"}.fa-flag-o:before{content:"\f11d"}.fa-flag-checkered:before{content:"\f11e"}.fa-terminal:before{content:"\f120"}.fa-code:before{content:"\f121"}.fa-mail-reply-all:before,.fa-reply-all:before{content:"\f122"}.fa-star-half-empty:before,.fa-star-half-full:before,.fa-star-half-o:before{content:"\f123"}.fa-location-arrow:before{content:"\f124"}.fa-crop:before{content:"\f125"}.fa-code-fork:before{content:"\f126"}.fa-unlink:before,.fa-chain-broken:before{content:"\f127"}.fa-question:before{content:"\f128"}.fa-info:before{content:"\f129"}.fa-exclamation:before{content:"\f12a"}.fa-superscript:before{content:"\f12b"}.fa-subscript:before{content:"\f12c"}.fa-eraser:before{content:"\f12d"}.fa-puzzle-piece:before{content:"\f12e"}.fa-microphone:before{content:"\f130"}.fa-microphone-slash:before{content:"\f131"}.fa-shield:before{content:"\f132"}.fa-calendar-o:before{content:"\f133"}.fa-fire-extinguisher:before{content:"\f134"}.fa-rocket:before{content:"\f135"}.fa-maxcdn:before{content:"\f136"}.fa-chevron-circle-left:before{content:"\f137"}.fa-chevron-circle-right:before{content:"\f138"}.fa-chevron-circle-up:before{content:"\f139"}.fa-chevron-circle-down:before{content:"\f13a"}.fa-html5:before{content:"\f13b"}.fa-css3:before{content:"\f13c"}.fa-anchor:before{content:"\f13d"}.fa-unlock-alt:before{content:"\f13e"}.fa-bullseye:before{content:"\f140"}.fa-ellipsis-h:before{content:"\f141"}.fa-ellipsis-v:before{content:"\f142"}.fa-rss-square:before{content:"\f143"}.fa-play-circle:before{content:"\f144"}.fa-ticket:before{content:"\f145"}.fa-minus-square:before{content:"\f146"}.fa-minus-square-o:before{content:"\f147"}.fa-level-up:before{content:"\f148"}.fa-level-down:before{content:"\f149"}.fa-check-square:before{content:"\f14a"}.fa-pencil-square:before{content:"\f14b"}.fa-external-link-square:before{content:"\f14c"}.fa-share-square:before{content:"\f14d"}.fa-compass:before{content:"\f14e"}.fa-toggle-down:before,.fa-caret-square-o-down:before{content:"\f150"}.fa-toggle-up:before,.fa-caret-square-o-up:before{content:"\f151"}.fa-toggle-right:before,.fa-caret-square-o-right:before{content:"\f152"}.fa-euro:before,.fa-eur:before{content:"\f153"}.fa-gbp:before{content:"\f154"}.fa-dollar:before,.fa-usd:before{content:"\f155"}.fa-rupee:before,.fa-inr:before{content:"\f156"}.fa-cny:before,.fa-rmb:before,.fa-yen:before,.fa-jpy:before{content:"\f157"}.fa-ruble:before,.fa-rouble:before,.fa-rub:before{content:"\f158"}.fa-won:before,.fa-krw:before{content:"\f159"}.fa-bitcoin:before,.fa-btc:before{content:"\f15a"}.fa-file:before{content:"\f15b"}.fa-file-text:before{content:"\f15c"}.fa-sort-alpha-asc:before{content:"\f15d"}.fa-sort-alpha-desc:before{content:"\f15e"}.fa-sort-amount-asc:before{content:"\f160"}.fa-sort-amount-desc:before{content:"\f161"}.fa-sort-numeric-asc:before{content:"\f162"}.fa-sort-numeric-desc:before{content:"\f163"}.fa-thumbs-up:before{content:"\f164"}.fa-thumbs-down:before{content:"\f165"}.fa-youtube-square:before{content:"\f166"}.fa-youtube:before{content:"\f167"}.fa-xing:before{content:"\f168"}.fa-xing-square:before{content:"\f169"}.fa-youtube-play:before{content:"\f16a"}.fa-dropbox:before{content:"\f16b"}.fa-stack-overflow:before{content:"\f16c"}.fa-instagram:before{content:"\f16d"}.fa-flickr:before{content:"\f16e"}.fa-adn:before{content:"\f170"}.fa-bitbucket:before{content:"\f171"}.fa-bitbucket-square:before{content:"\f172"}.fa-tumblr:before{content:"\f173"}.fa-tumblr-square:before{content:"\f174"}.fa-long-arrow-down:before{content:"\f175"}.fa-long-arrow-up:before{content:"\f176"}.fa-long-arrow-left:before{content:"\f177"}.fa-long-arrow-right:before{content:"\f178"}.fa-apple:before{content:"\f179"}.fa-windows:before{content:"\f17a"}.fa-android:before{content:"\f17b"}.fa-linux:before{content:"\f17c"}.fa-dribbble:before{content:"\f17d"}.fa-skype:before{content:"\f17e"}.fa-foursquare:before{content:"\f180"}.fa-trello:before{content:"\f181"}.fa-female:before{content:"\f182"}.fa-male:before{content:"\f183"}.fa-gittip:before{content:"\f184"}.fa-sun-o:before{content:"\f185"}.fa-moon-o:before{content:"\f186"}.fa-archive:before{content:"\f187"}.fa-bug:before{content:"\f188"}.fa-vk:before{content:"\f189"}.fa-weibo:before{content:"\f18a"}.fa-renren:before{content:"\f18b"}.fa-pagelines:before{content:"\f18c"}.fa-stack-exchange:before{content:"\f18d"}.fa-arrow-circle-o-right:before{content:"\f18e"}.fa-arrow-circle-o-left:before{content:"\f190"}.fa-toggle-left:before,.fa-caret-square-o-left:before{content:"\f191"}.fa-dot-circle-o:before{content:"\f192"}.fa-wheelchair:before{content:"\f193"}.fa-vimeo-square:before{content:"\f194"}.fa-turkish-lira:before,.fa-try:before{content:"\f195"}.fa-plus-square-o:before{content:"\f196"}.fa-space-shuttle:before{content:"\f197"}.fa-slack:before{content:"\f198"}.fa-envelope-square:before{content:"\f199"}.fa-wordpress:before{content:"\f19a"}.fa-openid:before{content:"\f19b"}.fa-institution:before,.fa-bank:before,.fa-university:before{content:"\f19c"}.fa-mortar-board:before,.fa-graduation-cap:before{content:"\f19d"}.fa-yahoo:before{content:"\f19e"}.fa-google:before{content:"\f1a0"}.fa-reddit:before{content:"\f1a1"}.fa-reddit-square:before{content:"\f1a2"}.fa-stumbleupon-circle:before{content:"\f1a3"}.fa-stumbleupon:before{content:"\f1a4"}.fa-delicious:before{content:"\f1a5"}.fa-digg:before{content:"\f1a6"}.fa-pied-piper-square:before,.fa-pied-piper:before{content:"\f1a7"}.fa-pied-piper-alt:before{content:"\f1a8"}.fa-drupal:before{content:"\f1a9"}.fa-joomla:before{content:"\f1aa"}.fa-language:before{content:"\f1ab"}.fa-fax:before{content:"\f1ac"}.fa-building:before{content:"\f1ad"}.fa-child:before{content:"\f1ae"}.fa-paw:before{content:"\f1b0"}.fa-spoon:before{content:"\f1b1"}.fa-cube:before{content:"\f1b2"}.fa-cubes:before{content:"\f1b3"}.fa-behance:before{content:"\f1b4"}.fa-behance-square:before{content:"\f1b5"}.fa-steam:before{content:"\f1b6"}.fa-steam-square:before{content:"\f1b7"}.fa-recycle:before{content:"\f1b8"}.fa-automobile:before,.fa-car:before{content:"\f1b9"}.fa-cab:before,.fa-taxi:before{content:"\f1ba"}.fa-tree:before{content:"\f1bb"}.fa-spotify:before{content:"\f1bc"}.fa-deviantart:before{content:"\f1bd"}.fa-soundcloud:before{content:"\f1be"}.fa-database:before{content:"\f1c0"}.fa-file-pdf-o:before{content:"\f1c1"}.fa-file-word-o:before{content:"\f1c2"}.fa-file-excel-o:before{content:"\f1c3"}.fa-file-powerpoint-o:before{content:"\f1c4"}.fa-file-photo-o:before,.fa-file-picture-o:before,.fa-file-image-o:before{content:"\f1c5"}.fa-file-zip-o:before,.fa-file-archive-o:before{content:"\f1c6"}.fa-file-sound-o:before,.fa-file-audio-o:before{content:"\f1c7"}.fa-file-movie-o:before,.fa-file-video-o:before{content:"\f1c8"}.fa-file-code-o:before{content:"\f1c9"}.fa-vine:before{content:"\f1ca"}.fa-codepen:before{content:"\f1cb"}.fa-jsfiddle:before{content:"\f1cc"}.fa-life-bouy:before,.fa-life-saver:before,.fa-support:before,.fa-life-ring:before{content:"\f1cd"}.fa-circle-o-notch:before{content:"\f1ce"}.fa-ra:before,.fa-rebel:before{content:"\f1d0"}.fa-ge:before,.fa-empire:before{content:"\f1d1"}.fa-git-square:before{content:"\f1d2"}.fa-git:before{content:"\f1d3"}.fa-hacker-news:before{content:"\f1d4"}.fa-tencent-weibo:before{content:"\f1d5"}.fa-qq:before{content:"\f1d6"}.fa-wechat:before,.fa-weixin:before{content:"\f1d7"}.fa-send:before,.fa-paper-plane:before{content:"\f1d8"}.fa-send-o:before,.fa-paper-plane-o:before{content:"\f1d9"}.fa-history:before{content:"\f1da"}.fa-circle-thin:before{content:"\f1db"}.fa-header:before{content:"\f1dc"}.fa-paragraph:before{content:"\f1dd"}.fa-sliders:before{content:"\f1de"}.fa-share-alt:before{content:"\f1e0"}.fa-share-alt-square:before{content:"\f1e1"}.fa-bomb:before{content:"\f1e2"}mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/web/client/resources/css/themes/000077500000000000000000000000001321131462300332055ustar00rootroot00000000000000dark-bigtext.css000066400000000000000000000225321321131462300362310ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/web/client/resources/css/themes/* This is a fork of the dark.css theme. The only changes from dark.css are near the very end. */ ::-webkit-scrollbar { width: 10px; height: 10px; } ::-webkit-scrollbar-corner { background: transparent; } ::-webkit-scrollbar-thumb { background-color: rgba(255, 255, 255, .35); border-radius: 10px; } body { color: #D0D0D0; background: fixed #040607; background: fixed -moz-linear-gradient(top, hsl(200,27%,2%) 0%, hsl(203,29%,26%) 100%); background: fixed -webkit-gradient(linear, left top, left bottom, color-stop(0%,hsl(200,27%,2%)), color-stop(100%,hsl(203,29%,26%))); background: fixed -webkit-linear-gradient(top, hsl(200,27%,2%) 0%,hsl(203,29%,26%) 100%); background: fixed -o-linear-gradient(top, hsl(200,27%,2%) 0%,hsl(203,29%,26%) 100%); background: fixed -ms-linear-gradient(top, hsl(200,27%,2%) 0%,hsl(203,29%,26%) 100%); background: fixed linear-gradient(to bottom, hsl(200,27%,2%) 0%,hsl(203,29%,26%) 100%); filter: progid:DXImageTransform.Microsoft.gradient( startColorstr='#040607', endColorstr='#2f4756',GradientType=0 ); } a, .toggle-all-pkg { color: #247D9E; } a:hover, .toggle-all-pkg:hover { color: #33B5E5; } input[type=text] { border-bottom-color: #33B5E5; color: #BBB; } ::-webkit-input-placeholder { color: #555; } :-moz-placeholder { color: #555; } ::-moz-placeholder { color: #555; } :-ms-input-placeholder { color: #555; } .overall { /* Using box-shadow here is not very performant but allows us to animate the change of the background color much more easily. This box-shadow is an ALTERNATIVE, not supplement, to using gradients in this case. */ box-shadow: inset 0 150px 100px -110px rgba(0, 0, 0, .5); } .overall.ok { background: #688E00; } .overall.fail { background: #DB8700; } .overall.panic { background: #A80000; } .overall.buildfail { background: #A4A8AA; } .overall .status { color: #EEE; } .server-down { background: rgba(255, 45, 45, 0.55); color: #FFF; } .toggler { background: #132535; } .toggler:hover { background: #1C374F; } .controls { border-bottom: 1px solid #33B5E5; } .controls li { color: #2A5A84; } .controls li:hover { background: #132535; color: #33B5E5; } .sel { background: #33B5E5 !important; color: #FFF !important; } .pkg-cover-name { text-shadow: 1px 1px 0px #000; } .pkg-cover-name b, .story-pkg-name b { color: #FFF; font-weight: bold; } .pkg-cover:hover, .pkg-cover:hover b { color: #FFF; } .expandable { border-top-color: #33B5E5; } .expandable { background: rgba(0, 0, 0, .2); } .history .item.ok { background: #3f5400; background: -moz-linear-gradient(top, hsl(75,100%,16%) 0%, hsl(76,100%,28%) 100%); background: -webkit-gradient(linear, left top, left bottom, color-stop(0%,hsl(75,100%,16%)), color-stop(100%,hsl(76,100%,28%))); background: -webkit-linear-gradient(top, hsl(75,100%,16%) 0%,hsl(76,100%,28%) 100%); background: -o-linear-gradient(top, hsl(75,100%,16%) 0%,hsl(76,100%,28%) 100%); background: -ms-linear-gradient(top, hsl(75,100%,16%) 0%,hsl(76,100%,28%) 100%); background: linear-gradient(to bottom, hsl(75,100%,16%) 0%,hsl(76,100%,28%) 100%); filter: progid:DXImageTransform.Microsoft.gradient( startColorstr='#3f5400', endColorstr='#698f00',GradientType=0 ); } .history .item.fail { background: #7f4e00; background: -moz-linear-gradient(top, hsl(37,100%,25%) 0%, hsl(37,100%,43%) 100%); background: -webkit-gradient(linear, left top, left bottom, color-stop(0%,hsl(37,100%,25%)), color-stop(100%,hsl(37,100%,43%))); background: -webkit-linear-gradient(top, hsl(37,100%,25%) 0%,hsl(37,100%,43%) 100%); background: -o-linear-gradient(top, hsl(37,100%,25%) 0%,hsl(37,100%,43%) 100%); background: -ms-linear-gradient(top, hsl(37,100%,25%) 0%,hsl(37,100%,43%) 100%); background: linear-gradient(to bottom, hsl(37,100%,25%) 0%,hsl(37,100%,43%) 100%); filter: progid:DXImageTransform.Microsoft.gradient( startColorstr='#7f4e00', endColorstr='#db8700',GradientType=0 ); } .history .item.panic { background: #660000; background: -moz-linear-gradient(top, hsl(0,100%,20%) 0%, hsl(0,100%,33%) 100%); background: -webkit-gradient(linear, left top, left bottom, color-stop(0%,hsl(0,100%,20%)), color-stop(100%,hsl(0,100%,33%))); background: -webkit-linear-gradient(top, hsl(0,100%,20%) 0%,hsl(0,100%,33%) 100%); background: -o-linear-gradient(top, hsl(0,100%,20%) 0%,hsl(0,100%,33%) 100%); background: -ms-linear-gradient(top, hsl(0,100%,20%) 0%,hsl(0,100%,33%) 100%); background: linear-gradient(to bottom, hsl(0,100%,20%) 0%,hsl(0,100%,33%) 100%); filter: progid:DXImageTransform.Microsoft.gradient( startColorstr='#660000', endColorstr='#a80000',GradientType=0 ); } .history .item.buildfail { background: #282f33; background: -moz-linear-gradient(top, hsl(202,12%,18%) 0%, hsl(208,5%,48%) 100%); background: -webkit-gradient(linear, left top, left bottom, color-stop(0%,hsl(202,12%,18%)), color-stop(100%,hsl(208,5%,48%))); background: -webkit-linear-gradient(top, hsl(202,12%,18%) 0%,hsl(208,5%,48%) 100%); background: -o-linear-gradient(top, hsl(202,12%,18%) 0%,hsl(208,5%,48%) 100%); background: -ms-linear-gradient(top, hsl(202,12%,18%) 0%,hsl(208,5%,48%) 100%); background: linear-gradient(to bottom, hsl(202,12%,18%) 0%,hsl(208,5%,48%) 100%); filter: progid:DXImageTransform.Microsoft.gradient( startColorstr='#282f33', endColorstr='#757c82',GradientType=0 ); } .enum { border-color: #2B597F; } .enum > li { border-left-color: #2B597F; } .enum > li:hover { background: rgba(55, 114, 163, .25); } .group { background: -moz-linear-gradient(top, rgba(16,59,71,0) 0%, rgba(16,59,71,1) 100%); background: -webkit-gradient(linear, left top, left bottom, color-stop(0%,rgba(16,59,71,0)), color-stop(100%,rgba(16,59,71,1))); background: -webkit-linear-gradient(top, rgba(16,59,71,0) 0%,rgba(16,59,71,1) 100%); background: -o-linear-gradient(top, rgba(16,59,71,0) 0%,rgba(16,59,71,1) 100%); background: -ms-linear-gradient(top, rgba(16,59,71,0) 0%,rgba(16,59,71,1) 100%); background: linear-gradient(to top, rgba(16,59,71,0) 0%,rgba(16,59,71,1) 100%); filter: progid:DXImageTransform.Microsoft.gradient( startColorstr='#00103b47', endColorstr='#103b47',GradientType=0 ); } .stats { color: #FFF; } .error { color: #F58888 !important; background: rgba(255, 45, 45, 0.35) !important; } .spin-slowly, .spin-once { color: #33B5E5 !important; } .frame .col, footer { border-color: #33B5E5; } footer { background: rgba(0, 0, 0, .5); } footer .recording .fa { color: #CC0000; } footer .replay .fa { color: #33B5E5; } footer .paused .fa { color: #AAA; } footer .recording.replay .fa { color: #33B5E5; } .buildfail-pkg { background: rgba(255, 255, 255, .1); } .buildfail-output { background: rgba(255, 255, 255, .2); } .panic-pkg { background: rgba(255, 0, 0, .3); } .panic-story { padding: 10px; background: rgba(255, 0, 0, .1); } .panic-story a, .panic-summary { color: #E94A4A; } .panic-output { color: #FF8181; } .failure-pkg { background: rgba(255, 153, 0, .42); } .failure-story { padding: 10px; background: rgba(255, 153, 0, .1); } .failure-story a { color: #FFB518; } .failure-output { color: #FFBD47; } .failure-file { color: #FFF; } .diffviewer td { border-color: rgba(0, 0, 0, .3); } /* prettyTextDiff expected/deleted colors */ .diffviewer .exp, .diff del { background: rgba(131, 252, 131, 0.22); } /* prettyTextDiff actual/inserted colors */ .diffviewer .act, .diff ins { background: rgba(255, 52, 52, 0.33); } .story-links a, .test-name-link a { color: inherit; } .story-pkg { background: rgba(0, 0, 0, .4); } .story-pkg:hover { background: rgba(255, 255, 255, .05); } .story-line + .story-line { border-top: 1px dashed rgba(255, 255, 255, .08); } .story-line-desc .message { color: #999; } .story-line-summary-container { border-right: 1px dashed #333; } .story-line.ok .story-line-status { background: #008000; } .story-line.ok:hover, .story-line.ok.story-line-sel { background: rgba(0, 128, 0, .1); } .story-line.fail .story-line-status { background: #EA9C4D; } .story-line.fail:hover, .story-line.fail.story-line-sel { background: rgba(234, 156, 77, .1); } .story-line.panic .story-line-status { background: #FF3232; } .story-line.panic:hover, .story-line.panic.story-line-sel { background: rgba(255, 50, 50, .1); } .story-line.skip .story-line-status { background: #AAA; } .story-line.skip:hover, .story-line.skip.story-line-sel { background: rgba(255, 255, 255, .1); } .statusicon.ok { color: #76C13C; } .statusicon.fail, .fail-clr { color: #EA9C4D; } .statusicon.panic, .statusicon.panic .fa, .panic-clr { color: #FF3232; } .statusicon.skip, .skip-clr { color: #888; } .log .timestamp { color: #999; } .clr-red { color: #FF2222; } .tipsy-inner { background-color: #FAFAFA; color: #222; } .tipsy-arrow { border: 8px dashed #FAFAFA; } .tipsy-arrow-n, .tipsy-arrow-s, .tipsy-arrow-e, .tipsy-arrow-w, { border-color: #FAFAFA; } /***************************************************************/ /*************************** Tweaks ****************************/ /***************************************************************/ /* More space for stories */ div#col-3 { display: none; } /* hides the log */ div#col-2 { width: 85%; } /* fill it in with stories */ /* Bigger Text */ .story-line { font-size: 16px; } .story-line b { font-size: 20px; } td.story-pkg-name { font-size: 24px; } /* Smaller Header */ div.overall { padding: 10px 0 0px; } .overall .status { font-size: 36px; } /***************************************************************/ dark.css000066400000000000000000000212671321131462300345710ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/web/client/resources/css/themes::-webkit-scrollbar { width: 10px; height: 10px; } ::-webkit-scrollbar-corner { background: transparent; } ::-webkit-scrollbar-thumb { background-color: rgba(255, 255, 255, .35); border-radius: 10px; } body { color: #D0D0D0; background: fixed #040607; background: fixed -moz-linear-gradient(top, hsl(200,27%,2%) 0%, hsl(203,29%,26%) 100%); background: fixed -webkit-gradient(linear, left top, left bottom, color-stop(0%,hsl(200,27%,2%)), color-stop(100%,hsl(203,29%,26%))); background: fixed -webkit-linear-gradient(top, hsl(200,27%,2%) 0%,hsl(203,29%,26%) 100%); background: fixed -o-linear-gradient(top, hsl(200,27%,2%) 0%,hsl(203,29%,26%) 100%); background: fixed -ms-linear-gradient(top, hsl(200,27%,2%) 0%,hsl(203,29%,26%) 100%); background: fixed linear-gradient(to bottom, hsl(200,27%,2%) 0%,hsl(203,29%,26%) 100%); filter: progid:DXImageTransform.Microsoft.gradient( startColorstr='#040607', endColorstr='#2f4756',GradientType=0 ); } a, .toggle-all-pkg { color: #247D9E; } a:hover, .toggle-all-pkg:hover { color: #33B5E5; } input[type=text] { border-bottom-color: #33B5E5; color: #BBB; } ::-webkit-input-placeholder { color: #555; } :-moz-placeholder { color: #555; } ::-moz-placeholder { color: #555; } :-ms-input-placeholder { color: #555; } .overall { /* Using box-shadow here is not very performant but allows us to animate the change of the background color much more easily. This box-shadow is an ALTERNATIVE, not supplement, to using gradients in this case. */ box-shadow: inset 0 150px 100px -110px rgba(0, 0, 0, .5); } .overall.ok { background: #688E00; } .overall.fail { background: #DB8700; } .overall.panic { background: #A80000; } .overall.buildfail { background: #A4A8AA; } .overall .status { color: #EEE; } .server-down { background: rgba(255, 45, 45, 0.55); color: #FFF; } .toggler { background: #132535; } .toggler:hover { background: #1C374F; } .controls { border-bottom: 1px solid #33B5E5; } .controls li { color: #2A5A84; } .controls li:hover { background: #132535; color: #33B5E5; } .sel { background: #33B5E5 !important; color: #FFF !important; } .pkg-cover-name { text-shadow: 1px 1px 0px #000; } .pkg-cover-name b, .story-pkg-name b { color: #FFF; font-weight: bold; } .pkg-cover:hover, .pkg-cover:hover b { color: #FFF; } .expandable { border-top-color: #33B5E5; } .expandable { background: rgba(0, 0, 0, .2); } .history .item.ok { background: #3f5400; background: -moz-linear-gradient(top, hsl(75,100%,16%) 0%, hsl(76,100%,28%) 100%); background: -webkit-gradient(linear, left top, left bottom, color-stop(0%,hsl(75,100%,16%)), color-stop(100%,hsl(76,100%,28%))); background: -webkit-linear-gradient(top, hsl(75,100%,16%) 0%,hsl(76,100%,28%) 100%); background: -o-linear-gradient(top, hsl(75,100%,16%) 0%,hsl(76,100%,28%) 100%); background: -ms-linear-gradient(top, hsl(75,100%,16%) 0%,hsl(76,100%,28%) 100%); background: linear-gradient(to bottom, hsl(75,100%,16%) 0%,hsl(76,100%,28%) 100%); filter: progid:DXImageTransform.Microsoft.gradient( startColorstr='#3f5400', endColorstr='#698f00',GradientType=0 ); } .history .item.fail { background: #7f4e00; background: -moz-linear-gradient(top, hsl(37,100%,25%) 0%, hsl(37,100%,43%) 100%); background: -webkit-gradient(linear, left top, left bottom, color-stop(0%,hsl(37,100%,25%)), color-stop(100%,hsl(37,100%,43%))); background: -webkit-linear-gradient(top, hsl(37,100%,25%) 0%,hsl(37,100%,43%) 100%); background: -o-linear-gradient(top, hsl(37,100%,25%) 0%,hsl(37,100%,43%) 100%); background: -ms-linear-gradient(top, hsl(37,100%,25%) 0%,hsl(37,100%,43%) 100%); background: linear-gradient(to bottom, hsl(37,100%,25%) 0%,hsl(37,100%,43%) 100%); filter: progid:DXImageTransform.Microsoft.gradient( startColorstr='#7f4e00', endColorstr='#db8700',GradientType=0 ); } .history .item.panic { background: #660000; background: -moz-linear-gradient(top, hsl(0,100%,20%) 0%, hsl(0,100%,33%) 100%); background: -webkit-gradient(linear, left top, left bottom, color-stop(0%,hsl(0,100%,20%)), color-stop(100%,hsl(0,100%,33%))); background: -webkit-linear-gradient(top, hsl(0,100%,20%) 0%,hsl(0,100%,33%) 100%); background: -o-linear-gradient(top, hsl(0,100%,20%) 0%,hsl(0,100%,33%) 100%); background: -ms-linear-gradient(top, hsl(0,100%,20%) 0%,hsl(0,100%,33%) 100%); background: linear-gradient(to bottom, hsl(0,100%,20%) 0%,hsl(0,100%,33%) 100%); filter: progid:DXImageTransform.Microsoft.gradient( startColorstr='#660000', endColorstr='#a80000',GradientType=0 ); } .history .item.buildfail { background: #282f33; background: -moz-linear-gradient(top, hsl(202,12%,18%) 0%, hsl(208,5%,48%) 100%); background: -webkit-gradient(linear, left top, left bottom, color-stop(0%,hsl(202,12%,18%)), color-stop(100%,hsl(208,5%,48%))); background: -webkit-linear-gradient(top, hsl(202,12%,18%) 0%,hsl(208,5%,48%) 100%); background: -o-linear-gradient(top, hsl(202,12%,18%) 0%,hsl(208,5%,48%) 100%); background: -ms-linear-gradient(top, hsl(202,12%,18%) 0%,hsl(208,5%,48%) 100%); background: linear-gradient(to bottom, hsl(202,12%,18%) 0%,hsl(208,5%,48%) 100%); filter: progid:DXImageTransform.Microsoft.gradient( startColorstr='#282f33', endColorstr='#757c82',GradientType=0 ); } .enum { border-color: #2B597F; } .enum > li { border-left-color: #2B597F; } .enum > li:hover { background: rgba(55, 114, 163, .25); } .group { background: -moz-linear-gradient(top, rgba(16,59,71,0) 0%, rgba(16,59,71,1) 100%); background: -webkit-gradient(linear, left top, left bottom, color-stop(0%,rgba(16,59,71,0)), color-stop(100%,rgba(16,59,71,1))); background: -webkit-linear-gradient(top, rgba(16,59,71,0) 0%,rgba(16,59,71,1) 100%); background: -o-linear-gradient(top, rgba(16,59,71,0) 0%,rgba(16,59,71,1) 100%); background: -ms-linear-gradient(top, rgba(16,59,71,0) 0%,rgba(16,59,71,1) 100%); background: linear-gradient(to top, rgba(16,59,71,0) 0%,rgba(16,59,71,1) 100%); filter: progid:DXImageTransform.Microsoft.gradient( startColorstr='#00103b47', endColorstr='#103b47',GradientType=0 ); } .stats { color: #FFF; } .error { color: #F58888 !important; background: rgba(255, 45, 45, 0.35) !important; } .spin-slowly, .spin-once { color: #33B5E5 !important; } .frame .col, footer { border-color: #33B5E5; } footer { background: rgba(0, 0, 0, .5); } footer .recording .fa { color: #CC0000; } footer .replay .fa { color: #33B5E5; } footer .paused .fa { color: #AAA; } footer .recording.replay .fa { color: #33B5E5; } .buildfail-pkg { background: rgba(255, 255, 255, .1); } .buildfail-output { background: rgba(255, 255, 255, .2); } .panic-pkg { background: rgba(255, 0, 0, .3); } .panic-story { padding: 10px; background: rgba(255, 0, 0, .1); } .panic-story a, .panic-summary { color: #E94A4A; } .panic-output { color: #FF8181; } .failure-pkg { background: rgba(255, 153, 0, .42); } .failure-story { padding: 10px; background: rgba(255, 153, 0, .1); } .failure-story a { color: #FFB518; } .failure-output { color: #FFBD47; } .failure-file { color: #FFF; } .diffviewer td { border-color: rgba(0, 0, 0, .3); } /* prettyTextDiff expected/deleted colors */ .diffviewer .exp, .diff del { background: rgba(131, 252, 131, 0.22); } /* prettyTextDiff actual/inserted colors */ .diffviewer .act, .diff ins { background: rgba(255, 52, 52, 0.33); } .story-links a, .test-name-link a { color: inherit; } .story-pkg { background: rgba(0, 0, 0, .4); } .story-pkg:hover { background: rgba(255, 255, 255, .05); } .story-line + .story-line { border-top: 1px dashed rgba(255, 255, 255, .08); } .story-line-desc .message { color: #999; } .story-line-summary-container { border-right: 1px dashed #333; } .story-line.ok .story-line-status { background: #008000; } .story-line.ok:hover, .story-line.ok.story-line-sel { background: rgba(0, 128, 0, .1); } .story-line.fail .story-line-status { background: #EA9C4D; } .story-line.fail:hover, .story-line.fail.story-line-sel { background: rgba(234, 156, 77, .1); } .story-line.panic .story-line-status { background: #FF3232; } .story-line.panic:hover, .story-line.panic.story-line-sel { background: rgba(255, 50, 50, .1); } .story-line.skip .story-line-status { background: #AAA; } .story-line.skip:hover, .story-line.skip.story-line-sel { background: rgba(255, 255, 255, .1); } .statusicon.ok { color: #76C13C; } .statusicon.fail, .fail-clr { color: #EA9C4D; } .statusicon.panic, .statusicon.panic .fa, .panic-clr { color: #FF3232; } .statusicon.skip, .skip-clr { color: #888; } .ansi-green { color: #76C13C; } .ansi-yellow { color: #EA9C4D; } .log .timestamp { color: #999; } .clr-red { color: #FF2222; } .tipsy-inner { background-color: #FAFAFA; color: #222; } .tipsy-arrow { border: 8px dashed #FAFAFA; } .tipsy-arrow-n, .tipsy-arrow-s, .tipsy-arrow-e, .tipsy-arrow-w, { border-color: #FAFAFA; } light.css000066400000000000000000000106201321131462300347460ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/web/client/resources/css/themes::-webkit-scrollbar-thumb { background-color: rgba(0, 0, 0, .35); border-radius: 10px; } ::-webkit-input-placeholder { color: #CCC; } :-moz-placeholder { color: #CCC; } ::-moz-placeholder { color: #CCC; } :-ms-input-placeholder { color: #CCC; } body { color: #444; background: #F4F4F4; } a { color: #247D9E; } a:hover { color: #33B5E5; } .overall.ok, .history .item.ok { background: #8CB700; /* Can't decide: #5AA02C */ } .overall.fail, .history .item.fail { background: #E79C07; } .overall.panic, .history .item.panic { background: #BB0000; } .overall.buildfail, .history .item.buildfail { background: #828c95; } .overall .status { color: #EEE; } .server-down { background: #BB0000; color: #FFF; } .toggler { background: #6887A3; color: #FFF; } .toggler:hover { background: #465B6D; } .toggler .fa { color: #FFF; } #logo { color: #6887A3; } .controls { border-bottom: 1px solid #33B5E5; } li.fa, a.fa, .toggle-all-pkg { color: #6887A3; } li.fa:hover, a.fa:hover, .toggle-all-pkg:hover { color: #465B6D; } li.fa:active, a.fa:active, .toggle-all-pkg:active { color: #33B5E5; } .controls li, .enum > li { border-left-color: #33B5E5; } .controls li:hover, .enum > li:hover { background: #CFE6F9; } .enum { border-color: #33B5E5; } .sel { background: #33B5E5 !important; color: #FFF !important; } .pkg-cover-name b, .story-pkg-name b { color: #000; font-weight: bold; } .expandable { background: rgba(0, 0, 0, .1); border-top-color: #33B5E5; } .history .item { color: #FFF; } .spin-slowly, .spin-once { color: #33B5E5 !important; } input[type=text] { border-bottom-color: #33B5E5; color: #333; } .error { color: #CC0000 !important; background: #FFD2D2 !important; } footer { background: #F4F4F4; } .frame .col, footer { border-color: #33B5E5; } footer .recording .fa { color: #CC0000; } footer .replay .fa { color: #33B5E5; } footer .paused .fa { color: #333; } .buildfail-pkg { background: #CCC; } .buildfail-output { background: #EEE; } .panic-pkg { background: #E94D4D; color: #FFF; } .panics .panic-details { border: 5px solid #E94D4D; border-top: 0; border-bottom: 0; } .panic-details { color: #CC0000; } .panics .panic:last-child .panic-details { border-bottom: 5px solid #E94D4D; } .panic-story { padding: 10px; } .panics .panic-output { background: #FFF; } .failure-pkg { background: #FFA300; color: #FFF; } .failures .failure-details { border: 5px solid #FFA300; border-top: 0; border-bottom: 0; } .failures .failure:last-child .failure-details { border-bottom: 5px solid #FFA300; } .failure-story { padding: 10px; color: #A87A00; } .stories .failure-output { color: #EA9C4D; } .failures .failure-output { background: #FFF; } .failure-file { color: #000; } .diffviewer td { border-color: #CCC; background: #FFF; } /* prettyTextDiff expected/deleted colors */ .diffviewer .exp, .diff del { background: #ADFFAD; } /* prettyTextDiff actual/inserted colors */ .diffviewer .act, .diff ins { background: #FFC0C0; } .story-links a, .test-name-link a { color: inherit; } .story-pkg { background: #E8E8E8; } .story-pkg:hover { background: #DFDFDF; } .story-line { background: #FFF; } .story-line-desc .message { color: #888; } .story-line + .story-line { border-top: 1px dashed #DDD; } .story-line-summary-container { border-right: 1px dashed #DDD; } .story-line.ok .story-line-status { background: #8CB700; } .story-line.ok:hover, .story-line.ok.story-line-sel { background: #F4FFD8; } .story-line.fail .story-line-status { background: #E79C07; } .story-line.fail:hover, .story-line.fail.story-line-sel { background: #FFF1DB; } .story-line.panic .story-line-status { background: #DD0606; } .story-line.panic:hover, .story-line.panic.story-line-sel { background: #FFE8E8; } .story-line.skip .story-line-status { background: #4E4E4E; } .story-line.skip:hover, .story-line.skip.story-line-sel { background: #F2F2F2; } .statusicon.ok { color: #76C13C; } .statusicon.fail, .fail-clr { color: #EA9C4D; } .statusicon.panic, .statusicon.panic .fa, .panic-clr { color: #FF3232; } .statusicon.skip, .skip-clr { color: #AAA; } .ansi-green { color: #76C13C; } .ansi-yellow { color: #EA9C4D; } .log .timestamp { color: #999; } .clr-red, a.clr-red { color: #CC0000; } .tipsy-inner { background-color: #000; color: #FFF; } .tipsy-arrow { border: 8px dashed #000; } .tipsy-arrow-n, .tipsy-arrow-s, .tipsy-arrow-e, .tipsy-arrow-w, { border-color: #000; } mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/web/client/resources/css/tipsy.css000066400000000000000000000031421321131462300336020ustar00rootroot00000000000000.tipsy { font-size: 12px; position: absolute; padding: 8px; z-index: 100000; font-family: 'Open Sans'; line-height: 1.25em; } .tipsy-inner { max-width: 200px; padding: 5px 7px; text-align: center; } /* Rounded corners */ /*.tipsy-inner { border-radius: 3px; -moz-border-radius: 3px; -webkit-border-radius: 3px; }*/ /* Shadow */ /*.tipsy-inner { box-shadow: 0 0 5px #000000; -webkit-box-shadow: 0 0 5px #000000; -moz-box-shadow: 0 0 5px #000000; }*/ .tipsy-arrow { position: absolute; width: 0; height: 0; line-height: 0; } .tipsy-n .tipsy-arrow, .tipsy-nw .tipsy-arrow, .tipsy-ne .tipsy-arrow { border-bottom-style: solid; border-top: none; border-left-color: transparent; border-right-color: transparent; } .tipsy-n .tipsy-arrow { top: 0px; left: 50%; margin-left: -7px; } .tipsy-nw .tipsy-arrow { top: 0; left: 10px; } .tipsy-ne .tipsy-arrow { top: 0; right: 10px; } .tipsy-s .tipsy-arrow, .tipsy-sw .tipsy-arrow, .tipsy-se .tipsy-arrow { border-top-style: solid; border-bottom: none; border-left-color: transparent; border-right-color: transparent; } .tipsy-s .tipsy-arrow { bottom: 0; left: 50%; margin-left: -7px; } .tipsy-sw .tipsy-arrow { bottom: 0; left: 10px; } .tipsy-se .tipsy-arrow { bottom: 0; right: 10px; } .tipsy-e .tipsy-arrow { right: 0; top: 50%; margin-top: -7px; border-left-style: solid; border-right: none; border-top-color: transparent; border-bottom-color: transparent; } .tipsy-w .tipsy-arrow { left: 0; top: 50%; margin-top: -7px; border-right-style: solid; border-left: none; border-top-color: transparent; border-bottom-color: transparent; }mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/web/client/resources/fonts/000077500000000000000000000000001321131462300322615ustar00rootroot00000000000000FontAwesome/000077500000000000000000000000001321131462300344315ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/web/client/resources/fontsFontAwesome.otf000077500000000000000000002226641321131462300374110ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/web/client/resources/fonts/FontAwesomeOTTO €CFF ;)7¼øOS/2’j€ü`cmap…;Ƥ°¤headíœ6hhea ÅÔ$hmtxØ#THmaxpßPønameoÛi§`Opostÿ}Zœ BŠ¶3 _<õËTt Ï™/§ÿÿþÿ ÿ ÿÿÿÿ ÅPß,Œ3†Œ3sZ3pyrs@ õÿ€ ? ?J ?a ?Qs Ä Ð Úï ~  ‹ ¡ .¯ ‹ $Ý ‹ ¢ £ » *Ï <ùCopyright 2014 Adobe Systems Incorporated. All rights reserved.FontAwesomepyrs: FontAwesome: 2012Version 4.1.0 2013Please refer to the Copyright section for the font trademark attribution notices.Fort AwesomeDave Gandyhttp://fontawesome.iohttp://fontawesome.io/license/Copyright 2014 Adobe Systems Incorporated. All rights reserved.FontAwesomeRegularpyrs: FontAwesome: 2012Version 4.1.0 2013Please refer to the Copyright section for the font trademark attribution notices.Fort AwesomeDave Gandyhttp://fontawesome.iohttp://fontawesome.io/license/"" ²³‚Z@ ©®´ÆØ!"""`ððð>ðNð^ðfðiðnð~ðŽðžð®ð²ðÎðÞðîðþñññ'ñ(ñ.ñ>ñNñ^ñnñ~ñŽñžñ®ñ¾ñÎñÞñîõÿÿ ¨®´ÆØ!"""`ððð!ð@ðPð`ðgðjðpð€ðð ð°ðÀðÐðàððñññ ñ(ñ)ñ0ñ@ñPñ`ñpñ€ññ ñ°ñÀñÐñàõÿÿÿáÿ\ÿQÿAÿ0ÞçÞ•ÞR    ÿõôóòñðïÜîíìëêéèçæåäãâ ´X@  À€v€_€]€€€€€€y€n€€€€€2€€@€€€€€€ÿÿ€€€€€€€€z€€ÿÿšZ@€5€5 €€€ZZ€€€€@€€€€€€€€€€,_€€€€ÿÿ€€€€€€f€€€@€ €€@€€(€€€€€€€€€€€€@€€@- €M€M€-€ €M€M€€€€€ €€€€€@@€ €-€€€€€€b€€€€ €€€ € €€€5€-‚8€€€€€@€€N@€€€€ÿÿ*@€ €ÿÿ€€€€€€ moÀ€ö)@€@ ÀÀ  'D9ÿÿ>ÿzZ FontAwesomeAøùíùíøûG å Šû•  U€6ÿ‹‹ U€6ÿ‹‹ #m#’¥öÓ ",04<>EGMT\_ehmqy}•› «±¸ÀÄÈÒÜçðöý#)4>HT_lp{‡•œ¢¬²¶º¿ÄÈÕâêîó÷þ '4=GRYfoy†™£®¶ÀÉÔàðôøü &,39COVcoz‰š£¯¼ÈËÏ×äóü"/5;FPUZes}„Œ’˜£¦©±µÀÊÓÚãô&+16<EOW_hmqv|ƒ‘›¢¤¦³¼ÁÆËÔâòý )04=DPX\aju…Œ”™£«¹ÅÌ×ßçíñþ(,26GYhyƒŽ– §­³¿ËÕàçíòü %16;>EMUckox‡•™¢¨¬·ÂËÏÛåóù    $ 5 G V g l p v € ˆ › ¬ ° ¹ ¿ Í Ø à ê ô ý    & * - 0 3 6 9 < ? B F O _ c u ‹ ˜ © ­ ± ½ Ä È Ñ Ý ä ñ ú     & 5 B Q a f m t y € … • › Ÿ ¥ ¨ ¬ ³ ¶ ¸ ½ Ã Ç Õ Ù î ò    ! % ) - 1 5 9 = A H L P T X \ ` d h l p t x | € ‡ ‹ “ — › Ÿ £ § « ¯ ³ · » ¿ Æ Í Ñ Õ Ù Ý á å é í ñ õ ù ý       % , 3 7 ; ? C G K O V Z ^ b f j n r v z ~ ‚ † Š Ž ’ – š ž ¢ ¦ ª ® ² ¶ º ¾ Â Æ Ñglassmusicsearchenvelopeheartstarstar_emptyuserfilmth_largethth_listokremovezoom_inzoom_outoffsignalcogtrashhomefile_alttimeroaddownload_altdownloaduploadinboxplay_circlerepeatrefreshlist_altlockflagheadphonesvolume_offvolume_downvolume_upqrcodebarcodetagtagsbookbookmarkprintcamerafontbolditalictext_heighttext_widthalign_leftalign_centeralign_rightalign_justifylistindent_leftindent_rightfacetime_videopicturepencilmap_markeradjusttinteditsharecheckmovestep_backwardfast_backwardbackwardplaypausestopforwardfast_forwardstep_forwardejectchevron_leftchevron_rightplus_signminus_signremove_signok_signquestion_signinfo_signscreenshotremove_circleok_circleban_circlearrow_leftarrow_rightarrow_uparrow_downshare_altresize_fullresize_smallexclamation_signgiftleaffireeye_openeye_closewarning_signplanecalendarrandomcommentmagnetchevron_upchevron_downretweetshopping_cartfolder_closefolder_openresize_verticalresize_horizontalbar_charttwitter_signfacebook_signcamera_retrokeycogscommentsthumbs_up_altthumbs_down_altstar_halfheart_emptysignoutlinkedin_signpushpinexternal_linksignintrophygithub_signupload_altlemonphonecheck_emptybookmark_emptyphone_signtwitterfacebookgithubunlockcredit_cardrsshddbullhornbellcertificatehand_righthand_lefthand_uphand_downcircle_arrow_leftcircle_arrow_rightcircle_arrow_upcircle_arrow_downglobewrenchtasksfilterbriefcasefullscreennotequalinfinitylessequalgrouplinkcloudbeakercutcopypaper_clipsavesign_blankreorderulolstrikethroughunderlinetablemagictruckpinterestpinterest_signgoogle_plus_signgoogle_plusmoneycaret_downcaret_upcaret_leftcaret_rightcolumnssortsort_downsort_upenvelope_altlinkedinundolegaldashboardcomment_altcomments_altboltsitemapumbrellapastelight_bulbexchangecloud_downloadcloud_uploaduser_mdstethoscopesuitcasebell_altcoffeefoodfile_text_altbuildinghospitalambulancemedkitfighter_jetbeerh_signf0fedouble_angle_leftdouble_angle_rightdouble_angle_updouble_angle_downangle_leftangle_rightangle_upangle_downdesktoplaptoptabletmobile_phonecircle_blankquote_leftquote_rightspinnercirclereplygithub_altfolder_close_altfolder_open_altexpand_altcollapse_altsmilefrownmehgamepadkeyboardflag_altflag_checkeredterminalcodereply_allstar_half_emptylocation_arrowcropcode_forkunlink_279exclamationsuperscriptsubscript_283puzzle_piecemicrophonemicrophone_offshieldcalendar_emptyfire_extinguisherrocketmaxcdnchevron_sign_leftchevron_sign_rightchevron_sign_upchevron_sign_downhtml5css3anchorunlock_altbullseyeellipsis_horizontalellipsis_vertical_303play_signticketminus_sign_altcheck_minuslevel_uplevel_downcheck_signedit_sign_312share_signcompasscollapsecollapse_top_317eurgbpusdinrjpyrubkrwbtcfilefile_textsort_by_alphabet_329sort_by_attributessort_by_attributes_altsort_by_ordersort_by_order_alt_334_335youtube_signyoutubexingxing_signyoutube_playdropboxstackexchangeinstagramflickradnf171bitbucket_signtumblrtumblr_signlong_arrow_downlong_arrow_uplong_arrow_leftlong_arrow_rightapplewindowsandroidlinuxdribbleskypefoursquaretrellofemalemalegittipsun_366archivebugvkweiborenren_372stack_exchange_374arrow_circle_alt_left_376dot_circle_alt_378vimeo_square_380plus_square_o_382_383_384_385_386_387_388_389uniF1A0f1a1_392_393f1a4_395_396_397_398_399_400f1ab_402_403_404uniF1B1_406_407_408_409_410_411_412_413_414_415_416_417_418_419uniF1C0uniF1C1_422_423_424_425_426_427_428_429_430_431_432_433_434uniF1D0uniF1D1uniF1D2_438_439uniF1D5uniF1D6uniF1D7_443_444_445_446_447_448_449uniF1E0_451_452_453_454_455_456_457_458_459_460_461_462_463_464_466_467_468_469_470_471_472_473_474_475_476_477_478_479FontAwesome) #'*U_dw|€„®µ¹ÃÖÚ.3W[_!38Xkx|‡Œ˜¦ª¯³¼ÇÍÕáåêíõùV}£ÿ;EIUªÐ÷ý38<@dp½êîòù#SYcw~‡—ž§®³·»÷$U]b™¤©ßåëðõù (/49>BX^qw~‡’¾ÆÍìó÷ü     ! & L P Y ^ l z € ¡ ­ ± µ ¹ Ù î  8 A S W `  ‡ ” ² · È Ï Ø ç ó ý   ' @ G J Q X _ j p ~ Œ “ œ ¢ ª ² · Å É × í    # * . 3 @ U j m • ¥ © º Ì Ý ã ì ð õ ú     ( 2 C F K [ b r | € „ ˆ Ž ” › ¡ § ¬ ° ¸ Ç Ð Ø Ý à å ó û$*3:@DIN[hu|ƒŠ“Ÿ¥°·¿ÇÌÐØÞãèóøþ  *49>C&! úTïšø<÷ì÷ìø<6KeKPËY " !® `g ú ¥~ƒ††Ž~”÷ÔûÔ¢““Ž‘’÷Ó÷Ó ÷3û÷û3 hnnh À`¶VûÔV``VûT÷ y}}y / . ÷À÷ˆŸ— ŸGù”ü´' ‹ü<ûìûìü<ü<÷ìûìø<ÐeûTP 5  \ Œ÷4 hnnhû÷÷ nh´ 6  “÷÷]¶ ÷]¶ ÷0ø”ýÔ­}¬t¢ûë÷ëÜ÷ ¶÷ ÷"øûÏ÷ÏüüûÏûÏüü÷ÏûÏø÷"÷ ¶Ü÷ ÷ëûê÷? ™™ y}}yûy}™÷™™÷™}y÷O F M šû™wƒ›”ŸµïŠŽˆ’ ʆ…‰iimdodŒŒŠ $š@î~† K…ˆ‰Šˆ‰zµ&”w{yƒyw‰û}|û |÷}Ÿ‰“x•z—{‚wa&z‰ŒˆŽ‰„—öK˜Öïš••Š•Š•••Œ• $|•Ö'˜öË’—ŽŒŽaï‚Ÿ—›•œ“žŸ÷™š 1 ûT; À¶¶À +‚„„‚+‚’„”ë¢ ) üfüfÉøøøü…‘”‡“”“±½½b ” þTv úT‡ úTœš|zTW÷TW÷TW C ‘ ýÔ$ ùÔ% œššœ …‘”‡““”± 'hn¨®®¨¨®¬  ) V¶`À 3 — p ÷ˆ÷À IûT& ÷T0 À`¶V )ûT2 { „÷ ÷ 1 œ|šz */÷/ \ 3CCÍ ÓãùÔô D ÷n ; ÷T5 ÷8 ÷”úT tzux‚ûuü[üŠBr‡lmy˜z—~øûö5üˆŠ„Š…„q˜s¨™˜’˜øU÷€ hnnhûhn¨®÷®¨¨®÷®¨nhûør y}}yKy}™ËB ™üTøTt žüTüTbúN÷;û÷(û=èšZ“XWûG/û9û;ûûû/û_Mûknmn9÷÷:Y÷IÈÆ‘•ÃÞPé`ðq¦„¨†©‡›‰š˜ë ž~—€˜d·_²iÞ ‹÷TøTúÔ@ ú¿üÔ÷Aý_ù^¾X*³Dü4·ü4D³*¾Yù_ý`t¢¯¢£øø€Ý üi‹üiüi q : ú€* * lþn‹l||ˆ…}_zob^ú÷^§b·z…™šˆšª¨— ¢øMø<øMü<v¢¨€ªšš‘™·œ§´¸ ¸o´_œ‘}|Ž|YY……‡‚ƒƒ‚‘…øü÷PÉøføf‘‘”“ ûÁûÂÁ÷û9û>û!÷ìû÷ } ÷>ûû9ûÂUûÁ gv› „{z÷6  ‹ ˆû÷E ûàûà÷9 ‹üT+øT÷=÷9 ÷à÷àb ÷8 Á d U üT6 ª ÷$û$ûàûà7 ÷ûB÷à÷à÷$û$‹ ’ !á5õõááõ ÷mû÷û3û'!ûûûêû÷%ÆÆ ©§#xM'û nq‘’w€Ž€‚dû—†™†›†‚¥°„¸÷‚÷÷o÷^ û´øËëûëŠK€ +üëŠK€ +´ «û´÷8 | V``V ( ø”üX “ˆ« ûÓ÷Ó‘„ƒ‚)ûT  0ø0 ÷C ü!55!ü!á5õ÷tÀ¶`Vk„K* Ë÷®÷z÷z÷® ÷D Å c üÔ½ ÷hû@÷@ûh÷÷@û@°  3ÓCã F ùûÔF Ìù:¨ú€§ù:Ž € þÔw ÷h÷@÷@÷h —›„œ DRRD }™ € fMû@û jm‘˜qÃûûÈû;ûfûvûeKxvuýzt—vŸ†•–ˆ––—Ž‘• ç üføf÷ YYÕøü÷PÕ½Yóøføf ——’›œ \¥b±uû2 Ë?ò±¡¥´ºÀK¡ x—x–tŒw„‡€…~„ û!û÷ ÒÄÄÒ ÷¹ûG÷Cû¿ûCû8û=<Ù<û8÷ûCû¿ûGûCû¹û„÷pû]“„ùüî—›…› DýT² ùT4 “‡« ÷Mû¤ûYû·ûû;÷–÷/÷Ž•›”›‘—Ž’’’Ž„Ž„‘„£a÷3û÷Œ ãCÓ3 t ' ÷F 3CC3  ˆ’‡‘…‘ýZùZr¤w‚h œ“”Ž“¢•›¢¥ Û 5 œ›’—— ÷÷0 – ÷ˆ ãÓÓã š Åü”ü”Ôø”ü”~—›… œ„›— ' ü<ûìûìü<ü<÷ìûìø< v‹v[ ”„’‚ ˆüføfE z{„ ûˆûÀ û9ù"ûûTûMÝ5ÉŘ˜“•“’—{Š~~üDû;ûøi ÷7üÔÏ …’“ˆ“ ûû”'5 ù÷H û”÷÷´«÷t÷ˆ÷¼ ˆY½E ûT K ÷ +÷* : û1 r¤c‹rr A EQQE ÷û ÑÅÅÑ  Ë‘ž™œøô•}y…vKy…x}züôy™‘ ¬Ó ‡……YY7 ‘‘ yr•rrryy —…›œœ‘›—— EÅQÑ ²²’¯•÷A·÷0Ý÷÷†º¼ˆ¼øƒø%÷²÷ö÷4IüÔnû4 « w 0 ˆ““‰“––Ž”œ•—›Žž÷”c ¤£vš |™zû@;¥z™|÷K ûû,ûl"ü7oû''ûü÷A 6úÀ-@Y —•Œ“‘Œˆ€‚††ƒƒüü¥1øÜ :øû4œ V``VV`¶ÀÀ¶¶ÀÀ¶`V ‹c ýTf ùT ÷êø÷8ûÎüT÷šü(÷Aø(÷Aø(ûA Ž Àò ¥{¢t•s•o†yx ¦OI—IûûgXû!û!÷gX÷÷÷g¾÷! ‘ø mím))mím©)©íí© 7 ½YB û¯ûyûyû¯ û1ù€+Ž* ýZýZ……‡…ˆ„ M½YÉɽ½É ÷G û ,,û û ,ê÷ ÷ êê÷ ÷ ê,û  ø<÷ì÷ìø<\xcik—v‘ss]tRatŽyxx ÷ø• ?rr‹c¤r ~~‹w˜~ ¤¤‹³r¤ ÷&ût÷t? w t yyrrr•ry y¤¤¤¤• IûÔn ý‹ú”ú” ÷ ™ ÷)‹€ ‹÷÷”÷ ­ ™ ÷' ü<ûìûìü< Q À¶¶À­ À¶÷I ÷³õ@º÷$÷‡ºû$@!÷´ ’““”‘”øø¦äüËûy÷ ÷ QÐDnt…€yû©¢†¨ÒÅÐ D G  C rrc‹r¤ I ÷  ÷$÷÷÷M arwwvyrô/–˜—™˜– ¤ STdJ,]ÈÓÕ·ÄÑÛÎ49üö % ‰’ˆ’…’„˜„š‚™û÷xû¨ \û;COLD|yz|r‹‹‹Š hŸ‚¤¤ ˜~Ÿ‹˜˜ – EQQEEQÅÑ­ÑÅQE ÷øF÷Ð÷Â÷ B û!û$ûûDûDû$}  ÷”÷7 ÷õ÷³û³ûõ Þ ) ø”÷ ÷"— +N¨ ûh 6 5  ÑQÅE ž‡ŸŸž•øT÷t ÷‹û]÷]÷G ÷E÷#÷#÷E÷Eû#÷#ûE › ÷”÷” ”´ŽNb†a†]ˆ‹ sÌ P@Á—z”y–z€’“… ˆ“ŒŒ L L  • ûÔ' c ù z…{ ÷÷ “”Ž‘‘ û‹û] Ø - ÷Ô0 i¦p­÷­¦¦­ D ù”n ‹•÷1g æ 0æ ‹ û÷ ‹÷tø4÷”ø4÷tà 3÷T4 t£¯¢¢  ‹ÿäõ ûEû#û#ûE ûð&÷ ûÔI ü;÷íûíø; ü4'h DÄRÒ Ž û]û‹ û÷ ~—œ…››œ‘˜— ÷÷¨÷—÷Rã ]û‚û,yû B ÷”ù÷” }jii™ V``V z||z Ÿ  ‹÷÷÷÷÷ ÷Ë ûÿ‹÷‚ ÷ D ™ •¤¤ Œ›™œ ÷ é œ›}yŒ ƒ‚ˆ…… œœ› À rsyyû'û& û‹“ G e ÷÷÷÷÷” û_÷ûI÷bû ÀY ÷  û”÷$÷ ÷÷÷”÷ û@ üü øø   }ƒŠ™¥ª‡ÿ‡ÑßÀVXZ\^`bvx»ïŸ«Ù-e¤¿Qí.Q×OÙao‡ ( ƒ º þ Z ž  Ç $ ] à p y ¶›A58~`nÕKõ{BAbŽ Êû-jº9yŽÅ+‚–«Òü&/Uk~¶î#Tw[×¹  C ¥!!m!Ð","‘" "²# #¾$f$½%g&y''¹(j) ).)~)½)û*­++3+—+Ø+ò,O,ç-1-°.c/Ê/ñ0Ù222l2¦33‰3Ì44«5ª677©7×88‡9-9n9¢9Í:7:ë;n;îI?Z@OAZA°AþBKB…FÛGTGGÇHH±H³HµH·I`J•JàK9LöMŒNXN×NßNóOh3cû #û ^u™i¡÷„¢œ¥¡‹¨°ÐÆ­êÀ÷Ô÷R      Œ ù´Iû@& À0   ù”÷”£F¼M”fú€fM‚Zn¢nŸwù ý ý”÷5 ú÷H ûÔù”ù ù ŸŸ¢¨¨÷ù”÷c  À`¶V‚Šˆ‚ýÔû”c~ofaþ[ÆùYù”÷ü­Æ ‹÷”ú÷”‚ ùT2­Ò Ÿ «” ú@v ù” s¢u¤w÷#û÷$û÷ûLÖè>óŒŒóèØÊÖ÷÷÷$÷÷#÷¤Ÿ¢¡ £ý”ú¯69ûJXû"û!û!`V+/EŠŠE+ç¶Vûõûõûô1ÒRî÷A÷E±…_r÷°Šú@3CC3þÔ÷ cúûî †Õ Ÿ ú ©k—süŠÔûuø[ž‚z¡tUøUû€„—™†™¨—£¥â Õ qø¨Óü9ü ÷[üû[Ôø9ûÆ÷½ø:É÷Qø÷Qüø:M÷qÇ©k—süŠÔûuø[ž‚z¡tUøUû€„—™†™¨—¢¦â Œ ÷÷vV÷ïû¹lûûûXûXû÷l÷L ÷*÷3ùþ÷3÷ì÷6ûÔúv÷)ßú÷@ øKVú”ý”¹ þ”‚ ¹û€¹üù”¹ øüV÷÷4÷ úÀw@÷4 Õ ù”ø”` ‚ ` úü` ‚ ` cø”÷´F ùT(ùûÔF ýÀÀ`¶VûÔV``VûTV¶`À÷ÔÀ¶¶ÀùûÔxýÀxùT(cø”÷´F ùT(Ž÷+þTV``VûTÏ ûÀF Ž÷+þTV``VûTÏ ùTIþTV``VûTÏ  ÷ ‡ú^¤¤yû÷²ý$ý%ûº÷»²ûûÙ÷þûþ÷ûÚ÷÷ùhùh÷>ûÿ÷¤÷j¤¤yûº÷º÷º÷º÷>¤¤yû÷²ûºûºûº÷º²ûûÙ÷ºûºûºûºÙ÷ûÚ÷º÷º÷ºûºÚ÷÷÷> ‹÷”ˆ ø÷”àú”÷* ût÷t6KeûtûteKP÷tûtq ËY ÷t÷t3 ÷«2… ‹÷”ú÷”ú”÷* üÔeKPøÔY ÷«2…‹÷”ø÷”ø÷”à÷÷‡û÷tûW÷&S¶:€aR`S—:Ãa÷)Öû)û6û®ûzûzû®û®ûz÷z÷®÷6Ö÷)÷íõ—Ü`ÃaÄ;–R`ûWû&ûûtû‡÷,ø;÷í÷íø;ýù”÷ EQQEýEÅQÑ­ ‹÷ ÷”÷”ë}™yûTy}}yûTÇ÷ÔlûÔÇøÔlüÔÇúTlþTÇÀlú@‘fú”ùu ø”÷œ›zŽûK§¬}¬z«­º°·­¹’Ž’”“‰“†‘aÆEÉV¼‘„‚‚‚‚ˆ……û" nšm—l•o÷Lœ‰{˜yûry}{‡{O…J„Nll~n|ûö‘ƒ‚‚iûû&js†„‡„‚‚ƒ‘„°^¯^­[{m~mkûNo|ˆy|ûrz—{œˆ÷Kp•i™jœki\f_i]†„ˆ„‚ƒƒ„µQÑMÀ[„’”‡”””Ž‘’÷!ö¨|©ª§ûLz›~÷r™—››Ç‘̒Ȫ•ª˜¨š÷û†“”‡”­÷÷'«£‘’Ž’””‡”…’f¸g·i¼›¨—©–«÷M§›Ž—šûÿ¦ ø”ù´h ÷”øÔh ÷”øÔh ÷û([po†÷D †p§»úHúþHý4úȼ÷ Ž“‘‘Œ÷ÑŠ”…Ž‡»û øtkLûÉE÷;¼wO³VûÔVOcZwEû;ûÉf ëþLûÓ1ãùÔãÓé÷úHëè ‚ ÷”ø´‹ŠüÓønüÓün‰Š‰‰üt+÷Q÷”üø*÷sø¹–˜‰ ~–ûo÷Jø,g ûWûˆ÷`a®G‹ahýcüë~€‰v–~ÉA…“‡“Š”Š“Ž’ùHøÕùHüÕ†‘’‰“ŒŒ‹Œ“Œ“‘ÉÕ‹÷ù”÷ ø4‹÷tø´÷ø4÷túút¥ ø4ë# ÷)½úëø°{Œ||ûˆ||—›Œ£÷Ô÷?÷N÷B£ûÔ‡ù‹üg³€³|¯ü5ú¨¤p¡pûç÷BšûTyŒ~}yû:y~™Œš÷T÷?ûçppurü5þ¨|g€ccn“_±ùTz~ŒŸ÷”÷?÷¤÷BŸû”yŒ}}zùT±“·¨÷ ÷T– üdûûgf[wXX[Ÿ¯fû÷üe À0 ûÙú ¢t›qû”øT: û”1üTû”÷2 øTüT÷2øTøTž§£÷%úôøô® ÷ôg ûô¥~ƒ††Ž~”÷ÔûÔ¢““Ž‘’÷Ó÷Óè ûôøÔ,÷%úòù(—ˆ˜‚•ûÔ÷Ô‘„ƒŽƒƒƒˆ…„ûÓûÓ…„‡ƒ‚= ‹÷Tûô‘÷ô÷T˜—“—ûòø ,fú“øÔ,ûTûÔ,÷TûÐŒ‘÷hø„ùX÷hü„†Œ…†÷Ym¯€À}­û‚ø¼¬}c¥hýÔhcqj}û‚ü¼}i€Vgüv÷  ù¢ w–ü´÷Ôx—r‹w€wvtýt—vŸ†•–ˆ–––Ž‘•ø´÷ÔŸ–— ¢÷# ‹÷”c ÷/Åûû÷û!ûSÚûYü;ûíûíü;÷,÷y÷lð÷D÷&•˜‹ž–û÷‘„‚Ž‚‚Š‚‡†„û)û'Cû3û®ûz÷z÷®÷®÷z÷z÷®÷÷Y4é€ûûÚ øTNÁçøtœ}šyûT|‚}†zcesdû,.û9/ûFûû½ã-÷÷‚: üT1üT€’÷÷û÷"÷Q>÷Wø÷¸÷‹÷öàŒ‹Ž¤ù´¡ ûû÷û"ûSÙûXüû»ûŠû÷5‰‹ˆ‰z™|÷[š•”™œ³—±£²÷,è÷9ç÷F÷÷Z3êûûbøTN÷$ ÷÷Ž÷ø÷ô#÷Ô"÷Ô"‚ üT† ÷Ô† ÷Ô† ÷ý” ú@v ùÔ‡ ÷Eœš|zýÔ÷úÔŠú@3CC3þÔ÷ üÿ÷÷Tø”÷T÷Ôù”÷TÇ ¥÷Ô+Ik÷T÷Šû^÷^ûŠûŠû^û^ûŠûTk¡ ÷÷÷Ô÷/z ]¤b²tûPËY ò²¢¤´¹ÀKU _û=ûû1ln™oÌûû¿û1û"û-SKûq~n}s{x}zsýz5 —•Ž‘–Õ÷÷;Ó÷3÷nãû ÷L÷÷ÂÈ÷¨š¢™° ‹÷T÷Ô•÷Ô÷TŸ ùø/ü÷ïüWüWüûïü/ûŸ!³(ŸZ÷Mjû¨î:÷ k2 Ë?øÔ• K;k+8V=_G—xÉËÎ÷Â÷¿÷œ÷é÷é÷¿ûœûÂHKxMGÙ_8À+«h «÷ îÜ÷¨÷M¬Ÿ¼³îŸõ÷þ‹ù”S üÿú”÷S øø´ïNí-°ƒ‚Œƒhnog?÷ û û û ?g¨o®“”Œ“é±Èìï ú”÷1 S øø´ïNí-°ƒ‚Œƒhnog?÷ û û û ?g¨o®“”Œ“é±Èìï÷”÷_û÷QûPÚ÷: o›x¢¦}¤£yîCÅûûûQû(Csyrp}t{xoW ¯“”Ž“÷PÚ÷÷Q÷_÷”÷ÇûK÷ªû®÷ ÷: nš{£}™ƒ›†šƒ§|§z¥x÷8û ìûSû`û`*ûSû8û qxozo||ƒ{†}ƒs}|{n5 ””Ž“÷®÷ ÷K÷ª÷Çûÿ‹÷¦ ÷Qû÷$úû÷$ù”÷û÷$þ”þøøüüù“÷Qüø÷Qüýû”ýýù÷û÷$÷”÷ûû ÷ùûû÷$üý÷øü÷ûøý”‚ ýýùù”ùýýù ‹Êª«Êª÷ªêÉꪫª«ªéÊéÊÊÊÊʪÊê骫ªÊÊøk‹øiøhvv‹vüi‹üjüi Ÿ‹¡ÊŒd €‹€[—”‹–éa –•‹•÷1a —”÷!w›¡Ÿ‹Ÿ÷a –•‹•Êa –•‹•Êa €–•‹•÷1ag¢ž‹ ÷1a¢Ÿ‹Ÿ÷a¡Ÿ‹ ÷a¡Ÿ‹ éa¢ž‹ ÷Qgkl‹l[«ª‹ªÊg€‹€[ü—”‹–éŠøi‹øjøivv‹vüi‹üiüj¢Ÿ‹ŸZ÷)Zøé ý_ù^¾X*³DûtÒìcX¾ù_ý^¢s™jii}jttüjüjh­¥s¿­¬™¢£øø€Ý  ‹÷¼ßgú¶|Ÿv™t”Œy‹w…xûÀþog€`vfþ/TF—Åwƒ¡Œ”“——”›Ž˜ùù÷¥­÷.º÷¦ú™º…ºq¯®ra \ýzz†‡zŒŽû¯ƒûaM{tsw‡xˆy•z‰z…Vc,sj|wu„t…{•t‰v†\h2p]yx}†x†z•u†x€Wi:mY{pvz‡s‰”~Š{Šs‡w‰w}e‹_›^#°÷:ñú/áãÍà¤÷§ú™¹„ºr¯þ¼‰®8û”®ü‹ŽŒ€^ ÷”÷ú÷M ÷”úû”þùùùû4- ÷4ü÷”K¦ô4â"K÷”ÀmÔe±û,÷,±eB©Vý4nü´K"44"ü4P÷tû4“ úT0 ÷4÷t3 ÞúTùôû3ûûû3û3÷û÷3÷3÷÷÷3÷3û÷û3ùTø4ûtX÷Ír=ÁEü”E=UIrXûût„þ÷ ÷ ú{ ýT÷# ÷÷]¶ ÷]¶ û]÷G ‹Ÿ ùiúe€Òû%Èû/¿û,ŠxxŠx((ŽŒ(ü¿ý#ÊÉŽ–Ê™Ÿ‘™÷÷ w÷Œ”Œ””Ÿ‹žŠžR“û'ŽØ±ð÷š¥ÅøV‰›b÷û½gfV„p…ûoˆqŠqq÷÷–÷÷÷{÷”Œ“”žˆžˆž\/‘j¥}–}©„›Yñhö^ó?÷DF÷G@÷Eûaøtˆ’‡’‡’V@û¬ýhûüüaû%Ÿ-n‰<ûÿ÷s÷Ñøc÷×û“÷åÀø¿šsÅ”÷OÐôŒõõ•§¶‹©÷5÷ƒû*è¬V“JMûˆû(0ûx[[˜ž_}ù~ Š¢‹¢‹¢‹ÀŒÀÀ %Àðƒð𒶶‘·÷;÷AHûWû{û'QûbgfŒ‘gü±þ ’÷F÷I›÷Gãã…ã÷¹÷Í÷÷ì÷fû=÷ûR¶÷!Ë÷Î÷G÷˜û÷ûv ^]Œ^ûû‚z‡û‚8À¬‡÷'„šn£\‰þPuH#hPMqJŠK{‰-ý‹ú”ûãâšä€ÏЊŠÐŠÄÆxÄ¡ Ž¡“¬‘¬¬M•M’N™Š‡µ¼÷[•»À÷•Ë÷—»÷—•ÄÆ¡ÁϦԖУ“¨’©©…!!!ûû•‘ûx$ÇΓÂmrŽ;ûnþi~G„h€ftnOlFƒKwz6 ‹÷ ø÷–ù—÷Ð÷;ú”Û·™§®pàû÷6p®_‹phûû6hp™o·Ûþ”;_}oh¦÷û6¦h·‹¦®÷÷6®¦}§_ùÿ÷% Ç‹÷\»¬ ¨öœ°œ÷Ž|™—}‡Cyû û^‘û^û^LŽû£uZ ÷­ˆ÷­Š÷­Š¸º·–åê‡æª¢q ‰£í ²®÷ ept”cû¹CDŒC÷3 ‹÷ ø÷‘Ü÷% ÇŒ÷]ºª›£÷¡µœ÷Ž|™šz„ûb||}3’ümrS ÷6‰÷6Š÷7WŠ÷,Š¸º·™÷ ÷"„÷•»Œˆ“–‡”…’‚Œ‰¤í ±¯÷ ~yv}uŒ”ûû …û÷3 —û]› yþ”›ö]hûû vp|€zww–zšv¦÷û ®¹{öú”y{ ¹®÷÷  ¦š—–œŸŸ€œ|— pû÷ h_ üÜ û* Ž*÷”Ü ú* c *üÜ û€* ‚ N_ üÜ þ* ú*÷”ø”]üÜ ý* ùN_ ø”: û* Ž*ø”: ú* c *ø”: û€* ‚ N_ ø”8 ø”8 ø”8  ‹÷”÷”÷tÅ øÔÅ øÔuú@uøÔ½øÔ½cøútM÷Cû´û´……ˆ‚ƒƒŽ‚‘…÷´û´…‘”ˆ“3 ûTJ c÷ôùT“ˆ« û´÷´‘…‚ŽƒeüÔ\÷÷´÷´‘‘Ž”“ ütJ  ¥{¢t•Žƒ‚ƒz{…~ü'ü&÷9&ýT‘ ýT$ ùT% ÷:ø'ü'~—›…÷. Ÿ ÷ùúTµ ú”üü4ø4ü”ü”û4÷4ûÔûÔûTë‚ œš|zû@Ê ÷4kŠ‹ùÀqû@w@÷4 ‹÷÷ÿ ÷ûöææ÷ûøDùÙ…‰…††ü²ü²††…‰…~‚”˜‘‘ø²ø²‘‘˜”‚~U÷TýÔýÔü4ø4ùÔùÔ÷Ÿ÷Ô÷Aû÷~£sj™iij}stû:û9ø4ü4÷:÷:Ý ý‹÷”ø”÷”ù”úu ÷”÷¯ûy÷yû¯ÊN’L¥Tøýš_Ÿ¹p»»¹¦· øùš¥Â’ÊÈ‹÷tù”ëGþÔù”ø´!ý‹÷0 ú”@ø”ø£ RÄÒ€¤“£—Ÿ˜ŸÀϠΖŽ•““•†€Ž HÀG˜w—w“sr@÷ðméXÛXÛûj÷£:÷¢¶b kkcv`~:û¢ûjû£X;€Y;l-&@÷ ÷$ ø”ëø´÷ú ÷ôSë+Ã÷÷÷,û,÷Øø𔂊|‚‚ûòûò‚‚|Š‚”‚”Œš””÷ò÷ò””šŒ”‚Ûü昃–~‰KK……ˆƒƒûâùÔšš‰‡š–‡—Ž””¼¼““Ž•‰–‰•„”‚œfc“cýÔ@+ú4ý4ý4û´÷´ù4ù4÷0÷0°°‹Éf°û,÷,f°M‹ff//÷´û´çç ‹÷÷÷gùÁ÷ø·˜‚–}‡‚‚{|y~w‚€…„€ûjâ÷‘±¢¸Ÿ½œšŽ–˜›|™z‹‹‹÷ "û“@÷ù‡Öüø—{’zƒ‚‰ˆƒt{tqûTû4ý 7ûÈû û\÷3ûu’ƒ‘•†•ŒŒ˜‘”™‰™l÷z£÷*ÜèäÙ÷ µ÷p÷4ûTq›t¢ˆ“”‰“œ›‘˜—÷Q ‹÷‚ ÷Àøò˜ƒ–‡‡Œ‡ƒƒˆ„„KK……ˆƒƒû’âùÔšš‰‡šŠŽŽŠŽ“”±¼¼““Ž•‰–‰•„”‚œfc“cýÔ@÷{ù»««‹½k«û÷k«Y‹kkýýû›÷›k«Y‹kkûûkk‹Y«køBüB«k½‹««ùÂù ù”÷”¾ üøt™û”÷”t žû”û”b÷üü÷œ øü´ 'ª ÷0 mœ›’——÷‚: û÷Qû’÷‚ý‹÷”úgsyÀò  ‹÷”Ó÷ùZò yùZÄ ÷S÷ùZò ýZýZÔùZýZ¤rŸ”®ùZÄûÿ‹høõªœ‹§lœúÐùvlœr|hú@h¤|ªœfc @U ü”1ú€+ø”*þ€U ü”1ú€+ø”Nfc @± ‹¸ûÌ ýZòùZùZÖýZùZr¤w‚hýZà  c ÷”¸ûÌ ýZòx ýZà ýù”÷”¸ûx ú@òû}‹™øÁrr”w®÷E®”Ÿ¤rýZùZ©ùû / ÷”: ú€1û”+ü÷.ú “ÓÖû:÷:©ýzýzÔùzýz÷ ÷:÷:Öü§ø§ø§ø§üåú úçù'Öýzùz©û:û:Ôø§ü§ü§ü§Ô÷:û:÷ ùzùz‹÷Ôú÷ÔÀ÷ û”û”R ÷0 Ø÷Rû”÷”¬ ´ ÷ÔË!‹÷Ôú÷ÔÀ÷ ý”hn¨®÷÷ ´ ÷ÔË!f}ø2z„z11z„zz{’—ûI÷IûIûI{„zzz’—1å—„œœœ’›——÷I÷IûI÷I—„›œœ’œ——åå——œ’÷D„—÷IûI÷I÷I——›’œœœ„—å1—’zzz„{ûIûI÷IûI—’{zø÷v!¿ ù¶÷@ü³ü³z„z{z’—ûþ÷þ—…›œœ‘œ——æåÙ ÷vûvø,ø+Ù æ1—‘zz÷û6k fú÷4y}}yûTS÷ }y¥÷”ù4û,#Q?`\pnZt‹³ ¯ììÞÒ«ȧ¦¥¿·P´Kgjzx}wy\Oƒ…‡‚„„†ûï~•‡”™÷#á÷Ñ÷7÷@÷TûûKøûT!fú”÷4DüT; ÷45ë÷Ô+; ÷45÷Ô4 ü”ë? û4ûú³ ÷4÷&û4ùü4!ù÷”­ø”`û$ûûû$`÷¨ûû$¶û÷`÷$÷*Îû¶÷$÷÷÷$¶û§÷÷$`÷û¶û$û* ÷÷ç÷, û#Z÷kû=÷=ûk¼÷#¨û#ûkZû=û=Zûkû#* ÷#¼ûk÷=û=÷kZû#§÷#÷k¼÷=÷=¼÷k÷#N úÝø]ç û÷÷÷ç û&÷&÷ ûûû÷÷ û&û&Õ÷ûûûÕ÷&û&ó÷÷÷ûó÷&÷&÷k÷K# “ùgÖ%ñ©û§û§û'÷'©%%Ô÷ºûº÷ ø:ø:÷!8#  ùûÂûˆû‰ûÀû%¬Ã5ù†ù…Â6«&ûþ{û¿Sájñ÷÷Á÷ˆ÷‰÷À÷òjQáøhü[ø=ûì÷íü<ü<ûìûíü=ü>÷ìûí÷ ÷íø>ËÀ÷Ï^ÇCýT÷¹÷¹££™¬­­}¬s£@Õ£sk™iij}ssýýtó j¢tùý ÷'Ö×£¢™¬­­}¬s¢û¹÷ºùTÓ¸ÇÏ‹ÀÀøÔ­~¬s¢ýù£sj™iik}ss@@st÷6j£t÷¹ûºýTC^OG´ G¸OÓùTû¹û¹só j£sÖ@t£«Ó ¢£ùù££˜¬­ ÀKøÉ÷Aýù£sj˜iij~stýýsó k£sÖ@s¢¯£¢÷º÷¹ýTCÇ^Ï÷ÏǸÓùT÷ºû¹s¢¯££ÖÖ¢£™«­ ÀKùT÷A@Ö¢sj™iij}ttûºûºùTëû·ýTûº÷º¢tj™iij}tsA@só j£tùý t¢¯¢£ùù Ý  ‹÷júß ü”ø”‹û”ûtûÜü,Qûíûa!€ûûû ÑûKÄû–t–kšv’’„™Ÿ—›ž›‡Š›ˆ´‰´´øq÷¯ÞøC÷tû”’ø”ø”‚fù‡øtdù¡ùôh˜æù”øÔhù‡úôdfj ÷û!y}|zûTy|š÷Ršš÷Tœ™|y‰÷.}Š|€yûMx|–™zù’Ž’’‘”Ž”÷p””ˆ†‘’‡Ž„„÷Œ÷ë÷÷Ô÷ë÷ú4÷HhnzhûThnœ®Ãøh÷T÷Ô¥ühSü\ùàV`¶ÀÀ¶¶À­£y~–÷û5øëV``VûV÷÷5˜–£­À¶`Vø û”LüL÷ïï÷÷'ïûHMoZdûû9û÷9¼dM§Hû''ûûï'÷üL;ûÔ÷A ü4“ úÔ0 ø4ëècŽùÔ'ûŠû/Jû7ûI[^_[Z_~}„yhn¨®’™—˜÷“÷{÷x÷(÷ö¬ ø”÷Zàf÷¹û7p\XTûûüHÚûaGû°-û‘ûwûÒhŽh‘iw¥V‚QûZ:#v’…”z]¦žlÊâÇ÷`½³ëL{»læî{ë÷,÷+³Ï÷÷ª÷÷\÷^Ë÷˘˒ÌËŒ û46úÀeKP@Y û”úô÷æû€÷Cû¨÷ŒŠˆŒªN®.Eû“üTiüûæ÷€ûC÷¨ûŠŒŠkÈhèÑ÷“øT­ø øT÷$Ÿ øÔûœû?û¨ûLûÕûÕû¨÷L÷œû?ê÷'÷÷÷0ÛcGv=<û‹÷]û]¶ ÷]÷‹ÚvÙcÏ÷0;÷ûêû'ýdøquuqû--ûä ùäü¤ƒ¢ ÷ÂûLûå÷aû÷û÷ûåûaûÂûLvƒtrr“t—vûÂ÷L÷åûa÷÷÷÷÷å÷`÷Ã÷L— “¢¤ øT÷$ø¿÷]ûDÚû'÷#÷5ê÷'÷÷÷0ÛcGv=<û#Ðû÷7÷Ëøþquuqû-.ûä ÷ÿ÷S–…•‘—v-Åy……U*–PN‘OüûÉû_ûÄûZ~w„rsr’s˜w÷ûH÷7û*÷V3ziU{‘•… êQ––‘•‘¼ä÷gø ÷eø÷gø Œ‹°üS§ˆ§†§û¬üŠ÷AÍ÷÷:÷NøTû¥„ ~¡=÷û÷ûÞLû÷=ê&Õûû0û†û‹ûEû·rAû÷Á÷¢÷÷u÷X²¸²¼ª¾˜¡’ ¥cú”÷5y}|yûTy}š÷R™š÷ |yûR‰ø ~Š|yûMx|•˜zø]‘Ž•’‘”‘”÷p””…†‘’†Žƒ…køo´u`¥\\`qbuý”ú€udŒ[¢dd¢µs¸c ¸µ£²¢¢²Œ»u²ûÿ‹z``KËû4K++û4û4ý-÷3Ž‡ƒ„ûû„„ˆ€Œ‚‘‚”†øû«û—û—ûVÀŒ‰ˆ‹ˆ÷C+*…„‡‚Œ‚Œ‚‚“†÷ûQ÷Qû‘ƒ“‡•ŠŒ‹‹Œ÷ëë“”Ž–ˆ–V÷V÷—÷—÷«ü‚“†”‰ŠŽ‹’’÷ë•“˜ˆ—û4ùL÷5÷5ëëË÷4KË ‹÷÷÷«Ë«÷÷4Ë÷4÷«Ë«÷÷÷÷û÷ Ë÷ ý4÷ô÷Ô÷´ûÔË÷Ô÷ÔûÔý4ø÷ øTýt÷ ýTùt÷ øTýt÷ ý4÷ô÷Ô÷ÔûÔý4ùô” Kv ÷´‡ Ëœš|zû´ùtýô÷Ô÷´ûÔý4ø÷ Ë÷ û”øt” Kv ÷´‡ Ëœš|zkcù.ú³÷"&ûÞûFûtI ÷t÷+Ëû û ųé´èÃáúúý³pû”û+K÷ ÷ Qc-b.T5û˜÷M÷K®÷½ûTzš| úpû”ûÙûû û–ûsRrQnSûSL0ûûtI ÷t÷Ù÷÷ ÷–÷£Ä¤Å¨Ã÷ÃÊæ÷÷”ûTyš}  ù÷öü%÷²üƒüƒü%û³ûõ÷Jñs {¡µfc ùTÈ ûKûi‚``ûi”÷K÷È ü,÷×û¼øQøQ÷×÷¼ø,þ”ù”U ü1ü+ø*ú”øU ü1ü+øN åL“÷a¤¤‹´r¤ýzùy©ýzýyrr‹b¤r÷:û9÷ ø§ø§ø§ü§÷ ÷:÷9 åL“ùl¤¤‹´r¤û:÷9©ü§ü§ü§ø§©û:û9rr‹b¤rùzýy÷ ùzùy÷)÷ú÷”Ž«’ˆ“‡‘û4÷T’…‚üÔø÷TD š†š–ûÔø™y“xxyƒ}ûÔü€†||÷6 ÷Tü4û4r†d°úTY ùø4U ûTø4÷4¤²fþT÷8„Žƒ†÷4ûTƒ‘•‡”øÔüûT6 ||•€÷Ôü}—‚žž”™—÷Ôø•–šš ‹Ÿ û÷5€ùz DÄRÒ…úz ÷.`…÷úÔU ûO»ŠÛGû”÷ ÷`÷EýË}n\>l÷6 ú”÷H þ,•Ÿ™ ¢¢‚¤‡¡ú¨÷@¬£§«Õ Ÿ ú4÷ý4y ûð&÷À÷N ÷)‹WWøܸX–gþÔ3û UGQûäü {y|ss^¾€¯úÔã÷ ÁÏÅ÷äø ›š££ûë÷ì÷ü´y ƒŒ‚ƒ‘÷åø ëÜ÷/Ò÷ùÔþ÷ùTÀß û”÷”t žû”û”b÷þ”û6 ª ÷0 mœ›’——÷‚: ûú”÷N ‹¾ þ”÷œ ú”´ ’÷‚÷. ÷÷ ÷ø”ø”û”ü÷”øúû”þ÷”øùû”ý÷”øú”û”þ”÷”÷+Ê œš|zû@÷À÷ û@w@÷4 ‹÷´Žú2o`gfbnŒ‚‹‚‚ûªûhûÔüû û®Æ.‰›œŠœîå­ÃÓ/>ÈpÞ‰˜˜‰˜ž™Ž+ž>àñŒ‹Œ‹«|¬®ŠR±iËÔ±–°ªóû÷/8÷C‚‡šŠœ›÷éé÷ÇÂrb±»”¸´£{Zja_q¶‘³–±œ÷”÷V  ÷tc ÷4úT&! ø´øôût÷t÷t÷:÷Z÷÷÷EßË…ˆ«ûcûŠ+o^Hû#÷}mûtû_üô÷Tï÷$ ø”ëú4÷ú4ùT)V``V)Q –P ÷tûKþ”üÒ÷c ´ üøÒûhû@û@ûhš þ”ù÷ø´ ü”ûT÷ùË÷ùÐûû ÷÷”ÒRÄDú}û÷ c … ‹÷Tù÷TùÔú”!55!no’—q—q’on!55!!5áõõááõ¨§„¥¥„§¨õááõõá5!ùçýT¨û«÷›f°‘…‚ƒt//tqé: v++û÷÷÷ÙôÀ÷÷÷nû+÷*ûmûÜûÜûÜûÜûm÷*û+÷n÷÷ÀÙôù3ý3y¤¤ÃËËä¤yûp÷pëëv Ü-¥¢çç¢÷)‚ ÷”úùu ù”ü”ERQDEQÄÒ­ÑÅQEú”ERQDEQÄÒ­€ÑÅQEüü9™˜}Žû,¢‚§¦~¦§²©¯¨²‘Ž‘’§û ÷q£…„Žƒ„„‰†…û 2s—r–q“t÷-™‰}–}ûN}}‡~Z†T†Yp‚rr~ûå…„Žƒnûû pw†…‰„„„Ž„…«e©f§c~r€rƒqû/s~‰|~ûM}•~™‰÷,s”o—p™pndmfne‡…ˆ…„n÷ ¥s†‘’ˆ“’“÷ 䣤€¥ƒ¢û-}™€™÷N™—•™˜¼Â¾¦“¤•¤˜÷1‡‘’ˆ“¨÷÷¦Ÿ’’“ˆ‘‡‘k±m°o³˜¤–¤“¥÷/£˜•š˜ùûð7Œ7cù”÷¯ûÏ÷yü÷ … øû”Y÷6éó÷$÷7‹÷÷÷÷Ç÷÷d÷÷I÷.÷3÷òô÷”÷TÐ øÔfo1\Š s™\kòÑû<^ûû û û®±ûžU/¯Skù«Ú÷ ÷?Ÿ¤ª£ª§¨ìñj÷-ËÌ÷¢@û û +6û ÷ôð ûD©ÉÇÑ·ÅlÈìZ'°#ik}ts')«û2OKebh`i_ømdG1dqû¦}ý÷ ÷´ô§Üm¨]÷÷a÷"òè¯á ¤·˜½½¢ˆ£…¡«»œÄÅ‹÷÷÷÷Æ÷÷e÷÷ ÷G÷.÷3÷øñ÷”úÔÐ üÔGNOHûôû ë6û û t@ûK̬÷-*ño¨sªrªÅ^û ÷?<kù«Ã篞Á±÷÷®÷ ÷ô÷ÕYû òx‰xˆyµt¢R]ñs…sv­kžc\k}\vsòºŠ§1f÷ŠôÅzÄk»‘¡Ž£¢ø½~½r·™Œš™ËvËd½÷OŒû÷ûJûû.ûeYû$n:moû´}ý÷ ÷¦²qÏ1©d­_®`±cÆJlû2ï)t£«}­óï°ì¼ªÇÇÍÑyÇmÉ÷Dñ÷÷ ÷ ÷ýÿ‹ùÔùÔà‹U‹Ò Ÿ ú@ûKûMû>ˆˆüØüÃüÙøĉûM÷>÷K÷­÷RÆ÷4÷)÷<û5M¿£n½‹£¨É¿÷<÷5÷)÷4÷RPû­÷†î  ‹÷ùë°d†rû´3CÓãùTô­ ¸~ϧMûÔ‘ ýT$ ­ ¸~ϧú4ø´r ‹÷÷{÷÷{÷†÷{÷÷÷ùJ÷{ýJšú IYU:‹Š=YÁÍÏ¿¿ÚÚ¼WGŒøÝþ øéjÊ8Ke`bz…|Švwüû{‹Žù ˆÌ‹÷{&‰»©ÂÐ÷÷,÷(ûiü"÷úz üÿ÷”÷4øtù4)Q øTFP üTù4ûô÷8û÷0ûø”­÷ ýEQQEEÅQÑü”ûûû0û85 ø(×üy{Ž˜€›‹Œ‹‹›˜˜›¾øwøAN÷$ ‚ ÷øô× ûÔâùT ýT@ø U ü”6 ª ÷DûDý ý 7 ÷ûBù ù ÷DûD÷#÷ ùr ÷ô÷ô&ûÔ^˜Gof²¤÷´ãÓC3ýTûÔ^˜Goq ÷Ôï ‹÷øÔ÷”øÔ÷àø^ù!ûY´û÷íë÷”û1«ûµ/úÊ÷§)ûûûYbµç«÷÷1÷”+÷÷Iû´ëŠüÔ€ +û´÷7´ ûR÷zûf÷Ì|³X°m}À[™YKKkK+++K+K2 ùÔ?Ëë+Ë++kËËË™½À»™°©³¾÷Ìš÷z÷f÷R‹÷_÷¤÷L±ù<÷ªø÷L‰”…‘„’‚Œ‡††‡‚’…’„”Š aȇ’ƒŽ†‡†ˆ‹ƒ„„“ˆŽ‹‹“†’NLj…Ž…†Š‰ˆ‰‡Ž†‘ˆˆ‘ŽªiŽŠ’†‘†„‡‡‡ˆŒ„…†’‰÷û‘…’‚Žƒ‚ˆ‰…‰…‘„”‰`“ˆ”Ž‘ʆ’ƒ‚Š‚„†…„’†•Œ ”’‘Å•Š‘ƒ‚Š‚‰……Œ„Œ…“‡””‘‘Š‘úXúP&! ÷t«­‹»ŠäN ûr[¬‹«÷tï÷ Ë– ü?ApDU8û”8DÁÕpü? À0 ûÙú\•¢†§xüTøT˜z‘{{z…~üTüTÚ ÷”üT.÷”*øT÷”¥¢›£•‹÷û÷!÷¹÷8÷ˆùZû¨ûZûÄû›.n8û„2ûûªûY\uZHm{¢§·¡µ¹(ÜrÚÜ÷…Ñ÷¬÷^÷-Ʒ֫Ϧ­áå®èˆ÷ ÷[÷ ²²”²‹Š”{Œwx^^]U–pž[›c”û\÷Ë€÷tň«‚™¯¸•¹¸óbÜûdeeû û»û û$fb%ˆ÷aûa÷>"ÂiÆpÈulàßeèÎÇž«Æ¸¤Ã« ¼š¬›Ñ¯÷<úô÷/ãÓC3ýÔâùÔ÷´û4&‹÷ ûûû3ýÔ$ ùÔïü‹÷ú”÷‚ ÷/û&ü;ø*2à26ü;ü*Úú”—÷^ƒ Ž÷ëqXsImû[FHN¦¢MûoÛû‚÷‚;÷otÉpÈÎл÷Í©•£¾—¥‘‹‰…Õû&›o–x¡tt_ûJdwr•yÕûæ0÷A¤yŸ²Ì÷·¢¢u€ž§{÷&A‘y†‹…†÷”ù  ·(TúüQrLyJ„γ¾Ê£ÖMfEpB}ÊP7².ûGû$û%ûFrŽrsû ™ûƒ÷û3÷Xo[{TOûÄ(âQVYš`£Š‹‰Šû1÷û÷(m„pn‡nvwŽw´û÷ .÷"ˆ4ûûXû+prŒŽq/÷#÷>V÷Køæ÷Ùø€ø?™‹™Š™ʹÂÄ·Ëý÷ò÷ÆúSôp.“ûûvû/ûû‘ûnû“û¼÷“ý‹÷Æù‹÷’²÷¼û¹÷Qà¢Æ÷÷1‹÷ªúh÷ªÀáûç÷pû´÷Å%²„™£ŸŠÈN 8rw˜s²’÷Åñ÷p÷´÷ç ù”÷Tø”÷TŸ úT÷ ûTý4¡øÔê+÷TÇ û”+ËN÷. ÷÷”Ž÷à÷/ ùÀ€ û@w@”ÀŠùÀû@œš|zûtù€÷t÷ ûùÀv øôŸ üô„ ú ÷÷”÷û”øûˆ üŒ ø÷Tµ ø”ûz÷i.÷]û,÷+û+÷,û]èûiœ‰Š‹‰{{…€€}„zyûj¤p¬ˆ÷Ån÷†û†¨ûÅjŽ¦r¬÷œ’™——˜‘œŠø”‰y÷òû'÷Ýû÷ŒûŒ÷ûÝ÷'ûòŠŠ‹Š{{…~„{yû#j¥o­‰øÙiøcüc¬üÙi§q­÷#›’˜—˜˜‘œŠœ‹÷ù„÷4ë÷4÷÷ú¤÷ÔÀ ÷”À ÷û4” û@v ÷Ô‡ À÷ û2øt÷1øvœž˜ù¢ž~z÷1üv÷Fû4¦ƒ¢ƒ¤ûYøòÑtH¼Aý¢AHZEtûYüòƒrƒtpûÔwÀ÷4  c ÷Ÿ úøëû4ûTûÔûtüüt€ ûTw÷EûuáûFÅûFç6÷–É÷!Þ1ÜÑ÷=Û´÷÷ ³÷ïn÷³û_÷Fû(­ø…ÒRÄDûüðû™÷\û‘÷û’§÷¢÷’§÷‘÷÷™÷\ ˆ ËÛÛ÷T÷t÷Рý-÷´÷t÷‹ô÷Ò÷ß÷Y÷%Æ÷C÷C÷%PûYûßôûÒ÷tû‹÷Kû™÷qû÷ç÷ä÷uû"÷ûn¥–Ž˜˜IV``V~Ž~€ûnqû"ûûuûäûûçû™ûq´øTð÷ ÷øT÷f`ù÷÷ž’¦…¤„¤wŸr‘ûP»À÷N’¤„¦xyžp’r„ûNV[÷P…¤wŸr‘q’q„yxûûû÷yžp’r„r…ww…r[ûPûNÀr’p„yxxy„p’rÀûNûP[r…ww„r…r’pžy÷ûûûxy„p‘r’rŸw¤…÷P[VûN„r’pžyx¦„¤’÷NÀ»ûP‘ržw¥„¤…¦’ž÷÷÷û}˜žƒž‘’ŒŒ‘¤’ŸŸ‘¤»÷P÷NV¤„¦’žž’¦„¤V÷N÷P»¤‘ŸŸ’¤‘¤„¦x÷$ ÷÷ù4÷ ÷.÷÷½÷ì÷”÷TôCìøÔFPPFûß s™\kÑû >\ûûVû?÷ûCkù«õÒåÔË´¹±¹¬À˜ —¡—¡¢–¾÷§àÖk+û+JLøÔð ü š´’¶·÷=ûâû3ôû`û?.Qm\ibgbjnG5[û´}ìý÷ ÷´ÊîfuÈeóõl÷á  °˜³Žµ÷=÷ ÷÷ ÷ ÷$ ÷½÷.÷G÷c÷ù4÷÷÷Ž`÷–ûCû>ûû[ûB¼÷ ®žŒžŽa¢tĹ£‘£— Îi«x³º«™º £ûßFPÆÐÏÈÇÎøÔŽÊ+Ì÷ë֫ঽût——t—t™u¬V±]´]BËÒ1õ«ý÷”˦øÔÒRÄDÎû´[Gá¬ng´i´mºèQ`÷?ûû3û4û=_’`šbü ûû û ûû ÷û ÷ ÷=Ža˜c f®‰}Š|}K K³Y–Š†ûSŠ÷#÷L÷ô«°ñŽ¡Èî°Ê÷´…Ö ŽK¦ùÔûVûû?ûCký«õ1ÒBË]´]±V¬v˜u—u—t–û¾§à«Öë¸÷Ì+ÊøÔÎÇÈÏØÐÆPFûß £º™«º³xi«— £‘£Ô¹Äta¢Žžž÷ ¹?û÷÷Mû÷ûQ‰²YK K}|Š‰}f c˜aŽ÷=÷ û ÷û ûû û ûü šb`’_û=4ûû3û÷?`èQºm´i´gجnáG[û´¸÷.ù…÷´Ê°î¡È±óªõ÷Ö øÔûZBû ÔxxŒŽyatRt]ss‘—vikcx\j_šŸqûßØFPPFGOÈÎøÔLJ+û+kÖà¦÷½¢—¢—¢—¡™À¬¹±¹´ÔËåÒõ«ùk¸ûC÷û>û[ûù”'hn¨®D Ô¬ Ø÷”ý÷kôfñuÈfîÊ÷´ÒRÄDÔý}û´[5Gjnbgbi\m.Qû?`ûû3ãû÷<µº‘›²ü û÷ û ÷÷ ÷ ÷÷ ¸÷=²¹™­ž؉™šŠ™ËË ³½Š÷SŠó÷÷L‹÷ú™÷”@Ž÷ üŠ÷QûQÀ—‘{z@÷00æ ûþ÷þ0æ³ææ÷þ÷þË —’{zz„{ûQûQøŠÀ÷ Ë!‹÷”ú™÷ù÷@00ûþûþÀ÷„›œœ’›——÷Q÷QüŠ÷øŠûQ÷Q³ææØ ÷þûþæ0—‘{z÷$¿ ù÷@00{„zz{’—ûQ÷QüŠR øŠûQûQ÷…›œœ‘›——÷þ÷þææË ÷þûþ—‘{z÷Šk ¿ ù÷@ûþûþ00÷"ûþ÷þ³ææÙ ÷QûQøŠRüŠ÷Q÷QË —‘{z÷Œk ‹÷»÷E¬ÚÝ‚¡º§¥”»Ÿ“¿vŸ÷”ÖÀj ÷¦ü–’”™‡–ˆ”‡~‚…‡‚„‰”‰˜‡‡‚¥|iyz“Šr|Œ‚†‹„‚ƒ€–x|…~t’}–uz€š‡€……Œ…„‡Œ—ŽŠ†‰‡‡†~€}‚ƒƒtƒˆ‰yzr«„Œ‹jŠŒhv˜…§ˆ–ˆ—Š‹ƒ—~|‰–€’€‘{‰…‘|€€Žˆœ‡ƒ“Šˆ†‚ƒ‘~•oz|’Œ‡‰Žˆ„’…‡„†……†˜r}sŒpw˜hž€”†©‰”™‘‰–—˜‘‘šŒ¶jh†yˆ~Š|‰‰ŒŽŽ‘Ÿˆ‘—’™‚}}˜|x}›o†–wƒŸ•ƒˆu€‰‰x –Š‡ˆˆˆ‰—z‘‚—‰Žp´‘}…o•~’v–ˆ¨q‡yˆ†„v“}•}’{”o”…Ÿ…›ž‚š•…yŸ~—t©Žˆ€˜c®“ŸŽu“‡ŒŒ€‚‘‚‘–yšu‰u~‡ž‡“„˜x‹†™ŒŒ‹ŒŒœr™—}–‹ ™‚˜|‘~”†Žg¹˜Žw†ºŽ—‹‰‹Œ—„É›Œ€Šˆ¦Žš|Œ‰‘Ž‘“‰’ˆ“€’„‘ˆc¥ŠŠ’Š’…x|•¨Ž‡Œ‡Ž‡ÅçÜØëÀŒ‘“‹“‰•|˜‚‡“ˆŽ“—’”Œ˜“‡…”„“„“ŠŠˆ‰Š‰€”v‡ƒ‡„†ƒˆ†‰ˆ‹‡ŒîÀ©›ª™¬–‘‡‘„”„…‹t‡–|£•šŠ¸…‚ $’‹|”‚””~•‘”‘Ž’’ˆ‘dŽž¢’“¤‡“†ß@–…—€|’Š¬‚†~‘Ž”“”Šv†™r£½‰y’­””ˆ’ˆ–s~Œ×@–ŒuwŒ}Œ{ž~|ÖÀ‚‡|‚‚}}xŒz’Šut‰‡…„‡ƒ‰ƒ‰€†œ”l„Š Žœ‹Ÿ„×@™† …‘|‘žˆ‘‰—…Œ~Ž€|˜rœ“Ž¡•ƒ‘ƒ’‚“•“–žŽ™“¢kˆœ•˜ŽŠ—•|Ÿ—’•‘»”…”…§ƒ‚‰Š‹‰ÖÀ“„’|}‡”¥y…‘Ž‰‘’’”†Š–¡‘Š”Š~…‚–ˆ‚’zˆ{¢…’‰ž–Š|ŽŒŒ}‘{œ‹‹x‰ˆ…‚|‚†ˆŠsvŽˆ~šv‹z‡yˆz‰z„ƒ‡ƒ‡…„ˆ‡†y†Š•–“‘û7þŠŠ•ŒŠ›œ–Šš€Žˆ–—œš——–—–Ž¢ˆ™†£‹¤‡£Œ…œŽƒ’”’‘’‘•‘ ¢—}•r~˜€“‡—““›–w›†œ†‘…˜€‡Ÿ’Œž“€˜™¡„‰w•‰‘ˆ“ˆ“‡–‘…/*ûGûs  iøËK ùø8û¿"ôW÷ý=ý=só j£tõû÷'ù>ù>ùøGŸšwwû|û&xjûUö÷t÷¹÷=”‘’––—…”’´N,¡B“û‹÷]û]÷‹÷Q÷?÷÷FÊ–«—´¬ Ÿ ÷ú”÷÷ù´ þ”ø”÷ú”´ üø”÷ø´ ÷ýÔ~ ù”~ ù”~ Œ {Ù¢t›qû÷2 øüüzª ÷0 ~—›…ùzøøž§£ ÷÷÷”÷÷àù÷/÷ø”´ ùýý4û4e ûÔ¸÷4ý4üt÷ ý”øtû”û÷”ù”øôŠûô¶ûôqüfúw÷$û$—›„øT: üTqt{stožy÷$û$û÷û÷û÷÷÷÷$÷$ž§¢£t›qüT1üTq›t£ˆ’”‰“œ›’——÷$÷$÷÷û÷û÷û÷÷9 m ÷9 ÷÷÷÷÷÷û÷û$û$Ú øT*øTÅû$û$û÷÷÷   ÞøåùWÖnåæ¡¡Ž¡|`_ƒ]û#àvûŽû¤:ûé[ï÷ÎÛé¸óŽúÃý÷vV÷ïû¹iûûû\û\û÷i÷L ö*÷4ùþ÷4öì÷6þ”ýKùTüvøÔûuÜŽ÷¤ûv#6û]_“š`Žuuu0n1W@óˆé^Î;÷ïé»÷ûøõK ›÷TûT`þ4÷Sû2÷S@°÷Ô÷Fzyr‚rrr”yûb÷cy¤¤©—¢ Ÿj¬§d¾9 ¾d§j¬ Ÿ¢–¨¤¤y÷dûdy•sqýSùUmtvw¬jo²XV``VX²o¬jvwtnrr”y@ûd÷dì ¤•¤¤¤y÷bûcy•rrúýUØnÓTÂûd÷dÁUA©??BnUUû'û&UVlA?>¨CÂT÷dûdUÁÕm×ÚÕ«ÃÂã3STk@< ?¨BÁU÷bûcTÁÔmØ×Ô¨ÁÁ÷'÷&ÁÀªÕ×Þ€ø÷Jû÷,û>³¥³šº¾÷ KQtd_÷O>ûK÷ûjÊ}Œ|Œ}û,D!û/ûGû‹÷]û]÷‹úÔ{ ù÷÷÷÷ãü‹ù­ø#Ëçü”÷ Ëü#ü‹ý­û @À*÷!‚ ÷!Àì÷ @ýŸùiŸª°ø#÷ü#fŸl÷¤üAý\ Œ÷3øT÷3ŒËË÷ÐúTù'5 ç÷ÀKøø"˜”¡‰ ˆ¡~žx•ûË‚€€ˆ†‚ýFüû͇‡‡Œ”ª¬ˆ¬‚òFîûÐÁ6)©-1?pWSRWn?’=”%Ð(÷EUàîméþ–Ÿ·‘‚’„”…÷BÀûB‚…„„…‚Ÿ_X–S-(mU6ûEF(‚%„=¨?ÄVXÃ×påéí©Áà÷ÑÐí”òŽ¬‡¬‚ªŒ÷ÍùFü†”–ˆ–••”÷Ëž•˜žŽ¡ ‚¡y˜û\ù&sqb]NEŸ²NûÏeðÈ㥴—¹ÇÒwdÈ÷G±&NS6ý}dNDwO0]b—£qNñð÷ϲÈџȹ´s¥ÈSe&ûG÷Føù””ŒŽŽ“’‘“““¥¥Ú\}ƒw~vt€÷û:û4+q¥ƒ“…“ƒ“ˆ‰Œ‰Ž‚“÷4ë÷ù”øC÷KýtüÔøôüüÚ÷ÛŒŽ÷E÷øœü, ‹•ß‹•¬ ‚ ü4dYztd÷ÜÔIü4VAlffü,ü,fflAVý4- ¬ø´û´“ úT0 Àêü´ûi´û¿û¿ûéù?û¿û¿øƒûðfflAVû”ü”ùø49ø4øü4¬ùþôþùø4Ì9ø4øûÿ÷÷Š÷ù—÷|÷+ãfàLÉüÙøÙ³dU¢Sû55ûT¢T³dø.ü.…‘“‡“ ÄÄ “‡“…‘ü.ø.|› ¡²¨§±¡¡‚|›øÙüÙ±e¤WT6LL6UV¤±eýœù[»oÌÏ÷!÷÷÷"ÏÌm\»øòüó…‘“‡” Ãà“‡“…‘üñøòÓB)´%ûhû;û=ûh&µ)ÒCùýœMÉàeã÷0÷ ÷ ÷0‹÷÷÷÷÷M øù”ü÷ø4êýÔnü4ûŽ÷ü4- øÔ0 ø4Ÿ²{}™÷­û­˜~œbxþü”ú4” ûTv ÷Ô‡ ÷T÷ ùkÀmÔe±û¬÷¬±eB©Vþ4núÀ- @0 fc úô fc ÷T]ù]ù]cˆ µ ø”iü46÷O-ÀAú€úôµ ü46÷O-ÀAùT| ÷O-ÀA «õž÷ h÷û ÷$ô@ø7Ð_¿H›ê÷ãûáû,õÀ«¬«Š`djXg]¥S´ŽËˆScfzhebŸ¤pR3^¸ËvÊóáÉ÷ù"OûŽÙ÷m¬÷(î;Â.?GdFjàP§œ¨©®¬ yi7ûvoûMyŽyŽy÷þû4»ú€ú×@ûø(!ûûÒ?žœŸš–¡:Š::  (÷ãû´»ùT| û@÷ ¥z™|À@3 càùù@f À ûËù{pkœgœG©R¡[™û"´.¶_¸_¸u¹¼Å¡¼¸²²¸ÈŸ×ÛÒmNÆ­g®G­&™‰ß…—ŽŽ›š™¶†È‚Ú„¿„³„¥A£P›_“—AT’eûAûa6226^%ûO›L«Jšnœpžsøû”Ðo¹s¡xÁZ¦WS]{`lcmcbnXzyY\‚a\^’šcb™hžn£n£pªs²€z¾fà%‰_w‡hY+‰Wƒ~€„‡•ƒ¢‚²€÷ cvÕ͉ÂÞÎ’™ÀÀ˜½¢½©¼ª¯¦£¢¬¬¢­š°§Ð˜ÒÓ¬‰ª†§÷h÷¸ùv÷9ö »!݉¼}›t–{‘Dûûá$<–Tš;§J³Y³YÇbÚllÚê|÷ìà–¡ÔÔ¡Ç©¼°»±±´¥·œ©™´•¾•¾•ñ†÷+À}øƒ‹Š¤‰Ÿ˜ž‘˜””¦º’¨Œ§¦’—•””‰œ‡¤yL„J…GŽûa•7‰5™ˆï¨Œ¥¡t™|’mŽ`P šûv˜†ûG#„?}Zhzdqcwuvltlsj{h€xPK‚GQPš«Ob¡kªt²lÁ{·Ü}÷¬Š÷yšŠž£Ù·”•œ˜¥“³¶´Ž‘³”‰ËŒ™Š|nŠa`ŠZ‰U‰‰TSŠR{S-ŽdeŒh}~‹Š~Ž3—ˆš‹ŠÐúDú@² À4  ‹÷øÒø”÷4X øoü”ù”y}}yûÔy}™÷T™™÷Ô™}yûTø”üoü”ù”oø( ÷÷ÔŠúÀz@÷4 ¦e¦úO ö÷¹÷¹ö ÷.œ…›—ûZ÷Z—{‘zz{…úúúú…{zz‘{—÷ZûZ—›…÷D‘————‘›œú¹÷RÈ÷ûO÷XOûXûXO÷XOÇûXÇ÷X÷XÇùrü6Èývù2È ÷÷ßø÷÷”÷¸ù÷õüø”©‘šŽŽ÷W÷WŽŽš‘÷2xû”úü”õ÷”úÔU þ”1ûTû4g[wrr¸ûZûZTT•·¾p_ûC‚i‹v9U:j\ùi% úT&‹÷¨øé÷kû=÷=÷T÷”°ùÑ÷Òá6¿N·€‹#û-jûû÷^òêò²÷AøµéT÷3û6dC@,Áû*÷ݶÊ×õ÷•8ÄQ±_3û9û*w:8÷XkûEûKû[=û.û û=¼÷)Ò¸ÇÆ°Õ¹ì–á‘t¨z¦±žœ“‰}|Š}û(å÷Ð÷J÷Cð÷9÷÷_ü”û4K÷4°ûÐË÷÷Ë÷$K÷”øT&þT°" úTÐ÷3÷÷÷3 «÷N;÷N÷h÷[¾÷NE÷"÷ô¬ùsùxt÷3.Ú÷÷ãü6ûû-f.û8CWï o‚rkO§b®÷4¬.QE-û]˜]£dû Þ÷Md÷*÷S÷kÉ÷Cò©÷; tû&ë÷G ¯¸·­Å§Ã÷Hâûû(PSb_ghPsY¬ýýû6ûgÑ÷W÷b÷†¿÷7››‹‰›ìE÷9ûû@û7Mû(ù¾ú÷m"ûmûhû÷hûoô÷o÷i÷÷)÷B ÒÄ÷÷”÷ù”øë÷÷´‰{r|€sv>Û÷(÷÷üT÷+÷÷”÷Jû÷~ûfûfûû~ûJûJ÷û~÷f÷f÷÷~÷Jø”û”„û€{ ø”L ‚ ÷ ü”÷ùÔU ù1û€+NÜùÔ[ Ü÷ÔXþÿËøÔùúÔ¡ üTüT„{zª øTüT÷#þÿ‹øÔøÔùß üTøT‹þ’øTøT‚ ‹÷ù÷ù÷à÷4Š úôùû€ù”«” üô‚ ùþô÷ÀŠúÀ€ û@w@÷4 ÜøT[ øXÜøT[ ÜùÔX ùÎmjingrû;ûû<ûû7û M7#?ûŠŠû#×É7û7÷ û<÷û:÷f¤i¨m¬ý®÷ úÔãBÓ4ú@ V7)0ðûÒ[÷/û÷1û÷/û^Ì÷/ÜŒŒÜ÷ç¸Ì÷/÷÷1÷÷0÷ãÈÞð÷ž÷Þùî÷Ý÷ñú#ûÞþs÷Þ ÀìŠEÕûûAA*,Ò?÷‹÷Ó×ꊎým÷Äû6÷"ûmûF=(G`÷$ûÝ‹.‡þ‹÷Ýø½©Ž¨“¡Æ£ÁÈæ÷ »0ûü¦÷ÝŽ÷”€÷ø;ûí÷íü;ûYûS<ûû!û÷m û÷i  ³Ãëé ûÿ÷ÿ¢sj™iel{ppû”÷”÷÷””—˜˜†—‚”m©¡o¹¥¢•ž¯­»¯Á¤¤yü,ø,yr•rUg[giyxtq]§u©m”‚~~†‚‚ûðûð‚‚†~~”‚©mu§]qtyxgi[gUr•ryø,ü,y¤¤Á¯»¯­ž•¢¥¹o¡m©‚”—†˜˜—””÷÷÷0 pp{lei™j£t÷ÿüt¢¯¢£ö÷Ý Ò ÷Q@ ÷TøT@ ø@üuÌ^­9v:p%"M$¦%¦Mô¦ò¡ÜÐÂÚ‘ðø”­® ­‚‹­‚ŸhƒiøÃûñ@ ýù@ øTûT@ ÷ÔüTø‚ü&ø&ü‚ü‚ü&ü&ü‚û@¼û;çû$y—Ÿ€¡z¡Ÿ–—ç÷%¼÷:÷@Ò ú‚ ø4÷ôû~ûªûªûôû~ü4`_Ž`R‘`e9C/R&a¥¹¤ÂžÒ¦ë4½ûAí'÷"÷)÷ª÷ô÷~ø4úü”÷öü%÷²üƒ‹üƒü%û²ûö÷Jñu{ŸŒ‹µ÷$ ‚ ÷ùT‚ ÷Ì÷œûDûdûdûœûDûÌWX”YV•_lw}v~v®ß*ÃûÕAõ÷÷d÷œ÷D÷Ì÷÷ … ÷¯ûÏ÷yüùÊûo÷6éó÷$÷7Yýÿ‹úú ú^”‚‘~‡‡ŠŠ‡ü )÷?øcŽ‘‘‘¢wžr‹ûÜvy~x†û]ý͈}|—„“—‡–‹Œø*ðûYý¼†v˜v¡„ŠŠ›•š“ø°…’šˆœ€— ÷T÷ø”÷à÷´I+÷Tëü”÷Të0 ÷ÔÀ`¶VûÔ ëûTü”·ûT+÷7ûÔ÷÷Ôê+÷Tø”ûT+V``VûÔ÷÷Ôê+÷Tø”ûT+V``VûÔ÷ ø÷@ úùX’vvuuv‡„vüØHNNHHNÈÎG 'û÷ û ÷÷÷ ÷ ÷ù”ø½Ž‹Šø1ü÷jüü üûjü/Š‰‹‰ˆq ”’‘’ÁÅÁ±ÞêÝ÷˜™÷ ÜÆêêÜ÷™˜÷ ÝÆêÞÁeUÅ…’’‡”3 ý”ùkG e ) Œ¡Œ  ¡Š  $ ‹÷”øÒù”û‚ øü4- ø4ýý ” ýTv ˇ ùTœš|zK÷”ý4÷¿÷¿û¿÷iûÀmÔe±ü,ø,€–”~“÷ÜêþÔnúÀ- ø´û4“ úT0 ý‹÷÷#÷÷x÷:Ë÷4÷˜èùtúT÷û¼.÷8q ÀöpFq A÷4KqHaZxuuvwtD6O'ûûx÷OïDàw¢u x¡a¼qÎË÷\÷_÷ ÷I˜÷I÷_û û\÷÷¤û—÷Dû‘û‘û—ûDû¤$­2Ð?èÐ?æ “ nzykjs”t›z{z‚tsjœm§yƒ}†z{˜J¾lÅQ¥ÅeÊÊűťžªÌ›†œƒ™§œ©¬£‚¢{œ›œ”¢£¬y«nœ“öæöÐ×Ð×­äò ÷ô|™zú ÷O |™÷ ƒ‚ƒŽƒ‘…÷ÓûÔ…’“‡”™šœ÷T`3 ùtpú -`ûTzš| ÞŽøô‚‡ƒ…„ûóûó……‚ˆƒ‚ƒŽ‘…ûô÷ô…‘ˆ”“œ™š÷t÷ôA÷Tœš|zûô÷t? ùût] ÞŽù4z}|yûtûô„ ûTv ÷ôûtQ ”“‘’÷ó÷ó‘‘”Ž“”“ˆ…‘÷ôûô‘…Ž‚ƒùû´] ûÿ‹÷I÷÷”ût÷T÷4÷Ìø÷TG '5 D Ôú”N÷[c÷Îû‚¿¨G„=BÚ^¼60Ñ ÷ EQQEÑ ÷ˬˆ¬u¦ìI7#e  #±Í7upˆjjû_×p¿B:Ì!55!!5áõܾÔئ÷_´‘´›±û‚WcûÎû[û7ö+÷4ùþ÷4öë÷7ûÔúvûÿß÷”÷÷÷‹÷‹÷èôŽùÔ¦’ 7ÀEÖpü÷÷÷m¦÷;÷4÷Uø”G …†ŠŠ†²ua¦[£ ÄRÒ¢¡’–žü&÷ø&€ž¡„¢…ÒRÄD[apdu茆†Œ…'ü”ûU÷;û4÷mpûûh÷]û@¶ ÷@÷høôÖ¦ÀÑß ‹÷´÷t÷÷t÷´ù‚ ÷ø”´ ýôKô Ëúô÷/û¶ûûú”øú´÷KûË÷N  ùÄ÷´û™÷qû÷ç÷ä÷uû"÷ûn¥–Ž˜˜À`¶VV``V~Ž~€ûnqû"ûûuûäûûçû™ûq´øT÷ ÷øT÷÷)Ÿ ÷TŸ ú!55!KøËõá5!ù€ý”÷ Ž÷ Ëù”÷hû@÷@ûhû€1ýt÷*ùT÷- «Ë{ûÿ‹÷1 ùÀG e ÷-n¨®ø4÷H÷-n¨®ø4÷Hý:¿B×pýŸ÷" ùŸצ¿ÔÜù”ùU û”÷5 ûDý´P÷tü”´÷÷‹÷ù”÷ ø4þ”û4K2 ùT ýT;ùtûtÂû”Âûÿ‹÷¦ ø÷t#÷Ô"÷”Ë> ù”üTœ|šzKz||zKzš|œËœššœû”÷Ô9 ù”üTœ|šzKz||zKzš|œËœššœû”÷Ôœ|šzKz||zKzš|œËœššœû”÷Ô) Aû”úàå c ‚ ú÷@U Ëûÿ‹÷÷÷õ ÷÷ª€ø÷t#÷Ô"÷”Ë) "3 û”ý´å ‚ ÷”k- øT0 €«÷”û€ü ” Kv ëû+„ Kv ÷Ô‡ Ëœš|z+÷ë‡ *Ë÷ ¢€ø”«U ûÔ÷´UIüTnû´÷û+ŽN÷)÷÷ßû÷N‹÷”šù÷@ üø”©Œ‘–Ž÷W÷Wl–‘Œ÷2û”úü”@ ÷ù4˜ ×¥÷”ø´š: û€1ûÔû4hZwrrlûZûZrrwZh÷-¨n®÷û!÷û÷"÷"÷} ø÷ ÷"÷} ÷TN ‹÷”ë÷4÷B ‹÷4ë÷”ÌŽø4˜ ´×Ì¥´ýùt÷ø”´ Ìþkô « ÷/û4¶û4ûúÔ÷ôú´÷kû«÷N ÷)‹€€øÔ‹‹«û´Ëûô«ûtËKû¹÷ôÐ÷J +û4KkËü4€û4ûT÷t+kkûT«k÷ƒûTs´ ÷Tsƒûkk¥«kë÷T÷t÷4ü4KkË÷4ë÷J F÷¹÷ôË÷tË÷ô«÷´Ë‹«‹ ÷÷”ùù|g‹>DRÄÒ‹‹÷÷÷”üú”üTû÷Tù´Ë«k÷TþTkûütkûËKûÔûh÷@û@÷h–õ‹–ûûTûT‚ ƒ Ž÷TR ÷Ôü”ûÔR úRûÔø”÷ÔRþ÷”ú4 ƒ Ž÷ ûÔûÔR ÷ÔûÔØ÷Ô­ RûÔ÷Ô÷ ø´ ý¸úZù÷4ˆüøøøb “‡”O øˆüøøøb “‡”O ý˜úZøçøÔ_ø_÷ ÷t<ø<÷ ù4< ø< þÿ¸øÚùút”‡“O ˆüøøøb þÿ˜øÚøçøÔYY……‡‚ƒƒ‚‘…øü÷P……‡‚ƒ‚ƒ‘…½Yo ÷ ÷ô<÷ ù´< ÷. Ÿ ÷ø´” ùÀv ùÔ÷Lœš|zýÔ÷ùÔ÷ þÔ3ÓCãø´4KGf÷6 ø”*®KÓàø´÷4 ÷)÷”÷‚ ÷ø4÷”úÔ”ùTŠþÔ€ ýTwkùôAúÔœš|zýT„ þÔv `ûtùÀû4+VÓ`ã@ãÓ¶ÀëÀþ+ñ ‚„„‚üÿ‹÷ú÷ù÷K ø÷4” ýÔv úT‡ ùÔœš|z÷8 ÷úTãCÓ3ýÔzùÔ÷4 þ‹ëøÔëød÷_gg__g¯··¯¯··¯g_÷d÷4” ü”v ùT‡ ø”œš|zýTûTùä‚„„‚ñ ÷´›ëü”·þ”´ø”÷ ù” , ‹÷5ù”øÔs úøs  ø”÷5ù”ÀsúùTsû_ù4÷”÷d÷tûT÷4›÷T ø„÷TÛJË<;KK;;ËKÛ€ÚÌËÛøDûTz ÷.@…üôùãCÓ33ÓCãôú¤üTÉY½MMYYMÍýÔúì<Ú**<<**Ú<ììÚÚìød÷Tµ ø´ýÀ`¶VV``V-  9ûdøTÀ fù! *÷jø4÷€÷aõ÷íûü,ÅûÜût÷”¡ ü”ü”„{zª ø”ü”‹ ÷”÷tøC÷¯8üqb‰bˆbŠ{‡y{x—{Ÿ™’’•’š –«–¢Ä÷Ñ÷K÷  ‹÷t÷4÷”ø÷”÷4÷tù÷Ôã ùã ÷4ûÆû¬\ûˆû<ûˆû¬º÷Æ÷-è÷÷7Í˂̃¿¿ˆÀÀ¿Ž“¿”ÍÊ—Í÷7èûû-÷t÷D÷&c÷+÷Á”ÄÄÖzÖiÏû0&H.û ¡0,•-##€s&éû &Ðû2iGz@@R”QT+ûcûû&û–û ¾&û¢÷øt÷œ÷˜÷ÿ¥÷Ÿ÷½ñ–÷ ÷ ÷B ù”÷c ÷tV``V÷OV`¶ÀúTãùTÀ¶`VýT÷ùT÷ý4y ûð&÷À÷N ÷)÷B ù÷÷‰÷õøñ|‚~‚€ûºûÿaiEjVþÔul’§š”˜”—÷º÷ÿ´­Ñ¬ÀúÔ¡ª„oû‹÷70 XDQû”ûÏùéãøÔÀ¶`Vû4ø‰û7£†¢ ËmGªGûT÷4Þ ü´y ûð&÷úÔå÷¿ÑÄ÷»÷ÿ¦­žµ·  ‹Ä ÷nøa–­x®j–i–gx€i j(Cûû(Óöj€­gžj€i€xh–iû5½÷'û÷=÷=÷'÷÷5½ü‚øG+ ‹Ä ÷n÷Ç÷5Yû'÷û=û=û'ûû5Y€ižh­€¬€¯ž–­ö¬îÓ÷÷îC ¬–i¯x­–¬–ž®€­ü‚øá+ ‹Ä ÷‚ øTU ý÷ ù*ü”øT+ ÷)‹÷TÀ÷”ùÔøTDûTûTÀ\ ÷T¥A Œ÷TÝ÷4 ûT÷T? ´ øÔK@ ÷£ RÄÒ…ÒÄRD÷”û÷¯ûy÷yû¯þÊû¯÷yûy÷¯÷÷ ¼Úå÷p<å÷ Z÷÷¯÷y÷y÷¯÷. ÷÷û÷”‹÷õ ÷÷÷÷Õpøøœ:÷÷ôœût‚„„‚+‚’„”÷t¢ û÷ôœ:ú”ü4œ ýô‚„„‚+‚’„”ùô¢ ý÷ôœ:û÷ôœ¿H:û÷ôœ¿¿:ü”øôœ:÷”뜠:÷”ëœ`+‚„„‚û„û‚„„‚+‚’„”÷t¢ ÷ü$ù€ú÷9÷ÒRÄDù€}þ÷ ÷9…÷ Ÿ øjMû Pûdi“™oo™À '¾û.àûûû±÷X…¤¥‰¦÷= @ûQúÀ÷þz ƒ €@÷  » ˜søÝø½úËü]LþTf úTÓ÷)¸&øý÷ç üøøøç Y½÷ üfüfÕøfüfó½½øãú¿œzMœ{y†zü úõ†z•yœ†Éz›†•œø  ù%ý ‹÷tJ÷jùøZü!ø!· ø!ø"И‚ «÷$y÷fû+÷/û÷ûYÔû¨ž÷š˜÷÷kz÷Xà,ðû­ûHnû¥Š|”}š†ŠŽŽ‹Ž—–‘–’˜÷1÷Æ÷dÕ ¢ø×Z\—IÇû÷ûÒ÷Á÷”ÛŽ÷ýĬ²ÉÒ ›÷T÷äËøTË÷ä÷TpøK÷  ÷=bà ûtø´LûÔ)M ÷Ô?ðûØmÓUÂûä÷äzœx˜w—yûƒ÷¦û§y•sq÷FggKŒg¯û¥÷¦ûƒy—w˜xœzp÷âûãTÁÔmØØÓ¨ÁÁ÷'÷&ÂÁ©ÓØüýùh€Ÿ~žzœûâ÷ãÂUB©>>CnUUû'û&TUmC>>©CÁT÷äûäœzž~Ÿp÷„û¦÷¦ì £•¥¥£y÷¥û¦÷ƒù 7LûÔ)M ÷Ô?ü´ø´à ø+÷=  þÿ‹ùù÷, KøÔÈ 5 ËüK* ø”*ûU û”1ûT+÷”NþÿíøPø”÷´U û”1ût+÷”*©÷/®Œo¨hûÔhonhŒ§ý”hŒ©n®÷”®©¨®Œ§ù”S÷3û÷@¤ ð€û<÷‰ùùâû;û|™÷#÷àŸ÷„÷&àû%6Nkjí­±ÀºhW@÷F x}Žpø–U÷3û÷@€¤ @ðû<÷‰ùYû;û|™÷$÷àŸ÷ƒ÷&àû%6Nlií¬²ÀºhW÷F yŒ|pø–Þú÷ý”÷äøù”ù9ùI¹v]¨Yý”fh{osþþ”jeƒVŸ]] ¹n½ù”°®›§£úú”¬±“Àw¹ øu÷KŸ øJôQìûûT*Fhl¡£tnª…·µݖݘÜ•’ÆŽ€…ûûqûDA§Ý÷÷«÷÷5Æ%!*QûûìTFhulstnl_…a99–˜:P’‡Žþ”ŠŽ‹Š˜‰ˆž‰ˆ~Ü݀ݵ·‘¨ª£¢¡ª®Ð*Â÷÷ìÅôòáPûûûkû9ÕoÒóóŸ•òŒ––‹–ŒØkÖÙÕ©½Û÷«û÷÷Æáòüÿ‹Òà‚ ùÔG l “÷÷]÷‹÷÷H´ û¼÷tûˆ÷´k£û”ø”÷D÷9 ûD÷5 ûDü”ûD÷$û$÷D÷D÷$÷$÷Dûÿ÷Òà÷£øク…±²÷÷H´ ?šC¦Iððúîøîç 9Ý÷ û.û.ÕÝ9˜~Ÿ‹˜˜÷’÷’Ñ`Ûnà‚£÷÷H´ “AEž«Nëë­°„±÷D÷$÷$÷D÷÷ý÷ýü÷÷^û äû÷5 ûDü”ùùüúÔ÷TúÔøÔû%ûû 7;L9\XpqøTý÷Tù”U û€1ý”ü9øáûž¤€“‡”‰”””“ $¤–øá÷žø9 ÷:ø÷÷÷÷÷÷ûú”þ”þ”ÀV ÷´B û´ù”V ÷´™™Ë™}ykûÿ÷´ëë÷4ûëÀø”@K ú«•‡”ƒ‘…„„‰‰‹ŠˆüT+}ˆ€~|û”Ÿ ¢ãCÓ3k•nšr û]J'ûV†{k˜eª{†”•‰•¢¢˜¡–Œ÷÷o÷h«ûûc-ûû#ý´+ø”*ù´÷/û÷û&©ñ÷”|–~™ˆøT+ŠŽ‹’’‘À“‘”• «` úÔÀ÷t÷´{™yûðûS;ûûŽRQPIODüwŠ……‚ûtü„{•€ËK…‘”ˆ“ŽŽ‹ŒŽ÷¨à÷­û­6û¨ˆ€Ž“‚ËK¢‘ŒŽø÷t”‘‘•Œ•ŸøÒÇÍÆÅÄ÷÷‚ç÷q÷à ‹ÛûÚ÷Ú€Ñù§÷n÷;íí<ûÃûû÷-ûÛ÷( ÷²÷( ÷=¯©vœvkƒhûFýÔ÷â@÷8ùfú!÷!éüZøZ· øZøZê ñ%Ô ûÇûÇ÷ÇûÇÔ ø¡ø!!fùa÷!é%ñ· ÷Ç÷ÇûÇ÷Ç· ññê øZüZÔ ø¸!‹÷Žú ÷Žø!éûÇ÷ÇûÇûÇé%ñ· øZøZê øZüZÔ ÷¡÷!!‹÷Žú ÷ŽùÁ÷éüZøZ· ññê ÷ÇûÇ÷Ç÷Çê ñ%Ô ÷¡X!Œ úþú?ý6šûIùYü´ûû(Š‡ûþïu÷ª÷C˜û ÷XV÷YÀ¡÷xüø\øªúû†÷º÷úbøÒû6øÖ÷6÷ž —è÷§÷/ Pû½¸eûSûGQû½¸Gûçüzû5ü:÷5¨÷'û½DûøùNûŸù¸÷Ÿ÷ž5 ‹÷(ø€÷TK÷”K÷Tø€÷( úTK ùÔþ4Lûô~ƒ††Ž~”ï'1û ûA3ûZpù÷T/ ÎûT÷7×·¿Ýê÷ „,¿9×_û7XûT1´  .÷TýûZ¦ûAã1÷ ïŽ˜†——†“~ûôP)ûô~“—†ŠŠ÷èèûQ÷1÷®û ÷É÷É÷®÷ ÷Q÷1è.…’“÷¨—“—˜üÿ÷÷Tø”÷Tú´ù”ýt÷ÔÇ .ËD ÷ ûÔk¡øÔê‹÷÷÷ù”÷÷÷ú”ùK÷ûhû@û@ûhš ÷÷¯ûy÷yû¯Ê÷ ÷ûõû³É ÷³÷õ÷õ÷³÷³÷õ÷÷$Œ øù´Hø”÷THø”÷THú•‹øø÷´HùTHùTH‹÷”ús÷µø”÷”@ ÷ó-Œ‚‡‚…÷& ˜œŠ|÷aû9÷9ûašzŒ~÷' ‘””Š÷Êz÷ŠûŠœûÊøŠŒ‚ˆƒ„÷& ™œŠ|ø3ûæ÷æü3šzŒ}÷' ’’Ž•Šøœzø9ü9œüœ÷µúS fj øýËü´ûÔ…€ˆ€€€Žw— ¢ù¢— Ÿ—Ÿ–¤‹žø´ûÔŸ€—vttvw€ Á÷´û´•ûµ÷µ@ú”úÐüÐüÐ÷ÐûÐøÐøÐü£ý+æ ûþ÷þ· øþøþ££µ‹£s÷þûþÔ ÷£ž¼¼‹ÝZ½û÷@@û‹@Ö@Ö‹÷ÖÖ€û÷Y½9‹ZY þþYY‹9½Z÷ûÖÖ÷‹Ö@Ö@‹û@@÷û¼ZÝ‹½¼úú ƒ Ž÷ þ÷ú÷ ø´ ÷<‚ ùtLýÔf ùÔ?÷üQùÔãÓC3ýÔ÷ùÔ&ýÔ@ýø”÷”úŽú9–¡‡¦{žûÔøs¨Y‹snûÔü{xˆp•ut–¡}¤÷TýûÔ‚‡„…û4ûTƒŠ~€—„—ùT?ùô÷T¤¡™¢–ýø”÷”«÷/ƒ€††€Œ}“‚÷4ûT„’”‡”÷ÔýûTru|u€tŽp›x÷Ôü£n½‹£¨÷Ôø›ž¦€¢¡€ušrûTùó}šy‹÷núà÷nùA÷éûú÷ú· ññê ÷gûgøgøgê ñ%Ô ÷÷¡ ‹÷”÷TÃù”÷œø(ø@WWSë+ÿ¿÷šø²„“}‰‚‚û·û·‚‚‰}“„’ƒ™””÷·÷·””™ƒ’û¦ýFû´÷´ø´ø´÷´û´ËËû´÷´çç°°É‹°f÷,û,°f‹Mff÷¸÷¸ ‹÷®úz÷”Žøôq{ttˆƒ‚‰ƒz{‘˜÷9 üªüªé%ñ· øªøª÷9 x†§•£¢•¢›¥øtn üt÷”ø” ‹÷”úô÷4úøG{„zƒ‚Ž„s•{¢¥÷4ûO!mFNB9xû*©û…}ƒ}~†‰‡†Š‡‚‚“„…“û5÷W÷]÷‹Í÷ÝøÒ÷4¥›¢£•¢•§†x÷ôûôÔ ÷G÷á ‹÷t÷´÷÷”÷÷´÷tùøT÷”÷”û÷øcü”û”ü²ø”÷”÷´÷## ƒ yùñ¡€u˜sýsu~u€€vq™x÷ÔüTz—ž  ž•œ—÷ÔøT™ž¥€ ÷ýQ=ƒ yø7– ‰¥}žûÔøTœx•vvxzûÔüT}x‰q–vu–¡~£ù£¡˜¡–÷û—=ƒ úÔù žz—üT÷Ôx™qv€u€~usýs˜u¡€ €¥ž™øT÷Ôœ—•ž ÷TütDþT; úT5úT™}yTýî÷úd÷y‰“†“ƒƒŒƒˆŠDs4û>û$í÷0Køš˜–šŽ£÷”‰•…“’…‚ü_‰²Š­Ž«ø|›˜–šŽ£÷”ˆ•…’“…‚üh÷)Î÷!æ÷<ÒÏzŒœ†œ•œ¶÷3“Š”‡’†’„‘ƒŒ‡5¡#û¿û”ûNû¬2);û2 Ήh‹eŒkI÷ ûz™|êûºß÷ûP÷Ì÷ è«Œš”›‡›ý÷÷ø2÷vúø#Lû6À)ûIü2ø÷Åè÷• ûÅ÷kñ×Ï÷ðáGŠŒ‘†”ˆ“Œ”Œ’‘’ò÷•˜Šž–…û÷ û\û’ûLû9ûxûs,÷û2 êü*÷ û*2 úPÓýÏ÷’î÷[ô÷‘úf÷ó÷…ûdÜûLÒû"ÂûºõæãÊ÷÷*÷ ŠŒ“…”ˆ••Œ“‘”Ü÷&’—‰š–‡û÷û_¢÷D• ûz|}yûHûecû$û,ûLû÷t1÷HD÷U÷ \+û!W)ûEû ÷Œ‰…’‚Ž‚Š‚Š‚‡†„$û‚Œz•…÷û ÷~jûCyš}œ÷?÷C÷h®÷&÷5÷`ýý‹úúú¾Lû?€Âv»k´÷}?ñ• ýÔ;ûz™|÷%÷ åe@±ü1;%2 ø?ûnûPûDû÷ ûƒŽƒ‘…÷Qû]÷(ûE÷5ûUƒ‘”‡•÷W˜–’–‘–‰™ƒ”û+÷Mû3÷Tû)÷3÷w¦÷'÷ª÷T÷<Óý|ø#÷€ø™÷Þ÷¶èò• û¶à÷¶?óœ}šyûk÷Íøו‹—…”•…‘€ûS„†ûSü8x_uaz`{±{³sºûkø=–…€’ûV€€……†‹÷ÕüÖûj÷ #2 ÷´6û´;$2 ÷´ûÞ= ÷@ü÷”÷{øÀ÷ú§ú_û,1û!ûÔøT‹÷Ô÷!ê1û÷÷•ûN÷HûŸ‹ü¯÷ý ût÷û)2 ÷tû ût;û2 ÷tûT= ÷;?÷Tøè÷• ü÷ ÷è÷Ÿ÷N÷H÷•cø–÷鉊ˆ‰Š‹Š@÷À÷3®÷ûuk÷÷¸÷1û­÷Ñ®û÷Êü@‰Š‰‰Š‹ŠŽ:÷¿÷6¬÷ûzi÷÷½ø û4LûG­÷÷% ûæ÷쎔‰–…“’…û|~}ˆ.ûüü)÷ü™‡•|û}~}‡*ûüûû1÷ü™ˆ~•|û†„……ƒ‰Žäûìûf ÷"¬ûûCf ÷d÷4üü}Ž˜™÷3š—•™÷;øü÷e÷:üü}˜™÷3™˜•™÷8øü÷iÓü÷”÷žû1÷.÷÷.`úz÷Jû1ÈûZœ÷û.û‰cbŠŠb÷‹û.ûŠjj‹l‹ûhŒ û8÷‰‰‹ÊŸgk‘û³‘‹Š‘†…‹†ü&wˆl`‹‰ûlûK`÷\°¯Š¯û“÷.÷Šµ´‹²û÷.÷“÷–™÷HÌ¢÷‡÷W/âû&® ã¸ÃÛ~÷ûküµûSûÚ¡#÷æó÷Ú¨ûZDøpûAû¤Ÿ4÷Çâ÷¤¦ûIfú”ú”øl‚™‚—•ü,ø,•”}”ûüŒø´ý´÷7ùÀ- @0 ú´ü´V`¶Àf¼ú¸ü,ø,•”}”üløl‚™‚—•üpû8V`¶Àø´ý´÷7ùÀ- @0 ú´üýt‡÷T‡÷T‡Î úüÁ þœ%Ðè ùØû ÷< ‰‚}‰––å÷|¾äúþö ¨äÎ óÁ ƒ%Ðè ú1ûŠö ä2é÷< Š‚}ˆŽ–•å¨÷|¾ ÷ø÷Ôùtë%è ú´ûLýÔI ùÔ÷ ýI ù÷ üTI øT÷ û”I ÷”Ó ÷ø÷ÔÀkLû”I ÷”?üt÷Ô%è ù4øLüTI øT?÷TùTLýI ù?÷TùTLýÔI ùÔÓö÷sîû%è ù‚Ðjmùa ößîû%è ùdû‚ ©¥j ‹÷÷÷4÷”÷Tgnohgo§¯®§¨¯¬ ÷4Ü û´1ý+÷´* ùó3ã#û©“«••–¡¦¿¨ÅÝØ‹÷Gûtž`aM€PQ€Oddlli`g]_Q+û fˆjˆoojýh©o­Š®ŠÇvÊuf÷÷\÷#œ×™‹ãŒÍ¥¶¾±¸œÈ…Ö¤£ž¬•°–³‹³€°©³šº‰½™‡©€«­² ÄÀ ÷÷÷”úT¯n§hgoogh§n¯D ÷4ü”e û´¸ùD ÷´n ýúý÷)–«©™½|ºm³–°‹³€³°x¬r£‘ÖzÈe¸`¾I¥3Œ‡}‹y?zû#û\fûLuOvhŠiŠmohýj§o¬ˆ°ˆëû ·Q¯]­`ªl²d–O—Q–P—M¶a|÷t‹÷GØÝmÅq¿€¡•ƒ«÷©óâãóŒÀvÅi±‹÷n÷4ÕåÍ^æ—ÎËΆ—̀ÆÍÍÎÝ÷nêXú+÷}j{x€€–€÷t––––ž•zjû1‘H÷L÷­­–œ¡¡–ziiý÷žû|EÙü;Õø;Û÷]SHû¬v|~}‚†•ŠŠ‹”š÷¢Iû¶qz€x‘š‚ ¤¤š©¥cÎ÷÷”®‰£†š§ƒy™pst}qv÷5Hüίp¡¢}¢¦™§“š¤¬÷œGqŠ|‡z‡‚{t€œ­Ì÷ײ„§}ž¤yp˜jip~rx}x…odûd’n™yrž¦~®­§˜¦“—˜šŒ’Œ™¡üWùÕ­€vuyiû0i•z¡ –œ­ø©üÁj°6‹0w7~Q[`R„|ûû‹ûûû‹šûR’[¶~Åwß‹æà‹áŒæžÞ˜Æ»¶Å‘š÷÷‹÷÷÷‹|÷Ä…»`™Pž8‹05‹ý‡ùû]A÷]„¯|¿sÑ|¹z¹|¹ÙÀûW¾÷WÖ÷[ü d„m}yrxq~jiq˜¤y}ž„¨²÷²’¨™ž¤¥˜­¬¥~rž™x’ndû÷Iû ³mpr|rv|”„‡—‰œ¥÷¹Îû¤{‹ƒŒ‰€Œ‘†”˜™• š÷¯ÎüøH÷Ä ¦÷lï÷ DïÇÚzå›Ùƒæ‘ß{æ™Ñ†æŽãæ÷Ô¨ú_÷¸·~¢q||„||ûÁ|šš„š¥˜¡¸÷æ÷f¸|¢mm|t^]åþZ÷œüÍ'ÕXøÍ"é÷Ì-÷IüÍÁbgiwknv—¤ƒ†šˆ¢®øäüv‹€Œˆ}’„—ž™§Ÿøäü‚÷è÷(]‰j„vg€rxhkl°m[2ù+ä*ûm¯¨ª¬®¤xf–’wj]ûY÷æ•n‹w‰‚‰wƒy€{hsfy\\hœ­qx£²À÷AÀ”±ž¤­¥®œ¹¸®zi¥r”eV$ûG4]štª¡˜—£ŒŒŸ¯æ~üôú%]~smn}£¹÷f¹™¢¨©˜t]ûfùcýƒ÷‹÷q÷yÚJÅ>”ŸûLûN‹ûMûMûN‹wûK=‚KQx<rûŠûû‹û‹û¥û<ÌQ؃v÷L÷N‹÷M÷M÷N‹ ÷LØ“ËÅžÚ¤÷Œ÷÷þzüGû›D÷›! M¡L¡M«.ŸE”Zû£ï÷£÷ ø#÷ ûáÀ‚²x¤­rhœ]^hzirxr‚dVûCV”džqi¤®z¸¹®œ­¤ž¤”³À÷ã÷å0ünwx}y„“™‰Š‹— ø0ügŽs|r” ¨¬­Ÿµ¯T æŒ øéùù‹ŠŒû7÷± y£gûƒ}†…„Œ}’~÷5û«ŠŒ‹‹Šû‘üT„~Œ~‘‘–„™÷ƒ®œ£¡˜÷‹øK•œ‹ùºù•…€}û…g|ut~ü–þ$zm‹‹‹Š÷çýv–žs¯÷ƒ™–•’‘•‹™„˜ûäøûŠ‹ŒŒø¤ú:’˜‹™„•‹÷súÖ÷sùAù—‹„~ûTûçz‚}xpûM€ƒ“††“Š•‘•÷X÷‹‹û÷l†•Š–“’”—÷L§™y{•÷ûq‹Š‹ùø…ƒ‹†ü-ýg‹‹Š‹÷˜üp‘‹†ƒƒ†‚‡€ûLn}ž›‚ûšøt‹Œ‹‹˜¢ø"ùV•—œ¦÷O–“‡ƒ÷wû( cŽùu€vx€ü”ûÔ„ˆ€Žw–~¡¢ù¢˜¡Ÿ–Ÿ–¤‹Ÿ~ø”ûÔž€–vuø”÷#‹÷,l÷uí=Ó-–¤ûrûu‹ûtûtûu‹rûr-€>Cu)kû‹û,û#û#‹û,ªû¡)ÙCé€r÷r÷u‹÷t÷t÷u‹¤÷ré–ÙÓ í«÷‹÷,÷# ËŸ ø&ùÑûæû£ø~ûÓ÷ê÷±ø€ûŽû'+ûë÷°ŠŠŠŒ‰ûêû°û'ëûø}û¹ŠŒŒŒŠŒø~÷¹ýÖäü~ûÓ÷æû¢ø‚÷Äø‚ûÄü‚ûÅ÷ëû±ø}÷Óü}ùðûëû±ø‚ûÄ÷æ÷¢ûÿ‹÷ ú4÷ ú4÷ýWŠû+ùWŒ÷…ø…û üþþ4øþû ýtŒ‹‹Š®lŒ‹Œ‹®þ4øù}û*ùUJ˜÷*ýødû&ù?ûK²÷&üœø¨>ûøõûüØ÷ûùGû5ø#üÜ÷àÂùpû)q÷ ýM÷)¥‹÷?÷ ÷=øý÷=÷÷BR÷ippiþÁip¦­ù÷!~b„^^û”÷jûc÷›÷œ÷j÷c÷”¸„¸~´÷‹ýû°ø©û9ûûû?û>û÷÷9÷9÷÷÷>÷?÷ûû9÷°÷üelleûBelª±÷9±ªª±‹÷B±ªleû9÷B÷d÷2äûûŠ‹û22ûûŠûä2÷v÷ää÷‹÷¦ø<÷ ø<÷¦àT üºý”ÏøÈÏfù”ú&û]ûÆø&÷8ût#÷4üž#û4-ø_ùGø_ýG÷É÷”!ûÿøå÷rø £ùÃù9Ù*ÁHb=g‹ûÛhÒ`ñÍ€ß÷ šû,û û€û€ûï†÷‡èÃãÞ°÷Æ÷5-û"÷ƒø²MM/ƒ8û(xû,Œû(ž9•0”KDzÃÑ–É•÷O¬÷TŠ÷OmÍ€Ö·QÄþŸŒ­®Ä\™û¿ûYü5‹û¾÷Yy‚…{›)›)¤+Ä)÷jóx÷Yh÷m–÷GîóÄ{÷§í÷IúU®“²sªVÎ7«=¢ûoËû{“ûvu! z'f@o&d1¤ûc³ûa®ûa•P‹EÀb÷4÷"f÷|÷au÷n›÷O鿦ɯ–˱÷n²÷n­÷o‹÷˜÷ïÛ÷5Û÷ð÷˜ùäù.“OB\WªQ£‹çĦ»¨ÑdRÛ›~ñûÏ-aOpbKŽI2ÞCã“ã“Ðá€ã÷@øl´U“[’û¡ûŒûs^„Yƒoc¹`̄ƃ÷~÷Šö™Æ’Α·¸µý~vD—,@aûDû1ƒû"¥@˜3£bÒyЀÒÑ——‘÷lû"÷À‹÷k÷"­rbs÷ùIrû3pû1oû1ƒ]_qewûGû1€û(›'–$¦:Ée©‹½ƒµr÷)n÷'y÷*”ËÔ§Á ӥؘؒ÷6›÷;…÷2]ÄzÇt±[œu†n‡s÷œï ýø÷oø÷/ ü¯E’Ušf™f¦h±j±k¹qÁzyÁÉ‚ÑÉÅ‘˜ÀÀ—ơͪ÷†X>>r=_d• iršyŸ‚¤¥‡Ääøø÷…üøfú÷÷Zt^zc‚‚c`†]V\’˜cc˜hžn¤o£w¦€¦€§…³Àø(û÷7¸š² «¦¬§¥¬ž±Ÿ²˜¼’Æ÷8û·÷¦ûIû¦û»H`’x’x˜|ž€{¥¨„¬ÅÅž°ÅûIø1úu þ÷ù‘÷—†€’~ûtà8û ût~€ƒ€††~“÷÷ü…‘”‡”÷ ”“‘‘÷òø“•˜†—þ÷ù‘ú§—‰˜ƒ•û÷ø‘…‚‚÷ ‚ƒ‡……ûòüƒ‰~–„˜÷tû § à÷t˜–“– ËÀùtLû ÷t˜ƒ–€~‰‚üûö……‡‚‚ë ‚ƒ‘…øûò•ƒ˜‰——’–˜÷tàè ‹ÀÀùë ”‡“…‘ü÷ò“~††„€~ûtû Jàût~“€–†—†˜•”ø÷ö‘‘””ûÿ‹qq÷ÕPVµ]Í]ÍtÖÝסжÉ£®±²¿·iµh­h£¶MD¡;ZQuItI[€nt]•ŸFŸEQ•Zû-[+@@*eûû-û8½û;ìû@û@îî4ò¬·–¢Â¡Á»–³´¾uÆvǹ€­àáÌ÷áÅâ³ß¤Úü •’Š‘’Š‘‰’‰”ûp7ZYCYCq5‰(º­‘¢’¯—¯£¯¯µµª¹Ÿ½ž¼•¹´Õ ù>ø¦‹ý>üÁù>-rý>-üÉù>új7þý)úûŸ þûý1úûÿ‹÷a÷u÷a÷÷b÷t÷aøú±vz  œ ¡œyvvzyuø:uz  œ¡ œyvvzyvýÀûLR]]SüBR¹]Äĸ¹ÄøBÃ]¹Sú¸xþ*ý.N¼ZÈÕŒûwR¹]ÃĹ¹Ä÷w÷ûwR¹]ÄĹ¹Ä÷wÖǼ¼Èû|úÃÒ÷’‰”„„Ž‚‰‡„Cû¦NGšCCG|pNC÷‡’‚„ˆ„‡‰‚„Òûû!C,ûû3ú1÷3,÷û Óøqü|Ä]¸RS]^RüBR¹]ÃĹ¹Ä’©wž‹«÷$éìä”»kª•´i±Ìᦿ­›®Å¯¡÷I÷7‚š÷ Y=€ù+úùk‰t•Œ–„Ÿ‹â}•Ÿn~‹Œx•Žûóü?“ˆ†‚†z…}}†Œ‹}•’˜”™‰”ˆùëûûb¬û‘ˆ;u{‰{~YP¹û †K‡S{TƒSmŒŽ ”ª”¦˜¬Œ«Œ©ˆƒ„€‚{qiTAsFƒG‚K’i±€˜wz‰ˆˆ†™‚–wÀ›oš_ewŒðk‘jÉ‹ZË’”Ïl¨s¤ûñh³zt”‚ u»|Ц¼”‡‡yu"Ï5š·–©Á‘·@•×Ð÷'ª“\ãñÏŠØŠ½¸û¸s½qÂ×Ù±¡–§—‰•ˆ‚¸.&7ˆeŠ}”|™_¶¼gÍ—¨•ª˜«—®ž®•5€¤‘‰ž†Žƒ‹„€|qD|u„n‚lƒaKš©]¥~’Ÿœ•”¤‘˜ Ž›œ˜”Ž‹ÙdŒiŒqŒqq™u”Œzwˆ|†wÊŽ©«›Ã³Š¯Š¥^Š=~ÅžŸv™}M÷,÷–¯„®™7†ƒ™Qu„p‚z•›¥•¥ÍT‡Sˆ“(š‰š‰±p¦†âzKY–N˜G¸´ûJ“€­¬û ¨ûb/Ñ“›Œ£•¯¥çc÷cÖt·u¨•¹pÆ4™K6—gp1›„²zyýùψ‰‹Š‘‚Š“—”†‘‡‹…‰‰—ˆ‘‰—y‡rø7ûYŽ}‚{w\» ¢ ‹@’’wž›™’xûF÷iˆ‡‰šƒ™ƒ‹…‡‘˜ŒŒ ŠsÁ÷}†€tŽ†‰x„…y‚’“š”–‹Ž• Ÿ““„ƒ“”„˜…Š†øÉúÃoGž…÷qtŽû ÓsÛp½^û)X )iz=JŸFŠdf…|oûL{1$+Žû–#~[G0`SQRnûe*wXjsˆIŠxŒ[œ™Ï¿àû÷û^‹£dâû7û,vX„9¯<ŸDœB–c–r’”‰•…¦¯±Œ««~œ€¥€¥ˆŸ”–‘”™Ž¢‰¨ˆ®‘ž—ªžš²}»\{zeugwTœqtmq´FˆXˆec_d5€dà†ãy÷qÔ]Å‰àˆ˜à÷Ž²Œ±±Œ¶¶‹Š·ãˆm]Än¼râ• Ÿ§¦×ËĨÔ°÷=Êû׋÷ ÷ú”¯j<5x0û3û%Äèû‹”…‘†÷÷¦ø÷‹ŒŒŒçû„±û\•QûMø󃈂‰‚ˆ‹ûöûûGûÓë #÷K÷.÷<€’‹’Œ’–÷؃ð÷æžff›f ÷hÀ8ûÏû¦Žz¶÷_÷÷=÷Ká”÷ û8÷û^ù@ûÓmûK#û2û'(„²h÷U5÷÷h¬÷KQ™‡ý¹ùyŠŠŠ‹ŒŒ‹‹Œøâû%‰ˆ.û"û‹/û÷bû÷7˜—½¿’À@÷:÷,M%÷÷süyƒŒûs¼ûvn€†–‡—†–}«|«|ª÷—õô÷,çûÂû#û/÷„!Áú@÷Ìù±÷¿€•ømû_ûX-ûPûuûPï÷ª½Ñö•û.÷MãIJ¾ËT•2¡û&¯û&®ûÇ÷<÷_÷]Ö÷A÷Q÷S@ûQdXJ*ˆ÷û13SsVQÄ~×yós÷"k÷=OûB÷ÿûmãmÜYÌ•»‘¾¾øûÏ÷ÏüXX…[½J:©3¨ 3©:½J[…XXü÷ÏûÏø¾¾‘•»YÌÜmã`{ ‹÷jËø”ÒÒ‹÷DÒ‰Žüÿüÿpqg}fo…r‘t˜xü*ø,p¦|®±°š¯¦¥÷ ÷ ¥¥¯š±°¯{q¥÷PûPø"ø#û÷€DÒû‹DDüßüßDD‹ûÒDøßüßÒD÷‹ÑÒøßøß>ù•~~}†üÒüÓû÷•‚~}~~†‚û û xx‹kžwø+ü,“ƒ–†–ŠŠ‹ë ‹™˜‘”•ùnùnžŸ‹«xŸ‹÷4ø´÷ø´÷4àùT÷TDüt; ú”5øt4 þ”ù4øDüt; ù5øt4 ý÷4ù”± ü‹ŽŽøtž…žšû”øÆcM»AüAM[Pcû”ü|…xxE«©›¦÷w÷é¸ûû‹ü/…ˆ€÷6 ÷Tû¤M¾YÈ÷4ɽ½É÷¤÷TD —ˆ–…•û‹ø/÷¸÷wûép©{«9ü4ù´‰ ý‹÷TË÷tË÷tË÷Tú”ùÔ÷C ý!55!ü4EÀ¶¶À÷ôËþ$ÍødËüdÍú$ËûôEÀ¶¶Àû´ùô‰ fù™÷~ûñømp°k÷ ðÎâÃÝ`¶Yy›¦u¿¿§¡›¶½Ý¶áSñHkû pfø1H! ÷xç‚ çÀùûÒû–û–ûÒûÒû–÷–÷Ò÷Ò÷–÷–÷Ò÷Ò÷–û–ûÒ÷¨û©Ž•Š–…“ûH÷Œ÷H÷Œ‘”Œ•ˆ•ˆ•ƒ’‚Žû¸ë÷Æ•†•ƒ‘‚‘‡û¸-ûH÷Œ›o‹{ûHûŒû¸é‰‚…ƒ…†ûÆû¸+‚ˆƒ„ˆˆŒ‘‚÷HûŒûHûŒ…ƒŠ€ŽŽ“„”ˆ÷¸+ûÆ“…”…•‰•÷¸é÷HûŒƒ‘•†•••“‘÷H÷Œ÷¸-•‡•”‘“‘••÷Æ÷¸ëÀ”Ž“’Ž•‹÷÷ô÷î÷}û%û ûI3ûUûõû³÷³÷õ÷¶÷R÷ˆ÷žÚH!fûûü÷ÁûÁø°°Ž‘¯÷_à–£†¨xžxžor€iB?z<— ÷ˆ÷À÷.Ê÷"÷óž’¨€¤£t›oŠü2|ûÙûåü3÷,÷¾÷¦÷C÷£÷ ËŸ úÔùTe û”hn¨®/ ÷”n øÔ÷, ú€1þT+*Ë€U ú1û”+c N «@`øÔU ût÷‹ïÍ÷A÷AÖ©ûAûAýàûA÷A©Ô÷AûAI‹'ûût÷ ÷tû¢2®Fû^ûwtpc¥s€˜š†šœ’™˜÷K÷c‹÷û÷Iú÷þ÷>÷÷ ‹÷ZûY÷2Öûd÷e³Ò¦é÷÷t*ütøÔ÷Eû#÷#ûE÷)ù÷)oš}úŒ‹}³4€û´‰uŽ{‚‹‹z‚ƒu\û O#‹ûûnWv™Zª˜êÏ÷h«ã,¢l’t:Œ$Œ4ŠZsj{rgš‰žˆ¶‚¢l‹¤b1–ûXl‹dvG®'÷b‹Qñ^÷ƒ {–‹‹y™q€û¦‰a|x‹‹|{™j÷jü‹÷ˆû‹‹÷sû}÷‘›‹÷®Žž‹‹›Š¬‰÷.Ó¢‹Ñ¡åû?ëI‹ÔY–÷”÷ŒK÷‹†”kÐû.÷#û4÷) s÷V÷–÷ ÷1ºë|´ ø ì÷X–Õ÷Røf÷ õ÷ù7÷n]Mw] ^ }À¨¸§·ÇŸ¸xºwšVo]é÷ ytƒy’y“†ž••œ¡“…„‘wy÷B Ç÷A÷û'±û!¯û3EMûMûÇû!÷#] ÷([÷BÕÇ÷÷Ì÷4žûWûtûIû½mû½nû”÷x÷Wx÷W÷t÷I÷½©÷½¨÷”ûžûW÷ȇ÷ûØ$«r“z˜¬§ÓŽÉl·QÞû3‡ûJ>ŒRq™¹§å‡×_¶(îû›%ûvûvøû=û=)ûGû/û½øûHøø{÷Ø÷¯÷uAùRË6£=zk„wl’k‘k«w«’ø‹±“´§l§l“ae‹lœjªª¬œ•ª¤×{âRÊ÷I÷7û ÷ûA¼û5i‹fƒsg“f“f°s°“÷£÷hß.ß/¡ûgû‹€gŸe¯¯±Ÿ—¯ë ½÷0l÷Fû ÷fmiûE÷û#÷=[÷Z\ûZû#û=ûEûO÷÷i÷÷÷­Ç÷üƒ”ûþNû¨ûÏüûQÏû@÷û÷ ÷÷Q÷º÷êúû£øû¨÷ÏûþÈüyûê÷Qûº÷ û÷÷Ï÷@÷Qûÿù¢à€zøEûÙ÷šûÃûã‹«ã¤ê›ï‹ø‹&šø}ûá÷û9ûÙ‹®‹Ü‰‘‹÷{øHü[÷1ûûâøû¡‹ˆ…û…N‹ûø[üGûC¯üJø’Û‹z"q*g2E÷ûK÷aü"û8÷1ü&÷¯·÷*ÅûûŠûaû/ûŠrwxrrŸw¤÷®Œ÷ˆ÷T÷(÷¿‹øvûÂ÷]ø‡ü Öë÷¯û*Iûã0÷ø¥û¡÷˜÷¡Ä÷ãæ÷ø÷K øÛ÷K ø÷3æûýâû30ûHÖ ‚ ùpûô-÷ôûTzš| ÷4# ‚ ÷* ûô÷Tœ|š÷ ‚ƒƒŽ‚‘…÷ÓûÓ…’“‡”C ÷T÷ô3 ÷4ë# ƒ ú”úTG ~~‡ƒ€üTûÔzwwv•xœøTûÔƒ–˜‡˜/ ÷”û4= ú”ùKû”ø´, ‹÷ú“÷ñû•ûdûpû•÷÷]÷‹÷Fô÷4÷7Óz÷ûw8û,ûlû†ûÑ÷—û—÷Ñ÷Ž÷r÷7÷‚ØøRóûZ(ûxø[ t™sü[{÷ø+÷ü;f÷µçÛÙæãCÓ3DK^Fxˆ‡uŒëýŸk§r«øl÷ƒüqv•¢}£••”÷”÷‹÷úÿ÷©æú~F6û„û1ûfH1:4%Oft@oZ )´i÷‰Q~{{Å~؉‡}ˆzy_™gËK÷ô飳Ðúó÷Ü©´n¦_ZZp_bn:©«¡ ¬°°v¬k¡þîû bA*t%nèüd¬Ê‹‹ÊÌ«««««÷4÷4ëë‹ëë÷÷ƒµ÷m±‹úøø4ñìtbÕú‹‹ûm±ûƒµû+ë‹+ëû4÷4k««kL«J‹J‹l.üdÕ ïùŒ|{ˆ†|û8S"÷Ð÷1ÁÞ»¿ÉÛHÅ=|}‰‡}û6TV÷5ÆwS³L4áû ªûqì{7Ö$û//û)Ï9çwhû §ûç0©m‹÷+û,÷5û4÷+÷,û4÷4û,÷,n¨Z¼‹Ü¼¼¼¼Û‹¼Z—÷,÷,ù¯þ³ó>à'™§÷l÷4ân©û,÷,û4÷4û,û,÷4û4÷,û,©m¼Z‹;ZZZZ;‹Z¼—û+û,–ç/÷o÷¯‹-žÞDï÷çç÷‰úø÷/çû#5>'}û­ûn00nmû,û,û5û4‹÷,û,÷4÷4÷,÷,©©¼¼Û‹¼Z¼Z‹;ZZ÷+û,——ææ¨÷j÷ï™Ùáó‹²ùJ·øѲù"ø^“€¹……û ½z“}’i™{’¸Ñ§À“’š»éŒŒ‘Œ¡ŠŠzsƒsƒ^myˆz‡SvnnU{u…u…wŠ‡Œz…‹Ž†—~˜ˆ™‡¢Œ•Ž–”ˆ—ŽÂ˜Ÿ‘ ’Ú¦•ŠˆLûveweû û:rnwt]R{‰¨ŽŽ¬ ÁÏ ¿È¹Ì¯Â‹’ˆÄ\ššÆj˜…˜†¼t’ûaøz˜ˆƒŠmƒ|†}‡l‚~ˆ~ˆn‡‡”h—~¡uˆ”ŠŸ¤‘‘šš‘¤˜•ž’ˆœùNû?ûM÷aûmüÑú›ùJ÷}þœø·àf÷ûgÌ^û%ª÷lø¬ïl÷Iý%üñúuøÑ÷Xüûšû¶Blznxj|Zû6{û&û´¸1‘~\¨‚ƒƒ€„‡‘†Nß÷ULõߨ¬‘‘¨ê›ï³Ü¿³IÁ÷4÷¶úØû'ºø6˜‚“€‚ýûk‰„üÂ÷Zü6nNwˆŠ…‰ƒ‰…„‰‰Š†ŠˆþÊŠŒŠŠƒŽ’†“•ùa÷†’›‹Œ‹ù™ûŠ ÷÷´Ë÷TË÷´÷÷´‚ ûz÷”úÔŠ`û7÷7ÀlÕf°û,÷,°fAªVý4núwùô÷ ù”éWÞ?·ýtþq4÷”ý4÷”ý4ë÷”þø”ùû4“ ÷4‹÷”÷÷÷÷I@c ËŸ : ýÔû´÷> P ÐKV ûT÷> à? KV ûT÷> P KV ûT÷> P ðKV ûû”y}}yKy}™Ë™™Ë™}y÷T, ø”úÀ. ÷Ô, ÷”þÔy}}yKy}™Ë™™Ë™}y÷T, üø÷tË÷t¤úp°±‹Çf±e°O‹efûxûxüûx÷xe°O‹effe‹O°e÷¸û¸ýÌÍøËüÍùÌ÷¸÷¸ûØ÷8‰ Õ ù ú¼÷ *÷`û7ûQûûû íû`÷6÷Å÷÷ûêüw÷%û ÷Yû4ûW%*û%÷ ûX÷4÷¾ðìø¦û‰ûßûôûûájì÷%÷ä÷÷÷1÷ñóŸ÷÷€ûß÷õû‰÷ƒ÷g÷6í÷`÷ ÷Q÷ûû7*û`û ûÅû÷øDóû4û ûYû%*¾&÷÷4÷ ÷X÷%ìWñûþËùùTú„÷”û#÷¤ûEûEû#û¤û”û\âû÷[^ýÉh‰¦n®÷T®¦¨®‰^ùÉ÷»â÷÷\ ‹÷z÷ú.ù„ù÷}ýýTø˜ýN÷’ùN÷’ùNû’÷‰Ái»YýT÷”}|Ž|||ˆ†}ýTû”Yyi[Uý”\¥`´uùTü€ž †   –žùTø´¡¥¶ºø©ø”÷ø Òù+Ãù@ýÃýè÷ ÷Ÿø÷8ûžüT÷jüM÷QøM÷QøMûQùýW¾m¹[ üF÷Nø$¾l¹\ üT÷T’{zŽzzzˆ„{üTûT\vl]Xü$üFûN\vl]Xü4[¦^·vøTût÷ ŽŒŒ‰ŠŽŠøTût÷ · ¦¸»÷©‹÷©øV÷¢ûo÷©Ý÷€8­ûü“÷÷—ü>÷ÊAû –ü,÷ “ÛÖ÷ ›üÝû'>á÷&ù&ŒšŒ››÷¢û2÷uû²ûªûQûeû¦û°÷GûW÷´÷n÷!í÷eÏûq=s)b?úɽ ÷ï÷ÂÀ÷ØXûû/cûû¼ø­÷º÷˜ ïåoû E`(üÂø‘ûø÷÷y÷k÷÷”÷2@÷ û/·÷ÁÆÝ÷P÷ûOÈûl‹÷÷A÷®û®÷Í÷A¾øÎ÷˜T ýü÷÷ eû1÷ÓØ÷©‹Ânæ€ù“ÝHÎ99IH99ÍIÝÝÎÍÝùŠîŠ~}Ž}HUTI[§_·xÀ‹Ëq‰€€‰€7GÏàßÏÏßÿlY¦úéüœ7GG7RWª½q|°µs´ÎÁÁÎäE F§•—–ßÏF7øŽøX$78$%7Þòñßßñòß7%æ÷-û÷û-û,ûûû,ŠûAûŒŒ„„‹„egxký£÷Ïêv6Ï*û..ûûè-÷°°–ž«ù£ûÏ, ßGíõäÜõ–÷÷V÷-÷÷÷.‹÷­ªùÁ¨Þ£÷N¢Ä÷0ùLWabXXa´¿¾µµ¾¾µaXþnµ©{k gV``VV¶aÀ’‘ŒŒ’c›Œf›y¶›±š±µž±}‹»xùIûÙÀ`µW„„ŠŠ„`³{²{_|e{d_xd›|‘{‘{’l›«w°¿¶µÀ÷Ð÷®ËW¿KJWWKK¿WÌË¿¿ËÄ+=>,û;ûJ…TWHMW·Å~ü}÷Ywu…sCQÅÒÓÅÅÓÈ¿_Q˜ø}ûY—Ÿ¡’¤Š÷÷/êŒØØëêÙ=+÷ø=  ›àùØøüD›>—‹m2Wû³.ž_¶Z¿‡ø8n¡šøüøÞüEœ÷ 5<ûhL‹‹hL²Q÷Rûù‹ ÷S÷u÷•÷'/ú¯û‹û>0ûç´„÷Aûgûþ÷züƒ÷8÷(Ò’‹‹Ó‘¥Ì÷P÷ûý¥ú0KÐCì'”ZL{o_ûuûøž÷ÑûO÷nø ºÉ‹ù#ûÇx€ûÍûW÷{ü­D‹å¤÷ ŸÁߥµ›Êp¸û÷øá€B÷dÈ‹‹eÇE…ü)Œ‹÷3û÷ ûÓû+5ø7w÷pø ÷ ù”o"ø7÷lûêûýT¼û!á5õõááõ÷ú4´ !á5õõááõ÷Z ÷ ùo"ø7÷lûêûK÷t1 üT;ût´ ¼K!á5õõááõËú4K!á5õõááõËZ «ÀàËß ü&ø'÷y÷=ü&ø'÷Y÷=üøt žüüb÷Yü&ü'b÷yü&ü'bøbˆKƒHJj¦p­­ ­¦¦¬ÌƒÎˆËøbN‹÷úÚ÷aúû÷Úouwr~ƒ’Îûû¯û'89€{=ˆ{†‚mx£¤«žš¢ êé˜í÷<÷*e>÷ž–€oë÷kjqpi{€’‘€ÕûûA½ûR*7}xE‡|ƒ‡}jp¦¬¬›¡«”£áã÷÷]÷VY0÷-¤|•xp÷÷Œaime{“}Þûûl¹ûd""p*ˆ€}†|bl«´µ¥£§“«÷÷š÷÷v÷\&÷A£}›xf÷aû)!‹Ò½÷%ú‘­÷$Òu÷/ û>MM>û>ÉMØêØÉÉØêØMÉ>Ïú‹fllfûflª°ê°ªª°ê°ªlfý—üœç›ÛχìûZ÷T¹Ë›‹¢‘¥–s¤ ÷ûjÐûïMƒŠƒ‰ƒŠ÷hüKý[ûWû!“ƒ•ê•““•ø„ü©û%ø—ú1ûƒƒüÄÊÂغå®6÷R÷}Ìû“Œ‹“÷t¬÷nŠ÷__Ì}ÊzÇvø@•ƒ“þëþ÷“Èû÷¢û);mû˜ûŽxž€ø©ø²ºÂ¿÷½±æôÑù¤÷8~Š~•˜Š}÷…™øŸ˜––—˜•€~Œ›üŸ÷¬ûhŠsƒˆ„…†††„‡ƒ‚ƒ’…‡‰‘‘Œ‹‹‹€÷‹Œ‹•ø׌‘•”“Ž‘‘‰ $“†‚—üÞþ´÷Šˆ††ˆ‡†Šzûœû†ŒŽ‡ŽŒŸ÷Í÷cŠ‡††‡‡†‹‹‹tûc¢û^…‡Œ¥÷_÷’ûŠ‹‹ûPø’†……††„Švû‰ û…Œ†‘‘‘¤÷Ð÷“Š…„„…†ƒvû ûˆƒ‘†’’‘“Œ¢÷ˆÒ÷~“Š„’ƒƒ„„ƒwû~ŸûŠ‚’„““’’”Œ ÷Š÷þû…‹‹ûµù•ƒ“‚„ƒŠ‹‹‹yüûŠŒ’ƒ•”““•‹ ÷ŠÔøf–‚“€ƒƒ€Š‹‹‹{üh›ûˆ€Œ“ƒ–•”“–‹ž÷ˆÚø—Š‚•€{üŽ›û†Œ”‚–—””—Œ‹÷†ø û€‹‹‹‹‹ë ûZù~™€–}}€€}}ü’™ûƒ}Œ•€™™––™‹š÷ƒßø›Š€—||{Šü€—û€|Œ—šš——š‹™÷€÷Z}ùŠ–…•‚Ž‡…†ƒ„ˆ‡†„…‡‚Š‚ˆý‘û ‘ûzŒ™}œœ™™œ‹‹™÷{úìž÷1û÷û0dfƒ}i÷“tûj÷\û™KMuTuƒ…ƒzþy™~œ‰‹Œ‹ù¥÷0÷÷÷0fù”ù”`ý”`ø`‚ ü<ûì÷ ´ û!÷ìû÷ } ÷÷!ûì÷ü<‹÷øœÇ‘»m¯÷÷÷l³÷÷Ê Dø4ü–üCP»Wàhô—ЌnjÊ•‹••Ž‹ŠŽŒŽŒŽ‘«ˆ¡™Ê•ƒ|Švw||r„yI•û«ûs7h3^1c:gJlXŒŠŠŒ†“Žƒ†ûJU>]ˆw€†‰Œ‰ŽŠ£†””‰•ÇÚá÷Dòö°÷&ª÷š_ßìnËÀšŸŽ‹‹Œ‹ŒŒŒŒŒ–£…„•´r6“Hgd‰†alorŸ@üÔü/š­ºÍÖÅK&``m}ø"ú,ŒŒŒ‘„‘€ŒyŒ‰‹‰ŒŠ‰ˆŠ‰Šˆ ‰ˆ}‰z‰~‰|ˆ{@ƒÃ‹»•§ûý)š¦š§š§¯Ò§ÌžÈ­B·O¼`”ƒ•„•ƒ)y)o3hù›ŒŠŒŠŠŠ‡†‹‚m^•Z÷¥x†‹÷ø:’÷ç÷ ø4ûiû÷À 1îüJ{zŒ~v Ž˜Œœ›÷$øµ÷÷$üµ{zŽ~Œ„ƒ… Œ˜œ›îøJ1ö÷À Eû8ý)û3ûøy†›Š›ˆ™ˆ£‡ƒŠƒŠƒ‰{ˆ|†|ûüyû3û8ù)E‹÷øÚó1óÏ•¸ ø4þgýªÏ÷V÷¯ûQ÷¤Gö÷¶ ?õû3“‚„„ˆˆŒ‡Š”š—žò÷3Aö÷« HûWû®÷Tû¥Ï!Øû·õ× ÷5„•…‘‡“‰Ž‰ŽŠ‰ˆ…|x$û5Ö!û­‹÷øž÷—~•° ø4þtýªçø¿/öø¹¹‡|±ÞhÁ7ûûS.1l~gd‰`ûû;è!ûÛ÷õøЪ¥• µ Ÿ¶ÃÀw´g —vp‘hû û ‹÷ù”• ø4ûüÔûÔ÷Ôüü÷$àûTûTûTú”ýÔø”õááõ’ !á5õß‹÷‹÷‹÷‹•–ù‚ ìûû”ìùP÷˜ûÌ÷Ì°fAªVþnùÀ- @0 ‚ ÀlÕf°üP÷ˆœ…œ‚’„÷ÍûÍ’„”z‘zü $ø÷# ûc ø”÷$÷÷ü4“ ø4ýûçƒržn<÷ûûH(ûâvM‹†zˆzyû÷:÷(÷(÷Ü÷ˆœ†œ$‹uÉ6÷³Hû!üeDR¨®®Ä¨ÒÒÄnhhRnD‹÷ù”÷K÷÷Ô÷Ð ø4 ý¨ûf~ˆ‚û:û;ûI ÷÷:û;…’“÷—“—˜ø´˜ƒ—ø5ýE}}•o¡‡³¢§ÌÛ®íóóhíJÛt§³§¢¦¡´‡¡oÞ%¹ûûû]û8%{~yƒxûg÷(|{‘–~r£‰´¤¥¬¯ž¹¼¼x¹j¯r¥´¤£¥£´Š£qÃOª>99l>SO~~z„z‹÷ù”÷K÷Ô÷÷Ð ø4ýûü·ü´ø› øë°ø€‰Œ‡‡Œ‡÷Cûûž1÷ûž…‘”÷—“—˜øÔ˜ƒ—‹÷ù”÷ ø4þ4ûûvûÁƒ€‹{“€÷vûÁ–}Ÿˆ™–¾±™–ŽŸ€™ûJ÷‡÷J÷‡–™ˆŸ}–X±}–wˆ€}ù¶ûÁûv÷Á€™wŽ}€Xe}€ˆw–}÷Jû‡ûJû‡€}Žw™€¾e™€ŸŽ–™÷v÷Á“–‹›ƒ–ýüaÊœˆœ–Ž÷ùÓŽœ€œyŽL•zŽz€ˆyûýÓˆz–zˆùy÷›÷u÷ ÙùYaa‡fûfû6÷&÷“÷»ÌÐ̶Qû HyA~`Ìû÷D®‹±ÞŸ÷ê÷“û÷(û‚û‰û#ûPûûŠ÷ûg÷Q+<û3%û!!!ûS÷|ûB÷ÊDøðû¯÷þ‚øûÔòMÆh½À©ßº÷÷÷ ÷ºÅÑ’›Ñ ‹÷.ù-÷.ù-÷.à÷lø÷¡÷H÷âûsûûý-ø¶÷–÷Uûùý7÷û÷â÷s÷¡ûHý<æû¤÷J÷¤÷J÷¤ûJý?èû¡÷Høïø&ûûùûÐ÷U÷û–ûß÷rûâ÷s÷ûøïü&÷l¤~¤v™ýÇø¶“~||||†ƒ~ýÇü¶v}~rrü¶r˜r }ùÇü¶ƒ˜š†ššš“˜ùÇø¶ ™˜¤¤÷©‹ù—Œ——÷ßû¤÷¡ûåû‡ûdû û^)¯[O¡Kû0ûûû-np“qû D:ûû)ûr÷Jû?÷t~Œ¹’’Š“÷r÷I÷F÷o÷9$÷"û%ÇúÌûž÷9÷ê÷/÷ÌÄü÷iÖüØÑIºIR^rdcl¯m°k®ÐÑÔ§í÷2÷*û:û8û)û0ûÔ\øûpFN[BAÈ\ÒŸ¤³´©g«h¨gGDDl)û3ûê÷= ßù”÷@ úc üƒü%ü%üƒÆ øƒü%ø%üƒû÷÷jR÷ûVûVVT•PQSyVûV÷VÄ÷÷¬÷ý:þýR÷j÷÷÷¬÷Ä÷÷VûVyVTPQ•SVøxüíûû¬Äû÷V÷VyÀÃÅÆ•À÷VûVRûûjûøš ¨ øx÷mÀ•ÃÅÅÃyÀ÷V÷VÄû¬ûûûjûRû ‹÷”Ž÷”ùøWûâø üFÉû˜÷¸P÷pû—ûÉûõû³É ÷³÷õ÷É÷p÷—÷¸Æ÷˜üFMûâü üWÆ  ž÷vøª÷|øª÷yàžù*ü†|øü8ø‹ø—øø ø¢„…øGû}÷AûI÷‹r•¡w‹ø-üuüûà‹û\û?û ÷5'÷´÷pÄò‹Ì÷î«$÷‹ PY8‹÷Õóû4÷Iû5ûK‹Ýûˆ ‹Gñ3±#û‹÷T¯1‹÷!û¦ûûI‹û%û>ûH÷Gûó÷ñøøU ŸŽ…‰ŠûûBû&ûœû² ‹·¶÷- ÷-¶·ùþ%bŒbd’œáû&¨û×-öJRpªr¬v®‹Qi÷ûu÷‹û,÷®ƒüêøètÍ~ÓÕÕ—Ó¢Í9§˜²œ±ž®R¬Mûgûûû¯ûÉûĬx¯{°}²Þ§äûEvhrjplJÄ- û?û&n@œ5d„b†bŠI÷®“÷‹÷,÷÷uûeøàuÊiÄ`¼ûMû6 f¶XªP—»÷„’ljŽiijˆ„l»û„PXlf`ûM÷6`ZiRuL÷};‚p†ommo”pû|; L­R¶Z÷M÷6°`¾mÆ[û……ª¬‡÷E ‘ª[÷…Æ—¾©°¶÷Mû6¶¼­Ä Êû|Û”¦§©©†§‚¦÷}Ûü‹ù‹û®ƒûŠû+ûûvÄj¡®£¬¦©ÌSéö÷×÷&§zᲓ´´ŒùÓýz÷g÷M÷Rjžhœe˜d9o¢I—CAA~CtIÞo}d{fxgÄjÉ÷¯÷÷û ø;û÷vûŠ÷+û®“I´Š´‡²ƒz5÷&o÷?é Ìæm£j¡hĬ÷7ü;üjüüüjüjüøøjøjøøøj‹øjøüüj·øƒü%ø%üƒ‹üƒü%ü%üƒÆ ‹÷”÷÷\ûO÷+÷:É÷Ç÷Î÷”¼øÚ÷xÁO’a_U‚TSË„¶@·¼—ÁgøfºtµXRweWW¡k ÁŸ®½÷:Ö{†z‡{‡‘zzy"J<%wl†y}jh»w§†Þ|æm'û!+\û!û ¯÷Õ¸¶Ï¡Žnœ¦¬«‘²«™ŽM báÉ÷åß÷²±x¬¹¹˜›¶ûÆü7Ž¤‹¤¤ø¢‹¤ˆ¢÷‰t‹ttüp‹opø›yje…fû{ó÷÷mƒƒŒ„~‰Š÷ ǺžŠˆ÷ †iiiôû yzyWûuf“^¸££’™Ÿû ûøùV]g`[[fµº»¯¶¼¼®_\øø»  Ï÷`ûU÷jû÷f÷#÷bû'÷^÷÷j÷T÷mŽøç¡4=yBF$–åäâšÒÏì3Pù‡:kS43g¿Þß«ÈçÞ¯G@÷¡÷ØpFAw@ªUM›MûMû%ûûO&Íûði‡Wt€LXU _¹o‡ûgBFû ûb÷WR÷?÷d÷/Ö÷yH÷®ü(#÷-Á¨ ½•÷:ªó÷÷=¨…§¦¦‘¥’¥”÷Òý;‡¸‹·¸øù´Šµ´ûraŠ``üõ^‹_‡^÷røí÷ruke€dA~ÓÆ ø২‡¨÷Rû?ˆÂ‰Â“ÂûwnŒmm(?+ûRŽžŸŽŸ——‰˜ˆ‡‰ûóVûB¤û=÷jÇÈ•¨ÀüÔwÖSÓ<;QE>?ÆFÚØÅÑÖfùÍø·üHûøGû×øá÷*ßû7âû7Öû<ŽÔ÷=è÷7à÷6÷*ø| üÄóXóúó` ùÞúXö4á! 55 pq–sa_^U^HûûKûûʲüJpŽ¢w¥Œ‹§Ž ¤‰¨m÷ÙÐ÷µ÷7÷‰²Å³¼¯²u«±~´`õââõø€÷Öû™÷™ûÖûÕûšû™ûÖ/¡/µ:˜qª¥˜¤˜•ª~¥iÏyÔØ÷œ÷k÷k÷œ÷œ÷kûkûœûœûkûkûœgf”ho‘py„p…oœo§„‚¶·†·÷Ö÷™÷™÷Õ Ü÷¢ùnû0û +û(û\f”m™j‰‘ˆƒ“ŒÅ‘¿Â¡¾Žš’ˆšCìûBÐ{ˆˆŠ‹ŠŠŠ†‡Š†g‰tzl…dg{Sû÷º†×á÷)ÎÈ¥ˆ¯£„i÷îk÷ç÷-–áÄ“–‰—–zê/†RÂÌɮ٫ÞŒŒ‹ŠŒq™¶,²Þ÷®÷2=÷5÷Š…“£¦¦Áq¿n·ŠY÷V÷Lûî­9+ 3ûûzZ$û;;û#û}ûMwz€VŒqzvy^oyŒz’z÷©‹øØúÇUggTUT¯Á¯Á¯gTù{üfggTgg¯°¯¯¯¯Â¯ggû€øUggUTU¯ÁÂÁ¯ÂÁ¯gTùüffgUgg¯°¯¯¯¯Á°ggûžø!÷¸MûÍ÷mûøü#ûÚû£ûíû[÷û8÷IûCûn÷‘÷yæÓy梡Œ¢|»ƒ¾À÷Ð÷¤÷•÷죢Šˆ¢øäüÅ÷¶û¶÷€ûÚûíû£û€û¶û¶÷£û€÷íÓÔžÔ÷[ûT÷I÷&÷÷÷%÷7÷(’~~€€ˆ…ù€þTvtŒsršv¢‚øû6úÁú1ýôþ·ûñpœs¤‚ˆ’“Š’ž“š—÷†÷»øYûMº÷(w™pŒv~ù€þTv~tsršv¢‚ølûUüXq›s¤ˆ’“Š“œ’™—÷¾÷Ûø£ûkºûêú%ü€÷]ørù±ýóýûä÷šùÏù”÷ø÷”÷ø;ûí÷íü;ûYûS<ûû!û÷m Àû÷i ý÷´¥ ‹÷Ž÷ù”÷/÷õ÷³É É ÷³÷õ÷õ÷³÷³÷õù”ý' ‹ü<ûìûìü<ü<÷ìûìø<Р÷•÷Žù ÷’û®˜´¨âûbX«kŸ‰â¬ÀŠúC¯Œò­¡½ªò_â©}³g55„533’3g}cm6ï³½m®v‹%fŠûÔ€‹Š€ˆ~~‹ýO~~‹Ž~Š–‹•–Š÷Ô¯‹ò® ¼ªîaá©}³g76„7/.’/h~bn1ö»½l¸p„û.[ýÁŒRhŠ5kuZi/¯4oše¬àà’àçè„è®™³©åû ^W«f¡‹ó±Œø–‹•Œ•›Šœù7›Œ†›Œ‹€Œüh‹7jvWi'±2n›f­ãã’ãää„ãüø¡÷z÷#÷zþC­p¦iüsûLû2r@;pEVP<Q·;ËOßdÌlÞwìƒü„÷Â÷#û>÷‚  ‰£ž›—–›œŸˆœ­¦Æ­Ä àøøÔû”ý4§ ø”÷4û”û4§ ÷øàÛK÷ü”øÔ¼ ùlü4÷”ú”ûû”þ4= ÷T C ü”Àlþ4÷”ùøô¼ ølû4÷”fÀø”7>jVRûü÷HŒ–Œ—‹–‹–Š—– %÷ü÷HVÄØjß÷ ÷)€ŒŒ€ûüûHÀR>¬7÷)ûE÷#û#÷EßجÀÄ÷üûHŠ€Š€ûE÷#û#÷E÷ ƒ Ž÷éû ++û û +ë÷ “Œ’Œ“û…÷ heXuSû +ê÷ ÷ ëê÷ þuh±÷…÷ Š“Š’“÷ ëë÷ ÷ ë+û û ++û SX¡¯eû…û ŒƒŒ„‹ƒ‹ƒŠ„ƒ %÷…û ¯±¾¡Ã÷ ë+û ÷”ùŸ  ‹÷9»÷/Ë÷/û÷4 øÏúG™j{fj}û^11^ûr€t|qƒƒŽƒj˜|°˜¬Å÷$÷÷÷$ÅP¬˜°|˜júB÷øû‡ûˆGÏr¤b‹rrKKÃ&û ¬ûüûÏûÏüü÷ÏûÏøø÷Ï÷Ïø÷j÷ SðËˤ¤‹´r¤(GÏ÷ˆ÷‡eñ˜—‹ ~—1æ~—w‹~~‹w—~æ1…‘“‡”““±÷zûz—˜‹Ÿ˜0å˜v‹~~‹v˜å0¢““Ž‘’´÷KL+)M ë?ûT÷T}™yD+M 3÷+´—˜‹Ÿ˜~—w‹~10~‹v˜…‘“‡”““±æå                          p¦@¦÷ ÷÷ ë¥(V\j{†‘˜¡¦ÄËÿ#.26<@DHLP^k‘•°´»¿ÍÑÙÝâðôùþLPW\Õíòöû,06:>B«²öý&*37=AN›¹ÀÅæëôý$U]jntƒ”›£§¬½ùýJY]b}ƒˆ•¨¹ÁÌÕÙÝáðõ-2JSX\‚ˆŒ¸ÉÞâëñ÷ü /4AGNRV]diyš¹ÃÑâó  $ C K S _ p z ƒ Œ š Ÿ « ² Ì Ô ç    + 1 > K Y _ d l t y ‰   µ Ë á ñ þ     4 I ^ r † — Ÿ ¤ ² Å Ø Þ å î õ ü  % - 2 C L ] n s { „ ’ –   ¦ ® ¶ » Â É Ï Ô Ù è ÷     $ ) 7 E S a j p y ~ ‡ ‘ – £ ° ½ À Ç Ë Ñ Ö Û å ñ ý #(.38CNRZep{†Š”¼„ûÌ÷Ì°fAªVþnùÀ- @0 ‚ ÀlÕf°üP÷ˆœ…œ‚’„÷ÍûÍ’„”z‘zü ø÷# ûc ù”ü4“ þT" û3ûûû3þT$ — ŸG÷À÷ˆŸ÷t$û3÷û÷3 ÷3÷÷÷3 n¥- ø<ûì÷ìü< . ¥ > ù”üT9 ø”ûT> ÷”Ë6KeKPË 1û+ z DÄRÒ…ø”z DÄRÒ…÷0 ûõû³É ÷³÷õ÷õ÷³÷³÷õ÷÷$y}}yKy}™Ë™™Ë™}y÷T> E DûÔS÷Ô4 D  9 }™y = A ? W ® ' ……‡‚ƒƒ‚‘… : ù€* €* œ|šzKz||zKzš|œËœššœû”÷Ô> G  A ¤ü÷Pø‘…‚ƒ‚ƒ°øfüfo M  H ÷Ô# P  £ RÄÒ…ÒÄRD Q  ÷> P  3 ®¨¨® ‘…‚ƒƒ‚‡…… ( ®n¨h #û” J œ|šzù@z||zûTzš|œÀœššœøÔœ|šzþÔz||zûTzš|œúÔ™ ù@-ÀAC ÷!÷} y™} Ë‹ûj]^÷‹häY¢‹E»ÖŠ‹×…µBÎû ÷­·Ÿ’½Ÿ¬¡Ÿû?žûGÍ÷ºߩмÀƒŸqÙ´õÌŸ÷'(‹œÈÍ”ÌÌÍ‚zÈ‹÷'îËwµ!q=ƒw¼V©F7û»ûHJû?x§s£]C$‹ …‘Y½E üfüf7 øfüfB½½b ™}y y~ l ¸ ù” ¡ ûáûáûš1ü+÷š÷áûá‹ à÷/ ! úT% úT& : DK; h¨n ( 3 Œø÷'ïûú`üt3CÓã–ãÓC3q÷Xøtä÷ù–ŽŸ›—ùT—Ÿ{€Žäûù÷8üt3CÓã–ãÓC3qU þ6 ª øTüTmœ›’——øTøT‚ Dû; ÷Fû÷/ûB´¦´™»¼÷ NPuc]÷T<ûO÷ûdÊ}Œ}Œ|û1B&û2ûBû‹÷]û]÷‹úÔ{Y øÔ| ÷T8 ëü”·ü´ø”› g€‹[ ‘‘”“  øj‹øiøh ' ;K2 8 1 K;üÔ2 Ë? âè÷½÷÷®÷zûzû®û®ûzûzû®û3û'Ó÷)†’‚‚Œ‚‚ˆ…„ûû€€Šx•~ûD÷&÷l&÷yø;÷í÷íø; ù”÷/ ü<ûìûìü<ü<÷ìûì÷ ÷ìø<'  — Ðe û yžots{tqüT+øT¥¢›£••¢†§x ¬  Bøføfb ÷ˆ÷À÷À÷ˆ zš|œ ß ü´ø´‹û´üT'ü+øTû´’ø´ø´‚ ÷C ûtV`¶À«÷;*ÎKû®ûzûzû®ýT!á5õøõááõ —{’z „û!û} Ç  Š hn¨® Ì ý:§¨ý: «Þ ûÔû&&û÷8 ÒRÄD} ÷!÷1û! 6 ÷÷! : ù€1û”+€* LfûŠeN‚zyŒzððð÷#÷ u÷"­Œ•Œ•”œˆœ‰›=®1‘?²uÕ—ÜØ q ?Ë• € ‹÷”ú”÷” ÷8 i8_dd_€~~xë zŽ™šŒŒ‹Œ©¨¦’ð¥é¶ÞÆÃÆ…Èø÷Ï÷y÷¯ 6þTeKPúTY ª ø÷ ÷'ïûû''ûûï'÷÷ïï÷z|šœ m/ ûÿ‹ c Ž„…‘…ùZýZ¤rŸ”® œ÷÷Ô÷Ô‘‘Ž”“ nûÔ- û3ûûû3 õ5á!!55! - „ 1 K ÷”C÷÷tI ûÀûˆ Dûtût³ ÷tûtA ÷T5÷t÷t ^ þÔ-úÔ^ ûhû@÷@° ÷h÷@û@ûh ­ ¡ û”û”„{zª ÷0 ‹ ÷ ‹÷túÔ÷t ÷® € —˜‹Ÿ˜~—w‹~û”û”~‹w—~¢““Ž‘’÷ G ž © }D ú÷;ûû`÷¼÷L÷Ÿ÷÷<û•û ûxra†„‡„‰„ˆ × ûôût÷K2 ÷Ô? ÷÷÷÷÷÷÷÷÷÷ Û ûhû@û@ûh ”’’” z’{— ”…‘ ®¨nh ÷Ô L‹ûT û}D}†‚}´ “…‡‘‘‰’ŽŽ‹ŒŽ÷kÍ ÷h{ U ú€1ú€÷; Ë5 DûT; û i ÷‹÷‹÷] r¤‹³¤¤ ¨®®¨ e ý”¸ø”÷ ü” ø÷ ™”—™÷•†•ƒ‘ƒ‘€‚ˆü û §}t¹ÀÆ÷.÷+Ý­Ë’‘Ž –™¡£÷! K÷û 6ù@-ÀY ùß û”÷”‹û ‹÷ûc û÷@ ·g¯__gg__¯g··¯¯· Ô÷n’ŸŒšŽ—ŽŸ…Œ…Œƒ—\Óûný ùäû4‚„„‚*<Úì”’’””’„‚<ÌJÚ”’„‚ ú@ò÷÷”÷ 6ûT-÷TY üƒø%ü%øƒøƒø%ø%øƒ L ÷!÷÷ : ü1´ û³ûõûõû³ „ ùÀv À÷L Ø æ0 ùZùZ‘‘‘Ž’ 3÷D 3C ÷ø÷³ûU÷ ÷˜÷´ûf÷ ¨§ - úT0 e øhn¨®®¨¨®¬ ‚ 2Ÿy—qpV``VV`¶À¦—¥Ÿä ÷$ c ÷ }÷E ™ ¤r‹crr ‹Ÿ  ß‹÷÷•‹÷Ø LK; ——›‘÷D…— ——›’÷D„— xy†o•ts•¢{¥ = Ý ø”U ¢¢™¬­ ÷&ðû ™ }™yDûÔM 3 ÷M÷÷÷Q‰²½ ËË™Šš‰™ ’‹‘Š’5øˆ÷ÿ÷ö˜˜˜œÔe÷ 11eû BB±û åå±÷ Ô quuqqu¡¥÷;÷÷÷;¥¡uq ÷t6ûÔeûtü {…zz{‘— ˜˜‹Ÿ~˜ ‘’“” ­}¬t£ ¤¤³‹¤r ÷  y£¥¤•£÷'÷&œ û’wš_›_¢c¢Ž¢’¡“‘®Š ››‘——ùøì””÷p÷]÷„ ûûû[÷0û"÷W¢¡¢ ÎÈOG÷Œ÷û ÷ û û4‚„’”© ÷4”’„‚ ®w”rr s÷6 û&&ûýÔ÷* ‹÷‹÷‹÷‹÷‹÷‹÷ Eûzù*û6ûzý*E! øÔe û!¬÷! üÿØúzúÇ ~˜w‹~~ ¤r³‹¤¤ û¯÷yûy÷¯÷¯÷y÷y÷¯ ÷‹÷‰÷‚Œ‚aŠ ÷ ¬ ´ ÷” ÷P ¨ üûÏûyû¯û6óû%÷6- ?ûTùTL ÷”÷÷”÷÷”÷÷”÷ Ò÷ ÷_Ö÷$÷ÛcXð ûû! wÀ” ŠùÀ€ z÷CûÔûÔ……ˆ { œš|zûÔ ‡ @ ÷´÷Ôû´ ÷´÷´û´ ÷. ø<ø<÷ì y}|z ýÔû3 ÷O ™ ‹‹‹‹ “‘–’–œ”—œÖÁ  ÷÷Ë÷À÷ Ž÷÷÷Ž ÷i‹÷4`÷Tà Û ´÷› û€  ‹÷ :Šü˜z¤{€ ………ƒ‡‚ûz} ™œ÷”“‘‘‘ û`þM÷â÷`úM ÷@÷h÷h÷@ ùt6 ûø÷ ÷TU ÷ðð÷ ÷)‹÷  ÷”û” ÷÷÷÷÷à qt{tsožy 33‡3vûKŽ„ ”ûDû$û$ . ÷”÷ þT û$÷$ Žƒ‚‚' ¿ÇÈ÷®ûÉ·÷ û û ûŒ‚‹ ‹÷÷»¶Û 3Ë s¢¬}­ ÷÷”÷ 2 ë ‹÷ õ5á! ýÔ ­­¬ û%ûòtû¥~ ûH6÷€÷*Ã–Æ ç `VK- ®¨’””n’h û*û“Ö û¹Vûïûvû6 ÷÷÷ø ÷- ÷T ÷® fontawesome-webfont.eot000077500000000000000000002154011321131462300411410ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/web/client/resources/fonts/FontAwesomeLP!HïûFontAwesomeRegular$Version 4.1.0 2013&FontAwesome RegularBSGPX„½ì½ðžBÍéŒÉ`ØgÊiSyR‡€&U:²47š4ÞÞ mjÓ1ÈꪭIËPJQ¸ÖõX*iÖY!G½Ô̱Í0Ä*Î-ža¹ŠšXn»$ïXÛ ¢2‡£ÙíÂRLŸ áRDð׉¤p«¥f£" p×vU;•îkœ˜2‘6IQá}-T®yÙ¼I•¡‘züÓûE'•²’T›³î¨Ç`óDæ°÷] YŽœG£ÿš´²&öEá7eÉ.%ë¥:Mt~ñlß«Û¢U@á§ât ÑÌøyŠÔœ×Xó)lIà‡ÊÎFW '&·‘ÚX#–±Ã€ê¿ÍJ÷GÀ~Ûÿšûøe0õsZ Ã+<±ò+ÁÀp]‹eÇ¿Cû¤hì†Ö½[±•­e}jÝIÊprÈn•è#A" PåÈ'!A~B¢³»ƒ¾ömtv-§,·ÑÈ)2¨—YQIéoƒ™—–YA@&&ÑŠ‚P‡÷zÂT.# üŸÓ°ÚË[hÍ°Q‚ƒØœÐmi‰lJbI„J@ìâüùÇKÀtK ”e'Ù<ÄOYšµ©ÅpB:üàx páú)÷ÂA¦gd Pú×­tœ÷’„Ð6‹²Pì®{žbŒÅZÆ­l ïðºkaÛtVµYúQ2UÛ,­ålÇ'kÜuWýÕ‰Aè–Ö¨}î€~Ëm!úxÍü=&À%ä§V#‡¿¸ú|;Lýñê [Ј´"˜k‚eT¨BõÍ}Ö– r|Ç€çOŠ« }4ˆ·=bCú+ÀL‰†’ ©dóšâÄ„O†2EÀ´Ù¬GÌé8²%„!‡'H6‹ƒ0¸ätò¼ rO!Qây…EƒØDP!µ•OÌÒé,ü4¦º3Ù¢Ã\ÿ ”S$ªÔêÆÙ­ù÷º%$Š§Ôa ïœñâçë;øáâdf#DwFC¢6bf1·ÆàYF:CEÛëäœÞå/Ÿ<`ä£ñv¨…^—ò“-ÑÄ>…‹Äq$Œ«Õ²Ö«·Á&»€5s4º0Ó9¶µÕvÌŠ¡¢Ú!¥WQŠJó‚nÖL¦8;qÆO°‡…wœÂmÓ¶¡ †¥1>°1³e? ‚.,I€c^eïDš-SPߨ¬â5€¡Ñ°úö`"a†èùUŽ‚ˇÖ×ïðaºç>Øþ\Éñ·©Üt'ª«|¯31HZ1Ћ†8µ 4È.1*É€1¸  .!@Ó2Ï[]¨!9ìU`ÚÛ»ñþ`ßT?î‡X#©ö™ëWÄ€“˜—‚ÓvzéuK95]"X u¸œoR\Bš‰×³‰XXç¡Q9‚Žö»lWJçdÖs•@ÕXYéõÅØà¥é˜Þx+üŽõ È+ÀnÛ–·âéŠÑ¿“ŸÊ:{’MáÂ?ÞØ*ï=­:zúíx}z§ùp“ç±ÀÜð_›`SG‚%")vÖfèèŒÂFßYŽ_ûuž´ž*AGÞ®4\à@¥tÌS._Š5AlŸtÁo¸ìß{LþÇø_!8¿n6BsgΤ €f3(èBupÌ5{X—a‚ûõ¥ë–JJmèi†œ>¥‡ðW(˜=ÜB䉉KÕÈmtcáþƒ œ²ô Åϲœ²4_e¤dÁ´oUN“ÎÊ¥òéɲڊ§ÁI‰ä°¨I~xlÏ~]¢@ü,µÌßV‡Ò R^4×¼,+Þ_ g„xWÚ¼m³ÖöÈ2"ê~zØu5ù¶>Do–¢Ò†|ŠÏš[•›3»‘ËðjcvQ—ºlèDNû v,ŠöpK Û 7\ „jÃ?Ö£¨ñ^*57×Isùü¢"?½‚”üYKª.ƒ¶oÏH#£t ǃÏ&@FL2ýíbô€GTžÐO²gð^渋¸è…Cp ƒow X ê;è7=<:¢æ€x¤\;jçù¸µs¤ îVÛ[½@*€OpFÛP#erJ¥RîOVH-èä!KUÝPd/‚Ú»˜ß¢Öá/zG¸/þ$B¡È.Is¢Ç@yAš÷FYÉŠ/V7Æ@'it#uvÚEtâ Àª‰rò3ÒN¡4³I4ø‚´jÑ}ŠÂ!4¯ç}™ƒiá…’ê,gÈQ5(®ˆBÀ3¯RY!àÛó¢Ñ²@d°í“f+GØI¼Ø¬x|±ÜwË vÿ÷VØø Š¢›Rèã¢Ep¦ƒìÕb—fQ1é€^»× ql>|ÊŠ ú‚æŠÊÐÏgSœ®iÜ/gû…\yW£ÖSzs?WvÄŠˆÈÒÀ_ojJ‰ ZK)àèLˆŽ ãÓ°hæɹdtkƒ€ïËÊúç¿Á}Ú(WCzTI)gný±ÂªBxÒ¼ÒkÞtS’4¼XÁó{›œ‚‡†^' ð¼ƒaH*Õí3Zƾ XÞ¬§W\lʱ•ÇýHErP†$‘d? ØC÷œåÀ Öqí!^u³÷º?Úp|9Œ'œ˜Ë™Ñ ÿIhàÿ¨z™à ’Ã뇇¶d—1TëìCI„h*'„[*ü¨Çðv×JƒG‹?nÃãIÎ¥ÉÓºà'%¤W¸Ð—ßà_s$58 jš¸`hu7j ##CÖ¤<ý?›‰ÖÓ÷¦(ˆ%3÷#†²ˆ¶åŒ_Úâë±°Z‹röKƒþ“sâgANº8-–ÅòЮ“Ê ]D 4@ÀTgZuó²w òCxÑ„á™òøsk“ì-”F¬É ÖBÒDÖ~NšvoÒ4‰µ:2µèZâŽê5gCÚnljXøvcêAX`=uÁÍ ôæãÝYÊŽÛ]Šê¹Œáœ^΢;‚€‚ª`@aM¦JHa·_æ$ƒVAª‚°ĬH˜µ'̸ b"¤‹££Ö ‡D@ö†E¨X‰åMC¼Ð*–?"ÿ ë$y“>)Ù88€Ö³çâ†RhÀ LȺÑXwË÷%KW\h§ÓðâÚfJ‰ˆä,©ÚÒ~‘:Á¿€Œ™I%²ëxÐ6a¯! ‘4D´Ôþ^ æ¤iö‹J b bœ[6d›Æq¬ ܶ_4Èóä'šƒ.Opc|g¾/PmftD;'b Z”äù[F¬¡a5K/ÕÇ—v0†U%œa,#¨ABH`õ§(Áé2CiáLb¦y„ µ#Êý  µt­´ûAh§4èQŬzç4AÉ9æ{ñ‹¬X €¨ì#«ÂŽ¢ŸË÷@/PøÜ=íí»£±¨\N ï麀«Íž¯ö¸OÃäô—>#öh<Ý7OÄ`|ñÒ‘M‰!2‰ —ølä¼WpvG(¡{fj±`ˆ‡g-Nèü3%á+ì˜1aW!Ë¥å—#¤H(âv$âÞl¤[Uvæœ:r= º¬ÿ°v1¼éâ€*ë4S䆧¤e&câ®Öôâú“áÐlÙ€ì× hJI~vÞµî1ôÌ µ ¨6-,† <Î ‡-¿Å…·ŠÄ@*Ge§Zx £½ÖÀM”°Ô0*]Á‡ÏÏN¤²wÛ $ŠB1U}¡\ÆI*¬Lxv²”g£ÏA®ò=ÃbÀHÈŽF¢ìþ*MŠð¯jøK3…ñùÆ."d¶`7ß‹¡…¨âý1OaÅÆ'îüÐÚ÷%Gc®ß_bùò_b›(m7póË“5¢‹0X.ñßY/eâòJ‡¤þpòj†DÒØêw•ÄH=éö‹Š)k)!,ß—Çøh¡¯Àlæ,/Cyc"¡óÄpH‹¤ÀdèƒQ&}p€W׆ڗ™œÛ…g kÖ‡d¿ znMp‰9!ÁÜ'Àáóƒé@èN£ëÉЇ*5kJ{ê×*“æ’á:9þÂ@ÀŠGËE·¡³Pvs ’ž!Pá)ÂZ@õ¤Õ1¥ ÜÙ(8Vuy1Å¥[øZvKÃgC Ñ¢¶@'™M5Ú#»å¸O‚ #èØ©81Õ´xVuÓ4¶Áu”’ä-thû‘ fruÿI‘ÌØa2ô¥”§¾˜Ó€€%ÂÀ Xúñ«¯)E+²(Xê·‰Ú’¤pI#ÃAçQ)2Ò¡`—¤Á Áä$Dƒ7ϧ¢…³Z“¥z@|+­{Œ!ã6l†:· „_ËY ¸¨²üˆ*.æSœ,›†®¸D• &Uƒ{·/®"¬äLN¨QéTQí•‚×Î_À¤‚`ËëϬ:Žò!™ÝmX’vºé† EÆ ëC¹ÚZ¼¥²r™Ç‡Hšè9qðåAQè>RPöI›+,Å®7jWŠ6ÊÓGÛ„ŽÅ R¤ Eݨ• ¤LÄÓñ-ü2UË„œÖ3-©Ë‘ɲٕ”MwµF…ÄÔÅꈗë#+(‰ßŸÐ )­Ý=*KÅÂ:a /“bÉÏÓÜÚð^Í&{Çɱ~ìv3ÞŠ “á {1¬ÒH^S ¢1-ò–Oìë8Û=âÛRW§ò,Fs$a˜¨—­&£]%ñ¾ˆâªê–/Ž,œÔiýMš¥ŠU&¸ôè>ìs…Lª%ÈH]Ã䙊3ÉzkC”V"qSÊa–‘<É?6d¢±¹×Ü‚rÞ‡“Ô§ìì¼W$É¥vƒfæzÒd@’ði¼Ž¤ÑZwÂ.‘ÖæhIî©<%Ö”ÆÀÁ,ÜI²ùÈ ð»F;cC¤ÆM±£³qü<G£îpžiHbT_|Üqmjø P‚“™ôØzud¶EmÜ$/FPH.;*ÅÁ²é }Iš!aWœa³¡×‰«jA¤_­–­ÊFLœ4ÉS`u æšÛÖÓÅî1Í-á¢Â>k`4üØ{£ ]ľ"´¼DCÆ­îÎY±¥´V!óî]ñwó±B’ -þ‹üOV8TéQ^t»#‘‡§Ø­InHÑ,( š¸Gja¥U> |º^ 1ò€‰lX`w¢•;¤SˬÁ؈´R“è2·ÚKx‹œ‰…ñV“öAoǺ¾ŽÇ^ð<ƒýf¸uv&˜ÁR PSµµÕÍȼ3Ð4&tÏE€¸æ8¬½ì\¬Ã **ó/‚ t 4Ò-ChÈ´gjŠC¢k㿜˯“)9Y3Q:·.húH™_ :ô…MF (0ŒK¦Ò÷ÄÒùáb/aÁ ! ÈñMüÀgߊmDANê{Ÿ°©¢¯IÔ+ šÄ¹¹{ ÷ƒZˆ5×O茲_8L¨kkO¸é‘Š'ïÉ«ø5 `nûGÒëð=¿É$•Á¾¨žûŒJD‚\ĨSóuhtqè&j rE9ýP袗ýºÉ'Ó5õ@gFBtŸò%ÆaViǶF“¤ô÷¦ó‰ S*¶°¾t…R-öŠ“Ù0u ;vÞÙ"ef°tm(@c€ñN€kAÐý ÝBzW  š“ƒ—`ÌlMèÈ=8,IÁ \¶ÞDþó¯ÀFü(Vm7 f„ÝpB@]¡XÎI•A]258.‰à|%"”MxšãVÆC-µ–¬Ë‰-UXå;ƺͼÔN³ˆ*ǘý?‘Ñx7òƒÖæ~G5T×{¦Æ´½ Aç)…ËÄ4Í}a²_Ü4ó¨¥#@@¬¥pŠdVìä X3{«÷™ªdQºc膬aï휄+õÃ(S¡ØÁÙû°†ì vûIx`fXsüì”ù%Þs“> í„çÝ…ÑY.àß zØÁÕ¼D•N-³6ŒàÚ1{mb̲Ǔ&ÝcéëE×iW{m¯äÊ;ÑXØUæ«-=”ÏmÇ 2õe–8ÊÖYHjbI½¥È^+¬I²¼/A‚pfD½û›þÜ\Ë0µ¹Šá^ÖHœ°8É‸¼ý ~EäDøg¼–›#áxÞ4#¯Zû+­mŽœ"X¿ƒ£aR86\ß1\…ÙÐ ˆ.vÝ‹IÅV™>E ±Z|lÝã(¤#lŽžÞ# $Íø)*÷!œ%8W49äÙè®;àÂ\‚jelo6Jà?ö Xü‹6Rt1«œwÕü5 ÓùÜ…ÁYaÔ°+3:‚Ž#î5ø {¼”)F9„ ™ÃP¼f/R\\Tš%¤£l]á!Ä$ïÆŠJGûÄ;×G¯*h¥ÙžÚ At9ј©ÞË<‡ÁÞãaÐ!Ü  Õ&,S{VÈcB^Â1³ƒ8ZR,J>ë„7oXü’01<-’ƒ°ŠütG £Ì^|ôº*ÂjkÉ®¾^Æôy.‹E¡jò]q;S¤è°ÀDK¢?}´ÊªN$\d²i@ëNȦÓokÀȧ Ê¥CWù×(X97ù¦ß†­éÇòö}ÞFöá—~|míÕäF¡hïÊBÿàCYl ;óa{¨Ê6|tp,>¿vÓ6oA©´#,ø!ÁR™¦dÍ#h=a}lXvðQƒ%‹þ_ÆÕ¶E%HS íe™@< 8¿„h9ÖJÎ8\¢²ír×&—¸Õµ/ta~ZÄLö¾â¯Bªx/#mHи…0ÀEAÖ«”ƒÌBZUP=á5l€“Ð> Q1Õ[¯º@À·#©V8«P‰ˆ>`:GÔ#Ä'È éœ ¯5€à6ЙgµªHeã„…@þÃi :*@VbòZ™BóÏ*jU—†À#ü戌NWi¶àèJtxˆÿB™Ec­6ŽkЀå‚s¤ÍQéMŽ£!þ†ÇÌCóåǤ† % 6±›²²Ê`~ä?qPnþVpJò¬¬ë àeõBtÙÁ²…þ5{ôai…‰‰ˆ2IñPB-aF8¶VØSÏ(¸ d3ÃöyˆLÒ‘=ÊnF/hjŠ «‡Z(…òWé° ªÐj|á¡ ©3Ô:•‡ºmI/•·5®MCº†°z»û´…E¹0! Üù”ö9tA‚E–<²NT}ìŒUݗǘ¥¤~KrmgÌõÑÙ˜ød&·EÙ¹dÐlj¹8ƒ™esªºŽ»‰)Ö––k“Ncy+…‘XØ—œ4_bº°rÛo\]ã¤Â‡e€aZ `)™¦ý}|YêC@Æ9Ú(,†A EŒ8͌嘬Ó-tœÖȬÏG9qð$xŽœúÖßè¼RS衕˼Xâð;ÑMDyaô’ŠÂöL%CêY{¿•õC:o`E^2«wDyš„ƒ ¿ßJMEP[1v]°”ÕHÏ Øj•íl—£ìXOõ5¤@Öˆ ’ö#GªýÀê¡ìj³Ú¾i¶Øžs G ¾ÄP¸QöžP‚Rlßý6õ'¾wÔöE«óh…ä`,/ðÉb¯S©¾t³ù§3‡ãÔAoÞ —Çi8-±æö+|`^ݘ&W- ÅÓx‹W-mgMÑçI{R°IY›M«PÊîáÁ2ÜÓY´©Í\ ó(Lðváæâ§=Ï~xÒ²ñ¹ÈeG£á”Øüv  õ½Õ(®Ótµ“ñl”L)nF_Ôe XCS`Y`Ì~ÝŠ©|0s«¡Ë·É¥ßÚ"™\,$-Üh§03ÆÆ3€SžÞƒ+Îں܉tJ¶|n Ÿ]—9ËGp8“ñƒÇÄŽºÜŒÑ//öÌ¥&Ââ;šø*ñiDÙý{fÐÒ"c“Ý«žÝQ{÷áVŠ¹2¸ ŠW³¾†qùåh13*æQn>]¸d—{UhÀ‰¶í¤ÏMu_óÆ¢š4vé¤ó€bÛg) Pç;KD„x‰7Ù1ÅlO¹=ÅÕI ²Ì#²<7åøèË þq3,YP±•i®uIo‚ÇzÓ ¸Á\¡Îƒ1²n$ÔdŒƒŠý5Y‡ó8ˆëH²µ!òò¸´½…þˆ r*/_È„}LJÈvâ8''òÑš·„ÒÀ¢ÜîjÞKTŽ2²ûf”o¯’¿ÙzWZÐW#]Ý!÷ÓX–‚3b* «-d+$ËE%Ï 3;‡½ÂRÓÈ(ˆ:Þwü²w°ðLjÝIåoxt36 Äš /Xº>"‚2ƒ!J}ÛòdC&FðòOŽ¥*áäÁ±¢ÜÀoŽdMQÄÊ%w³&%nñA`l£‰Dqˆ¯†jš¡È³c•þÿ¡¥2cWŸfV+*Ë™(dŠöãÄB=L'€¢Ó-Ÿ¨¸9JyòXÖ©\²³;AohµÌeXÖ"ö?u”´åË([f rn?„ aŸØË\ºioje¡m<„OÙo5BãÉ•Á°­O‡ó¾'Æ5:d«s“ àÒ9ØœC̶ôÆsV[’Y]³ªbK€—•¡B#:ËÛ¢¹,$ñªz&i š}'€€kW D%H‚†kèècNœÄíõ§bJ- à^õ •šÆe@©¬ ’|ƒ0 hú MwÞÂÕÆvxêÑ£AùPѤä‰â>Y滘e eÉ‘ºv0Ÿ(Nõ²²› ÙhÅ%Ô÷£Ÿ}$]-Äÿ×»%Š3Rf|smÖåîIŸØÇ!”©¬ËK®äl@BÔÐ+[[ï ÿ Þ©À?ó,Îñ“锤ò:\(Öïù e~s³é»Ý¶Â!ª—$áxPG.ß2˜Ûõ˜HYë8ÞÙb‚á\H’†KQHã5sãå†|J«rˆË^ <¤´¸§%4 5Q-}b>`G·Ì€˜Rž§½:=™Xþþ_3h{ÂЃ2wbò =¥gŽžRß<,4™ +Eˆ²¥:$ ¨„oê~Y²Rǃ\dl±‰VÕ·ªßœ±}yÀuy%ܤ¾ÐŸŽµvV  ­ÞG´ç¯ÊÖ¹¼‹10¯™ƒ2Œæ5d6Wãg°®àT¹ý#Z·©Oãpœ¯õ; „ÏÒ ÛèÕÉNÁjè(áºÿ_~ó'– Â'xëçÏ ¬›=ÇWcbèɼÇ{^LÑí‰bÍU=•Õ©UZaw ðc Pè’®  éI¡¢ý|´B$Hž; ‚špT•6)ˬaÛL¸úŒ7C_japZ¶1ðp_²¶¹üTÙÄÑ$Y#û—ˆÙØ[¡Õƒƒû£RP+€+PG bEãã@H\"cWUÞñ¿T‰™ÉR·×[41E*Hªfü‡jm:ÙúêH$òxZ"5óú<«”Næ~ÌZ_Ç—­áóëÜë‡}€ècŽ¡>åÇð¨ýñ«/"®VLÌhöýûè95ûO X¡ÉâJoæÓ‡Y²Í?šÉ]b™s h¹R+ùšÊdSÜQÔ[äñàM{‘'‘àí,3sG$mw±·hŒÇ‚ðÀ ie˜˜xÂu«+H~ìÅ¿² ƒ‘ù)Mœ–0µXXØóÁ ‰‚9 ^ 0Àe/“â"ï²Õ°AÆÌŒ™¾»­–‡Ô qègØH’B‡âà!¹0‡@È+Lϸâª;¦ê[R3¦-'£§Kµ9£’h 抡z¬,gÝ9ôÖtŬ\ "£F ¦@ÞÙ9ä’ß#Ò^UUZåÔ÷¨3^Õ5è§E”ì‰ µ:oï{ø󲡘ÈcS/2h+< Bæáo4´öVÚî+m©=Ûqi¶öÉÀ˜1Çü¹BÔzcKƒùOï‹úð/yYÓ1ý¦¾1åùûЇ!ðÝ0:à¢TÑצOkýc€Zú¸ Š¥òíƒe·BX4>ÔEÃÓðÐ×XTêIió|½žã.€%Î÷z™R #1}òû¾·ú…H¢›éüº*=Tjtk'#Pf@´óÃî;½œcTNi6wòq#DÙý;›®FP¸•×ÞY\”èær:0ÎÔrÓ&ÝÂDÙðýS ±HÏ<œ›Ø¸´Æmw¸r]hM8æm ú‡„ƒvD?s~€BÂß’¬ë ¥Âše@€½·,´éjýgëA„@ów¼¶m†¶mž¾Þ:1†G¹óëà¶É‘žÖI‘¡¢<ìÄÚ=cé.»! °”¿Íƒ¥Â;P‰€€ý’èŸisqM pqDmÁ˜P8 µHðÂŽTF­FCI?°_ŒbûtfèÌ¿[¾Öù¬¯íÜ  ¡©A pKª@ Ü”³ײr䯒|:™USa›ŽC!ôƒ%X-IH¸’êKô‚äzOÑh“²S„N„fg•<:s‘3í³kW€JäC¤ÌÌߦ^˜ ?ÁšòÃ,²éS ¹m´i²óÒ–¿B-ÚÏq´¥ç „€5N(+Dõ†-·Œ‘œgšc]¡I÷'©LüÅØè™AÙØ!Œ£ŸB–XAh:«˜>>¹c³ zj!ÆÁźTÂ0_$½jx‰" ÄkÆ|çó=Ëtñý©©ÂÂ3–´¤õ솀mù(ðÊJpFX,3Z ÚBã; :_`ÙŒ¯‰¯›þë'ÔMNÒ½W§#ZÐA÷xÍÜÈ\h§yõÈc,›õQ¨Á#uÚyðJ5gZ³cq-yÝžJ­v.aêZ‰®¼ƒ§/ðsÑƵý¨ßaØÌœ–¦j¥”dd«Ë$)ã±Éˆ B/myB7l‰G5¹ø¿¿Rz  )%ÿRÏ<2ÒÁÒÙiC( ÝèJ æøABËczž‚Ç! L9i#/?ÍN%\…Œ7¾lÕ@ý‹ÙÞÄ«M¼L7#‰N÷Δ wÚ™ÇQµ¤N±½~5F›` R¢&p,¥E"f¤Àµœ#Kò Um8oO¯!²Ù©eVŽfn bË°IÙ½à]¢°ß.P }HÅL,÷L†Ã1hV,“'ÿüHTEö5¨„D¹00])#h[LDõ¨IÏAoƒwƤIÄ8l–$eª¬Ä¡gÕâA“@"›?á‡u‹Œ¦éx@ˆ!”@íZ+´Ä¸{½ƒéò$G#±Y&K®\^Uu9+ó Å·ïݬË4)a…9q! `!>hÕu“ˤ EÑ#‡æ,$§!õý&(DG‘‰cˆtù3ËX‹HBæ°ðÐôÜš) >eØ  mAz+þ{lGnÓf¦"ôzÔ­C]à” Ðo›GÖ6æJzÓ\õüi P†[À-pÊÃ2tÙ¢¦9|·˜­|´yèÕ]`]ëùkò}w—n6t¥íu8w¯#_´®ì×C,ôêIñVú¬E™=“@DåvËä%ÅÆûðÿŸsñÝc¯]åïÁ\ ÑåŒÍ'ôYÍ­å—zUY•Ùi_TÞ·hߨ+õn‡º‡\KãïÑ@“Þ‰yû¬WÞ¬†Ü9`ËÑ) †ÊÛë×m¦XÞoy ŽŸ>ÿ•0–ojl¸ïMŸ ªX”=S4wZûD“û{¼؆‰Óý²˜f"âùò”ø‚žôB;ïO)ôGÊÈ"Š€]5cEóü³sèÛfõ aõUh!Rc{fjßÆ” |EaTMZd)=jÉ„xƒúfR„F™Áí-ä§d°ó¤A<‡ …†ºoצG¯Z +Plìzì˜:ò 8L1žžÃßb¦š‰0XV;ƒ±LªYš.»øºBf™?.cûŒ¥qy§C2DëVR;v.Þ”Y^=l8Ý¢„~朑¸«dh·«FdÝð(ÚØÒ±]I‘kïÒ yjJiÁ¬ÃG6ÛN{$uïStÛ#¶OW@è…Wzâím(…Èöž7„M"‚‘LÄ dl¦h<öž<„Ç 'ØŽ ‰y‹˜@s²xð1É7ÓSß©ú<$% zOQ®æ X23õpù…jrIM"P`:»Ì- È%$ MÂ%;vƒÕEJÒMŽ“l3 Q¢”Vg•—RW‹øÏHxw‚ˆâÔO±–G‡ Y¦–_"Í7üaȨ:Ë8ß·Dñ=Šbj=û"pjŠ~ šÀ;hf}@:¼Àeóp&ƒifg“™­³&”­×yøg;8,]@òsb Ý*¾+‡Ù“^|‚º#â4?‡‡“AH±ˆÏiU^õµ¯-q-ä®EˆÖTºè!üHŠmTŠˆm˜ s|'Ñ´&lGB‹¢õà4b`\Z‚~´ÑRÖ5m õ$u)Ø[¨– + ŒÔˆsŽ‡(‹—-:ãs"Šµ&—»ÈÛ ñ°ˆyà “r2°¨Ô‹7ÁH ò0$íx†˜5tB¼ Í…Œ†ðÍH”MÏ¥«{q<ú9WhHïÏ[Œƒ{àëõD–‹5^°¬4TÀ‹ZEQÞöavU"ãÕb¥=Z=†¹dºq“æG»Â”Ê€fh{bOX¬d‹ô¢Y-·¨—N§ækì­è€ª_ݯ<+TÂ…ƒ ÀÙ½]d»aùˆ‘ÇjáT–…Ì­îÇzlI~4ÂGGz‡%R‡[Le$” ÐÉ€p²Æ¶<ñÍT7®Ú I¾jnHË€HShvž®“1ë“9oD›ÉÒ ç*zò2mÅ‹#6y4äý" ¦»¶Y°Ë6äØhf?õhÙÄV '¤ü%s$xF‰uµµs0-4wcîQ9†½pQ§(˜KqèÌNð’/˜ËxÄô7»‚VåQ“Ý Øà[~VæÁ „‘¼xV(Ê@¾vuôŒÂR•±©Aè+Íqd®èšJJµx`q@>ÂIÄ_Á0L’ôqeµ/£¶H¢ýæh‰ÆörjAo8/ÐŽ$©[œ ¨”´<“· äœ]•Œ{‰¡cw•Ê7–ˆ¥ÏÓ¯@ºè\笶€?/%ª&rbºÈ©•zé)”&›ñW¿hÿ)€'n¤·ü°}£ W7]Ž-Aј§‹ –•p•P¦ðJ¥úF+š®Qµ Ž¡ù/ÚŒ%Ö÷˜HUÇá“RY@"T€füí/Ì‚Ïx¦Ú9ìÊbì-n·›P\öy/t4Q6€|D¡¿8]‡„9!îȃF ÃÁ  ï´T¼J‚ë/ÎÂÆ)6ÑS!RÞlµ´ÂLU,˜){‡<Òùõe‚JlŽ9ÜH—,uøô­9yœ j`Ùt ¢òíN2ÀÐe5,4ÂLýßUT4ñ¢Ñ›åŽâ¿Aeº€VnWº¯Y¡+x¨©‘#sl`åÙ*I!ýgsÅnl*|©ÝÙC9!˜Ëó€î`ØŒPðTòGÕ¤*EÁQ»_­|æhl°à ½+©$Û¿$cºrb¸˜"\oÜ.Ûõ¸ ˜Œ8ºÍ„|å]1 ‘Sxþík"Š®;Õa'2¶B…Ü!Ž‰{Hð‚8ÑóP2öâGÊà(Žívvµ;R>D³zõÕE¥bkÔ^(2¼L‰s…ÉIáÑ •šåŒ$¹ì´%Œ1TnžŒ#/œÃQ™.Nr.îä­T|âáã4óX"‡O%z37 ø@§a dwŸÍÕÕÖ¥NZÑœ"– 9o–ÃSÆnuŽ‰ QÄ È•*>i°°.káÝ-µ¬AZC€kÅïÈVR7€À\1ãnD” ènIMš”sŠd®AùW=úU©Ð¹ƒW²H5HǨ˜IˆfÉl};?‚˜Ú yÎ'õ&ÐAQSqq4z‡ž„ ÃP¦lÄØ¢U>íÄ(é™=GÛÈÐ ‰H-À:ŠÈS¸SÒ9ªQpC/2 á,š+ Œ5d͆{Y”Z#ðþ3’`p4Iüš\`L0-ÑŠ <ó$’‘cÄTO ×Xš!ÍP!Ä´í᱉<}¶³Êqä"ñ-{¤ü0#¼ï²SfÙÅ&FÐŒp2´ž˜Ïì Õ¹ü¾T<Ÿmß7-¾ÈZg.¿Ë'Jʬ&ZCFÀ ÖD11á—ô>!íÔs·w7 yV*LÔrKy”§Æ8”¡+Ý; h›3îØšíb,¢‹žŒèµF“ ÍZgÇm3]ý$9)»5nÀOOCsÀ m˘ Ó§# í‡îÏEWÀY^„wN1™2—ãaí÷¢ÜÒÛ%dQ¯^5U|ÁPsz+b7–—ÇÈõ‚9^àþš‡Ë’ ÚôÕó¢D•Ò)Ôd× "*êŹô°:Ø/šE!äç0)ÞiWð9vÅ¢˜±…§¡½+ ¦Ç¦\ó˜Š6'ØÉ„Á>ñ5^!g_šÒƒ-%7ßfBG3‡{ÇðÏY=‡|@óðqür„ÝäFq|¹Ù^dÅ·ÖÚQ4§OÉá…˜KÃü˜àA{Ì‹J¼,DŠs«·§bù–NóÀì=«o–§Ü Þ¼¦ýx†ª9À±U+ÚoCÒðìœîÌÖóu¯‡N(+:áéœTÚUne³Ę¦rÞÍ:@šc~Ø`HLŒ?‘á%W0ÇÒüè¼R‡E0`qp ÕnÝ$f#ÝÈVc…k<ÐPC¥dI½ ‘ Ù+JÌ6$ j„[nħ ¤*¹+T­n¶ÆˆUÇvÙIMÅ åz‘ èÐm’ŒÔô)Ó]Ó™T¨ÞRâÙ\ºT»°§g%u¹áœ•è¹°%vS9´ˆXÈÜVô»…Ã]Á! ’Y#@ÈóÕi¬Rãï¿$Á|"Ñ¢ª<@>6#‹Šxîã@âÛ)@“,uŽëb £–7p¤d¼ûj t]PRDÀFzÛDÄÑ(ë/dNˆFÈÛ,ªW˜%$9 ûÃúÅï9 ê ÔνŽ(ø¯! $ñyO#hîÀoÎ.ô[øÆBíùlÉ™yj·šMBwÑ–'%]êÁ/…Úª ÷x„­‹ãŸoi绦:AØÍÞ@YR‹TÀwØ°^,çÅå’ج”W¢ Vƒy|"VQrƒÇÁäöÉù —„‡gýl¬wµRèÒPþØnªXòëKèós¶Ä9álwäô¤Tdz8©Š’x]M_1Æ4j –­8(:í¥1‚ü>¸Ò²”ÑÈ ã‚Ï|¾î@8ŽÊCM-éƒì>µ/Èý!AšŽÔ0¨L\þCo4UÚ[$"ëB?r[æ–‹Cez–`¨ëÐæÎ(›ÀÞfcQãH êšJLÝþdj¸Ãί‹;cIfSW(»Âs¢ø° o8I¸îvâ&Æ:œ›®£^fášÄ^h+hõæÏ¡Ôp%ÐFF2ɼÉÏ(^ŒF ž,ØØ̇X!° —õu,.A?Ÿ‡óeS„xÛäÕòÍwC™N´}hι±ODǃ'–ìWŽ<™åÄ¢Êc¬<ëíZ‚5¸¶h­RißñªftC$ˆ6ñæø¥~‡îtˆîU<{¥~fÍ7l Aé¿´[Sbü?uøâ&ßÇB Iì(µ{y›ì9íÑ·ËOÇ ã¹ØÍZ@™“‘4*kÜNãmÖpu&¾€|Wè>w¡®GÓß9YÒd) rp||ŸÏƒáúa–ëä9¨6bsråõÈÈ&g”LŠ¨=ä èv¬Ýy ðî"Š¥hÎ4t'LL¤ üZ€-ªDH­Å#27a?Pr)c¼CJžLEC‡ìäP‹H<¤zQBèî­CâÅa“„‡»ÒDÇöÒ®èXŽ |HK…À ÁT3ÍCöê³ÛÖ„À>¹6𥽕6àMB ݶ ¯/ 0‚øÜÃêS…Øì!ž"‘Ä´7FŸràá0“ªp5)P&èçN8?u@`]&žÃF‘C'_b  [PgÆ‘ññŠØ/©‰‚KJè%\˜7^5èº1›úbÛ¸¶+±d——ÜÖ뜯ëçBÌ©¿ xTIÀbû¤,ó“Z8!KºŠak'ÿòµÍ¹[²Tö{䔋Èɤ¶!‚\”^²”#*þOÜ$M‹TMÑ|hƒƒh²\QV ìþíÄ‹y¯z´®çij¾àäpÁÀ4q"KàøˆxœKÏIØ%XÄòùÿµŽ©%×Ðh›xç=].$¦cÖx‘€t0Ñ>3G ‚@!#âç<€4‚žžOå F帑‘áag5Ôû£ã…b,òÓÁ\p¸Õ]ŸSÜ/˜ÌÊQ@&Uˆíã)†0œµùs~ëEËòj/N—‚ªr[FZ™üæ5êŽ}-6…Ôy5¥«ÑÒ¦4Û“®ÅqŒK˜€8ê2ëa9Ôa.‹ºUøÊš ´Éü)6Ô$õP0Öüª÷óNýE44Ùf’U`ƾjKCAJ"ŒqWq.Õ»¼­!;4〈œúù\ÝÄç žÍ¡ä&¯øÜk•êüPÊQlÓ8b”2Ü¢–^q½:®ðÝçã(f‡ ÑI0·_Ï›y†ö[˜ Ž²D—! ‡•—ƒ§žHŠõõ©Ž@¥–M@Å@£l—é«\ ª‘ܚبXìܹ« 5?– u{½²–œ­¥ææ’.~jÞ£`¨š8Ø uxklëâ¶Í‰§—J“µ-鈩§"êâ²1ëÔ|é_ñL¢ž³p’ßÃ㆒°È½ ÃA¸ôÌž!ú{b¬/ ¡!EhT5M Þ#Ceža¢–Æ«UuÓ¬áaåL\ŽX…ö0ò]ŠÖ=^‡KdZi<›Y³!LޯŒm­/Ñ.çÞÞãs\ ÓÄ ´Bãà ¿ ìÙÏ1E£/Å!´Ûý¦:D¿é¾xp{!wæEl5Uf CXÍâšÁ^L°†ß!…áÁÄ4?šzÃEŸ×­|]\0Ÿ9ÙtÇ…Vg*æ`aöRÁï…D þæ!}…/Pövº!ä‡[Q ‘`ß=…ìšÚû˜# 0¹í¤@E†z´‡ç;ôB.Ê0é·Ú04?cY¥¦ÈhÇúñÄ<2 ÛN‘jfõEÓ³À2¤qÅ $ú¥ÿ Hg@”7<±dCcIÈ?”?:”Ä#qÃÞØWìÖ!äJ@ò¿â—d…æ±y5÷(ÕËuÈ2þð½bîÀ ꉔœŒ“­iÒQÝwç{r" ƒô(þ”æ¦àú Óá|q´jgÐO’=¹˜Î±c\ëÆ–Õõ᧣‹0µc¾ª€ÊâVäÎÇ-—ŽÔŒpJ Bšh[W6-Jer÷=E°ÒòW~Æ>eíyœ,´´_šŸçàD’èùlDú+”²#ð'‘#û"¸×DäŠKôÁŽ|‡ tPHbÔN§U³¸U€Ð¦±ó¹Úqk|ä­B²%J¨§ÞP¡;'Õ¨¢iQ–=1ë°qlÑÃUZÀ“ÊŒƒBì(ù‰‹ÔyIÄXîæÐkô€èe#ŠqÇ“¼õ°ƒ·©ÞélxÍ_·t·Zá-NÞHÍŽ_ä”’ï¨ý¹¶]^äÇtW̼;…’t#gÕCgœm°u ä³I²t2¼h-T*¡ßsbø@4qà%üÙ¡ìA7Ù]Ëþªvx?"T³0ðkŽ=&˜ ¡O»>E , i9° LÈl Yë'k¥ ÖÊ~–F¿‡uf u]z¦?òƒ‰X‘…}/©r¯Î”*.Gpô6Ï!¢÷Ž ŽZ˜®3ù“L· e–£úÀ´’”Ç€ãeXªÊæLàÕM­“€ç³‰_YÝ,ÐÊdK§‰5Û€ž‰="„’yµÙ î,ýH@ÄXÃ1 ©aõí­ÖRI&«!%4 õÉô6;ƒÙ@(Ä $,(ÂÆ£8>ÐL¿`YÑ0w"T}æ%´ÛÓIªk°§voë@tJ’ö!-†}UÙ\DÁŒ&¹3 *åL£Ê8¥Ê[s8yÍr󇓺’ÌìýæP\Úð™Ae±êlì|º=Þéá¯õxrwn=†W%`0v;ÈCð.!v±paäÐÅ‘@Gyûƒ»ÓLÒï„S6á"ÍPO¹áÙ|bæÌë±'!ˆÃuy¬ÅRTO‚["%¿çŠO`¢Èrõ†RÚé£XÕ^”ähèh2ãl5PÍx•3µE~ ± µ±JmÖ´§°qJ"YWbÊC¦ŸB¾@÷$U™èÓ;Ø}øUïÉC°°Ýƒhci‰œ™(žCÍ6ýóðf#m}áÞ€`U+‚³äŒtÖÌ·\Ñc0¸ ìÕ0è(«i¢ùrðƒÁ”ç4ˆê%©¬TútXððy{öJ Ñn2f ªã¤QRô‚^ !'<+¸ šòž}@´øz ðx¶B JÊ;4eÄÆj(™ÙðÚ5Ù«‡Ÿœ w£ß t@ﬥ;ˆŽ¾€|A¡“ý4ÁZk¼Äí8bž4³Â8 "X?ñ"‚ Wr-þ—9á|ቊ(í0!ÄÕ ’”ÀÃ……"oèùo¤´=.)jÈ3ô ó³Õ0$ÄÕq¦pwP1¶DŒ„,d Ü ºòeή‡,‹¸NCõyãqÅ÷O ‘LsV‘ ‹¼K‚â˜{p,ÑI/ìÄ ÔüKá¶ÙGR x3±A–R,Iͤ˜¡‰Ò¤ô鞦…Qüs•Ìü.BÑ(º¼6FNVJ Ä] nÚéJì¡EÀ÷v!ßPv¯Ü0Ð/>»&ÅÝ;Qö%„þPFL´—Àº`õõj.Ý楦{Wƒ‘©·Á$:ß°,Hœ ‰vºýk—º8®,;¾£-;wÓuØÀhž’T³¢d”t\ÐÚ%Ìñ~57(Á¢‰dbü‹ï-¯ÄîÛ¤ue?SòÁæÔÈEY¥=ëlg ~f §päLŒ÷ Œ…ù±¯ëª¤S§ 9´ox„,Bï±_¾«k@J#Š•Ñ„A.›k0êDŽDV ᇔÀ0¯Xx} ÂÇÚÊq§œ§ØÁ Ò—´hÝ9À±(´Íƒd|"Äâ=r«ægo„š¥%'„ÐÖX÷?ŸŠ¾Æ4ÚY§™ñGáàîK@”äL§Û‡ýÅÊ·G–ƒ`£gØ)ONSxï-â§éùþ;d² 6ÉŒˆe¨}«ˆ4Œˆ!og¥\±qðpö8o„á÷âfuD9(0‚0ËW‰¶¯¡Çò†x}«9Ž¨yéA6·j€$Í:L_0À½ÃM?’ÂÈ.µ¨x³Î¡ø¿Cwäª&÷ë%=>ÄXÁr£íÀÔ²¯ þŒ ÆL_Û¨hs*ˆ9•d úݪu^žº!kgÀ ®DzÝð¢,¡&ßšolI çû·¡UûTÔTŸ3Àæ®+ÀÉ-{z8oþËÄóWö“6QWbË r¼w’ ¾„z8 ƒör¼æy!Wç rGp¸I®ÍèÁC!™Ð Ül6Â…ÎB€.|g…ĆÚ!Ž—·Hën?z×vF¥Ž€eßã5(Ÿ‚Ý—Ú9‘ã»u½Øzê¡E‹õ&”üúmb:šØŒþLësâ)ÒÊ¢;‡qÙ49^#ðAw÷»UïüA×cYʯº=M{NÛ$t3EEpÞ`Ó¨˜e}™ÆnÙIEÐ%Ój=Ë·àm<…à>öµÃ4Úu¢¸¼V¼!îl#05øCÏâ:è¦ðNA?Ù›tNpµvèA¥ðè¥Kj;6àÒ ×δ¥ñ‚KS?9!H…¦™ö æ®,7¾VžcâõϤ8Î_ \ËE¼ H´en½5@çV2-íwy}Áºc¸·2\ƒ ØÔ,$ܼÑ*ý1, hï7€i#•„ÞC®6׉¨ªÀ¨aÎÜ Ã]…q1á|S‰cyù¼ ðx‚_H`Øü:lÐß Æ *@ñZØS¶Ôšc‘ØÅ°„”¦†ôq,™-­SX¢mºÍ.Fî,$Íí*´ +®F#‹üÆ"ñÖº—¹HajFˆG¤Ïå ùÑb%Ô:J¢<ïÅ.ˆIÀ ÏÜapçÍc+‚ßPA‘À5]ðtSKèƒUÇöQ‰â –ÓÇ FÖ϶#~ ~áE?‡!l˜O¶/?¦^z}êJ@úgäAžsñ¾4ÀBûjÅŸÇtÐÝ`ÐMÁQÆÓ(QàÔ/C$Îø‘ýÂK˜$àZÉ¥E$â.yîÍeÉɹ7sÜœ…DV# Räì»fîàh™¶W9–Ã'雎'Å î9°\žì²ÖÙó6'·Ïˆ½€¦F•²«€üY5îéüQòGvxÏ ®-¸é±4b.äÎA•v‡’g?Ò=Ìéσ#_§¥Pÿ{8•¨„4åK´a‘Ù@óØ™®W÷Mù³5'ùìœVÖ„š‚yyÿ®×ƶ±-êaÝ€¿W9Kø¨+t8.X|š U˜]Öy"Üìµ)”Ï)<.3€ ´§ …É(^ØúÒ—WñqÒæPæ *c†Ž—îµ™)ü_wŸÄŒr "Öÿ†Ü¨ÉRND‘±¬HdðÉ™?·".’ÁtÊô±ö¤üQCÉý>gωiÒä–YÓQy‰òP¹/G(6Ö`-00 ÕÝê‹ ÌAc²L†äÁ|"J%ƒ à»9ŒŽ“áÅ,FõC“M°?ÚcLŸ‘—;gœ¿?©"Þ‘ƒþ+D£òõ€* e@â’‰[®JÆ©ú•UÄ(ê­Ô5TUUDéÏŽ ʨЀ€‹;{#ðñ.3$ »í¶SoáªY2aÄç¿šÍ)äõ3w8mý;Jdwá7ǧ™tÍÔ¨Àm]yƒÞËÈÓeÛ Øø·!ŽZƒ8œ†4Rõ)¡ˆUùz~3GC²mÏ Äá§Âè¡$uduV++ÂA p6‹6•²ÆNèŽV&BØͺW²(d™NӬšGÂËüiI`«c?Ø­zþà-Iù³|,ÚêèYþ? ëb˜?Ê=›[¤ÿ‹þ×|i#Ì™ÌáW ÜÕ€è:ÀCâºg?ËÇ L¸zåN7cÖ—™¥—[ø—úÂ$î&æ¡Ow “L^Lú§D¤ù× ¢bËäv¡Gì]ÔÞ”T1`˜òá¸fM¾> ²µžfòØïð-¾ÒŽG²Wû—}¦L”§éx8 •Œ b/yi·?N³õ“kª¥—s¦²ÁŽ—!Å Éij‡¢:¬á˜±.{àbâSSÉ þ ®¼‰¨„ ƒë1ùöeW?F Ly¹ÈfìN(Ô±ø+cŽ%°´yã”q£”\3úrø d¥<¥?wÜZ¾êA–Âß }g@A€ìhF͜û·"¨¦!<Êä˜ì\‚&bá6¡6Y bJ#¸ ¦"󲸦 ?˜J¼e1LG­v@ð?ÓÆ¢óø48¿#œIBˆìñé˜ÑJ}aš`,)fåÔWåÉ"¸Õ“q$HzP!rŸ•1O}`™,l]bŽj1UÌZ~†F[Ñf;:Ø©€¾ß_°¨zø-“YÜŒVø¾D×t´J‹1‘WØ’ÈSrU 5¤8  ˜£'‚HüÛÉp“÷Ç({“bðM%¼À¥– äÁéSãæ±òA¡-ŒÊ$4N)®_Gdœ1Œ¼@KÂy`'­ÂÞ«˜ó7À>`.ái—t—HsA“ÏŽ1¨%¥r€Ãi¿³-ñ¾¤2δaV–Á±`ÃIßùö zQ¿<ä›8ÌJû~e5Šfÿ %9IM5Ù™°–¿Ÿ+MÕsN‹šD Œhtud'ë¿ð÷»0ÿÑÝ%0­ŒNW|ÌëQ¦ ŒW€ ÷¢ÒÄVài’ SÔg¢0hThõѼë³á QƒIK$°¨ØÿŠ!½a{#É¡IZš2l Àé4ľÖo-k¡+ãaÚ†í’C'+ά8µV¡ãcµ ;xX¤ÎîÚiJê!¢NÏÇ»aô€àöN —”[ìƒd?¡Œ½-»+ãçƘŒ¤¢?A²<ïisEð¯#Ø"|r¨S}¡«€—.gÄHï:Ž±ähü’+slÊÛúp*åµ?¢„.*®Ç|¸ÝOÕˆ]ó„ÐΗ"´Eÿ¾§=§-¼— ÈÌ-¦6¥þõ\¬àþé`@lD}ÉÇšŒ…â*-tK+¯ÂÔÓ2€ŽOåµWÁ5S§uKr_È´MhM¦µ¼Ê¯DU¦Õø8¬Ô&˜7œF¯éo P/|ŠÍ>D;…žáŒñ]Ü~Û ó­ÃA*ƒŽ±/'–•™åyNµô¨JÛÛ½V¤(z@ç¡O~Q!I4cl€Pðº?¡˜öîuÿÈ4-2t[8Â$¿É6›P0îF2ºŽ¼†ÇÛ ¹D`—ØÅÐÑâk{§æ2ENhú ¾˜¤: ÔsÄàÁM î¿«@vÐNjÆú7ð²A†úÏ~F ‘Ieäp¤Z¦Æ‹ÊG?JªÖ9adßø;Pd®ƒ('ÈÔ HÿþñöìEӆȺÐÆj±Ñ<çX*GõFïÖ¤ÙŠÐrʵàš/ŠãÉ TøNÙÐIè*²ud¨šžˆÝØ™ÿ—Á™áï¾ÁV–݇OìÖŸlÓÅJ@Ã’xD¿@êia0ø“OÑ'ÿ"¼/\TU¨Uˆ“^gõàaö·5âZ¼ˆ%û:P’£ä«fͪŠ"tÈ–ýQÈ{_ L ™” œŒ äN+Ä€c4fq´‚“…°*¥KÌœèx)Ê£è… d/a$X[{»Ê7ÅãZm瀒µ|îun ª!»ñgp'›.î@AßÓ×E±…Æ.eµÀ6P'ˤxöØã`i#6o¹DfÂÝÕ¡,—6Ć ¹_“@b$NŒŒC2®5߆Ç~RQ÷$‹{|_¡‘Ùt.!CËÝ+¥…$Z#¸ñ÷| jØ‹DÏè<2e22è—-'•ùË…Û"ˆÂ à‰s®w‡Ã>"Ú Éã?dš†9…Ÿ@,/Aõ íC¡Ñj&Širˆ3hM<€r ±µ=¥kƒ¢NN„¸¥‡b3ÁXŒø´>˜¯, P¨Bš’àôPyiQÄ‘ú/èu…'Ú{jfA@P†Ë#Ò4 •4/Þà|öG®û9›‰Ð öDÐâO¤ök4’n*G%1:‰({TI9‰2á\O#€9ç@Óy xEøÄMzY»šG ªE¡CËè_>ª”ØÂÅPn„kÕ%æ¼( ܘ­Ðg-®)SPá 'aI™…¾šLÓ/Ò [r5ÔÔXàø±(±Å(6ų÷͉d,T¬8]m‰f€àÒ Ú w)L ⥅Ïl$341·¬ÉÌ jÅ’É’ ðgë!çºe:D:ÓRÃêÑ>` ÙÑ@*#m>bÑ~R ‡â›·üëÓ¸OÛ½]›¿ÄàÞp%¬•‚[+º~B©gZþVÒ¢GHžÞý>WÎ Cu¿t2„ }{6hà„¯Ü¶¯ÖÆÀå¯v K€d”îbðhžî*ÕZ ƒRèȨß÷ˆ{ð @õŒ–ªÞ”‘špczb`—he’ÿ\wócÂÊ¿iVl–|¡6ˆS'¦bÝÓ¯Ö¿h€Á”+©Žãš”Ç€Á3Çî ºÌ$ºdGú…:èµF #¦Ý–v„ŠO®`‚fm­GÀR<$TºÔ·¡ øÂ3†nÓÝ… õ®Ü0p æA´~R O Ã>ù‰øa 6_%šBÖêÆ~,‡YÝz=„Ž¼)E D­"òè"t´ùX=ggq!„rìéQ1ñe3H?½ˆ{XuFšDût¡.MQðqHœ†CXž—âM·qGÙ3™äá:qCqâÍŽ) ÉÞã¿ø{UñHxKäNÂ\X©5e»˜×Ns»¹Ì+D¹¾@³ xHò6œÄ—²Šê`rE>Nìaw €hB³“åø I9ø×L’":‚™^SøÀ¬m‚×÷‹ÆŽ¥+–nˆ„×ÊÁÿ/¥ƒÂ¦oØñŒ ž­¨ü±!„Õ Xï“ôë=TȨJ.…*’:VËLŒ] %Œœ2E^lOÓ~Åäµá™¿%D™+“ha@ò;wµ¤&nú Ò™ ‡]Óû•U¢zET#µy‘Í èÕMÍ&Îé*.]þ&(‘g¤øI ŸÐŽ±1£É²Bûˆ:ŸnC™‹Â"ö!žÑúûh6Új4ôe‡5‘a`©£ÅGF´<©…q´L2Oo,0QᘡºA™áp±' änb™ …-CH–™‚–ÖXç|ç×Ã|ì{O¸Šq5Niûy»mÃãôTšÇlÖ"[Å«hDsWIÎÚˆ„ü)좹6Ëï„Ø47W íÆ Cú¢ù*¶%5$T…œÐ#º´tdwBÚ³Ð]“xòƒD_s‰xû Ûâ뀗d ÁÛ65HËéÕèÊ(Ll¹Á¢T&Åeœ~5¼=4ûßâj<ÍBbDê1R ´œ5î/$¼<GëR+ÉÈtnrˆ´Q—£B^Z¬y-_Ëã€CKa {“Óo aÌÒ\͵„°Â“ 7 w C¢þòR’©á{UúŽSW\ÖFöz9m¯Ù¬"öequ‰ŠëPG¼|ãj°$‘0„áHÓÌS×ãµ…ë±Æ›"üÚD¶ÓLø³·VH|Ä«§-0Ü7É>Á8Ux£nDr?0¤Ôûˆ—a0&ÈØ]$ç¹VH:ß'aˆà9wÔÙƒ@ÑQ>œ6v˜˜rÁjï—â[­¥º…ׇ63ZäPÿÍ©X)d,c°}bõÂàå ¡!EvkVHÁP± ݬJPGY$‡©€tàȆc–Î]cSd%JDB<›EC¨.Ö%,&'?ŽÀ&+V"¹%€N½l’ì³´bKpI×L0*µÐÉÿä -ÐD­}“(h°ˆ3,\ýZÌB0•,r±òE¬’-’¿+é.F RéQHZÐK§å„ˆ§aèTV gø_¢5øôäÕJÊû¦%Ù•˜ hj lï×!‚qR4ÉÞωyvF;bÎq2UЀÐ÷/ø5ˆãm§£ñµx~WLÄ5€<•ØMT þÍ4 ¤¥˜|àˆ£D´HÑMÈ 7ÜVŸEš‚ò”Ù$ÄúÉZ…RkíŸã1´£÷[>v'˜s#—•‘F',¦è©©?½ì‚Ë! Ѹn&5°@C¢%1 •¡âÄàÓJTË=øÛ%¥Òu^„@ l~l‚ú;VŽ‰Ï&èE¿LMF2ˆÌãL­á%ùÍ‚=MùYº¬ëÛ2nNñÁxT\jç[òJg, &>PÒÐ4xرúÍæ>Mûýyà\lÈGkÑ÷|Îè’ÛbdúÏ& „FNØivàmW¯…àxŠÛõúè¸ÏUsÊÊaìjå"x xLÑζpSL¨Q6Âò±á$÷›ŸL+rbªÙƒ›ÃU…ð5¤]`0|D¨ˆÜV!ˆ@ít]€…ÞH—Öë•Þ´ ô½à'§•ô„ `q‹—Èq3t œ~zÇÝvüÒÞ¥K1Ž MÚ‚~ȇ%Ž¤„P ^e–Ù87´Fˆ"‡wÓwÐø¡xs[‘tËXÉBm ¸ÔSø›Š[Ϻo¸l˜âeЮØ!„MnB?‹]k² ©t¥BS8)4½º6hK›—jYA=-Aè³EqÓ„‹dä࣭0ý³„¡â¾X`¬ƒ˜Ò’M@™Ê¾ˆÿKÃÌ” ÓQLNFÖ‡ûNbAø .¾Ri›£>·ô¶-eÚ  œŽÙLŒ^nƒâz dÛŠ%â)ÄøÁê.!zà=ÜÓ³î!Ò2»E!cEœ »1Ìd5Xy a Q…Øܲü¢dU{q>Ù@"Õ cÍ0 vY²LØè̈^ê¬ÿ„s V|  óR[G·? ¹ô„WVsfÛ'_bØ^Š¯‘CFXAã3°ì8¶D_ݺ“E -–ƒ‡¯.ùˆæ¤À¡Om„ðqaÐR6Ø/—Àá…aîÉ@†èëô¸¬*R"غi](i$ô±{r>veí;õ™ú_¶ÒŒv¨GËÖz|¡öâ×N G]?°ãdø g¸.ß˪V²¦p°¡IÒ½†]`ï¿êc¥ÊÒÎ÷tXºÓbï…ù{ _$|+âVŠ>ê*GéÅ$Yº‚Æ>]¹ã—Í._ mÒÕ¾:Âþ ®fY3kÄÿ¦0­Ën§EìRž”-ñ’ßqoÁDK¼ð›ˆ@ÄEPRúþá³ÑP¸#ÌDÇA)ðIê£.‚)©f¬îÓ¯I+ÂM0,"~„9´Ô….$ÉÍ y–Ä-ã9r¡”2/-RtÀsÀNÇŸà‹³~i tƒfx ­N÷L 8Qý:ÏlgÖ9¨ ï”Q2÷&.k ju~-@Ái: U­Iܹ¤)E$š¨Æ A !eCFfaÔí ÓŒ… .‚t'Í2b7?’ƒæXNP ∠¡ä€üM˜_Ua­3‰Ç‰_qBƒUHÆ’š°ðQ¯W$ða‡¨‘wýý ¡GÓ}pÍ`w ¢pƒ|WT*CÛ¸Áoˆ]"-ÉVÜI‹A5{Eï‹é‡‰IÁ„˜Óö”ü»zl=|–ɵôÄxÁPÁ <„imácœsDŽH2'HèN(â&þÁHr9m(+ÐKßÇúŒ%C¸ß¤2A"†Bäó,‰èbCÄ‹`z—tΑ—Iu8néÀ<í<à$Û 0i ÝìŸJ_v´ &$™c›}t -gÉÛ%–;˵LÑ*â5„96Pˆ×$ž@ƒBr!h>èzô å(UB%¡‘Š²*û{°:m ½ç»Ç$ÿZ:u«?âÖ|¶z)–À<@ÕÀÜpÀ»[kl'ÌÚ↎[ÙÍÛ®nÍ nż P7â ‹‰ G&Ðæõ ÔeªÙms#,?°¸)´—Ôi6U!J˜Þ˜pJŒÞÍCvH†² ²D~¤ =ËÁ£‘ Œûq Ákî¥h‡G8*ÕIÑQÍ«žõpGR±Æ™p}îóẽ%˜1ත߼Ðc’Á}§°~E¨y3¦²1t®„ÝG`~»ÅçAjÛ=ÄlU®{çS\µ%Ò»aeÁö,ǯ¤†¤¾WYCNqùk"˜¦‰”Rܳ\±•‰rI‰OöSÃ`k4+ä<²Ac íÓ²¿µÛÚCX˜_eðÛ®7ô ž8;ƒâà5õ+u°§CçÿÕSå;! A¡üUU%„‡TÁÕºR·ã¦L:Llš<ÿtÝÜŠˆÑ2RåŠ½× ê¼äÈ!˜B 4¼¨à{>z,›Ñ°YÙO»’ ¤@„®ö‰0ãë@äk¹´Zƒù \…19‹’KhÁ >ˆéR‹] ¡»r•×‹é¿Zp™!ÖÂ=uÜáÄÕs®®¦J94°üÏqÍœ>RpF‡ Ù_­ƒ”Êht ­Í³©ù1Vî g Þ4¢ÒŒ’¨œÞö&e°FË`ÙE2ö°ô] vPÕ«oç-&^´QùÕªšÄ!³ï DY@@ˆ»MTïvúEH\Y)ßjänÂûy”"`½U ³×Ô¥§—iQÍhž5Ý´˜£ÄX«t}þ'»ÓG‹hGááñºÚ¸cwhÒ«è%‚EjÅu”sVÌ@ÂÕgŸP#PŽÁ¢R1à r…`Õšy„>õI––´E‘×!Žç¢‚Òñ‚m‡"¡(ZQhKÂ:BR5ÊF…(ˆ =õH=ýtÞy0Á y„ÚÕêPaèìx̆ƕx—áù‚v°(ä^q²ÃŃùè¬æ«; ÚmŒ0ÃS”þï±]s@`ÁÊ/ÁÉÛ_Pø|;ï;†.ví4M€q(Ÿ7™y©ê7xÿôôå½’½¾iÑW‰[¿Œú’µw¸ôê–àâS4ùóÿ¢ ÐÍùuZ¤`íÅ­§†žž±¬Dºpª±ê…WOtil~ƒXíM°n#BqÈÆ„GÿFî¯ +‡åæ3ĨNÃDd>cÑ” ïoÏ7©Rqµ1À.ʥ鄄0 ŒÅˆKüI Êòõ@šó?±‹Åf a-N_oø1/YÆ¢6]añ|EƒÔ¨cûz\‚v#~ è"2œ`?3cù_9U@N¼¥`Aà죄ì¹bB‚mr*±Ãvš›OTÕñÈwâ;b¡qì§ ˆE¤#$‰jÖÍû¢CA¡÷0…1f†…ëÿçÛê^fä7.Ðj%‰‚™+lDóf$X‹§†ß€ò¸±Q´Ÿw ²j ÐË LÎïŒS]yƒ¸øN(jIº‹« G ˜!ž„ùƒf¿-xºü€ä-xº;#’`k˜ap’ñBjfóÕÃLØ .7œ‰&j˜ÜÀì+Á®Í¤\ÀÄЖ=Yò¸æÖÚ “éw lʪ1…Øû½'’‰“ˆ0 ÁoùºöìØn ìÝ¿„ÁhŸ²ˆ8£ ª‘AC+‘B÷'ÊäQ±qŒ¸qV»=´…˜~ÌpYm…û‡ù¸ªÇðew3 ÒÍ%pf7Ã$œ-fÙŠo+ žQr_”§ª¶{ÖC.ç¦ö -§1\lí ШÇïâO¸ÿ|kû9w`\E!ãUá•€ •]ƒÂx@v:áÌôÏ7‡“I“'㛄ôø pH¼æ`ðlÎe98†6)ªäjsÌæàa¥TÈé~&¹¦Vëð)\°Ôm“€0Lš`l*¡5LìÇ秉Þcjø†„á­¡´–$M ŒãVL?G«@0…3e‰bÐ[g÷àè·9MgmO}›ô«†ÈhrusœÊð! 7wm(ù·:Þ—ÊÉ…j&:ˆÚ3Ä[¶Í¢Ð¤`ÄÊkf†-Acš^Bœ/°/\z1ÿNl+§Ø»œýÇ3‘=ªüÀ`Kàz’Á£?zú²8`io,nWb8ºà€¾Pá2[@“§ŒÄG2ס´… Gȉ/=,L²ç:æïzS(‡"- ø£`¤šQ@5¸€E—ùƒè”æGIúC¾óèP\Ð" ©a®œLáF2@©\ŒF(2¬UÆ€áýóåzrÝ£ê#6T½`GPÃ_6 foýÐ,¿S/gÀæË'9<:ò^[ …1|ŠJýºA:W¦Çx]×?¯øsšÓÊðtÐ]±ÔFÿ\Í<˜U7iP5 $ö¦Q1¿J© âF ¦‡Ý/BJƒç —uìÎ)pÜœ¨o-Ë35ØÙ½0ébR`§-þ:/ý°(Œù_xú» äÑ$$úÇÕƶnKt Ì…Ç cD­Œ …DÄ.ÄoFêhBª “ñn "r)†POÃc‡û‘ÜçÉxí5—"b@ÃÁ$Ʋ7j+*…ò2½Êðyj !ýñ…mÏR­Ûn³ <ØA$LF¨úÌõ¶LU©Cµº’=ó¹=bžu »›®"ÓfŒ=méˆøü©N^H²¥ÒÒl€mœ ‹=cÊ"7ØR)¡ïKLò{ 5ª BŠO9×L¨v\ÅÓ1þ^€4†5«˜I/$Éz ¢‡sü›ßZBù×ä®ÐkÇÞ[…E†‹¡ÎØHQeà4UkÙžõÓŒÇY•¿}< S®¯ú¥î¬‚rSµ÷Ü…ÓêO^à‚Is¸œ ÀXÄ C->(Ö4'ÂüÅlûú!âX —1…FO®P\áQ°af¬k”á³f» ä±NOyŒàhuù;;|Uú5Á¢¡«àž-˽hZ„r‰ˆ€üÁjÚŸ“-*8ô©QHg}DÒ×(ðÃFÐE„c"•°ÂÖ¿7ׄöCˆ°ápÄ9€’@ps^¤ïë-?ÀÃk˜É¤RŸ‘9wMNMmÿãâVÄC=”g£‰.bˆ6Áµ5T”|º½|q0nÄÃ6sêŸÑ®ÄÂâ Ñ‘T᪎ºúnI®ãºÑú4Hðµt%$P}-œ0%ˆÁ3Œ–íµºL™` ŽÉÏß´#°_„6 ÔˆxïmˆrX¦TlRdFjr KϺ.Th†Ó†ÀÃk©"68+y»0/›%§9Uƒ£Žo*œW23Gf)ù:ùLqÉÓ˜.ê{#¾à4‘^då\4Ôð¥ÖÚ(&à}² [c¤E‚<7 %n„!êócF·ëo¬ B+{ ƒ0rR®lS¢tCciNÔì5D1˜Ž$b‰Sè:'/v?PyãMâìQD-µ³+]ø+ ãl*õ>JÂSJ…_%3r²¯i¬Ç2d0m•A?æüüÒá@}±˜ŒªÒJ;åø‘¡pLðòœ µ0þƒLH™—ݨÀ§û›µ0AÊ “áv+¡hˆ.r©kŠÜ&¸üçÑHÀd/:lá ìãÚsh8Ï£I½_ †ƒÑAØŸ|{(£Exõ¹Ã4(T©Êv*­-!Ð4=e^ë±öø1?<9(Â8¶˜Ê…xiˆa Y¥\´I¤6VN½…éV›^|ZP›ƒ@Ī¥< •; ;õ?ÉL?ÉQæÿ–IŠfŠ À(š5ûÙžµúéž(¥oj›¶êÞ%x‘˜7@{Jï3ƒÉº˜‹“½jp¤¿Âï>IFdÚ ‘Ç¿Ørò¡¾nð¥Q6ÊŠõÙ'áC YƒlYM¡„i{T¢*V\䈊ø.Ït*åM`Á¡*ª!ºè&>±¸Ù9üŽÁ¢_Töš´Òèl9‚1’Xø0!6¶‘9^··Ú;—:d8<¨mDI,+–Ýßç&V§L$Ñ‚«Å÷gÚs‹AËÿgpsá˜g‡.³XÕÌ‚Ôù°=NÓ#Þ|Ç.µM y¾ÖÓ*gãÖ%3ü_Mšî)èɘBÑv´¡Qi0f0Ö! qjÈFÈC )ƒ/Ø¥.b2&ÔA@èkñm£ ¡1xßw3è$HÎ øÙ—/2ÛSš6d9=vÖ’SN#g«,I¤U;$ 5 70xNþ Yr¯Šà½.&·/`d/çj±è›Â >f°y{ÿó£¹ÇEpx¯¡wz·øßj%ôää8Œ2äÛ!4K—5<ºkþx7Û6rCeÅö¢tмÚB?R¦ÔãÉte J¢[€¦ÂM8c´àrèKÐsô×Íá½E… é‚”$.¬yoâb{o sVç dBÊâvÄ¢jIp»iÔÎY!À‰©¹¯Ï›ñbTþ×C– ºZÕNC5ê|x„e¢€i ºjÆ®¾ø5ĺ9³&TõŒã ßÑŽÍ„B0­âlÉ´ªÞÛjšq£@.¡fD1žOœgè»êCê(`7 2†WpG÷F253B1¨dMñåniÅ…e"žSâ#ãÊ5ÔKf{Ñ·"Ÿ¦=èYü RP*:ç‘j$Zˆ!jy4²-“Ü€Ô…r™à!6@+"pd©öÅäCžhöO4!n^XéÐä*ßëRþ™Js1³аHî<eäPVl~xCòÅ$$à‘ƒ¥Èò®H iº,‡|ò1Gºå¿Ë#ê¥ù0åè*òÎ 3x?ƒ¦ÃÈ…m£Ý³j§:°=á…‹…UÑצ×.LЇ'âsÊ_hœ5uœçœÇ—*ûxK TŽ+Ž Lvˆåöß à©E#»õ~jvýª/°÷ aXGq6ûúpíÊ8¨‡e9î™çŒ!VÅs;‚#11X¬ìž9,3+… ³bƒFÝKøYgj b9ü²þ*&§âœi£Ü$A_â*\°ª®ÁaéZnA@µ'ÎÜSË=S²¨†áp KÚSdȶpúîp1Uv¥Ž³SŠ)p‚ÌÃì "2pXæg›‰¯UÀ„÷§1@c6QwQKî2YòcxÅ¥o¬7,¶àÃÏ»§v#Ö}V~'à8c°d û],~ºÕx³âü>'2ãÏa4­Ð=A Ášk†=GúôKé_ß(tB Ø #›Öà£eÑRÒÑ#ìíÞúIJ)±F+®¾T–"†“›½Ñ}‰(Sš ÑÐ# x—c’O=…L°LHß.•-/µR{F¨YWÃ_´;Ù †íÞ§©D‹…ßÂ8Ât (üFÆDl ‘!¼h¥Š/ #°ןˆHÝã/#B €HØaH‰$€lwàâÅ%­§Ìw¾ìÒI~Rnó9Í—hháVr((ç'4Qû%ƒuSÎ@pnö wCåë–Ly—¡ÞÍ,àÆ÷-ÿkÜÿã_ô (š nÛ¤ k¸ìúѳ¸=Ø &8Jìpyàk« mÊ‹K P°|¢¨ôzSóÎ};%a± ÀFúŽ‚å!8[ Æid–€2¸|-ÌÒD,Ã@vL`òguâó¦ºñ]²Ïû  d™ Ý@“b Gƒ6Öë€í`ûÁ ®tH,^»@·øê)· ]bDëP,ŠY  –þ˜Jyu”Tš&  ¿…LvwØÿ%igìò š«Xb®bóáOê’m`I"‚±ƒRC‚®"ãïCÙvçT+çaëêQWIšàŒ, ¢ÁÒŸÛ€q9Dîuè‚ÿK]DùFà Õ®2,&1©xïü(Ì€OÞX+îêáàžÆÔÎ8p˜Wo ™x `30e²=3»,@Cî¨( ò4ˆ’û v´³S¦ ‚#A(AcPÈ}‚ð°À02J'ÁÀ‘¿¶\ áá¤è@ĺ¤XÈ\ 7æ¹嶩èPƒg>·²©´¾ñ ¶5à¹Ú‘§h_r'Py¬‘¡ó”ÙE". åÿˆÇbžà$vq\N¤ˆS¨fBˆµÄÈ;*£kr9)l¬ìˆ0 À Pfu+™c[Þ€itá¡­MßyÐ-í üSõLNV€|êg^Ÿ‚¼[JMj¯üåç˜ÚÒáƒ)è¶"xÙB^SÁ0€põL·ï*nÝ/¦ë>­´x·Øжñ×hÙ˜`®-~kªõx7ô§ug×L-Ê•"ý\V¢1.?/& åËseØÅ´ (œÖÄ8„)߶°¹`/z‹½³r{ø³0>¿¨õNkîqDö÷Bæ©ŽˆàÒ‰?×J]õ´F(!Æ¡ªw`rç0‹¬ n6ò÷Ú“-DÑ‘k8±€7$7ƒip.Cpæ$8X1301)ÏæÌ1)d¨oyÃŒ:ãÒî¦è‘ä°Ò>'ßr#˜]á‚‚q0Îf †”Œï\t™˜óˆ@‡%‚1a»£àë.i¤]fÒ1vø µ’üƒÙ¥oø¢Âé,mŽ”ÀÍã) šCA®Ñ@@äa'±Íá‚ZnÇÈ {d¾,Дá”ÌÙmš,=Ç;‚‚ý“æ„”‰„{9@ðŠ1Šl aYüaÞ·#å¼o’Û-ãJ8"üÕ÷Ø>/5zÔÝVMØ绲^_Û[>#Ë [ÊS.„Y^ü9=IxMÒt<¢Ø>¸ Q{,ÚÂPWøœ,¬:8Y¼€ôx á<݇z0• '{ b…UØ9URê;ìXPÊpþsÎ S26ól oJiD@àFè`̾“ö×Ù’Ô\>ž °³xƒ…‚R˜Dh«b6a8tB]}K  a™ÖË@ÀB eG§LwYôèMÃtv;Ü—˜sq‚®"YžêÛ¼¯ Z`£k‹À?]4HØbò¥ÊkŠÕye ÝmÔúX#Fo·Ä¥]¢NÖIqklÌÃâ, áp„6ù-Š7ïSò“"ÑÆ`+…œG < „Eö¥*»5ç¦vÉïÛ¤åñð .1ªwzôðY)÷ oBYW÷ðS»My˜Ô¸—‡ ^à¿({3=$p“«®ÅdƒNmÀ®SZ8£±â%…[ÍHðÍÁ)“Ðê«¿0Á]‚¤â‡eÄËb@¨JùdF ÀÄ€Y‰8‡öf>)Ë#ƒ´ÝíìL·_¢NÝó°P’°5ÂF"¯Ü*Îq¿kœð&wU4K”çÜ`Ŧ†xÜfW‡ÑöÒe&þ'Fž$G/Ì¢¬ $Ž˜'ôá^äÔ^jfU'·Æ¦dܬڨIö€ÿ÷4"'4ÊlOòRÍLGàv Ë’mÈR÷>^9ë’ü^&£©Ï•äÒ–¯-ä›4ŽdZÄq¢A¼%Óf™É(àùàõN÷âô +ÊPûôèC~Ÿ{ŠŠ/ë³qù?â,ô†gëóQÉJÞy ‹îˆ¼ˆû/:®}´¼##Â[:ÈÖ:\¾ H|‡ð¨í–±ê.Úg on&”¸"qÊβ€ö-‰Öó5hõ#?KyŒ’À¦/Â6€Û–§ Ë体®©í»RÈdUAI®" 'O$“ò µbÖó‹– ý©Jcê\ÇXß-VÁ’ÌÂ.50x‹äŽ"rÝ>œm*Þ”‚èPÌô¤F?WÙňx¼ŒµøØ<•õðJÛB9"~'Ñ%ŒNÞÈá¯ÏvݼóHô"sëD¢Ä% ² ‚jÛÞ^–ÐÕ—´-Ö=%©¡d1¸tʆ=±YZ +¡„ž*!~±e£“¢Ä”2% uÊx°E ÏÕLÍ‘¬‚ºÅ(·',ÅÏÅ.ã(@kne‹§PÚ Å î0óÔŸM‚Ìñ–(ÅA—t=2¡ _–Lhl ²/RRg³iVü±¸»1ΪÉpþg¸.E„PŠôg1¾OËÖ¤ý màÂOyX±}ðþ– íêØ(Å–@Š­‹ x//D¼ûÀdQ pP›š4o6 ˜ øÔ,¢€*NRÃZþ¡‡Æ9–Bhu‹Qòã¥z(Øùþ©;(iS·˜ |pZ{Ѧ8í¯Øv ÍØX(°àœÅKf±º{R „µŽ]SBài¤Ï|LvrBdð,lOQ…!Ób¿' /¯ð:ˆŒB”ˆ½,hë’Üq¬#0D!%?ÿ±2»DüZ”e·…=9é:õÞ{mŠû,–JÑâ÷,¸ÕÓ)baÄòl ”©É'Ó~ÁÍ )EŧÎTÒ 3nÆcÀõS US”¹ƒ¥§{&;³§#I¶Fã1Cèeq€pe—ËûNˆqL|| G ·«M ‚†pìäF‚ æ3áÔá'8`QÈhxGá èÀþ*Üà<µ@rÛ è8î?Zã@Ûý?¿¸·ƒ‘Àd+@íä8hŒNV{.@ #à­¥ôÏóЮ8nàPÖ¥M¬dœ¯ý£.ŠH(;™Ž,ØH;‰Ùµ)ÊFìfzÂŒIa—u C%ÈNÒŒäš>$êE P‹Ð`Ä@3]׋¸Á»/©•ƒ@"ZŠ½PÊbÎ`ÉäI,Ù½û5@~‡§Â¡ùx”ÏO¸,38;÷×È»ÅQò<•…*‘Onp¯™°âÿ«øä}/ æ #yqhÙâ¾^ÎäSꨣα-U&Ǧ7uˆˆrñTS(ÿÈA·ÎQî† °3JñÊ4s<°áºÀT÷a E•W‘ÁÉ^Tž†¢† ÇAhøñÄ”:ˆØÂI’;ˆ#ÀmdÂVQø/á3«ÊÁäÈ»=‚ǺàÌ\ÃYDÀXí¢‹fï)ìM „½Û1ùÜÓh±ØvA~êm êëÖóD G>Ñ)áŠÑqÂÊɾ$«¶ F1£àJt` PpÂÒ(4cxÇ ÐùWBGéÕ:,Ÿç·p.¿a ;#Íœ ƒç3Åû½ƒmÝë— VRLGìžr` œÁR”â ’Ïû@ںĔ„N³Vô‰Ù8DK…/¿.Ô¨)è  #½âª¿€rùÁŸý>ÌãÈ÷™ø €~Ì*þà€ÖÊ`8ÍZèCzJ=¼J!¥x„ϺCP"o6Í]mW­¦«ëÛÛi²äUz…V’yØäô9˜óßÀÕŸ§Ú·&CrXÙ¦ÄVz6·iŽÚ™®žg5 ÏAz»ñvFäåæ"Þ!OIÍ-‰Î€Â¾Na‹—QdÜ l}wkǧð×Ò˃¬§¢AæÌt—3_Ë}øð¾ô[’Ó˜”U£/ÍäX€qF$P¬B&ˆÁAp~Ù=µ™Ñní‚…5™âñPˆx^JMÁQLåÒÄ—ÓB+ÐT"¯ê0.Á³GÐvExå«ì‚’ü9- …†…D°x˼`ݸ¸gQÿ¢èÍLWºG8ÿnd=k1'n è´hE‹¯¢•\Äx¹mØ ¢žU»ÃUÍ´î´,žÄJ"I[ÓgIñ=f‰{“Eè6“戯>»ß’¶Ú],²U2Èž„·3r4ƒ•!¡àŠbö‘¿Q ‹¤[^K¯ÞבM5G„°Ø󚙏Âd&.š€^w ´jFO/F±6¾7\=jÙ¾©çÂ~ù…ùnm°’ÉË *ÇdÛ ‰?¥åÇaû €G”×lÃBÅËàw’€m”š \!¡q˜ ÙúÛ"0jƒo“ɺ2àXá†=,Ýiýž½¼Œ²¤k/K %sƒDD5’ #\3)WŽ²%ëÀ Yማ5¾sÐä"89ÙÒ§F­¬*·P« ‘5‰ITÊ)Mó=û̲kc 㪨 —4Âv¼P|·WÎxx) $·‰iëC ©uëäž/‚ü|CÐH¥#ý¯C¥H´ê*K ¼L–6%Ð4 ]\;) åwÃóÈmÓþX_CLûäm5Šo¨ú¼'u.Ï‚öÞÌŒe9%\£Ï× †@õB,éi‘cZlÜ?¢*Ú0SK)”æ–¦ò¸¬;Œ —zrhê<Sk-³„/1¼~Ðnžc{¨{”¹å*#v}uFÖÒVкµ, úùilN}=žíy‹\,Œ(Ÿ¿hø2·“„aµ0ùYã†U1SŠ‘XÞM”Õpî ±|9QÖ."CïÀ>‡- Œ˜ìfÏž~âX:¿P›”6ÑIA°˜ŸZ((±â L '”ÃFÀÜ&æqëiÐ$¢Ö`qñ4T2t‰!$>€vÈÔ3‰€'Ý'2v¼QÚÅ+3ä £ðr/Uœ8é.‹!ôaº@¹3l,=èCpf$¤`‹§.ff Ø H@ö¬–VÛFKe§ñZ2 âœ,OÈnÜ ‚Í1Xž¢¡ù/ „Q‡ÃÐÉàè¢oêa/¤öKØ—&‚"A)²øS¾ºFJÀX½ž|ó­ÃĶ{ë1f*-dmv~U¯°Yù¾Ö¶ÀáÌÛ¡á…¼¼ÖEµØÑ.†D4¥@8šyëJFzär sùg°õ£ CÔ±èã»j^œ|ù¢pÄ£çÿ7,™(³mnMø¤9Çi‚ØRïŠ1¬?´Z嬅¨Ôæ7šüš´ËY+Aé¦KŽEëy™{êÙ%ÚNË1>àî·_ÂŽ„xôâ~2!èdÖ<ãQkê ÀÌ#²)þ  •Þ€œO0H”Þo7Ò…… jĺ©­wüO>CQòé¸ô3T=U·=5…÷±Rä¶L3í&’ï[Hà-BNywŽFÅœj/Âë)Ìì˜C)ËxUfvRD@( âa˜…æ4hlÌ«H'¦6·–æMúù­y*Õ+R¯œ[½­íø«G¯d²ëãB2nLÃ×w+Ã,2fíø(=Sœ'sæõË4¦^Eì~5b èǧ1•ôi>ê¿ø,ó;ZÕ®ˆa:UôIc¬ Ù¬>ì\^¯†Ûbè`³BVתBNh{g1E ÎQÇÞ\ú/cÜΩ(8ͳàEŠ¿Þ§ÝL#z‹‹Åø ‘O Y…e)!‘\åx QA껫äT÷JÔ¾mè(šTòò&Çî[´Cáë4–Èù3Ìc߶\ cFŒÓäÏù{v̓,ŠùôGx„ÌÎÆn†à}®±]ªxz{žÎ—ø%7ø:ì@nå‡~:–’ñÌéltÇxPz}(®´³|›Òš)Ë‘Þxhi$¥P‘±"CþP®Aˆˆ^Ƶê?»äòSÀ ° ;ʵòÙ5$ÄŠcÔ>+W!ÈŽvÉapè±YF²;ƒIza ʃ¨¨ƒ•>0:*…sÄ„}RµÅ`¸Š{rýIp’ ­ieæsƒ‡!&Ö¡ÑQ19ñ¨qQ’$AŠºD?àdÑPª¬årv"Ðb{†ôpŽ’óI»ñý[+kR°” &ä2ž•r";®"’tðlŽuy{fÁQ=`–½ åÂp‚+Æ?»eƒ¢V ½Ø5¼©YhSÕ™ñÊ*úËUÆH½ëVÏac†Œú) …źSýI€WQ·ê牢¡fŒ{&R¸zGSf;[ôK딬祺Ïb~Ÿ‰ *,Ô -|>üKp×äDã¨*©˜¨ F¸á,Îý„Aœ+ð¾é:€ÐèK4äßõ1 µeZÚÝ Ïȳ‰‘ÌÓÿ«ÿôʃ¨äž C¿±/謫˜ÁmbÌäv}ÚÓ+ÑálmPi \¥NK2ª U•M‰¼¨8ܹQ;í¢ˆ²å†uZâVyb[Ý [ Ǿxíj†}~W(ò£¦UÉZqÈ·ËÂ#ÆÔúHj ½¥ØPž4~×,$B-—óe7’ Ï2)Ì>Ì0'œÑvz×l­ÐE¨¬'¿Q ï0õàw‹Üˆa¬yÍÆ1ýàdP á@«‚R5Ïœ¢Î†Q Bõ3t€iØSß/‘°7êe)+X{‰cÄ)ìÆLjûÍ é”äê|4ÑÛ¦«Ð×zì¾`ÂÄ[à˜•WIh(9ãW½Ào?Sq P„®ô”Áˆ,üÜšû¬ <ˆ2#¹}¥øÂRÒÆÇ !ñlXHô 3v'$F2làGtjÌCNÑÜúž×˜Ñ‰ÃI``!º›¦à@¿í/¡¨ñ³œ×Êðàzž‘3àÚäÚ­éi|`¯Ý3Å6þí#PŒ9ï *ÛaGcÝØ™µ¤´×!²”$ï@Xj!Þ9ðQÁXGœÁg€¶k2… ®IŽ… Šñiå6Ë€m)”Òƒ»‰Hh„­SaëPd¢Ë„ÕLBˆ- 3„68!kÔÑ5D! DCÉóÉÑEø‰¸0^/¢ïÊE9Ö`ÌÙß Ñ2t&Ý#j.è;ÖÁÂ",‚æ6ÙŽ$éˆ<··ßâ@ßiS{FždÐL² 5À=o|€NdgÑûRП—ÈŽçÉI¢H$õoU›È˜8¾V+f1·Ð‚ L"Êp…¥À ¥š|‚0îÆÞ!à(Í.eP1Rvo÷•NaÊUno¼½)û”,â&”…¬iƒñxT<,eHèÁKpCpªŒˆ×nxµR~ '&Ì|(AØVM9s@X†š¯OÖ,™ò ƒßPe—Î$“”:/àÚzëçxPдÃÓŸ‚ͱ»~&õh¯SwG„:-‰k;+$µt±kùSa˜û]D:c! Æ ÄŒd Þ>NÒw‰ý¢±EÒšÔ!BÆ-²CÐ ¼ˆ³X¡~ ÏšÌK€˜²#vÆAã°¬eŽ´xý‡é–m‡K«”œ,ÝÌpL ÕÄëpiAL,CJ ?I˜ÚmiBßt¡µ;µ ¿~{Éj&Æ’•a JUµ"Z/Ûð ™)1ûºâ¸³qQ)'§rænñ a~#Çø—-„Àl×÷ƒ¯H“§¢:8×oïʈ!®Ca¿{À4LDñmŠŠwV>rl}Q‰¼ ¨øCtš ”û¨´-?‡?dnÅhþ⚯° (°/Ȭô‹~ù€X| ,Ç®B†Æõp½\·íü"ˆåÓmÔ§“$°€¬Ôµµˆ‡˜G"‰Ù>À$3À_²}êy­°óö'zðçUNýty¹Ó08âî­Æ5êÐJ#Ô´!S9Û¼œ@ˆ:x„ï%c ¥‰t»øŸÀ-þ1±·-DeÒõB½ƒ¿#ÏÒÄ>ûŸÔk†£âëãüL>Fá¥êÊdÍ÷N,x©Ð »ÑÞŸ¡~4žð>ø¾”6X(Ìí Q`E¨|áÄ# {7ØÕ×Ë¢¢IŒ½ƒ.½.½$`¿Ÿý¼hËѵS$œŽ_ `5XŠ¼žù9è!vPä%sÆÅc¸,Y+¥}(»|Nž5>Ûçð´õ‘.´†tƒ’™FLÃÔ2ú– Á2äI"=ÿýð‹d¿,×JÌ ‚‚¹¹Ôˆ=–Ugàp" ãR U|°’t“]äûGîÊÎåÐ;Mp871õ­V_ÐAÄ:O—ÒOjõ'7¦UÓâY‡rÿ¿:T”ö+<+¬æ> ­¢k¨Ð9œÇ¦ ¢0*}“z»£ç+(Ç {xT´wNŸh¥‰Ýß-Àª3QªÚ û NHªlq˜Ãå“n‡®Ÿ@΀âXÁ«uÀHp'ñÔVaQøi:0ü‰¢pµ¬ &†ëwÆ%¨›& }‰þ¨ô‚€Þ| Ób¾º)F+~ÿá^ÓÌ#È>©;å 'l#µýÞDþÕÊÂÝñ„?SwÉ7mS°•$멳@Ö¸ïXÐw öÇ3·cv[ò7&Eü;nDRøŽÐìVÔž  ìbœoU€ÇÁÕ2à­°HœÚâÌ ½hðbTÔä(=Ú&šKî\ï#:1àßHãÏ·º¤Ñ-È.%¤RÞS 9¬×ô [»zÞ¾]qôu>VS‡ú= À!xa-{2•P=äôýÉR¡æa¨l }Q{ïxÑ|Ȩ?²dH-§ÂVQ `»`ŸÇçPîº]lÄ_Á¥r¦Ã0Ðx@‚oÇôØco‰?öz îBRèügÐ`2ªCÍÓG"³xáPb\déMbsÕºÿÖ%Ÿ¯­×oì¨ÃQ¢üK‡85¹d[÷”Ï0*äÁ:·ÛL‹Ã® ¢än¾÷2èP7ˆxäÝ2ñæ¬Ù”LË…Ñ~-[wúÓŠ-À¸â6 S,PPnM„¢ûcñ‚Aá #ÜLÑ^ŽŒ1qFœƒÂÍ©‚pOô Õ½Ù™0™‘éŒì&.]äØÔË‘ª¶M„iJ­Ÿ#UE··û¤pÃ}œß›c!- ÓÑ|i>â„ØGQ§/ž«ÙT¦ЀÕG*7³/RÃÃË'3v¯ ºNYópz`âÇcëDˆ{r‹Beó·jMÆšhµõ®_ø5ìR^‚ õM" Ù’-Ç©P`½‘ÐO–$G¹: „±ÀŽ 1&e(¿Åéiéïê„cšÀÚÍ? àã»ï¢¨?GÞ%ØšÛ£vF¹æ—Ÿ3__ÄæùŽO!Q_SE낉ßì´ÉOWõXŠ¦,'ØTOp¤ ±EX§Ñ” “ÑYL¶{ï_GºŠWcI¦ã“A ßcY¦VG¬Kà ëœ(+º6^C1‰ß… –ÂdºçñG@ ËòF  1ì¼-p“H¡¾–Hï-÷E… Sè/ ½ÜQ[xÓO¿¾Ö¹ Ê4ÀÝae@+aŸ™*/d~1sR/vÚ=VVC*Qj”¢„šæ^§¶OÇÊ«ì­6à4ˆµÂ’d#:XE”` ¥ÑE¯ª,³Ö½5²ŠZpœs¡<€Š`8Ø„·öj¸ôCK–œrõ©²v2ᥑ0O¼Mü)W‡ÐΣ©¤3á"Ô” mavÊH.* ¨¾“¥º@ê`¯íøìKe0.º?QÆMÔ¨îÍ6éÇi# hÕÞ*+Ù2~ÁœYKDx¶Ø@¸sb$>\HÐB.‚A‡»%й—#Šô(ÁFˆ°@…A.È·R-þu˜Îè½™9ΡNJ ©J!(=W@5ÌòL¸5„ÛݓȪ)û¿ZFæå´ ±†ƒÜ"»4 EäX¿‹¬¬.ù™c©JèE:H&G‡?«Éñê¡[Së×J 2Õ¸QìV3âeü }Äv…üÊÉàF1£ßO£+¾a®r¶g*`…îTDIÒè2ª  á檷Lhž|€؋u4½0Ô°ùqfÚHŽ¬,Tn"IÀX~e£”Sa»Aæ}D"¾XG_jnäÄÐbž¹l‘ ½-„TîÝÞ»—f½˜„ sœ®å(¹J0&¾ó€xñ¬¥ƒ!1ÉQ“™id¬ý/']JKFâ„púÑÖ¬~ãg;Å.Ÿ ô¶Iotб8ƒ\4žœ!jêA1†ò¨‘Ø"W lIep6삉£t²B¹z ªáQÔJ3HȃP+QnRÒÝâöUÀ“^ú 74‚/M„×ÊêÀ\5ît§é³¨ôXR`U™Ív˜É6iP#´P!ÐësGøßÃë.ìÃLÖ¨ŽáA®Ô©ŽpDX™MÊÊ¢À0<„ƒ€`›Ü…é ªÎâ»*¹á«Öj:bцZ^J¬Ù!»c´Êka=Ш©‚8ršñIã¼8â²÷úbÞ“Ÿ„ ¬«ºiŠG ±›’IÁªo³JF@c_««L Û1‚Æ•®äÈ&ŽÃS¶}]jgêðÿ“rÑ)ÐزJŽ…vÝ# @¤Ï‚&`ÙiÉ´›‚àø{H¬p1냹ÄnÀÀéÁο‚óÃ7x¾‰œK‡¼‰ÓB„îì]äïÓ1ÈX /¥c¦—?Ȫ gÍÉM:?–ªA†J.šš¢ú¸øVƒÕ£%o uDZJj~þÅò·ƒgF虀Ẫg† ãØköÓžQ^,©½hÆx¥•hL‡fN'GNÍI†äªq.v‡¦Ž¤“¹à™UèíÑ5Ô­¡² •¨‰éÒ®!EiV¶Ó¸•P†ƒ,c€ö†©¦ g ðŒ©.ît?«ïï–ð…søÀ„ý®ö½³È ÚÔWæbJ(SÆ2ÿMŽƒ¸5ë ™õZi¢üKX?Ó=ŸŸCfUÃð9CŠêð¯¯ÐïÅ°e»Ú…4`_i¸VϘÀDìo’0L¤_€G°°®ÒÒ>FÀÍjòß°@:ÁÆ°M×›×.ÌŘçÂMî .4 qdýàIòþù áŒêÒ%N. jðb‚øQ8aÚUx0 `a†Ð÷Š„µ5îÅ]î×〶Üt Åø :™ä‰…ß‘ïÏ¢kâ½Í)B ùè'w+–Ž aà¿ q›„ü©ÇÜ!ì8Dþɱ” 3ºèic¾ý‡L6z*à.&fÝtšÀnÖ“µ×æ`*ØÂ¥ëG¾`—Ó°(§Eƒ¶Åe¸‰ˆqr|ØM(Ù› …t¿ …;%†\Õ¬\§vrä„L¸”ˆ4ë°©s‹ÉN’U w•ØI€¬O©Xð°<´¹ñáš5•;zU-hIÿ)2Æ7 ýðÒê9 •l%:€mD<Š­ÀêQ5pÙeH…$ÐB„_ˆ#×v ÌkÊ›B{P&!.ÊžcAë~b h¡µi8Y½&{p4f$YL«¾Œ†èi¤Fw²àŠ%ËM嘴†9q”‘¿/ ‘ìÊÚZRÏá<ÖÁ!Ó¨‘GU]Y•„k|µº{Òï½WJ–º@hM½,ïC£nŒöÖÞ÷Õ“ã!Áª£±:±øg‰x2!cÄõ®7aÀJôÈaË mvq  qCë ‡êœ¤®t´«BLK€ Ž(ñ8aêÌE7¤},r3m-}Œ\Ï‘Lä-ß„ K#]ŸA.½-턱]¶ëQ\j…é”;ÐM ÌFó(µŒƒ’:>”|«|U,Ln"ØRÏUɉû­‡ô¤ñ±§È=•ú×gÏÅÞ„8=%Ë @LtP¶RQ+ÈLa»ô1o¾~H”¶„B¢!Bà¤$ð"Ld=x 9ÉUˆ;æÉ…½½Ö´Ó¬µÃ…FÝ»ÒrÄK„íá?Y–”,R-CìN¦EO{[!U•HãÈö:À&QªåÉV&DQ$Š¢<ñq\[§cÖìÕÇØÔ½‡òD~?×bÒü­SÜ–C­àîIXÖƤkW&‘*!$,>ô•aÝÚðRêUðÐÜ_6÷Ù¿äU*p/‡3çÜô—…oV“²t ™žpLþE°Œò.Û'Ï3E3œ ÍÕ•`¢¬XG“ÄÃmï±à¯ $hr­°nÑš4ã_¡„Ù¬ÑY3þÂÎT¨¢WÒˆídJÌéÊ w<þ¤æã”i2…xå Ã(dµÌZkZ’’-@v•õÝC‚ü‰ˆ“$ •pˆ{kèÀ—>cPI3R äÍ&V:¤nd„ƒÐ£86›V¥#®(Êf×Ð8XÒ’‘W~%§›b„nlF †?ŠõÐ\Jwbå °@TÆ0…ÆDìM©¢œÁ} X¢Ž`6œû(Gexž BHˆA<5N­‡ÊNš@PUt7)õ¡îæÿk <{S1õ Êñ½Á!MX×XbW½ÎÒ.-ðÔ„¤H—2$ƒI¤ŸÎUGÇ‹®Èa·UUCê‹Ø®v|±rèÏË)ûR6†V 2# uò”+o÷¹pØHÉÃÖ¬”¼»é…];õŠê”ÊH‰„ºö/Ñé&לQHJ§ô®Óòa5ŒMŒnnÝEçÖ3Æφð€Áé ,¾Mb õù” CBŽŒ!Ø)ð?ÑÝi‡€Ž‰mçP©{‚qð áÚ>pI›ëéäЬ:¯K^®|õÊ×-ÞâTJM«^k+Æì#Ä„€½Ü1”o±Ç:ÌøÖᔳf›Ý½ë,Œ$QAjRøJÒ8µšâ€–:³·d»!j™®øèd[²O;“ñ8Â&’Ö0‰qzýx͈԰=U$"ƒ«å¢Zk &YþNw œ½-—m‡O…à„é“š¡‹ K¸Óœ•Îtª`x6I%etŒ™9‘ PÎ kWµ= ^!éÂEd±Îµ:-°ÁÀ¬ðóÝ>©ÀE:ËÃìÕ²*x3‘§zNœ‰çÅ{%ð ê… Is_9åuâ›÷l<”Âx¡æã8‹ó¼ù"¦ y¹C ]4En³ð ›ÔшƒýÌè 5û~¬ôœ‹JôR:Ž9°?t“Ç,G‡B˜€CÌ •c®Hø‹˜Ë ˜OÄfO›Ö:IÕ¶gl°<ͲܥÏuF’ýffCfeÎ;ê]ý+´kØœe(øÏåüò.äHZÄõ¹ÇAÜ8>ÑåáDØ»ØH Ö®±}õ°¦ãÓ¤Õª9åe-͌͘¨)¶ºDQqFÍa±Õ‰€Ù¯#^0DMx]sq³LJ±æ‰h·C˜¥{ËÞÕ¡|…€ñ­"ùBßá’•}>$ vf„¢5Z¡)á ž[ JàY_Ì ô²a©O!‰ç¹Á@¤)Õ™1çbÉwt +ú"~GEÑ»XÝzôç#¥ ."mí¬„þŒÆ n¨çƒi5ÒJ~2%ÖË[%4Ü^(5¡!ÜìêÐòaê‡ò͈D‹Íø%Þ bHå|·e[&aýÃOÎœh*öv8õã‹Qó?À$/˜òÒÙÈÏ%>¬Ø4šbÐç«"sŸÊï€4qÛËü¯ê;S4UüÁÞb”—³øðDz²ù5Ü•èÂúž<xÈ¿lû,nGªä@0’s$!RÔªŠ±vÈ7CöÂ) ˆŒ’Ž~’ó°´²çÞ¹³ KgˆÌ^‰.@¶—j(‰´ˆ±çŽmzçZõ昨¶+®ß®ÝÑn6E¦G ©í›]°ÑÿdˆD[¥Gtžú€vö?!B+¶ 2"¨a„†[„¹:€èÓчïQF”&E±« ’)°Å›á)¡“h¨†³N)ì%7d©oâ­ñºçµ"XKuÀÎ?Á6Â@eÉ5s= Èp—À›¤5)­I*!„öÑÑ»x/£¦{Ñæ úRì¸5PÛ¾5 9±ƒˆëtZú\°q¶¥8sºþô%i ôJŠÄìÔàÅIjmà¡×.¨ÜdY¿\C¨A ÞM¬z’9¥Gßb‚±($oSèA3èŠ9z³ªYŸ †ÈŠh)9¢Y2>Nu_h¾‡ºÂWƒÖ$’€kB¶&ð=÷¨ºSÖ­0ŠÌE.ÞXåVy·ßvpw @$]ÝÔ €Ã`2jÖ ê~‘´6b [6Ûee5*þŠsLy€6E7´w® ¦iv†¬]$£\":-Öc‡Í-’=Dî}ÜâI õ;†Caƒ,_QTGUÒ¨Bγ¼–_ô±-뎗,ínQà—W(9iB o@È’Èzé0š¢DÍC;¸e]¤oà`„Zîz e^”ƒPRv˜ZŒ÷ƒ§2öxàÐ,!7Jl)ØØ•ºaÃxaã>ú.ZHx)†øŒAÜ„@•#¦Ó…g¬ÛºðnºKƒÈ£¶ ÖHèh]ššEçV.‰²ù4Æ#\¡B˜˜ç†ØÆHˆ(Ì.‚ƒ›EÒcð]ùÍQ‚ýÏ g1e•/fA,ŠM¶ï5‹FÕ£Ø^vFÎ÷Q?pT˜-¼sé)¯SêÖcLŒ~Ð îô‡K(¶Ý8Ð]µñ9#QŽ‘,¢ŒrÍNéõ‚Œƒ çÖajaO›ö‰´!zý‘æßtý[ ¢>”ÈxËF·u2×Ý~œ´ „£"¹5ñ”-uöÙ"!¦Z1P31DÍ°ÞÓRA;‰ÐK>ùŽÑù²äØó‘«eŒx©-©w'Å5ÎëU›­äÎ!RŠo·Ì8j\E{Ðq¨(s£%‡bŸ¨×Ä R»23‘~#DÚþ'øí=¬ÈãL$ƒ6„açOÔÁÛE@3¶+ô$QÅ«ààŒjÀÔG2!Õ[¹„Þ±ScCý6g‡Ù”Kšßeè$Üáµþ‚oZ©¦»P7ê:K")оò(¼1ÄÈ&QÞ•Ę̂*FŽŽ]2- T¡äQW ÆzPT_N1’¨‡cb/D"DÐ`“ÂØgσBn ¾®ð•«7Ù&ò…2„²43S<ƒø€ 8@“B!:èu;#‘È'4%$={p°^áî4±J=œÊg(-ó.Šý‚eu‡H† i§uôõÆÁKLËQœ=}ï ûvy] Qé4׬gȆïVqX L˜‹™ÂÄÚ?јCJ…ªÐˆSDž;¢1‚Z ‰„Ö,ôÿ° €.&±CöVº”‰o8¬h^+v¢„Q®V†ÞP„W¥¡P\Byô®‹& 9Â9‹Š•Y™î'C­E¥‰ÊºF/âêM4±„]ëÆÍ£*y¯ÁFS (šPÍ&D:˜'Äêå©Œ+XDÞ?'‡SÎî*¨2Ó£ÔDó|ລ36aü@ŠøXˆÉ*M¦œ|¾¯A= Žóˆ~®}p?äf¡&¦óc¯'£â+$™xˆžü|”e`&ß@ôl×v¯Z5pÊýzwpQ¹xiXF° â!œC2Žq E âðþÀ ÀMr°*Ê®úñ.Û·òá˜E ÃÑK~wÛó![ ÜÐò$Kš5fÃaˆMí(mN‡ê’ý1ØB13dJ3¨nåfl±ÛU%Wf9pà!o¦uÄ^êQÝP7£3âÇbDYäKoAtj‘ ⱞÊ}î.&€nø<\Eÿå’b¼ŸÊ^r3—ƒ‹n=ÕÏøB’vJ™ŽäèQň Ñ+Eñ2^JM1…ñ1#™‘ }š5™ðIÀÝ9£W‚`*‚ÔˆJ-¸¬ž;É7G²©PNX7n´:ª…B(ÙC’C,WwhD±,Êf7xº1ã'6Ö}Z±ˆÓ«ö™ðèaT ƒ­ “Fv™NM;ΑóÁ¹®Î° Là¸ÚF;›Ì¬¶!©O.ªi\ÐŽ©7Ó]¯ÁMªàå ¥}7aHd%ŠÐL2Ì{’ø«¬´iÊe‚ÒÒ45ôéçR\6 PÜžè$Jm&<êS3èùGåP š|iTŸmÚ%öÕX›$â8‹|8fÇJ„¤å6Þ…Ê’í*‡Fq²}€ç ˜"a-$Çf\äìúŸp¸Ö±˜ahÉTÊRºDÄÆ®ËìULJŽ) íM÷¯†&ÕU«‹Pª†d ˆs†[Xa¡AÐ8êx»—ôÒüÄ‚iäú‡söø2)^fy¼_5¸ßÝQÜšù—gÍQ¯CÕÖºd’šµT Ê,ƒvS¦¯{¹.˜‡H@š#Sh˜|’.RNmT0ùÁˆmJuÁo‚"ÐF ]¦HþÿBÁ5&šN µ7±¡…Ñ@¾Áô°:TÂЄ)kazsuè©174Åõ`P ’2 0Š-ï‰Ã‘ÿÔGl°Ê\!…„b÷? L¾Ÿä\%”YøPƒ[œw/ÂøÎa¬mæ,VbT‘ cä(ðÙÄÂ4€?@}8ÿ/m!Â…†ˆ;@›„C“2qPñ˜"‘VI‚eù¨Ø‡->¿n›Z›<Øð@¦0ÿe¥wùaR$š$ÉAw#BJp¾k“L‰Äq‰Ûx¤P´,tz¦µŒO!kõãs®ÍDN–ïcÇx ÚJYmHd*Ç4éóò ŠGØá¹ ”í¾Îâ1¢Ú{!š4ÏÑ ¥Åá Ù ´Âr&`Å‘9=tU©˜½šENrsEª6„@çZ}ƒOx5¤#¬¦VÚ§ŠÍKh2 %ÊÀíUx‚¾ æ,LÏÛÓÓ”H˜˜ E‚„r­&xH§Má2pq¯ÑÄUÏ9ûu3’æ´I°%¿¨qSÝw‘¯± ƒ¦)›œ#¢å¢a²ŠÙjŽ×¿Kakòçµ’N~"?ž„>'ëBÉClMˆÀ=M Mø@Zã wwB`íéhŒsÔBQGgš}JÂ@>sB2¬M‘£"XÊ‹†Ê3Îö8LUÉï «#FV‹°më0‡×ÖÐ ‰dxH kªb›";zÜ>Tέ…¹°šfW’&±ÌÌdffàãx‚ìŽÄPr9WöU(ßÖc“™‹ ój¸PÏO¢À˜ O.£:„xE9!0 Xð19& ¥¶”D%FðÙ0Äèô‰±g‘@¯&/¢R¼®CüÓ˜T"> ŶZ,ØŠtázwž4Ô€‘¼ÃòÐÀH†¡µ ÀSѺ†ÄBĈ¥ûÐO •|ðt“³YíTð£èO ö¯¦t©ítYgô "’ïâ¨ójk+M{9ÍlCŒÐØoÐp6D„ÞŠöNkÓæ~Éxpqod` eÐØ9^lÃ9Z{q{Á„8UZÜüöp­#¦“úŸ/XN‘®£A{îK×è„*Ll&™’¿xÚ ßj lSHW¯µÇCª¼)¢?JýÊÃÃ+°)=$±äˆ€_©(›T/oöö³8zcl–’)cÓõÞ@eaõ¦WâM’Ä(¹±LXŽâ¬gh@F•D­™nÝë Ú‚:k)ØÚ>:J™Ìñ‹\‹sU¢~5ß Nd6æ×ׇó”9ÊÛÆyèæiA~5ø¼JÀ3*š”ˆ7“ò‘‰‡‰ÃEÂoWÏ*…ž$ýV\šÔå#·@Öð$8Q|-+›0‡ ì_Ú¯"îˆdj8‰;Qç0ÝsqLKБ´^€ÜŽqó`(*³'I «ž‚BÇW%‚Q²áh =IwÎîÒaéŒË#”¤ðx” 6š¤±½aO7†BÄP“˜¼ïm<²V85r YF^§áÉ cM…$aßhIÊjÌ™vI­Qs¤á³Íµ5þªäN¶ÄYÅ´úçÅ9BADÀ¡7„G·‘b‹âUþq<¡ž*V0EÚ= G¾ž‚ç#!ƒùGô ¹ä§Ï·ÞÕ>Ñ…Ä2XæK —ð$õo†OÄbÊ àæ(X1ÙÑÃè@„á|ãÄ¢>äu‡œZΔæBMu˜jqÓµ,µJw\ú–‹m[‹6L#¶Öƒ-m.!Ë© ÏÒ|K7ÖKbïêÆ|œ-¨Ê² )?·Åç~Ëö³ˆ’œˆdÍb4¹â}uåZuìÚÄ1uY`šŽh $¾)¢>!þ>Ç¡-4w=IÏÁözàA8[ˆf¡f ÛÕwÝdœi…ÌѬzTÔÞG8» SAæ äkóþ¼k#\ï4“ñ'¢šÀœÆí$þ\ÌÅEˆ|u¦äö‘w11ÂÝ^M€º€œ\¥nµÎaã-ÇE:‘:Y`þ®,l-]©D¶aÄfµ'p¬RK+€ e2”¤9DKIFdVóay°@/ ó]„jûQÆQ\Šì’g*¨1ß‘<ør#B‡¨çŒÜš$ôŠ¦9r]ÒÈ ¦SôT‘‘¦UËš+ÅœÁpûüPúí NPý3Àxá×Mg¢ú¯lÓ£½N¹¿; ¸QÛ}DôijbFñ;wÇ«jó4¨NÒiúàC|¡Oª³ÿ€SŽ‚º‘=ÄB¿.Ú…b11ê››úh4ŽŽ£+οó®‡fã]ã´Ç‚þ=ºë Ö~¯mãÍŠ¡{cªB²#® D|*¤5h‘uÐëò5(ÎN¹ †o2I:Ò‚X$˜Z¨ÿF u¡¤&f׳> »qÐ\Š ° |I”ÝíÒ?œ¯÷·ß^|¶é@'©h’=XÔÛ‘jB&b—Ö#L Yù0~° â ÃÈѳ1}ÉèƒLïü\Iú¨Ï÷Jåò ÿáN¾GÞ{û%Ô6à€ê/ÿ¸íPVAwâ¢ÄáÇð©6ZDÈ ã½É )v ·ãK~Ú¬¦Düe¬ƒDŒ†¬º]›‹9•c´¥±7CÈP;€jµ˜¸ÅèÈK´oÛ ÒI Ù!}s£ÛCU¾ª¹×ÞŦÈoP<Œ½êæN–ƒ1Œ—{. bÊ^àÈ ¸}|ˆ{·‡ä›¦cÌ/‘b1pÆËhK4?bs?Ù'K©©è¦Ìrà‚ Lœ»PhF9¡ˆGh¥ùxTSÒˆ>ŠM]zh fž±šß p–Âg÷œÅü\µþÁùg½ÃÊèjd-•ª‰Àqo• m*Ã/îi,T÷ú@ö2šó[úúmæ¸5&»——‰šë_Ý•l¯êYæñz‰¥hF=íî…‡ìûÊveÁíöºe_Äô1ò,»`Ó8Ö1ï ë¬K(7zømúNÎéN µ%¡n˜Ú ÔY_;¼œ°ž®+§™« Õ¹S!­DÌŒc 2 ­W5UM"Í1|Æl ½&çŠÀ’°{íy¦Ql³A1ê94ÏMž‘ŒÄÒ&YÿuæÜŒ nazn)Jr¶XS‘(µñ`@ ,ƒoMÞÉùñ‹ É `=8Tùq½Dœá4ÔŠùr¤ë)S —„Ò…„BÖŽþ‡©¸+9ƒ¤†k\貞N5ÚÒ1¿#-e™{LrP¡xLÙeE@KʧŠ8¬\Ë»ÖIÝ^PˆŽ-d ¶3åÒHO2Sünµ¨àÿYÃä¥WÞ›uY–A¹‹%VFëj[²“6¶–OºŠu<Ɔ³“-Õ·H#7궛­7ôn€Œ?/¯?¼2þ¥px9&wèù8éòiŸCz‹fO• æt“uæ[›Ô[ Ö “lËç4y²Í†[ó)‘N `‹„¦Xž`µ® D–9tRÀà \ð!ÀsËŸÜer‹©o¼¾ç÷qÛœ.X½.õ[ÕïK»é{Ýžî[A,[i”V•[™fÛSÙ¢Ëö×´Õ®l´öÌK*ì!³¥\šUERmIUõ©£Ê¢+óQ]U§U+UåJU»ÖïV=H”4ÐÕI Ô.Ñ»A]$ôbPõAÅ"©' •@™Éè'*šß1’d´ôg͘ =ÁIÑ'gzpI•Í†h38˜)<œÁùצ¶ÌÔ‘-)Ô†R¯È”*@ü‹-ò ¤ƒËœ’õ%êH$é ’!dKŘŠ9f<,Y˜’ø²‘$q$c„ÄñƒÇ~qL¦ŽèÄâmhOÃ:¿õ0¶…´!9° @€ôcÝ´ñ›ÉÏ'¼\öËo<.ðcÏž/yCÔ/‹¾xó÷ÃxûÍÎ)º®ë¬Ž«¹Œä³†œÈæÛŸîö:ÒéS’î»`æ·X9Á«Í×m mÛöÚ WíT´>צ¸›;j¤Æ’[ÚÒ GMB7å¢f§Sj-«–™teÅvXja©’æ]c‚vKXÔaɃ†G2`ÁžÖ_YŠd½‰³öÌÁ°Yg ŸFd˜²€£ŸöUÑ–÷YRÚV‚³…‚KǬ]aiºËŨe¹˜ {ºZÍôV’ÊÕù×#Uãa†&á`f`l;Ñ[­èÕÝŒ-0m>)‘y–ÿ Ôÿm>N"!#0Ú¡ C/ÀæÎÔ$eA½nVNႨóQŽ±&êv[¢)À­ƒ‰BÉPÀ(`[ƒLtRÀôô†f!OÐÅEB-ŠÐTdDê¿*¦Ÿ~ìâx!ÍÃ'O©Š Ðp!¡f%X"•E9…¢s¬ e³ Ò–Â %…!ì(>æΊ¢eôïÈ$}óºZ0æˆÁL „«C¡@Ûà‚@à¹CÅÝXÆèy›LÃ'ÕZ°HpŸP‰IE£IB¬ÏÅÇHI¹Ü_á“¢€Þt{gF‘ sO† Ë‚åÄŽAZS ÅÿúüÛ<M˜gþVÁ¡‘ž™~ÈßÌÇþWÁ IÊ„AÝ#ñ³©´B|uÆ€?YêjP—'Ë¢ç%-éŽöµ¨×;PÉàÒ×IÞ8å~Þ³*gæ ´±¦qf÷“‡ÀgBf2=‘+Ò&Àó7ˆ×+òT¿åà‹ñ"Sb4ÏôÕ´*Îq„ _@CÀƒꬅüæbÞ˜öñ“ F›;ʧýœ¬v7–àG_ž®@V=bðD84fÍ}¼Ü*ïä]p%ÕV`àДƒp«· eÌ W$‚e4ܾJœÿ*;°qhž ‡&•¼ I|Ož aƒA Lyé€<&î‚i¯ |À vãv𪧧aá@¨A¼zíJmSàºP€@ª†w› Ó_'6gŠL¥2L¤I`T»‘’æê {à]Ù(œÅ.¨3›xþ­¢ß YßU8I»9–àxb|Rƒ%q"Æ{¦sI³ÛaaÑTE5Yv "Îá(´Ã£QíeéÄ•Á—Ÿ}†RÓ¹[©-èvqdàT|Âí⦃ãñó<àq@Áê¿x?ØãêKœ"·˜Pðx|ªsÀópµv³ < Ælƒpÿ.jÖþV‘t/³ë³* ½[ÆÂW‰ (õv¶¾xƒùÆ챸ìQ>§àðëzµ+ù` –¼ß*ÎGq^1oÕ\ PNW)Ñs¡À ¸Ó ð¹Ôá7žYÑÍáLÝ-¡U ³ÅA`•[ã±¾dø¿ b÷Lš=cŽ±)á‚Õ¢„€`–Œ‘0.,´¤”Ä«Ô‡žòd[5IFD)‹duÖiØ`\J ¾¸€; W<6¥"%jJA„åkÓ„°‰n…t$ç±#Œ'KŠ™::cAz^.£BJ¤.¡e"’ÛñPËÂÀgušÑ¼&`‚åýØAkì <ðQ¢£‚PR•%i­¤à~ÈuS*jaÄâhÎ[¸J,.B(iÞÕÿŽ »…ä i¦è¡Ü–Ø„ÒÁT¸ðÙ%l£­Qºi7Ms;ó‚iÃÅ8·à®+`UÊ¿«ò`9+à1ˆ])@ÛÕÈŠ,Žû°]M›LØv–•…60›Mµß¦ÃÞ…h¬î1¼³AËÆu±+ ìÀ|+·¡•Ü€u°Cj[TçÙ#³²­/`íÈN`X,CÃéýke‹!ÓA}“*öY“áæ„jòr˜«J#t;¨¡*‚6nKˆÒ´mÂPj Šiw¬” R°ß¥8·LÁ%D\m™ßD¬VFáu†‹ë»¢zâªÔÞ©ég¢Q¬’5¬“MrnŸ Lݤx!öDÑ{Õ¶s>p€ËË$ÑlÙ îÅ3b-ˆ¡Vլǩ2é‹aô¢zõ’%™¨Š&cLM |kΣÿª¬¤BtM÷ª#õÙ?BûßõÂkß«W_) …D3„wØωžÃ{ÁÆ–«½‘ú¹÷^xIœµ{—…•ÔmPBñc,Œ3QvŠð)ûNRÑ\@xwË@ ›m§;XW@mÖA'u'&C'W1ÐÀ4;*kOd<þÖ?tpéUÙ©²xÕÍ8¢@*ÏR¦Ý´¤e&F©£uß)9RxôHy†Ð“á¨cÖé;ˆ«GdzÀ–!Û5`>(­Àz¾kËFMz;ÈñnØSRÖÅJÄÝB&QSy¢Ä8FŽÓOõÔ½€`êÞ„‰ÚÞέ'õBõFö¢ïé¢Î@â“Á¡W@,3#jú§dðHæõÁ*D(~õçM²HP+àîSÖ—Ê@5P Tú°{ð²xÌõMîœÊa¨Ð¼ÕÇ4-``Ò<:…çd¤Á†T!Ý.)ú“¦fl1ºS3çÌŠËaÁ«ØeŪ«œe¹5’TÇ"ÌIb¾ rõ¸_v{Œ‰Ây<°SâÁÐL(Þ`áòt®Ü™¢Ú¹ L0õ%gšì$0Š;Êx¡z–ñT9Â2paºü†Õ;ÒÛ'f¹ø)ç°¦^Âéä)‡P¥‚‘9Æß´MìÎŒtË ¶ µÜ¶8:ÒàÓC‚ìN °¸®à*›¿Ô]ý­(0ú©(0ôódðëhæFÏ‘€V{ ,¯Œ€,ÊAbï…R»Û(MSôä£àSŠ%L;ºŠŽÿQ-ŒøÍìHŠ€*”h¡Å 9´ŠŒ‰Ê½@Ênæsb[®S8¨Ù`öWOÜ“tjíòx‹?3€ÂÜU“²ÀWã”ëjpÕØðiJg“*)E´U63£Ö6wL½é¥d5WN!åHL³È /ÉÌÎÊ¡æš5lXÔ£. ¨ÏÏçPE™tü§ÈP,šÉ¯CzIÞ{Iœ}yéúÐ.ÇЗv€<1ßãÌŒ[ïs£›ëð8ð.ÄZ3+.‹^ëÜŸ€Uˆ–Ñ gö˜Õ¾=Šœ•4 …¿ ¿÷a(MÔŠA%ChÁHõýÞ$þ¥"p‡¶Óˈ!ÿ>£ÞI ŠB‹QoDJÛ$KM'é`²Ä^ðç-ˆ ¬I.„>v©ÄÙ&Ó·M¹C '"-̉J¶;,¸®Çî ÍŸ› ",«Ê« R8‚ D}ºÒŠ´‚{ñ)æ¸áG”Ñ8Ñû¶5ÔšMT¿‡M¦PµHƒ¨t6΄] ÙI€´ŠâMAÛœX‚Š$¾Ô|À´PÚípÔãY<“‚ˆº3ÐÔ¸OƵÉ\ê6‡'Â»í¯“WLy®v @„õ"Ät˜ÞŒà¤Y總Os— Ñœ‰\kßÚ¢eEñŵAi€cn¡òþæÞÇ¥D×ǘŠ4§–`>ý®ŽZ`“§DÛ¼¹! ¿lÓÉn0(.Q­?küG¨êÞ{N,T@=Çä• ŠüOÆói< ?znôyÝÕ°¢½]%ÌŽ&.¯À €!¢ÄFÑ^ߨgŠœ&Švô,ªÐ(’i" &Â@Ë 0ª6È°ŒÎéŒV{~bÁ/ÂýÞ{{_i†»;îè3"¶i6*@ðAPAÖÙ)åèùVs íºËT†/õ‰›™¯¹‚Tš·WšéКû,åߺMüL¼~0Gƒè“1~jíˆ*‹´Dd+îÙmíM€¡Æ¾ìo Fï#cða°¼ Èöõìóìº:¢À(ˆ©wBˆ’¬ÜlÀ™¥0Ÿæçm&—N’¡?XŸuÅÙK2¤³Ç,}åUÒ{ù%\oí›O™±ßí8}à¡žÝyÀÖ¼‘*ñLt¿å–$•¢;¦”8FšZÝ-…Â]׃, 2¤2Mëo 2eÍ©ÈùM–#Äæ¦%¥cÆŸcÞ`<¸æ•Mì,ELÉ'TÜaL˜ Ak-ý^©øò“HbÐû£ÅÖEOrõ‚æ¯{¶AÏ«žîd‚T¬¬I{¨‰‡r‰ø¬ÏÁ‚•±ü*²¾Wµ(Ú•¬Aƒ‘èvØè ŸbW·Í¨‹eWÖP:«ã˜Àèz¡¾æ.ëQ„l‹fb›9ã2bôN<˜c²QTb³=Òuóe¹“Ù­ë 0¡ž”‡²– ì ߉!QÎø1Np¼¬Ü' 㽑£,Ã~®ÅáñHž÷5œa0Êdr‘þÑý¼ZƲ‹6p Ã0  ÆiSZBý˜¢(Ü€ø¡-6…«¿ÞîЭpz—¨"àjkU»´E˜¶ÚBA9-ÇÈ£|ù}ÍÛ²b~"r¾šEx4‰|ðì>5z˜ù›Á¸øu0#EÙ†üf"†Â;Ó¸²dqU»žñv¥Æ¬\Ý{Fqá±, °äWåx¢Ú9Ñ:z”‚ ò4` ,|äÒXÎ?M€}Î]Ÿ ½çs—¦@<è òÀˆ±â*ÑTò´AË©Ðÿ©R}1W Gºˆ]ª’7z­‡¥XLlI U(ÊôåEoŠ÷t6Ýî'àÄ FHÉRg¤ ¿‰à<Ée_‡€q*0Du…ÑЭí¶Ü©¡àe¢Æ< ó Šr3ðg†Œà”)„LOÂßįñ nÃÈz»\ºl:‡+ÿÔÃbù¯[1âBT®Ÿ@«¥ÐiÚ3]¿:­ô¿Å/ÔÚ뢨&§W t±,fÔøˆ21ûËûË Û¯¬6OYP'ªµð.Ž‚ ¨ cPÑš!ñ¤ê'¥ƒ=™ºÖ p‹$Hy‡é³“‡‘µÈ8gH#Ýu/BI€éÿEþå7**ÛaŒ|"8L^¥šIú™‡ê¬8b-¼wõ  ÀÕ4mó…K2%@ D PÀÉÜÀÈ,I+«¢Nh—\¼-Âwbó=%¢TÐ0 Wˆ.ÛrØ€@=À4¢2,)ƒñE›:Îqnx'ŽîNÁ^ȆtÕe/âD:ò+&+çTR LDáêPºÅ@çí5/»å´’ß_BŸñ ¾0Nèiô¨J‰ûÉQ7G2”­X*©VK ’*$7m¸…ý&ÃóMy‰sÎP°3î‘”[ʹ :…B!dwPs q¸^eF‰špϲi£šDiâã/Ï$ð¨²ô ‹“üˆ´¡Õñ›‰j´¢Riü±öi}Oƒ_Ĥ ¨;]æ§Í“ÕR¥)bñ~Ý`Q~Þ¯4÷:¹†oN^óK<ÙÈ—fæñìIóÁ®).u°ÅÙGú¬àfF ¾Ä(nå‡_Ÿ¸(4lõa.‘y(œnô(js30Îc 2Òø’%L¡g[í<Ê\Ö#¼š¶ø‘ˆ81½â($5ìƒäÔ°EbÇŠ±ó¯:`r–Aª2Ð¥³Á×K¬± ®×ˆã¬ü£Þ†õ M…•±OÓÓ!wçF…Kµ´ ·% ÛC}·ÝKCö bÐp+É'Œ^*‡Ä¡ð·Ð*î%†Ÿƒ´â×9¾¬•þ ‘ëE:AJ8¡ÑJÚiÏ‚+q,-Õåá!¿ý©y|aܬî4Bá8ˆ[z]ôˆ[€‰°>+’®aU€m!ƒl¼Y± ø&<©)a 3ñÄ2ó¬8ÀÑÄ%¼¾Ch¬ª£¾.DTÌh²ê\[ü<Ê·`ïˆeWDîeã,~OK¸©u<åCc3áîÜ@_Þ±7×Ç…¯Ê“:é\A’?\¶¸ž5¬Nl¾˜·n:úhú¡ˆ÷Lô`|bK'ÈMȪT¨ÚSp@|Ö™ý—nz¬r;UÃgŒ8©‰@YÅ4¨i~\E#ïd®! %mš‰„븀ÌÛ¶ÛA@uQ" È;:ñ—A¤°8ßë ÒSú‹/<ùÔ¤ûM`80’2=X™•’Qž‘–8|/PÔÿ¹^^äÎäN’4¶h¨b}Ò ó1×C:ü¶ÜE—¨f$Û¤Y´pBdQô#’ÜvÄ£§ž8VËÁ¬¢Kö“dMJ\”©6½$Q,G'l¼ãr_ pâÙp–•·È02ü1ZÄH7=Ó]ˆ£{ª;­1¬PР֊g¤üÍA.íi–ǯ™à6~.h]Ä’m1MÁkH²õ|¸<"qW5ê[J~–X(@ç @ã8Çœ‡5ù䶟O¿º.ß!L!µ˜ ›§—&`œiÃôØ^æG¡0%|Lv_!+à6´WÜ=²ÓaD ‘Q*W‹º°·ÐÅ=ãDGÅØ $"þEί;£$31!Ä¥j‹y´V¶”ˈ’‰€f‚jq”Ì:k#zf芙IÛ›ÅüѼ·¡ òt|™yAG')¸ Òš½#ëã4fõNÅr"Œõ¦¨YÁ[hiàcйE©±ÙÃr¶V( ¿PU'ñmi(3Ì,¤²%ºæŸ†L92ÚÄ°ŒŠ¢ð2qÁš8òꈚ¿|ÚJθÝ9ÿ:®úB%Óݬ¸3›h±À™Øg…Xæ„Ê\BlÞ–®UM9Á{¸MF·$ öË“ ‹'/e›4ˆÅ\´Ò#Ê~R–âa-pó=mÃ)n wØ9$]X’Ë-Fè ®©§ÒŠ3u $®2Z¥A?±„& …éPä«ÏxÞ"è+Li…çå"êvHSbrUþ,'³¨Pάä'Y’ñ¢ÎÆo¯ãê–´q€"¬›‡¤ßœ "b‹/uäx.^/³^þhª.Ϫñjó =®l®Â{’Û¬,] E^#)¹¼¡`ú° 856Ų<ØÙª½hÜ•¡jòY•Òðë<ÂvëîÑ ¦.‹éqÑbK¿ ÒX1)x|=ˆÞÊ  g:©Å£Du ÿ©²Øä žŸÁXL"tü‘I¹áñ¸‚)¢NVÔ!Z¡üE:Öuç²A' o–qÈ„UÉÌCpÆcþÑq$0£—…YŸ•³9ÈàQ©~} £ÜõDÌ—Š> *Ë( M”–ê‡`JJãAh Èè¼x Í]BD®’ÀÄ‚™µk†§”êíæ¸rehŠ±‰þe±ZÆ$ÈUnR uÏ€FÔÁ…®¾¦Bµ5Y_«K?nÍ«AÌBÃô`€Ø±?‹fÙ ¸6a™PÙ† àhäÆ%‚ ƒ¸q3ªŽtªÉ;ÃxŠØõ-‚!cÄË®1üÅN€_=õ 6ô ï~c'Ê/‰¤0Gâž±nXÓ©™Ï[É÷ŸÊ®¼Æ2ë–|ˆLä8vJAÜ5ͯ3”–bfªìàëþ [Gãc¨_8]^# ‘p‚¯¼L«K j®X¿²¤Ìé\Ô+Øòùn—òbŸd.ß›Óý·Áú„ɘzöS{ÙgúÕçQ`}FÁ>Ú? &‹ü ùLÔ®vqÝ~TÅ™ XÓØ»˜†è ¯‡£Öxè5`Ç;.ý¦—~ã±ÂËE+&°Ô˜Pªi›ã£ŒÂ@›*Kd#™¤úB.¦ëk£ ³b™^ÕCS°£à ´0–Ðù’ÞQa|åM€…[ ƒzD_!Cä!Ó;ÃòkVÎäãëÏBIù¨ê$«§@ƒHDXìKÀòq·,€6Z¨íÑ´pO ñB ·¶_àY"…íÎР›dðl›¡Gš‡9‹;ü3Z>  Er c\H£œî*ÚM×ÞLpvJÖÄcÊ”à¼(Èeü²Œ„=Ì\1ùRÒ©±:“;…st’N†}0‘ŸŠ„ý)a;jKjè{ß’ m[@h}LÀPS‡¨…X25Jl¤£‡Ä,xæ7ðٮݷˆN…=ˆ¯L—â`34Ôúj^ëJ˜Æ-èÙþ«Þ šJóݽíÖF 8‘Zäî'™¶v‚$0^œ²ÉsVê Wÿ–ä%±:åCcæ „­)Á k€t„/DÓ²åú¦ ¸\/"³Daɬʎ›¯PXqY“’£šKFõ•-c 7Ú£/ïµ²ŒªðzGâK@•ú¤€èé{ÜîL*ø/žîÄØÎ=¡uê{ì³Hضî-ËnãL€*T&½@µr?@ç€=Ôƒ‘µØb2ŸÀÔSI¼µÉä)xΪb[Èq,MÖâÏĶwÎ"Æ‚0¡CYf—mݺsÇ1{¾ŽG­°¿HÛ& ¯âëo3ªGo!.jÀÅìd£þF«Ñ”yŽZ[løÇ‹ã@Ú™wÊڙ̒í1ÒÁ(få™;uWd˜`mÏ£)YU?’+Ã8³#ç8žE–9Ù 8Xia,  Ks^Ùþ²%¿y>+;™øTWäë.Ô#£/(ÍŒÉ0ìÚŠ×컢[ÕS3âjú+º‹ø<ãÊ¡j—°·NºÛ’Ž7ž$$æ…Ó°C&oJÒ–ÃLŒ¼f«»KÞLár¶rÒ+c-+MzÐ#£šJtag@å«¡Ò×m”“ „@| nŠ}óŠ¤8¤›U>,È6TºÚ¨ãiûÊÒÄ2CÇLñ•AÐ jгU2[Õˆ#‚<ŽwNÔ˜¼Ö9*¼½;hIv†\uÅ1IÁÛ‡ Š*ø"ºê蜊V§á:êx‰ñ'%ø A—àÌ*¯"pèñIÕñœwA6•~GJhXóLUÈó3Z;&Ýæ@;3J¿¨xY‚$¨$ò4W€èç≶”ªI[,Ñ0; ËŽÄ=€kîv­ pìàÅ’]ņ±¼5L–1á9w©'` L-ñ7AIêÄj‘_Y¥ø¾0Î2‹gÄ~’Þ…©¿Éâ65¼/¸;šhoò_YSD¬¯ °QÕ`8ô}tf2ÍD!«‡Ðð³sT½cnŒG Þ'Nm´ßŠ¼ †ØÆj¿­šuzQ†œ­d1ˆ¡ñ‰4ge…ò ´#¬°’®Wµ=ä˜%Ö‡Èp¦Zž[®4oQƘãM#J´Ì´Ø2!ÛçHâWp!"Å™*0 ë KÂÃ0…Š¦¶eÚfÐ`06Œ’ p}çt€²ÅJMO »g DïÓ0U”}Qj³±Å]¬³i²µŒ±Úé«76³S$!÷ kÜ÷ž•–U¦ÔMùù}Yã ©r*À5V°G§è/§Á¬c€» ¦²øõ iMƒµ ÇÖŠ©À ñ£b*£ )Ë fwÔFôYÝö͈Ù“ìŸ §X EšcB˜v6%Üʺmª ’zR@ é¼Ï‰r¬ÒR1¸Ø½qŸ‘РîN{,Xd:Ȉ°´»[BR*Ý»¾™íB9 Š7„e&d…Ì,NW ˜šn:/†žÁÌ¡ Y]Ùy Çï¤,ÕŽv±ø[Æs—â |Ø/‘˜eþjËÚÔyjŘ•| ‰dŒtsÛ/2´Î'ÿ ŠÃ®”y-Œêk.NJî *Huã—) BY¿ßô³—· AÏÁ"Jc&|÷©ËóÿnFF(»iù­&‰0ã‡?äñ‹E—T@†¥iÆb–øl%vBt]G`0Ø^Ÿëª¼7]|…²‹µTíÇäǃ­Xò7«ÃˆPØðŒÝç“X † ¢÷òCCd·þM<£"%ÿ•@ .ƒ¾WfÊ/ÿ˜ôuóí½]p.ëŽ&éô!±‘¸‘š2sÌ8•5˜w™|Ÿ…S`òHê¨~¯oœ"W*HjˆÐU'Pp¥L2O-^…j½iÎÉN¯¾݆HÖM¸QÒiWdX‡ ¡3)72ïx°2L9,wP-P¥Ëxä8˜î¤±ò§¨|TTtf Ú´cÓäµæ7v». ¬l<1÷R¥Ÿ´¿jǘ‰.+br79xmpSm¼•Ê÷¢ù%³2ÒäîqHK–¥˜š'¦,lÏŒÆðbýBTòvNe£c©õÖ—áì’„¤Î£W¬¼'Êš†`ûÍý·Š£Œï$lÚß··®4̾;DCÑl×»8#³þe¯t#WžÀ@†ç|"?EJ°ÀÐ6úr6óH÷šñ=¤×Œ|êl2´½„ àÑ¥°¸íÑ0úâA%-ÛqD {VÅ? Æh«|ÎÜÕÀ‚ߤ; "&F äŽªÚAþ•Ù– k?ÆV·qmjjrŸçè‘ãÁa1ùÓ6EÅ‹ˆáÔÖ žFãŸ(¥«~w@<1Ö2£Óh¬ €¯vÖFœü ÇFðéåÁž'W™äØ*¡¸PH”j¬–v¯qI#‡Ã«Ø¨fz5gÑÊ–<±˜À*è r]¨GWôSª×=Cžå+=½/ö€UšI]ÓF— «Nü&‘Ò67Œ Æ(ä É®˜vüÖSg4áÖT#åT×ox€Œ^Ú:h†Œ¸œÌåžðyÕÃA¦ö’ãÍ”VOÜJd'ë"Ù„½ ZB©m Äh Ï2\J„ ˆÁ®j‹Á.€^P”ù`H€ Ñú §5îæZÒA×.ž/Å,Gî°BËÓ”ì‹eÑãÇBPg‚ld½™‰Ê‰´ˆ4ŠÏÖ¿È@ÌÊX‹0—1’GN<¦´ù(û%aÖ=q;ã£Ê=1ÂÄ^?Á»o/MH$AÛ²*NxL™² dŽ íŠ ­TJ'í3³ê&*!ƒ9Ìï“Òoì‚uŸ‘s$wǶýós{ÎX·Í¾Ì)ïw‘ 3,¯.¾ú±m@5KìÅ´ðB,Ñ©ä*‹Ú¡$*/n ’T äÔÂØиDPÿÐÖRq±{§z¸ÑºÇ # Bâ xŠ´Ü 20Á”…UíŽGã擇hü˦†”\”i­ o€ÉcÅÈê1 |Ïœó!X÷3Dô !Û¦¨÷hôƾ%±ÁäÊIÎ&…_íôØLm°E¾{Ù=ðú{[‰„* 0@Ê (fÒhz£Ja÷HÀ7š<ßÂDz:Ç€&KàœWד~nÁÕÛZcÕM…T&ôռĖ-ÉŠ‘í9“Ž´@¤4ÉDá cÖÿÁh/:{ –¬)¡³¨Inщ“µ—ç\y…>ߥÇKñˆ«S1 ¶ëê«q]»zÇBrUפîoÚß𲜮¿Þù=çÛObØÌi±g,à¨d1ÑNÕ¨C{ù´ípœU 7+™ÞÆ€Ù¬5´þ@Ù«±° Ö³C”ÖnХ϶i®¶ÿ'Ö6GŒ‘¯³åI Ô»GSõh†w4ƒLÎCÂg0¸EGÞl¢ Ž·ÿ œÞÐÏf-¤t‰ù ) •ÿ±ÎžD¿, ¯Œ!Õ£Á‹+¨;º:š!j‰ ecÊ7$²þáu*†òu¨“‘¸[HæûHïxéep܉4;åN02 í@êès{ͦÒEøéN7¥ì½G9áääµFH§½g„܃Â.:ik°¸)Ï\¹õ4!èËáÝj‡"a(-¹ÎÎíte¡›Äu>ÕX×=R±±µhíÎDQ¶î½±%Œ£†N-)‰7`‰”¶=#Yjš,B͆˜ÜÌš/œ\Éû‡Í¾ÅO÷Ò3a‚¤@Úb¢O÷k z†WáC!¤·@tf~Žhàjá(È$hÛbÂFG’K5 áx"…PDe”L%¸Zôbo'õû—hl`î[ŽàþÊE¹WˆŠãiŽ ÂåÃæ÷ó7iä\åSô)ó"ÿܯ”Ûש7*ÿÎ눾Ø$ôæMePIûâarÞôÃU`š¤¸YÓ)5´P†Ù«œgçS p˜#8Ù†Ês‡HYšÑ7 …ûwŸ~¨[:kˆš3¡0`‹ˆ¥Ör1…¿úz´Ãµv¿øñgFðŸ6PÛŒ—¿%´Ì=z°m.Áe¤ñZ2¡’Ãв•¢âgb¼Yð`@åò¾.·«Ò*ŒaTŒw¿Œ“Ìy•#œx=Óp•s8zg"4Bæ=‚ÿ\‡*š"8in}m¢>NÂ2dŒ5> a®ÂM}µÙÔR›!Y‰iôùW…T«¡áÀºÚ2×Ö–x…š¨è‹"ä5-²@ÐË1:sFxc7š£7Ñ5Î-$ÃËØæŽXeåÂ#£¾1• ˜(6ßwEÖˆ³5°=¨[4„ò‚(ÔYˆÀgœU‘Ý~qsÇy:6‘ðkˆxfg£+capBré”l*¡ ã¶Àp† ÚÕ^¢[©Ž¹gؼêLàp¶Àæ¢Øèph­ÓÙ?¬,J•:çS]ÐåûWœ¨Ù-Žˆ—SK¿³AûViDBL½: &3<ËŸHDD æ•uüž PX0û«Gûn"R€£›¯ÎŒ ³övi×IšÍź¥-}fK,ƈ)… ´¸¯ÄM¯t®–Žë=eÒKû®í•&{:í2p5`iÿ…Ä Àfè´BZ NL»Ê€“±0wcÓº¡·ªY´r%cº¡Ò"øˆ$À•L2˜—”4òtÚS>ÒœÁ}¹µ‚ ¦:˜fãïcàrƒ$ÐrávåTìcîÔW´âHO ÝN5¢Mƒz¦4n—äý¡f õg´ƒ)B—œ(óàBþÊz'ù™v)G˜ƒÐðNyQÞ2ð«°qè%C äy=•`ë†ûV©¤+%­y˜\²i1`Gˆß3F 2ä]IÌüÕ‹ƒÄ_/áî,j«1<\•@°‰Y©Z¤@µª8¹~¨Y pwú.Ætï#™pH&ðb®Y—)aÊl ¦ãÑŽ€i5˜N£Cïp©—Bƒöí¨ÃiºC]u¯ò¥tÏZ—oõªÎ&-Ê;ˆÄ½º¡^³ ¼üfÉsÑ”Ú5ôá<ˤšáUÉÀÊÒhË úìÃ#½°šw:@¢ÆÖ§¢¼Çæò„[³-•ríÔqD{{¢oÏEMôFÉ“mw–lÄ8ê2¤-6ù%Æ¥¤ú9HVÛ“,I¸è@’NÓojAQgm§Ó¡gã²”7?½ÊÝ9\ØiƆscd1jáýn¼·ÛpÊÓ@. ½!¹{;im"Ù3²ðd7öÞ Pœ—«4<x(8Q=íx2ž!zö/Ä\€Þö¡ú€R¬dòõ¡k•jÔˆªeX| †‹]Pû}Êé<`ŽÃ{®&íWU°Zéªa7ßD–°h ¦S)Œ¸0@³©–^L¹é!eK¸@’*zQ&,+FO$ÉV! ±õ!´b·QãÃKƤF´„€Ü‘À’úûë@á/´VQ *ؼ´Q`€©¾‹@Bl£¦^l-„äãÊ1çÕQA†ô PSíVçáqžñE³ÿŽú¦ ,Ø‚rñ$ê@"@ùâÎþh è%!<)¡²"Sâ0 +Š@SÆ$C$‹nó¨/Hƒe·8’اè××Ä$ÑL#aH1˜îë°˜Qgm¸ØLß| €Æ.7½•®kÔF\ å¯U@j@çOÒ¡ïƒÃ¤@J`d&B*.Z˯8sYO'€ØÝJ3[­ —‹ejBÂA˜Ä¬#ZðJêºá(ÒÆo]>M€Z²?è©‚1.¹|º£„ “ØaÕß(°c‡è-28ÄïF©KN B}…'‹-$«2ô@÷¼žì-;2 [,þímBô—Š¤PT” 4ÚM1Ü‹C«%`UÁ\GÉôÛ‡O„"¬£͈½’j{%†æ?ˆi48V[HcñÑ/ÃÖcWÙNŠÂ9Ovà£ßÞGáó«Bpñ‰@(½ÅѵfK„·T•,ó,˜Ìð|œ” Tj4ÅGy¨S—¿Ì÷éU]V ç¨L9þÇÊÂf öljB]»¦*öm¬—D•÷¡)ÄÙJ/G7Öy±Ë8+ŠäΆ¾Õâ`f„”ÄK÷Êl¸ÿEÄ {Ës¯îÓ–ñ, ²†Ù÷ñ¤9õ¯åG É9¥¿E –ZýÞ‡%¥%Ùæíþg ÇgL GŽñ®Lçn¨d¾£)·›ïÆYUƒon¹Êçâ³·rÊ+¹ˆ]îü üÓ)ÉÅ—8Ûô~¾ŒçBê`W‰E¡<¡¾'y%@¶--cyG~å. ¢öT¶Q!Öºo‡T’ä‚Ûì³Û>þÊ›ƒlÓÀŽ¹–!Øʾ OT¥Âjñ9ÐÌ ÔâåòÔÒÿâƒcy.˜An-¢…¤ˆ&Pý´g²ÈÀ䛂ÞF3‹a‚I$ ŠwHö{â GxJÒg&uÝ Ø“2ùmÜ$Tü)ORÖ­ms‘† k-‚Öj¹ÒkXO-²Œí_p“[ãv¼]b%ƒþ–§ËžV¸–ÊUjof‰¬ ÙC„£†P@½¦M_Ò”Adkjý K2¹§¹bfQ¾yÆ.ú½K?íõ7 ¯…—“ S­ÊhyÛpCDøõgøE2F9Y¨bË®9f3•¯C„5©‰”‘2õàh©’姂`ôñ ¢À.O´ñÂê÷C” f#…ûˆ ¨gm(‚x3–Pÿ $F6÷t9 Ï<¹òN‹»­á4E©ÙY@ÍBh°‹kË` PT´qý–Îx€äƒµ¦Ò0T ë ý¹a¢ð/·¶çÉ!˜]ôÙ¾‘ªqG /—ÇTµ¹¢¯Hß?)!Ïœ!(QkKm€HK‹p®e‹GŸ¥LÚÈs++• ¶–ÍÅ;\Šƒ¡tËÊݦµ+ìÚ÷Ž}"4n%†J=T–ºŒÊÛäb¿“ÇUce ¸+‚à¼+‘¨\DÈ<•}êкläãW(ºwåá,JÀÒÍ c¦$p&“w–k+‚Uµw‡ÎdÂá³)Ó¥|ÉFÕ(z}Àq ›À„C!mö™ Ìê–Šf•½Ñ2¤LÖÉGTFˆ0T4ïÌÖnì¨ÓTÃóýYƒIΙ¶Q‡ s3,EV®ï¹ ÂIÜ2Æh‘3‹5÷Rã2©ôE2Zˆ™»"ðɺ¾ï{Ñj"f¬•Ã¤ ð,ëó0b‚ªó²]!ôð²aGÆ׺!‡y-lŽÞÓ Ó±±2 sM-bjP¼Š• îsžˆ§¶uÔ‚”³Ø˜S#ïžN:µ)/)j¨€p ¬Ü™èòy‘Þ»1&²i½×ÕR´S¤Å\‰¨_Æû$Y²1§®ÎG>uÌØœã=Õ²=º/‹j²™Øþ«°øD).Ù h»{Þ|grðsîE&ùúÿ2—˸¨ù72î02ø3¶ñ•9ѽ®Ñ?‘Aë<%f~š_P_VMLÙ,“@xn:#¥9Z% ³"2,œµ\Mn¬˜F*ž,pwE(»íÀEí¯ä½Ân’ÓfıæÓp´¾fw1Ø=\bš¤,]ù­ÚËMBddƒ•þKo˜vÚÄfqFõ0;'q:ÒÚNìqG™† ¹È‰Q ³)ZêàYÁ½‘|hr@ ïe¨«u —î‡ìÌlÇ}ÝòžÞ [Ë«ÛW8C›á`úa³‚Àȯñ{Oˆþâ0q7øz.…DˆxÙìFBï²îq=Ýw¢wÀ î¾8{~ÜÐs€–Õ$4ÿ3ÍZ Õn‘óæÆϤ?0·ImxK…“8hŒ7†ñŠ4„‘rЩlÌ£ƒàÓ²)° €Ýmfûe]˜8Œ:H†B g< D%j•˜¥¤;ƒêŠ1e##g} 'Z dè£!€›ùHãý­ÅQ‘ºûD£MþgDáÈ[Qƒ4jƒ ô){‹àUz²£É‘£`¯ ñ“âÊñÂdÔk~Èù°*Äš®Ùƒ®ÀS+böMƒ{RÌÛ™  ÍBô‚j÷¥ñ ‹',Ã7½„éC‰BÌ–÷“–‘ž©Oòå\ÇíîëE±«E äàà5d¤örÐdÒ+c2tDTP^DK\¡¤ ýÁCÛ!*=ÁKë½Êe°’Üj…—ÊcM €å ‚“ Ù\9¡ÀêÇ›^ÝKl Ìš¾J|;¬ ª—:ç ÏVyOÙý‹™“L÷¸: 8ìÃäŒC¨H“ë :‰“èuÛE¬.åK¬sÇxÓ!Ü—½¸\肪F0§±ÓJ<nfdQúâ¬ð±€±ï°[çûØè»v¾[28íÅyì!àu½íºäeò*Î’}*füÿЫJÓ™˜ì‡9诛%j±ëýª(¹@à…M]ѪÛz¸ð0hFÁ#SÅÀª[F2@-Ò–ÎFjíÓÅ‚¨—ÏÍJ¤áš*‰Ÿ³ˆJr“;¤! c˜øp¼`ìµ q8ÇàÏœE28õr8±&Œ]Âh» 8 ˜ú&¯}#ÒÏg'óm–:fkâêa¼ûmŸZø–†îWˆ^aÄ,î)fÜtm¸SÌö»‡ÔcDº*õêÎ \Bݦ~œÑW¦ji÷Îëex4ɱ&'ô‹œÀÙƒsÖÛm¢B…0078Žò*ÜÀÒÝk!VúÜyµ !G²Û”0¼r›Ã¥‡ü÷‰ LXþËé‰+Ä5›Ä@¤ø÷ú ò¤¡åz‚$ `Âú“•S  Œš¨T†Ž~´Ä¿˜?bC$ùb¹O³rºñx|˜ºDéѤ Òà TZ <$²ê½‘Ò–5’>_°Áiv²>ªSvÈüíèÏm9+Ë™¢–}ÌT.Y­Yl(¡e`Ô »\™JCTWp‰þm¾2®…dHiIdÞ¡š‰s$[(ªmºâ¶ËÒd¯í±lL™}°‘<Ôl ,žpÇZ,ç$(Ó¨•Zˆc”(ÈËT…w8\Rs#jjئ¹‘-ó ÀÀ¡hQs¬Îf÷Šv‚ñz` ’Ã4[ñúµŽå~-ðþ É”h˜ðǪÔ.‰‡t¸í'Ü—4@žBÙË€’h"4qDòùL<"u‹œB>cšä ñÜÃÍzšÝß.C®Pý`ýºi#9 @[ÄnÑAsS5;ÈH¼Tö#\ÑlO`¯°þø˜,;1l1dŸgÐôv„‰Ô.¤ñ4!k˜Œ/SœbqÒ‡@šC¿°Š{YHËÅ”Œ¼&{HÈȈe5ÉF˧FË…TÐ(K«¡èfªø£Ù£MZ°Nã82Ôûá&G8)[,å&”•ßž„¢ê´— Zw™šc7=Ûp;Ç”açRûñ2ìÖª\#y<‘Üa}ÓÎó"Ì#Wfž FN[+CY=²³`Y:†\Ú?rtà¡e! hÈ…ä«¿þçüiÌVÐíÍPé¸!üZýŸ±î8Hò‚ûÁ ~5 TÒ?2j6Öä©—i€f ðS.ùÉ–Ç÷ÀC§µËz}l9œ‹û¬ñ84å ñƒ„ÃäÀÌë+ìÉbæØÃNcà–n›‚y{/%å·¬JÞÎT–«)Ùk£ôì!,Ù–ÑZé=¨ÌgŸ†ËÃÔþKêÌ:l¹ R2!“¯i °*CGJJ‰u?JÌÝ ›·Z1 0…ú6Ë©ª³F¡{z.³zð4m¡,Û1QAÁa·±@‘DùUO”}]ÎAJÑÀÂ0é-3‰ï„…ènÅ1½•vö0„¬ÎÆP2ˆ üÒýu ”ÍEg<ëUIØÌQ“V$²L€Bœ|Ðڟ䯂š{2XÕ”zm5<ÓXÖ˜)…Dúžñ[èÉ+Ú7Ò9=0*áœôE~õn*,À“¦8`¹/¼ ²À7BY ÜÀù.š«QüÉmÓºRœq‘4$˜«–2´M§¦{l”Jéœv|u¿ÿ‰Â"â}~W2ÌAØ–5Û’DK$Þé¢o 5ñÞÀ¢€ˆ©ä¢{ø¢w_n³÷Ö:ö§;ZêׄæQ“*n¶hûH§78ÊBàÛ¬$i ˜$¦Iz‚†W’&€´ÉF”  ÍÒsïs¼À¬Ö"ƒn¬@P¦Výˆ„@h!âèغÈxDœ3©ñ{ùµ(++%vEˆ 1Í8†9nZbí”Tˆ0)9À?QÁn–åø i„cŠe`B¯Ñ ¥°L0ØöÍ`¾–Lª4#c«µ øæ#¥n%{átNE¡º€1RyªØ(Ïê‡â*Ø׎;,ö‰g˘9þ¨Ì!Çì(€=9‚ô’8|îbèNþ>}¤÷4äŠpüE6…>Èq%;Ì%õÖÿAÌ“à1ìVŸGÛ¤…|M†XÞø„† ‹ úÜ;À¸±‘—èÍAtÒ¦òNá[ÉkE¶D ¦"‡,Ó¾}d€½ûFò¨›€X ÈÐx ¤QXÑAF«ðêºsÏ$9«-] ª³8h€Ý2Hü~=Mem/ç÷6¢)>ÇÖ$oánÂâ¢z¯!ä‰D’´TÉ'±#n¹Zè'͉ëå 'èSd"\²ªß®`ŸÅF˜$P9~,¾îñ­bÐ1‡¸’pZŠ *1aŸˆ6GÁk?ê½ezÊôUZÇÅåFô²IÁ¸„¸î¡áŽÜ c¾ù&òp @ß i8w”D¤vˆ¬†¸ò#@`w!ŽƒqµúC"Æ‚ÕIª®„feœ†Å†SÂS› %•ŠâLΣö‘šÈvf“m*–M˜“eBð8”VN4¨—¦D¸úVsÉsFÌ!ªxG•ÂH}RÈÓ×`±PÑ ,à+Ù¦Bå•H;b4×U€´¾Ôšðã;`2O)àùï6oú(1°å6" ¬YGBìB¯ÕN‡kbJRžr~"Ø=ìšwQYñlBÜX¦OžŽ“ KäxM@Émlen;ÊšÅQœb]oC:üÊÉaSÒtÖEA•g0¬F/îa{¤¬@H}|„¢æ­ S…á !ϯƒîó7ãà% ܶ¾ú&êö[Ì9Àùøð -±ldªîÑ5úŠ©ø6ƒeü‹Ò¢2̦ ¨QÝkSKõŸdyž ?ƒ@ŠHú àb®‰ùé>…±¡£U]]5­L—¦úEû\¡ØÛŠæ–@…On[¦5ò”°ø––n‘¡™âÐQ‹,ÁÄFiªÇr‡áöD½)Ÿ×ïÁ«MöHÉ]¢ êkhÀQ€©ìÖ+  «-0f“ÅT=–u¨”™½&}]˜'úáìµ4òˆªj™ñã;IýÏ {/¼Ðjg&OÁ¦‰.ýmÌ NH…Å–4Ž‹.<(@„Ê5ÐÙ»ÐÍA¾Ìké (S :„¯V£¬îæžb¥¸>´j¡2!ë|no±<$6sóB‘EÆóÍX?0mqþy%qV‘^™?¦CÑÔCÁÒ!í„D³äM&+d–ˆêBˆ²xJÉã!ØÛÒŠ˜Ä`¿±ïÚá¼&Í Pž½xñ¶+éE\iROÆKŒx”  ’© ú@÷º ®äg{ˆÎÜ‚þ¦ÀQ©#E¨ñÖßÜIY«#‹””¨øËó5£»÷8ˆíHˤ¬“%­ g©´HÙ«=­y¦â0¨â¹@²æv¹@¼‹b¾1óÑ«òH)€£¶çoC˜´FnqmXR×p-êŽx·#”Js&ݨ ˜ bÇGð-LE6°a:T^9çSWò:‰Fe°1.ubz½y`ÂùD†C²™Q7?Í ¢zÔ½,“§ƒÌ¶¾jpÍX2µˆwvP|¯—Çø¸™õ¬»÷mÛþÏXÙE,3 XG!Ö‹‘û>¦R‚<ïnZE”ËU‚ö¢H’‹pEæ·²NÚp0΢Ï$Ü…Š$˜‚x…Z0ø!˜ ÐÝ“(ÄK°-Š­’à Àjâ– RœvïÌÊÛäsTür¦×€ ¡ô61à.W4!1®ò(MYwH|7îPÇ£,°5ÐU•C5º Ì Oè+yJm .Þ>BÕü•¹{ðH@×êycÓV™ Šbø­"?aòf1æÖ4|úôÑT*Ê>Š ðA 0µ;Ͳ`® @l¦‚MÆØ& Ê„"”!M¢ š"±‰bE~ؾDeGïï\Â[:èî=qjTÀž? ¤§Eät€$à›SE‚Øbq¥’Qÿ²Q/l™¹¨šÄ ¢:™àG&5:s743#þ3“yŒúCI¢“ôËæE^ FAS7ˆp- û·w «ÙþÙX°bv{•%[Ã;Ž‘ Yç-YF(Bë80™XÈtšhñ°àb‰\| 6TÔ¼™¡ôC}>¨­Ò$J ä µHȲk,íá¨7hÇÈíã–ÙÜÿ›3S4K¡F¤_ŠÙKXk·àV>éQ' _— TçNéË©öX4ÖŠmçü»I_T~ .¹µˆ9~¹RÉ F®iÄHkò#¼¯C­ÍoÄ,Ĩ€.µÄi‰%Š¸!Èv˜OÑ3‘þ%- %ÞóénÃxÎÒKÚ‰g ^"H¹Hþ((=/#û´Æ¿Í¬ ê?H³ xiôÌ P¨>bF6Á¶`4uÀ ø‘ª|K¯ºµÍ~©¹å¾È͉'z«ÂÙGnT^èÖ1 —tV‰Ï±›Fco,I×dÐðâ³a€#X©œ–¤Bœsy9Ö´¦±u§PA!¤Ã-иXî÷Këm„Ýnºµ‹]«3µhÞý¸î34zrÊ{­†Ô pc`û†ü†³Ÿ™¨ŽY÷Ê„huHÓùÃBº>c;“ÞB%ª–XX ªÂÓ£/ —É°JÔáì÷°ñ1úƒ†} ÐZq  ÃèH¡(QÀÔ¹©¤] ’$Ájƒ–“à›kX@YâLþ(çÍÑL̵?Úų'Ž°R¶¾²:!œÆEÚ>á0vZÃÕS1±ëvž7u D¯î~”øUáƒÙtOc53‹Q #C)6\â£2ÂÔBa>‚I@ŒÑ›Ë\hÕ±4OØÊ÷Ðù^GÀ#@Ì€Stõœ}§9œátí¤ª±4HZRÀ-S Õäë¸rà·t÷fŠ(¹$ûï[H®§­´ë£”š µ,‚}hˆ(d–X¦Æ¡Ï¸èœÛZ=ÎÖ#ŒµH –®v;ÞŒxšc–µÜ¼ž¯aMék»»¾j Óã Mo:¡[ôr’"Ê‘Us§~uÞµ¢&LJ@óÀ”‰þµÿ~~>oƒ®cQèk=^‡+áivšb'Æ€v,̃‚ÎGöè‘6Uèdô;˜HDÞæg•*É¢”u#â³}RCŠ# ‘!ˆ¢> þØÜ2–X¬HTJ\¼U–íØΛðV[´Wµ?¯T Q¨ouT—š£«ûÓ¥rAÁL— yó…XŠ¾ˆpyŠšÿw«`] “‹¸1kÐõ.ìi^³h¯ük§‰1©‚lÏÇFKVà–ÊFâïKp?höÄ­ÈÎ^’¥¯sàÍõÞe­úgðc ÅÙ ¾?)M2­ÚF”¾mR@M[ˆÛ¸UÊõ²QàWiÙÛú2"[dTYC¹—µ4Ú¥ Œm@᪇^ÊsCI@>’”‘ ˜^Py'üõá¢ÑY`¢ÿ¤JÁ]^3H?›_OÏ„0D¹>×Úø±ueqá2yq&YŠçˆ sœ4y¸RN¦t5@fæ Ž>ŹÁ K cj¦eãÒЧK$¡µ¬d¡œ¯ÎW“’bl‡?D:yã E’BeV w ý~…T‘ßæX«Àß•VUÖÖ—×.0‘˜Â(›T_‰ÙÆÒ $œ¾ØÉG¥]{¦°™Î¦pZ)0÷û™SûAª$#¿Ÿ_>ºÃÝ á&Êܯý>QŽrêH°)œ–ÚtÐþ@+4q—†1ö L8îHæM2@‹¿ç´8N; ‹‘aÉÞµWc?ÿÁ•‡KÔæ?–®KUà™‡e& Gá“öl³ä•{PŒø Ôa‚‘‚O^“ŸWIûfontawesome-webfont.svg000077500000000000000000007570571321131462300411730ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/web/client/resources/fonts/FontAwesome fontawesome-webfont.ttf000077500000000000000000004243741321131462300411620ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/web/client/resources/fonts/FontAwesomeFFTMg+ŽYGDEF8 OS/2‹z7X`cmapà€¸J¸¢cvt ƒ¨\(fpgmS´/§„egaspìglyf’«BÆôþœheadh86hhea ²È$hmtxó¤~ìŠloca½=œ xâmaxp{\ namePûx†|Xpost­®¨Ôïprep°ò+(Ä.webfÆêSs(ôÌ=¢ÏËTt Ï™wiïŒ3†Œ3sZ3pyrs@ õÿ# œ€\@  ©®´ÆØ / _!"""`%üððð>ðNð^ðnð~ðŽðžð®ð²ðÎðÞðîðþñññ.ñ>ñNñ^ñnñ~ñŽñžñ®ñ¾ñÎñÞñîõÿÿ  ¨®´ÆØ / _!"""`%üððð!ð@ðPð`ðpð€ðð ð°ðÀðÐðàððñññ ñ0ñ@ñPñ`ñpñ€ññ ñ°ñÀñÐñàõÿÿÿãÿdÿ]ÿYÿTÿCÿ2à ßç߸ÞöÝûݺÚÿþýüûúùø÷öõôóò á òp%tFë#¿¸Ä†fºM'ÿˆ°,°K°LPX°JvY°#?°+X=YK°LPX}Y Ô°.-°, Ú° +-°,KRXE#Y!-°,i °@PX!°@Y-°,°+X!#!zXÝÍYKRXXýíY#!°+X°FvYXÝÍYYY-°, \Z-°,±"ˆPX° ˆ\\°Y-°,±$ˆPX°@ˆ\\°Y-°, 9/-° , }°+XÄÍY °%I# °&J°PXŠeŠa °PX8!!YŠŠa °RX8!!YY-° ,°+X!!Y-° , Ò° +-° , /°+\X G#Faj X db8!!Y!Y-° , 9/ Š GŠFa#Š Š#J°PX#°RX°@8!Y#°PX°@e8!YY-°,°+X=Ö!! ÖŠKRX Š#I °UX8!!Y!!YY-°,# Ö /°+\X# XKS!°YXŠ°&I#Š# ŠIŠ#a8!!!!Y!!!!!Y-°, Ú°+-°, Ò°+-°, /°+\X G#FajŠ G#F#aj` X db8!!Y!!Y-°, Š Š‡ °%Jd#Š° PX<ÀY-°,³@@BBK¸cK¸c Š ŠUX Š ŠRX#b °#Bb °#BY °@RX² CcB² CcB° c°e!Y!!Y-°,°Cc#°Cc#-ÿÿ1]ÿ£€=°/°Í° 2°/°Ö° Ͳ  +³@ +³@  +² +³@ +³@ +±+014>3!2!2#!"&463!&]$(€($+ýˆ@&&ü€&&@ýˆ+F#+ýˆý&4&&4&x+ÿ€+¡²+°ͳ+°)Ͳ+°,/°Ö°$Í°#2°$°Í°/°$±!+°"2°Í°°Í°/±-+°6ºÒÂÕ+ °#.° °#± ù° ±"ù³ "#....± ..°@±°(9±!°9±°9°±!99014>32467632".4>32".Dhg-iW&@ (8DhgZghDDhg-iWýDhgZghrdN+'Ç3 8(û 2N++NdN+'íý;2N++ÿ€€!P²+°Í°!/°Í°"/°Ö°Í°±+° ͱ#+±³$9° ° 9±°9°!³ $9016$ #"'#"$&  o½½o|W%L46$þ©³Üþû½‘rþùþŽ1½oo½þûܳþ©%54L&V|o½MþŽþùrÿ€*MI²+° Í°"/°5Í°K/°Í°N/°Ö°Í°+2°±+°B2° ͱO+±5"°9°K³&*$9015463!2#!"&73!265+".'&%&';2>767>5<.#!"^BÀB^^Bú@B^€ À  %þôž3@m00m@3žþô% “ÁÐ:"7..7":ÐÁ6] ú@  @B^^BûÀB^^B  $΄+0110+„Î$@¨t˜¥1%%1¥˜+‘;  ÿ€€°/°Ö°Í°ͱ+014632>32"'.þà>oP$$Po>àþåý‘4ý #L~þ‚ÿ€€€'T°/° Ͳ  +³  +°2°'/°#Í°(/°Ö°Í°ͳ%+°!Í°!/°%ͱ)+±!°9°%±99°°90154>322>32#!"&6   6Fe= BS…†…SB =eF6 ’yü–y’@á>ááþƒ5eud_C(+5++5+(C_due5x‹‹V>ááþÂá ÿ€€/?O_oŸ¯° /°ͱSt22°/°|3°#Í°ƒ2°,/±[‹33°3ͱc“22°54&'.7> $&462"&¡’+i *bkQŠ½Ð½ŠQkb* j*’¡zÎþäþÈþäÎz€LhLLhL€¶Bm +*i JÖyh½ŠQQŠ½hyÖJ i*+ mþ¾¶œþäÎzz΀4LL4ý€4LLÿ€€/?Ob°/³ ,3267676;27632#"/+"&/&'#"'&'&547>7&/.$264&" º(C ‘ Š,/ Þ1)Ž  $H·  ¹#H  Š,/ Þ1)  ~'H· –Ô––ÔÞ ..9Q $ kˆ2 ¸k w3 [20 Þ 6%2X  %Ž lˆ2 ¸k r6 [21äÔ––Ô–ÿ€€€#/?GWg§²(+°Í°!/±.33°ͱ@22°E/° Í°h/°Ö°$Ͳ$ +³@ +°$±0+°9Í°9±H+°QÍ°Q±X+°aÍ°a±-+°Ͳ- +³@ +±i+±0$°9°9°@9°H±EG99±XQ°B9°a°A9°-°9±!(µ43!2!2+#!"&5#"&3!2>5!46;2+"&!'&'!46;2+"&%46;2+"&5FN(@(NF5`^BüÀB^`@ü€€@@`À0 þà o@@@@ @§%44%§@üLSyuS¸ü:%%´üà@ýÀ®u  ûë@ýÀ@ýÀf!5=²3+°.3°6/°"Ö°2Í°2±/+°+Í°2°+°Í°/±7+±/2³'$9016762546;2#"' '&/465 #!!!"& Ï X ôÀÛ >  ýLýL >ß??&þ€ÿþ€&oWÌÃþh¶ J Aý¿ JýÛàÚþ&þ &€þ€&ÿ#H°/°Í°/°Í°/°Í°$/°Ö°Í°±+°Í°±+° ͱ%+±°9±°#901463!2#!"&7!!"&5!!&'&'8(€(`8(8(úÀ(8€þ`(8ý€x þÇ  @(8(þÈ`(û€(88H8( þ€ 9 ÿ€€ ,‚° /°Í°*/°Ͳ* +³@! +°/°Í°-/°Ö° Í° ±+°&Ͳ& +³@ +°&±+°ͱ.+± ³ $9±&³ $9±*³ $9±³ $901$  $ >. 546;46;2#!"&Îa¢aÎÎþŸþ^þŸ’ú(ú’’úþØúŽà@þÀ¯¢aÎÎþŸþ^þŸÎÎÆþØú’’ú(ú’’þ@`þ@2N1C*²0+°3°(/°5Í°?/°Í°D/±E+±(0±9901747>3!";26/.#!2#!26'.#!"3!";26'5.+"2¡$S  ¦  S$¡.ý@  þð  ý@.÷ ô  º I6> ÀÀ ûì>6I   ÿ   @  þÀ€-5=u²+°1Í°82²+°Í°5/°<3° Í°2°>/°Ö°"Í°"±3+°7Í°7±;+°Ͳ; +³@; +±?+±"³)*$9°3± .99°7°&9± ±)*99015463!2?!2#!"&63!463!2!2"'&264&"264&"8(ч:œ:ˆÐ(88(ú@(8E*&&*þ@6þ@L&4&&4Ú&4&&4`@(8ˆ88ˆ8(þÀ(88¡'À&&þ@')þ@Àý*4&&4&&4&&4&ÿ€€ 0m° /°Í°/°Í°1/°Ö° Í° ±+°$Ͳ$ +³@$( +°$±+°ͱ2+± ´ 0$9°$±,-99°³ $9±µ,$901$  $ >. 6;46;232"'&Îa¢aÎÎþŸþ^þŸ’ú(ú’’úþØú0ÀÀÀ þÁ  þÀ¯¢aÎÎþŸþ^þŸÎÎÆþØú’’ú(ú’’þ^`þ  þÁ @ÿ€€ 0m° /°Í°/°Í°1/°Ö° Í° ±,+°%Ͳ,% +³@, +°%±+°ͱ2+±, ³ $9°%±99°´  $9±µ($901$  $ >. 4762++"&5#"&Îa¢aÎÎþŸþ^þŸ’ú(ú’’úþØú. ?  @ÀÀÀ¯¢aÎÎþŸþ^þŸÎÎÆþØú’’ú(ú’’þ’ ? þÀþ `#%²+°Í°2²+°Í° /°Í°$/±%+01547>3!2#!"&!!7!.'!î 5@5 î&ú€&Å<_@_<Ôý<Ô@â>=(""ýØ=>þ&&ÀÀ ðþ ÿ€€ 'F° /°Í°/°Í°(/°Ö° Í° ±+°ͱ)+± µ $9±µ$$901$  $ >. 476#"'&Îa¢aÎÎþŸþ^þŸ’ú(ú’’úþØúŽ ! ýà ¯¢aÎÎþŸþ^þŸÎÎÆþØú’’ú(ú’’ý2€%þÀJþÀ ÿ€€3=°0/°"Ͳ"0 +³"' +°/°Í°4/°Ö°ͱ5+±"²999°± 99016$3276#!"'&?&#"3267672#"$&zÎœ“k‚)'&þ@*Š”Éh½ŠQQŠ½hwÔI ‰ mþʬœþäÎä8Îzoe*þ@&('Š‰QŠ½Ð½ŠQh_  Š „‘zÎÿ€€$G`°/° Ͳ  +³@  +°2°=/°)Ͳ=) +³@=E +°52°H/°Ö°ͱI+±±,/99± ² "#999°=°9°)²,./999011463!23267676;2!"$'"&5!2762#!"&4?&#"+"&&À&‰G´a†èF *À @þhþî’þïk4&Aš’k‚4&&þ@&Š”ɆèF *Ç À&&4‰BH‚rd þôþ³nf&: Moe&þ@&&4Š‰‚rd€/?O_oq² +°Í°-/°\3°$Í°T2°=/°l3°4Í°d2°M/°|3°DÍ°t2°/°Í°€/°Ö°Í°± +±0@22°)ͱ8H22°)±+° ͱ+±)µPX`hpx$9015463!2#!"&73!2654&#!"546;2+"&546;2+"&546;2+"&5463!2#!"&5463!2#!"&5463!2#!"&^BÀB^^Bú@B^€ À  ú@ € @  @  @  @  @  @  À  ü@  À  ü@  À  ü@  @B^^BûÀB^^B  @  ý@@  @  @  @  @  @ þ @  @  @  @  @  @ €€O²+°ͱ 22°/° Í° /°Ö°Ͳ +³@ +°±+° Ͳ  +³@  +±!+±± 9901546;54 32#!"&!54&"8( p (88(ü@(8@–Ô–`@(8À¸þø¸À8(ýÀ(88ÈÀj––j@ÿ€€7X°1/°Í°#2°° Ö°,Ͳ, +³,5 +°8/°Ö°Í° Ö°ͱ9+±±99°±99±³$901462+"&5&476763232>32#".#"#"&@KjK@ @ @:ì¹kº~&26]S &ך=}\‹IÀþð&5KK5H&û  ò&üˆæ x:;*4*&ýt,4,’ &€€Kk²A+°3°+/°Í°L/°Ö°.Í°.±D+°42°=Í°=±+°Í° 2°±'+° ͱM+±D.°H9±=³*+$9±'° 9±+A± 990146$ #+"&546;227654$ >3546;2+"&="&/&†à4L4à†<¹‰X@@Gv"D°þ×þ²þ×°D"vG@@X‰¹<Š—ÍzzÍþè—¦”1!Sk @ G< _b”œœþú”b_ 4.54632#"&&M4&&4þ³þú&Œ""""& FUUF &À€&M&ûÀ&M&*.D.%„˜ƒ%ÿ¹€G-Ike°i/°`/°l/°Ö°'Ͳ' +³ +°2°'±5+°CͲ5C +³5. +°;2°C±T+°eͲTe +³TJ +°]2±m+±`iµ +>G"$901463!62"'!"&%4>4.54632#"&4767>4&'&'&54632#"&47>7676'&'.'&54632#"&&M4&&4þ³þú&Œ""""& FUUF &d'8JSSJ8'& ŒªªŒ &e'.${ŠŠ{$.'& ÓþþÓ &À€&M&ûÀ&M&*.D.%„˜ƒ%Ñ'6£¸£6'&;þýþÎþý;&Ñ$ [2[ $&[þþ4þ[& €€ #'+/37Ȳ+²,4333°ͱ-522°/°3°Í° /°Í° /°ͱ22°°"Í°/°$3° Í°(2°/°03°Í°12°/°*3°Í°%2°8/°Ö°2°Í° 2°±+°2°Í°2°± +° 2°Í°2°±+°$2°#Í°(2°#±,+± 022°/ͱ222°/±4+±)22°7ͱ&22±9+011!!!!!!5353!353!5#!%!!535353€ý€€þ€þ€€þ€€€€€€€€€þ€€€€þ€þ€€€€€€€€ý€€ý€ý€€ü€€€€ü€€€þ€€þ€€ý€€€û€€€€ü€€€ #'+/37;?Á²4+@<  $(,08$3°@/°Ö°Í°±+°Í°±+° Í° ± +°Í°±+°Í°±+°Í°±+°Í°±+°Í°± +°#Í°#±$+°'Í°'±(+°+Í°+±,+°/Í°/±0+°3Í°3±4+°7Í°7±8+°;Í°;±<+°?ͱA+011373333333333333333333333333333? ?~_>_  ^?^??????_^ ?€ú€úúúúúúúúúúúúúú€ú€ÿ•ë€.°/°Ͳ +³@ +°/°Ö°Ͳ +³@ +±+01463!2#"'.264&"L4 5€&Ë%%þ'45%ý5&5ÀKjKKj` 4L5&ý6'45%þ%%Ì%€JjKKjKÿ•k€5J°/°Í°2² +³@ +°6/°Ö°Ͳ +³@ +°±0+°%ͱ7+±0µ*-$901463!2#"'.264&"%32#"&'654'.L4 5€&Ë%%þ'45%ý5&5ÀKjKKjµà5€&Ë%%þ'4$.Ö%%ý5&€` 4L5&ý6'45%þ%%Ì%€JjKKjKÀ5&ý6'45%þ%Ö%54'Ê&5 ÿ€y€Tdty²@+°PÍ°:/°XÍ°a/°hÍ°q/°1Í°,2°u/±v+°6º=<íc+ °D°EÀ±Lù°KÀ³DEKL....³DEKL....°@±X:±99°a±99°h°9°q°G90174676&7>7>76&7>7>76&7>7>76&7>7>63!2#!"3!2676'#!"&'&3!26?6&#!"73!26?6&#!"  ,*$/ !'& ùJPþî$G]ü› x›6,&(þísAüeMø `  ý  > `  ý  ¸.  &k& ( "$p" . #u&#  %!' pJüvwEFÛ#9Hüv@WkNC¤  @  À  @  ÿ—€°/°Ö° Í° ͱ+01546763!2#"' #"'.'!!''!0#þGþG$/!' "8 8"ú÷"8  ¨þX! 8ÿ€€€'+4<o²(+° Í°+/°,Í° Ö°$3°8Í°+±4°.901546;463!232+#!"&=#"&!!!#"&=!264&"qO@8( (`˜(@Oq à8(ü@(8à €€ü€€ (8ý€&4&&4  Oq (8(˜`(ÿqOþ`  (88( “€€8( ýZ4&&4&ÿ€€!)n°/°Í°)/°%Í°!/° Í°*/°Ö°Í°±#+°'Í°'±+°ͱ++±°9±'#³ !$9±°9±%)³$9± !²99901546;7>3!232#!"&  462"–jà3e55e3àj––jú€j–rþùþŽg©î©©î€€j–ˆ1GG1ˆ–jü€j––ãþŽþùrýÉî©©î©ÿ€€€HPY²'+°3°FÍ°F° Ö²$A333°Ͳ&=222°4/°KÍ°Q/±R+±F³!?D$9°'°9°4²7999°K°9017>7;"&#"4?2>54.'%3"&#"#2327&'B03& íK5Í!’)VŠ?þ@Lþê'ƒ >Rþ>e;&L:é:%P¿!Ï9&Wa€O 'hÔþ Nþ™_"Ý:- &+# ¡Â:þí ' ýÇÿ€€€5Ka”²Q+°0Ͳ+°Í°[/°@Í°/°63°Í°J Ö°Í°b/° Ö°`Í°92² ` +³@  +°2°`±S+°*Í°E Ö°!ͱc+±` ±3699°E¶0JNQ[$9°S°'9±[Q± *99°@°'9°²!E999017>7><5'./6$3232#"&#"32>54.#"3 4'.#"Œ$ $5.3bäƒ[F…|\8!-T>5šÍFuŸ¨\,°,jþn÷*CRzb3:dtB2KJBx)EB_I:I€^ %/2Ö+ S:T}K4W9: #Æ•dŸfE‹2Ê3j.?tTFi;û±J] OrB,¡òÕ+ °° À±)ù°#À°³ +³ +°)³$)#+³%)#+³&)#+³')#+³()#+² Š Š#9°9²()#9°'9°&9°%9°$9@ % #$&'()...........@ % #$&'()...........°@±/±5799±-± 99±°9017>7676'5.'732>7"#"&#&#"—$ zj=N!®}:0e%  y¨ + tŠD3¸~U'#B4 # g  '2 %/!: ”ýáT bRU,7ÿ€ú€a}•°(/³%*-Y$3° Ͳ( +³@({ +±=D22² ( +³@ m +±22°~/°Ö±M+°2Ͳ2M +³@2; +²M2 +³@MF +°2±e+°tͱ+±M±D99°2±A99°e´ =bi$9°t³lmz{$9± (°&9017326323!2>?23&'.'.#"&"$#"#&=>764=464.'&#"&6;#"&?62+32"/Q6 Ç,°,$$% *'  c2N  (¨$"LþäA2Ê3Yl —!x!*o!PP!~:~!PP!~:~ÿ pàP,T NE Q7^ý´¡oH!+( 3  *Ue”eu  wgün%%¢¢%ü%¢¢ÿ€a•¦²o+°ŠÍ²c+²z+°Y/± '33°Í°–/°Ö°b2±Q+°*Ͳ*Q +³@*8 +²Q* +³@QC +°*±+°Í°|2±—+±Q·AIYloŠŒ$9°*°>9°@ ':prvƒ†‰$9°² z€999±oŠ±”99°Y@ $<`fiv$901732632$?23&'.5&'&#"&"5$#"#&=>7>4&54&54>.'&#"&47>32!4&4>32#".465!#".'Q6 Ç,°,Faw!*' =~Pl*  (¨$"LþäA2Ê3Yl  —)ô!* @7<  <7@@7< ü <7@ÿ pàP,T MF Q7˜47Æ¢HoH!+( 3  t¯‡¬JHQ6  whû·86,'$##$',686,'$##$',6€/?&² +°Í°/°Í°-/°$Í°=/°4Í°@/±A+01=463!2#!"&5463!2#!"&5463!2#!"&5463!2#!"&&€&&ù€&&&&û&&&&ú&&€&&û€&@€&&€&&š€&&€&&š€&&€&&š€&&€&&€/?&² +°Í°-/°$Í°/°Í°=/°4Í°@/±A+01=463!2#!"&5463!2#!"&5463!2#!"&5463!2#!"&&€&&ù€&€&€&&ú€&&€&&ü€&€&€&&ý€&@€&&€&&€&&€&&þš€&&€&&€&&€&&€/?&² +°Í°-/°$Í°/°Í°=/°4Í°@/±A+01=463!2#!"&5463!2#!"&5463!2#!"&5463!2#!"&&€&&ù€&€&&&ú&&&&û&€&€&&û€&@€&&€&&€&&€&&þš€&&€&&€&&€&&€/?&² +°Í°/°Í°-/°$Í°=/°4Í°@/±A+01=463!2#!"&5463!2#!"&5463!2#!"&5463!2#!"&&€&&ù€&&€&&ù€&&€&&ù€&&€&&ù€&@€&&€&&š€&&€&&š€&&€&&š€&&€&&€/?O_oR² +°L3°Í°D2°/°\3°Í°T2°-/°l3°$Í°d2°=/°|3°4Í°t2°€/°Ö² 0222° Ͳ(8222±+01=46;2+"&546;2+"&546;2+"&546;2+"&5463!2#!"&5463!2#!"&5463!2#!"&5463!2#!"& À  À  À  À  À  À  À  À € @  úÀ  @  úÀ  @  úÀ  @  úÀ  À  À À  À À  À À  À ûÀ  À À  À À  À À  À €/?O6² +°Í°=/°,3°4Í°M/°DÍ°%2°/°Í°P/±Q+±M4±! 9901=463!2#!"&5463!2#!"&47632#"' 5463!2#!"&5463!2#!"& À  ù@  À  ù@      þàW @  ûÀ  @  ûÀ  À  À À  À þ   ýÀ   þ÷À  À À  À €/?O6² +°Í°=/°3°4Í°M/°DÍ°2°-/°$Í°P/±Q+±M4±9901=463!2#!"&4632#"&5463!2#!"&5463!2#!"&5463!2#!"& À  ù@    þà   À  ù@ € @  ûÀ  @  ûÀ  À  À @  þà  þà  À  À ý À  À À  À ²+° /±!+01463!2632#"'#!"&©wÀw©“ '' þm©wý@w© Àw©©w¥’*ûÀ*“¦w©©ÿ€€€&.i²+° Í°./°*Í°/°Í°//°Ö°Í°±(+° 2°,Ͳ,( +³@,& +°,±+° ͱ0+±,(°"9°°#9±.³ "#%$9°*°$9015463!2#!"&73!2654&#!"5 462"^B@B^^BùÀB^€ @  ùÀ €@  ú€p pp  ÀB^^Bû@B^^B  À  û À@ þ`þ@ð pp pÿ€ëk %3²+°Í°°Í°&/°Ö°Í°ͱ'+±° 9±° 901 337'7327654#"7632@ üÀþà€k[ë[ª  ýâV¦$65&ë%%¦€ @þ`üÀ€[ë[• ýâ¥&&ê'45%¦ÿ€€?° /°Í°/°Í°/°Ö°Í°±+°ͱ+±³ $9±±99014 "&'&$264&",¨,!þ”?H?þ“!–Ô––Ô€Ô,þÔÔmFüú!&&!F×Ô––Ô–ÿ€€ G° /°Í°/°Í°/°Ö° Í° ±+°ͱ+± ± 99°± 99±³$901$  $3"Îa¢aÎÎþŸþ^þŸ’ú””ú¯¢aÎÎþŸþ^þŸÎÎÆþØú’@’À-I²+°Ͳ +³@ +°./°Ö°Í°±+°ͱ/+±°9°² 999°± 990147>7>2 %2654'.'&"QqYn 243nYqQþÔþXþÔKjK"‘‚ £‹Ù]""]Ù‹£ ”ÔþÔ,T5KK5$!+!77!+!ø€*/6>H}²(+°Í°+/°0Í°2Í°/°Í°I/°Ö°Í°±++°2Í°0Í°2±+°$ͱJ+±2µ /457$9°$²-;?999±0(°9°@ !,-.458;547632#"'&=# #"'.©wÿ M8 pB^^B@B^©wüÀw©#;NoŠµj ' €þ€ ' þ½sw- 9*# @w© "^BüÀB^^BÖ  þýw©©1T`PSA:'À*þ€4þ€*Àƒ‰þ°  "g`„€/DY²-+°Ͳ- +³$ +°/°3°Í°E/°Ö°Í°±+°)ͱF+±³ 07A$9±²7=A999°±9:9901463!2#"'&#!"3!26=4?632#!"&4?62 62"'©w@?6 1 üÀB^^B@B^ @ ©wüÀw©nB‡BnüÒBþR @w© 1 ^BüÀB^^Bþ @ þÂw©©6Bnþù‡nBüÒ®ÿCv°=/°*3°Í°2²= +³@=A +°&2²= +³@ +°2°D/°;Ö° 2°,Í°2²,; +³@,0 +°2²;, +³@;8 +° 2±E+±,;³34$9±=³"#$9014762!#"&4762+!5462"&=!32"'&46;!"'4&€€&4&€€&4ÿ4&þ€€&ÿ4ÿ&€þ€&4ÿf4&€€&4ÿ4&þ€€&ÿ4ÿ&€þ€&4ÿ4&€€&ÿ€€°/°Ö°Í°2±+0146;2676'&'+"&&€& Æý: &€&@€&&ýZ Æ ú@ Æ ýZ&&ÿ€€+°,/°Ö°%Í°2±-+0146;2676676'&''&'+"&&€& Æ Æý: ý: &€&@€&&ýZ Æ ý: Æ ú@ Æ ý: Æ ýZ&&zÿ€€€476676'&''zÆÆý:ý:f4Æ ý: Æ ú@ Æ ý: Æÿ|„ 46&!0úÐ!`À ý $ ý ÿ€€° /°Ö° Í° ±+°ͱ!+01463!2#!"&%463!2#!"&&&&þ&€&&&þ&@€&&ú€&&€&&ú€&&ÿ€€° /°Í°Í°/°Ö° Í° ͱ+01463!2#!"&&€&&ú€&@€&&ú€&&ÿ€€4646&5&ÆÆý:ý:`À ý: Æ ý:4ý: Æ ý: ÿ€€+°,/°Ö°2°ͱ-+01464646;2+"&5&5&ÆÆ&€&&€&ý:ý:`À ý: Æ ý: ¦&&ú€&&¦ ý: Æ ý: ÿ€€°/°Ö°2°ͱ+014646;2+"&5&Æ&€&&€&ý:`À ý: ¦&&ú€&&¦ ý: ² +°Í°/±+017463!2#!"&&762#!&€&&ú€& Æ4Æ ú@@&&ÿ&&ÚÆý:šÿš¦æ4762 "'šæ4¦ýí¦4ý¦4æ¦4ýíýí4¦æZÿšfæ647 &4?62"/Zýí¦4æý4¦f44¦ý4ý¦ÿ€€ /B° /°Í°'/°Í°0/°Ö° Í° ±+°ͱ1+± ³ $9±'³$901$  $3!;265!26=4&#!4&+"!"Îa¢aÎÎþŸþ^þŸr&&€&&&ÿ&€&ÿ&¯¢aÎÎþŸþ^þŸÎÎò&ÿ&&&€&&&ÿ&ÿ€€ I° /°Í°/°Í°/°Ö° Í° ±+°ͱ+± ³ $9± ±99±±9901$  $3!26=4&#!"Îa¢aÎÎþŸþ^þŸr&&&ý&¯¢aÎÎþŸþ^þŸÎÎò&&€&&ÿ€€ 7R° /°Í°2°-/°'3°Í°8/°Ö° Í°22° ±+°"2°ͱ9+± µ 5$9±-µ*$901$  $32?32?654/7654/&#"'&#"Îa¢aÎÎþŸþ^þŸµZµµZµµZµµZµµ¯¢aÎÎþŸþ^þŸÎÎPZµµZµµZµµZµµÿ€€ #Q° /°Í°/°Í°° Í°$/°Ö° Í° ±+°ͱ%+± ³ $9± ²999°²99901$  $327654/&"'&"Îa¢aÎÎþŸþ^þŸ.j[4þhâ4[¯¢aÎÎþŸþ^þŸÎÎþ–ZþiâZÿ€€ 6Fg° /°:Í°C/°$Í°5/°Í°G/°Ö°7Í° 2²7 +³@7 +°7±1+°ͱH+±7³ $9°1´ 5>$9±$C±99°5±9901$  $32767632;265467>54.#";26=4&+"Îa¢aÎÎþŸþ^þŸÓ„  5!"40K(0?iÀ+! ":o¦Wó_ÀÀ¯¢aÎÎþŸþ^þŸÎÎ]d D4!&.uC$=1/J,X–Rü Àÿ€€ *:B° /°Í°/°.Í°7/°Í°;/°Ö° Í° 2²  +³@ & +°+2±<+±³$901$  $%3!26=4&+4&#!";#";26=4&+"Îa¢aÎÎþŸþ^þŸ2À`þÀ``€ÀÀ¯¢aÎÎþŸþ^þŸÎÎR  þÀà ÿ€€/_4°-/²0?333°ͲGW222°`/°(Ö²3S222°!Ͳ;K222±a+01546;>7546;232++"&=.'#"&546;2>7#"&=46;.'+"&=32#&%ë¡&€&¡ë%&&%ë¡&€&¡ë%&S ¡l&€&l¡ m&&m ¡l&€&l¡ m&&@€&¡ë%&&%ë¡&€&¡ë%&&%ë¡&&l¡ m&&m ¡l&€&l¡ m&&m ¡l&€&ÿ€€ ;F° /°Í°/°Í°. 4?'&4?62762"/"/Îa¢aÎÎþŸþ^þŸ’ú(ú’’úþØú; ‰‰ ’  ‰‰  ’ ‰‰ ’  ‰‰  ’¯¢aÎÎþŸþ^þŸÎÎÆþØú’’ú(ú’’ýÅ ‰‰  ’ ‰‰ ’  ‰‰  ’ ‰‰ ’ÿ€€ ,F° /°Í°/°Í°-/°Ö° Í° ±+°ͱ.+± µ %$9±µ!)$901$  $ >. 4?6262"'Îa¢aÎÎþŸþ^þŸ’ú(ú’’úþØúf4“4fþZ4þÚ¯¢aÎÎþŸþ^þŸÎÎÆþØú’’ú(ú’’þX4f“f4þZ&ÿ€…"F° /°Í°/°Í°#/°Ö°Í°± +° ͱ$+± µ $9±µ "$9016$  $&&#"32>54'zÍ8ÍzzÍþãþÈþãÍfY󇥔úe‰ oÉ’VWæ:ÎzzÎþãþÆþâÎzzÎO”¢‰ò[’ü¦YW’Ëo¡†@ÿ5K °/° Í°!/±"+± °90147632!2#!#"'&@%‹&54&K&&þÛÀ4AA4ý@%&&K%54'ýu%@4'Š&&J&j&þÛK5€5KþÚ$l$L%%Œ%ÿ5ÀK °/°Í°!/±"+±°9015463!&4?632#"/&47!"&A4ÀþÛ&&K&45&‹%%ýu'43'K&&%ý@4A€5K&$l$K&&ýu#76%ýu%%K&j&%K5ÿ€K@!°"/°Ö°ͱ#+±°90147632#"'+"&5"/&5&‹#76%‹%%K&56$þÚK5€5KþÚ$l$K&55&‹%%ýu'43'K&&%ý@4AA4ÀþÛ&&K&5ÿµK€"°#/°Ö°ͱ$+±°9014?63246;2632#"'&5&J'45%&L4€4L&%54'K%%ýu'45%ýu&À5&K%%þÚÀ4LL4ý@&%%K'45%ýt%%Œ$ÿ€À,O°/°Ͳ +³% +³@ +² +³@ +°-/°)Ö°"Í°"°Í°/±.+±")°%9±± 990147!3462"&5#"#"'.'5¢Éà&4þ4&àb›™qb>#   Ç†“&þ4þ& 6Uu e7D#  "ÿ€€/46262#!"&47'&463!2"/"/&4L  r þ´&þ@& L&À&&4þ´  r@À&L r  þ´4&&m L4&&þ@&þ´ r ÿós/647'&463!2"/"/46262#!"& L&À&&4þ´  ré&4L  r þ´&þ@& L4&&þ@&þ´ r·À&L r  þ´4&&€€#J²+°!/°3°Í°2²! +³@ +°$/°Ö°2°Í° 2² +³@ +² +³@ +±%+015463!46;2!2#!+"&5!"&8( 8(À(8 (88(þ`8(À(8þ`(8`À(8 (88(þ`8(À(8þ`(88( 8€€° /°Í°Í°/±+015463!2#!"&8(À(88(û@(8`À(88(À(88zÿ€€5°6/°/Ö° 2°(Í°2±7+0167-.?>46;2%6 '%+"&5&/m. þö.@g. L4€4L .g@.þö .@g.þöL4€4Lþö.g@egššg.n.™34LL4þÍ™.n.gššg.n.™þÍ4LL43™.nÿ€€ -0° /°!Í°*/°Í°/°Í°./±/+±*±99°±9901$  $;2674'&+";26=4&+"Îa¢aÎÎþŸþ^þŸ¢¹ Ü  À  À ¯¢aÎÎþŸþ^þŸÎÎý“  m ü/ ¾ @*3AJœ²#+°7Í°(/°3°Í°2°/°>3°.Í°B2°2/°H3° Í°2°K/°&Ö°4ͳ4&+°,Ͳ, +³@ +°4±;+°ͳ;+°FÍ°F/°ͲF +³@ +±L+±;,´ /B$9±F&±99±2.´ $901463!"&46327632#!2+#!"&5#"&;'&#";26=5!3264&#"¸]ƒƒ]k=€€=k]ƒƒ]¸`8(ûÀ(8`x8(Ã~+(°$À$þÀÂ(88(+ @ƒºƒM¥¥MƒºƒþÀþ`(88( vP8¡ûô8ÔÀÀþ,8P8€9Oh²1+°J/°Í°P/° Ö°:Ͳ : +³@ +°:°Í°/°:±H+° ͱQ+±:±,/99°H±'99° °9±J1³ ',=$9°± 990154>54&'&54>7>7>32#"'.#"#".'.327>76$3264&#">J> W—¾m7´³²•' '"''? .þëÛÖà”Š’/+>*€&^‰¶&&¬þÜãzy#M6:D 35sÒŸw$ '% ' \„t&_bàþÂml/J@L@ N&^|h&4&c©‡ÿ€3².+° /°Í°4/±5+01463!2#!"&54>54'''. @  úÀ 1O``O1BZŒ‰Z71O``O1CZŒ‰Z7   @  `N„]SHH[3^‚)Tt¬bN„]SHH[3`€)Tt¬€!1H² +°Í°/°%Í°//°Í°2/°Ö°"ͱ3+±"° 9±%µ $9°/³ $901476  '7 $7&' 547265463264&#"ŒÙÙŒŒþ'ýòþ'Œl…‘Ô‘…˜å=þùþŽþù=å8(zV}³D#åþêå#D#æþëåEÍóóÍìuhy¹þù¹yhulVz(³ÿ à#-=OUq²>+°?Ͳ+°;/°Ͳ; +³@ +°V/°*Ö°2°.Ͳ.* +³@. +±W+±.*² &,999±?>± 99°;@ &0,EJPQ$9°²99901476!27632#"'&547.'77.547265463264&#"76$7&'7™Æ Y[6 $!iþ\j1  z,ñXl§NWb=å8(zV}³0JÔiys§?_¯9'F–þu>žLëa  ¼ý ½YF  KA؉Eþþu?ÀkyhulVz(³üÄî¼³sp@²_"F"@Q¬¾ö-'‹åÿ€ð#3° /°'Í°0/°Í° /°Í°4/±5+017>2#!"&'&;2674'&+";26=4&+"#"'&' +&/& ` Âþ €™ LÀ4,@L¡ € þéþý5 `  ½ü Ý a 5 € Ÿ L@,4ÀL¡ýH` üþýÂ`  ü½ÿ€#'+/?CGKOSWgkosã°!/°$Ͳ@Lh222°'/²BNj333°(ͲDPl222°+/²FRn333°,ͲHTp222°//²JVr333°ͱ22°3Í°[2°Í°2²J> +³@J" +²>J +³@> +°r/±s+±7²M^_999°J³ /CO$9°>²A99901=46;2>767>3!54632#"&=!"+"&546;2.+"&673!54632#"&=".à0N<* .)C=W]xD ? þÀ  ÿ0N<* .)C=W]xDààú mBZxPV3!À þÁ  þÀ  ÀmBZxPV3!ŽÀá\µ-7H)ýO]´-7H)À þÁ  þÀ  À".=ÿ&'² +°Í°'/°Ö° Í° ͱ(+± ±$99014>$32#"'&'5&6&>7>7&ŽðL¶ôœððþdôFKÆþú1A  0) µ€‚í¬e«þÙþ¤þÙ«¯C58.H(Yÿ€€#3CR°!/°Ͳ! +³@ +°2°1/°@3°(Í°82°D/°Ö°$2° Í°,2° ±+°42°Í°<2±E+± ± !99015463!22>=463!2 $463!2#!"&%463!2#!"&&€&/7#"462"$462"& ±& ûì˜&&ü&%±ÌZKjKKj5KjKKj¦4& %&þ%z 0&4&&3D7ûKjKKjKKjKKjK€€²+°/±+015463!2!2#!"&„\@\„ \„„\û@\„àÀ\„„\ „\ý@\„„W€*-²(+°Í°/° Ͳ  +³@  +°+/±,+±(°9015463!2!2!"4&47>3!2#!"&„\@\„ \„üÀ^Î=þ¯IP+›B@"5þ°+›BûÀ"5àÀ\„„\ „\ _Hþt¤#Œ3G#þt3G@ÿÀ;° /°Ö°Ͳ +³@ +°2² +³@ +°2±!+±³ $901646;#"&4762+32"'@&€€&4&€€&ÿ4ÿ&4&&4ÿ4&ü&4ÿ@À;°/°Ͳ +³@ +°2² +³@ +° 2° /±!+±³$9014762!5462"&=!"'4&&4ÿ4&ü&4ÿf4&€€&ÿ4ÿ&€€&ÿ€€€#'+/v²+° Í° /²$(,333°!Ͳ! +³@!% +³@!) +³@!- +°/°Í°0/°Ö°Í°± +°#Í°#±$+°'Í°'±(+°+Í°+±,+°/Í°/±+° ͱ1+015463!2#!"&73!2654&#!"!3!3!3!^B@B^^BùÀB^€ @  ùÀ €€€€ ÀB^^Bû@B^^B  À  û €þ€€ü€€ý€üÿ€€@[° /°Í°$/°Ͳ$ +³@$? +°A/°Ö°3Í°.2°3±+°ͱB+±3°9°µ"0=?$9°± 99±$°9015463!2#!"&%32>54'6767&#".'&'#"'#"©wÀw©©wü@w©”®pÄŒe1?*8ADAE=\W{âO[/5dI kDt‘ Àw©©wü@w©©õ^Gw›©T -@ (M& B{Wta28r=Ku?RZÿ€€$X°!/° 3°Í°2°/°3°Í°/°Í°%/°Ö°!Í°2°!± +°2° Í° °Í°/±&+±!°9± ±99015463!2+37#546375&#"#3!"&©wÀw©©wÀËé8D„`Tˆ¤ààýàw© Àw©©wü@w©`à6:Ï ¡‘¦àý ©ÿ€€&.>¬²+° Í°/°"Í°./°2Í°ááþÂa–Ô––Ô68(B^5KK5û5KK5€€vŠ€@€ýþÂáá>áþÔ––Ô–(8^ÿH“€1G^°//°5Ͳ/5 +³@/* +°@/°Í°H/°Ö°3Í°3±>+°ͱI+±>3²-/999°° 9±5/³ -$9°@´ $9014$327.54632#".'#"'#"&2654'3264&"&#"¾2 £Íƒc`." b PTY9b '"+`ÜN*(ýa°½£ÍÀp p)*Ppp p)*Pð 2¾Í£½°þ`+"' b MRZBb ".`Ü(*NŸƒÍ ppP*)p ppP*)ÿ€ðck©çñû546?67&'&547>3267676;27632#"/+"&/&'#"'&547>7&/.$264&"54767&547>32626?2#"&'"'#"'&547&'&54767&547>32626?2#"&'"'#"'&547&'&2654&"2654&" › "8x s"+ º ")v  < ˜  › "8w s%( º ")v  > ˜ €–Ô––Ôj• 3>8L3)x3 •• 3zLLz3 •• 3>8L3)x3 •• 3zLLz3 •KjKLhLKjKLhL%¹ #)0C vZl. ™ Y… L0" ¹ #)0C wZ l/ ™ Y… N,&ÐÔ––Ô–üºŒq$ ]G)FqŒqG^^GqŒq$ ]G)FqŒqG^^GqüV5KK54LLÌ5KK54LLÿ€%Oo²N+°&Ͳ:+° /°Í°P/°Ö°Í°±.+°3ͱQ+±²&(L999°.±0699°3²9CD999±&N´69L$9° ±99°´ .03$90146$ #"'#"&'&4>7>7.32$7>54''&'&'# ¼E~E¼¼þ»¿VZ|š$2 $ |Žh:¡(t}†–Ž| $ 2$š|ZVþñ‹ì‰‰ìþêì‰X(  &%(HÒýûZT\ð†MKGÖ{xÑH(%& (Xÿ€08m/²C+°(Ͳ-+°9Í°32°m/°Í°W/°Í°^/°Í°n/°Ö°2Í°2±6+°9Í°9±[+°Ͳ[ +³@[X +°±F+°#Í°K Ö°Q3°!Í°N Ö°Í°#±T+°ͱo+°6º=Íï_+ ° ° À±aù°_À° ³ +°a³`a_+² Š Š#9²`a_9µ _`a......µ _`a......°@±62°.9±[9´+-A$9°°9±#F°L9±N°9±m9´#7FT$9°°9°°f9°^³[c$9015463!6767>763232+"&'&#!"&6264&"32;254'>4'654&'>54&#!4654&#+K5$e:1&+'3T†F0°h˜1 &<¬$]`»{tþà5K€&4&&4Ú %/0ÓƒyÀ#5 +N2þ `@`%)7&,$)' €€5KƒK5y„*%AŠu]c˜gYJ!$MCeM‹¡-+(K4&&4&€I§IJ 2E=\#3M:Ë;b^v…+D2 5#$ÿ€2:p0°$/°JÍ°/°QÍ°//°;Í°p/°93°Í°f/° Í°q/°Ö°4Í°4±8+°pÍ°p±M+°ͲM +³@MP +°±^+°W2°Í°b Ö°Í°^°Z Ö°ͳT^+°ͱr+°6ºÁ?óm+ °*°(À±Gù°IÀ°*³)*(+°G³HGI+²HGI Š Š#9²)*(9µ()*GHI......µ()*GHI......°@±84°9±Mp´$/h$9°°9±b°\9±Z°9±J³-FM$9°Q±.C99°;±T99°p³5b$901463!27>;2+#"'.'&'&'!"&264&"322654&5!2654&'>54'64&'654&+"+K5 t€¾ipŒ­<& 1˜h°0##†T3'"( 0;e$þî5K€&4&&4Ú ')$,&7)%`@``2N+ 5#bW€ƒÓ0/% €5K(,,ž‰MeCM$!JYg˜c]vDEA%!bSV2MƒK4&&4&ý€$#5 2D+…v^b;Ë:M3#\=E2 JIURIÿ­@à47%63#"&547&8öáþ?Vþ”y% IÇ)úÅì ôbÿ€€95°5/°(3°Í° 2°:/°Ö°Í°±#+°ͱ;+±#³ $9014632>32"'.7 654.""'."þà>oP$$Po>àþåý‘4ý #LHexh\`C+¬Üø+I@$$@I+øÜÝåý¨Z$_dŽC¨»ýÐ/¼¨Q|I.3MCCM3.I| (@F²&+°Í°>/°-Ͳ>- +³@>: +²-> +³@-2 +°/°Í°A/°Ö°ͱB+±->±569901463!2#!"3!:#!"&463!462"&5!"&©w@  þÀB^^B   þÀw©€&À&4 ýà4&þ@& Àw©   ^Bý@B^   ©€& &ýà4ýà& &ÿ€€5Š° /°ͱ *22² +³@' +°//°Í° Ö°33°Í°°Í°6/°Ö°Í°Í°±+° Í° ±!+°*Í°*±++° ͱ7+±±99° ±99°!±1299°*±/399±°19015463!2#!"&;265."3#347>3234&#"35#©wÀw©©wü@w©ßG9;HFtIççfç<,tç’xˆIç Àw©©wü@w©©Ý3EE34DDü@¶ýJ„&#1þŽšžueBÿ€€".~° /°3°ͱ%22²  +³@  +°/±+33° Í°//°Ö°Í°ͳ+°#Ͳ# +³@ +³+°(Í°(/°Ͳ( +³@ +³(+°ͱ0+±(#°9°°901463"&463!2#2#!+"'!"&2654&"c4LL4€4LL4c&þS3 Lþl& @{ÅLhLLhLþÅ{&þ å&zÀ'?a²%+°Ͳ% +³@ +° /°Í°@/°Ö°Ͳ +³@ +°±+°!ͱA+±´()-.<$9°!°+9± ³+7:<$901463!2#!"3!26546;2#!"&47'&463!2"/"/©wÀý@B^^B@B^@©wüÀw©­ Œ°&&&4°ýt  r @w©@^BüÀB^^B@þÀw©©Š Œ°4&&þ&°ýt r@F²<+°Í°/°Ͳ +³@ +² +³@ +°%/°3Í°A/° Ö°8ͱB+±± 9901463!462"&5!"&>3!2654&#!*.54&>3!2#!"&54&À&4 ýà4&þ@&~ @B^^Bþà  @w©©wþÀ À€& &ýà4ýà& &þž ^BÀB^   ©wý@w© ÿ€€€;BI‡°(/°/Í° 2°B/°G3°Í°2²B +³@ +°J/°Ö°<Í°<±2+°Ͳ2 +³@ +±#H22²2 +³@2 +±+A22°±F+°ͱK+±2<±7?99±F±C99±B/³8?C$9015463!5463!2!232#!"&=4632654&'&'.7&5!>=!8( ^B@B^ (8SÍq*5&=CKuüÀuKC=&5*qÍS€½Jÿ6½ÿ €(8`B^^B`8(€GtO6)"M36J[E@@E[J63M")6OtGN¨¢Ñþ¨N`Ñÿ€€Yaipx‡µ°W/° 3°MÍ°/°†3°{ͱ‚Š22°`/°\Í°%/°Í°Ž/°Ö°.Í°.°^ Ö°ZÍ°Z/°^Í°.±+°ͱ+±Z±AF99±^@+,454'6'&&"."&'./"?+"&6'&6'&&766'&6'7436#6&76©wÀw©©wà 49[aA)O%-j'&]Æ]5r,%O)@a[9( 0BA; + >HCàw©  $  /    61= Àw©©wü@w©ïa-6OƒUyU[q ( - q[UyU‚P6$C +) (  8&/ &‚©  A   )    ÿ€€À/7?p²3+°:3°Í°°Í°7/°>3° Í°2°@/°,Ö°%Í°%±5+°9Í°9±=+°Ͳ= +³@= +±A+±%,±99°5± 099°9° 9± ±()9901463!3!267!2#!"&&762#!#!"&5!"264&"264&"8(«c==c«(88(ú@(8EÀ6À*ÿ&ÿ&ÿ**&4&&4Ú&4&&4 @(88HH88(þÀ(88ð'Àþ@'(þ@&&ÀüÚ4&&4&&4&&4&ÿ€ÿ€2dý°*/°$3°;Í°A2°;°> Ö°'Í°[/° Í°X Ö°U3° Í°2°e/°0Ö°6Í°- Ö°3°9Í°32°6±G+°Í°N Ö°Q3°ͱ22±f+°6ºÂ^îÀ+ °L°JÀ±ù°À³+ºÃ‚ë+ ³+°L³KLJ+² Š Š#9²KLJ9¶JKL.......µJKL......°@±N6· *$;AS[$9±X>·-39GQ$9° °S9014>76763232632#"&#"#"&54654&732632327>54&'.54654'&#"#"&#"$I€VNšÂz<ç:LQJ  Œü›|Ê9â8aIe€a9á9µgÕw   N<è;+gC8‰A`1±oÕζA;=N0 eTZ  (:¥þ»û7,oIX(¡*( )W,$-׉,‹-[% 061IéO4767>3232>32#".'&'&'&'.382W# & 9C9 Lĉ" 82<*9FF e^\3@P bM€þïO0# -\^e FF9*<28 "‰ÄL 9C9 & #W283 #0O€Mb P@3€€*² +°Í°/°Í° /°Ö°Í°±+° ͱ!+01463!2#!"&73!2654&#!"©w@w©©wüÀw©€^B@B^^BüÀB^ @w©©wüÀw©©wB^^B@B^^Bÿ—€#D°#/°Ͳ# +³@# +°2°$/°Ö°Í°±!+° ͱ%+±°9°!°9° °901546763!2#"' #"'.77!'!!''!0#þGþG$/!'€§YY§ü "8 8"ú÷"8  ¨þX! 8A–UUþjÚÿ€€UN° /°!Í°Q/°ͲQ +³@Q4 +°V/°Ö°Í°±&+° Ͳ& +³@&A +±W+±&°F9±Q!°09015463!2#!"&3267654'./.#"#".'.'.54>54.'.#"©wÀw©©wü@w© <9¤0)$9“G55 :8 c7 )1)  05.D Àw©©wü@w©©`$)0¤þÇ< D.50 + AB 7c  )$+ -.1 “,T17327.'327.=.547&546326767# ,#+á°i¦!+*p“DNBN,y[ƽ†Œ`m`%i]]C_L›ÖþÒ¬þñ‘Š}a ±u&,ŽSXK•³ &$†½f9s? (bE‚þýî·m_ÿ€¿@°/°3°Í°2² +³@ +° /°Í°/°Ö°2°Í° 2² +³@ +±+01!54632#"!#!_ÿЭ“QV<%'þþÎw(ÚºÍ þøHH½þØý ÷ÿ§€RH° /°Í°S/°Ö°)Í°)±+°ͱT+±)±54'6'&&"."&'./"?'&Îa¢aÎþÛè49[aA)O%-j'&]Æ]5r,%O)@a[9( 0BA; + >HCèþÛ€ÑaÎÎþŸÑûþoMÓa-6OƒUyU[q ( - q[UyU‚P6$C +) (  8&/ &fM‘€€%f²#+°Í°2°/° Ͳ +³@ +°&/°Ö°Ͳ +³@ +² +³@ +°±+° ͱ'+±± 99±#°9°°9015463!54 +"&54&"32#!"&8( r&@&–Ô–`(88(ü@(8`@(8À¹þù¹ÿ&&j––jÀ8(ýÀ(88ÿ€€€#'+V²+° Í°$/°(3°%Í°)2°/°Í° /°Í°,/°Ö°Í°2°±$+°'Í°'±+°2° ͱ-+±'±(*99015463!2#!"&73!265!!54&#!"5!35!^B@B^^BùÀB^€ @ ù€€ ùÀ €€€ ÀB^^Bû@B^^B  `€à  û €€€€€€!=Y²+±233°Ͳ +³@ +°;/°'Í°>/°Ö±"22°ͱ?+±±;99±±799°;²:999°'°)901<62"5476;+"&'&'.5476; +"&'&$'.p pp p $qr‡ ‡$þ»å!ߺ»Ö % ²þãþ}×#p pp p¹‡ ‡rqþÜ !åE$ Ö»ºþ!þú#׃² %%/7?©²+°Í°7/°>3°3Í°:2°"/°&Í°'2°,/°Í°@/°Ö°Í°±1+°5Í°5±9+°=Í°=±+°ͱA+°6º<Ýì7+ °&.°/À±ù°ÀºÃ#ì7+ °'.°(À± ù° Àµ (/......· &'(/........°@01547>3!2#!"&73!2654&#!"7!.#!"462"6462"Å\77\Å^Bû@B^€ À  û@ 2œüò!/B//BÑ/B//B @2^5BB5ý¢2þÀB^^B  @   â  ü½B//B//B//B/ÿƒ€.4B°5/°)Ö°Ͳ) +³@) +°±1+°Í° 2°ͱ6+±)°$9°1µ /$9015463! 22##%&'.67#"&%^Bà³Í4L5KK5L4þ_þu:B&1/&¥¬.- zB^y‡þvþŠ ÀB^€L4þ€KjKþ€4L[!^k'!A3;):2*767>32!2+#"'&#!"&6264&"323254'>4'654&'!2654&#!4>54&#"+K5 A# ("/?&}£vh˜—i©!<¬…½¤;þà5K€&4&&4Ú H¾ÅQ½#5K4LN2ýÀ$YGB (HGEG €€5K J7R>@#†zD<˜gi˜>9eM‹¡E;K4&&4&€@@§IJ 2E=L43M95S+C=‹,@QQ9ÿ€€3ksà²F+°&Ͳ"+°JÍ°n2°1/°7Í°M/°Í°i/°Í°`/° Í°t/°Ö°4Í°4±)+°CÍ°, Ö°?Í°82³C)+°cͲc +³@ch +°C±K+°mÍ°m±q+°ͱu+±,4±/099°?°;9±C)±=99±Kc´" &F$9±qm±!99±1J³*=Cr$9°7°;9°M°49°°9°²RWf999°`³Zc$901463!&546323!2#!"#"&?&547&'#"&73!32>;#".'.'&'&'.#"!"264&"˜hv£}&?/"( #A  5KK5þà;¤¾Ž°=!©i—€L4K5#aWTƾH #A<(H(GY$ýÀ2N€&4&&4g˜R7J K5ý€5K;E›ŒLf9>˜h4L=E2 JI UR@@€2*!Q@.'!&=C+S59Mý§4&&4&ÿ2`hÙ²h+°?Í°/°dÍ°^/°Ͳ^ +³@^Y +°K/°Q3°Í°F Ö°Í°U/° Í°i/°Ö°3Í°3±+°YÍ°Y±# +°>Í°>±Q+° Í° ±?+°e2°Í°±D +°ͱj+±3³/6\$9±>Y± U99± Q°N9°?³FLa$9±hd±"99±^?´#D$9°°9±F±LN99±U± 9901463246326326#!"&54.'&'.7!54>54#"."&#"4&#"".#"264&"†zD<˜gi˜>9eM‹¡E;K5ý€5K J7R>@#€‹,@QQ9€@@§IJ 2E=L43M95S+C=&4&&4€}£vh˜—i©!<¬…½¤;þà5KK5 A# ("/?&B (HGEG H¾ÅQ½#5K4LN2ýÀ$Yý4&&4&ÿ3hpÙ°+/°@Í°#/°JÍ°D2° Ö°NÍ°1/°7Ͳ71 +³@7< +°V/°lÍ°p/°Í°q/°Ö°4Í°4±.+°=Í°=± +°XÍ°X±C+°(Í°(±U+°m2°Í°±Q +°ͱr+±.4³17c$9°=°:9°X±+@99±(C°F9°U³!HNi$9±#@°'9°J°F9±N ±/H99±V7´Q$9±pl±99014>767>5463!2/#"'#"&5#"&732>3326532726732654.=!264&"#@>R7J K5€5K;E›ŒLf6A˜ig˜6Jy‡€=C+S59M34L.9E2 JI UR@@ý€2*! Q@.'!&&4&&4€&?/"( #A  5KK5þà;¤¾Ž°=©i—˜hv£}GY$ýÀ2NL4K#5#aWTƾH #A<(H(Ò4&&4&ÿ€€ +B° /°Í°(/°Í°,/°Ö° Í° ±+°ͱ-+± ³ $9±(³$901$  $2?64/!26=4&#!764/&"Îa¢aÎÎþŸþ^þŸ-[j6[½ö&&þ ½[6þ–[¯¢aÎÎþŸþ^þŸÎÎM6[þ–[6½&€&½4[þ–[ÿ€€ +B° /°Í°!/°Í°,/°Ö° Í° ±+°ͱ-+± ³ $9±!³$901$  $3!27764/&"!"Îa¢aÎÎþŸþ^þŸ2&ö½[6j[[þ–6[½þ &¯¢aÎÎþŸþ^þŸÎÎò&½4[j[6[j[6½&ÿ€€ +B° /°Í°(/°Í°,/°Ö° Í° ±#+°ͱ-+±# ³ $9±(³$901$  $2?;2652?64''&"Îa¢aÎÎþŸþ^þŸ.[6½&€&½4[þ–[6[þ–¯¢aÎÎþŸþ^þŸÎÎN6[½þ &&ö½[6j[[þ–ÿ€€ +B° /°Í°"/°Í°,/°Ö° Í° ±+°ͱ-+± ³ $9±"³$901$  $2?64/&"4&+"'&"Îa¢aÎÎþŸþ^þŸ.j[6[j[6½&€&½4[¯¢aÎÎþŸþ^þŸÎÎL6þ–[[j6[½ö&&þ ½[ÿ€€ Ø$  $76.7"7"#76'&'.'2#22676767765'4.6326&'.'&'"'>7>&&'.54>'>7>67&'&#674&7767>&/45'.67>76'27".#6'>776'>7647>?6#76'6&'676'&2>767676&67>?&'4&'.'.'."#&6'&6&'3.'.&'&'&&'&6'&>567>#7>7636''&'&&'.'"6&'6'..'/"&'&76.'7>767&.'"67.'&'6.'.#&'.&6'&.5Îa¢aÎÎþŸþ^þŸ +  !       $     "  +       &"      4   $!   #          .0"’2Α      ¯¢aÎÎþŸþ^þŸÎÎ…   ' -( # * $  "  !     * !   (                                 Pû¹ $™      2 ÿ~€ /P²+° Ͳ+°0/°Ö°Í°±+°!Ͳ! +³!) +³! +±1+±° 9°±99°!°901347#"/&6264&"32>32#"&©'—býV%54'j&ë&4&&4Ú¹:,þÛÁ”{ /ë¹5&©b—'ýV%%l$4&&4&‡r! " ©àk[G'C†§€/37;R² +°4Í°7/°Í°/°0Í°3/°Í°,/°8Í°;/°%Í°990132327#"&462"4>322>32#!"&6  462"654'32>32+&|Kx;CBQ¢g†Rp€–Ô––Ô 6Fe= BP†ˆ†PB =eF6 ’yü–y’@á>ááþÂß–Ô––ÔgQBC;xK|pR†gŸa*+%‹u{QEÔ––Ô–ü5eud_C(+5++5+(C_due5x‹‹V>ááþÂá–Ô––Ô–þ€u‹%+*þŸNQ{ÿpð%Gi¡°/°MÍ°W/°Í°°+ Ö°"Í°C/°Í°j/°Ö°&Í°&±>+° Í° Ö°HÍ° ±R+°ͱk+±&´ "± h99°R²M999±"MµRY$9°+± 99±W± -99°C³ &$9014?632632#"/&547'#"/7327.54632654/&#"32?654/&#"#".'U“SxySÎSXXVzxTÐTU“SxySÎSXXVzxTÐlÐ)* 8( !Î('“¿Î)(“Ð(* 8( !ÈðS’SUÏSx{VXXTÐTðS’SUÏSx{VXXTÐÌ(Ð (8 *(Ï’ý(Ï’'(Ð  (8 €€7²+°Ͳ+°Ͳ+° Í°/°Ö°Í°ͱ+± ± 9901467&5432632#!"Žt,Ôž;F`j–)¨áŸûÀ¹þùÀ„Û6Ô,°Ž>–jK?чŸásÿ€ €!M°/°Í°/±33° Í°"/°Ö°Ͳ +³@ +°±+°Ͳ +³@ +±#+±±9901&7#"&463!2+#!!'5#–E8÷@&&&&@÷8Ejû€ÜÈþð€€Y&4&&4&þqüçY­%þq%ÿ€FTbp~†Œ‚²6+°C Ö°KÍ°R/°Í°†/°‚Í°r2°/°YÍ°`/°Í°/°€Ö°„Í°‡2±Ž+±„€±kl99±R6²<ˆ‰999°·9cjkl‡‹$9°‚³ .pŠ$9°Y³ #ow$9°`² mn999017>76326?'&'#"'.'&67632632 #"'#"'&6327>'&#"3276&'&#"7''54?'462"7bR„’SD zz DS’„Rb)+U‰‘„Sbn² €þû€ ýNnbS„‘ˆVZË2.'Jd\Q2.'Jd\ƒ2Q\dJ'.2Q\dJ'ã  `à€ý `!O×&4&&4TF€ýø±LŽ5T II T5ŽL;l'OT4ŽM01Bƒ@#$þrþr$#@ƒB10M5TNTЄ*$;3„*$;í„3;$*„3;$ý„` @@þQq : $/£4&&4&yþ¹@˜Šÿ-09<‘°/°1Í°/° Í°9/°:Í°-/°.Í°4/°Í°(/°Í°=/°Ö° Í° ±/+°)Í°)± +°!2°1Í°1±&+° Í° ±; +°5Í°5±2+°ͱ>+±/ °.9±&1°:9±.-±&<99°° 9°(°09015467>3!263!2#!"&5!"&7!467!#!7!!!#!7!(˜`( (8D< (88(ü@(8ýà(8€(<þ€8(þ`U+€þ€8(þ`U+à (`˜(8(þ¸(8(û@(88( 8H(`< þ`(8€+úU€þ`(8€+ÿ„||?w°;/°Í° /°3Í°/°Í°@/°Ö°Í°±0+°#Ͳ#0 +³@#( +°#±+°8ͱA+±#0±99°µ+3;$9± µ +08$9°3±99°°9014632#"'&#"32654'&#"#"'&54632#"'&ÜŸžs] = ý¢Ofj’L?R@T?ý»"&š > þf?rRX=Edžu‡dü÷qÿŸÞqý¢ = _M–jiLü÷?T@R?E& þf > š=XRr?ý»b‰uždsÿ€€15Ed²+±233°Í°5/°Í°+/°9Í°1/±'A33°Í°F/°Ö°Í°±/+°2°6Í°2Í°6±=+°(Í°(±3+°Í°±+° ͱG+01463!2#!"&73463!234&'.##!"&5#!!;2654&+"8( (`(8(úÀ(8€€8(@(8€ þç 08(ýÀ(8€ý À  À  @(8(þè`(ü`(88H (88(þ`€1  þ`(88( û€  @  ÿ€€5463!2#!"&©wÀw©©wü@w© Àw©©wü@w©©/ ² +°Í°/°Í°-/°$Í°0/±1+01=463!2#!"&5463!2#!"&5463!2#!"&&€&&ú€&&€&&ú€&&€&&ú€&@€&&€&&€&&€&&€&&€&&ÿÀ@'7Gl²%+°Í° Ö°Í°5/°,Í° Ö° Í°E/°<Í° Ö°Í°H/°Ö±22°ͱ 22±I+±%³$9±,5³ $9±E±9901<62"462"462"5463!2#!"&5463!2#!"&5463!2#!"&p pp pp pp pp pp  À  û@  À  û@  À  û@ 0 pp pp pp pp pp pü`À  À  À  À  À  À ÿ÷<L\l|²Z+°QÍ°22°Q°1Í°/Ͳ%+²7+°;/°!Í°/°Í°Í°j/°aÍ° /°Í°z/°B3°qÍ°DÍ°@2²Dz +³@D> +°}/°Ö± 22°ͳ0+°1Í°1/°=3°0Í°±E+°@Í°52²E@ +³@EC +³@E+°+3°Í°32°°8 Ö°$Í°$/°8ͱA22°8°Í°/±~+±01³ 'L$9°E±&J99°@· !);>$9±Z!±899°Q±'599±/±+499°°9±aj´ $9± ° 9014>54&#"'>32353!&732654'>75"##5!#"733!5346=#5463!2#!"&5463!2#!"&5463!2#!"&/BB/.#U_:IdDREiþ–919+i1$AjM_39°Kµ!.EO\$9°R´1P$9± E²;OR999±%³1$9°°9015463!2#!"&476!2/&'&#"!&'&&?5732767654'&'!#"/&'&=4Àù@€†…2uBo  T25XzrDCBBÕEh:%ý0f#-+>;I@KM-/Q"g›)0%HPIP{rQŒ9 @@ºµ€ $&P{<•8[;:XICC>.#-aý)&%,"J&9%$<=DTI*'5oe71#.0(  lÿ€€s² +°Í°d/°0Í°O/±C33°KͲF222°t/°mÖ°%Ͳ%m +³@% +²m% +³@ms +°%±:+°;2°ZͲZ: +³@ZM +±u+°6ºÀ/û'+ °;.°?À±Xù°VÀ°?³?;+°V³WVX+²WVX Š Š#9²>?;9°<9°=9·>?X;<=VW........¶>?X<=VW.......°@±%m±99°:´EFd$9°Z±RU99±O0³EPls$9°K²IJ999013!26=4&#!"6323276727#"327676767654./&'&'737#"'&'&'&54'&'&'Àú@ <4„"VRt8<@< -#=XYhW8+0$"+dTÍLx-'I&JKkm’§uw<=z% @@@ v 'åþè|N;!/!$8:IœOb“V;C#V  &   ( þ‡ÃmL.A:9 !./KLwPM¼$ €€/?O_oŸ†² +°ͱCs22°/±K{33°#ͱSƒ22°,/±[‹33°3ͱc“22°?>;5463!2&#"&5!"&5#".!#"264&"264&"@&  Æ? &&! '–Ô–þ€–Ô–@' !À€ž à €LhLLh4LhLLhÀ&@6/" ÆÀ&&ü j––jj––j Ï à þhLLhLLhLLhLÿ€€J…° /°Í°@/°0Í°/°Í°K/°Ö°!Í°!±-+°CÍ°C±=+°3Í°3±+°ͱL+±C-³(*GH$9°=· 08 E$9°3²6999± ± H99°@@ !%-36E$9014$ #"'676732>54.#"7>76'&54632#"&7>54&#"&Îa¢aÎÎþŸÑok; -j=y¾hwâŽi¶[+PM 3Ñ©—©‰k=J%62>VcÎþ€ÑaÎÎþŸþ^þŸÎ ]G"±'9‰ð–rÈ~:`}†Chž 0=Z—Ù¤ƒªîW=#uY2BrUI1þ^Fk[|ÿ€€Lx° /°I3°Í°A/°1Í°/°Í°M/°Ö°"Í°"±.+°DÍ°D±>+°4Í°4±+°ͱN+±D.´(+ HI$9°>´19F$9°4±799±A·"&.47F$9015463!2#!67673254.#"67676'&54632#"&7>54&#"#"&©wÀw©©wý+U ,i<µåF{¶jhµ}Z+OM  2ϧ•§‡jX–Õ¢¨ìW<"uW1AqSH1þbdš©ÿ€€=Uco ° /°Í°Q/°CÍ°`/°YÍ°)2°,/°Í°p/°Ö°0Í°Í°0±V+°]Í°> Ö°NÍ°]±g+°k2° ͱq+±N>¶# 3)9$9±]V³!CHQ$9°g³&+d$9±CQ±99°`@ !5:3dfhi$9°Y¶#0&jlno$9015463!2#!"&32>54.4>54&'37!"3274>32#".4632#".33535#5##©wÀw©©wü@w©%3!##"&'&732>54.'&#"3267654.#"53533##5 YJƒ .”ËH?MÓp¢ŠƒJL1EF1@[Z@0HþꟄå9%ºFq}A:k[7'9C 5hoS6j+=Y4&P5"?j@*Q/øÔiÕÕi¶QŠ.R*@)$1Á”Rš6B@X?ŒZHsG;@"$ECP€NZSzsS`0$/. 0$8]§.ggR4!9f:†}R'!;ý°lÙÙlÛÛ€/<W² +°Í°-/°7ͱ22°+±³ (08$9±<7µ !()$9015463!2#!"&2!463"&5!#4>2".673#!5##&&&ù&€j–€–jj–û€–j*M~–~M**M~–~MPM* €€€r@€&&û€&&Z–jj––jj–þºŒ|NN|Œ|NN|mP%þà``À@€ ° /°Í°/±+01463!2"'&€&þ@4þ@&4&&4þ@À@ ° /°Í°/±+014762#!"À4À&ü€&4Àþ@4&@€€€ °/±+°ͱ+014762"'@À4&&4þ@f4À&ü€&À€@€ °/± +°ͱ+015462"&&4Àþ@4&À€&þ@4þ@&ÿ€€€:²+°3° Í°/°3°Í°/°Ö°Í°±+°Í°±+° ͱ+015463!2#!"&73!!!265!^B@B^^BúÀB^€ `ý€` ý€ ÀB^^Bû@B^^B €û€ `ÿÀ@ 463!2"'4762#!"&€&þ@4þ@À4À&ü€¦4&&4þ@À“4Àþ@4&ÿÀ ° /°Í°/±+01463!2"'&€&þ@4þ@¦4&&4þ@À@ ° /°Í°/±+014762#!"À4À&ü€&4Àþ@4&ÿ€:°/° Í°;/±<+015;2>76%67#!"&463!2+".'&$'.,9j‡9Gv33vG9ªH9+^Bú@B^SMÀA_bIþˆ\ A+=66=+A [þª">n 1&öc*/11/*{Þ'0üæB^^lNh^BO3þû@/$$/@í*“ÿ°l +r°%/°Ͳ% +³@%! +± 22° /°Í°,/° Ö°Í° Ö°Í°±+°+Í°2°+±!+° ͱ-+± ±99±+°9°!°9±%³ $901462+"&!3/!#>32!4&#"g¦dgTRdJ¶I*Gg?«Ðþ·QV?U ÁJaaJIbbû8ßü!ð00 08ãÛýÈiwE33ý×ÿ€€4>°/° Ͳ  +³  +°)/° Í°5/°%Ö°ͱ6+±) ³ 12$9° ±99014766$32#"$'&6?6332>4.#"#!"&('‚k“œÎzzÎþ䜬þÊm‰ IÔwh½ŠQQŠ½hb´F‰*þ@&@À*eozÎþäþÈþäÎz‘„ Š  _hQŠ½Ð½ŠQGBŠ'(&(ÿëØq4>7632&4762.547>32#".'632#"'&547"'#"'&(  &  \(  (˜  &  ~+54'k%%k'45%þ•&+ÿ~(  (þhà  (\  &  þh(  (~ÿ+%þ•'45%l%%l$65+~  &  ˜ÿ€!3;CK]°/°Í°F2°;/°Í°L/°Ö°Í°±I+° ͱM+±I@ #,48<@D$9±°%9°;@  *.26>BJ$90146$ #!"'&264&"264&"676&'6.264&"264&"264&"ŽðLlLðŽ#ú†#€KjKKjuKjKKj;PšŠ,2e2.e<^*KjKKjuKjKKjuKjKKj€¶LðŽŽðþ´¶þûÞÝ;jKKjKujKKjKý1MŠ(PM+±&°9°7· #$9±:3µ#*0$9014$ #"'#"&'5&6&>7>7&76?32$6&$ ðœèœððþdôFKÆþú1A  0) µ€‚W.˜{+9E=ÌcÑÑþþhþÑ€®'««þÙþ¤þÙ«¯C58.H(Y–pËJ2`[Q?l&‹ìì‹‹ìÿ€%:d›²c+°;ͲO+° /°1Í°8/°Í°e/°Ö°&Í°&±5+°Í°±C+°Hͱf+±&±99°5¶ #;=a$9±C±EK99°H²NXY999±;c´KNa$9° ±99°1³ #+$9°8·*.CEH$90146$ #"'#"&'&4>7>7.76?32$64&$ 32$7>54''&'&'# ¼E~E¼¼þ»¿VZ|š$2 $ |Ž€j`a#",5NK™ þöþÎþöè:¡(t}†–Ž| $ 2$š|ZVþñ‹ì‰‰ìþêì‰X(  &%(HÒwR˜88T h²Ì²hh²ýZT\ð†MKGÖ{xÑH(%& (Xÿ|€!>3!2%632#"'.7#"'&ÉH«Œ ýä  Åþj '9 þ1bû{(e ÿ€€Uˆ°S/±*>33°Í´"26FJ$2°I/°43° Í°2° /°3°Í°V/°Ö°OͳJO+°Í°/°JÍ°O±B+°2°;Í°2³6;B+°GÍ°G/° 3°6Í°2°;±.+°'ͳ"'.+°3Í°3/°"ͱW+0146;5463!5#"&5463!2+!232#!"&546;5!32#!"&546;5!32#!"&8(`L4`(88(@(88(`4L`(88(þÀ(88(`þ`(88(þÀ(88(`þ`(88(þÀ(8 @(8À4LÀ8(@(88(þÀ(8ÀL4À8(þÀ(88(@(8ÀÀ8(þÀ(88(@(8ÀÀ8(þÀ(88ÿ€€À;OY|²D+°NͲDN +³D? +³DI +°4/±$33°Ͳ4 +³4 +°92³@4 +°,2°P/°TÍ°Z/°<Ö°AÍ°A±F+°P2°KÍ°V2±[+±A<°09°F³%,MN$9°K°901476$32#"'.#"#"'.'."#"'.'.#"#"&46226562"&5462&"-ÿU¾Œ à¥! 1X:Dx+  +wˆw+  +xD:X1 €&4&NdN!>!˜Ð˜€&4&*,©·ˆP“㊠ ..J< $$ 2#"&'"&547&547&547.'&7367>7654."$4632"&54&#"Y‘·¾·‘Yg-;</- ?.P^P.? -/<;-g€D ) € ä € ) DEo‡Š‡oE` 2cKl4 Àc«qAAq«c›q1Ls26%%4.2,44,2.4%%62sL1q›eO , ™‘‘™ , OeH|O--O|+ L4  .2ÿ à4V°/° Ͳ +³@ +²  +³@  +°2/°Ͳ2 +³@2- +²2 +³@$ +°5/±6+± °9±2±()990147632!2#!#"'&5463!54632#"&=!"& @  `  ú  þÁ  ` ? þÀ  ú   @  À À À  @ -À À þÁ  þÀ  À€€5p²+°!Ͳ! +³@! +°./°Í°6/°Ö°1Í° Ö°Í°1±%+°Í°* Ö°ͱ7+±1°9°*± !99°± 99±.!³$9°° 901467&5432632#!"27654&+4&+"#"Œv,Ôœ;G_j–)‚§áŸûÀ¹þù `  _ à À à À‚Ü7 Ô,®>–jL>цŸáY þ  _ `  þ €€5€²+°Í°)2²+°$Ͳ+° Í°2/°Í°6/°Ö°Ͳ +³@ +°±-+°Ͳ- +³@ +±7+±-± 99°± 99±$±99°2³$9° ° 901467&5432632#!";;26532654'&"Œv,Ôœ;G_j–)‚§áŸûÀ¹þùà À à  þ   þ¡ À‚Ü7 Ô,®>–jL>цŸá™þ   `  ` þ¡ ÿ€€€PX`ä²+±%533°NÍ°X/°TÍ°`/°\Í°a/°Ö° Í° ±R+°VÍ°V±*+°1Í°1°^ Ö°ZÍ°Z/°^Í°^°3 Ö°(Í°(/°3Í°1±8+°Jͱb+±R ±99°V³ $9±^Z¶#.TW$9±1*´>AD$9±3(°-9°8°@9±X³#(38$9°T·!*1:J $9°`@  .>@-$9°\³D$90154>72654&'547 7"2654'54622654'54&'46.'#!"&$462"6  %:hD:Fp pG9„F„j– 8P8 LhL 8P8 E; Dh:% ’yü–y’&4&&4á>ááþƒD~–s[4DËd=PppP=dË>hh>@–jY*(88(*Y4LL4Y*(88(*YDw" A4*[s–~DyŠŠœ4&&4&á>ááþÂáÿ€€€EM©².+°@Í°C/°*3°Í°M/°7Í°/°3° Í°2°N/°Ö°Í° Í°±B+°+Í°+±+°'Ͳ' +³ +°'±4+°GÍ°G±0 +°=Í°=±K +°9ͱO+± ± 99±+²-@999±4'±.?99°G°69±M´14932#"' 65#"&4632632 65.5462 $=.$264&"& <#5KK5!¼¼!5KK5#< &ܤ¼¼9Gp pG9þùþŽþù¤Ü€&4&&4&$KjKþnj––j’KjK$&þØ„j––j‹b>PppP>bþuŸáោØê4&&4&ÿ€€ %W°/± 33°ͳ $2°/°Í°&/°Ö°Í°± +°ͳ  +°ͳ +°Í°/°Í°±+°"ͱ'+01546;#"&35463!23!5!32#„\@@\„€€8(@(8€ýþ`@\„„\`@\„û„„ (88( û€ú€„\üÀ\„ÿ€!-j°/°%Í°./°Ö°"Ͳ" +³@ +°"±'+°Ͳ' +³@ +³ '+°Í°/° ͱ/+±"±+99°'³ %($9° ± 99°°90156467&5462#!"&5!"&324#"&54"¾ÂÀ¨8P8¨À¾L4þ@–Ô–þ@4LgI;U €¡Ù¥Â(88(Â¥þúþ'¡4Lj––jLLIg U;ÿ€@"?°/°Í°/° ͳ +°Í° °"Í°#/°Ö°ͱ$+±°9±"±99015!#!"&463!2+#!"&3264&+–jûj–&€ŸááŸ@„\ý@\„€@PppP@€j––Êà&áþÂá \„„Í°>/±D+01462265462265462+"&5.463!2+"&5#"&&4&&4&&4&&4&&4&G9L4€4L9G¼„&L4€4Là @€&&þ`&& &&þ`&& &&ý€=düõ4LL4 dþ „¼&ùÀ4LL4ÿ,<LSq°/°Í°*/°!Í°:/°1Í°J/°AÍ°/°MÍ°/°Í°T/°Ö°Í°±+°MÍ°M±+° ͱU+±µ-.=>$9±M¶%&56EFN$9±M°S901463!2#!"&7!!"&5!5463!2#!"&5463!2#!"&5463!2#!"&!&'&'8(€(`8(8(úÀ(8€þ`(8ýÀý@Àý@Àý@€x þÇ  @(8(þÈ`(û€(88H8( û @@@@@@n 9 ÿ€-=M]m}­½ÍÝíý -=463!2#!"&7!5463!2!!546;2+"&546;2+"&546;2+"&546;2+"&546;2+"&546;2+"&546;2+"&546;2+"&546;2+"&546;2+"&546;2+"&546;2+"&546;2+"&546;2+"&546;2+"&546;2+"&546;2+"&546;2+"&&&&û&€€ @ €û€€ @  @  @  @  @  @  @  @  @  @  @  @  @  @  @  @  @  @  @  @  @  @  @  @  @  @  @  @  @  @  @  @  @  @  @  @ À€&&ù€&&Zà  àû @  @  @  @  @  @  @  @  @  @ ý @  @  @  @  @  @  @  @ ý @  @  @  @  @  @  @  @ ü @  @  @  @  @  @  @  @  @  @  ÿ€1AQaq¥µÅÕåõ463!463!2!2#!"&7!5463!2!!#!"&=!546;2+"&546;2+"&546;2+"&546;2+"&546;2+"&;26=3;2654&+"#54&+"546;2+"&546;2+"&546;2+"&546;2+"&546;2+"&&@8(À(8@&&û&€€ @ €ÿ8(þ@(8ÿ€ @  @  @  @  @  @  @  @  @  @  @ € @  @ € @  @  @  @  @  @  @  @  @  @  @ À& (88(þà&û&&Zà  à€ (88( ü @  @  @  @  @  @ ó@  @  @  @   ``  @  ``  ü@@  @  @  @ þ @  @  @  @  @  @ @ÿ€€€&/7[cê²3+°^3°"Í°2°%/±33°Í°7/°b3°(Í°*/° Í°X/°M3°Í°°SÍ°d/°Ö°'Ͳ' +³@ +°'±$ +°1Í°1±(+± 422°=Í°V2°Í°8Í°=± +°]Í°]±D+°N2°ͳaD+°Í°°IÍ°I/±e+±(1²!"*999±D]²^c999±a°9±%3³14]`$9°³05\a$9°(±@A99°*³;;463!2+"&5!"&5#"!#264&";;26=326=4&+54&+"#"264&"@&Æ@ &€&&À–Ô–þ€–Ô–€š€žÃ€KjKKjµàÀààÀà€KjKKj¦4& @Æ@&&û€&j––jj––jà þjKKjK ààÀààüÕjKKjKÿ€€ ;?I° /±@33°Í°%2° Í°3/°<ͳ A$2°?/°Í°J/°Ö°Í°± +°Í°62°ͳ< +° Í° /°<Í°±$+°.2°ͳ=$+°Í°°)Í°)/°±@+°FͱK+01546;#"&35463!23;;26=326=4&+54&+"#"!5!32#„\ \„` 8(@(8 ü`àÀààÀà€þ€ \„„\`@\„û„„ (88( û ààÀàà €ú€„\üÀ\„€€:f².+°/Í°%2°!/°Í°2 Ö° ͳ!+°Í° /°3°Í°;/±<+±2/³#367$9° ±99±!²8999±°9° °901575#5#5733#5;2+31 #32+53##'53535À€ `À @@ `&&E%@à`þáþ à@þÛE&&` @@ À` €€ À à   þ @ :# @ @þ    à À @€€B² +° /°Í°/°Ͳ +³@ +°/°Ö°ͱ+± °9±²999017!7!!57#"&5;!@ à À @€û€€€ŸáK5€ÿ€€€À üàÀÀÀÀáŸ@þÀ5K€ÿ€€3G° /°Í°Í°2°+/°Í°°0Í°%2°4/°Ö°Í°±+°+2°Í°)2°±!+° ͱ5+015463!2#!"&%;265!;2654&+"!4&+"©wÀw©©wü@w©&€&&€&&€&þ&€& Àw©©wü@w©©—&&@þÀ&&€&&þÀ@&&ÿ€€3I° /°Í°2°Í°0/°%3°Í°°+Í°4/°Ö°Í°.2°Í°±+°&2° Í° °!Í°!/±5+015463!2#!"&3!;265!26=4&#!4&+"!"©wÀw©©wü@w©&@&€&@&&þÀ&€&þÀ& Àw©©wü@w©©&þÀ&&@&€&@&&þÀ&-Mó3)4762 "'$4762 "'- Ò  2 þw‰ 2  þ.v Ò  2 þw‰ 2  þ.3 Ò 2  þwþw  2 Ò  Ò 2  þwþw  2 Ò MÓ3)647 &4?62"/$47 &4?62"/ ‰þw 2  Ò þ.  2v ‰þw 2  Ò þ.  2“ ‰‰  2 þ.  þ. 2  ‰‰  2 þ.  þ. 2M3S)64762"' "/4762"' "/M Ò  Ò 2  þwþw  2 Ò  Ò 2  þwþw  2Ó Ò þ.  2 ‰þw 2Š Ò þ.  2 ‰þw 2M­3s)4?62 62"'4?62 62"'M 2  ‰‰  2 þ.  þ. 2  ‰‰  2 þ.  þ.“ 2 þw‰ 2  þ. ÒŠ 2 þw‰ 2  þ. Ò-Ms3°/±+°Í°2±+±° 9014762 "'- Ò  2 þw‰ 2  þ.3 Ò 2  þwþw  2 Ò MS3°/±+°2°ͱ+±°901647 &4?62"/ ‰þw 2  Ò þ.  2“ ‰‰  2 þ.  þ. 2M 3S° /°3°Í°/±+± °9014762"' "/M Ò  Ò 2  þwþw  2S Ò þ.  2 ‰þw 2M-3s°/°Í° 2°/±+±°9014?62 62"'M 2  ‰‰  2 þ.  þ. 2 þw‰ 2  þ. Òÿ€€/>°/° 3°#Í°#°Í°,/°Í°0/°Ö° Í° ±'+° ͱ1+±' ³ $901463!2#!#!"&54>5!"&3!2654&#!"^B@B^^Býà &þ& ýàB^€ @  ùÀ  @B^^BûÀB^%Q= &&. Îa¢aÎÎþŸþ^þŸ’ú(ú’’úþØú¯¢aÎÎþŸþ^þŸÎÎÆþØú’’ú(ú’’€€!Cb²+°@3°Í°82°/°03°Í°(2°D/°Ö°Í°Ͳ +³@ +°±"+°=Í°5Ͳ5" +³@5- +±E+±° 9±=5°,90154>;2+";2#!"&%4>;2+";2#!"&QŠ½h@&&@j–8(àPppPþ€Pp€QŠ½h@&&@j–8(àPppPþ€PpÀÀh½ŠQ&€&–j (8pPþ€PppPÀh½ŠQ&€&–j (8pPþ€Ppp€€!Cn²+°03°Í°82°/°@3°Í°&2°D/°Ö° Í° °Í°/² +³@ +° ±"+°+Í°+°<Í°„^^„^’gg’güôxTTxT€ pp pû‹jKKjK\BB\BÏB//B/þhP88P8ÿ€€ ° /°Í°Í° /°Ö°Í°ͱ +01$  $Îa¢aÎÎþŸþ^þŸ¯¢aÎÎþŸþ^þŸÎÎÿ€À,A°&/°Ͳ& +³& +³@&* +²& +³@ +°-/°Ö°Í° ͱ.+±&±990147623 #"&5465654.+"'4&àÉ¢5  #>bq™›bà&4þf4&ÿþm†Ç¦þã"  #D7e uU6 ÿ&ÿ€€&@LX‘².+°Í°K/°V3°EÍ°P2°>/°73°Í°2°; Ö° Í°Y/°Ö°'Í°'±B+°HÍ°H±N+°TÍ°T±4+°ͱZ+±HB±> 99°N³9< $9°T±7 99±EK³4'$9± ;µ $90147&5472632>3#".'&7;2>54&#""'&#"4>2"&$4>2"&ˆ3l¤k“¢”„i¤k3ˆ=&‡“Á–\N€§Šˆj!>à@b’†R¨R†’b@Šv)šG¬G˜+vŠ =T==T=g=T==T=ðíŸRXtfOT# RNftWQ îÏ|Mp<# )>dA{ XƒK--KƒXx¨ ¨ PTDDTPTDDTPTDDTPTDD€€,V²+°Í°!/° Í°)/°Í°-/°Ö°Í°±%+° Í° ±+°ͱ.+± %°!9°° 9± !°$9°)°%9015463!2!2#!"&73!2654&#!"&=4&#!"„\@\„ \„„\û@\„€8(À(88(ý@(88(þÀ(8àÀ\„„\ „\ý@\„„\(88(À(88(@(88(u€3Ey²+°6Í°@/°"Í°2°(/° Í°0/°Í°F/°Ö°Í°±,+° Í° ±#+°Í°±=+°ͱG+±,°49° °(9°#°'9±@6±99± (°+9°0°,9015463!2!232#!"&7>3!54&#!"&=4&#!"3!267654#!"„\@\„ \„À6Z.þÙ+’CûÀ\„€,D8(ýÀ(88(þÀ(8+5@(\&5ûÀ([þÚàÀ\„„\ „\ 1. $>:þ•5E„Ç;5E (88(@(88(ü#,k#+þ•ÿ€€ #8@‘²+° Í°7/°-Í°#/°?3°Í°;2°/°Í°A/°Ö° Í° ±+°!Í°!±:+°>Í°>±+°ͱB+±!µ %+$9°:³,-67$9°>µ /3$9±#-µ (1$9°³ $901$  $ >. 462"&676267>"&462"Îa¢aÎÎþŸþ^þŸNf«íí«ff«íþüí«šKjKKj9/‡¨‡02%ÊþÊÉKjKKj¯¢aÎÎþŸþ^þŸÎδþüí«ff«íí«ff«¤jKKjKþÍ/PccP/y””÷jKKjKÿ€€ #8@™²+° Í°1/°'Í°#/°?3°Í°;2°/°Í°A/°Ö° Í° ±+°!Í°!±:+°>Í°>±+°ͱB+±!µ 83$9°:³&'01$9°>µ /*$9±1³,5$9°'± 99±#³ $901$  $ >. 462">2&'."'.462"Îa¢aÎÎþŸþ^þŸNf«íí«ff«íþüí«šKjKKj9%ÊþÊ%20‡¨‡/öKjKKj¯¢aÎÎþŸþ^þŸÎδþüí«ff«íí«ff«¤jKKjKþ3y””y/PccP/1jKKjKÿ€€ '/7Š²+° Í°&/°Í°//°63°+Í°22°/°Í°8/°Ö° Í° ±)+°2°-Í°-±1+°5Í°"2°5±+°ͱ9+±-)³ $9±51³ $9±&³ $9±+/³ $901$  $ >. 463!2#!"462"$462"Îa¢aÎÎþŸþ^þŸNf«íí«ff«íþüí«š&€&&ý€&KjKKjµKjKKj¯¢aÎÎþŸþ^þŸÎδþüí«ff«íí«ff«ý·4&&4&ËjKKjKKjKKjK€3;C]² +°3°7Ͳ +°Í°;/°Í°°CÍ°+Í°D/°Ö°Í°±A+°ͱE+±Aµ !48<$9±C ¶ %&/>$9013!2#"'##";;26=326=4&+54&+"#"264&"6264&",Ô€Ô,þÔÔÀ’Ü’ÀÔlÀ€ÀÀ€ÀÀKjKKjµKjKKj,¨,þÔþXþÔ€€ÀÀÀ€ÀÀ‹jKKjKµjKKjK€€+7CO[gs‹—§³ã² +°Í°/±A±33°ͱ;«22°*/³Yq‰¥$3°#ͳSkƒ›$2°6/³Me}•$3°/Í´G_wŸ$2°/°Í°´/°Ö°Í°±+± ,22°Í°22°'Í°±D+°82°KÍ°K±P +°WÍ°W±\ +°cÍ°c±h +°oÍ°o±t +°{Í°{±€ +°‡Í°‡±Œ +°“Í°>2°“±¨+°œ2°¯Í°¢2²¨¯ +³@¨˜ +°¯±+° ͱµ+015463!2#!"&7!!54;2+"54;2+"54;2+"543!2#!"54;2+"54;2+"54;2+"54;2+"54;2+"54;2+"54;2+"54;54;2+"54;2+"K5€5KK5ù€5K€€ù€€``àà```ü ``€``€``€``€``€``€``€p`à€``€€5KK5ü€5KK5€ý``````þ````ð````ð````ð````ð`ðþ ð``@ÿ€€?V„°0/°JͲ0J +³@0< +°7/°BÍ°O/°!Í°T/°Í°W/°Ö° Í° Ö°Í° ±+°@Í°@±L+°*ͱX+±@°:9°L³!07$9°*±%.99±B7²@HL999±!O²MRV99901462+"&5.47>32327676#"/.#"#"'&7632327#"'.#"@KjK#@##W¤IpÂp&3z¼ # Ú—XF@Fp:fþõ_ €õ¼7ac77,9x­©‰R?d¨^­æ5KK5#:ûò:ücæ#+=&>7p #ý't#!X: q%\h[ 17@ÿ€€?EKjr¬°0/°UͲ0U +³@0< +°7/°LͳCL7+°HÍ°p/°!Í°I/°Í°s/°Ö° Í° Ö°Í° ±+°@Í°F2°@±W+°m2°*ͱt+±@°:9°W·!07BHLk$9°*±%.99±L7´@SWXZ$9°H¶F[ejklm$9°p°h9°!³JKnr$901462+"&5.47>32327676#"/.#"#"'&76755675323275'5&'. #"75#"'@KjK#@##W¤IpÂp&3z¼ # Ú—XF@Fp:fþõ_ €Í³µËש¬Ô€fµk*1x­ë•8 2.,#,À”쩉-!5KK5#:ûò:ücæ#+=&>7p #ý't#!X: `ÀeáoÅvþÙ:5 ¼\¸t-à  |*„½[ €3$²"+°Í°%/±&+±"±9901647 &4?62"/5463!2#!"& ‰þw 2  Ò þ.  2iÀü@“ ‰‰  2 þ.  þ. 2i@@-ÿ“Sí$94762 "' >/.$47 &4?62"/- Ò  2 þw‰ 2  þ.‘u > þ‹ > I ‰þw 2  Ò þ.  23 Ò 2  þwþw  2 Òý£  úõ Ô ‰‰  2 þ.  þ. 2ÿ€»;K°< 1þœBŸi7IÇ))þ9I7 þžþ !% ìì %!ôbýí¨cB/ú4 <Bÿ€€&67632#"'.5!"   ý€( ýÀ,( €)û##@ÿ€€258”²++° 3°6Í°2²+6 +³@+& +°0/°43°Í°2²0 +³@ +°2°9/°.Ö°2°3Í° 2².3 +³@. +°3±)+°72°"Í°2²") +³@" +°2±:+±)3±4699°"°9±06±3899°°901546;546;2!76232++"&=!"&5#"& !!àÀSö  ÷ààÀü àSý­-S Ààà÷  öü­Ààà`ý›Sý€Sÿ€€3;CK·²7+°2Ͳ3+²0+°K/°Í°C/° Í°L/°Ö°2°5Í°<2°5± +°,Í°2°,±9 +°@2°/Í° 2°/±+°EÍ°E± +°$Í°$±I +°!ͱM+±,5³ 12$9°/°)9°²(999±$E±99±K7@ !:=>@F$9°³ 5.5462"&6264&"264&"264&"4,,4p p4,6d7AL*',4p p4,àD‡€S,4p p`8P88P88P88PH8P88P@4Y4Y4PppP4Yþ%*EY4PppxP88P8HP88P8¸P88P8ÿ€€ '6B]iwƒ®²4+°Y Ö°GÍ° /°Í°‚/°{Í°/°Í°„/° Ö°Í°±7+°>Í°>±^+°eÍ°e±K+°Tͱ…+±7@ "#,/0$9±^>³CD$9±Ke·NOYjkuxy$9± 4¶,:;CDKT$9±‚³"#NO$9±{· ghku$901463!2#!"4?632&#"&'&4762#"'462"&7?654'7#"'&462"&4762"'463!2#!"@þÀU“SxySNïþï('“#þ°Tp   ÿ —YïR“þî#PTU“SxySþ²’    ÿ  7@þÀ² xS’SUþ±#’'(þîðPVüI   ÿ i@þÀÚþî’'(ïþ°VvxS’SUOW@þÀ?   ÿ —`ü,<T²:+°1Í°#/°Ͳ# +³#) +°=/°-Ö°2°6Í°2³ 6-+° ͱ>+±6-±#99° °9±#1± 9901&7!2+"&=467>54&#"#"/546;2+"&c 0P¢‚R'G,')7ð‚N;2]=A+#H  ¤ððË  >h—S6^;<T%-S“#:/*@Z}ügðð€€.H²+°Í°2°/°Í°,/°#Í°//°Ö°2°Í°'2² +³@ +² +³@ +° 2±0+01=46;#"&=463!232#!"&5463!2#!"&&@@&&€&@&&þ&€&&&ÿ&@€&€&€&&ýÀ&€&&ZÀ&&À&&b€2²+°Í° /°Ö°Í°ͳ+°Í°/°3°Í°2±!+01&63!2#!"&'5463!2#!"&b%@%'ÿ'&&&ÿ&@&&ý&&þà&&à&&þk"Gƒ²+°3°Í°2°/°3°Í°2³@+°EÍ°E°BÍ°-/°6Í°H/°*Ö°9Í°C2²*9 +³@*# +°E2°9°AÍ°A/±I+±E¶ $9°@°#9±°>9°-²(1999901353#5!36?!#3#/&'#4>54&#"'67632353!'&€Å¹‰‹Œ}¸ÌmøŸ ›î4NZN4;)3.i%Sinˆ1KXL7è~ýþ§#¨ä& *ä¨þõþاü* úÉ@jC?.>!&1' \%Awc8^;:+54&#"'67632353!'&€Å¹‰‹Œ}¸ÌmøŸ ›ð4NZN4;)3.i%PlnˆEcdJè~ýþ§#¨ä& *ä¨þõþاü* ú·@jC?.>!&1' \%AwcBiC:D'PÎ-²+°Í°/±+01&6763!2#!"&'7!! €&:&? ü€&:ý&?uPýmK,)""Kü,)"5€ÿÜ€hš²H+°_3°7/°1ͳ,17+°<Í°i/°Ö°VͲV +³@V[ +°V± +°ͳ +°ͳK+°BÍ°!2°±P +°>Í°(2±j+±±S99±>³ FH$9°B°&9±7H³>NY[$9°<±PV99°,±4S99011327654.54632326732>32#".#""#"&54>54&#"#"'./"'"%–_P%.%vUPl#)#T=@è/#,-91P+R[YO)I-D%n  "h.=T#)#lQTv%.%P_– % #,-91P+R[YO)I-D%95%–_P%.%vTQl#)#|'˜' 59%D-I)OY[R+P19-,#ÿ€€'3‡²#+°3°Í°%/°3° Í°2/°,Í°4/°Ö°Í°±(+°/ͳ/(+°$Í°$/°Ͳ$ +³@ +²$ +³@$! +°/± +°ͱ5+±/(± 99± ±,199±,2´ $9015462 =462!2#!"&463!5&%46  &&4&r&4&þÙÙ&&ý€&&ÙþÙ¼¼¼þø¼À€&&€¹þù¹€&&€Ýþ¹„&4&&4&„GÝ„¼¼„þ„¼¼ ÿ€s7CK‚².+°"3°)Í°L/°8Ö°?Í°?±/+°"Ͳ"/ +³@"& +²/" +³@/, +°"±+°ͱM+±?8±4B99°/µ2ADE$9°"²H999°² K999°°9±.)±45990164762#"'32=462!2#!"&463!5&'"/5462&%4632 Ò  R þ—¼„76`al¹&4&þÙÙ&&ý€&&}nþ  Ri&4&e*¼„f¥"3 Ò R  þ—€„¼`3¹€&&€Ýþ¹„&4&&4&„ Dþ R—€&&€57&5462!467%632#"'%.5!#!"&54675#"#"'264&"  8Ai8^„^. À   þ@ ÿo‘&þ&}c ;pG=( ]&4&&4“2 KAE*,B^^B! ` þÀ ` f°süà&& j©o/;J!#Ó4&&4&$ÿ €€%-(°-/° Í°./°+Ö° ͱ/+± +° 9± -° 90167%676$!2#"/&7#"/&264&"$à {`P¼T—²Qrþ€ @ Uþçþì @È8P88PЀrQ»Ž ùþ•³P`þ… à @U @¬P88P8Ѧ²+´ $3°/±33°Í°/°Ö°Í°±+°Í°± +° ͱ+°6º>•ò›+ °°À°°Àº>•ò›+ °°À°°Àº>’ò+ ° ° À° ° À² ...µ ......°@±°9011!2!6'&+!!Ì™üe±;<*¤þ²² 8©Ìþ²Ìþâ̹GQII¿cý@8 !üG¹üGÿ€€ +° /°Í°/°Í°!/°Ö° ͱ"+±³$901$  $2?64' 64/&"Îa¢aÎÎþŸþ^þŸŒÆ4fþÍ3f4þ:¯¢aÎÎþŸþ^þŸÎÎL4þ:f4334fþ:ÿ€€ +° /°Í°/°Í°!/°Ö°ͱ"+±³$901$  ,2764'&" Îa¢aÎÎþŸþ^þŸ,f4Æþ:4f3þͯ¢aÎÎþŸþ^þŸÎÎì4fÆ4Æf4þÍþÍÿ€€ /°/°Í°!/°Ö° Í° ±+°ͱ"+± ³ $901$  $27 2?64'&"Îa¢aÎÎþŸþ^þŸ,f4334fþ:4þ:¯¢aÎÎþŸþ^þŸÎÎì4f3þÍf4Æþ:ÿ€€ /° /°Í°!/°Ö° Í° ±+°ͱ"+± ³ $901$  $2764/&" &"Îa¢aÎÎþŸþ^þŸ,Æ4Æf4þÍþÍ4f¯¢aÎÎþŸþ^þŸÎά4þ:Æ4fþÍ3fÿ@€€¨° /°Í°/°3°Í°2°/°3°Í°2°/±+°6ºÀ?úd+ °.°À±ù° Àº?»ú$+ °.°À±ù°À°³ +³  +°³+³+³ ....@  ............°@01!%!/#35%!'!7€€ý¾ý†/dÅÄ ¯jg2ý|¢€úb¢¢xýêä55Œþêdc µ¯ ÿ@ô€h°/°3°Í° 2° /° 3° Í° 2°/±+°6º>Àój+ ° .°À± ù°À°³ +³  +±..µ ......°@017!%!!7!!  G)¦æDûH:¹&ûH;áþöüÜKd“¡¡S)¿)úËþõÿMUŸ²J+°?3² +².+°/°,3°Í°$2°U/°Í°V/° Ö°2°.Í°#2³O. +°Í°/°OͲO +³@ +³S. +° Ͳ S +³@ ) +±W+± °E9°O°9±.S°9° °D9±J³6BG$9±U² P999011463!2#"&=46;5.546232+>7'&763!2#"/ $'#"'&264&"`dCõ•À&&À:F–Ô–F:À&&À•õCd` ]wþqþ4þqw] @&4&&4`d[}‡&€&£"uFj––jFu"£&€&ýy}[dþ  ]§§] 04&&4&€#`²!+°Í°2°/° Ͳ +³@ +°$/°Ö°Ͳ +³@ +² +³@ +°±+° ͱ%+±± 99±° 901546;4 +"&54&"!2#!"&8( r&@&–Ô–à(88(ü@(8`@(8@¹þù¹&&j––jþÀ8(ýÀ(88ÿ€€ #+3Ž²+° Í°#/°'Í°3/°/Í°+/°Í°/°Í°4/°Ö° Í° ±+°%Í°%±-+°1Í°1±)+°!Í°!±+°ͱ5+±1-@ "#&'*+$9±/3@  !$%() $901$  $ >.    6& 462"Îa¢aÎÎþŸþ^þŸNf«íí«ff«íþüí«,¨,þÔþX¬á>ááþÂa–Ô––Ô¯¢aÎÎþŸþ^þŸÎδþüí«ff«íí«ff«ý½¨,þÔþXþÔŸþÂáá>áþÔ––Ô–€€/9° /±,33°ͱ$22°Í°0/°Ö° Í° ±+°Í°± +°)ͱ1+01546;2+"&%546;2+"&%546;2+"&8(À(88(À(88(À(88(À(88(À(88(À(8`À(88(À(88(À(88(À(88(À(88(À(88€€/3² +°Í°/°Í°-/°$Í°0/°Ö± 22° ͱ(22° ͱ1+01=46;2+"&546;2+"&546;2+"&8(À(88(À(88(À(88(À(88(À(88(À(8`À(88(À(88(À(88(À(88(À(88(À(88ÿ€€+EJ° /°!ͱ622°A/°Í°F/°Ö°ͱ,22°±;+° ͱG+±;²$4999±A!²).999015463!2#!"&264&"';26'&'&;276'&.$'&©wÀw©©wü@w©KjKKjK šÜ  €  þ¸è Ì\Ñ € f±éþáš  Àw©©wü@w©© jKKjK¿  Üš èH   Ñþ¤Ì  šé±f ÿ€€ /° /°Í°/°Ö° Í° ±+°ͱ+± ³ $901$  $%32764'&Îa¢aÎÎþŸþ^þŸ2  ýà! ¯¢aÎÎþŸþ^þŸÎÎò% @J@%6ÿ5ËÊ+/°0/°%Ö°ͱ1+±%° 901476227"/64&"'62764'&" 6%‹%k%}8p 8~%%üu%k%~8p 8}ûj6jþ–6ý–[<<ýÄ‹k%Š%%}8 p8}%k%üt%%~8 p8~´4þ–j4jý–-<þÄýÄÿ€€(° /°Í°/°Í° /°Ö°Í°±+° ͱ!+015463!2#!"&3!26=4&#!"©wÀw©©wü@w©&€&&ü€& Àw©©wü@w©©&&€&&€€/:² +°Í°-/°$Í°/°Í°0/°Ö°Í°±+° ͱ1+±± (9901463!2#!"&73!2654&#!"5463!2#!"&©w@w©©wüÀw©€^B@B^^BüÀB^€@üÀ @w©©wüÀw©©wB^^B@B^^Bþ@@@ú/²+°Ͳ +³@ +°/°Ö°ͱ+±±99017&?63!#"'&762+#!"   @À(@>@(Àý@À €%%€þ€ $%ü ÿ€ú-°/°Ͳ +³@ +°/°Ö°ͱ+±± 990163!232"'&76;!"/& À À($þÀ>þÀ(ÀþÀ   íü¡J þ€€&%€ Àÿ€€$(° /°Í°/°Í°%/°Ö°Í°±+°ͱ&+015463!2#!"&2764/&"'&"©wÀw©©wü@w©Úf4ff4þ-Ó4f Àw©©wü@w©©q4þšf4fþ-Ófÿ€€%/F° /°Í°./°Í°0/°Ö°Í°±*+°ͱ1+±*µ"&$9±.µ% '$9015463!2#!"&%! 57#57&76 764/&"©wÀw©©wü@w©  þàýà`4˜48.# þÝe \˜P Àw©©wü@w©©W  ýà`84˜4`® # þÝ þà\P˜ÿ€€)(° /°Í°#/°Í°*/°Ö°Í°±+° ͱ++015463!2#!"&27327654&#!"©wÀw©©wü@w©f4 '&þ *ýê Àw©©wü@w©©14f*à&')ýêÿ€€5C° /°Ͳ +³@ +°./°Í°6/°Ö°Í°±'+°ͱ7+±.±"'99°°*9015463!2#!"&3276'7>332764'&"©wÀw©©wü@w©§ ,j.¨Œ( `þ '(wƒa8!  Àw©©wü@w©©—µß  bw4/ *`4`* '?_`zeÿ€€ g° /°Í°/°Í°/°Ö° Í° ±+°Ͳ +³@ +°±+°ͱ +±³ $9°´ $9±·$901$  $ >. -Îa¢aÎÎþŸþ^þŸ’ú(ú’’úþØúŽþ€ÿ¯¢aÎÎþŸþ^þŸÎÎÆþØú’’ú(ú’’üãýâ1€€ÿ€€-<° /°Í°/°Í°./°Ö°Í°±+° ͱ/+±±-&99±±")99015463!2#!"&%3!2654&#!"63!2"'&©wÀw©©wü@w© À  ü@ ‡(€(þÀBþÀ Àw©©wü@w©©w  À  þý###þ@Àÿ€€-<° /°Í°/°Í°./°Ö°Í°±+° ͱ/+±±!(99±±$+99015463!2#!"&%3!2654&#!"&762#!"©wÀw©©wü@w© À  ü@ ‡@B@(ý€( Àw©©wü@w©©w  À  ýC#Àþ@##ÿ€€-<° /°Í°/°Í°./°Ö°Í°±+° ͱ/+±± '99±±$+99015463!2#!"&%3!2654&#!"476'&©wÀw©©wü@w©Àü@##Àþ@## Àw©©wü@w©©wÀüà€(þÀBþÀó€`B²Z+°@Í°^/°<3°Í°32°/°03°Í°(2°%/°Í°a/±b+±^@°I9±%°901546;&7#"&=46;632/.#"!2#!!2#!32>?6#"'#"& BCbCaàf\ + ~È2Ô þË  þ}0Ë$ #  !"'êþ¢?_ q 90rÒ Ÿ €p r%D p u‰Ÿ Ýü€?|²=+°Í°/2²= +³@4 +°/°-3°Í°%2°!/°Í°@/°Ö°2°/Í°$2²/ +³@/* +²/ +³@ +°/±0+°8ͱA+±0/±99°8±99±!±9901=46;#"&=46;54632'.#"!2#!!546;2#!"& a__÷¿¹– g *`-Uh1  þÏž¢üD –  ƒß«Þ}   $^L׃ þ…µ  þ‘4ÿÒb|°W/° Í°=/°%Í°c/°Ö°@Í°@±Z+°!2°SÍ°)2°S±+°Oͱd+±@°9°Z°9°S² =G999°°H9°O±1899± W±R[99°=´46O$9°%±!*9901?676032654.'.5467546;2'.#"+"&=.'&4g q‚%%Q{%P46'-N/B).Ä ‡9kC< Q 7>W*_x*%K./58`7E%ÇŸ‡ B{PD«‡  cVO2")#,)9;J)ŠÐ´ °"!*’ #VD,'#/&>AX2™Ý¯ ¯ ,-3‚€>)²9+° /°.3°Í°&2°/°Í°°$Í°?/±@+01546;267!"&=463!&+"&=463!2+32++"''& p„¡þU9Ó‘ @é/«¨Ôª§$ à þÎÀ ] VRfq …f=Sf´²þš oÌ ÿ€E[².+°3/°(3°:Í° 2°=/°3°DÍ°2°F/°1Ö°;2°*Í°2²*1 +³@* +°$2²1* +³@1@ +°62±G+±*1± 9901&76;2>76;232#!!2#!+"&5!"&=463!5!"&=46;  ×% )¿¿ þÇ×  þÞ"  þÞ ¬ þà   þà  ÖPþW&WX¤ý½ hU gþ¶ Jg Uh €08l²)+°./°#3°Í°2°/°3°Í°12°8/°Í°9/°,Ö±22°%ͱ122²%, +³@% +²,% +³@, +° 2°%±5+°ͱ:+±8±9901546;5#"&=46;463!2#!!2#!+"&=#"&!264&#!àààÈýýÈþ¬ùþ §àç@j‚‚jþÀ€v• uôþ~ôv€ÀÀù|È|€PT]aen^²I+°@3°N/·nDEMU]f=$3°Í·d4RS^_c$2°/·e3QT`ab$3°ͳ!*$2² +³@ +±$22°o/±p+°6ºÂð+ °°LÀ± ù°VÀº=¼ï+ °T.°\À±a ù°FÀºÂDï+ °`.°CÀ±b ù°iÀº=÷ïþ+ °k°"À±> ù°)À°³L+³L+³L+°³V+°k³!k"+°>³*>)+³3>)+³4>)+³=>)+°`³D`C+°F³EFa+°³ML+°³QV+³RV+°\³S\T+°³UV+°\³]\T+°F³^Fa+°`³_`C+°b³cbi+°k³dk"+³ek"+°b³fbi+ºÂ3ï^+ ³gbi+³hbi+º=÷ïþ+ °k³lk"+³mk"+³nk"+²gbi Š Š#9°h9²lk" Š Š#9°m9@")>CFLV\gmhikl................@,!")*34=>CDEFLMQRSTUV\]^_`abcdefgmnhikl............................................°@±NI±Yj9901546;'#"&=46;&76;2!6;2!6;232+32++"'#+"&'#"&%3746573'#!37465¯!ŽmY ‰Zga~bm]‰ [o‘"³Õ¤Ÿ¦Ñ§Ÿ  Ðu á#åKQã‹#F"æ!äQN @€@X þ˜hþ˜h þ¨@€@ý˜hý˜ hÿþÔ+€€€€ÿþÕ,8ÿè€3H\­²+±(+33°Í°42² +³@/ +°)2°G/°KÍ° /°\3° Ͳ222² +³@  +°2°]/°Ö°2°4Ͳ-I222°4°/Í°//°3°4±*+°2°)Í°2±^+±/°9±*4³7FKZ$9°)°E9±G°D9°K²999° °Y901373273&#&+527536353#5"'#"&#%22>54."#52>54.#8o2 LoÔ@!šR(šOzh=•ut 3NtRšP*šH :&D1A.1,GHI$9°F±:999±7D³ $9°8±.:990176;46;232#"'&5333!53'#36?5"#+#5!76;53!3/&5#"ÀÀÀ þÁ þÀiFæ¢æFþàK/ó/KÆq   èx7þ  øyý¸Ë±H l`ú  þÁ @§j–ýjjjjüZ såYýî wéhÚ/" "ÿ})GRù²%+°HÍ°)/± 33°ͳ"&$2°*/°CÍ°@2°EÍ°6/°9Í°2°9°8Í°S/°Ö° Í° ±8+°*2°7Í°&2²87 +³@8) +°7±D+°#2°GͲGD +³@G +±T+°6º<×ì$+ °&°RÀ± ù°À°&³%&R+±R..³%R....°@± °9°8°9±D7·!'(/?HI$9°G±;:99±H%°9°*µ M$9°C±+?990176;46;232#"'&333!53'#3!56?5"#+#5!76;533/&5#"ÀÀÀ þÁ þÀiFæ¢æFþàK/ó/KþáYq   èx7þ  øyþƒ±H l`ú  þÁ @ï–ýjjjjZ såYýî wéýhÚ/" "ÿ)9IYu²+°&Í°2°7/°.Í°G/°>Í°W/°NÍ°2°Z/°Ö° Í° ±J+²*:222°SͲSJ +³@S" +³@S3 +³@SC +±[+± °9°J°9±7³ $90176;46;232#"'&463!2#!"&55463!2#!"&5463!2#!"&5463!2#!"&"ÀÀÀ þÁ þÀf@üÀ€ý€Àþ@ÿl`ú  þÁ @yÀÀÀÀÀÀÀ"ÿ)9IYu²+°&Í°2°7/°.Í°G/°>Í°W/°NÍ°2°Z/°Ö° Í° ±)+²*:J222°"Ͳ") +³@"3 +³@"C +³@"S +±[+± °9°)°9±7³ $90176;46;232#"'&463!2#!"&55463!2#!"&5463!2#!"&5463!2#!"&"ÀÀÀ þÁ þÀfÿÀþ@€ý€@üÀl`ú  þÁ @yÀÀÀÀÀÀÀ"ÿÎ8KVÀ°&/°3°/Í°6/°Oͱ 22°U/°Í°?/°@Í°<2²@? +³@@ +°:2°W/°Ö° Í° ±+°MÍ°M±A+°<Ͳ +²A< +³@A? +°<±R+° ͱX+± °9°M³*+9K$9°A²&/G999°<´6:OU$9°R±3299±6/°+9°O±299°U± 990176;46;232#"'&%4632#"'&'73267##"&733!5346=#32654&#""ÀÀÀ þÁ þÀ˜m{¤8PuE>.'%&TeQ,j†À{¥þ+§>ID2FX;4l`ú  þÁ @¬i’½ž>wmR1q uW§¹ýrrr° :üMrL6)?j"ÿÎ8KVÊ°?/°3°@Í°<2²@? +³@@: +°&/°/Í°6/°OÍ°U/°Í°2°W/°Ö° Í° ±+°MÍ°M±A+°<Ͳ +²A< +³@A? +°<±R+° ͱX+± °9°M³*+9K$9°A²&/G999°<´6:OU$9°R±3299±&@³ $9°/°*9°6°+9°O°29°U± 990176;46;232#"'&4632#"'&'73267##"&733!5346=#32654&#""ÀÀÀ þÁ þÀ˜m{¤8PuE>.'%&TeQ,j†À{¥þ+§>ID2FX;4l`ú  þÁ @¬i’½ž>wmR1q uWü§¹ýrrr° :MrL6)?jÿ€@€\8² +°Z3°Ͳ +³@ +³@/ +°]/°Ö°Í°±+° ͱ^+015463!2#!"&732654&#"467>767>7>7632!2+".'&'.& &&þà&€%&&%`$h1D!  .I/! Nr7.' :@…$LBœWM{#&@€&&ý€&&š%%&&š%r@W!<%*',<2(<&L,"rNV?, L=8=9%pEL+%ÿ@\0°/° Í° 2² +³@K +°]/°Ö°Í°±+°ͱ^+013!2654&#!"4632#"&46767>;#!#"'.'.'&'.'.& &&þà&€%&&%`&#{MWœBL$…@: '.7qNþë !/I.  !D1h$À&&€&&€%%&&þ%+LEp%9=8=L ,=XNr%(M&<(2<,'*%<!W@r% ÿ€€*2?Sem‰¼Âò+° Í°P/´0Ln|¹$3°Gͱ‚«22²GP +³@G± +°¨/°½Í°‡/°À3°sͲAJ¢222°+/°.3°,Í°o2°$/°9ͲXŽ‘222°/±a“33°Í°°3Í°<2°Ã/°Ö°Í°9Í°±1+°0Ͳ01 +³@0. +²10 +³@1+ +°0±@+°CÍ°; Ö°TÍ°C±M+°I2°LͳfLM+°kÍ°L±\+°ŠÍ³Š\+°nÍ°n/°ͱp€22°Š±›+°•Í°2³x•›+°„Í°„/°xÍ°•±ž+°©Í°½2°©±¾+°­2°¦Í°²2°¦±+° Í° °’Í°’/±Ä+±9±3?99±@0±>99°C±=P99±T;±—$9015463!2#!"& 7>7654'.'&! 753##35#'33273#5#"'&3276=4'&#"542"3632#"'532=4#"3273##"'&5#54762#32746453#"'&7354"©wÀw©©wü@w©Ú A+‰&‰+A  B+ˆþìþíˆ,A RèPJ # JZK35DBCC'%! p3113C@@EC $)  )#!2 $)CCC‚f…"D 54BBB Àw©©wü@w©©E°T+<<+T°±S,;;,W FFþY§ú\g7ÉÉ(ÃÃû¬"þòþ‘(-:&&<‚:&&:œ44œ3ýí¡(*5’4*)$H12Õ%-(rþåüU;&&:LA3  (&§"33 ÿå!-AS[mw‹©¯»²4+°^3°/°Í´25\`$2°˜/°ŸÍ°Ÿ°œÍ±;v22°ª/°­Í°q2°!/°l3°Í°ˆ/°P3°Í°U2°Z/°Gͱy‚22°°/°Ö°.Í°.°( Ö°)Í°)/°(Í°.±?+°9Í°42°9°& Ö°%Í°%/°&ͳB9?+°TÍ°9±6+°\ͳW\6+°LÍ°\±x+°{ͳt{x+°nÍ°n/±]k33°tÍ°{±…+°2°„ͳŒ„…+°dÍ°d/°ŒÍ°„±ª +°ž2°¯Í°˜2°¯±–+° 2° ͱ±+°6ºÂ6ïR+ °"°,À±#ù°$À³"#$,....³"#$,....°@±()³ $9±&%±2;99±\6±GP99±{x²i`ˆ999±Œd°9±„…±99°¯±¥99±Ÿœ±9n99±­ª² o999°!@ 78@Aik¥$9±ˆ³)(„†$9°Z±'990147>76  '.'&3335!33#&'&3273##"'&5#547632#"'&72=4"353276=4'&#"5#632#"33273#5#"'&327676=##"=354'&#"542X;·æ¸:Y X:¸ý¸:Y oidkþÈ€jGDfyd/%© .06YYY—&CE%%EC&ZVV^Y-06 62+YY''.[[[52. ¯'EH$[!.³'CD'YZêt;PP;pîêt;PP;pçýÇ9^¥þùþqþñJŠgú1%=6îþ†* lR¯P%33%P¯Q%33&?FFÒEEúÿ077IÅI86ÙýÉ-CÓC½Šþ‘!+}þ 7>%üÌO%35 1 3 $EWgO%33%O.DD.ÿ€{ö'&72'&76;2+%66;2+"' ý¡ ï(¤ ÷&ïô'ñ ýðP ï*o"À-þâþJ.¬ Ž-üZý™-ÿ€€#7,²(+° Í°/°Í°°5Í°8/±9+±(²$/999015463!2#!"&;274'&+"%;276'56'&+"©wÀw©©wü@w©ã¹Ç~¸}Ä ¤ ¸ þü™» Àw©©wü@w©©c $`Ý" Øþ¦jþ!# ÜÓ #/$²+°$Í°0/°Ö° ͱ1+± ±99014>7>76  '.'.32764'&jGÞ‚ÞGkjGÞü~ÞGk~!þ"! Àl¥AIddIA¥lÀl¥AIddIA¥t& @J@&@ÿ€ÀŠ° /° Ö²222°Í°2±!+01 5577'5 @RîþªþêVþ“VW“þîRþþ©Wéþ®.þÏþã\?þãþÐýil`þä`lþÛ‹1þñþÁ~þÁþòÿ~ #ð² +° Í° /°Ͳ +³@ +°2°/°/°3°/°#/°!/°$/°Ö°Í°±+±+±+±+± +° Ö°ͱ"+±%+°6°&±.ɱ.ɱ.ɱ.É°6°&±.ɱ.ɱ.ɱ.É°6°&±! .ɱ !.ɱ#".ɱ"#.É°6°@±¶ $9°±99±±99°#±99013!3!'75%77777y xû”#ÜÃýCÀ ýj'«'ýÒMaMþ×}Ž|•y•ÿàý–jýC#î——–A–’·’$‚þ˜‚ßVý·UýGÿ€€%/?° /°Í°/°)Í°/°$3°4Í°./°Í°°<Í°@/°Ö°Í°±"+°'Í°'±,+°Í°±+°72° ͱA+±'"°$9°,²0?999°°9±)³"'+$9°4±&,99015463!2#!"&73!265##"547#$3264&#"%;26=4&+"tQvQttQûŠQt«#-$‡€Ü‚Åþè"µ€µµ€˜(®((®(EvQttQûŠQttz##ˆ?D~Õ|ÀD? ø¯¯ø¯=((¥))ÿ€€8° /°Í°2°/°3°Í° /°Ö°Í°±+°Í°±+° ͱ!+015463!2#!"&264&"264&"©wÀw©©wü@w©|°||°¸|°||° Àw©©wü@w©©¯°||°||°||°|ÿ€€ °/°Í°/±+±³$901$  $37!3Îa¢aÎÎþŸþ^þŸg^h h^þ5ÉÉɯ¢aÎÎþŸþ^þŸÎÎ2  ³þ-2þÎÿP£#<P\g<°5/°(Í°f/°aÍ°h/°cÖ±i+±(5±/;99°f·$&)-STe$9°a± 9901>767$%&'.'.? 7&'.'&7>7.'$7>'.676'&"8$}¼{)›<U,+!üþšø’  #¤ß7à ,$VÏÅg.GR@&\7<äÜ?5\H,1þÝþí+.@Ü“\[z Æb?Kk&$I7u5'Æ- .%W.L>§þ4~&p )4 2È{¬üŸ ””"8 eCI0/"5#`# ## /1 "ýŸ[€˜\kr,y9R ;&?L ÿ€€.AU`iG°T/°O3°EÍ°H2°j/°VÖ°bÍ°b±9+° ͱk+±9bµ=>L]ef$9° ±$;99±ET°L9015463!2#!"&7>776'&'&7>746&' '>76'.&676&66'4&©wÀw©©wü@w©$ i³µ0 +pØþñ„^&+3y/ù³" ¡þh¢ . ."ÆÒ!$2C',›©,&C–7-F X„jM+'TR$ Àw©©wü@w©©ûDŒÊ$4" P[ & Î57!? "0ý>š8Q.cAj'jj¥#"þp1XRMBn \i6-+.Nÿ€€#b°/°Í° /°3° Ͳ +³@  +°$/°"Ö° Í°2² " +³@ +²" +³@" +° °Í°/±%+±°9° °9° °90156767673!!327#"'&'&'&5N[@@''Ûlþ” '2CusfLM`iQN<: Ù67MNvþ|ñþvˆ$%Lò02366kÿ€€3\° /°Í°!/°(Í°2°-/°Í°4/°Ö°Í°±'+°+2° ͱ5+±±399°'°-9° ²)999±!°9°(°9015463!2#!"&3327675#"'&'&5!5!#©wÀw©©wü@w©*+=>NC>9MXV3% þî¤ 10D Àw©©wü@w©©¿þlN+*$% $µ8c'µ#Z99*(ÿ@ý°/°Ö° ͱ+± °90176;46;232#"'& àÀà þ¢  þ íàû &þ€ €ÿýÀ°/°Ö°ͱ+±°901&7632++"&5#  ^  c  àÀà&€ þ€û à@ý°/°Í°/±+±°901476!2#!'&@ €àû &þ€ } b àÀà ^ Àý°/°Í°/±+±° 9015463!546'&=!"&à&€ þ€û  Àà þ¢  þž àÿ€q&8M°/°Ͳ +³@# +°2² +³@ +° 2°9/°Ö°ͱ:+±³ '1$9±²9990147632327632#"'&#"#"6767qp¬Hih"-bfGw^44O#AŠY'T€1[VA=QQ3˜•“«KJ°?66%zä’""A$@C3^q|Æ}}Ä !"ã•lk) =KK?6 ÿ€€ (°/°Ö°2°Í°2°±+° 2° Í°2±+01!%!%ªýVªK‹üu‹-ýuß5^ýmý•üîf}üæÿ€~ "=EM[„°"/°Í°AÍ°H2°\/°Ö°Í°±#+° 2°&Í°"2³9&#+°3ͳ+&#+°0Í°0/°+Í°&±N+°Vͱ]+±&#·>BFJ$9±39±99±+0±99±AµDL$9014632"&467'&766276!+"&=##"&5'#"&264&"264&"4632#"&<+*<;V<ñ€lG H_Ô_H Gk€üg–@-K7>5'&7>.'&'&'&7>7>767&'&67636'.'&67>7>.'.67'.'&#"'.'.6'.7>7676>76&6763>4'>&4.'.'.'.'.'&6&'.'.6767645.'#.'6&'&7676"&'&627>76'&7>'&'&'&'&76767><&'&23256&'&4723#76&7?4.6>762674.'&#6'.'. "  V5 3"  ""#dA++ y0D- %&n 4P'A5j$9E#"c7Y 6" & 8Z(;=I50 ' !!%&&_f& ",VL,G$3¤@@$+1$.(¨ *.'  .x…,  $CN7  J#!W! '  " ';%  k )"    '   /7*   I ,6 *&"!   O6* O /í     Wh   w*   sW 0%$  ""I! *  D  ,4A'¾4J" .0f6D4pÆZ{+*ŸD_wqi;ÐW1G("% %T7F}AG!1#%  JG 3   J  <   mAe ‡ .(;1.D 4H&.Ct iY%  "+0n?¢t(-z.'< >R$A"24B@( ~ 9B9, *$        < > ?0D¨9f?‚  .Y  G ¶  þu7  ÿ€€ $37C[bu²'+° Í°/°Í°B/°Í°c/°Ö° Í° ±S+°ͱd+±S @  %)468@D\a$9±'·+Sb^$9°³FIN$9°B·"46:DU$901$  $>?>7&'!7 %&'327&#63"3>7&#">2&'>7&Îa¢aÎÎþŸþ^þŸ^XP2“Š{&% þÉþ–.0x|ŠÀÀ¸ê„|*b6”~ˆ#ôƒsEzG<¹øLÙ $MFD<5+ ’ CK}W)o”Ò¯¢aÎÎþŸþ^þŸÎÎ2|áYY›^D 1>]yPÕ¥Aòüè–4ñMWŽMªÔE6<¤þ 5*è² @9IþüïæKåˆ<ÿ€€^–°/°#Ͳ# +³@ +°D/°ͲD +³@ +°_/°Ö°IÍ° 2°I°Í°/²I +³@IS +°I±(+°Í° Ͳ( +³@(5 +±`+±I°9°(´@$9° °9±#°9°D³ $9°°9014632632#"'#"$&547&32>54./.543232654.#"#".#"ែhMI½oPែhMIþû½oPxô©I†oB':XM1h*+D($,/9p¬`D€oC&JV<’Z PA3Q1*223ŸáPo½þûIMh‚ŸáPo½IMhþ\ƒ%FuI2S6, M!"@-7Y.?oI=[<%$('3 -- <ÿ€€#;°!/°Í°*xý& þi5–5K55þ÷þq¼*)y(;:*þh )k5–5ýµ55K*xü?x*ý& ˜ÿ€€/8° /°#Í°Í°/°+3°Í°0/°Ö°Í°±+° Í° ±'+° ͱ1+01463!2#!"&3!2654&#!"3!2654&#!"&€&&ú€& àþ  àþ @€&&ú€&&ý€€ÿà19L°9/°5Í°:/°"Ö°*2°Í°2²" +³@ +²" +³@"' +°"°3 Ö°7ͱ;+±"³4589$9014763!2#"'#++"&5#"&5475##"&462"Ig€gI8(3ã-÷ &ÀB. .BÀ& ÷-ã3(8 ƒºƒƒºà€kkþ€(8+U„þe&þð.BB.&›„þ«+8뺃ƒºƒÿà%-~° /°3°Ͳ  +³ $ +± 22³@  +°2°-/°)Í°./°Ö°!Í°!±+°Í°' Ö°+Í°±+°Í°±+° ͱ/+±±(-99±+'±99±±),9901463!2"&5#"&5#"&5#"&462"pP€Pp8P8@B\B@B\B@8P8 ƒºƒƒº  PppPþ`(88(`üp.BB.Ðþ0.BB.þ (88+ºƒƒºƒÿ€€ !°"/°Ö°Í°ͱ#+±± 9901$  $ >&'&#"'.Îa¢aÎÎþŸþ^þŸ¹]^/(V=$<;$=V).¯¢aÎÎþŸþ^þŸÎÎÕJþ'ÙJ`"((",ÿÔÿ9I&?'&767%476762%6'%"/'&5%&2>4.", ´´ $ $´ " ´$ $ ´´ þÜ þÜ´ ´þÜ þÜ[›ÕêÕ›[[›ÕêÕ›k øø `2 ^ø ø^ þÎ` øø `þÎ ^ø ø^ 2`™êÕ›[[›ÕêÕ›[[›ÿ€¾1:²$+°Í°)/°Í°2/°Ö°Í°±-+° ͱ3+± -°/9±)°'90146$763276#"$&732$7#"$547sÅ™,!V[’ú”vn)^þ…àœþäÎz€f«í‚[68¶þÊ´hÉÿ€™Ì}))NÏs”ú’3(ËózÎœ‚í«f{n ´6¶À¥<þ®@ÿ€À€+&°/°Í°°*Í° /°Í°,/±-+±*°#901463!2#!"&463!2#!"&3!264&#!"@&&&ú&@&€&&ú€&@&&&ÿ@&&ÿ&&ûšÀ&&ü@&&44&&4& ÿ `ÀBH²²/+°,3² +°A/°3°Í°2°./° Ͳ . +³@ +°2°C/°FÍ°I/°@Ö°2°.Ͳ@. +³@@ +³@@ +°.±-+°Í°2²- +³@ +³@ +±J+±.@´ 5>CE$9±-´ &FH$9± /µ&5>$9°C±99°F±990146;'&462!76232+"/##"./#"'.?&5#"46  &à­&4­L­4&­à&&àCÐ6Æ@Bb0€3eI;·Ê:ົ »&4&&­4&­­&4­þÚ&4&«wÑ4Å) €ü€'' Ï5ãr €…»»…ÿÿ}G†(°‡/°Ö°1Í°s2²1 +³@ +±ˆ+±1°z9014?63%27>'./&'&7676>767>?>%63#&/.#./.'* 46+(  < 5ºR5"*>%"/ +[>hy  @æ 5d)(=ƒZ& VE/#E+)AC (Ž ÿª÷K%3?JUkc°"/°*Í°1/°Í°}/°oÍ°j/°YÍ°€/°dÖ°_ͱ+±_d°e9±1*@ >8BNTa$9°¶ 0dev{$9±o}°|9°j±p9901476$6?62 $.776$'.$&7>'&676&'&7676&'&&676.76&'.&676'.76&&‹€©YJA-‹Ö.-- 9\DJÁþýþæþôÕ‚µ  ’ß%  þÿ’ßþÛQ//Ñjo_--âoKDQ#"NÅ Ë {òWW3' 26$>>¬WCw·%`”Fí’`”Fíþ¸¹_]\µdf`$¼E ""F!I  B8/Ka`ýs2R´DE5¨) %^{8+?` ÿ€r 2°/°Ö°Í°±+°ͱ+±° 9°± 99°°9014$7&>7#"&§$³ý̵ŽŠÃ"#Ê«ÅÄI³$§µÌý~»EÖþüþac×þxWøøW^ åÖþ»»þè×cŸÿzk8°j/°Í°b/°[Í° Ö°l/°,Ö°@ͱm+±@,°S9±[ ³U]g$9014636$7.'>67.'>65.67>&/>./"­+f$H^XbVS!rȇr?5GD_RV@-FbV=3! G84&3Im<$/6X_D'=NUTL;2KPwtŽB X^hc^O<qþŸÐæ&Õ¼ ,J~S/#NL,ƒ 8JsF);??1zIEJpqDIPZXSF6[?5:NR=“ˆ;.&15Pt=  äþùÿë '° /°3°Í° /°Í°/°Í°/°Í°/± +0175!+!"&5!!5463!2ÖsQ9þüýïQsÖû*Öû*sQNQsÙBBUwþó wÞÿÿHÿÿHCTwwTCÿ€€ 1s° /°Í°//°Ͳ/ +³@/* +²/ +³@! +°/°Í°2/°Ö° Í° ±+°ͱ3+± µ %$9±/³ $9°±%&99°³ $901$  $ >. 5463!54632#"&=!"&Îa¢aÎÎþŸþ^þŸ’ú(ú’’úþØú ` ? þÀ  þ  ¯¢aÎÎþŸþ^þŸÎÎÆþØú’’ú(ú’’þÀ À þÁ  þÀ  Àÿ€€ 1s° /°Í°*/°!Ͳ*! +³@*. +²!* +³@! +°/°Í°2/°Ö° Í° ±+°ͱ3+± µ %$9±*³ $9°!±99°³ $901$  $ >. 47632!2#!#"'Îa¢aÎÎþŸþ^þŸ’ú(ú’’úþØú @  `  þ  þÁ¯¢aÎÎþŸþ^þŸÎÎÆþØú’’ú(ú’’þd @  À À À ?ÿ€€/<° /°Í°/°Í°0/°Ö°Í°±+° ͱ1+±± (99±±%,99015463!2#!"&%3!2654&#!"47632#"'©wÀw©©wü@w© À  ü@ ÀÀ&&þ@ Àw©©wü@w©©w  À  ýÿB@ &ý€& @ÿ€€ Z° /°Í°/°Í°/°Í° /°Ö° Í° ±+°Í°±+°ͱ!+±· $9±·  $901$  $ >. 462"Îa¢aÎÎþŸþ^þŸ’ú(ú’’úþØúŽ–Ô––Ô¯¢aÎÎþŸþ^þŸÎÎÆþØú’’ú(ú’’þÔ––Ô–ÿ]à6¶²/+°/° Í°3/°&Í°%/°"Í°!/°Í°7/°Ö°Í°±+°ͱ8+°6ºÀ…÷ß+ °!.°6°!±ù°6±&ù°!³"!&+³%!&+±6..´!"%&6.....°@±±99°± 99±3/µ*+$9±%&°9°"°9°!° 9014732>'#"$&7>32'!!!27#"'!"&'Ѫz’¹~Õu f:þлœþ÷› V6B^hD%§þiÇ(äÆ:ÿ (ïþ(%@µ*>ƒ6ß…¹þù‚Ý~̳ޛ  3?^BEaþ߀€#þ9cr€#Ý!ÿ€€K°L/°Ö°Ͳ +³@ +±M+015463!2#!"&66767676'&6'.'&'.'&©wÀw©©wü@w©€ C1 $$*=+T"ƒwh‰%4‡0C>9PC/+,+  /9F6¥( Àw©©wü@w©©ý$)7 .’3c M ‹3IU/A*7U1.L4[N .QAg#%@) ”€€Dù²:+°E/°=Ö³>$2°+ͳ!"*$2²+= +³@+' +°2²=+ +³@= +° 2°+±.+°5ͱF+°6º¨ÂÇ+ °°#À±?ù°)ÀºÈÂÑ+ °°À±ù° À°³#+°³ +°³+³+°³! +°³"#+°?³*?)+³>?)+@ !"#)*>?................· #)?........°@0154?5#"'&=4?546;2%6%66546;2+"&5#"'&é× é wþwwþw¼ ½þ¼¿ × `€G]B €Gúµt€y]t€yþ ¾¿þ¼½cB €€Cr² +°Í°A/°63°$Í°.2²A$ +³@A< +²$A +³@$) +°/°Í°D/°Ö°Í°±?+°%2°8Í°-2²8? +³@83 +²?8 +³@? +°8±+° ͱE+01463!2#!"&73!2654&#!"5463!46;2!2#!+"&5!"&©w@w©©wüÀw©€^B@B^^BüÀB^€`@`þ @þ  @w©©wüÀw©©wB^^B@B^^Bþ@@`þ @þ `ÿ€€'7HP[°./°+Í°!/°3°Í° 2° Ö° ͳ!+°&Í°F/°DÍ°Q/°LÖ°ͱR+± ±JM99±&²999°F²LO99901467&546;532!!+5#"&547&327!"+323!&#64'M: @€žnY*Yz--zY*û§nž€@ :öt÷Ùï9pþàY-`]]`.X /2I$Èü tkQDDQ54!/@@3,$,3@@/!Ó@&*0þà&°Ð&þà !P@þ´0”0$pÿ€€RV46?'&54632%'&5463276327632#"&/#"&/#"&546?#"&%%7,5TS]¬8T;/M7þÊ7T7%>54&#!"©wÀw©©wü@w©8(@(8!"Å5b„b.¿/ * =%/µ' #?7)üÀ(8 Àw©©wü@w©©7(88(´#~$EE y &Œ%O r    ®O"):8ÿ%_gqz²h+° /°Í°]/±&I33°)Í°/°Í°r/°Ö°Í°±k+°oÍ°o±+° ͱs+±k@   #&,`dh$9±h³#`df$9±) @ "BMUam$9016$  $& $6&$ 47&6$32#"67>&&'&67>&"&#"%654'ŽðLlLðŽŽðþ´þ”þ´ðeˆå=Z=刈åþÃþ¦þÃå2CoÄîiSÆ“ i 7J ?Lþê.*ÍK  Px¨þè.*Í Ÿæí~pòë;_ÐÊlLðŽŽðþ´þ”þ´ðŽŽð¯þ¦þÃ刈å=Z=刈åþ£–ü_t‡ »j`Q7  $ki'<Z ÿ:!   þ¸þ@! ûyžýy,i¦©k*%®ÃÑþŸÿ€E°/°3°Í°2°/°Ö°Ͳ +³@ +°± +°ͱ+± °9±±990146$7%&$&57%7&É]ÙÙþé5êþðäþŒÖnÌŒ%ýó“wÇŒ÷¤¬&à˜æP…ú€¤ý'¬!|OþzrSFÿ€ 0y²+°Ͳ!%)222²+°ͳ#'+$2° /°Í°1/°Ö°Ͳ +³@ +°2°± +°#Í°#±$+°'Í°'±(+°+Ͳ+( +³@+0 +°2±2+±$#° 901463!2!5 ##!"&5546;!3!3!3!32)ö)ø€ÀÀ€)ú ));€€€;)€&&€€€þ€€&&ü@&ýýýý&@ÿ€ €(6]°4/°-Í° /°Í°7/° Ö°#2°Í°2²  +³@  +±8+± ´!'$9±-4³!#$9° ±%99°³'*/$9014762"'%+"'&7&54767%27% $&` `û  ýt+8?:: À ::A Wþ³ê>4>¬þÖþ¤þÖ¬é.`þ .þ Î"›e$IE&þO ±&EI&Ï{hýŸ<µµþÄEvEEvmÿ€“!°"/°Ö°ͱ#+±²99901327>7327&#"&m:2+D?Á*%‘Zx/658:@#N ’Ï >+)@ (þÿ°oíþÄE=é“ÍW'c:†øþ–ý= ÃEÅ(oÿ€‘0La”°,/°7Í° /°SÍ°]/°3°Í°b/°Ö°Mͳ1M+°Í°/°1Í°M±+°!Í°!±X+°ͳ<X+°'ͱc+±M² ,]999°!µ 7EGS$9°X°9°²$999± 7´!'G$9±]S±990174676%.547#"&5467>3!##"&'&732>54.'&#"3267654.#"oYJƒ .”ËH?LÔp¡‰„KL1FE1@Z[@1Gþë „å:$º/Kce3:k[7'9C!5goS6j+=Y4%Q5">j@*Q.¶QŠ.R)A)(-Á”Rš6B@X?ŒZHsG;@"$ECP€N[RzsS`;v8\;)4^>0$/. 0$8]§.ggR4!8g;…}R'!;ÿ€À5>R]q|„z°+/°EÍ°o/°dͲdo +³da +°h2°[/°z3°VÍ°t2°>32#"&'%632#"$'.547.767&#" $7>4&'&$ 462#"&462;2762+"'462#"&264&"654&#"„^SAøX†[]8MmmMLmþÅtGé@W^„>4‰}þ¿¯°þ¿|‰0:M31ƒ$.>Wewpt+H+tpwwptþÕþ¸þÕtpSpQQ89Rj M¼¼M  cÜÜcáSpQQ89R’@Z@@Z5ƒ/9W>1Ò^„7ž§R2>mšnlMJþ’˜:„^>h!yÛTRWWRTÚz%e;C,ƒhWÚʺIKQQKIºÊ¹IKQQKI³9RR98PPþ½! MM ! cc†9RR98PPoZ@@Z@ý˜i….G>Wÿ€€AI`ht° /°Í°^/°QͲQ^ +³QN +°V2°I/°g3°EÍ°c2°%/°?3°.Í°r/°lÍ°3/°Í°u/°Ö°Í°Í°±C+°GÍ°G±b+°fÍ°f±i+°oÍ°o±+° Í° °"Í°"/±v+±C²=?999°G±JO99°b²;)999°f³*UYX$9°i²,6+999°o³%'3.$9°°9± °09±EI³$9°%³"'=$9°.³();<$9±lr´+016*$9°3°89015463!2#!"&32$654'>54&#"&'3264&#"'&&#"462"4762;2762+"'$462"4632#"&¼„€„¼¼„ü€„¼›'!”ÿ—–ÿ”#,H3<&—àSÎG12HH2$<ã _à$93HR4J44J1{z3A@:4J44JÑ****Á~…¼¼…ü‚…¼¼‰%=b§aa§b?'3I0k 12FGdH)!6 þÒm+I¸J44J6ž33@@ÛJ44J6V****ÿ€€ *<£° /°Í°-2² +³@ +° /°Ͳ  +³@ 6 +°%2°=/°Ö° Í° ±(+°#Í°#±+°+Í°2°+±9+°2°3Í°3±0+°ͱ>+±#(² 999°° 9±9+±-99°3± 99°0°.9± ·)1<$901$  $32654632754&""&=#26=##"&='Îa¢aÎÎþŸþ^þŸrsRQsOpoOþåx|PrrRz~{ÿ£€]0ƒ°/°.3°Ͳ +³@ +°)2°/° Í°1/°Ö°Í°±+°Í°±+°2°#Í°2°#±(+°+ͱ2+±°9±° 9±(#°.9±±%&99°¶  !"$901!2654632'54&"#"&%7265!#"&H7>3263232654.547'654'63276.#&#"'&547>'&#".'&'#"&%>327>7?67>?.'.*#"3>32#"'>;?757)æ £ ¶¥//7/ D+R>,7*  2(-#K‰cgA+![7>7>7 $&32>67>54.#"#.67>76'&#"'&#"767>3276'&'&#"';RKR/J#=$,9,¬+$UCS7'|ÐþëþÐþæÕ€MLCF9–vz NAG#/  -!€‚$IOXp7s¤_"kb2)W+ rJ@ Ÿ   #    5/1Y§|qK@ %(YQ›&N EHv~«\¤þç¿lsÇhp4AM@=I>".)x.--ST(::(›þY ! "1 [   / ,ÿ€€<ZxX°-/°U3°%Í°C2²%- +³@%" +°F2°y/°uÖ°S2°bÍ°L2²bu +³@be +°I2±z+±bu²FPh999±%-²)I999015467&6?2?'#"&46326'&"/.7.?>>32'764&"?#"&'&/7264/YE.A — %%%h%—¡— —A­UpIUxxULs T«@ ˜ %hJ%˜ —¡—D,FZ¼¡˜C¸V sNUxfL.C — %Jh%˜ ²˜ ˜@/LexUJrV»D — %hJ%˜NHpV®A ˜ %h&%%˜ ˜ ˜@.FZy¹UybJ/@ ˜ %Ji%˜ ˜ ˜C¹Wpþº ˜C-KfyUMt U·C ˜ %hJ%˜ Ž˜ ˜@­U sMUy^G,D ˜ %Jh%˜ÿcv•˜ £²Š+²+°3°’/°‚Ͳ‚’ +³‚{ +°s/°kÍ°¤/°Ö°Í°±—+°Ͳ— +³@ +±¥+°6º´Ã+ °:°=À±1ù°'ÀºòÅ+ ³(1'+ºâÃ++ °:³<:=+²<:= Š Š#9²(1' Š Š#9³(1:<....³(1:<....°@±±99°—@ &7MSdnx‹–™Ÿ¡£$9°± ž99±Š‚±Œ99°s@ c@I™›ž¢£$9°k³AEDŸ$9016767672,32%#"'47%67>7>7&'&'&'>76763>7>&/&'.'767672#&'&546323267>7''+"&'7'7j+.=;“üúý. &¶ýJlLDf' % :/d B 4@ } ,+DCCQv!0$ && !I­G_U% +ž6(‚’:!TOñ?Ë=þ/f-Ó%fµdL?6 #€Ænkþ^/ûÉöó !èéýX¶‰ "  ##  292Q41 5gN_‚   ûø  %1$I  BS N.’¸|ûónA‡‘þ™¹ã ÿ'0@P`p€ °Àβ4+±d”33°%Í° 2²4% +³@4 +´=D4 +±t¤33°=ͱlœ22´MT4 +±„´33°Mͱ|¬22´(]4 +±Œ¼33°(Í°0/°Í°Á/°Ö° Í° ±+°1ͱAQ22°(Í°1±8+±HX22°aͱq22°a±h+±xˆ22°‘ͱ¡±22°‘±˜+±¨¸22°!ͳ)!˜+°ͱÂ+±˜‘±./99±0(°90146;2+"&%463!2#!"&!#"&=!;26=4&+"5;26=4&+"5;26=4&+";26=4&+"5;26=4&+"5;26=4&+";26=4&+"5;26=4&+"5;26=4&+"^B€B^^B€B^8( (`˜(:F–jü B^€€ (8ý€`€€€€€€€€€€€€€€€€€€`@B^^BûÀB^^B(8(˜`(£"vEýj–^"8( ú€€€€€€ý€€€€€€ý€€€€€€ÿ€/?O_oŸ¯¿Ïßïÿ/?463!2#!"&;26=4&+"5;26=4&+"5;26=4&+"5;26=4&+"5;26=4&+"3!26=4&#!";26=4&+"5;26=4&+"5;26=4&+"5;26=4&+";26=4&+"5;26=4&+"5;26=4&+"5;26=4&+";26=4&+"5;26=4&+"5;26=4&+"5;26=4&+"5;26=4&+"&&&û&@@@@@@@@@@@þÀ@@@@@@@@@@@@@@@@@@@@@@@@@@À€&&ù€&&z@À@À@À@À@û€ÀÀ2@À@À@À@üÀ@À@À@À@ûÀ@À@À@À@À@@ÿÀ`%k°%/°!Í°&/°Ö°Ͳ +³@ +°° Ö°#Í°±+°Ͳ +³@ +±'+±³ %$9±#³!$$9±!%´ $901462!762"&5#"&5$462"@8PäpäP8þÜB\B@B\BþÜDƒºƒƒºøP8ää8PþÜüÈ.BB.€þ€.BB.8$Gºƒƒºƒÿ€€€ #3CQf°/°Ͳ +³ +°"2°R/°$Ö°,Í° Ö°Í°,±4+°<ͳD<4+°KͱS+±,$±"99°4±99°<°9±³ DO$9014632#".4>32#"&#"#"4>32#".4>32#".4>32#"&TMLƒFTMLƒFp§ÐYv¸"?B+Dï?BýJ·M&X=M{<&X=L|<'<{M=X&<|L=X&VFƒLMTFƒLMTÔPwoJPvoœý‰VÓ®vÃþés.= ZY 2+"&7.@U–ª–Ur_-$À$-_rð€óó€‘Å%üË&&5%Åÿ€€° /°Ö°2° ͱ!+0146762"'.-.&À,À&.$ý@Bý@$†ººýF@€ý€(BÿB(ý#<þ€€<%þþþú£]|éÿ€*.26:>B2°C/°8Ö°Í°?2°±@+°ͱD+±8³<>$9°@°=9015467%467%62"'%&'"'%.-%-%-%+#²+#À6À#+²$*&!þ@@þ@þ@@þ@!&¬””þl@€þ€¹¹þG@€þ€,””þl@€þ€` &@º&@À À@&þpº@&þ`$>àààà>×­­­üàÀ:¤ͽ½½ý ¥ ¤þ}­­­üàÀ:¤ÿþ!7;A¦²5+°/Ͳ/5 +³@/2 +°5° Ö°Í°,/°<Í°/°ͳ?+°%Í°!/°Í°B/°Ö°Í°2°±+° Í° Ö°Í° ±"+°,Í°<2²," +³,) +±C+±° 9±,± 99°<±)"99±° 9°%°9°!°9015!2#%!254#!5!2654#!432!32673!"!5!!&#"RWˆu?¬rt1Sr€Fþ²(ÍÇþÒN[¾þü\ΊÍeýnsm?vÝdþ¹ÖýÈÿþ3˜¶ZpìC~[µR ¦yK{T:Ö§´¾IMý²ÐˆÞ‰oy@7þÍ+|ý“Ãiÿ€€%,AEK©° /°Í°0Í°/° Í°6 Ö°9Í°9°3ͳK +°IÍ°&/°'Í°B/°CÍ°/°Í°L/°Ö°Í°±+°&2°#Í°*Í°#±+°-Í°-±<+° ͱM+±#±99±<-³BDFK$9±96±#99± ±-<99±IK°9°'±?99015463!2#!"&7!2654'654.#!532#532#327##"&5!654&#"75!>32©wÀw©©wü@w©€~u k'JT7þ­½|€¹£wjiž†Í>Š I'DH›•€¤~?þáF8q  Àw©©wü@w©©Õsqž*4p9O*ýsÙqhO¸Z^¹‡¤¿"(LE „±¬óMMþÉ8Bzl5R[eµ°/°9Í°>/° Í°/°#ͳV#+°Í°c/°_Í°Z/°ͳZ+°3Í°f/°Ö° Í° ± +°TÍ°T±\+°aÍ°a±X+°ͱg+± µ06;$9°T°9±a\´UVZ$9±>9±99° °9±#°9°c°%9°_@  ) STWX$90146326327>32##"&'#"'327'.546325.#"3264&#" #".264&#"462#"&zUIr19­¢rs££sþ÷wOIrüñ37UCY? @!'G2LI*?YUI+?YY? $G2#(œmšnnMLGWzXW>=W¦¬y\GþÅør¡¢æ£ÂPk\G;Ð@Y=$2G%,Yý¹%,Y~Z  2G [šmmšmº>WXzWWÿ€€1DV`j™° /°Í°_/°dÍ°i/°ZÍ°"/°Í°°/Í°k/°Ö°Í°±X+°aÍ°a±f+°]Í°]± +°ͱl+±Xµ$28ER$9±fa³"Z_$9±_·&)+PU$9°d²AC999°i@  ,2%5@WX\]$9015463!2#!"&327326?264&#""&#"%.#"4632'&#"676&/632#"4632#"'2654&"©wÀw©©wü@w©€L6$é G.2I§GffGHel # þ G-6L"8(- 07 ((}*: ('88';íD10DD01,7L77L7 Àw©©wü@w©©Œ5LÅ,:D1zefeG›Å,:L^P8 8 å 9 7P7I`DD`Du'66'&77ÿVïÿ->M\-²+²L+°3°AÍ°2°]/±^+±AL´ ?B$901'.?67&>7%.'>%67%7.'6?%7&±´“?a0¾#Ov "N¯þ\$> áP(1#00/ÚþÃÕ•6 'IŽÜþ]—"RE<šÓªâ98¼ 1G”#9Ô  ($=!F "Êþ…\H‘iTe<?}ý8J$\ þ9%ýd,6?þŒ»œ=Sþ‹VYš]C úÞj­þ™#¤ùà þ•%N#" Hÿ@À€)1;CÆ°'/±33°ͳ23$2³-'+°>3°#Í°2°8/° Í°D/°%Ö° Í°22³+ %+°Í°/°+ͳ/ %+°=Í° ±+°ͳA+°ͱE+°6º>ðq+ °2°;À±ù°ÀºÁëðq+ °3.°4À±ù° À³ 4;....¶ 34;.......°@±-±0B9901546;>3!232+"&=!"&=#"&264&"%!.#!"264&"ƒ]i¢bÀb¢i]ƒ€p pü`p p` ^„^^„¸Y ý@ c^„^^„ €]ƒ£^^þ]ƒ]þ€€PppP€€PppP€p„^^„^ eý„^^„^ÿÀ3;EMã²1+± (33°ͳ<=$2³71+°H3°-Í°$2°B/°Í° Í°2°N/°Ö°5Í°5±9+°GÍ°G±K+°ͱO+°6º>ðq+ °.°À±<ù°EÀºÁëðq+ °=.°>À±ù°À³>E....·<=>E........°@±5°/9°9±,-99°Gµ')* $9°K±$%99°±!"99±B-±:L9901546;>;5463!23232+"&=!"&=#"&264&"%!.#!"264&"ƒ]i¢b€À@b¢i]ƒ€p pü`p p` ^„^^„¸Y ý@ c^„^^„ €]ƒ£^àà^þ]ƒ]þ€@PppP@@PppP@p„^^„^ eý„^^„^ ÿà3S°4/°.Ö°12°'Í°$2²'. +³@'! +³@' +³@' +².' +³@. +³@. +³@. +±5+±'.³ $901647#"&47#"&4762++#!#!"&5467!" ’å&’Å&€4€&Å’&å’&þ2 $þÀ$ þ2&4“&4“&4€þ€4&þm4&þm4&&##&ÿ€€ $:P£° /°>Í°FͲF +³@FB +°M/°,Í°7/°Í° /°Í°Q/°Ö°%Í°%±+°Í°°3Í°3/±R+±%° 9°3@   ;I$9°°9±>F±DI99°M²0999°,²(.3999°7²%999°³$9° ° 901$  $32763232654'&$#"32763 32654'&!"32763232654'&#"Îa¢aÎÎþŸþ^þŸ) …®Ÿ-g+(~þ²°Ì 4#zÑ##íþÉ™–0  „oâ«Áþ…š*¯¢aÎÎþŸþ^þŸÎÎ(*%D= )/IK/%þé#!| #(* þæg  s" ÿ€€:NUk²8+° /°Í°//°L/°?ͲL? +³@LD +°/°Í°V/°Ö°Í°±+° ͱW+±µ 3;CPR$9±/8µ".1;QT$9°L´#('0M$9015463!2#!"&73!2654&#!"5%>36'&%#!"&463!2&'$'#&7&Q:ê:QQ:û:QG(ê((û(2ÇÔª ¯84@Àao¼ û ê UgþÚþ¡ AéU„¾ÿ ê:QQ:û:QQ:((ê((û÷ G;.Æþ}‘þ Á0 þT@4†¾3þ‚Ëfþò=Œ t !-;<JXfuv„’©ª½Ñ762"'?432#"5?632#"'?432#"5?4632#"&537632#"'7632#"'74632#"'732?.#"7462"&'7>2"&'732765?4'&"7567632"&/47632632#!.>  C  E  F  )  J  N  O  /!R U     ;  _U`Ã59u¦¦uüî •€ €~ ~Ï ÏË Êõ õí íü üô ôê êö ö| þ„ö ôÔ þ,ô öú þòòñ ñ  ýñþ  þï  îì  þì  íë   ÓJüÑë| ýç  rqƒ "þùÀ¦vu¥ÿ )9:²+° Í°/°Í°'/° Í°7/°/Í°:/±;+±±99± '±990115 $7 $&5 $7 $&5 $7 $&546$  $&wœÚœwÎþžþ`þžÎwœÚœwÎþžþ`þžÎwœÚœwÎþžþ`þžÎÎb bÎÎþžþ`þžÎªTVVTªEvEEvŪTVVTªEvEEvŪTVVTªEvEEvÅ€EvEEvE€EvEEvÿW\gy€ˆÑ²Q+°/°Í°J/°ƒÍ°/°@Í°/°zÍ°-2°/°Í°‰/°Ö°Í°±j+°8Í°8±+°zÍ°z±+° ͱŠ+±j@ W(*OXZ]dyu$9°8²:nt999°±2_99°z±>M99°µ@CJ{…$9±JQ´!$OXZ$9°ƒ±G]99°°M9°@±>_99°³(:dh$9°z³5nux$9°°€901463!2#!"&7!!"&5!>766767.76;2632#"&'#"/&'&767%67.'&'674767&54&5&'%!&'&'3274'&8(€(`8(8(úÀ(8€þ`(8ý ^U 47D$    7[!3;:“A0†?Ý«™Y  A4U3I‡•L38k Cx þÇ JL0 @(8(þÈ`(û€(88H8( ú¼(g- Upˆ~R›2(/{E¤J1&(!;þú  †(Xå6CmVo8ö%(*\ 9 ûéÿJQ\°/°Í°/°KÍ°/°Í°R/°Ö°Í°±+°GÍ°G±+°KÍ°K±+° ͱS+°6º=âï«+ °>°=À± ù°!ÀºÁ}òF+ °'°*À±<ù°8Àº>mñä+ °3°2À±,ù°-ÀºÁ1ó¶+ °'³('*+³)'*+ºÂ ïö+ °<³9<8+²9<8 Š Š#9²('* Š Š#9°)9@ !'*,-238<=>()9...............@ !'*,-238<=>()9...............°@±±J99±G²HI999°K³+01:$9°²./L999±¶%+/16I$9±K°Q901463!2#!"&7!!"&5!3367653335!3#'.'##'&'35!!&'&'8(€(`8(8(úÀ(8€þ`(8ýiF¤Ÿ€€Ÿ¤FþÔZcrcZþÔx þÇ  @(8(þÈ`(û€(88H8( ýýkå" þ•kkþJ !ýß ¶k 9 ÿLSn°/°Í°/°MÍ°/°Í°T/°Ö°Í°±+°MÍ°M±+° ͱU+±·-./378>$9°M°99°µ02456N$9±±699±M°S901463!2#!"&7!!"&5!!5#7>;#!5#35!3#&'&/35!3#!&'&'8(€(`8(8(úÀ(8€þ`(8ý-Kg kL#DÀÃCþéJg  jLþÞD½ÂDSx þÇ  @(8(þÈ`(û€(88H8( ú€j¡ ¡jjkkŸ Ÿkkþðþå– 9 ÿ1<C‚°/°Í°!/°2Í°3/°.3°,Í°/°=Í°/°Í°D/°Ö°Í°±+°=Í°8 Ö°'Í°=±+° ͱE+±· !-/23$9±'°>9±!±099±32°'9±=°C901463!2#!"&7!!"&5!!5#5327>54&'&#!3#32#!&'&'8(€(`8(8(úÀ(8€þ`(8ý G]‰L*COJ?0Rþ\\êx48>/ÿx þÇ  @(8(þÈ`(û€(88H8( ú€j§€RQxkýÕ !RY~ 9 ÿ#+2‹²+°/°Í°+/°'Í°/°,Í°/°Í°3/°Ö°Í°±%+°2°)Ͳ)% +³@)# +°)±+°,Í°,±+° ͱ4+±)%° 9±,°!9°°-9±+² "999°'°!9±,°2901463!2#!"&7!!"&5!57 462"!&'&'8(€(`8(8(úÀ(8€þ`(8ý€À€€@üp pp x þÇ  @(8(þÈ`(û€(88H8( ú€ÀÀ€€þÀþÀp pp p 9 ÿ 3;?CGKRí²2+°7Í°/°Í°;/°(Ͳ(; +³@(& +°D2°AMPU$9±X°^901463!2#!"&7!!"&5!546;76#"/#"&32764'.3276'.!&'&'8(€(`8(8(úÀ(8€þ`(8ý€ƒ¦ ¦ƒùWW6&44¿6dd$x þÇ  @(8(þÈ`(û€(88H8( û À§ýà §)5]ü]$59”9¬5Ÿ˜Ÿ5{þÂ{š 9 ÿ,<Ck°/°Í°*/°:3°!Í°12°/°=Í°/°Í°D/°Ö°Í°±+°&Í°&± +°=Í°=±+° ͱE+±=±-.99°³15:>$9±=°C901463!2#!"&7!!"&5!463!2#!"&%5632#"'!&'&'8(€(`8(8(úÀ(8€þ`(8ý€L4€4LL4þ€4LÀ  Éx þÇ  @(8(þÈ`(û€(88H8( û€€4LL4þ€4LLÇZ ýÀ w 9 ÿ0@T[ °/°Í°/°UÍ°/°Í°\/°Ö°Í°±+°UÍ°U±+° ͱ]+°6º?#õ„+ °1°2À±:ù°9À³129:....³129:....°@±±&99°U±BF99°²DNV999±´".&'>/.$&?'&6?6/!&'&'8(€(`8(8(úÀ(8€þ`(8ý~â 3 ¶¶ 3 œŠ ? Š ? ;¶¶ 3 ââ 3@x þÇ  @(8(þÈ`(û€(88H8( ü-- & óó & U?   üÁ  Š óó & þÓþÓ &` 9 'ÿ—Ù6h°)/°$Í°/°Í°7/°Ö°Í°± +°!Í°!±+°Í°&2±8+±! °9°²999°²$)999±$)±'99°µ &$901!67&54632".'654&#"327#'. 'XyzO©vŽ¢Ð´²¾:C;A:25@Ò¢>;eaAÉ¢/PRAids`WÚþ—þïÆ`©íH(¹ÀõÓÀŸ ' gQWZc[º×ƈþò¡-05ránÿ"&*-Q°./°Ö°Í°±+°2°#Í°'2°#±,+° ͱ/+±³$9°#µ "$9°,³!$)+$9014762"'&?'%%-%% "3,3""üÍ,üÍ"šÁÁ>[þ²þó NÃþðM[þóþ²N ý¥ØÁo")" ýÞ)ýÞ)ýÞ "¹þnþngßn´ßgý]¶¶¶ü§’´ßxß´’ý]x#Z²+°'Í°<2°./°P3°4Í°J2°X/°B3° Í°Í°[/°Ö°$Í°$±?+°ͱ\+±$²!999°?² 999°²999±.'°)9±X³,H$9°³ $901467&546326$32#"&#!+.327.'#"&5463232654&#"632#".#"n\ ¤u_MK'³¦£o‰ì§ûGªìÔ¨|‰g? CM7MM5,QAAIQqAy§¨{b& BL4PJ9+OABIRo?zª—nº6'+s¢:š¼¡þì£.Çz¤é çzŽcIAC65D*DRRD*wyŽa$, @B39E*DRRD*ÿ'/7ª° /°"Í°&/°Í°/°+Í°//°Í°8/°Ö°Í°±+°Í°±+°7Í°7±3+° ͱ9+±±99°±99°·  #(-$9°7±0599°3±1499±&"± #99°±$'99°· 14$9°+±),99°/±(-99016$  $&7&47' 6&  7'"'627& 6'ŽðLlLðŽŽðþ´þ”þ´ðZÂÂ&á>ááþÂÊ«|«ÂRªRÂÂRªR«þ„¢ÂZZÂÊlLðŽŽðþ´þ”þ´ðŽŽðÀþ„«ÂRªRÂÊþÂáá>áûÚZZŠÂÂZüY«|«ÂRªÿ÷!Z² +°Í°/°3°Í°2°"/°Ö°Ͳ +³@ +°±+°Ͳ +³@ +±#+±±99± ±99014$7 >54' $&Ê_×ÝþÝf«íí«fþÝÝ×_ÊŽðþ´þ”þ´ðŽ€Þùþü-þ æ‚í«ff«í‚æ`-ùþÞ¶þ´ðŽŽðLÿîc@°_/°d/°Ö° Ͳ +³@  +° ±G+°[ͱe+± °9°G¶5;NQ_$9016721>?>././76&/7>?>?>./&31#"$&ØÅ(@8!IH2hM>'  )-* h'N'¡ !'Og,R"/!YQG54'675#&#"432#"432#"2654&"3&547#6323#3275#"=3235#47##©wÀw©©wü@w©(DL+à`N11MZ % N92Z2¥<)Um©Q‹¹//Ê +)³&')-S9þÐ9kUeid‡‰=RÕ;XYtWWû©-Ya^"![ý›Y-©¾L6#)|¾þ“ƒ!Ä'(<`X;_ÿ€€"#° /°Í°/°3°Í°#/±$+±°9015463!2#!"& 3##.'©wÀw©©wü@w©pC†W–U3D/9$H  Àw©©wü@w©©Fý³þM´L'Ÿb‹;0bqGŠ9ÿÇ+Iw° /°Í°$9±<²%(999°8· #3>$9014>32#"'.7>32>4."&'&>767&5462#"'#"&'9]œØvž œœþóž@C$39a²€LL€²Â²€L4 &) @.&FD(=Gq qrO<3>5÷-¹wØœ\œþóþÄþôœ% L€²Â²€LL€²arh({ü‚󿵂72765'./"#"&'&ü ¹}‹¹……1R<2" 7MW'$  ;IS7@î5sQ@@)­R#DvTA ; 0x I)¿!:> ‹+)C 6ÿ>Â&8CO[¼°6/°GÍ°S2°M/°Y3°+Í°$/°A3°Ͳ$ +³@$ +°\/°Ö°Í°±(+°Dͳ9D(+°"Í°"/°9Í°D±J+°PÍ°P±V+°/ͱ]+±"±99°9³$9±D(°>9±PJ³ +6$9°V°49±G6¶'/24$9°M°(9°+°9°$³ <$9014$32&#"#".'7$3264&#"6$32'#"$3264&#"32654&#"32654&#"ÃMÅ°9Ó'©þä£#!0>R ýHþÞ|B+)22)+B´£©¡«‰u7Ç–D©þä[B+)11)+B-(33(--'44'-Z©£„éšþùœNJ ÚËø'31R23üªòóŽuÕWµm% '31R23ýÝ-,,--,,-ÿÿ&7632#"'%#"'.5 %&"€!ÿ þ;ò `ûÓþu%ü(À (ú¹þÙ!]#üc¢ÿÿ÷ &76#"'%#"'.5%&7 #€#!!ÿ ýñþÖ þ(%ÎP_þ"ìÝü'À(ú×þ¹!ÄÁ7‰üãÉ+ÿ€€4Iy°/° Ͳ  +³  +°G/°9Ͳ9G +³@9> +°)/° Í°J/°:Ö°CͲ:C +³@:5 +°C±%+°ͱK+±C:³ ) $9±9G±$99°)³% 12$9° ±99014766$32#"$'&6?6332>4.#"#!"&546;46;2#!"&('‚k“œÎzzÎþ䜬þÊm‰ IÔwh½ŠQQŠ½hb´F‰*þ@&à@þÀ@À*eozÎþäþÈþäÎz‘„ Š  _hQŠ½Ð½ŠQGBŠ'(&þº@`þ@ÿ€€ D²+° Í°/°Í°/°Ö° Í° ±+°ͱ+± ³ $9±³$901$  $ >. Îa¢aÎÎþŸþ^þŸNf«íí«ff«íþüí«¯¢aÎÎþŸþ^þŸÎδþüí«ff«íí«ff«>ÿ€Â€…Ò°g/²BHm333°bͲ7654'&#!"#"&#"#"&54>765'46.'."&>.¹.*©*"+8# » #Q3,°,+¬+#-:#"$$ð /:yu ÿ€€#3=GWakœ°:/±^33°4Ͳ4: +³@4 +³@4Y +°1/°(Í° /°Í°U/°LÍ°b/°fͱB22²bf +³@b +³@b> +°l/°Ö°2°Í°"2°±=+°>2°6Í°F2°6±X+°b2°[Í°j2±m+±=³ $%$9±X6³-,HI$9015463!2#!"&!+"&46;25463!2#!"&!+"&546;25463!2#!"&!+"&546;28(@(88(þÀ(8€ÀÀ€8(@(88(þÀ(8€ÀÀ€8(@(88(þÀ(8€ÀÀà@(88(@(88üè ý`. þ`ý @(88(@(88x   ü` @(88(@(88ûè ü`.  ÿ€€%Q°/°Í°/° ͳ +°$Í°&/±'+±$±!99°³"$9°±99°³ $9° ± 9901632%&546 #"'632 &547%#"»…~\h» »»…~\þ˜h\~…»»þö»þ˜\~…û »V´ …»»þö»V´´V»þö»»… ´Vÿ€€5j° /°Í°Í°/°(Í°4/°Í°°-Í°6/°Ö°Í°±+°*2° ͱ7+±°"9±±99°³!$9°(±"%99°4³&*2$9015463!2#!"&327264&#"'64'73264&"&#"©wÀw©©wü@w©}XS>ñ~°}}XT=ññ=TX}}°~ñ>SX Àw©©wü@w©©¯°}9xX}}°~:xx:~°}}Xx9ÿ/>JXgsN°r/°kÍ°t/°Ö°Í°2°±?+°Fͱu+±¶ )03$9°?³ 47;$9°F°9±kr° 9016$327627 $&327>7>.4762#"/5462"&4762"/&4?62#"'46;2+"o½¶¡@5Dó.ôD@Yo½þûþâþû½1 *"T0l¦,¶  Z [—E  [  Z Z  [ ``1½oY@Dô.óD5@¡¶þû½oo½S0 (T" 02 ,¦l [  Z)``¥ Z  [” [  Z =BûïH!_<õÏ™wiÏ™wiÿÿÿ þÝ ÿÿÿÿ ÕUÀÀ€À3U3€ô]€€€€€€y€n€€€€€2€€@€€€€€€ €€€€€€€€z€€šZ@€5€5 €€€z€€€ZZ€€€€@€€€€€€€€€€,_€€€€€€€€€€s€€€@€ €€@€€(€€€€€€€€€€€€@€€@- €M€M€-€ €M€M€€€€€ €€€€€@@€ €-€€€€`€€b€€€€ €€€$€ €€€6€4‚8€"€"""""€€€@€€N@€€€ €,@€ €ÿÿ€€€€€€ moÀ€ö)@€@ ÀÀ  'D9>XêRäX¨8¶²`ŒÎ’” 2  ü r Ô ` Þ xŒÜJ¸T6®Ò(üŠÔR@z †(øÈÄæRÀ.šjö ‚ ¼!šœšö›ˆ›Öœ8œ~œâ*pž:žŸŸvŸÜ B ª¡T¡è¢¨££¤¤(¥ø¦È¦ô§Œ¨†©|ª4ªì«È¬¨­H­ä¯Ð±¢±æ²T²¶³ ³Ì´f´¶´öµ¶¶€¶ê·f·œ·Ò¸¸>¸¼¸ö¹¾¼Š½d¾0¾ ¿¿€ÀÀRÀÈÁ6ÁŒÂNÃ(Ä*Ä|Å.ÅvÆÆ’ÆúÇdÈÈœÉzÊʸË8ËÀ̼ÍÍšÎ&ÎnÏ>ÐÎÑôÒ Ó*ÓxÔÔÔÖ ××äÙlÚÊÜVÜÈÝrݤÝîÞ„ß<ßþàèáÎâ‚ãHä(ä¢ånæ(ç\çÚéêBêøë¢ì>í2î"îÂïªð2ð¼ñvò0òšóNôÄö÷B÷Œø6øÌù´ùìú,úÖû.üHü°ý”ýøþzÿNÿNÿNÿNÿNÿNÿNÿNÿNÿNÿNÿNÿNÿNÿNÿNÿNÿNÿNÿNÿNÿNÿNÿNÿNÿNÿNÿNð^® ~ ~ ” .¢ &Ð $ö  ¢0 Ò ê *þ <( Èd É0zCopyright 2014 Adobe Systems Incorporated. All rights reserved.FontAwesomeRegularpyrs: FontAwesome: 2012FontAwesome RegularVersion 4.1.0 2013FontAwesomePlease refer to the Copyright section for the font trademark attribution notices.Fort AwesomeDave Gandyhttp://fontawesome.iohttp://fontawesome.io/license/Webfont 1.0Wed May 14 15:41:29 2014ÿzZðŽ‹Š‘     Œ’ !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqï rstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ     " !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abÒcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏДÑÒÓÔÕÖ×ØÙÚÛÜÝÞuni00A0uni2000uni2001uni2002uni2003uni2004uni2005uni2006uni2007uni2008uni2009uni200Auni202Funi205Funi25FCglassmusicsearchenvelopeheartstar star_emptyuserfilmth_largethth_listokremovezoom_inzoom_outoffsignalcogtrashhomefile_alttimeroad download_altdownloaduploadinbox play_circlerepeatrefreshlist_altlockflag headphones volume_off volume_down volume_upqrcodebarcodetagtagsbookbookmarkprintcamerafontbolditalic text_height text_width align_left align_center align_right align_justifylist indent_left indent_rightfacetime_videopicturepencil map_markeradjusttinteditsharecheckmove step_backward fast_backwardbackwardplaypausestopforward fast_forward step_forwardeject chevron_left chevron_right plus_sign minus_sign remove_signok_sign question_sign info_sign screenshot remove_circle ok_circle ban_circle arrow_left arrow_rightarrow_up arrow_down share_alt resize_full resize_smallexclamation_signgiftleaffireeye_open eye_close warning_signplanecalendarrandomcommentmagnet chevron_up chevron_downretweet shopping_cart folder_close folder_openresize_verticalresize_horizontal bar_chart twitter_sign facebook_sign camera_retrokeycogscomments thumbs_up_altthumbs_down_alt star_half heart_emptysignout linkedin_signpushpin external_linksignintrophy github_sign upload_altlemonphone check_emptybookmark_empty phone_signtwitterfacebookgithubunlock credit_cardrsshddbullhornbell certificate hand_right hand_lefthand_up hand_downcircle_arrow_leftcircle_arrow_rightcircle_arrow_upcircle_arrow_downglobewrenchtasksfilter briefcase fullscreengrouplinkcloudbeakercutcopy paper_clipsave sign_blankreorderulol strikethrough underlinetablemagictruck pinterestpinterest_signgoogle_plus_sign google_plusmoney caret_downcaret_up caret_left caret_rightcolumnssort sort_downsort_up envelope_altlinkedinundolegal dashboard comment_alt comments_altboltsitemapumbrellapaste light_bulbexchangecloud_download cloud_uploaduser_md stethoscopesuitcasebell_altcoffeefood file_text_altbuildinghospital ambulancemedkit fighter_jetbeerh_signf0fedouble_angle_leftdouble_angle_rightdouble_angle_updouble_angle_down angle_left angle_rightangle_up angle_downdesktoplaptoptablet mobile_phone circle_blank quote_left quote_rightspinnercirclereply github_altfolder_close_altfolder_open_alt expand_alt collapse_altsmilefrownmehgamepadkeyboardflag_altflag_checkeredterminalcode reply_allstar_half_emptylocation_arrowcrop code_forkunlink_279 exclamation superscript subscript_283 puzzle_piece microphonemicrophone_offshieldcalendar_emptyfire_extinguisherrocketmaxcdnchevron_sign_leftchevron_sign_rightchevron_sign_upchevron_sign_downhtml5css3anchor unlock_altbullseyeellipsis_horizontalellipsis_vertical_303 play_signticketminus_sign_alt check_minuslevel_up level_down check_sign edit_sign_312 share_signcompasscollapse collapse_top_317eurgbpusdinrjpyrubkrwbtcfile file_textsort_by_alphabet_329sort_by_attributessort_by_attributes_alt sort_by_ordersort_by_order_alt_334_335 youtube_signyoutubexing xing_sign youtube_playdropbox stackexchange instagramflickradnf171bitbucket_signtumblr tumblr_signlong_arrow_down long_arrow_uplong_arrow_leftlong_arrow_rightwindowsandroidlinuxdribbleskype foursquaretrellofemalemalegittipsun_366archivebugvkweiborenren_372stack_exchange_374arrow_circle_alt_left_376dot_circle_alt_378 vimeo_square_380 plus_square_o_382_383_384_385_386_387_388_389uniF1A0f1a1_392_393f1a4_395_396_397_398_399_400f1ab_402_403_404uniF1B1_406_407_408_409_410_411_412_413_414_415_416_417_418_419uniF1C0uniF1C1_422_423_424_425_426_427_428_429_430_431_432_433_434uniF1D0uniF1D1uniF1D2_438_439uniF1D5uniF1D6uniF1D7_443_444_445_446_447_448_449uniF1E0_451_452_453_454_455_456_457_458_459_460_461_462_463_464_466_467_468_469_470_471_472_473_474_475_476_477_478_479¸ÿ…°K°PX±ŽY±F+X!°YK°RX!°€Y°+\XY°+SsÆéfontawesome-webfont.woff000077500000000000000000002434601321131462300413210ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/web/client/resources/fonts/FontAwesomewOFFG0(üFFTM€g+ŽYGDEFœ OS/2¼>`‹z7cmapüA¢à€¸Jcvt @((ƒ¨fpgmh±eS´/§gaspglyf$. þœ’«BÆhead3D16h8hhea3x$ ²hmtx3˜Šó¤~loca5¸«â½=œmaxp9d {name9„ŒXPûx†post; åï­®¨prepFø..°ò+webfG(ÆêSsÌ=¢ÏËTt Ï™wixÚc`d``àb `b`d`d|$YÀ<›#xÚc`fccœÀÀÊÀÂÒÃbÌÀÀС™Š¢À|œ  ²¨˜ÁAá+à ŸQH1")Q``³8xÚÍ‘ËJ‚qÅçóVYøŸîZbŸBÛŠ@„öâ¢MP梵øâˆâ²6"Ò"Z„«–â2/Ѣ̩´‹æ¿Ï¡ M40g8pø Ì‘Fí'ÃR2Ž-g|z‡‘±æ>EÈi9“ tJE:£+º6Ýæ¦y …¡Äz_<°D%.IIKVòR”²T¥!mÀƒ6Fq$‘Fyq‰*hwHkkË~2¦Ó: KP"“„¤$#9)HI*R“– [ˆ †RÈ ‡J¨ †Ö®ïô‘>Ð{zWïèíÖtó¾yÞèÖ{õ‹›5öó*ûØË˼ċ¼Àó<dzì`;ÛØ`RZ Ի꫞zS¯êE=«®ê¨'õ¨fnGû»2\4^aØ,±}Œ^÷jÂåt®L¹}?&¿â~Ö¦’øòp%tFë#¿¸Ä†fºM'ÿˆxÚ]Q»N[AÝ ÄØ 9Ú³™Æ{¡ ÄÕbd;…åi7r‘‹q@D Ú¯ ¡¤H›!H|B>!3kˆ¢4;;³sΙ3KÊ‘ªwékÏSç$ÂÝÍ6ýNHµ³÷¤ë댴ƒZlfôÊuûþ ›Ñ”;jå=o)M;Z´§þÑü †ûüó;´4ÓôÔ: é!æ›qKƒïͺËú‚Õáb00¤˜¦â.?¦Rþ·4çjË°µ‘Ѽƒ3ùÉ4@SkmšþÔ!ÕóqK˦±6˜˜²þ$Á…ÉtUSµÌøÚÁ]²³è`ƒ*ÍØÃVy &Ò·$Ê, öb«Ä“ 9åÜÉþ¤@ùHƼIJ;ㆵÆ‘×À 6O³ÿ<›MmoÂøYÁw¿K:øȆÚb;b)€ DBFUù†Ͻ,äRûÏ@”€åñ´îØD<—µu1Vz~ÛÜòËŠ»V¹Î‹Bwoªj¨Ò)Íû^ξÇž ÃAcÁ›ÏûþJú<,®4hCz7zÿ¢µêˆ«¼>²'Ó¿±ZÿÿxÚ̽ x×u(ßÓëÈŒ°é”[ÈôåH_:år +J°Õj­zJÖ¼¶ûºR+W0óñ~8ÛyíÁ5j壞Þxõ¦NgŒûV[ÚDMüüL *œ›h=Ûüë…Aµ†‘¥0*Œš™ ³…)»JþŠLÊÚ ‘CI™œ¡Ýçq¬dc¥&0lÐY­Æኸó²Q› G~ôÈ‘—ƒÂ,ašŒp¥§×Cì}‘€ÆeÇu9aXC1‡ˆd癟c/-i%Ú—ÝNvD§2}å…Ù?ªœùq¢'7½ò†òÛ«69ö²rþÑÏ*/D³™)‰\vû±—ÙÊ#ÊjSèý)ê-Ãؘf#³)‹Ø#K»’­È“IYýÚ””™32_‘;S2Ï—Üе±ön3 d)‚®øóò¤0ë“:<´+YÑ‘Ž EΜç}YA§×è­l'NLŠJ1Ááv¹[5ƒlj„ËõåFHvˆMpp‹nϘvnlÏž±s…±=EÑ¢³ˆ¨ò»§ G{é9ZH\ù]4ð¯}W7Ê%„8¹Ð€î»_ë»’hufùÜ¡)à3ÎÓ'YDÑÂ1‘ÖWîíìéííé¼÷•Ö)|æÄÓÏi{½Q»=êíÕ>÷tçレÝ(LZ§.©Â¨Èø'Cd |¥ÔJç#v5ÕʺG8DD: [B£œ¹ëØ–Hd˱»FÎ*?_xÜž±/Ç<ÆÈ–¤ì¨”¶H¥°£·§¡_ò=) ¿¥]¦ÓrºRºêpm()$-¯®ÈŸJÉSÉÒá?k8ce ¡RôRÐNàKÒYŽåÖãÙ–Š< G¾´fòµ)ù†J¹øØ ^¹/ÝíÞÿ¡OãÌðEqçòéìt¸Iªo˜d¤NÒe—žB³‹Ÿ“9ÈH8Õñú’sò>ϘŽÎû7`Þ%/]ßö@ %ÇàÉ=.–5Ì;}Æ´–þî9¤7?­_ùE½ aV*ž§E–Y¬VËç‹ïøŒK׈ScLÙ‚Ô¼ QBŽPDJZÉ`; *ÃA–=päK@†ž¬õrª´ŠŽûr2ÞL–ž“·¹>•a™ÌÔTF¡ÇÅ2W|«+ER¤E÷ú7£µkž` ӗɉ´ìáF8؉2ü•ëá”úª?E$õ§”B‰Ö)?„«P÷g¿ì«=¦Ê÷ª´Ò|õæ‹LÙ‰ã«ÈcI9—FAN¦ÊcQ”¿Æ†A‹Ža1ÚlF@åõ×R^ß[‘½|©”SB|‘©r¾€Mó¸«Çb!w¥hU%‚uˆ^^Á^Ö´òÀ}äÙ™—[ABð‰m ‚Ï \Š˜—Ç„YÆÛäÇ+Q»lÌË¡LZ›óù $†lÐbZZE·NX_á’† °sK…ŠÉìŠBÅûEËYÑõYä¢ëÅ eC“ŠJà‚±¸lz˜ƒ‹ã@n­ëÞXW¡˜(¶_ÒjDg°}¸%þP¸5NÎw #¶€][˜{W¡0«òeQ‡d­É2ëYJGä>ºV›+(3w@ÿ{+r/_räkK9€D‡Y°—ô`S/ð´<|;í%o4Ÿ§â‰=×çr»tz+ ;ån³)– l¹¬NˆH,®åêÊ’ž}¢óº¶€­cÿá­§_þî˧·Þßa ´êxâÙS¯(?S¾­üì•Slqêàü±ÅÏ“±£kgÇu‰3·„æp×Á[ÏL®ëè´Ž*_ýüGñ†S¯ñ±tå^PWn…Ϫ|µHÃ÷#w?k¸)áÖTÊdô š*C4z\cì$ò `b€róäúU^™vJÍqbæÕYº¡RÚªr´õ9¡Î„¨ žcÿÿ;çvëœÕN¤øîÊÓµ‚ÝJ xTh™¥åZæèqžÖhiù–kø°»†¹ž¹›‘7&åCùzÔ-ù…ÌÁŠ|/m¾»SòDEöÑ/ól¥tpç HC%qàÌ¡äÜ ßöÙë½gΡÔ:UY{)°Щth#´ÜU× ³Ú|ÏUت/ó ×4 æ9)†BâЛ68ƒÿ* îîˆÊ ð£Li%z¨j%8@îõP‹•a ù:=üG¨&‰Óãì¬=0U q¸R})Ä7}ÙÚ_m2zwY,§»’¼EïÿŸV'ñõ¶?b´YÌwEôÛ¸Ýkû‚…çÍ_áq“±å1—Ùº´ñÃ&›µéŽmÜb…Æ,óÔ«O=õ*+þO³‹õ%ù­f³ÉyÔtØm»?å,_䇦›Ó«¹É¹«9ÕãcÚ¸/šºÜì5E1ilÛtcŸÉ¢¶íma?ÃÇ?¥ò0U¹6L±=³ƒ¹–ù4SŽW)a0Yr%TÞÕ ².í#ý¾xü°­E-£LÇû®Hn1™•o™ý3:`‡ã>åÛ¾éøù"p¶ãøé¥è7“¼ÙTÓRÚĸ™.¤¢¦$ê÷:’0ûʾœ*>dá\jwº)3b©È¾äGƯRöKØÈïF_¡R_)% g~ Œ§‰³¡æ·$Jpbä5NÜRgz cÇK.œèÌ"©é9±ó,¬Ëv¾•FŸ Hñ af X^!ûÈ'ɾW^Q>¡ìQ>a≟{â‰sÊ?ž{Än=[Ev\SÈç¾ò ûMhóDµ½bǹ1MÛV×–ÈV›´h¼XÍt0åjH£r-[‘G“²€±&YZ‹:àx, ~×€\&G„ªSµ ’ì0MÔ"S}1+B:=§sAÃj³XªQ}£çR^ò¬!â Û,@x»åy‹¾²Í1g½‰…Ô8 Fyš8 ÉB!Áþ'±›g¶\ø2Ô{6ôh¢O´¨k¬Šç5Ò·A´ù®7áÈúÌ°6heÄ”9œÃU] ൓馳ø$S¶cÿ{Q9¢ 9K*&àO@˜U÷ŒªÈ!¾”ÈUä_„’­R´!† ‘.^„ša¼ úö\=ÓBÉ«§œ³Ë †É lïÈ×µènWj”4*]ÐÐSÓ³a9U5ÎS]]Õo@ôï½à£÷“ï¢`w¦Y+tFU¦CÚ”‚½Ï®Ú¸)j ú!=N£Äy?ü©(÷lŒÌ¡–I)ÄÚýJAÉœ¡ƒšÔ¿åó¨‡9Z›GÕiÓÛ0mZ(°rEZ(‘¸ºrU§ 2ö-0m^ÄiÓƒð‰¥®n€Ø0{\0{^JÈ´u]|Ê4N˜õüŦMÁ5GI'ü™”¯5yš”9ÛÅ'ÏGuêÌØ­f³ò5£‘øw“.è~´Rî¢2g’’è˜t5Ô\û}$/"HKaâ‹_&\U`2êÕ…×WºP_& @‚ÍЋå ³™ŒÊ/:”ÊßNSž™-έ0­Zœ\ Û¥Ô¢‡Š}zºpàò ª!s¢Êc¸Åú<ƒî`.˜ 1.ÈYIóoLY/WðfM¿i–¼ç`UûÚK {ÉáÈ« C¯®@~:2ÌÆ›C¡æ…QZ§YïÜgâÈë Ïš/Xb(…-³xØU‡m " ÏK£‰ó´-ŒÈźÖç¦:Êç^Œœ‚ml X8kx>pQà/¤ØbT´‹Êœ}®Ì ‹¶,Ú·4Ú {€!©”C=hAŽd'UÜÎÐ.¶VJY$íÍ!Á^&Œ€º ­P2˜êt:¥†Þ]˜>»TF­ +Ýw–dÈÉœ½oÈñ%×—/ÊÔëo ­ñËÊ÷•²ò}Ù¿&tÓúÅk—?àú’cˆ=ý!â©œ:UQþ÷‡ž²7¸íp`QŽ¬2ïÝÿ$Ñ}ô£Ê¹'÷ï5­,ÊÚÃÛ‚½ORø8FsäNFµ9’šî2F‚”ªêÈF¤–Q™Uη;GÐÄ»ˆày$¸d£Dõ­L@S¤Ïéô&¨vöž‘c•²7†˜çÅu£-…â:L„•~)šá2 ª.Nt®âÑ ¿Ï=ä …<ø‘¼6ÓºK/]g²­øVN¿³9±&Ñ ß-Qm˽OßãÓF©Lòæ—gÖÓwÝxs€‘¯KÊÓI"Yñ­å+¸¼ºRήÆúlêSòj¾´êTÊÛ`ýö ¨¿2U:ŠËýôu@”-úΑõ!:Þy§ÝêÀ“‘TmÕôÃS»6BpÚAE •Ï´x§ »:Öï˜Ø¶mÂÑ\„ÅòÐÿñCs‹t ¦oÓ'"·>}[$Ezñïåï-–wæïÅ~[ߧ¾ø©>›ßƒ™=¨,(¯( ƒZé{·Æ¢iöî""YØ7&¶¸”ßDÖ_9ÿ‘–¦&“çî#þ>éÒ³’3îR~-¾gÕüú<ä¿4f+;miÖ8¡°0…‘ j¾¨IX -º&G‹I:,™â†¦.rí{Ú/l¾A´œU噳 â¹â<|fâý °ÄP­ç ™Ù|@ ÃÓ¾éø›Ì ›•ióP š?@\® ¸°³QGªG½2ú·3×3UKI;õvªpè #¥.áúòÐF—–R'ªGj¯+ÅÂÀïûAµ.´ ª‰. RõlKk›kAt4±Úòù:pêƺQŽ©º=°(-—÷Ô¡³iñ@–e²ÄôYØÎ=Å2‹¾×¾ð›^ø äÐS÷÷®_ß{ÿS‡æ¡üûÏ‹Î …m^¨ù5 ^Œ3[˜+˜rŒÊ§iy]E^ÇS®ÜY…Ü©”›¥aä;+&[“¥KpˆÉ:ìVpt ê?cT“±—E!‡ê™IAæÑl”ÑäD2HPMh´Fßr‚Öf3$…C}f”¤F´Ù xT"N+—F ŒuaÈ9éTNŠ±î±ž´dþ5ñLf \%øD»í2¿Ã&ž¶éȨR˜Rþ5¦¹‡¸ N£E;r QF¼|ƒÒGØ0D¹-ä/‚›¥ûŠ›õM&1ÖÆd_µê•À&åÃ{Cÿ4Ðm¶ùu’¨±kx+é û´À›ÌþÙ¯sì€òëfW›ÝhcF»Ã`eÕ° ßRq‡ò•Y÷1O2å­Å54Cf*ò®¤\¨ oØGyà œjáþ¤l>#OWä|ªlž¦r>Î*à §ùÒ6À«ŽŠ¼+¥«¿¦Ñ›$Ýp]+|ÞÓÓ2±ië.„ú6»Ûµ.›;àrA€ Ùa/Ûƒk)†9)½Ö ‘,Kh’u„ÒVÎé°rzŒX±ra:ÄAGÅ¡Êà0 z³8Vé€{Ã!=^fmEôM:-qi"ÙDZ«ÙO~v{—kÝûnßÝìÞ>’}¦²îä'>³»Kî:¤\OþÓ@HÇêKNíO\}b,5I †‰1rK{ËÚ±½6øHqÆc3·F}IgJËé4XŒZ ÙÆŠÄ;°ý½“™ù€'üÍ^ý‰kÖút.탩¿N·ò&Üzïè‰íë®ô/M\éÍ7Žu )ûjÆPÓ­jÞæ™gÊÝ8&ÀÄ1È@#VsXa¥šdFQÈ^™$5Áz:òìüƒºžêxÙ8WjçÞÃsp2«×ÅÎYåv~6Ò†Ó(=Jô£Ç8ËÐ8p:p:¬³ ö¼lÈ—¡K0LR^ŽæåHž)4é¢zƒ1‘bñöÄâ?òVÔœ$aس0ÝJÖn(Y|Pâ½4Š¥:ð°šxI,›`c9ÔC úéaäu,ÑÿC§!³Æù&è>ñYÈ©CÄ3¼IƒöÞžû´ÖÖG£³ÎȶÜ*°.»•á3œ¥©³ÉÂwzMú‹w\ÊÆìá1=›a›ÂÍ–&-w-kÔjl,eŠÚÄdpÀòäÂO¶÷_r©Í®iéÊq¶æ+sÆgó^惌OÎF;º¯@#s¥7㼈ßìæðšÌºú˜Â9±£GðÈÿ¡ºENUÊ©x55hì,oLaqã:˜P)¾t®Ÿ¨”î„Y´‘”´k`š¤„’a|°¿ØäÞÎ¥Âì‘£§n£¶s\@Ó2Œ9œ¨›B=ÂŽ"EB¥ÓƒÐÌÆBµÇn‡æO¼Ùˆ.‚ V3à“ú„ ‹ÞªH娮ÙÊê%×E¸yTu³DÓüŒºXní3 &PäщêZ›œVC‡Æ¡aµ1³Ÿã-Dgõ~V¸*µ)`$­ÖÿLDË…¦”Ÿ­‚éÁ Wñˆ:Âj¸¦oqˆ­Ao‡ö˜=¸eKÐî¸Ã1ŸÆîMäZ`Ö¢µ4rüì¿Uӵݸi-19–fknÏ‹ÏòÇƃÎN>n²Úë°§‰±%àµvK'œd[Ü>‡Æì±Zn¾–õÎ_Õ0Qï'½ð¯–ª2Gíû`ÔŸgÊÇp"ž®”¯Büž\‘,bé4U¾=EÙüý)tºXîØŠÃÛÑ#½•ºl] #Ý¡ú!:*òí©Ò‡`°·Â`Á°jÃGŽ~Ç·CGЫ³`4ÅŽßxÓ=÷=€Õ¡l>UÌ£žòØiÀ;Ÿ¼¸B(Œ'24}Íu7U•.5DˆhÜ®eX•pT)´‘¬©ê[ ›‘²ø7BQÍä0V 7Î`FÂpBŒ_B÷+ Î ÀœlÐár /à\9Ö‘}„¹9ènÄ «IзޱåH‡‘–¬ˆz#G´8Ôš¦µÿŽ§Èaôj ¹!³Å¦å4 §µYÌC¹‚Æ»X;¿X[ÖhH Y6®#Ëj´[sOgrßüäøÊÈŸøÜû?ËéýýÄøÖ>­¹¥É|óAÖ{þ ýN®¯+挴…Y6Üqƺú8çJ•5€%6©j9ÑO=^º“h6SA…AU(·>ãËÏ%¯ŽFw¼AZf1XDGçèQ£‘À±P!ϼM‘y»~©=R{÷výßÆ÷]¼H¿ŠÐ1z‚6[tNàŠµ¨U¸ÄÒ“…%}ãcn”gVªýÿSß û¶8„Å•ÇíïÛÿ=||ûò»ÄÇ·¶E^RíßéXCZ»©kðvÓq„Z'¯¦ÖÉÛ©uòDªj‹,ó¨ÎIJ'Þ%´=VañnŒ‰¨qqùyU^ÛAK$•êÏѪ·/ê÷“‡ß¦xþáwÞ–új_0>}‹˜°ï¢°ß˜D›p4¥â"úhS¯ëÒÆ ,yÁJ o‡‰öL=°[UK¼-4uôEß PX,Ã0R»œÕ¨œewˆ mqž¶X,/ÂL³Øc¥Í‡·«ýPRþó¿ \)uv.ƒK³g%¸Pbªî ò®£Œ–ÂÅŠÝ8¨Y¼Âß.äa nÀ›}x¹E4]°¬ R… P˜²Ÿ¦$ÑÂÜ õB-A0ÔTUSÔ¼p3;wó äö³%³˜[ìÊÑn^(@]¯¼pósä Q+tœŸë´"ùÀóP§ê ê±µ“`®[ŒjO$QÖ­z*$<PùHQ“3eü»$àòºêÞ Ö…\z(/»9 ì[Bì³P8Zåö"ùwâ¿@ÜF"0U-Ë’(U ô7tER˜a2s®x|æøñ™€†º œ/Ô4Æçgæh;eZ)°¯cÃãêÚðfQûšö0”š˜f&ʤ™²¾Š‰ž2¹í¹¾‚VôtM¯…®™0Ï‚^ÀPtÀ5rig:ÓçéTuÓ ‘AÃy¡œ&W 3ósÊÙâá]¯íúc—I϶êá¸ðS={Ù󑾬ôZ4ú|‘Ìpez~Ž0EhöA¶2¹°çzN’þÓÏ×b_4êrà B˜H=‰9xcO5ž-ßè9 /ÞŒžÃ Ç6™¨åQâªZº™ƒªu+AÕºT‹ ]ä3¤+¨<ÉŽÚ”‰êèÏ_%]Ê«¯]7.(IAN·îûª‡>Ûà&2ëkÞ`‚ŠCŽo0^õƒ×+ñx¼½^(iŒÈî èï‹a+ºƒ¥…îBׯ'Ÿ<·²——¦ð„êkN\;C›°š¢¥Rnq!·˜Ðp‘  óTÐÙï*“èè„JDM^ö e£KŸ§Î„%“³2Hô)+8+˜Q„`6"hL Q™~«î†+®÷S™´Áwý7è¶*¯*—+¯fòФƒø]>½&¤Ñû±Ìãw?õà®l …Z¯üÁƒŸ2Þùä«Ð´k;zND€snžwç‚$X¥§ºÿ˜w5ícF˜qÙUM²‡j’{*èH_„ ´‡ÎŠìäQ?ŠWz¨—½ú™–&Ð|™ì/YMÉL6§ú”–»G©ÖWÓWBÁl vu'2Ùþ¡ÑµãØLc/­Ë×­à4tņž÷Që@²A¨®Sܨ`dcêÜésÁÌ‘ôF˜54´ÑF^¸™+ŒöÙ8ÎÜkµ»]ótbs0±[ü…›ç¬±Ev†¦ç¦ûO<}b. =B@P>I>·Û·Å÷´Ï·›8 ‚Íz^€§ètjÄž±;,ðÞùU ‚;€BÎ(gñ!ðŒoןÁ&wûà[|»«~˜¨‹î`®`>Z…®«"O wy"‹4±äÞ쳃@mÉ*1ØwR°‹ ®èE bQu-ØT)oß„wmï„ÊMªß?ŒÄ.‰í0Kåî¼¼I(m¼ÐÎk±opÍø:…'\ès×y âcV(€¯JÀºZÀô¨ur/ú$eFôè«”k\4c¨óèu¢‹®/ Í 73oZDïÆ~“îxmì>//:Õ! ŒÞÜtìôK‡f`áñ"&*EºÍ(/¿çænÎmÐð&“+ßVGC´´h½!Mm,Έ&‹‡7Ê ëîÝ>½eÛª˜‹.UJQÌàÖ®¹{Pdwk±†®¾·6§uwî'™5¨+§šDo¥ìí¦¾„rR¶ªyÖÒ1P Í­4æÆ—¶ºÑY¸'·ŠUÄhÓÜð*ªF(å.ÄhÒ…8]]•UÁò`ôi@g“…Ó-Eh“E§sTJ<×{ƪñªÏÔ©p®ÂÁÝL_^€Â€ ðEˆã!dF¨7±ß¤Àx8˜½ì7MF,¬ˆk­gdk м×Ô½,ú°úû¼†A»˜ùE}™·x%(<¿PöyõÅÞpÅyè=…y¦Ú–¿ã /·òû4¼É / òðË:¢ÕÁx¶0ŽºÔJ@LB~~8·líR•ÌÁiTbµXEûs…‚šŸæM<’.Žüâ3o>£y^û ø=u^-Ëü@žÙ_Àƒž‡~ÍŠ"`Pá½3X¯žýzá×j ö*üvÂ3¯QŸÙ˜W¢J€“d§ÈÂ]êÝø”/Þ³þWÌKÚ,áû“ÌåûÌ0…°é¡|¿‘ïWùþ^Œ÷3ÃÚ€Q t¥ˆ9ÞŠåq•­&-Ê êz ë¯PKg„+ñ2qàFŒÚRóU¡JO¸Ëeòjý w0KúÕ2öËVAKóÅ~U£[üݲ¤_6f9«¤A7q¢Ë¯Ô½Z§VìÊbn¥•^¾–Ó¨ñ]sÌ%ô]AtSJLå€úkoœJáKûÔD„zÕ=Üg®Få´eé›w Õ¨GÇ c8˜N¢ Ž ë$IŽ¥pÈFÍ'€›è­_.ª½$î[¼âK/‰Þ(báš :ºå­ÛÖk–ŽW˜ÙZƒAK¨¶õQs©£†qµ®%£€¾—õŒ¹À¡¬#®ü…ãæFäÔ΃˜½ÆN/ënÂNỲmvû.ädþŽ». kk±+O‰Ø®Åg‡ž)×ýºf_cÕǬc®¥½¨È«©Ö:«ââzÚ«:¼—sÔé.ç¦,ÇãTÃ>ŽCs5&‹ˆâZ¯ð¢Ñ¡ÉŽÐþFVW± ¹ ¯::ÜÕP`ÄôVLE NÉL_nDƒ^"á¸,µØ2Xü½Í}¯Þ̳ÁP¦g2Þ3z Žë BmÍÇžßñÛ½ i–ˆ»Òc¿Zg^ãñd‚RÂå;¹:‚-ÅaÑîìMNt]þÔ%ózvˆ¥±iÌ@•*Ù¨Î?Q‘s*ÜkØp3S¸™Q›Õ™B‡Q¦ä·½UŠ.N[`_Õ¹«‚x[óm ARv+¡/:]Ëa1=mµߺû—`ýŒÕÎ2Õ‚2g·²g«'ÐáEÜO2{™ Ó¾ìëMÓleÇú©”šÅ)~¦lHoC-°Ræ'Sõ¬MªÖ~„äêÚûV⮧Á±}=N‚ÄÐ1 .×›ÂmÔC Ïár½)ÜV}DXò>}íYJ°ž}-ú(’­ed[àÙ#ôüȳ£Øàèò ¶ðÖ·W+ÞúæzÅòØÅÁ b‡.Œ]^»Ø±4v1˜¾hì"f…Š©«lÛ¢ŠÃ­®áI5GÔEâM<`2=aòâ· ËÎ/àø·º­zάÛ¿ÝÂ#±Ñeðh¿(<Ø*(–ˆÈ€G¼èæ2×u܉´ô‡ª½œ6Å{èÍpH¤Æ¾¾ø8¾Zh K* Ó¾ªÔ€ªÕŽ «?®ˆZ³EãhVûÚ‚}51´4'-¯¦ ²;a@O±ê¸;UºÙOü4¢çŸ•o+ÿ\¹æ ö·ïîÉs˜9öWO\¶ƒü‚ ?&‚ßT~Š%vó“Ÿ|€ý]OÌ?ÅŽ'¾sìÙû‡+¼™…>L2ÆËÈÎ$P1‚ PBH¸Ì˜Ø‰¡1]Ô6¤Â¸nëPyG´H…(û :>LJ’ò#v.³jUf¡@¢’4‰¾Ï '£l!cOKÒ„tZLf‹ÙI凑#‘©h”}(Jyñ¬v®ö­*¶ÔÞCÓ ï!Ô“Ÿ¨|&U7U}¹aé„7FyU†S~?+e²û`4ºp2–IÇàµHt¡YÅ2ðÃD‚†ª…“á\´ˆF'á­Htá‘…1Ô˜ ¼Í/ìEÍ*ŒZY›gêðp«jy ‚ºl@g¢„¿ŽOÇw˜”0{Õ;=)±Ù_oñõõ]^‚w)ná»>Ÿ( 5ƒ¾Ku)…Ô,Uxx™ Túi*SÌL ÇdRýñ,%v. U~#‡™¢ Ð$:I/žÀñ‰Ôå¹9˜Ó›)žÀràDg}ÆÅÔPNLŸ­qÒŒQFT‚ÃLo¯&g@OI&I'z¨^; X¯q¢K£EµäìÁ´Ð¨ºÁàx«ßQÍ¿›`clö“ì_•@x``æ¢Fåìþ|ø†ý#a­V°ñf½ÙÆÝIf¾uùrß´ '7·õ]zræ@n.l´9£-?Ã4òznXñ¨$ÜHNÜ®š*.‡t·.“a*>:Ìñ124ðF“Iyñ±j¼/g1‘)<©F ?¦¼ˆM 4îÛCs/mŸ‘$¶®ÇckÓôÝ,o>¬ý­ö=ê»õ½Å;·xç•_‚ý—•ßY\ñ-Ø/¬øÎU;c5‡ÒSö¡LÊ.ê,`M•5ÁELˆÐ¼IÚ,©²§­– ©Üæ©%Rª¦Pçw‘딦>¹Ô¬34i"¡nßÊ4=Á<4ìôJµ´}UÞgá9Ô£8—êQªê“ Djh†Æó…êÃëÉU=•Žú{«’<ƒñ_q´6cpŠšL¨¸˜QàjÜÚz§¢}˜—K§·L-d%±h½wZ”$G[Ĥü>Ñâ-x¯…¢:gM‰ká¼%¡üŠê%å÷ô4…KäÀµÞgžÚëáê‡Išæj­|î¸>ÑxE©à’¦W–®×~¦›é¡ëuæâUÛ«ÒáD’Æc–øŽƒï]‰Á'U~5'fbÈ°êuoÇÀ~RpX¿d‰Ýd²þØj2ñËœÅn‡ƒcù¢¬ñ,|Àd³™Ø£fÁ ›OZ¢õ«VÑaYÌÃÝî`ÒÌ*ÀÉ2å0b%H3qê ƒíLÉÚ¤<’FÖ},%§’ò8M&ÃO;™”¥3r¦2kÈH†N´K¨ZÚ€QÛ5­L[eVl„«èEŸ¤†˜uØF)©4äm° Ó¨X´É1 X'¸x4ð•R ¸`ÐÛEKCˆ'ÝA€2riuKšŠ©1—ƒ DQ¸K!ŸFëj8¤à‹WÞsÏ•‡‡‹ÅáÃX"_¤’ -f…!à–þø_ÞáíŒËßœ/¢ÌÝו;½lóßÝóå{6>÷ÜFøR¥ˆÚ¤±³7mé¶íüïš[ZšûÉ«ssJçèßÒßVµ™èUßë͘E²a=0¡ Mg@¸,›:&„àÚÁújž´M XÐV“?ÈãBɃï€]v¢Yªí)±®a”2E¡ÄS–lFM¥ˆ–,†ŒhБÍTŒji"˜]*c s^§¨›t¤ -N¯™ñ±ÆúêÑÜ‹³åÆL1G(æ‰xGByíGgÎ>yÚö„›OvŽø[;kà8ÌSíq¶ìq<@ôŸG à³Êÿù”xkxc߀¨YcJgßówŸ¸9b·qÆXÔÜÆÝ÷žöî?«|ý葤v¢0Upyý«ÎB69õìo?(e¤«^x¿³¶Çí‚6À]7SN ,ͪ>“¤9AzzKIS–d0ª"掵jœºVÆÜ M£Saz7OOoîãÈ·Ø™SÏVkÔ³™zè7½éÞ+·ïJï¹›öí'îúìþZÍt±Z£ò»8椟A¦—_ÌVá£Ñ4I•ïMQ]o¨‚9™J!dÝ$㫲¹N‡4)Ì6·Ü5‹Nð}諃ïXÎÄ$'ÅT3x6“ÓiUSx_uuŽ‡ÈX+ùÁCÇCJlá?”ØCGÞG'¯’Çß÷ôχ1\Fycø瘩Ìwê2‡Ïçxï,Ûº&üsâRþõçá5á_(¯×Ï×V~ûÛʯN¼õK@ó¥[ž<‚m/;·ÍÒ<™3zŒye<¿3tŒ`ŸG+Ô·%m¥¬¥æ,-5þ_–”;ÎÈ­) 1åõ_NØ:ìX$:ÐÔ*uQ#øè`~+`µ<(šˆÓÅH=]k'¶lEèhíe½ÝAµE8ÁÍ㨺ªöC zή…¯•À„˜pÌ¡§2µäj8ºË…ãÃä›ÄrÅ®>“]ë´9ž\§ì>Ôk²›Oñ]þûåG>M4›vì_AÒ3ñ*¹îÖ÷|ztïçòGlÝSÊÉâ1|œõNµ½Fxaoí"kôìWÌ/_Á¯ƒ'N®úÇÖ*ÊɇGç/…ðü_ÞkÿÍWfßs¼PÞZ*lýìWaMü}wìÁŸ«òkÓë0/tÕö« *ØEƒ¶5s ÑøN}=(ñm×#žc„¡uCÇ„£Â`è¢W_•,M?n²˜øE×Àam±-i;Wõ‡BþQî§JÎdVë;f}S“~~Ö*ÒUI´Öx¤#Ú#L }±º©/V:‰ÅÈkH£*Ÿn$æñéskizXˆ5ûpÌH¨­¸“`bš6Zuì× §h¬ÛT´òì‡g¦æ2]…©gg´BQoÖp6ò/ÊBVk¶¬Íøò|ù'‹yŸ‘d GÜžo*Z´Ÿ˜™*te榞]­Ó:ÂYȼ²ðuÁ:md›æ_Ö#%¢y‚öµ¸íQf5³ž™„Y°æË<ÌcÞÃü3ƒl_¤R.LDeP,YÛtÕEñJyÍ–#X×™,¯»äz¬ƒEu|ûqâž,O\vcºšds¦¤+ò.º»ÂUi4i‰°$Ÿ ö­H¥ïJáæ7%- ¿–Gyªlmï†ÚB¥´óÜÔ0m+pŸ<ºÞ–Ön€Ú©JiËvüæK6Üx¡"_ËÓ[/…Úƒ•Ò‘ãøMsÊWv0=çÑ0‰K¥t²Á*ZWQs;7¦JÌV?Ñš•¡ŠdbÃ5òÛg·g¬0¶‡¨_4ï¹"&ë(gëf1!Î4)ÀÂ^û—œ›5Ü_Ô2™©i4ÿO«Ç©Ìyº- H¡@TOD  J V9Ï\ô²ÊSÝÔžÞ` (æ êI¯¥Ø¥©rŽ†xç®By1G¥„FÊ:Hiy¹çòÄõ„ A‹ê 3ÒŒ”õÆdé=T2ºqÏ^T«O³–äêÍH3Gìeëª|Í¥@‹9¹]:˜]êÑ9L‚À$=´6º»uú„†º÷åZ5+ܲ’„În=Û³i¨ÃHøÛWï¸ò–5˜Þ´–w ½<ßd–5 êÕ³çf†6ºZÓéÉ.8g9X=Y~wàPÿÎÌTj,30¬XëÐhbäèØÎ[¶\–ªÉñÐtÎÄhÉ5;÷\þÉî—ºsãí~ûÂæ+_¤¥e÷Âé­îPb¸Á—–9 æxÙŒë®ß±³r®ÅèDkD•ÕGf!C†(”N ‹ŠËJ}òcÚœÄ>ò:™úüïÈG_]¹úwë&¿©œë]%´h8-1±fVßãl÷´6}ì%¶x÷¯?{àO”(¤üàO Ÿ[m5°.;Ñðge Ywb<~Ñ-Ñ)â*°­RAÔÁ—mTÈ´i0­R ³ìÈýª¿ ’º×FÝcÀ¡æõñWä!ÕÇÄa„^‚ªûÝ¢à×Ê¥F¸Ÿ`lØå»l\h×Çt'É¡K‰K†’êé7”g•qåÙo¨g˜ûUÝ×dñŒ­zëg¦$—FãBõ =ÿ+å«/½DÆØ ‹Mo£ò÷NÆ©{^¨Ú^«f׆$þ;U{îrãíÙ¬Èþ\ZĬøœXµÏ>Gm¹guÏs¯©öávªVÜå†[ö5úÕfü<ž ¿P÷•Ô_ŒÂºñ!¦ì©îDz=¦…£I<§@Ü<Ue+M+ÝŒÍꀹ´bE¥ ékqü*åÌZ¬Ì`tØÚ ×JxÃÚUÆNJØ­AôHÕäó¥ÌZ( #¯eõPe™¼^xÉÈ„2ýè¤%·ÛåUû¤Ï©º©š3Õ7D†iŸ:ú­œøÉ’œ–jzØ j‚l¤ ‰¤`“¼sl7Îè1™¡I¯aç`¤‹˜—¬vfSæeÛ.Ìa[vÎ#¢Ë¥WRŠMsM&‹¨1éƒÌ‰|yñT™qDPŠn7¡ÍIÑ«æ°ö§¨u¢·Xuc“ÇáS µ7 à‹ Ïu© E4Î.›)gJ¡¢qW'‚^K%±úöx—ã¡šóu¤ú 9¾ÙÖ¤ÑMÉ+šÏÿŠèµîi„Äx%W”-ý—ìTs‰dé—æùŒd±·¹¢zô—ñD¹Sz¿ÇÄ÷`Z¯5½FÃåÎÓ†Õ¿%9¿ÈÙ)ÿåL¢½¶!ó¿1Ñë½»Ia÷½ìÌî{ïÝ}Jg¹9,îݽg÷Öpz<ÓÅt€T úpQ±a&²‘&5jp¹êLbZ¦äW#v—ü"B:=Ñg0QQ¨ÞÓ ïØ}ïüÜžW†•ÏiɆ6²¥ó#cšB(Û¦ÈP:?Ê.¾ßÌÞqå„N#üQ[˜<”^ïmm +'à›Quü ;§Ã˜€AÕ{IƒÎ»ªþ¶à„ÅUæS5å-Æ©R4%S2¸Ùâó«ÉUú2Õ€Ö%>w‹v \Ëêâ` 0‰Ã¢»ÜÌ}§õ_ú×Ü;½ýþ?:{váìÍ/4ô>ûhßù[ã³?vaæTï,î "2^¹1žg„ù,Sæ«X.b[ŒqHÑ„2 nqP]qKÕ« ½dZ¡‹£´‹ܹc°àr@Em_ªŠÓ˜R¦«‚q?A_àjÿ#ˆJ¸}HiÖž—šƒR{·¹”»„ÙhGˆf{¢:ÕÙp¬ s1ËCÂl¤­SMÃÜ»|nP‘ h€>ˆE†wúx©žz…[¦5™ÌêhzÉsp„±<þn§™ÓSÝvpbé³ûìýqdðÇö¨I)ÏÓ#Ì–›N Å…)_ÿ Þ¡¸hp a±m¼nÛS³?ë>ðîézƒ:´l¥œ¤±IÜü¨ Œq J53Ùˆj8Çä¹#i…º“š< |‘–,@l–w7!ä‚ð¢ÞȸDu눌=Rå^rõ\‚j`K°1½»aTÉ^ >qQ¨Ð°ù*IÍ|ªr¹jšK„û‹I·eûùý‚1êä¦ìÛÔ÷-ì“_þTeîøÌq±½cËñê7ûú I}µò©—eåcÓ\'°©Â~“nã%;Ç Âþ0[pw¼c“ýÄ=ÂÍ?¾¥£]<^ý¦´×´÷uæ*æ0óóKæß™ó ów?YyïçE6?Yaëã£W0ƒ©–ømõéð4x0<†ªç0·,6øpú$x;á¹™¨c£ ÔKVãGšœ¡~½Þu‹ØdzO¨³É¬w¹ÉNÜ¡ö› æ&ÓczóÍÝô´ÉZoê¾›FãMõljáÝfhJŠê&,‡>hÒÍH?k˜²:Žt»Ns‹&-X>øA³=­9U­¶NØSš´ÝüÁwÛž†,MœRlôK&‘xÂí=«›ŒfCëMúvë‘„Çfú°Éy…Þ𾣉Ÿrõ„ܬÐToj2™õ­7ëwŠæ#É%M­›\]’‡ߥSnþËñ6¿û†f ÇFW:Yv};»ŽÓ4ßàöÛx¸ÖÒŒ×Öï+Î=ëñBs‹MÃÿwîš¿ '?n—ø7ÕBÍÆLåì(³ósmBJ*UÊømRç÷–Z€ žGC9n7Šö=ÿ²ŸÂùJ=˜"(m/çW¯¡Jdi“`QàûòS8ÙMBÉÙ†'öÍDOº:é©7 ¯£òº·2”Ê€¬>¢É%zäEpàLŒ¦µÐ?ߪÙ9Ecºpà+d-¹ƒ¬ýÊW”?ÿ‹ËvÞþL$Å5‰,!«åtDáýNÓí°ZŸ%ñï½Ï}×SÜnrúùˆ–è0Õ4u˜S‘gnßy™òïóà¯xàWÊ¿þêþò¸QÏ[8½N§ÑsèQíŒÆ=ã·p^³sûî×ïÛ8¹þÌm·|oÜ:%&NÏYy¢7Æ/çkz =L?s”$™òj„h¼¢Fð€@“NÉGqµ•w$qå݃j‚»51µmaúê»÷좑zå]"’Þ]—«¡UëTÞls5mE¾NÞ„E?e׶«®ÿǪùù*ÿ¶WÍ'dâeó\iŸæ yïœÌ6™Ìb§¼ŸÞ·Wì,ÃébÆ 2ÔÁó’©É¼wz_5/Ð’3ºAw_Šæ[+íÊÈkmÝ«TØìÌ—ÂëàÚT¾äl[-Žb£–pnÝvjLäfÜžL¾&/ïfõ⮫vŒFr‰Š²´º½¹º>Ô?ºNÑWѾ*t§QæCÕ%àÌF -rˆAÐ,ƒ'áºrm2K쑽·ÔKo¿o]|ðé^£’õgŽ\9ýç·p)ga™U·ÂX¢þ¤»Gû÷÷Ü:§m Û³[ sSJ™™.L{=ÑvWN#5wEÚc|XÑì¤çžÉló­÷vDW>yåUO_{ÅD0²qµÓu`ãƒÏvwÆ'¥YàŠ:½Í °>ímå7LRk›‡²;œÞ8ðÁý{¼7½¯Ó½F› dÃ{mXSÌsœô0ÈÓNPÏ­ÔÂ5X‘'å<ÍÿzM’†åÝ@yÜLÍĨ„>M¨š8¿òFêî°q &æK{ rG Âö#Ù'yy'•ÙíÂŨUŒúÚèoªÕÁËñ¹Òzíò†98™mïˆF­çgÇ×oŒ‚cFÁEŠQñöŽõãjÕxF1ª?CÃQK#F"Ƀˆ,m€Üù’m?\Û/9w t§æ’˜Š¶îu±ÍV¡”X†+{©y;|fmîìþË6Z]q Ö;° ð¡¶æÒ˜V܇ªÊhZ‰¸4fcÝt‰ËSuÄŠAŠfhıj)^\'Š_½îøCJ†8ÉØûôA¹'¾o{:Š7yÄžÁå7‹ˆÅÇÚ#]Í’&çjz¼€Nd:µ©3`sdíáVíþÅ{þ^ÛãNú£–Ë jÅ»º>þ€vã—sõÆHpâŠkŸ¾êʛ֬] îßv™3µñÏ$«¢×BÑ g)íwçûnòîÙ?øéðn" 7¯M&6ð­ÞK/ÙÀ ›^W“þ”+hÏ2öÚ®ßiaùþâ­+ì'~îì^Û'=Ïdô⎧1k®%…‰ÎÈ©;?aNC¾‚. ¥°½·-§*Ó¿ÅNê9jÿ²™Gå8^!+w‘ýÕ‹ήe×|¥sõô÷ØGìžñ·Ü=½ºó"{¯¯þÌŸ/|—M~å3[oßàÓWû\.ßêi>±áöj\fÖÍ8Ș똲T—IÊÝ•òÝRmdÀØYîT-^–Š4R%M¦Ô¶ÖlßÒÈV—•]Œ¿`1cžZUÝcy™C©pË"–hm… Ê$ܤ 3iªu bÑá Ô¢¸p£ ^IÍžâtÀéµì[ùšÕè› ôü⦹²^‰ÞxH –w¦.gcå,sšÊÚ¾J)БJ•}ºYn%B­ïrÒ’tòZ5㺕¥ a>5v&@± š‡°C á6ª)uý>LŒáEG ¡äqÃwÐ^êMå©ö/™F¦£ šÈ½+ˆæUëj6AB:1-„IZP™r§¨³J:v5Jäÿk}ž Ž“u'6XùKrÍ/õ¶¡®¿|â–û7°¿ä…pîŸÒkצ3kÖÌØÏ/L{%{¸÷cÊÃä‘g>~òÀ˜êCA÷c¼zƒJ.Î…08SÀ‡{’$K¶ÎtšæýLV±þf9w­WÊ\Ûrzcç,OëâÔƒˆ¯”yš¨‚·À•V>n@‹!ÍS@Úò2/ÈõI%„ª®z!¥j”9+n¶ãÅ(#/PÉêcWÑ ¹©ïªI^e[š̤E;¥¼˜YþHá¶o°Œºÿ§Â|ã6¯¤øÍB ù¹DNÑ~ª uß 51f”ÙÇ”£t·ƒJÙAw:r ,ê4)Ô6­0 ¼ á’ºq=f¦D3ªG€Õ!ÞÞBÊäNܧì:sC$¿æšÒ¸·ü’}ÓÞʉ³ŽÐ  õÈpܺ ›ÿ§&ö!Y¬†JfDyáº.ªaÌ´]-„¹¶•'` 9í¥weªÁ•ô®ªOem/$·JS†ª{>6x´.÷eEMMZ¥)3r•¦48°ª¸^0 ëÕur,ŠÜ­ªƒ*V ÜHN‡r¶‘Äœ 7+èÜ3·2ÑP>NI ;·„ÄÐ.@ê6‚"3ÈŒ1˜÷cVFÔÅR¸óúºÿæØ¢ÿæE’¡Š<Äã¾X°¦”ý4£ßj„eæWŠîù“ÒÂyç*´«œ3ÐßIÀ¡Ô€*7šÏ—ÖÁêSò¬F*2†j wÿèê†]-³Kä•®Ô•^t|¢¦9•5`YÊ9\nàÈ&AGœ óh8Äû·=\¹¡#+ù‡WOž´[çÉNN®öKÙŽ*o+¾üðÐŒ¾‡_~“áfŠñ~ÕÞ/®ìÄfm_{hcºob×Zu+µ»&úÒCí}ÚÍ'[¿é3þO~OyØÿ™MÓßÃZU}̶ë˜ãÌ-ÌÙ‡™—<ÌiycE¾3)ß—–o«”î> šNÊ»+ˆX8 ¡ü#Ý~DÞƒô{gS=ì¡û‘´¨ÓGŽ;1¿åªuÇ–=‚½à°;;»2Cã—\wàð±[NÜz{ñÞ¦š±;7l'Þ¿ù~œ³· /‰Å›î¹÷A<™¶š2Ρ5®ºöÐÑûÑK1º[°Þß–º£ rA=Ü5™-cœë‹I:F©%`dÜ:LæëÆ áþI ú­u,ðáFiºYJð$Òçvéu1É]ývI˜@B_?U¿s™tŸÓÖõÑ«µUâ,/¸L™ü®}«Ú7G»}‡bÒ•ß¼’ÏÞèïŠnn/ìÛ•=c«Üâ Ãáäuf½ÞÕi2YFÆW£+ËuÖdg2qZƒ)¢3õðIÚFƒÑh7˜ÍƒÙÒg°ñœÆÖË ¼0¬áy–mT‘œÂ¿íëÖyú6ßsé­—îºÁ÷x¼Þ¦@·ñ†]Pq÷–>.²ÚdêlÄ5œÑjÕjMýn·”´Fº›s¹¹ˆ]Ëiõz­Ö®36iõ¦¦U^­ÞbÖ;Œæ&|Ú]m“YGšXK«õ`zúÚ_¤¹f’LhùñêÞ¦iusO̼£­fÕ˜ ô¼‹†ôGë6=l‡é.6åa&h@ok¤ìÑ.Ü@Ò§Fë™{p_tÕSÏŒÛ!ÆÛóõ]Aéf²}¹Æ ¥ú†vÔ9[õV †VØñOœW fø*'ù“†=ÛÈœ½ÏNæp—1Œ’ÅàÙ7™®£aOÄî‰Ø?>Þ_ÛñõX+™E¥Ð‹Ó}µ€vÎÿpÉžˆ”'Ö¾Iå·«™í‘4 m«Rò /àôŠÑÄÍÆŠ|9ž]J¡gèHÊ=g侊ÜõLºªAèãKë‚­UÙ+*ñKvO*UºF•Ó¾¾ç7sªœ6ÅËs%7Hþ-sšY»Eìüò_Þýš®6Í6ã)4™œš¡ N„6¨C¡íó-nO³šÆŸŠmp^?¥bÛ¦>Áþ›±#2¸jÛ.:Û/îö v¦;o]O½Í‚¼MõÕ`«Á–j†[šþ¦, ú¬ºƒL8¤ÊHOs4ØÂQK‡‹2œî[ÎÒë±jãpÈJ.³‘ ÅË6=óõSC¿§['L¬FcdyûCó¹ý¯ó?í÷ìkÞpÀÕ\lvy\PÎÿ$ÿÒµwýÃÍÖ&³É`2iŒâ&ÇÐÿì¼vuÿ«¦ïì%¥cÿðÊçW oê1ØîÞé6 ‚É¥‹là9åÏÏçºüþc<—»ãÏvÄgÚÝ;ºü®¶H÷÷‰ã®[Z}Ý^÷.WÔNŒ=n«¯wÿü[CŒÂf*gõQ^T1ÑRmÅlä,¦qmåÔm©°Èª›eSp8¤Ê© .5štªyG‹Uo7I÷ÿR÷àmçÙðyÏÀ^“A H$H‚Ä NˆC‹C”¨-Y¦%Ù’(Ù–íÈ{ ¶by$ž‰ìÄq̸Nm7I €±Ý¤v>&MÒ´)2ZÇÍj+7I¿\mÒúï×$%Âÿû<ïR”ã¤ý®ÿúm 8ã=ç¼ó™÷]gJ¤uj™øÊý|£©Vkí‰õÛMu­¢;½Þ¶^%ØõŽ+ì¯g¦µ'³¥ßÒêõVµØ¾ÿÀ•½]PÑri·ØZg²÷Çz¬ÚZS#ÿW&ˆC­£÷6Õ f_P°ªMµ»Ü±ž¸Úª¯[ˆœ<¨nÈÄ™<#•}’­+"rÅb©‚ùÿáJ(¸Kùgç@:f™TÆ-&y±/ÞT–Ø ³±Wæ?p£$,©Š…€ Y€_Ó+s3½Ô¿ÌH\~®”0éœÑš³¦aBŠ¤\Dö_š7!Kžß³‡<»4Â:rvÇŽÒœøn¥Os7…z–¿˜ÛŠ’áV” ·&”ßJ¥±R A-œ®S"}ƒú6ëéØÜê—Y˜Éj]‰ØÁˆÆ¹ê%¤2˜/º‚&»Œì,Þ6%ª=™ÈJo¦$ÕV¾Ÿ¤ŸSuZ[ÜM–ôã'/lH&%¯Sgíí±¨m§pèáoT©[ºZtvA¨ñÔºtúÎdÇè ýjÖÒän±vªž+ýE?oU%i´#Ù©—4o`×­V«Œ|êáC‚Ó`S[š"fÓ+©Ú;º|¢Óñ8³k´QÙz;òs)˜@胳¯âtaˆ²St)4Te÷-k¼‰ˆ_[ òfîØ6ø½‘Ö“N OµÝBö}MóÚ½œ½z¶ùØe—\N&žz£ô7Ÿ)ý?Šðw\!é]ùSbPh{hf÷øGtÁ¦{_»Ê‘¾aH>8fòÞ]Zú·W®¦Ïuù;YáQ}ÈNeþGu9`=1—ÃdmΪE;¼ªñ!9Û9>Þlc¬`Ek0•"J؈MVet¶ú…€ì—/çÞùögßúôÎ~Ò*•¾ÉßDÂ?øBÑPú¯_+}oIËÿZ±û<ýkðv+ñË3Ø™ZŠÀÔ¨ l‡àV¢—ÃÜ)¿" FK452‰Ó½è£Â§¶©¹âÓó‰V‡S«‚¿¿ FÅ0®œœSúáÏjÝ¿¯Èå©ýYé‡|ö;,uç;çK×NJ5Ö¿ýý%¨«k4I­Žçiæ®R²{D€žÈB:]8]ÈDêEÀðÂXOÕè$O……Ñò Œò:õb^UÞ†“Ë!;Hĸ þJûŠà_ 0aüAK€‡±ÌËÈ? Ÿ/„¹G™œ§ïª¸·W²s9ª¤ ­zT¦k‰A耧ùÞVž†<ÀnP<}-¸Òj'ï 8ך~WºO;®@f—˜ß±FÄÈo¨8Z5’½(^„Ÿ%Ùs,d¨Ä”œ\ŸÔœŸt5@ÆÌ×Äâ`)j4¶µ˜J*"©7y#¯i¤J’TDên Ôž†>hA 2k “& æ†^p‹…¬¹ÚTýDñ惧µÐ‰Æiu9™_Vð"³3BÏØ*gx®‰žCÔÏ“Ù#Í“¦ë®?cämÖº3î&ÞYú³Ÿºýv«G *ò_ø³7Œ¼Ýê}ØÓL …ÒKwü;À®å?¦Î*Ï\]éGó^»Ãïþ)sòM¼ü°×j5¾ñg_(ùKo×Úí÷ß‘{H]ÁHšË¸‹Œ›¹Y‘ò_TÚÞ]îãÅ\o R‘ƒ´ycÐîêŠí"Eúk6ÑÅÎD¨ i" 6v¢E³HdN:0LΑRLL€wx"Qº¼tªwX ÚUÖ®h°îSŸéP·Ûj|ëð#·3¥Kðó veiñìøÜx ²A÷ùmŽ‡üëâ}-õ½±ÚV×ûûoÜ~]÷ÚÖÒw…/”þ¦¥ŒOÀr8ütFIÑ•¯Ð€xžq%-;…bbÍ›zì#”—¢z Ì)Ôcd=Ç°y»ÐáYpwa\žCY0º»4`ŸÈi€û*"«B ¦7IǨQ^P™£107¸»èA}-’ߤžÏ‡StMã¬ÀÍÉéå¼ÊŒÙ~ÝVÿ@`@ç•-Vt2ˆ"MbdOOZ|²Ç\¿ê2_üòâ šžéÍ ‹_þ"­¶ ‘K™ÄÄ+’õ¹O-e?E’G6Y,};|ÙO’ïÕ§¾l·Ú`¶Yí_þTéíR蓉 ˜¤'/‘b‰ÐZ,•â¥ol:âÛÑguˆ§:fIºƒÛÄq¶ r¤ºÙgR²À§ËÉ>ƒ}ªUì`:ÔˆYÆö Wóºú¨×¯& u-_èÔµ´Ô9S×Ò¢ëüBK]ƒ!ùjØpqƒºÁ~挷µªYhõ®<Ô¢34<ø`½^ײ|áê2aï„›ë—Ë”ù³ÊþУܛ _]¤Xˆbþtpjš,探b.Q—¿[*Wíe,ŠÃŒê 5áaÚw˜­«¦XØ‹Éà{wЮ6lÉmU{2S^Ø‚Ô õÅüíTà¶ÌwB€÷Þ>p\FÑ ôš9ç¡i˜žÝ¸™žÝ É·Fèg€&N#À줜یTx[Ñ3^ŸÎ_æ°ÉšÝ³ÕÖ¯A ôE‘yÅÐ_D× •âW°;W¸Ä©@PígÞË€Ÿ%¬Rá]¥VÂŒÀw©sÕ8jM5üº€1Ü ÞñNrãÑ'Ÿ8ö¢èGßø^{®¯Ú1¾ñ‹_Ýúšâ'㉉©ØÒb}Sýž 5Ã5ÆðÆ õc˜K\k“½f¯°9åØ6˜ Ü{ëhÿ“GŽ=9˜fNñ±¾²O<“©v‡O$â“ötr&22ð`›#³u«;]Ýöqî8wwŽ+¬W"W1Û·˜»Ó.Rˆ³N—«c\¶Mp®¼¯ªí[7×: ª‘Úø‡Š…C¨:J›}ÄæâÜÕÅÜÕ–üu¬ÉO(4y,TCr®/¡Óq^ <~ˆvw£6¸¦–ë®°{4yø«[F®‡&OÁU¹Ik.‘ιåì…m»®éa–ÎL¦½‡Ê¡2q?SO ÓÒU¯ª’•Ð\2DXHV@YåÀ8íRAÀ)©Áé-3íGÿ6°jôÍ;èòW6Ž=y”Üèüƒ;‚CÑÆ°1°Ž¯1Õ:j\:âƒE¡t®ï¹/ÞõPŽÁ/¾xì :ï“q槯صýk_ÜèóÖõ‡ëxAâ7†M5Äfu:4öÐî°´›’X—È‘'ûGo½7ÜæHmh§mÚñäí#}cO}Pš¸ÊéH>y41QñS×øvlËdølM¬Õ/*~kÆÙ!„üA×ÀHd&™¶O.=¯˜ÙÊqtm‰q³t^ø>W8Êòb»å0†ÚPñîúÝì¡;Ë]V×C'°áD¡­L,°òûös{,ù€>É`ƒlè3¼ !`PŽÁìBÅ÷Q=rÂŒ ÅÁ¥íÞ}`pÈò;hß0n¥‹öô™Ûú‰+Pw:z˜žm¤‹OþÀí9NÎ@v;Av?ÛzzvbŠžÝ!CÆ“‚N‚Ú|:ëèÊŽº+FêUœ8r¢CÂÆNÙa²wa@ŸÒýƒ4b²} ô2d=¯t‡5Æ(¶ÒÊ‘œ-KþÒCW!Iä³—œNÖš{ªfKN3K¶*>EÖîqÚê'i»6x¦¶žÍHâƒæ*²y¡BQ!ÕO;ÀÎhîÆÎ8XÈLer計¬Ú¨»‹¹Ý–üa~WK~Ì1˜]¨p±Uî'ˆÉw$€z½+C77 çzÓ¹ÝÖ|$ÒÄZ_r;äÿÆ©cØòŒ \z¹Í2=“ŸòÁŒ²‘–ÝI%ÏYÜ\XNó'O€JV2ÝL¬Ò™Ð0Eó“JÁ²€ªL`A”Ñzš”ÁêA[7…{ °øÌÿ›ÄrÛ¯|õèì^÷ä±#Ovo¾åL¶<㉉Žtõ`]ÂÁª•*CµÒ~ûôR¯¦Ó‹2U¦˜mO6±2ÕðSmkW°C" 2ž…IE;­ }y™]´Q¯±!1l½$D¿½' B&¢¤‚l™êVPÕ«DÚ­ûÈœµÛºÏj}ü åt¯Ùlûè¡ÒÙ}|MÒ’¥³V+œ ¡Ü^C‰‰7Ãåô5üƒÒtņ§¢¿ ¿Cezgwȉ%T® ‰À/4Â-»á†¨ã;ñý¡öCN0¬A Äd$5»‰‹¾6T-ÂÓ‹UÄNë¸CÝ ½¤Ú$¸ÀˆÔAú&¶hÖ£ÂÔ“«aíjIäVE"6^0 ÔjµDxA6ý*^°DÑ á]„Dp „U¼Ç 2#¯¡W :“WY4Z§JRñ¼Ñ`¤ZÎ Kf¯ºÉÆKz5/y$ZЮ15X%çE-¯"ÄÎKNI0òDà‰VÅë 65°ìFµÑñÞ‘—D‘þª@Ô•Y-?Û- A-éx½F­!ðŸY­Ó“,:Tj‘hÔD«–$IkP«¤AÍ ¢“—ÁjÔYƒVy³Söðf/ÑŸ°˜‚2ï„7è‰Jkâu:áÍô™IEo&¨¨ð*è³E§ÒÒß%f» IÐo51zEÁ¾xž¨$QÐÛDµÖ¥’šÜ~ú´Ä fÉHç›d´­$Ì‘-¢•4Á«³ÕªkUÑ댼IÅuô%‰¾¡O'ÖÈðú‚h::U*ÉÂ7j$“Jí²ój^4›4Õc|Œÿ棂M°ªˆZkx¨W©áÑyâ0K­^%ñ´wI‚Yk<}ÞÆ‹‚ÚVË‹ËEˆ¶PbQ©4zâ•EÚl&ڒĉ¡]ÂÂëµ*) RyµtP¨“†··ºEÉ! ôAÕ‹“WÕÚuš&•Ú¨Òñ´ÞEÚE›†­zAeU‰’¦†êÌ~¢¥]Gm55‚–§•A+œ £>M0k5­_¶ðf«(í‚V¥7Yªµ ¢@kALº0Ý’õjV«¬6-‘4¢Í¢¥¿¤,¼A§Ñ¨Õ*^c¡¿Lô"o¤o@Œð:•$™è D­¡olã„v '±éàáiµkkIÔÎ’NG/ /ÂI%Ñ¢µ^ÒŠ*­MP™$µl¤·×8T¼}[ršÝ’Fk4j%b2 *4ªÙ š¥:t¤FC¬ô´ô…\´Ï¹‰Yc"3íëj­šÔ‰„ŽGÑ.JnQ+‘Wkè@ ÃÄì¡ %&µdÑŠ‚Je€ dúüçUº¦Ò £¢Œª]C›F@kŠv3^%ÑéVÑž¬çµ‚h¡­"èbÆÙmvŠêZfßs¼ãPÝI×#çà¢Ü4WAÓ æ:³$Ss1gfËd¥º²óQ9½6‚êf9¨r.9/X1â3§ûf<‘ì^`³lìà,d09éäpa6“Ôíò/†ž8¸´à%ç‚ÿŠ‚(ùQ¾÷®6‹¥ôÃ/I¾Mk–]ÑýÐç“´ðÁ'B´pó‰¦GP¢äÏ€ Å_¯oÔ¿xoƒÝ¹÷yNµŠë-Î¥¸>à'DÄŠZÉ%ŒÐï,BÆ»½ ~O< Í,×=ùF¾+Œ„ùšp,VH¢«( ¡0_ ³Þ×ðŽ¬ö‘¯Þ§:ž¿üï½p3ò˜;K0‹¨êKÙj¼~Þs©Ò^zAV á¤w²Òmè/°r f­€Õí ÞIF0£&eb7À# Jr«ÄµÊrCɆ¤nïp¶’­Aü~(ÔRW²-y˳yÈ?“_ÔU¸.iµÛ”ç[•ž¥Âšm/扞V¦ÌvùÆ0BüPµ ;œû È¿qc¤¬›cœçáê,f05 -P¢Ñˆl1Ø í-/ðT'k»°N¯x¬üŽ2H¶E;$WäïC€çŠŸ§âa†Öõüá·Ñ/Ef{Âà…#³ÃÎgy®™ÎóäÜ<Ôï|ÉGËðw“ìðŽ¤—•²¼/{ÝWUù¼Œ»Z¢äÊ Ÿ™‚e_é̸«%U,I`áÕâbÏÕ?B•ž~Äæ1ÂÅC‘C@@`n" Ò#¥§é¡º–€rb™ÒÓô2(ñO™ê Ú.„›ãeõ¡0»L²­¼¬òóPBÉkçÔYÄÙrsin·‰ÛǽŽ¨=¡b! =\¨Ís¦h>³'‡®0+¨¢CÅÓsÛctc(ˆªècÉíGüÜx1ÇY@¦›œ 6]Å…¡¸GÃLÂQ°Å£ï‚Òo(æ&`og1ˆêÀý'L‘œ{dë+*»{lãæé½p`¨N`˜ ±T/qºÞ¡‰`pËyÍTrŸò}ƒ¨Ô[˜¥6ù¬˜ g-''%È„`q@’BˆÈYº}N‹ÊWv\ JJ,¡?8x»jü澑aië³GîÝv’¥O:Õ_÷ú+tÃÓ÷Þwïô°nàÊõÝ>‡ú±[.œ½å1’Q2ˆÉ?bé#[¥á‘¾›ÇU·ŸÜvïþrEkÄÕ\÷à)鶭üKa’Wž:|ùH8’ŒÐ¿ðÈå‡O]™¼ùÁ…ìVoòx«³¥ì©ëš]‘ÖÒ3S[oS0ÔQ”Þâši>Æ}’ƒ íILˆÃ…!ZnÄ:‡¬ô9T•‚Å\åÓ&«ƒ‹9%¿ )¸óÇ!`'Öw_c?ðz£¡]dZÒ:ß&Ì5“˜¥Ø8I[Ånk¨Û¶ÊFä¼ÑGËšwAu;-;"/NDÅËšZÆ/v) Ófe J&R!ÜJ1êˆT‡X6×.óFP[á•(S—³œ…ʲãñ™›o™ùæÌîÝ;o½yû··¯Ú?áývmKk½àÓÛÔ=a³ÛchüÞozáºÇ½üÿò~³¶%ì}Üëý¶7¼º”ðõ·f›Ùñ­™›oÛ¹{7½õÊÝ¿Ó[7 ÛîQÛô>¡¡5ìý–·ö1ïR ݨõ<æ ÑB^ßÊBe,Œ¨¥«_Á ³1 dT›ˆḂ4"\Þè<½bÉ_]½E T×+ÌŸÜCïãIÛëŸ ¤oýìÜÙ–÷¿ðæ3çqñô»½æ×I[î¡Á³sãCõß9óÌ›DÍl 7йшØÉ~n’ƒ0ŒÀøÌ[êâqÌŒkDbC± `œ aYp^ô¬^ ®Á(rÄ™n@:»œÁƒQr("Tìò›Ÿ„’r@v¨ÏŽõ_c(#QÊ_÷ŒÍÏþˆÿzé-{Öž½kà&³ÀÐÒuþ÷ž»xŽ|¶¡™<\º®¹—8¢äå®ç¶s¹“Üܹܽ»¹B7ÔçôûñbnŠ÷Fsws×Ç Ãh:9Üô?ÍeßÈ.æÎÄòÑQq:K_áø èõÛºek¡ÿ¾ûÁË É¯¨Ó‡æŽŸ8ƒQØw[t'€Í=ò‚1píM,6»à»ú0CÍ1Ž9☄ án¡ Ær¢¢¹ìÊ(¡;Z‚ÎE\ðQÓ4)+T·ÊÅâ8!vSÍ;q¯Éì'Ú@) GÈ•j¸2å•éÎERôND}pÛéÇfFµÆ[o5jGg;½í Zj‰ì¸ÿÑÓ3Õ¢IÔ\ÃL²Å˜­—oI"罂TŸ5ZdÓÒÔ5Z@}pæô£÷íÜûXGhóáý[Ù×=±­ûou°/òc-UM¢g~–?—]âægý¦-Á$QÁþï°·óë³Kÿ•çŸžx(¹½Á¨Ý´IklØž|h¢ïDhËöÄC“]D&÷hÔK É^º¾t½½)`ÉPóža‘tuN~(¹}jû·O·6õÅáƒÿÅéx_S+|,Öð¢h=³>>“)m½n¾Wßd×D=‚… òä°ÝRú|†<ù€Àbv˜ŒÔ€¨Éi®Ÿ{çÖ.”D}Å\ùUÚ‘'$³mPmæ1T Ÿ`•‡{­ž èe<¦`Åéѧ/GvÄØÜK'å|ÔÇ’ƒ]ô»¨qÛi· öÓžf–sÆt.¼tX’WÈ®˜ ’òc™ Vtà ËÛa/yÒ;<íÑ~†ª MKçÂ=TŠ¢gûKYÚÞA"„²•sü|x® Ófè٘ѳ‘pp¦¬èMHäíbVÙÄ9N|ç´t»t;7ÄÝÄTPƒ±NTz°0ÔªL%_ˉW­èÄèÒ0X,Y¢‡%.:a2± õÎK¦M„62’òÐIæ%Qé„ì‡\\ÎÛÐÚbÍ™è  ëÏÄg†-C˜¿j¿|>¹ª¼ø£g>q™nÀbÔ-=»åª¹Ç&ÍжÌö¡¥?ó4ÖQÑõcºA‹AWºjèúm»ø±ÃŸ8uæð…__'¼óÌ?\·ô¬Î`Ðñ—Ož;6qá×CÛ3Û†ø±š`¯¶t=7¨#ؽízz·ƒ÷ŸúÄaAsCuŽ ëâ’Üw˜+Ø!ʪ¢¬d¤÷q#‰kü2ùк8crZõ‰©Ø1ˆ~!ä} â‰³à÷z °¢A¼î†\s.Âbs1ô'^Q¡ ã/D:H`ÌzYzÙ°»Ô@wy{‘öÚÚc²v]éë:Í,PŽŠì·ÄâeŠÕ'ÑRaoég´“^€€»eèw!kêÒ·Î^F²>J—o9@h%§·Zï«Ž²­’-c c¼ÓE}Ëœãȼ^æïŒ*8M¿u}õþ ò¿KlgÊŒsTM\kS‘éÕ€‡®Fvç•6p'”\@o1§†ÅMÀ®ÑFå@ØÓÜ´¿˜s1-‚Î@,ž…ÅâìTSÞ µ·L墦ò|[’îh F ìØÆÈó值2ÌNùû·ñ§¯ÞgáuUä‘ê ±Kmw²¨¼“Õ_f+Té¼q­MZofÄÄü5WGgô n?­³ÛI=WØ õ¶9϶Z`–Ž±. )ÚÁT®"Œ4*D_QÌiqÒ¿5šŽç®+}&V½æ«ÑAR½†_ÞPZÄ…N$›v¡çt ¶ C=Ì@ŒMa,ƒh‡#ÚÈ‚*3FKFâàáˆÇrVK®Z A“`úó@ ^m£ù;édØ hêú†„ŒÉùàf:åe¬¯ˆZ³ÃßÒÇè»ötbCOüC–åE<’Hc<,—Î_1Ge~Qeuè¡­ÍZ™ÚÈBEhãbÁÕOÆþ MqÒ3|*Ù¨ 8TIWäÎFδT2ž Ú}@¥þ]»†9:<­swvÔ\Þ»éðè¶1r×±ÒY•˜îJ×EŽy4]M6Ë:Ë™¼<ÞõÖ¹ø}s'JT{á5­ä «i¹³ToWw"òr|{"Òær×ööÅÓ3b3)wÿ3MKŸØÝ^çÍhzt#-VÂ'ŸÜ}ƒas|z¿êæ»J'jy6l›ßþÏE“µÒŪ6+½­:ÆÆLgî+¹Ó\a :ÔþbáÊô§Õ S ¸ Äç-ô¶X˜æÜÂ"f¶óG€} —6H,k‘sƒéܸõ%¿½cl „EPmìs5 ]Þilh#¤…¾-@ùœoŒ?‹·¡ JÙå\Múb  |f¼Å.付$ ir”ãüôDÂ%S,Æ¥ð¼AÖPȯÐH—ÃÞ‚À°šT˜õû›ŒÉJ²÷~€ˆ±SÃ×êô&É°ÝKî¾õúÑ‘ááïŽím^r{]õ„ðW™ëÍR =2Ø·)3>ÙÝÚx„<¥nqu6oœÞ4}Ûõ[?˜6kxËؤä /eﲚ‚Ó·õ[kÿ‘ž}}½»7Œ Ú;¼5ö+–ZêƒÍm|ãæ &ÝÜäpÖzúF·oªk %¯½2Õèè´:\a‹Ac2žàVåˆÜ@Ì˳ÿa´>n‰æFèâ:^,X<ë‘+í}ÑÜÕ’Wh¾p3D¢_‰ØW߹Š­/–Û[,ìE¾„½“T!:ÅÂv£çCŸ+æú:L¹¡ÅünÕor;sC–…þ¡>[da?á3·Ó²°kçn[¤@?«RËÁ<’Îõ§siî•Á¡Ý}ý;w•CyÉËôHÕL2k†Hª'ø½òçÜÞ±õ‡¡{ìµæ·íÕf •­ƦOÜGÇå‚sÓfT[€º®š†RFô-ì ±”ÚåP±Nãt¸lU„u”Ö­Ì$”Š»œ)W¥Ó@y§Í¹Üƒ0² ¬o¸a5IØÞ¦ n¬íOœnܹí}õ=õ„ïÏôÓŸ˜TíÝ{Žîê‰tÊMTs4«DÉÖ9lâ·'n¶ªÄöÐ&•YИT³'¸yüøÕ=ê¦þ§EvßÚ¬YîNÒÃDT "áM­ÖmºÑRý´ô³Û§úüQ¯ÕßäíéÝôñ-ßÙ7â^Ø©Œ|Ш®1½ÊìQ‡õ¶Ò™?¿z¢c]oÚçOÜ4ý4™|ÕÝ$ðÇ¥«ä70ÙbˆÛÂ]Î]ËÝÅ=Ì=C5ÓrnW~ä:¿{£ùñÛhW ó3÷Ä *<¿ïÁ8‹ç=$õüñ§9o^ÉÈû:c1%,J1øôéYŸN¥ºü®#tûd1Ÿ}¾-ù›è±3O0Ãù'ß w²B<šü-ûäÿrùÃZ}߆¬«© € knóÜÿ\©yû<Æ£WX$×ú¸ùïœù®ö§TŒ3ÄE{K1$è† ¯mˆjøtH¹”ï!¿lTç/ŸªµJ*k·õkVëÛoÃ÷ÌÁúúƒô߯ô÷…þ» ìÿ8i>îSv>Ð WÑ‹ºá*ë×$#>xðY¼æ+_¹ ì—¾—-½¤ìR]%£Ø\ÜÕT&¹W¹Â:è×ãFj€¼?ˆÙ! ŽNÄA%éaxß=ˆ÷mÙi*šS¿P‰j„JTƒ«*Émú2CÀíº–n $(B#P&@·!¦\o(æ6°µœbãÕJOç·Ð«F†èä×Ò á¥èVS¦¼è::å oØ ’Ow« .²Î® }$‚ƒp<õ•Å:6Lb0À‚Ôñ“ª¢ ëж y$*ß™ ‡Qk3~Í6T;ôˆœ'¨±™ü†€6]ú‘B¿É¦Y$ÙOµ®Í"ˆÀ¯EOd4ÝÎhm#½…g‘á(›]&­@²Ã?B­ÉE¾E8z¹±äD ö·Âϱ™ûFÏP-;ƒkZ-‹¡/Õú-<ƒfz¦%²ØM%®XFÚ!ÞºuÃFš÷Š ³ÔvöÆP߶D[7š…m@jlØ’¨œÑ«ÔœÅåonwU'¶1œyX#Àn•Hñ`=.`bJ8SÁƒ)%ÞdAå òUß¹öxŸMÛnŸ¸å‹Goú§‡Ž½|×¾Èôd½†7ð*9þŸxñþã›MšfWwlp§û,~³TÉeCw»ï² ùPúþ·Î^ÿõ;{gï¸wäè'|ŸºSå²ì}âûÏÝóGÿ¶k pjOCløú›ºJÖßGn¯ªß îfÌ,Ý„9üëÐ`¤$ëN¢ís30(’j £Ì Ï%] bŠVñ(ðI…#Æ›ú@þœ·KNCt.aÍÛSP½ëì²õÙÕìH¤Ö_ìð—ëÔJ«”¯T)®ÆïZ¥ey)²Ã¥msëé§ëo{yîèKwìl™4:D¤’cßzþ#ÏŸ™ë‡út&»vÔ¬‘_Y¡Qߺ»ñOB=$ôOÛŸ¾eSzö¶ _õqŸ¤3µÉ.Ûàî³ß}öý/ü|Wã©] ]ë®›ÙØU:xøc/²|9Eàvp‡è9uêÄlÝ´ÎîÁ„¹6V³'±f;©Ó’ßI+ò²"˜*æ.³€øœ;ŽËÜu´v§eëË Î€/Þ’†ñ~ÙNÚ¡ý#1»þˆ¼PŒFIzd+íµŒ#Ïhý ÉÞøá«ŽCîõå@gpîÄ5×®Q÷˜ÿ+0:Ï©O¡xÊߨ (þ)q%ÀåªW+(­hŸR´§"ÅTÍJ’T­Z‘lo öß27îí 7´µ5´Çfv—~½ãÉ#ï?àtò-š¾)¶u&b×ó­º&£[«=µµeËƶ‘Lrk`¸/9 ÿ‘Ídé_µ „"cmõ††£ëº¶&"ím-ÁŽMý[â™Ìé]—Ý&Ô¹Ûb†xÝngÇhÀÌ“u¹ÞÙ`™Ød Žò0°sïÉxÿ–'~9?ŸAÿªÈùh[N!†ã87KµíŸsÐhtο"š;Ï,æ·]‹^sôÁÃt ?hÉŠÃAäY>Nì§zwʯ¦ëʼnâBׄ™jHÈ; lÂ’×à\³×.H,.ôÕîÒ`Æd­Z¹C±Ü\1we¬0wî¼ícÝÙÝCÜ»ñ† }™Æ¦±‘éìÔÞ™[o˜™í?µþx_'q`ÐÝÙuu:yÞÔÔs™ð|Ç‘#ÛþÚôU½÷Þ±-äï[Êøþ÷Oüð‡e.?u¶bcëçv-ã´CXyÞâB ²b•¹sàb °”»,täúÂhëåòý)ÙúRMƒÏnYsPÚ覟wÁÂàèè‹ÕóvO›ÍՊˇ?A½N¿¡ŸÙ¹³bÙóô“çZ'ï<{çd+ûšžl5òY’Í^ŸÑ>w>É^(ÎsðYú¹}jêöGعzºÙ^:7;K¹2.¾È ãcårzf7EΈ+S0”øƒ°êK >Íè3=Ûò½hå v/søVÝ«ëOë‚^(þ‹6*Jd=@tÊ Wl˜þœ\–n#gãð.„­NìfV†Ã0_!’Á»±§A˜}å¶A|2ðmfùLõ½8}Õ½’+µªŸd±ú}mAŽ«Â·2sN®ŽëUriéü`Dbf/ӈ꫺ 0øÐÚVË:NÃ¥5`pÂ|éz$>/eŽŸ5Ú–VgE‹ÙóÕ:‹¶ƒEl²F®–ãV¶¿¢öW¶¤mUcüaUÃ’ÇW´ a¿Aêwî/+n«ôSž÷wì/Âêþ²Œì¡mbEOdÿôEóýJm;]¢«žïã1Ä·¹;¥T{¹ìT@T›Ä˜,³Ý–&sgÒnŒ¿qCúÈÆt„ýÌLJ‹ë.?¸©tß~ݺÈ@·‹W÷@dn_é¯ñ ž®à¯µF»º¢­·ýC¨óÂ?Ó¦OL=0¼å‘xé|F­k²Z›ê¢êÌ/jZgý*GeŽœžö¬w=F9o±ÐŒ>ìf?]! `'ײ§K˜Cï0îEÂ< ãtpÄ€ÖÁÏ80! Ýl(>E,· (Þ´bf7YÎrv„ÝaÚ:²;X-Qâwt'=€2¤%ùÃÄÙÎo;l#›_æ !›x{ë†#CŸþvé•­;‡v8ôâ—6_qÅæMžïþñ‚Ÿþ™Ò_]­&šûuf‹zÓë7}í­[xíèÁÏ­¿¿â$(¡Qï¿òZ¸¤ôõÒO¾y룧unÍZ^wùQZþÛô² Ã(1P„ ¿ãPý«ô=î:Ž³%ED–\ ×I‡ Û%ÅÕgH A`ÊjpˆQ!™Z¯‚¸H …µZ§¾^¨ê,²NVÙy“‰ì7…M¼C´ˆÁ+Ôê=V]®½“pð>on>¤Ü¥#ïpw®u}騗?g¤ÛúZzTCÏ:xZŽþ˜‰·«è -º ½¹Þ©ÕBÙðÅEï|‡‹Ð_€ß9ÑÜLN4u'#„þØÅ×Óg­ðE°Ø1?òPIî2ŽN‡²>Æ82‘è©â¼ÝÄ&Z lÚd“­ƒ$:=õ¶DOf—j‡ ‰ÂÓ åj¼¾ÖŽX÷àðæ²nˆ æV‡EÍÂëÊ*uù›¨ê ²uw 'å3ܪ’ÀWFN‰·ú-ðö½Û‡²È t ?IŸ}úcØ-m±+Uµ±õ•ýZÙ‰SÕ¥²/à z«ô¹—Kçÿ¡®îïI²‘SøµÔ5ù@xz²ÿúFr§§ÝTë)Ý-M $¤MV·¬Ñ•ºòf{ÍùÛܼäµá+‰Þ\^»Ð¿¶ƒ»ËÍDó­ƒhÿ\c¬{=Mb¹MÑ\)Gëb ãÔÆÑõÍ0¾¶6o·,ã®Þ\Ìmaðæ¸ß\±…î>1Ø€Œv:´Uzhí7¡â}! ³k¨žÕ„¢qªK4Wâm:ü«¨EŒ.€ò¼û±žðìD‚çXȆÜÌòÀï.ã'†gKÜ%öjq11±X¾.N$Ë…ñüÚ{™{‘Îý[¸=Üí\aÆäT±0:RÂ褌n"õhÞÑ„áÃ…$þs =šŽ-d@óÕ"Œí´þ÷FsýoäÖsë”ìt BñvÆ€¦!¿®QÕrëå…æ¶É)ôB)9 ¢Íxar,* †ªrL䈑U»(61š?Ÿ.ú » ‚Ôº¤´sï_ü 1žû”ŸØŒzC×îÞÑ›#j‡¨—­zÑ¡ŽÜtßM¸k•q÷æÑÞÝ]½ÑF 'êð”Ðÿ䷟ĽÖ6þE‰…È÷M?þãxÉhÓutlî×5©dYÕ¤ëß\½ÝÑ¡³-ýÔÇØÔTŒÕë—^=úä“’ê ;ȳ VK¥Ó—âÞÇA€~[‘1 Aš¯’çÙƒæ0/â»* L1"¤‰å’$$‹‚E½aÇžK;pPtƒ1€]Ü5@²˜¤‡RžÓ®P¨W„ájpµ'¢0øIOX¤]ÊafQcå03ˆöáÑ[¾¸ëdF{l)Ës$Rúî¬ÄzêŸÍT’™ /aožïVa6ÛÇg!þ§„fØOE†g1Îíçár Èç°/Jzaß$þØI»áF&±\V•¤¾›VÃL±°{:íîIZh†-)TŒ9@ë&Á1ßûnùIô†£ýpE™ =wÆÌÄàœ”Z{溈ì“_Ör†XbdFY8ÐÜb#¯®&N rò”ÿÀDÊŽÁ ®x7ÂÁÔhâ›*&BÄ—4îyô•/¾òèž#í}ýbÔín7uاLÛ;†ŒínwTìïk?’Õµè²ÆŸ³ô{tìÚ3œ¹vŒÌÚŒ±Cã6íDÂ(,úôuëÖ]÷éCO]×5qCÌÛÝ\[Ûœ¨sÕtÄÚ‰¶XG«.Ǻ½±&º®{êÊ-ú6ýG}ô£ôkË•oßÒÞ¾åöˆÇæ›H@ãtÄY‡q¬{h¯Ý‰Ú…¶X°b~ŽÕ©´V¤TÚ¿XB‰cJk§ç†º¡ BÉ(S<´@Ç¥ó ± Š-R|Æ—q¥iŸ,Çë-ãN¯âjIøx¥YìHó6£ÁPú’Öf”fWö¾=OÇ7g‚â6ã"vÐ?ÝåÛa{%¯m™c¹“€é‹ÑÛà‡B*?äÄt°PÑn„±ëRÔH/Ɔ6C ^1× G, ´¿K¢ï¬Aˆ~ ´ÍY¬y½d—?€$X8rëA÷{÷0p±±a\•,g:A~ðFÿ8ú6\>w¶åîç•qžÓ’YúzärÕt_ÿ “ßý£T½ñuÒöÇ ž›løν6Nö˜´¥y--m0˜¬ë¶4o[]'Y¥NÀ†Ï6›*AîÐ –ë†ªà’·‚ëç-ÏW ²CXT/‡jZ½êFαnš@„ØϘLëÈŠØSFë{¨#gßrŠ{90´‘vK×QUÕÀûÓÞðIÝ%ëè£&kiƒéø3AõÒâeþB,½in77Ëý„+˜!ʳ9IÔ©bn7¬œ Yœ€õœ+Ã@ÖÆNºxZò­„E˜­Æ?`ÉÅá£:ˆc?¼¦ÍÅüAZ{ÛÀB¡1ѪÚ)/¨´H’?°W¶¾l–½Ží»`¿«•ÊÉžºÁu£˜£¬§í ç2€Ql®¾pcn·Ë¯p²¿µ«w³AÁ$×ڵŽÁ ’Öí—\žQ3Ñ ‡ªŽ c„Á¾Œ¨/E2À0ª”Ã!e®Ú†bÍr?èˆ.óÏZ•¤}sïÑQgïú“ó'7¤Ý§ÉúÓî¹³¾žéßÄÑ üë#DÔiFö6ë•ä¯áQRxî½óì û̉ÑoØLŸ<9=pØþÁ†£G3gçöԵ’ÔZ·¨–÷FojÔ­kH´ÚÌûn8{çè-<ðq–©ÜõÍ2Ž5´5øÈ_ä Ðù3˜¦ÓŠžÃIÄ]¢J¶…×úúÄ‘Íš]fr*ãu¢0Zp†`ñrz™Ä=Í}–{+rÏý‚["FRGÚÉf<¯fÒ­d]Ë~[’üÀ;C·‘ÿ›ûäÿçׯÞz$tŸ'1ɲì’=ŸÍ*úéïðºðÿw%—?«  ö"Ôó9Gû`¹ 1¾÷Í¥ÿKe/¯ÇÄX#n®‹ÎÃ[¹+èLô~îSÜKÜW¹ïr?å~Y•¡qÉñá¨X?~ב"ý¶òLý qÇÊ|ª:H*Zùî퀫@':‡‘̽ú:•èõ—ý½{]võæÚe[¿]„aPô‰Î±-÷U1‹‡}æKgø?kžÿlÍÎ.g’±í ™µJ—ÞC‡“0äü ¢ïãqÿ¢°ü@œæÚX®9š¯©g±©hî`Ô´V€l•o2ÎÂr3t1Û pœ]‰Ëf°æBgr?zNÂÖ|fò.ôõ±ˆÄnŒŸífѳ+„Á³9‹¬Ý÷ôzGe0«b„$+ƒ€ön9ºÖcûš-ãÈZœ¼ËQµYÏÇHö&ÍŸ«yæô#/QMƒ¬ÏÁòYÙ$ìô&‚T¦Éлy”1@ïW°åZýç]É…®<Þ·ú.¸yá»eGŸ´B¿è£òé&î.ˆ½Í«2´µ©dÚ£m’òD½chCLÛؼJÛ¨+æºc jôתŠ?æòÕ1b€L1p5i"LÁ¬ã(h"zz=µ½›&ò*ܶJ[ñQñ–ÌÎ3meþÂìÚU‹ˆ,BÖw %æµÈûVê6 >‚˜åzµå(V ? 5cð# ¤ÖÏâÈiZAÉÇ€.ïN)n>IDk~Úñz8áÍ£QÎi0K*‘—ÉTÜ—É>žá¸K]Î.•‘¨L ŽIZBAp^r1ëóÍ.Îg2ó($‘æÌ92K$!¥7Kóç2¥ŽÁ‰Y(²8ëóÑÊÖh|‹¾sdÞ§ZÆ×|_¦4O÷}dþ=«a¾ãŒ’C"s5T“`¾c#jTíá‹a¶yl¦nL(³ApæòF}?u:Ï×Ðw–T2¦ôØRþ”ߥ–]2…Î*fÿòg|äœOXôe@ž¡ªáÆ“YààÌf}Î-ÒÿÞ|†dJ‹Éq’]‘7ç6`´n ðn‚×-‚In¢t›c|+bù"úÛÜ_?3¹'× Ñj./†~yUš1†ÇàÖJ L˜åÙ~”ØvuÌë¨ËÐ7oé:‹lü¯z¯Mø^ì¥èÛuRý:®¼Z¤X~/Út4Z`ZE+@ÂŽsZ F§F/ñfè<©¼TŲüzk¼Éà«°'--²×[\ùn¼‹[£4}·vnRø?bœj-g]Î-Ñ2H–ÆiZë`»ŽüΣ‹ét¥›Èý:ºáÑ•:Èkæã8Îön*ÝÄJ`ɵc7ÒçúÛòsu'RZÔ˜J`žëâƒF¹ŸÞ ï ÷.uÀ]á¹Ö8ü8ݹŸ>&{à|V¥Ì‡ÙØ›ä>$ÆÅ™Ês)¿Žµ¢ÅGà×:8yé×]ãðßV?¥®üì@yºÆáòs}–>× åvÄZÑV% Aøá'/ùºk濨má àÁÖ8Œs6í_ü ØŽõP/a © \`²Ì›ˆ æøJ8é{êf—êOð{´ßð3«OBšÊï ð{Ýï½û<~ÉA¸Ibãô‡:œä8úé;ïÆHÏœ.¿Þ{ëdæR ¿×Nïö{V„­Ñƪ~ÏŠ¼‚±ô[[°]ªýXLg1P¢X‡\§à9¶À,§ä^tVÁ„Øì po!4ÖxeÆ¥²[Ï^ö¶EqK¯ •)³-óùɯϷt®ÂTÄXŠˆo9!¯y뀦6SÿtðA¶A,Ç›ëÑ{纹‚Ö;x4Û6(,Ð8ÊÞó:ã”I› Fþ¸c¥‘ðR¤8œN剙WeæÇá /?.„ ãã‡÷8g™·XæggÁÅMŽò_¼´Ìº„>ò >ŸáSˆåÒÄ?cä/nlg.yg1¿—vÒ@d5¨M§sSòB}º_Ö|ʱ+cã´‹9¹D{^Ÿl}IäµF«] #Ã1ækW|9”Ì$;DL$èÌQíQ5"µ³“JZ±zb‡X³¦ªíûjã'ž;þø³>}ì¹ãñÚû‚gÿÒÙýSÙç¸oÎ?x.sð±{·½°íÞÇf¸±åc>³áÉÈÌ»¶¸áƒ?RÙ$oýâ™m»ßwÕ–í߶©«Þ·këü¿}ëöÉ“ý­ÊÖ2xxÝm¾Ý÷Œ·›Líã÷ì¾ù‡^ïxa~zûèèö•Õë—ö¨\ÁŠÌv8¹hѲ¶½‚†É¦p¾F¥Û„*¯mf ™^™Ïµ~Æó×"çš«¢ˆáµdˆ`%œñô~’ÙšŸ;Öyº•í ‹,»T ¨=',ÂYs ŸÞÇy,ƒE¸2¾˜ú}¯:*‡Žq·p…Zx³nÌÆoÒZÝ´h\X†pcðlm•W 0=ÊÄôíÙ–o«ÇÅÂÃé\èp¸|¦›ö3{=¶´aÑÍuÊtÅ^õòŒ,ÄD°0|;¹ªlv$Š‡ð1ä{$*¥V|ûO/vïuš;Jß<6ržVC–pmŒ œÂƒŠõIŠ™ð~7 Z“çÃû<¥X—«l¾«Ã×4Ø[úHrìô_¾äØ|¥â.¶rÜ)" ¥ÔT8U•y¬– p=t´>ª XëЌގ‹ÆPû>dV…ê\W%ÕU2†¡‡±Q9˜ÄFoÞ_G‡Îâš1  W^hkgÆÃAëKZ¹FŒÆóP;-§æìÆ0b,5È *ƒãbòÞRÏûyKï3‘2§DFŽzºÌ§I=A ßò:±jÒºêÓ¿ â/>}ý.]øŧ?†‹CZSãqG5î3/œqk:c5šæ¿*ýùK¶p¬?×]µ|ŸçX†J‘Þ€ÞfúСiO%ê¾åÃ&¿fVìµêù£ËõÜ…ËòÿP=÷Ä•z†:»ªë¹ë¹ s5×–„S!9o§3e¾õß¡¾é´Ì @ÜÉ¢Äé÷ïVßP¿ÍššX§RçQ·§†üêwªï8­à[ÜQK¹Ê5š(ßµV}‡ÐgôÀr}QO¥:SwÄÏX¥¾{ªêؽ1T˜*̱ô]®uŒõnшÖ:¬0Iz ª±¢‚PÑF;Š=‘è{ª`kÈ—Î eù¦é=ÖkÐÃL–è§â¥yoÕ¹ô ª˜äXwãe¿‹¢ï‹Úl!_í2Eß7ųL«,%}e³ôHÍ·£X‡Lï\Çj dùuTW{Ikò'zú&/_&*}s0:¨T Gß³pÆPPïÞƒ/¥ S&] m¯ Ù×I[éõ×ûÑc‹¯Ÿ°š­¦¬ÉÊPÊ›Â"¾¦RAm两´»ôz6KWÆM& ¾¤TŽ¹âG1s6ªoì·…ÛÇánàîâäžàžç¸+ºøþòëòñxÎUÌ÷}šö¸ÖèžëîÿT“ LA 3Çïy ÜVÝÑ…É+ïø?·áò›~ÛX÷üÜÊt켯ި;0h¯d¦€Œ[òÓúHnW1·Ë’߯ÉÜ!Kþ(ݺ¶˜»Ö’ݺ­˜»Í’ÏÒ­3ÅÜKþƒtëq:±Är[ò/Ð{}<–û“bîÙXá…?‘ó…'©Úö'–¼ÌL!/­ÎB^h³QÕ”6•|‰mÚ’ô2ºM/ª>îªÚ¶ýwã>}²UåÆ“ª,„Hþ†~R9õ7Ù¬eÖçð· gèÆ…ye?û;|d÷*ï øcðSÈ.)÷_ñUb_<ûz«úÔ»î¼e±”æ•£ e_©¢òÞi ÍÅBçfh¿N ¤‹ú0@ðÁb²’³  Ü[PM/§akYº¦ˆgt«µ©ùŒ„Hʹ yÁßéÅU¼Õšoîa{8%[ ™àôo¡Û“Ûv2ßØràju(] 3²Ëèv.F Á !µYdv˜`Ì3{¹œ¦¤ÎÐQ¨ÃÀ­ºá»>ôܦ“_>ŒßúªSÛÐÐЩðÄîõÞÌú“½W•~y¹Ùj±ø²¿|5uÅ¡TÊÛ–¾ù³/Þ¿mèð >ûχÁ²½òyŒuñ?äÞ ‡øØ‘à`ÊvÒ Y¬öÀ’²Jâû&½ww¯Vc{ø:s³»ÖäÜÏÝçëJÝÅ o«ëŒçæ¸ë¹Ï`+ì ­°£º&Š #) ê7'±96±æ¸áÒͱ1èv1²GÚ(ï«j”]ò+Ð(Ã'Ž¯h˜ ànÌÌìÚ½—Q¼¼~ß•sÇO\ {'­¹£H¿°yüšëqþo¶V*©R'ñ“ÉÂ.\’T…’TVÐÒ¦“œt–ý=›°¸ðÒ7þîÅϼN²¶«^:n³·vÝüÙýˆÝ&õc¶O[ ÍéòÅÿüÅûÛý¿wÓΚ-W¾y­ú«šKßïMjU¯Êûÿô}íçTZÁ«ªQÛTzQno=ýÚ> úÙ¨Ž…þ’&®žc¬¿€zß5.ï†è_+Òe®é1‘VE®íAáYMBöîþ”c•xF:´¿ó¸zFü>WzmϤ–$ 1S…% !åk=ß%²SrºdWi¨4D¿œÒÎÒ‡…Pì7tRúøpý3±”zù‹––Rz“:å+}¢dð7~þsC³Ÿü'9¸ô‹†È¡áèÛ ]?f8<ædpœ“ö¹`7&•¹à¹Øô újÕ.qFK­Õ¬Ö-eå°¤sÖ.-:ùÚ¶°ŽÏªm¦Ûy.ÀK'Ÿ©ð(g‘_=Iµ§s…Œ2¦×Ä ‘nhéHö€NLTÁPö^ÔÒÃrŒ×@ÇàÉŒS ?VèˆÃÙä3y?ã+Væ]ªCf&P¸ò-q:ˆÝét®QΙé´Ú &8à@‹rÎ¥à÷-‡ úSt Á0“ãek½ƒM©˜8‡ÁãZâ·ùårÔŽ0ó+ÚáµÚ_WEò\˜ÇhÚà3KŸmçg„ùJxϯµZZüW>»"äG˜µ.=E gùŧär2ĉW8Å+bô\¡vÆQ‰"   ãˆê;ý¨ïzÌ}5Ç ý5Mw21ˆ2Ä€¨ ÌDcÅܘ%ïÖG\Û’ß$ ·‚ÁžëÀITε¤s^kÁj ƒ˜Ð0èõ °HÓE*£Í¯¿w`0³^±Ôý딧îÔŠ$ªéKɪÀl"uDIé,kü*ÉD[[âäüÉD[÷áÔº‰Ö¬ìòçFÏdgpgmÃì߈_™Ä·pïI€ÅŸn—ÌžÙÝÜÚ¿¥úà›w#áÁ1;t3ÞB܈_ÊìÆÌ/¾`=ÕJ»¹aªSãnâîáþ˜+$ )öÀ’¿¡&e¡˜»; 2º'š“iÃœF‡*KgHUL€î»˜»’Átn/æ?@k=Õ@kS«–=ªÆ@[´óÐiC¸œ#˜v6~¥l}ejËž¹ã§n¾Õ1]‚ªcm½}#£ãÛ¡ÄÝ-Þ˜Ú;žÛhqƒÓÕpäèñSes}EQ]/\j…ZÈÔÙ¯¸ì•”ÑTÉ«h Ú€5ɇB$å\ CªŠ9«îÐrVýn¤,Ï؉ȔÃñï¥g$D^bµ¥Üö“ZÂá¸z‡Ó zò„Õk¥{þȵÛjiÁÒ¿Ñ‚dZ¡8*ä1Vd~ùJ}>Uõƒ¤€øù›»¨”w¬Ä E¡0½Ý[z»6ÑÅŒÃAúý:V†K~`-ý[-aå‰íßô9wÞˆ÷"[®ª¢C+nòþ,ÿgé¤xα²+ôBßéB’X,DðZÀA0͵¿‘s#e…5¶àën×T`ߺE ¤ÑØi#\d³!/•.u~L³¦KŸiyêBì=Å"Îä¿ÕÒ‡$Í<éœ~öîm ¡ m¡–Tå-³ãØeë"F«Áø±Ð£–ü¾Qo$ºÁ£OÌtèë¯uº¶»å†f[ûÌãÚÞhk¦Î½×¢¹ã‘rùf×æa=¨ç:¸\Á«à‹ÛbàF3aTE€Ž™(f¿6ÄÀ;Šlúek´‘‚d«¤Ãêb@“¢°P°°ÎŠŸ1¾,—Ù."¡È «ÙƃA¬w°Š“((HV ›[b±eAq/F’-2 ú.éG½‹ã uð.dï«ä6ÜjÀ×° Ç‹9áÆšDù›aŸ Ð{à©B«ó i†8Üfâ%!xªá«ŸQÂG_âØ œƒ/ø ÏE»—T’ŽsÜ:C![f®&þFg rÄl蹑ÑNÒ(«è–íL‰´­o—ÊH¬Ðš†Ún ÐÚ‹åÒ„¬ˆ2šŒ1B§Ag0:êêaÚÏȹ@:¯­f0k— á®4*’ñdÜ&’~„Îwñ~G@°Å€D·I Šå¾B(†C…, ¡ ”ýêçï'öy‡Fûƒ„Üñ§}õ=SC÷µ:óSü¿%¦öN%úZâ&ç1Oó̱kîëß=‘~vçRIŸ'byá'bPkÐZòBé—¥ï=¡UkpØkÞæÿ2372Ô1èv…ôµû›ëÖÝt¨ç@_o¤ß?ýÍZ/kk r¸„»i®­uZ€½Q¤ù[§Tcu=@OaU:¼¢JG±JA[æ7B•b n*ïsuõ­]€Îšë¶BŒÑlhm¿Ç*•Ö¬Rá½Wé[+«túÄ5÷:¼Y„…w­ÑW.®Ðác#½£!ZŸí¬> Ç©ï’ 'ÎEõœ‚¥Ê}Œ+l„_»<Ê|Wq¡­ ”ù~úãÇpàî,vbÈÎ}Z`È[ôà·\Ð;-˜Q¹0ŽtÀøc9'³× B,I~bC|É6C¥¤A']Šë}ë'zXÎéDÚH NíÙ÷ÿ2÷`nU×ÚðÙ§¨ë赑4uM•<ªÓGã)öØc{Ü»=î °± ¦ÙŒ 5@(!$BI2 % ¥Ç¹¹—$ä&ᦓv/Ísüïµ4ž’û|ßóüxŽNÙGÚ}¯µöZï ÷:ÄÂð Ü®X@] ­Ú,¿¨êvQ)æiš›ÉÚ`#H)’‰21-Í €õÛÐò4Ù%>gLÀ6Té=ŽÑ]fNlǼaï•Ë‡/ Ö—uæ~‹5Y9ƒMöÖæá†%kW/ªlê _æCvcàèÎXç2œð’ÅˮįÅÂÃOèÃz3¢i–ºø‹­i/MOû­e‹á·®‹Þå#ҭᾦÁºE«×.innµ754KÓhR_d¡­¢Xú½‰*Ë—^Âbê=Ihœt9V£HkU×G¼V×P&‹q”ŠŽ´¤ÃWŽçB~ܨñJÐ)¸¶â@ÍjÐã&39ðYc3¶ ¬tjM U”25S>ªUε¶ŠPC¨üÒ üX|Dòã¼H¢ï§?U§î ²¦ ê§ ¾Þ/(o¿@«Ú@I¨}V=ÿ™ò¬ó¸œz܉æüŒ¦Ž¿ðÂqŽX¯2c]í®£,ÑŽ•wéÉ|ª ´œ)ÅÇË„´q¢aE«'ÎLñF5ÚA诈ÌßݪÒìVøO‹R¢§`š¤¢Õ2·•ÐäMÆùpæ•ò,pÔÁé²…dÒßR…Ñâ~úAuÕ ÿJÅ:´ªñf †‹%ƒòÑŽg3#›.yöâµxø2îÂÏ,Ûêq…ßþX é‚÷ñë.üþèñä‘äEkÕܧàTôGÕ'éŽm;öB%_¹¾ŒO@¼ŽÖÀ€é‘ÕHÄ€ òYt=ÕMÒ§ÚÕ!²Ú3¸Lƒ¤™ŽOø"Ä4€Ü‡•i5\§wË-¤“Ç$¤¼eK/=zhÔcÔ‚R+ž¸áº%ƒ.­F£u .¹î†'”mÝ󾘧GËþjÌ{°ÌµƒPÙ›°À;¾˜lMâ±ÒK°äYãqîU­«„XÒ9u_Ý2‰žñ3À´¤ºT—ÈÚ?䫬4Ož%§ï(„gD*Ì$HJn˜›½©£à|ø.>bñÝQ"®Ƙ)ç¸iRC#àv9¢‡Rï·E–R)+|D ýü9™Wbßx꣆¨;(p4h%üqsÅZ‘Xœfá1Q+äý ÌáBÅ ëè‚x>u&ßT34¥tM46œXJ*3U Z?€ÿ:S+ ‚æÌ^T0‹­°œ¢”¥8¨êÀö B”MÞ),†²ÔÞÅž‡ðci]…+.GEÛo;¹M¸Ó€’MW¼UM¢‰“[zvµTm8¾G1ÞˆÆÖ¤3á,£äŒü9jïGT‰÷ð_û¾9VV¬Ìh½ ,qOÂiðÍïé—ê¡fý5F‰AZ½ Œ z-¡%ãvGþÀY"o2¾ÝOx÷ÆÛçùuA-ú¡êñJS¡s>bó SMT-ò^ÅahȬ`j œìTAßTfÙr#(r6"¨y``4ZNeTÊʨ|V)gèuƒ€®~-Coýhqñ~+Í+£Z½É˜3sË•ÿRþÈhx}Nd¿A,è{h”§­û?‡l~G¹olxD¹Q0¼Îê ÉŠª–#}N¦Ÿšô£(Í÷‰-ìÓª´wÊ`”d;lðÙâÑšLæi\(GöÈ2¡}ÍKBÁH˜… ŠAÆõ\×}{HŽø<%äÑ8‡Óæmã“·ó²·ŽÍ™ˆoÞý·«iBÞ4ž7yý8UDzpÆŸ¢Õ6…ÉÈÓ M³Ì€°äEZÆ/g¢xtáO?óêÇØ³Û íõ¶G•bÑìq·<ñªR|UùÏW™gќŃƒ_Ù2Á1¹ŸÿìæÙ³s¨iþ½>ªxɉ°J¶2ýåvp¥ ^ñ}y ÔR7ʤ¢z|ˆ¡[á·Ëè9%o—e¥„’2>IÉJÛûÞCpW}Š’8úFÛt¾ªiy­šÌ« ¤5¯Uï—×FB¨ °PéÈÖdý̼¢F5¯ÀO«Y@Iœí™ý£úä•rRR¢’Rº0¯qjf‚ï‚KÝw€íTé™uKò«¯TðÅê¶ñ‚úºhå¢?NEžRÀ‹æ× š³¦æ×v>¿¶ÊovKízRÉä÷‚JƒŒ_ОR;ÃŒŽSÉoŽ` ±xÔ~† zcõKŽç%‚(d#º/©R%`èVèx÷»[ÉH¤b|žç œî>o®ûùwCðYüDÄO<¡ñæ„1 g–ÆLp̋˜$Úñ¥ Ž 5F³f‘ðåL¢YNcÂõc³Ç¦ü‡0 :ú.ìF~à Ê\2–ýQ–øòÄ×>§·Ú_~Éü´ífÑŽÄÄuú¯›y„½jâ÷¿N§oW~¿m¡}§Ÿ=Çt.§ù±Iì4Ÿ¼& ˆ6ú`¥’8kÆeâÄ&§ñ¿ï&e7àr¸„f=.!_)¡IG†*pÕÀÔ6pâG'ÚÔ‹ûþ»w«E§³£^²êX³aý!år%¥\~h½žguV&GnòX¶®=l¥o"öªO®€Àí+Ÿ"7&®¶^»U­X4:i×Ñúõw>þøëõ´Ž›UVAj| ‘'G¨¢¿ls&ð¢À…6`³€"&:g©è$R±³ŒsÎIã%ÜÅŒ% ¸˜ëu ÙXQE¡+c§ðìR¶Rb½•D{NE}õ•U(WÎÁÕB¿^aj¸k”ÊòγPUPXe¼ìqy¡$D>ÝqÞ—Lu©OÆaG¤ì£”WÔ ß½p X ›*Ðrd¿Iõç+Ï~ B6c1&'Àô':«¼5`$Zß  }< `á1[mžjŸ?®­3ý2W þ£»/#D|ô¿æKæ:ïõTlm®³?úç¾d_:ïKE?¬|í—ðºb‡wO¨ûx4®I¦ÂÝ× ñ~O#A +XCXÉ8º¤úè HESµ£ºR™0x&ìFøŸ\·ÔÿY| ©÷9©œ]ô ú£ó¼ƒÉ÷å4ºZÁ§Ò:kÕÏæ)æLäý³‡ó¦k/v:•óøï¨~j‰°ô— ¾õLõŽv– 8”á×®*¢àÝaîÖPŠ€|÷@œ¿½.F¦±™Ž_•‰(jñÿ ÏOшPµvVRosC¡hD;3[õ>ͼfD’yÔlEfå‹¿å­’ùU´îûZrÏ`¤¹í…ß)¿|€×¦³.‘·¿b–ñµÌXSþ-škFV3¢ð-í÷•G_5K=ÿªù]a;‡ ó ùÄ]–O ~ÑCƯ Y¡Õ Ÿ˜ð´Îè ì…òI˜˜ÔÊò.ÚLÑ/áÑBû ³Æï›9˜þ–uz”“æI('Kr˜Œ—̹´æÛÜ·HÄeœrQ¤…3ƒñYÂ3c5¸²ŽŠë´‡6š™œTÏ¡§3aæ¶ðžðá–}'[Ž„Ãg¯ÀGàâð{2Ú-e$z7–ŠNà“‰kéÔ1ñºmO˜¹5Œß9¹¯å0Nö`¿ƒ/ŽœJAZx'oãwšè奉—fpÁÖ€gžaé»0ÂÒÿþ¡ýSp‘g†ñ«ˆgG/ Ü/o¿LÆ pçÇpÛ4ƤÐd®.Œ$µ­Æ}Ö¶^‰{aÐäÌ]œßÉÎÜè´`P‰gˆAâì8Ö }çS=q’¨ •ÜyÇb‡Æ%aÞåŽR\ 5ö+97Y6ɲŠç$Íð6õBÆ58ã¼…d<íZ YÄR…êç£ÕP ØËÕ™Nꔯ•Dî‹]¸/º%©vpÖl’Õ2n¤GÃá4j·+£¸ËƒÉϹQœÀÕn¢@›¥KEML¦<äÆSQ¡`im87fžäF>¿ÍVfÛÉÂbî%Ñ[!jt¼6äVÆqV”q—ˆ³¢ŒóÆ“föO²ÌŸýä<Ÿ‚³‚Fk"azÔ8ÎOïo¡r³‘9š#>YeðOQ€  OŠ\´¿ÍP6P”©îße½½¬i4ýT‰iïr|û’¨JN¢êS¹ù¬33N œâ>Ss:µÖ«9…>X~Ô’ÍYˆ± ײ£*ì‹^”¬+ì×ÓŽtÖ¡ ¦³âÑ„ëY²årMFÈGû”×'^IÝŸj‰ñ" Šf^T~&¢mÈ·Îã¹ß3ì™Z•´áÉl¤§ù¼ÒófH_³'¾ßã™É]w¾M‚êh«ŸÒ&^u´5\´M¨²‚]ÞÛP‡šVSƒ¦5 r‘¡íwIn“9q)> ¹¹kâ÷Ó‹fÒ&8•Ì‰õèuW$ZWÓLËkšê%yµ–ŠV3ôfkµŠ:ͪÈÊ“ U( ‚˜wï@Tu ª¿(©¡Z€( 4v¶é«F5 ðÜôVyÜ`ÑjìLãîØgn¯5™\2Áé¤7Z{èk7ljñO_?zú&FïD›¥â'Áa §Æ³òø•Œvo¹fÛ¹ÀH0[½`ï]3EzõÖS*zˆPîq©Òå lتa±hhY<¥X[õd€ö3 ²:]ïiË"¹&ô±ÚwД2Š¨sÔmŸýíEÔÄ6ÞDfÚÚÓDuÌX}bÎóñÊ<߉Ç#CcÖ]LÞ ÏœñU¥®e™è Ö q·[ÉÕƒÿgeñEÿ—eïåLÙ›5:£]¦ºÔ"*8%“Ó IÊ _ŸÞv’HUpµ˜¿ãòŒšÔš2 õ†x¾ƒ¸"&<+ ¦þZ@ª#ä)›âN6ä°7ØZ[ð§gÒ“0’´ d(°áƒÁ€¸ér@Å¡p‰5õÜ?7Û Ó<ž*5ø¦6 ¢ø‹dólšé…"lîE›^߾Ψ×0 ŒÝ̲k•»†?òú‘€5O'çVœ ƒ¾m1è'-•Ã³¾}T ÕxlË™Í&&ȘŒk–n *ÿ^y¤{£Y¦éËÍrë,‰ßÏK?@”§1?l6³1,ÃУûL&~¿+Üg2Yö-WÜ°Ç"šÓjù‡M6|Æh8|‡FÜÏäóuz×i7p¥t–u­x¢Èv¯Î¸ûÆóM€OV†0ƒZÍ{‚…¸(†Å8±*Ä!nš‹OZâê&UK B” ³â¸3UËꎋÝýËÏCœºú×t¯ •‘ZiO%4lS(ÄÊÖ$[¦yÓF¨öo}åÙzZ·Co6¸ú‘¦å;Q3çßEŸøGHïêã%ß ³ŒŽÊæxéOþü°®ÊpÔˆh=ç mú‰Äß`–•O“÷>B¤AD¥ÎQÌ4µ×ÄrKàõ˜Õ[fµƱì ‰üR¶T(ðøzQ©°" ä•kͯk©T4vÎÝY^ÌÏmÍ/’ Í-P'Æ•¸N–¬m¶êS¬7•çÀ|O/õPOÝ°!é˜å QàyÀDc:ðÛœTj½,é²Pk¬êXôMÄÜUq/ƒÀëÔ­`ÑÓ— ‡_ë §2Ѧ…ñÙu±*ñ¥‡dóM¼Ôº§·CÒˆ¦Å: ofÙ®•õ¯ëÃócñtËH¶?ìúúÓYž}íp_'>y“¦ô—nÅ"O"Pç° RÐÝX×Ú>¯îÖïyO™e‰ÏkþzA#Yï¶ ÆÀHÁjÇŠ>WcÔ”±,tõ¬J|ìg®§yI6?­olJ:5¶óýôî§]X¶)¶B?ÕÇó18I½ ØbèŽÃFèyûE&ë¯8›E*þu­¡Ù“V@iíª ˆbZ6ï;þI»²œìL>ÔúÃ@ T5âwqñIøüŒãGŸ}…xƒÎö¢ W¾3®§×5Ë+–Hüv^º\6ß©ðiçRòq×)kQy@$Úûª^%AÅb=ÁÖ_[ö HÆóµÉ|[)ïK@ó&|Ûž „æ3°;\_Ê×$ŠõÍÄ7 hñl®‡«æ¾Ê$ˆQ¡ü ÍU Â!Û](+“s;‰)sœZ•ˆ”É:Kû+ƒ’Õé Ò×dÃOä°¡Nûí+¢A¯S¾þ2R~Žê§l~ rŠ|êçnXIYYé\%¢Ge'¾$›wòÒrÙ¼ƒ—”/@å¢y¿Ã,/—øf™ª`ýýYT u U¬#XHñ|Lùnâ‰XE&§æD–ÂäÔÏ7ž)p–^JWs"Q 7jLž ÃpÚ¨ú$‚µ0MòÁÿœ*´ÀŒ“Ó¤§ùäŒ4‰´>µ¶&‡P6ùÁ2ôKüë“ÐîoLL|Cy ½Cö¸µ²ùqÃó¿Pn÷±c»•qDòÒ•žÛ¯à¥(GþqåÔ˜HôÎu߸bž ’"|˨õÔ&ju½*–±rÆŸ¹¬¯ÁòõÛ;aÛ“-=³5µdé†[8mÔÆŸÙ–\¼ldÓf <åKc§¿?)òZ¨ ¸I<¡îd{ã…}ênÃ×´Ѩۛ‚/8 ïäWŒ?×ù›5ê>˲Ÿ_7Î6ßáóãÏ}­¯òd?éÅO6Ó]ø·ÞTÔ¯Ú#äã….Ó;ùºqñ' É cr´À1ïÆœŽød0æßÀ']ÂX}WN$Ç9vÂ1?"Œõôâ“a¬`>Áß¹ ò=‹á{Æ–o['Œ-]·L½¿¼rg=¹ƒßÝ@ÞÅ߶‘|ÛfalËæ]j¶Bƶ‘œàûÛáþs_K¾¹—È8¶.Çv’›åbá­KÈ[—‘» >Š8©ïVß­A îd­ù­EœfÊK[©œ 8u]½C+Öí¸tç®=—Äfü‡rœÆ"8œþ@]}2ÕÙÕÛ×?0´`ñ’¥Ë–¯X·~ÃFÜÆ[¶nÛ¾ãÒË.öúý{ÔTaá «wŸÑÉÀT&¿<íÓ®e&§PíäC¦Q,Æ‚O°ÐèHfÙnu¤2i9›Œýä†ÕNnHüÓþ; ×_ºš3„[\Ü´c“ÖyÄ©ÝŒ.]Ϲn ní^Hò‘À|üøQ­óa§öÓßEúä÷ðغÂ÷Ëàoæ#„ÿê¶àVÞðÿz1¾\HŸwbàA«,f“S¹ítªG“Ù¢|FõW!ljûNz'>òz§ôçÑÑs”ò#„å,¡†ÑQrýc¸À·AÖn9G±¿%1 s©uÔçT?„BmC’ø¦EŠÄOQq`©M€“é|‚‹»Ø ‹²Í™ÀÓ”ÙiÌ"Nþz¡¬KäS¥¢Ô4ˆSäSˆ\q¬E& l¶è:„û+6šÖB} «‹Ùù$±NÌ÷cÑb` öµæç‹E] ²‡IʯÕ,~&#Ab¿‰l:iˀ練Á P¬ÖL¢¶ ˆà {¢Kƒe6  ¦võKÆ-5{:Ac0íýQÎÿÀ’Ú]³³S#ÝwÅA³6¹ðàÑ% ×? Í•‘A×ékî‰5{eo㜎U‰E:®=0»±=’ªB‰Á†í3It7B5}"tö-ú¿ÏjkÚ7ÍþÂçÄms.ˆÛÙsÔ9ôÄp&ÁˆyB-¡*“†~ Ã:ÞQóø“~‡AƒP…o¦QÀ¢­ ¦«@¦eŒ<ˆŽp´Ô2¾–ZÚ§$°”G÷ó<á;¸÷`C‹ýú7žWvòvÕÆTù^?Ai‡Ö‡}PñÂKSšÈŠúRQO„j= ÖºA¢~I¥BÚU"–²B]+>7– óðy•pÜì^hB#H‰T…bZÎgØlÓÿäú¢%E£ÿÄÅêí¬XMùñ‹œ!ßùêÂÒN××a‚i_GÍ¡–à¶QȦÿñmïNƒsK)ß"€³›+ž÷õ˜§&…å,ÏÏ-焦¹Zu‹ Ïš£dÖ$GDî(êtHÁñ>^´¾¯žœk’ ˜lÊ,ÌVr„ëõSö6ì“ÌÈïÃ\.±§ {q¶‹†€ŠÃáÊCÀ¬òÃÛmv­]«! t †¢€Îq!‰ì|Ý »áÔF#¡*çÎæ>¿äÒëµFUvÅã~‹ɲÄð:ÙîÏZ˜˜(Z¢ú¶Ü¡!qöÇW.¸6èŠäΣŒEp‡ÉW>@__¦éý¹•~©#\mì°Ê¶šDm‡×j hœV~ÿÂݾ¡Î–ÎÖð¾þ!ºÆíj@(<‰í#¸ÖP³(ðµ5±(¥Sž_®7ËÔzÓUêMœ±ßã(÷,ÂUõ•ÖÎà¦%Z¨+²YB;H|3‘m4ü‹¨LçïSiWðÚ+?>[ ݈‡cÔ"Š1Æ’E—/TþÀêxF’¬HoñÇc.Ùê1jõz—äïkÞé¬ !â„©VÝh¹Ö”*úzWëì.w =Ô¿/ÜŠkgÈ×عjá~ÞêÔ„kDœÞŽÚDM¶v4FëÃ’en?MCµQ¦){hõT‚ꦖRÛ¨K©£Ô-ÔCÔ Ô×ЋTÑQ&ŽŸš5tÙuÏ‚‰mN©pìI¬ÑÏ&ògOŸ‰ç¿TÊßÏ'óJÅžyÀ’Û@¬Ø¥üÞxi¶–Š«îø¡ð üì‰RþK‰üBáËøâs‰ü§Kù">ª™*.õÝ¥üÝñÂKxl…íÅ$† ¹Y`kí³_¯XèÆw–µã;xB,ìÙ.JÅЪM`që:|÷ØMøìªãxBo;Á·¿ q϶æ?-æ?fŽaü`áü½Ÿ ƒ£8ÁM_ÂßV-Ü3í1yká!ÀEnïºë£uçU2s_™ÊúkÄïÓâ‰@¦‘ eÂvnK¦å 6*‹IQu0~‡x Ëeÿ¬wGI`¯Í‘N2Z§¶‘p!|A¼‹miœ§Ã©ÊoÙð× .@0‘Ó)‚rR‚6+~˜Ê¤p&ÊÈPÑH6™N¦yjý»ÕÐÓp ¹¥¡Ç`• ³nVþ¨üéæF|µä·Ãó$O4Î[3?™î›oµ÷öFÃ~½fŸÍl®¶Ùª›“n[o.×ßë Õ™´ZS]Ð/ˆÕÕ¢Ðñ­Þ^@\A½Ç¬ÕÛݶN ꣓;ª¶Íž={š£D~YCg±p Ëò…¥ípÞÞ¸Ò40 ¬FÓï:Ö9vd¿ùMTûâ‹ï=…Êßœ´¥9•Ô6yµUG"îŽcðQÝvçÇS©''œèOŸ¬­·¥ïNÙêëBs…æ‡úqXr7Õ¢ýÊojÚ‰„³Ë¯owG"ž¶¡ž¤ ™lF}5o—j#îÇÉ$x!byà7DÚ<®×âq}ˆºz‚z=_F Ù„­%OéT"½nä.ÐNïç.åò/Ú¯Ää³ñüçJùËÉÖè%Iˆo½9žNâ”_žAOWÓz g@ ùZ5 ÐkáF¡Ýq>ETÝ< “ÚHilvk·ŽÀ2· À+Ÿ_W[¹.ƒo •òë„ÂU@Ç^{UeðÖïÁÇA4N‚¡Fbž<#NµÔiÕøj`|F°"\H´ãá·@|æÀ¿ö*<wÜ Ãúö­xÔm-¿b°µxh>-îz Ÿ‡?Žoµ^†}î³ø3µF®_ÌÜ^W¶%׳kÏcðGoÆ¿WW{üC ­ ÑëU(<2n}d Ô4¶>2†e,ðˆÉ´_NºQ’ÁC,29N/qSG(`€lr2=mT§ƒ²ˆSÀbàƒfx#H¾«áñ:mFp»øUíÏÐo|±mµÙ…ÏÛ¾8á"ç{wmÝ£|ct÷œ¾íWoåãá't¦Ø¬ÌêÕ^·Ä ÕõDzûÃO¸¿7âY³bņÕM³2¢^/f «WÛѨ#¶1’Û»vm:3ëž®ŽöÏ I ½K3±1w´·/êY½±¿?Ø>¬µZµÃíûþ ç›MƒÏÑM|nÝÀ<qÎÊåÊ_‘eÞ­;Þ=Úì wfП•ÕÛº„^òôp8™ ?½Dº~Ðßÿî¹YÙ¬{ðåAWKæ§ßDMöÞö2_B·*ñÓötX1g»Âγ¯. 'Ón·¾Ùœ4„úWîXß´Èë닇QîZî(™ŠÊUVND'÷ 4°¯ΠÊV¦­²qk±&ú¤É¨w¼YëzÔð–;ò&ú‡D£ªè_íz£qâ/hØh0Ø߬w¢½#ÜM,–&å?%e^ì)sG“E°]ƒ&>f-MÓýh‚T–j¤Šµ07˜H‹ Ëš&¸¶€VKܵ¸ÏJ¡øEý·eˆ¨ÍÊ)ˆù#^u6F¶#»ê±Ò(£>™:ŸÿJ'<[#ýˆ­æ‹’N«;ü’=Šgõ}QÒêôÊYô1N+>ͼ[Ì!4‚~0šÄCʧùÝ´âšÌô¢(˜LÁÉýU-˜±ÁS7D« d¡)T9ÄÒ8 Uº2]“ÌKù¸2Äb8[Óý³i‹EØ=çç̱ŸÏÙ#ðº|}öHùúˆ_°X±òíõ*TMÀOûÆ/y¬gp«®ªJ·u°ç±K¦_ŒH:ʉóD”³JR„ªðVjƹ[qKi‰§] 塈׳ñLÑîô€4ePê –‹^#§(íÈÚþg‹jÓ¢^“CKp§þ¬bG¿G+‰»­@­¼ß@èÏh‰âPž@+Ñï”ÏÓ1dQ¾«üŠY‡º•_)ß›ØuÉòÐÑʯG.Qþ§Gôm¨Yù«òUæªV¾ªüT3ð¹!¸T‚¥9 R¡Š¦²I©ŠŒd839K+Æó$”|9ýq̓ۆ)åºA`j%üÄQÀÁÂòQõ “™<¥í‚(ľI1öMT%8—äØ7+OmV¸cµÁS‡ÎíŽóOý>¸ãóÃÓ`ÎAò”FdêgQú‚‰wV¹=à•˜×Š„€‚*ØDðñqãù;(2ØÃHŠ~ü§µù£Ùt7§Uÿù“³²öjæäUè½{ƒ¯Ñ/Nôòô¸ybw”~2:ñƒô¦ÊO£;®óÞwõ}çè×'Nл'zƒ¸>Š>Š˜='Ðõw?s7:¦ÜŒþÅŠ‰g–3×Ä×yÎu,ƒ?p7u}Å+®&ëqU<JæSea¼;Tw§IuèTTÚÀ¸'^'Ä}.KBPÀÓ)P¡ûÅbͬnXºÜR¾ ×E¬î@”€´§ÄB¤ñbSĤ“{4w¬©Sx9 †ˆ¢ zj¸×\ŽÊ?¸˜½rñÁƒ‹ß»uñÁ'ƒ.¶©*t“uôµc/+¿µ~N=}zô(º¿¶úóÕµäÐþ…ƒ×¸‚A}swß‘_‡,ã}Ýú·Ÿ~úí§;!écžº:Ï´ùÏ{lK¥Æ\ pB÷&§Ä¨þŶÉp¢êŠ6 fÀÆMó”®Ë_w]}‘|Lsø~î”ÿQÓüO”DÙpa¨@žìqhªÀÚH4q™“bªw¬œÌúIĸg:ÅîØ°“6ìÜ ¤¿‰eÓ™q¸‰“'é1¥ %”ï”ý̇¹ë¹Oá±ÜA cízøZ¦‰d·=žß„s²3žßr¦° 2S›Æ"Žå¢üvñ™=R×´tÙ6蛤‚—XäÄ.K !Žˆk£H+Íl4ÆÈÝ«%^¤±À0|—ÁBÑ€Á+×!Ž§±n‚'h<ãv,zx‘Í®‰F˜ê@KÈ{øt-ª{°C@×r®±ÁVyàí»-63§¥õA›ëQô :ûºM#è,æÆЊﾼ#6gIÎZñ®ËvüúµîôºjëÜÆfågÊŸb¹×Ø{Ö­½ÆÈ¿²¹{þO$4˜Õ]‘Ž²¯¸š¼^‹1&…WƆ¬]ŽÇ§7åDÜûLÕuî”>ñkŸ:û° ¿÷^M EïÚÖ;hgD5Ž°G=A½¶Ú£Ó«ÝA½.Þ¬5&^;ªÓÝ¿nÏþFÏÕ­KDÉÔéò‰`üžìŸ1,É/§F¨]Àë¹,ž_D8Pæbá{w<¿âL~s)¿Y€ezåPG7‹Òéή¡õÛ¶CèÅB¨°š,Ãcxèb~å`Ð`°îÇBKfp-®v€w"íÊD¢x=ÔÊ`DÂK¤š0£e•B0ýá#ME¦Ç°:{Hƒtɼk 1§55ì,Ÿ^lØ÷oÊ_oˆ4$¯vYâ½3ðZ8#gù¤²óSÌ x_ù?”à­½ÑÆŸhŒôž ³Mwt«ŽïÆ t™fIhêbÞë»ý[!.e ‡­žµfkĆŒßIÛ³þn·)`±Îšèz e±;¶EîÙ-i£UìîÝú1Ù©å‚N[%Û\ÎjÕh«”}Í«¬5K̴̾îè.É‘ijˆÙU½…eLÌ µ™‚\™x;PI² N,Nzm925@|àu‰¢™€Ý˜ú†b€˜ôà¥ehP–2ª »pÃØ[ó&¶"ôRÈŸT&‹×›„pU¦/kÈðZ\¸6—‹F-ÿ.QîåÍÑDï¶-ÙµxaG›ÍÎêÍd,¼R¹î¯Ê•7‡ÂŽš¡¿ÍewU"™Éì¡ÝÔ ~Õu$fÝEX^j µNÓdH*Ùׇ-ý¨Ê«’Ä$¢„d+PBä› óE—·Žl û]jXs­˜¯¹X§Kª…*+ér±Ò¢? tÔ` ˜Þ‘:*Šõ ] {»Z¬Z‘ WŒHRþü¨±ººyVß´ùô+Ê% êCa«•7‡N·8Dw ŠžFÁ5­­õµw”£'ð0sØ8gÙNÈžLBžfX¡+6hFo-ó%Û³òˆÁÌ”‡Ì’Yâ$÷ž/"(£Ê1Wç(z‚?ÿ[¶3À¿ÅÛˆ-EXÊh˜å¨*Õe1hÌhü–~u“¿ËRáßPFY~@Ì°¯Ão壥˜ ò[ déÎcštXnÉSª:©OuúÃåÊAžåéÅ ãŸÞÌë¦gˆø¯"F3^ù-[…Oý-XŸ®Šºõ…©“¸Ò[ÈðŒ2`AyZ•~BýÕJw¹x¡Z¨H6ºR±®r5eçNu5„ÞŠÅW&´wZ+ñ‚,Xq?3¹£Í$¼DWƒÕJpuF,+ÆÐ ‰·¼@ÎÈG0 jµÁCƒ“2^¥V»j§Òj.ß÷ÔÜ];M›·Ï9´!•Zì¹uutÙõ£ÍkWôt.^œ¼ÿ¾{è'™ùóòˆA¨ÚÛÉ„ék~}÷]^o ÐÊõ&7\~Ý+îÇ_òùüœ†£uß%{êaMlçüùÝÉxc QÐ@ή¥AJÇ&@dÖ$@jÖ!(78qó @W ž5~‰aQ.ÒŸXAv>sÛÙ+˜ÛÜtÓÄô/èô†‰K'ô}gÿÌl§:|ö ‚Grý(w„2Qª“êÇu¾X„WºG]Ö‘<èð<§R"™°AHŒµF‚„n¬œÌ"tJ ¥|DeãZQ*¬Çm ŠÒ3RuÐ5{`Ø>’­eOÕBØQU08{ðj&Ø«jú†ˆ¨SUÞR±`S‚qPA'/È6$ª.¿зLŒ„¾ ¼þ¤ò'¿ ?íh¨ïh_Ññ×ÑKæhMfíÜ?Ú8Wk6içì=»ƒ9‘kšß±¢ãVH…æÅr?°ûºÓá³Û}hVG}Cy´}¾¾££^Y‚¯éá+^ÎÞ`ÖjLÇëë›4Zó Ù—¯˜˜M?0±=–û¼ñ+õ˜c¾_Wþwö ôù†ööò%¥§Œ¸=ÞÁÍò8º=ŒžB§Ñ è›èèM<…ÁCdŸ§ ¥ñüÒxE×Z55¤ö~ÈÆN’½ wg| ÈŒU*SÓÚA÷e@4‹ðøJ«±—¿˜¨ÂxpøëxNKTd"«AP ¼¯X¤QC¸ñ?ÖKÛ2XDÀïb‚ ÿð!îÚòÃ]ÈîHE»˜H ¶QPÔ®¦ ßD¾:SÞX¿™Í¤Òø¶Æa ÆðD‚ŸFpr/loe´(#a×@güÈ4¤ $7 ÐCéU‰K¢ˆÆÓj¥Ê¡RÚƒ.¥ÍBÁ™,FÔW±0”Ðj’‰4ü®#•M$±&£Q‹}H‡µ¥°ˆªÉຄB&2ÙT{‡Y]Ö ŠÊ „ðaàWˆ^§-íKôf‰6q, 0LÀz}йµÇÑÐÀHVÃÕ³úšŒ,žC$¯V¶G¬—ñ&–N G{Ò»C­ý–`¶dW[°ˆe4¸Ý™€ä–ôÖq“Þ«e,íÍ1gŸNÐÑœ^›,s#:M¬ª×Qäƒ>Û®Õ.üFQrZªÜBµ! màf]fµv?r°–f›®‰E;j$êZâ Ùm=ƒ³™H!fv•lѲ9Î[kÓ3º#=Ãj[g#ÔZci¬¡£UËv/ª±Þä@¼‹Ó9,FD‹È¤õ¼†1šM +³X•cY‹!“ [ô¬žæ8VÃhßá2»jôŒ¶ª{V_µæ3­ÒvÓVÓíñÈè ŒZ—Ƶ&rœÎ@Ç8d±2¢‹¦W›$#ÉhÖ0È2!ÖÍpŒQÔ!ôNÃhðS–£5:Ú‚Ìf «\!dYœZ§eXƠѢ©|­ §WS!,CæZ¬\A£e¤ ù*«FVM¢C,UCa!’j©©‚ßâôúÂu©LK®oÝ&"¬x¢x™ÔRNKÃÒÍ@¡óŠc®Á…ÕUzFƒ©L[ßò ìx;º˜n„'¢H”õk²>¬qóHA'ÂÁZÎ$IœŠÍâI\&Ó?S²5xÒÃÏÕÈšÈ 3†UÉ{n½6f%ÖæS¾©œ@<^f]uÝ­ãã_üýñëê7Ó´¹÷ÈÍÁ Üén8ÐÍœ ÷ìÛC?­’i=Z0Ðבnð ÌÝHoí¸zeÝÞ{í?¸ @7qÝ/W¯~pCoÆÂQs×zíÕÃ?~¬çog{"õWüÕÛ‚•w,`¯GŸý‘«?ÓaÓ>ª˜Óõî V_9šþm™ªr­ƒÊÙ7ߘÿ››;¦Ç”×P¨u X*:‚u†ûâ¸YŠZâf©e@£ÛH$A¿4(ÔÍxqÐ —â7UøW7k©XKTÁZ #ÁM;è©èA§Ù¡ÍA»™¤<°éÕû¬O£‰A˜Ež@0ÊÚ%•^„QüŠÐéT–xH'h7ÆÄQŒM§’ /£FÏ¡`{ ù‘£ŒÑËà5ú—Û¹`ðNÄ}i¯0\¾PÞƒ tÕ?žüÐÞÙѶU šwz=õ’宆¾ÚP£+޺祝¾Ñ½½‘y+:î^c÷ ÷$7×'ªI–zø—ÃÂÞ/)ïÝ9¸`ç1õqp¡ˆën\1˜XšitZ­ ¸ÄNÀ™kÊ®ŽÕtïì\ÛæCvÞZMúšš|•va‰~ÝN9 Ž¨½TakJ@ÅR!]I8ô°¬V(ì5(IÂûU°”!D45hVU.QšžŸ>‘Fzeÿ õ­íuWÕ×£Þ°ÆÓ¥÷ÐéôÄéÔGñáþjs#–î²Ô[®âù‰ˆheiɤì¢ñËøÒÊ[Êå/Ô×]]ÛÞV¯ìôèÙ:zƒŸMœNãçGëù«,–³t·Årþ†‰ˆÑ&tÿŒØå8ØMÐóÊáË É‹"ˆøpŸS•îI0 Û[û3â–g\G\ñy0N$íN}kÚUî|ªr’:ïs¨úVÆį½N˜©‡(P´`¯¨X=ê ±œ”(º‰áÃmà D ào> –ül °‚ îVËRé–VGL©˜ÛDU„6c‚6` ž¦LWVNØ+ä‘¢w ÑƒˆZj“Õ¿jzKqÏŽŒÍwEôo5ýª:YÛ‚NÞðÜ 7<‡^¯v¢Ñ={”QgumKZ~\Ùf‘\å/±Ù³cHˆ¸$ zð¸òdC ýxá†J¹Y(7àŠ¡ÀÖ(Jþkï~÷Þ+/««áµº ʯ\ùõw®Ýþ䟎݅˜µ™–/(ß:µó›çèÑ!Ç«‡5t]]ÍÂï¸÷Ý»“R _+}ûï×|y>~ìOOn¿ö2\£™/Œ?Ö¡|ž*ójÆËse¡ÊXiV"…ͪ,Õ‡‚Q…új\’ صfÎŒîÎ$Ë­\Ä¥!×ïßÆÔ9’ÎM¡¹`sç/"ï=À¼³@}Á¤*xþs'5#Ü85E¨bÚ¡1YôÁgO<ïN‚‘Æ–€y‹&B.f2à)Â’ò¤‰œÊsN¬TÌ‘9®Ÿ9àƨ ˆ¥k¢èi"h*/™óTá)âªb9Q:eJwõ`zÁƒ›ø”Ù!ÈÿTÁ¥ÓœÕIw‘À ± Åã3? t„[N"¡ÀÑH F°OUȧ`ʵjaU…¡Á³à$ˆÑñòFݯ@pÞq½þ99’’?Ç }NNEäÏ©Œ ½ß“e)#½ÂYs³7ÏMnlç-ÏX=NYfÄoµ½îBÏ= ÏÓ€UQ_T¿Fùw|ëÉCß—S²,¿Ì u>3zvÔšùïÚ)mýÕþ“ôèÏ?#E¡sç(¤=ÌΡ>D¬c7Åóž3€—xWñ$ôàê,Ü H‰ Ž]ÓMø‡°B‚½L"ÛŲb€1áð2VÂb{$6?²]¸à]´#œ¨ Õ$5´,#(Èi"X&c°í°j¶ ¨J‹1t1¬¥I&;Ç :kÊ"Tgj=fZ#é Ík5UfI´¥Ÿ[’¶ºy-õÈë¤@}W¸#Κ8¬¹Z ÈMh4ŽÏ9ëšÄ1{óN` VW9G9sV«w¸µÇÉœ²iYV ˜sâòõÎ*Cð’î`~iç42VVYÆhKìñTw¬jöpHjÛ9X;Ûl èi»ltÑÈĉ5þ¶Ôꈱ+¯ÑÓ¬«am×Ϋ †AøÍYô†Ü¾ôÖšºZ['ÎÄ k8KÄ[ÅrV“ɶ¢?®Cœ3Øß`©Òp2ÃÖõô:†Ú;N"͇˾ŸÕ¼ÅÍÇëi’ê¦æQË©=ÔQj ±2Övk,Žñìîx~5&£ñüÖ3ù¥Âõ¸%7‚·Õ6 ¦®Ö*›‡êj™½phMyAü‚Î8kë¶+¯…±÷0Ny]k~·Xàö©6_)› Áìï…$pEÄ“±”%¯W1”õ"'ÂÝ!„§B*f,BxÁ EŒOYÜôåsªB&®u(KLW¸gÀ]/­R]ã›ZMä¶Ñ'Ðêy=M¬†·h4·‰55Ño0µ®ë›w×W• å å?>vZ¡»¼þ¤rîî_(ÿjÇãßß½wcSÓî/õ-Æ’Q0°Ðö²èå½ZÞÌW£o›j<×þmåÊdTŸÈ¸tžPW×S+=çrv\¹¬JÖ58pI­«ºõ覈}âCóráM¸£ÑíÝ̼w—¶]¹¾;oØÙÕ{è™ðȽ¼ãOw«ÊŸÝ¸~»úôÖí#¡ú}î@`À»üƒ5<02º9ÎÈÌn‰k\ó7Lp»¤„{É©¾þ´¤ùŒ³Ž3‡7\Û‚g¢{Ä̹¦ìsï§ô”Œ5è»^²nGÂ^ZU*ÔàÖæÀ#ÖК·Š3L_Uy@dF)”­´6š.nB<7!ÑÎJ6A¡G¡±‰WO£;n}1|ñÖ'_~ Ž¡Ðã§_ <úÏx÷YeÓ–Ÿ(W­|û®»Þ^¹5£ßxÏ(Ï?¯üö'[ÐÃ*w Å]£¡pïÄ2ûnB°¶9ž_[Ê뱇ò—6C>W*\ (x]Ì/År­B]—¯ßAs+^ˆð"ËÓ1&Úû­8çàœ«A™tŒËd½,O[@]ã$“ˆF=e@ÉÓPÚ€KþjØš»aÕæKýû¿qÓþKkŸÓ·qÉŠ\“fàèæI¿cM:÷œ–I^Úâ4VI§Åª8ϬÚx}í\¸|ÙP»(:çüáCï˜í[µaç– ‹:ñråáïÉoDªÐ_à%¹qÞ‘¥qkpáPã 'C3bu˼Q®kïîn¶× j¬ýóö]þᾪÁá5«–d,n­KëèN·ÕÐŽ…G—tz%<]0÷ܬu´Ç"tszø`§á½Uï•wTÈ_ʆeë?pà.PV,ÑD ®˜†Dš› 3—‡H[œP¤ÖÄÁ+¶èÒ*`@ÿÁæ!ÿmh2ÜÊÆž9°¸U9;ñæâì™÷êáïÀbfáâ?={ù!åïÈ|èçÔ¹sh.9ô.;thYïtÿ –®TPÎâà9[Œ{&±<Ȥ.e´Ä´2ØÈ]²¯ÂÄÀVayBóNI0]yÄB8‚;µÈÞeôÁˆg• µd…j5X¦†ü4^6£ˆVAÝz½2®çͲrÒ, $š"ˆ" •Ñ{à%Ù<.@ÝÔ>l±ÞO \ÀqßOð[üÕÿ뺩ŸZ7~±Påü놀™¸†©;›°gûAu£G9¨4B°^ÊA=\5[=ðTˆ¹\I¨ûܸøødÿTÅ' 7þ+ød•Âª›WQôþhkãn4.ZA³ŠJîý ÖΛI Ñ1¡ÜL?$ð“ZSiëNdŸÄblÕ*BÒ!æåöõãòUW‰Ò3о‚Ín!-ì®)ü™%ÙôOšô¢ÐÓÓþ.Ž1=­Át(é2nÂz¬ÇÛ¨ õ…²¼.‰)àEˆ‹z€8A¸qá²S(žì*WQK¶ÿÆ·~ABëý1>ŸXPïíì;„äGØwðåXÀ‘ÆÂpd¨‚=‹¡Sþ@8’© “ìZÜÞ ”FbAd£Bäu-e©çÁ©O "},ƒGƒ”÷•È¥T2Ñ…¢¢«Ñ„5†)*ûm~x“³Ž˜R€ÀìûŸ¯¹iŸ=òã+ôÛÛ”ï=ÿqå­ÑIZǯÈÌÞ°³/ŒWv èëµâ¯_i;G™…ZñM¥ÖfPî4ªïº!ó‹ŸUÞ9ö³#¯ŽýüA¤gO ®d÷†Ùý›´Ê/FGƒJë–ý£Ú ú™ß9Ý·d>^Û -±ä‚"`Ý‚w.âFGBQ@˜¢U"de3Ä5 ×™²ÜM6 ‰\U‹ãù¡3y[ bŒ©‚¯…y Z[ ž‹Èj¿ã±H-"ž;B*C(«>"áðOuÝ÷ã§USqÄ‘Ldýmx>yÔ€8Þ—MrþH92©¨Ön]Ц•Í¹ÑO\Æ®®¿^X}MSÓ5«…ëëß{ü²OŒâ%TÛö?ÕdÞúé›­ûÜåu×ꦑõëGb«\ÈÇòñÄ`}ã¬þàCÜžÅ}}‹ÓtÊ)ÒUN<—ÓÚK²1Ô˜´0vm.÷;«èæ"õ³œNˆeòè{1ÊšýU¶áœrÊ;ëÞYÞоòü \K¨…[Œ™*)c Ÿ?-skââÉåS *oü`‚;ª%n0ð=„´+–ÃL¶ñ¡´nYG|È’A™Œny{|%ýˆÍÞ±¼£ñ¡]:í]K×?Õ¢]÷³Ê·²jÚìǪm‹³ßõq—½c }É.”ÙÅxð“ôÃNGÇòLÓÉ]'ŽöÙÆOf5‹Ú›-å¥ÝâÎMþöÇm®ö™¦Çv? )2MŸJë‡;áUÔšÑ-ž¯|}jŸ!KE¨ªgŠW{ºà FלÊèŠ&*BUŽx'>Ó>`¯öEœ‰œÜ(QCª¯I4]æ!Ð$º¸lX%-Æ#mºxÕRËäj[jü—Ó›oŽ}%nª7t†ã§£Œ‡÷ÈN›Õæ”ñƒŒÁîlÝÙñÚ–i‘,Ybl?´Ú„úû}WûtÝíáEU¾ý.ZÖ‹zÇð‡LÞ±(P×ÖRñÉ"¸0…©Ôêrꪸ“DZx¦õñBd0 $ŒÜòýdÍU÷öàÊÙ[ÊïU¥4\G°l¶G¥œ™3™Y›ÇŒ4ŽlÝI$´à`Ù >Ä…:3°¬#P˜½`ù¦K+[‹lv,³­L„$;þÌà뾯a°|¡åL(™`*l§Æ¡’À2Ä[)bQ÷Àö&OÞÂíâFvPãÃ2DªÂ*pÇ_к ýåŽ;þ¢œRîUNýeÛÍ¿Ah êüÍÍ7ÿFyQù´òâo½hïK>º -}ådÜeÈÎcY“FÂ#°›³èÜìòûX½ÌËriþQ“¨a,¦á«>£ü¶|OëC¿ñ'Ĺ~úÛÚ5¿‡¾5ãGñý4ù©›§ý¼ýS'ÎÊÑAú¦“ÏïYœ59e·Åk q{vÉÑÏó9Šic8Ú_ HL’Ì#òEEÇä*wß»šþÄÄÕ®qýé'öÔ‡?ÿâ÷•‡'÷«I»K”›ê§Ê̾,Xƒ @>ñÁ+êe¬ŽÃKˆNe€ãUÔ|£ËÜ¢,w2• emÖfebXä"¡J³Ž¬ÎF¾‰Öÿô§ÊïPú÷HPþòkåö3ìeÈöêíቿßs}ýö·u=yýÎûßðrÃ7¾KZ £Où¯[¤\³é@9._ ó–ž²S³¨«ËÑäÕ¥¢?\päÒ]« BØHPOÜU›‰Ñ¶¦TôGNƒ@ÆÁöKù —åHØoo(j‰¼4‹XÓ \ÞPxžÂFiÅ àÓzd Nkª€rÈNùÒÕy4ÿã©{{”gÆGë<ï X¤Q£•íž:5ŸÃW£Ê¨ÊAåð4NMPSÿ"®\¥íô0‡Õb]c=žÔMÄ Á©ª…ï €:9ˆeßGøa}`¨n¥Ð'J§DÉî’ñØèwVÐ:±ë a`d–Æ,Ñú8ŽåqTÞò«Íª•Ë1„‘¬ «a&F2gOdòŒZ;;šXvÄnï$>™8ØТénk£ z˸Eo ÛÚzŒ+•1ô{‰î²§ìt—Ä>¥œQUÎ<Åü.¦C#)'u1r¡ïÜì(‹x#þG…Hÿ`ä»×îœxuœÖjO+/õ_Ùß%–‰/=7Ê݃ûˆŸòª»ˆ^B$[ˆN/^íµ:w« ó þ*^$9º˜,œá$#ƒ[®¡èKÛ }Ýþj}ø#k®ŠgÒ-mž\p¡áîïš»êræZå\^CY,{ÿ„¹ów÷”Vò|tKۇķ•F#ýb?zÕâÛ{n”ýÎÏ,jˆÚDÝK|–ø÷/…i•«á&ÛLÀ$”ÆšX°èB•òp8nŠn’—i ¢ëp¯ÒAo-lÁ…Ò-À…25®W£~Os†lÿœ¥Ð”«¤|MkÞ-Îñ›7eq»S:”€­_Š­…Ęe’x8SÙòBÚž_ô"˜TñôÊ€k2Öa÷ þ ÄCDž<#“;•Û|65{WÏ»‰¾[Ì~ï·çvýhúä-Çç5ô7çÖ¬Í5ÏQþpòøoÚBÏÅçoÙ–lÛ³6Ë[¢ÖV¡—üé{—fv[:W§Â‹«Ò®Ý¹úÅ®Øß["ÕõÔÕ6±_½wəٹUÝ·¯™{`N{.êï]¸vÉ5–Ž´_Ù²®½Nt¥6tUÍ Å1Ó,šæC-ë™Çc;v,IùÝ-;Úo<¼$êo/ûYiÇqû¤©.,­Ç+ßuÔqêÃè à&úñªÏo-·î…­ø­›ðt°3‘_Ï_“̯(å&Àäv²WÈ/Ÿ|ÁX%Èܶw©4SýP(TøkpÒZUʯ ûñÙ¡Rþ*e)å`/j?­DˆºnQáqîT5´NúŸ%ª˜6Æçuã\¡Jx‡Ï;ÇŸûëܯ>ؼ#V¨rêð=¾`ÞÉÇ©S:£ÉáTõ©ÓZ|ᬚB¹™kÆó[Kk~©8Æpmjë[´a3œî‹ ý ¡—’Š;vï°ôcGþ¿âÞ¾êÜž3£Ñ¾F›µZ»¼I¶$[–WyI¼ÄNb'N'NBv²“•$8$@ÃRv …@XÊv+É! Ô@)·ôŠÒÒÒÛ¾”BK¹¥-m^n!öä;ÏÙY€›Þ÷~ßïË2š9çÌht–ç<ëÿá OíNÝÕ7@—¹Ô+ðÌJwá–ó¸§U¾xswíµ$-¸á©âªîêCpÁpY¯Ä¬lþV[*{pßÅRg}”|²°Dï@øÌP€‘X ,)q\ É!2q#(i´Ô€»™ÔLR;ûñ$Nà ‹9™”-¤±OíXeH q ,@ÃÐÙêÉ@;Þl¡n.žÓò4xÄ®C Íõ½ë×÷ö¬GÂ+—£ŽÓólJ°‡öï¾÷Œð½=û±•u½ñªþHÓü•;6]ŽåÌ1^¾i>~Ž·æŸ_¾ Ñs6õõÕ¦úך‹U½ÏÑÏõªŠÍªåoÓo/GïªÐ­é¡tz¨ú@45¿©ŠþéâƒÉ{¥è­Žé5­¿{Ãe½Ý­Ú#u7­qy»þÏÜþùóûçþj·3à^YßV~`MÑü_½öl׌¾¾]ϾvJ<Mõ÷§jgÏž÷˜U½½*³Gµ|9º¦PÊl„¯LO¹ôêHGÓüo8É+·P]ÔRj u9’Ž¹ˆäèËçúÃÚè› Iåc`q^M"É–“¼Íq@qÀÜâeD ÛÓ6²0W‰¹k“ˆ2)¦d^†ÏVå3«ôýWà(Ïâ¢xó˜œg·cš×†YÈßHÂE;¸l7–Ú2Ë ¹¢zʬâFK Â$»Ô+¯)ƒÂÜh @¡cVfŸJˆ^ëÂûŸÉéæ v<7ª÷†á4b —Ô7­¼l ¦œe•U5¥Pçð*ù* Ì[šŒfI<æöRäï½²`ˆ·€ï‰G•ÊÀ¸ÇHep.)h Í"fI==5%ioÈ_¨äÏzî 3¹ÒÇññžGv;uæðÔ™Û¥¾òÎxCðð»s^GU±ÎΘ¿A÷;Ç,y÷[þT¼õ'º‰n\f’U]Ðî¸Ì¤•µÜ„ÐMiTGê~Rêt•–ºœ¥/2û®~ǯÂGúP QWä\öÈ%—<²Ìn×6‡â]•ëäHQ›Þ±¢³ÄSC+”ÂO%ë˺ž‡ÔÜk–Édñ¸L éÿ!Eô<ñ¹¥çé|K©ê8ÑùêˆÊBG¸uf<…Š£S®Oéâè5@ÂNy·†§˜6aÕ€Þ–‰ŠŽ€ÿÄÅ\ ²|¶ O@ (ÌL¡ŠSÙT&5îŠ eV*ÒJC&‚§B±Ž3Ëþü‚üNNªq2“ÞI­“±ê¶ü¤IØ@(‘aý h $†B§|•ÙÃyÄw¿0í[šCï˜H ÅÃÎSöΟHFïÒc†ç lrJòÅbIFCqT~ÇUB=N¹À'ʈæ³&OF2k BÖÆhÖ&ù¹³wh’´”&ŽÄbÊ*i>#Õgeøgб‚¥Û,¬-Ÿ±‰fo{¬0äœï"‘UAQ ‘eŽÀB%•V´©P`:RªðfM+À O“*Œqœ Ä9—xµUC„¥‡ƒëóÎ;ÿM8uÅè®<þƒ%òNáÚ$<ƒKîFÂ)ÚHÎuô)ä/ymžø}ªÿßN'Ž÷Ó§ÆûÑ]hóøggÏÏÏUæ ‚XþISÏŸ×2‚"Y—5Ö P ±¸Œd=R™'FÞ–s4§°¿pdâך6˜p,Ó˜Ï4ŠZqqB`IÊͶ‚ÍI§¿=•©áFEÅ`WÌ6ÖbSV#lv3d€/IeêðVb¨ˆK‹Q䬊¹œÙ­²uÁGîKª£$€æÔèaçñróßS  ËTÍyÚ£À›ÉƽÙìÞî¶gßt”V÷ôT—]úf¼uo&³×È[’ó÷L–ž§3ZXò:ÿR¿à‘‰Y8þýB 3³n‰ôm\¸pdˆRR%g²ùÜ—ÐVÁdNµ«(`öØšKztȤԻ»ÍšT£‰¶Uï»Ë(±m2„ÔJãBu¶’æ\[Ä>G¡¨p Ôƒ–,1ùC– .Å÷èÕóúA£P*ø™ŠgMrTɲ4#Aãßœ£vÚÊÜ5‘Z¶B…´F¦C2J.CR)dkBWOlLþ‚ihµï€sˆ§W?áO7çGË6/ÆÔ`–«¢˜ ËêßÊ8ó€÷Ee÷ÇšÌfîD¢fhÕX°eË0[¸ ïlû¸l\LðÀsLîdA‹k2Ô“¬”0xM"ØÏ¢$ Q|இ(h@2k “™„ÿ’@@ž–àÿ%‚#ˆË;Tß?£?Êk»}.¹|ªü‰2“ mN2´ç áOÂÂ?A½t³mzêÎí»‹m3[:Œ¾h±Ã©´T¸<#Wùí]³7%·>ˆ– ¹wݲXÉü2™šey×–îýiV®Òݧà,ŒNªUèµ¼ÊîSÉ•¬Ò¢à–ê¨ÕYe£å Ù³yFÚ©”Œa«cAß=AçL»Æ:­sû¾Ç=(üÇ÷.Ûú*r¬Ù”0r-½i„»šã”쌘+*sæ¢p]]¡{„Fe±ƒa$»LÍñZ³·J¢^(—iD)‘2´N«ã¤µ9ªÕ)ÕåÖspg\˜K¢vRƒx¼ÄA"n‹åÄS5àÅlÍtÌîŠf¶½•™ƒî‰å–mƒÚe+!z&–Ý)ö²m˜@Z­3Œ¶Lk¿ðÇ&N„ààØX9žD&ÎÂ@—J$Ë⢓AØʤF1ºÿ%p»ÜŒ) x[’èa1&ZóŒ8,ˆQÊ|’¸’&cbà³ßn f=Ò´u˜…,2hNRÎ –ÛfBLÒ V·¶ŒŽÐ¨ÕKŒ·¡ˆÈ4l>9Ñ}™´Ç´_˵ÓòUò‹¦k³X J ’TuÑ´²U¥(’Hh¦ÈÁ%Ò꽬DC#‹ÑX^&k—´µõY%îíˆñ+ý<'adê Ëe³hƒJ¹Äá‘t=Ù±äæ; ,»·&|Õ­už¹³>nF?¢…誊7«žZáêiÖKjH ÃÈ6¬3 ‹£§ø™ôS òüA"ÿpB'´ž´»)—VÉ!èSÉÊdNÊÑRF¯÷Ñ> £DHm¢c)6Öç&hT%edr…ÑÉVÓ«g.ÑÑú*L³$Z5Íé4“†ÓÿP`Âi UN¿Œ3I»4ÇZç©gFØ[ŸA{NêÞÐr­›¾Å-Üuêw<ÜI»ZKfij6µ”ÚDP7ãU‘¡Æ¨×EäÌìŠÛㄶ©c¹ɸ•(ÊN4¶'$š²ìåâÊÆ|ö²£±Ø‰Þ¹¤ìà \Ö›Ïîy—…‡IÙ Ïá²0AD0âµôâ)ë«òÙ–>,DàU„ËÍvâËKòÙÍûáSŸ]ƒËv~Ÿß’ÏÞŸ…O}ö.ûö3øÜ“-ñ‘ƒµ%û. º¿µqÇì‹¾šé3 vFþ h‹“οy»ÐY€?]Æ›Éö™ä#(=pçcwlYRAûmc6?]±d ó·‘O¿õ­OGny%0þ#X]Luàj*oŒ›ˆ–jq]oø¤fXÜþD{¾¸!‹íijˆG Òcær3=ŒøÝiG«c"íö_C?K?;1=MLŒ üMáV,ÕÊåg(mkx‚ò5pˆ^F¸& ÂÇÑ0½çÃIW9ì#¥T„ŠQ5TÕDµ’xœ¶h¦–(_›IJ·´˜Z´Àßjñ¤p8HXašË4¦ jXˆ·Åüö,¼=[ø ,¸%`YK<)üà¤/ø,ó¡þ?f©± 1_ÊùKƒ!]”.Ò,M³…SOð t;º]¸, «C†N¡SB9/?§|):LëŸE7ãã˜R9¦O…MÏÂq©¿Iÿ®Vû.ÿÀ§¾ ýâÉ'Ÿw Õ=ÈäŸþù ÕCHù °wª”*ØÚ9ÅÒ” ­'©zª…z˜ÊUƒØÍç¢Õ$:$†×^µ>CÁŠãóàOÐ@°XmùÑf[‘œØ=Ñ Âd©•L3~”uÁê|Æ%BÞ‚-tÀå$©K9„ÕSå%˜0µA¸5d`VàZÊ_µ™ä]É–xS©¬­ˆTe Ox Ñczbã&}|O¬:áóTƒ¦¢%®R™‡XQ’qÚã¥y\Ï{`aÓýó¿±­ù‰-—WÍÙ22]È¡pþU᧨hæ„qfb_¿.¿’žØ°u}óvî×+„SoMü+:# 8:b89´É,ù³£mߧú‹Þ5㊹u¶·9ñBWï͹7ÿwq®»ÒI!äLÙž‰Û^¾”*ÌÍI=² SórÜÛÓ¨Ô£“Ö‚JâXœÏÔ@‡¥S°Çf»q'wåè‡þJÉ_^ƒ=çh–Á¤$šåR¢Yå{E>S¡Ï6ˆ^r½€çß)+îÖ† <é[Û§Ï Ô?8ðF./oÕŠ|Ö5C„s qYkóW¢á’Þ‰Ž¾‹–F#~°Ðï…l6ÕžBrBDzž‹;Ú·íØMëBÝs“ÂO>¿gäÔñkÑ¥÷^“oºNÕjïD÷ ;ö<¸5 ïI¦×nV«NþùÖÍ÷–&6¥f•r[¹y šõÌÐâS×>ø=o¸gšÒx0ûħ½½Âk[w‹x°ÔerJbÄôªšê§R+©§(0Òàîn‚<г¾üè<Ÿ wº187Kò*@—etCt,z«€i¡F$À\1UÇ%ymÀsÆÏ®†8õbÎðcuUÖÔy™ ؘÙKáÍÖ80oH´x4`œÝ”S<½³>1e–s™@*³ÄVSHÊŠKÔsæÎ,xIuZLN:-°¤»C&„ô?qV€&ÕÀS‘¢)Ë°Ì¥·=ºà€‹ÄM?a÷@×=£«JieO¢¶l=~|«ð_ò³péøÇñä@Û‚f•9í uÄŒ¦cWióÉßUÖ¼`A³ÆHûe.¹U¦cÙŽ˜Ög ££ëïÞ°¡·§cþîÁùMó釟ص¨Cxʼnþ±åþ>8þÒìu‹:P½ëô‰MÛèuÈ‘;P¾`â>ì’ -£•êUƒUëP( ô»ׯ¿{ý³MówÏŸ¾Ï@ÕNÍÃRïZê.b¡)ÊäÍŠ|æÒhfìùc\áºB¬Á©‘[…φó™aÑD%Çr0ÃA=C‡?V;­§U—à¥ãZâ$ƒ·‚‚̼3XR6›$‰ZÁåZLm`ÿ½œ»X_ T§ç.þšŒ&0R,™fT°Ûƒû(‘5³8Ö$Îl1QCI‚Q4i˜1$&ÏBÄÖ ÐóVYOß…>TvDb]ì#«Vut®D—Ñ ÚW,X”5=ÞÚ°½B]éLªÔGX+ Ó{ÙRgZeu†µ²Pmm¨þ£öªÊööʪòdOÿ;ÏæxCuá•òºöªÝ+o^µ²ãÄ㫞Ř´ð*›ÃY«Fzú÷4§.r:Sj=œD]KÛÛ—¶o ÕÔ„‚É$Œ¥þÌ<é_Ù3”ÓÈ ¼w÷R‹ðgÎú¼âoØF1/I€”méÁ‹Éªp4·’þåY>¤etˆÀþš¤!ØD'Í,}²#~f-R&€X÷nI2d„Á5¸C›£EénáIÌÉ´¬,¨GÙ·5_Réf$/p´L]¦Sxé™è;:ZX„7_Å{ÆÙak•¯ÒZ)þJxýÝá®Q«B]ß|[>ìíŸÖÀÝý¦ì±ß¦jŸSWñ†ŽÛå>”âfP™5a£gºÊË¼Æ W/ê¼åÒ¹&Zikà Í{'´µÝþE2µ^¸ÙìdRf­p;$´Ñ\^T#onø.:Š»N׸Žp½qÞ‚»‡Û4_¼ƒÖ>©7›ÍÂ]N#‘±2Ÿ¿¬îÌô½f³ÒÀtliàR”à5SyîP™P4kvÅÁ#w”ÕÆâ~Kl´B¯)»Š$qWˆ‘ Býb±Ñ²ânòöÐÑ(¹l$„LÖüh‹Õ)'Ôpš¨Pm2ým³¨Pé3õcl–5|®ÍHÇž}ñOb›‰G´™®ÑBfŒ•jõD_z’•j´qñb*/¶oeÙÊÖÉ-ªñàOˆW ŸÔ 4=“Pšg4U ¦Ó <®Ü%n•óê¹U¬6ñβð>!—ù·cwÂW$síÞ,?±jq~$üð®;+‹íf¶øàÆß>Îky‡ëEáê»K/ôÉbÂîRy ½Q]âŽZºfDeáÃ"ŸÜ³Gã+ ›n,Õrûj•ÝTÌoõ*Î÷Uqãq™I°Hrµ…Èžþc¡¡9Ÿë!Q{=ígüæ}9¨{~!¨û©âx}Ûì~1àKËOy#Uõ}s¡o{¸¾p¨²÷+y›/ùL›k$"Bn((Ãr²Øôl|`0ägqÏ"åƒI^& öÕIþX××WwÚ\××vHþHY§ÍŽpŒ~õg½ä1¤úN­=‘»dãþçh“JvÚ,S©d’?ÊT«…_ ÷KÕ-´[_ØFkU}X_4YrÚf£åŠ6­T©”ô4“FM[,´Z3ݨji“‰ÖJî­—)M&¥LOwëiƒ\Åó*¹ž©×Èjd0ÐFžž¥E…™Öë‘F©ÐF=ZQ‡ÿµ¨s’fÒjõf=PIZ•BTj\/× z«šV*Tr™–Öj 6’.q ,}¹¸êÔ¶‡Þ6þÝ1¢PŒìS(öýX¡øñÊ×þS­þÏTªÆ5šñ¿k4ÿ£T¡ûãgz…ì3´Ç€‡þàg2•áïègø=…ò¿ãþ }¡Ðh‚ô“é“•ËÇ´J©Õ*'$#A¥Õªú¯JVõôgµ^¯ŒVéõªÐŸR¦RÈ4Ö7ñO—³¬\/ÿÉŸè=ŒN!c冉ýÿ¡14[63,J¯ðù˜ùáíÛ¢ “øé îh(;É(]Gå$°²UDcÈc¸²d”È7uQ€&¤²,Ÿd¥D{€à3ê`û­ª&.ëx Á¥„ûo¯$:¢qázf:…Žîx]¸WX*ÜûúÅ®_GËÐ1´ìõÉëÇæΛ7÷1>ƒ^ùú‹ò9Mü8ÇÖÏSj>É㲋¡¾×T®ú€#°jÝÑÌ|f?Iíl‰fvƒ³ï$y;TÀÑÏõÙµ˜¼Õæ!Fòãf»ÅÌ8š|ö:LòÖ!Lp~¸tÖàÐðŠ]Û€ÎÕr¹º —ÃÆb3dcKðçn.ÛÔ‹?M†§ÒmÝWì¿šÇî>,xüøN¸ë—íÆmö2½ [Ì6ÁÃh¸ŽÄ'⇌Voض“€§2#©³°˜–sL˜IO†£¼Ålc;à0ÕӢɲ»ZÈ‚…Üó&ÑDFû¼“0`Z€»BP,åk’E…†`u0dÄíž`·$J˜ Ô†™‘ðRªu„kÃ_Œ…kGX À'¨ýŠÅZH¶û­ÊmBµAÔêäBO¼¾î6—^K#iKå5Í¿~ü®:±Ê–Ä@¼ ±×ÞA›Ùž¸½Öµ¿2`9#5–¹ÚÐN¥ZxUíìî©ÔJhë1iL‘¿:–†O„kk;%Tmûâ¹ðê …Ž¦6}c_ÿ=±°Î•Ò ëºbÚƒÝ6—¬Êì´`Øc­¾©‘Di´^ü}qlÛúykÑg²–HÀO ™µÑ¥‹œj”R+OèÀWÖs×Ì·nª-¢ S O«S8(ýçÌ)×× s ·™15§æ‚h~û×ÇEɧ‰¸’ÓŸg<˜ûÞûÉt±8¤Ï”Že´ŸgjÇžmZÿñûbq\Ÿ‰eËùÏ3¸uÕ§'‰§IH?•òe£%p|ö%Õ_?#å úÑTC-_–ÃÇs=PB¥g¯2%)*­+ö„JË+bñZÌÖ‡KRB \¬\x©dÝ §íO§NðtÂœÿhYe‰é1r‘hñ…²à¶'ݲhUMÁ÷cßE§|ÿ…p¯8øžÀUµÇg¤:äÆGdvžÕ ®Aâ$þúÉ{éôï‘1´„A,3r߃ӅŸ -gi¸–Ò7o¹™f‘DBÓìò!ágŒerV~Ýtœ0M¬C¿7Úôr+ãUvúŽuë„n£Ídb‹´gâ7 ·Ôd²ÑÉuˆ'E]8¿z°Ü°áœùÕ;5¿æž3¿Îf6/̪È\Ž»ôigE$OÖóE/—IRe,Q]3“$ £ðî%·éqä©ö%‰ÓªЗ}&|͈Ý.#}ÉI‘kžñ]´ÇQ*š±šU²xaJhVƬëA¾ö±—Û„»WKÔ &©jmðNûó/µÓs.Öç_Œ¬½_ÆË%R‰L!¹íZÄ!Ûºu÷Éx ƒŸ£¾Àß„ß3wº›=¯¯«0oÖF]5ÙÛžh&F…ÄDϸóóç^œí|\S šùñÕ. ´©Ap{*¢ 6IeMx£Í4Q•ô<Q²ññÀÎ:ñgÛ?3Õ˜ “ ,kx *Ïm‡ÐȢϋQÇð¡žÒ¶YÝÍ•ýÂÍ‹ýqgÂ]ÛäŽRgþ‰þ}DgéïÛiç×MüY‘Úàé_àÖÑû&gðù}ê£Ê¨u=•sžÝ‰Ëˆ±ÂBÄ¿BÆÏéOH}èŒeJò¹âT¹oJÄ~.'fÝBÿ&pÿ–8@ Ê–C&&žÝ¢‰Ê–9à{SbÖ&î\­‹]” T'- ÄM‚ _´/GÆFÐJS›ŽmÚtŒ¾ùâý7wcÂMnÙDO.}Å9ýVLô=Íx6vP3¨~ê#*ƒþKæ ]XÙ«ráz‚ÂËU%ë ÂÀÔËCe듸Úõ@uXTe]Í¢ ›„R7õ_d„|&&ä˜;á«ã&"Ô˜‰¨¦ íÁtžD€ð…Oö¿Á‘B”Ü´|d–Ù+]'¿å[Ff¬ÿLþÁã{‘A9.²7£Þ‘›I8n/š³~ýzœKà ŽS^zÞúˆQí˜g]L=7Iu* Â\%A˜«,Ç#‹×ÉàÔ:Yr΂5œ‡‘²‰ñ»m@êIï¼ 7@éo s†Ñx²àù³ƒxÁŒN›3w>ì ó¸L'Ø€&M'’í]=óDpºÑºúÖ68µNú›Zz‰1#ëÄí_|I6p¦I¥e•¤ ²´k ª=ÀaA‰^Ì€h1ëeüE—ŸA{àa=o4Ê%jÕôô9Í­vãüù†š Í'ßcM³›ß¿__c4±ÜŠþ‹æéccZÃ#:¹Ü<ñ®YN+1”T8ãðø0Oû«©ÛSOTëuÖûБûLRŽ«6]!¼ts÷ÔøžOÿÊÉž²nrtK£™º8„ÐWž~CC¡`‘5^¸¥4‚'pE¶rn´ªº®IL¡ñOm¢Eª‰•prhBÌE{¼'F== é1¤Ph%rè­â‡íÙ‘³·ö¼:„” wòt2³ãkÖøªÎ¥‚—ê40Õk‹.؆qÍÀT_ ‹œu³ï?Š¼rá•ë$ŸgRcÔhU,U'úYOž‰~Ö°-» ’p€Ë¶N' S®}æ¼).õ„7ÒÐ ê.Ü “ ¢Ù‹v{ô*à| °E˜ Y %2Ì£FQù ; õQK/ºöiµ¿•ÛTq#?yRÎà›üèu´YÓ¬ÑÑ…OTNåo 7¤/6Xã<*ðsƒ¸ù§Ÿâ[ƒø üä«ÄÜ V#DŠ[ìn˜‡>î)©NÏCÄk¦Ü0êñ—”‰ö"4i€NÜ«`–ñˆ 6À1ÄÑ*Àrl@,Þz|•ðë_ÿ-yíì¢GÞAû?w ã± u¤»ø-­@÷ç•ïœ9êýIy¼_ÿÏ£åx¯Æ*ʬ ?A“Ç?dfI:àlþ óÙ•ø½5y2ã$#¯®ŸÙ·D$X|!«Â´ZB¢ƒHÉ < j5$Š T PIN´$·˜² "‰¢`Ü\å’[ ´˜Üƒ—ÿû+,’‡Óµ¶«3¶¦·I¯9tvVYRQªÕ¬ Í4ò(d2ÞÌb$æYÇêò~žw{QÏ‚¾³©¡Ë*).­*Ñj´2e¸bVU{Y¥ƒGÌ;†3§„ºš¾ó—h7¦eòøªGîx¸#Ò»9}üÀ–.gQ•Ç&•nå¦Ûì•‹ÝO?Ùìõ:8n«¶Ó鬽çTºÂmôpúê=;ölZ=§‘ã4ŒÓۛݽjÍU„°âƒÛÿúEùp /‚åÃNjµ—ºŽº‹ú+UÇKE3{ã ¾Þˤ£™} f®ŒM"åÝ}Î öñ!뫈io#œÌB}öF<>·Æ¥wä3wLáèÝâÌ{²H )2¹´2XZŸÖÙ5cíeP²Ðv‹0{NcMmª¹µ­§z`Á¢¥—®ß´yëå{÷]ù ¸s#¾qÞàð’í»\sýMPr‡á©«vß|Ûw^6]ËÒfXüœµH‰Vz:g¯Øµûª·ÝùOÁòÑú¤E* ‹Ì ñÙfø‡O1{ÀX8\ g˜CÀÿB˜@È MŒ“5˜r$ƒ!Y0”$–uÜšZ¤A,²B‹/n˜Äò nòÄeÙµï£4„Þ¿öÚ÷…ï  ßѲ”‹ï÷ùç˜í)S³¼åö·¹–Ú7„{/]‹–þ¤¥–{ûö– ï°§õTý`eùe啃õ§Z=jµp·J U&%*‡R§ÚÜÐj‘¶¶Ú—;ëÖ ÷¾ñ´tmÊ„'ÖÒ&¿¯Ÿw¥–-KÙÍ_‹ô÷}x±³¯8Ñî>á©­u¬Ø´~µ£!á z1‡üíòyjÔ*ý1óÅ?–¶Òªy¥Ö–Ö¾7Üó@»áoJåß íô Ï.W:{Qïm†•Ê mô.‚¢ñWz^ù·S±*/¾YªÅyƒï~´tžj¼sõúM+µµžªžDÃ…þ°µ˜ªtQs¨%ÔÔJ<÷ææ3bx¶ÖÏUËË`†w‚ãkvåv³FŸÝ†¯÷Ä € ›ò™MQˆðΦ°Ë Ü ›ÉM¸´ìôL·ë›S€~-öãÏaC¦;•Äå½}øz)—™•Ê¬1d–°‚vã52×YÉ!‘pg=JlÅUÉÍbꛧ‚ÞÈÒe»áÙ W‹¬N?–ì³û®üjÄuH}ªD^ZÅIU^à’-&XE&©%A|w½|‚°6>/šr%äãXÆI$}ðLbxŽ›|&‚ÄFRž7‚óN¼Ú-œÈw>Æh¸½§ìÝ¥3íUU½CÊ€zf*Ö0o{}y°dó¾e«†×izýÁî^´&6½ª²³Jˆ¦1c~Äè%4kp×Óå.Ì~)|ŠK™$ çúf+Ú|úçÚÒZÖm-—ë6̲:’½Nç–y±5:†k¯¶2%éÆVšŠÐýÕ5>²fBaO¢‹¥RØC70ˆþe ¦>hµî2õ¿Goë7ZÝQàÚñž÷¦ÅeTKøx~î@N𓈩µÑÌÊ|fkt”Ÿ»x;L¼yùœÖ°thóô ¡™VH”ÙͨÞÊP1ànËó™„>ã„9ÇŽÀ ?ô™T‰i¦P@pÙúò™>½¨ø=ñÿîaÜæ‘(ô¡XnÙ…>¬(ËmY§[0÷° ðCXÌ*Ó2"TÕr'µ¶P$&º"cvYo:Û€Ül|Ö×Ϧ¥×XäâÀɬäNÒN;§“Ø,·ž–©ì‰šÚÕ›EÅRNß;3%Bû%«E£zÒïÄ/<ääbMz7B'0ñ<#ŸA’{ivo‘PÀ{,|u¼šœÇMÞ äÎÅ9o„©æâÕà!Û~²­¹sÉ 7,í_¶Ó_¦¿uO8TÑ1o^G…pÇ´ÝZþí‰ÃÝkÚ³£¡~=}V}~ͺÙ6‰ä‰dñRéï¤ëRÚù•«›†bN9-³JM²‡$%ëë£}ןŠF_S+ËJ®µÈƒ!w‰Å䪘“Þ(J­Xyé úÆk5ö£Ÿ×.¸|þüÓV, /Yìõ,œ¸gAýè =5¾’=/H„Ûx¾ 7,¬GK$ôxA^,Áΰ@xÓ'ú¢Jeõ‚þòå%­@\œC>-#óE$¡óÖÛ&Ôv š§i ÞncLÑ”¿SsLŸzÑ º'tß²ëë+—mî¸ÎFÞ)u†’¼Jæ{µƒPasðk‰Œ$µ›T «Ï¿º|¦N”å1÷0Я@oE<«¹Ñ` Éã•©3<­fÍ.·>.ª±Ì€§‹Sòi¹Âf÷Å©&Q¨/a鱃TCMDeXHaGƒ§ŠÌÙ1ñwõ¤Ï:XºÁcŒÞ©á£ÿ¾ý^¤9zTøôÞt›É²~S$·ˆ‰Á>"¢Dà‰OÐ2“à¬C|ËùÑAøܬAœöÔÞëO]}uUCÌë6ªQÒÀHzç‡ü gRé–F뻌s’rZ¦ÿR½µ/­“kÓò’'û}íÛç¶ݪz£DIÓ•;5¬Dnè*A cArÄ÷ëôæ&õõ¨¬¡5iª©›9}ùì:vN›6¡F,‹¶üð²²-:c±ÉM#ÉÝÓŒH©Ä*½Ä`æYZ‚PE˜ÑÙjá“6#š¦ÕóMŒ±¤M¢@5“ñHMrŠ}‰²SAÌ´Q³¨… 3¯‰‚]}N œ ÄAVõG3-$c¥ŸÀ¶ù I%ê !¥­'ÖžMµ‡1ï@örðhééì|f¶¨=bÖë(ÅdRܨDoÒ¶Ú&6¼ììnÀ¦*«‘tè <;j8ÃIm‘-% F×0^ *•ñs£r¥»¡ d0€nÁlÁ”Js—Ю,é'ºÑÕŸÒ!’’—9[)¶ÕYì9ç/£ÞW°lõ¦ÛzTxÿ¸Åç±U6ÙûÂ;hOkYI,VRÖŠNGŽGïGŽÇmK¾zg;nº×UUA¾ÂŽÇÃö tS…=”H„ìÌУÈqüà‡7Kî>?:³›a”Ž¾òW?BÿÅ«úcññÇë“oüô›Û~>ÿ©õ%ÅbùįåNGy…½ðIä`é<¬.Šâ‚IQ -CR¢„0bî½jNAÚ+ÑqF½Gz†bíZN¥ê?1¸5 ÞÂ,=ý¦°-€ÆÃ<3¦PYÃ_PN½œ=%üÒ"‘yŒhXâ_þ€v2Ê,wÛ¨âÂ7žó}hòûÁ$«@,Ïø¤#>ÏÙoœøXxËàÔ*x³¼Žf3K/úó¯ÑxÈÈŒ™,“_ü ᔉ|ñ÷_Ô&ÑWŽÿî‡lÙùù˜˜~î"ØjÅù\±$Uµc²fa.Õs6ÕOÑŸSÕº·ð®ž«#m]5®jm¤Z‘¬¶ÕáIh(.QˆÁZx¾j‹,áFšªÌA…!+‘ŠHi‰d –¡É¤" –¥sÜ\@* ç‚뉑¤ÏÂ)@a8äºjâo;Š¯ïÞýºðþÑ'„×ÖËüR§—uýlÇšç¯ëë»îù5ËNL?äæ¸R!m Ò”Aûn!|â™4+å8÷þ•á¿BfÍ[*‹ä×)hå’5øþ7ðc:Z¯s…ÂAáÙ³9àçåiµSíTŽ+ä"/mŽs2ö˜D F€ 7ipwï0é®"_AŽž/A,Òz¢;ÑGèbí…™•fNjNð§0þÑã_JËsJWm%êIšðû¾„ß÷jê§Tfu4×Ú¹>c.-×л˜ÃÁ( ýŒæ´žÔ0ùœ"T5Œe®‰fv¾2Ë ï„Ù0¬çðᘳÛIÄ‘ìÜ$ %ý"Ä^m>WÛOÒp4ãòÊX®Ÿdâ蟯ü±ìµ¸S†w‚àZÇ—Òg«Nÿ967²RyŒìßâ8¨>’·Ó-–fó£Œ @ãýˆp%¨¬ß ¬X˜ÌX¹QÊl#f*!k0 2ŠX E*L‚Ô¢bØ0ÄÅf=ìͬÙ(cnè¥Å Cpáw¯Þ·­¡!³.œ Gh­Y´ïêï~Wøì»´pŸ¢Ó¸rÞ ³Z,ÄgVó‰ypúÝ«Õøì[þË 1¹-~L³¸ŒÈ¢Úø/œ~+œ~¾ÊX¤Q•¼ûç•E—=\.9©PÚ”CJ¥R­Q.mÇß—¾ÿäMøK6n|žžS©dÃs÷{U•1£²üáË;y~,~^IáÃCäZ|þíä+Å—i$¯Aý?2ŠÚxÚc`d```apúýÞC1žßæ+ƒ<;œŸYž £ÿÿÿÏÀÉÀâr00(a| xÚc`d``cøw—“á?p20EãU”ÈxÚTMO1 õ|$Ù¥]±j…„Êe…*Q$öm—j½–¤ªwÚ'8Eýý5ü(Ô+}žØO´UGzrƱûÙN ôÕDÕ}B i4€¯²¬!«P±ÿ äE’¼gý«‡^~õìoöxÍp¬‹ã=àújãÕ‡’=to¼üÃ÷Xm¦À~m:»c»Fþ‡»ó9¬Ûr§±iÍýa$––²´ù†±îÎÙØ;¯©B,¿Ëçr›@'ç|`„¬_¸8pwg¹qcÞ—®¨…Ø]öˆ&Äegsöæ~j¢á!×dÈÛJÕåý#pòÍ›Ú8Ûi]Û˜ŸE¤ÉÛµ_Š¼¾›¶ì%`{w¤½ ¼gý*Hß0êH]-¼©®-bÅúÝhîbŠ¡ì™`òw†SˉËs•ësŒ8k ,Pƒ/ Ķ†½£•y1¹’_¼Ç\ë’û÷:™¿þ×â[#ÆZ9ùy®àï°¯¼Äû…Î'Ö äÛ©z //uöUWûô£êqoÃØ4_¦vï›_ µNçˆèÔÔŸ}¯0ï°Ç=húªsñirï¹OoqÃ>užÕî…/æÉ™wöG"»ÔŸöM…íÎĬ ³Ê6³â=fÌ€y²¿Æ?Ãý¸þ^lúÿ?tXΓĩosŸ×Üø̲í’Ï–óWzÆüßßFÆÆlfíµyç>KRRÓQËQ›¦vL]B=D½O}‡ú Eš*š}ZZZ‹´­´éXèÌÒ¹§«¤›¡»NOJ/Co›¾€¾™þ,ýÛ c 7i½0ö0^frÄt†é³2³yf'Ì,8,Œ,z,îYXn³r²ZdeýÎÖÇö‡½’CˆC…à Ç,ÇN-ÎBΓ\l\3ܘÜ9Ü«Üx(xðäñ ðüàãuÊ;ÊGÀ§Ã×Äw•ß ÿm›w©M úœVö&¼(|I„VĜȮ¨¼¨Ñ1f1bkâÄâŒâÚâ•¢’’Ë’/¥ÌKõKý’v+ýIFVÆ„Œmw2™22›2WdžËÒËZ“-—½+'%ç]î…<®¼=ùu· C 崙h”L(å(+½S6¡B©2ª*¢ê_uSõ¹«š5_jj{joÔ ÔyÔ5Ôí¨—©oª¿ÓàÒ0­Q¡qSÓ¢¦sÍFÍßZ’ZÙÀpW[Q»Hû¢ŽwëºVt}éŽé~ÔcÐÕó­w_ߣþ¤þD&웘6qÞ¤’Él“·Máš²`jÈÔmÓL¦uM{0Ýbú„B3²fÍœ1ËnÖœYßfw̾6ÇbNÝœGsµæÌ=4ÏjÞ„ùLóËæßYà´`ÕÂ…/­X,²xÉ¥?–XöeyÏŠ¶•5«LV½Y}bÍŠµkŸ¬¿°qÑÆg›B6mÛ̵ùÌ–´-Û¶|Ûºm[öWÛÓ¶ÏÙ~iÇ»{v|Û¹oO×Þ”}ûìgÙßp€é@ÐÍöò;¬qDëHÍQ½£eÇXŽM:öëxÊ ‰sNV:µã´Åégöœ9;ëœÚ¹¼óvÎ]üriÁe­ËW$®\¹¦pãú“›9·NÝ »sânÑÝ%wßÝk¹osÿ߃Ï=jzìñDãÉ¢§yÏ4žÇ<¿õRè•Ó«¯½±{kôNéÝ¡÷«>}Øó±ì“Á§YŸý¾ù&òÝé{ϳg~nùùæ—ίk¿õþxüÙðwÊßÿªþû‘ËïÌ`xÚc`d``üÀ$É ÂL Œ@,Æ¢â@!CžxÚRKJA}=‰Ÿ d%A\õBD\LÆ8.ÜEq!ˆ‚Y'™I"êD21!.<…'È<‡îÄcx—â뚎I$ºëuWÕ«W5 d ²9O\)V(ð”b‡1Ïgàbhq›x·xø²xµnñ†Ê³xkêÃâVÕ§Å+ØVßçqàlYüŠ‚ZüÏyÄ!Ú¸Ç\£‰ºÐ(ÁÃ|¢2Búkˆˆ/•ÐáŽVã1êôv˜oöªøBvcònùé ÖDNmDÛ³‘ÇÌŒé-£/¾6¹#\p5ñ@†ª°u 2ÌŽ~5—æDè?œW¢"¡:­Ù«Ël—#¦Ý9LçdˆÈ‘«é¨!\š‘mÙ[â™5W“S'UmÈÜÆ9 [Ñܘy†2k£÷†wf¾]᫱1KLkNuQ™Î´#,ÓÊÈГ:'D1Ù¢«KŠüFõ«Sy®Túd‘JÕÄÒqîÒIWä hœ‘e ·¾ì{¬áÓüûã×ø؇†ÅxÚmW”ÛHu•™&™,Ó-3í±=³œM6Ę̈•ä¶¥X–Á@–™™™™™™™ŽvùöªZòdæÝÍKº«[UÝÕÕ¿~µ˜ß-N”ø?ð-7 L$g'ÎHœž8+qnâ$^òhYA>h–HxMh>Ô»yºFò‡Òw`J’aŸÝqœfŠŠÓ&Òt‡b²@1ðÜHiŒžâô*•>ÑÌÈP9ªlrBqxªÊM¾«‘:7 nšÜŒp#¶-¨Ì¢X«še£ÑÙh”FÙh”FÙht4¥ I ¥*75n†£Õ¶­ð ÁM“›nب2Ä ­°Q…*ÃÜÔ¹a‹ [TØ¢û6o(îÙ®ÊvU¶«²]•íªlWe»*ÛUy§ïTc‹[ÔØ¢»7?^p~%Öâ-ç×ã¾÷¼ø0¯1Ì»ó®Ã¼ë°üÀ¦Ã±év¼q7®ó²u6ª³QêlTg£:ÕÙÕ[4Ø¢Á ¶h°Eƒ•¬Ü`å+7Y¹ÉÊMVn²r“•›¼|“-šlÑd‹æè]¸ÿ…°K°PX±ŽY±F+X!°YK°RX!°€Y°+\XY°+SsÆéOpen_Sans/000077500000000000000000000000001321131462300340675ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/web/client/resources/fontsLICENSE.txt000077500000000000000000000264501321131462300357240ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/web/client/resources/fonts/Open_Sans 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. OpenSans-Bold.ttf000077500000000000000000006665201321131462300372340ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/web/client/resources/fonts/Open_Sans0DSIG’t:WÜtGDEF&¯S¼GPOS 77SÜ8GSUB+=·TÆOS/2¢u¡¸`cmap)«/h´cvt -”¨ªfpgm»s¤uÐàgaspS° glyfÊô%¬KÄhead÷áÇ<6hhea) Rt$hmtx$ÒškernT+ ~qp¶6loca²Û`+TVmaxp5˜ name¼f{"'¨ÜpostCïl-„&+prepÈ ük°øš:©9³_<õ ÉB ÉèJ¡û ý¨  ý¨ û þy £ªŠX/\ ¼š3š3Ñfü àï@ [(1ASC ÿýþ„X Ÿ^¶ ÍÁJuÇ…+-‘X5?R!…¶R¶=\?‘XR?“=HuN‘J‘y‘N‘N‘#‘d‘H‘7‘H‘BHuR?‘X‘X‘XÑ-f…`¸wì¸{¸d¸Ëw¸B¦ÿhP¸…¸‹¸¸^w¸^wH¸h^¢) ®3¼Vþ¢1¦N ¦3BJÿüÛLÕV \\º\)…B q“qÿ}ö q Û B ô\ \¢ ú\y/BšÙ  ç7'hÇ'R‘XJu‘‘R‘q‘hÇãjÛ¨d/ìR‘X“=¨dÿúm\‘X/;ÛLH =qHu¤ÿÛ\9ìR . . ZÑ=………………žw{¸{¸{¯{¸*BÿÜ9ì/¸^w^w^w^w^w‘^w ® ® ® ®þ¸° ÕVÕVÕVÕVÕVÕVVV\º\º\º\º\qÿ›q‘qÿ†qÿãô\B ô\ô\ô\ô\ô\‘Xô\BšBšBšBš …ÕV…ÕV…ÕVw\w\w\w\ì¸\ì/1\{¸º\{¸º\{¸º\{¸º\{¯º\Ëw…Ëw…Ëw…Ëw…¸B Bÿñqÿ›?qÿéqÿ¯Bq+Bq ÃBº“¦ÿhqÿ}P¸ö ö …¸q …¸qc…¸q …¸m …¤¸B ¸B ¸B ;¸B ^wô\^wô\^wô\ÉwÓ\H¸¢ H¸¢cH¸¢Sh^ú\h^ú\h^ú\h^ú\¢)y/¢)y/¢)y/ ®Bš ®Bš ®Bš ®Bš ®Bš ®Bš¼Ùþþ¢1ç7¢1ç7¢1ç7 ‘Å…ÕVžVV^wô\h^ú\ÛºÛºÛÛãq“žT¦ ÛÏ´œž×žº…ÿÈHu ÿ®ÿÿ°ÿÆÿˆJÿÆBÿÉ…`¸}¸D9{¸¢1¸^wBP¸3‹¸¸‘R^wö¸¸¾N¢)þá\VmJ79þ-\qNB B )-\H ‹ô\qNü\B ò\B ö ìH Ãü\ô\éòyü\9\N))V\¼ÿϲçmB )ô\)çm{¸q)}¸jwh^B9¦ÿhþ¸q)`¸9ö¸…¸`¸}¸ {¸‹/^–¸–¸`¸ö‹¸¸^wö¸¸w¢)9á\V?¸Óm ¸é¸Ñ?¸¸NH¸RÿöÕVú\ Ó Pº\üqNààô )Á L ô\7  \m/ƒ\   ?{Á á ®Í é J ¾º\BÓ 1\ú\q“qÿåqÿ} Bô ` ¦¸ ¼Ù¼Ù¼ÙþRRRJÿü¼¼T?º%?!{5{b×u ??!…Ç…òRòRu þwbf‘#‘R#¸‘B\?))9‡þJ7ôf : ; Z C¦;D9î¦ )‘Xd%¨qL‘X‘X‘V‘XªX‰)‰)žhqÿ}^^N) T-;-+ªVyHšÍTTqÿ}¼Û) þ3‹¸Û …ÕV°þrªXy ) )šwo\®šüüÐûàüÙüÙ{¸–¸º\à´wbLš¸f × ¸7 o)ü–¸  )qm²^wô\¼×¼× w )\°wo\´w\´wjw1\ßhu´žôžÍžËé)¦)T¸j î/鸠y/î߸Ñ ;‰/^qN ¸R P¸Ë %öݺ¸ò ¬¸  ¸ 7w?\w\¢)f/þ˜þ˜ò q)T/omÏ{Óm?{Ó¸T –¸–¸B‹ü¸J ´Ñ¸L ݸô Óm?{J¸h B…ÕV…ÕVžVV{vº\‰¤Ï\‰¤Ï\‹ü/^qNº9¦9–¸à–¸à^wô\^wô\^wô\NHJ999Óm?{}¸Ó ?¸Í y/îÛ) V  \\h\b\Nö9œJND{X¸ž fwN\)ß//XsN‹Ë…ÕV…ÕV…ÕV…ÕÿÓ…ÕV…ÕV…ÕV…ÕV…ÕV…ÕV…ÕV…ÕV{¸º\{¸º\{¸º\{¸º\{ÿͺÿß{¸º\{¸º\{«º\BquBq‘^wô\^wô\^wô\^wôÿß^wô\^wô\^wô\šwo\šwo\šwo\šwo\šwo\ ®Bš ®Bš®š®š®š®š®šþþþ1\ûü-û ü-ü1ü1ü1ü1ü1¦ VVÙ-ßfð=‘B‘N‘‘d‘H‘7‘H‘B1)áR¢)y/\\\\\¦¸¦ÿƦ§¦ÿ ¦ÿý¦ÿµ¦¦ÿ˦n¦¬øÿ¦¸ÿý¸ÿý¸¸‹¬ °€0HI~ËÏ'2a’¡°ðÿ7¼ÇÉÝó #ŠŒ¡ªÎÒÖ O_†‘¿Ï?…ÇÊñùM   " & 0 3 : < D p y  ¤ § ¬!!!! !"!&!.!^"""""""+"H"`"e%Êûþÿÿýÿÿ IJ ÌÐ(3b’ ¯ðú7¼ÆÉØó #„ŒŽ£«ÑÖP`ˆ’ÀÐ>€ ÈËòM   & 0 2 9 < D p t  £ § «!!!! !"!&!.!["""""""+"H"`"d%ÊûþÿÿüÿÿÿãÿãÿÂÿÂÿÂÿ°¿²aÿIÿ–þ…þ„þvÿhÿcÿbÿ]gÿDýÏýÍþ‚þýšþ þ þ äXäãzä}ä}ã âBáïáîáíáêáááàáÛáÚáÓáËáÈá™ávátáá á ânàþàûàôàÈà%à"àààààßçßÐßÍÜiOS®ª®Àðàê0L\pr`<–—˜™š›ëœíïžñŸó &'()*+,-./0123456789:;<=>?@AIJ$%TUVWXY¡\]^_`abcdef¢hijklmnopqrstuv£hœžŸ ¤¥£¤¥¦§ijêëìíîïðñòóôõkö÷“”•–—˜™šøù¦ÊËÌÍÎÏÐÑÒÓÔÕÖק¨F©opqrstu45]^@G[ZYXUTSRQPONMLKJIHGFEDCBA@?>=<;:9876510/.-,('&%$#"! , °`E°% Fa#E#aH-, EhD-,E#F`° a °F`°&#HH-,E#F#a° ` °&a° a°&#HH-,E#F`°@a °f`°&#HH-,E#F#a°@` °&a°@a°&#HH-, <<-, E# °ÍD# ¸ZQX# °D#Y °íQX# °MD#Y °&QX# ° D#Y!!-, EhD °` E°FvhŠE`D-,± C#Ce -,± C#C -,°(#p±(>°(#p±(E:± -, E°%Ead°PQXED!!Y-,I°#D-, E°C`D-,°C°Ce -, i°@a°‹ ±,ÀŠŒ¸b`+ d#da\X°aY-,ŠEŠŠ‡°+°)#D°)zä-,Ee°,#DE°+#D-,KRXED!!Y-,KQXED!!Y-,°%# Šõ°`#íì-,°%# Šõ°a#íì-,°%õíì-,°C°RX!!!!!F#F`ŠŠF# FŠ`Ša¸ÿ€b# #Š± ŠpE` °PX°a¸ÿº‹°FŒY°`h:Y-, E°%FRK°Q[X°%F ha°%°%?#!8!Y-, E°%FPX°%F ha°%°%?#!8!Y-,°C°C -,!! d#d‹¸@b-,!°€QX d#d‹¸ b²@/+Y°`-,!°ÀQX d#d‹¸Ub²€/+Y°`-, d#d‹¸@b`#!-,KSXŠ°%Id#Ei°@‹a°€b° aj°#D#°ö!#Š 9/Y-,KSX °%Idi °&°%Id#a°€b° aj°#D°&°öŠ°#D°ö°#D°íŠ°& 9# 9//Y-,E#E`#E`#E`#vh°€b -,°H+-, E°TX°@D E°@aD!!Y-,E±0/E#Ea`°`iD-,KQX°/#p°#B!!Y-,KQX °%EiSXD!!Y!!Y-,E°C°`c°`iD-,°/ED-,E# EŠ`D-,F#F`ŠŠF# FŠ`Ša¸ÿ€b# #Š± ŠpE` °PX°a¸ÿ€‹°ŒYh:-,K#QX¹3ÿà±4 ³34YDD-,°CX°&EŠXdf°`d° `f X!°@Y°aY#XeY°)#D#°)à!!!!!Y-,°CTXKS#KQZX8!!Y!!!!Y-,°CX°%Ed° `f X!°@Y°a#XeY°)#D°%°% XY°%°% F°%#B<°%°%°%°% F°%°`#B< XY°%°%°)à°) EeD°%°%°)à°%°% XY°%°%CH°%°%°%°%°`CH!Y!!!!!!!-,°% F°%#B°%°%EH!!!!-,°% °%°%CH!!!-,E# E °P X#e#Y#h °@PX!°@Y#XeYŠ`D-,KS#KQZX EŠ`D!!Y-,KTX EŠ`D!!Y-,KS#KQZX8!!Y-,°!KTX8!!Y-,°CTX°F+!!!!Y-,°CTX°G+!!!Y-,°CTX°H+!!!!Y-,°CTX°I+!!!Y-, Š#KSŠKQZX#8!!Y-,°%I°SX °@8!Y-,F#F`#Fa#  FŠa¸ÿ€bŠ±@@ŠpE`h:-, Š#IdŠ#SX<!Y-,KRX}zY-,°KKTB-,±B±#ˆQ±@ˆSZX¹ ˆTX²C`BY±$ˆQX¹ @ˆTX²C`B±$ˆTX² C`BKKRX²C`BY¹@€ˆTX²C`BY¹@€c¸ˆTX²C`BY¹@c¸ˆTX²C`BY±&ˆQX¹@c¸ˆTX²@C`BY¹@c¸ˆTX²€C`BYYYYYY±CTX@ @@ @  ±CTX²@º ³  ±€CRX²@¸€± @²@º€ @Y¹@€ˆU¹@c¸ˆUZX³ ³ YYYBBBBB-,Eh#KQX# E d°@PX|YhŠ`YD-,°°%°%°#>°#>± ° #eB° #B°#?°#?± °#eB°#B°-,°€°CP°°CT[X!#° ÉŠíY-,°Y+-,Šå-@‹ !H U UHUÿPLOMdNLd&4U%3$UÿÿÿMLdLLF 3UU3U?¯KFËFÛF#3"U3U3UU3U¯Ï03Uo¯ï€¸±TS++K¸ÿRK° P[°ˆ°%S°ˆ°@QZ°ˆ°UZ[X±ŽY…BK°2SX° YK°dSX°±BYss+ss+++++s^st++++t+++++++++++++^¶u¶Í^{ÿìÿìÿìþÿì¶ü”ÿëþÿàþ¼ÿìþVåö+Ó²ööíß²T$$$$Vzïzèpˆµâ Kh}ž¼þ+yá*…à }ÙHq—®ò R ” Ë  5 Š ¿ ð  Z y ¿ ú < { Ñ $ „ ª ßm¯ã:Xz¦½à:ŽÊsµQ»ø?V²í0…Û e§ãq¶:…œë++\«`¾ã`—fº×ßm„ºô.ƒ¦ï#D~«á5K`vÖçø  , = œ ¨ ¹ Ê Û í þ!! !2!‚!“!¤!µ!Æ!×!é""v"‡"˜"©"»"Ì##†#–#¦#¶#Æ#×#è$$$$­$½$Î$ß$ð%%%‘%¡%±%Â%Ò%â%ó&4&’&¢&³&Ã&Ô&ä'>'O'`'p''‘''©'º'Ê'Û'ë'ü( ((.(?(K(S(À(Ñ(á(ò)))$)0)<)M)])n)~))Ÿ)°)Á)Í)Ý)î**R*§*¸*É*Ú*ë*ü+ ++#+4+K+W+c+t+…+‘+œ+á+ò,,,,-,9,E,Q,,Ð,á,ò,þ- --*-6-‰-Ö-ç-÷...*.;.ª/2/C/S/_/k/|/Œ//­/¾/Î/Ú/æ/÷0000.0?0~0Ù0ê0ú1 11,1<1N1_1q1ƒ11›1¬1½1Î1Þ1ð222"232D2T2~2Í3X3ü4 44/4?4J4U4†4¸4Ï4ü55M5u5¶5í66Z6n6w6Œ6¡6¶6Ê6ß6ó777767>7F7N7V7¯7·7¿7ö7þ88D8L8q8y8Ã8Ë8Ó9A9I9™9ý::!:1:A:Q:b:t:Ú;E;Œ<>7>¬>´>ü?H?’?Þ@@W@¾A$AvAÕAçAøBBB)B;B•B¦B÷BÿCCC!C†CàD&D7DHDzD‚DÇDÏD×E(E0E„EäFF,FaFŸF§F¯F·F¿FÇFÏF×G!G)G1GdGGÒHH]H«HèI;IIðIøJZJ·JÖK"K*K}KÞLL$L[L—LâMMMDMLMTM{MƒMêMòN%N]N‘NÒOObOOéPCP‘P¢QQQmQuQ}QQ—QóRIRŸR°RÀRôSS>SOS`SqS‚S”S¦S·SÈSÝSòTT+TLTkTŠT«TàUUAU†UòVV^VùWW W7WfWrWWÄXX„XÿYƒYüZWZÌ[([0[†[[´[Ë[â\>\w\œ\Þ\ó]$]Œ]Á]×^(^`^–^Ó^ß^ë__?_a_ƒ_¦_Ü``p`½`äaLa™a™a™a™a™a™a™a™a™a™a™a™a™a™bìc\cmcuddKd¾dÏdàdìdøee:eeeŸeþf`f°gggg"gNgdgug†g–g¦h)h„hØi(iŽiîj6jƒjïk\kÖlOlèm€n0nînönþoSo©oôp$~PüÀe~eþ´:CgH9CM_V\q…࿉ÁTV]˜º­‘wÅYþëu¸‡þÿcƒVf=J,`†5=@;Xj0]…¦œ¶¶?Í3310#œ)Å)¶ýðRþ¼y¶ @  $??3333331073#&R›’ú“ˆø“š1 ήÁþ2ôõþ7¹ªÆ=þ¼d¶ @  $??33333310#654'3d›’ø‡”ú“š1þùþ:¨¸ÉöôÎÁ¯þ1?V5@    ?Ä293393933393910%'%7°)u!þ¬ß㜉ìÝþ®'m)þhüþ×y9þÉw)úhpXã9Å &@  /3332293333310!5!3!!#Ûþ}ƒÛƒþ}ÛdÛ†þzÛþ?þøËî·/Æ33Â210%#7!Ë4|ÜA$×Êþë ì=¨V¢µ/333105!=¨úúuÿåÓ9 @  TY ?+331074632#"&uZVS[\RT\TVXRO[YD¶@ ??993310!Dýßþë!¶úJ¶JÿìHÍ (@  OY OY?+?+993310!"!2326&#"Hûþûýþÿúýý5]nl`akm^Ûþþ|sƒoþ€þŽþóéì  ëëyN¶ *@   ??3939339910!!77'3NþËM¨•×þN‹˜M‡ºwNPË=@  NYNY?+9?+9399333310!!5>54&#"'>32!Püo£d,aQU W¨lŽ¨h‰ÒtG•¼¼}×s§n;XVNHÇ\L)d´te±º¬±NÿìBË&[@/"  '(!$OYPY   $  OY ?+3?9/_^]+9+39933339910!"'32654&##532654#"'6!2¦–±¶þÎþäî¸UÌd™’¨¸oqªÐH•[Èão‰À$«‘ÓëO+6hsgVíYl¦0;Õ¸#q¶ F@"  PY ??39/3+3933393339910#!!5!3!5467#q°þÒý°þ" %4þô/þÑ/×°üiø>ìRNþkdÿì5¶V@+  OYNY OY?+?+9/3+99399393993102!"'3 54!"'!!76fÔûþÒþçô–OÒ^þÛ5€({7ýö#=¦îÏõþøO *5èÝ BéþúþáHÿìPÇ$A@! ""%&PYOYOY?+?+9/+99339910!2&#"3632#"&2654&#"Hon}GYWŸÉd cÚÄÞþøê¢ñƒcjcd^…}m²¨÷`¼­ªöÙêþï– ¿…{k{zQw¤7P´.@NY??+999393103!!ã%ý/ý×°ÂûHÿìJÉ".S@), &  /0!!)) QY #QY?+?+93939939329399102#"$5467&&54$32654&'"6654&JÒ|Š¤þææðþî…“}nxhsrqÕâOaMebNdÉ¿¢p¯EX¿r´ÛÌ»}ÂJO´kÂû¼V`cQCuBbÌQD<_2.`?EPBÿìJÇ%?@  ##&' PYOYPY?+?+9/+99399210!"'532667##"&5432%"32654&Jþ”þ‚CT\›Èj :˜r¿Ü æ¢ó‚ýï`lbd^†}FþPþVø[ë^LõÚë˜þßÁ„|j|{Pw¤uÿåÓs &@ TY TY ?+?+33331074632#"&4632#"&uZVS[\RT\ZVS[]QT\TVXRO[Y‹TVXRQYX?þøÓs(@  TY /Æ?+33Â23310%#74632#"&¼4|ÜA$/ZVS[]QT\îÊþë ìÛTVXRQYXXË9'@=/333233993310%59üáýT¬Ë¶ððþÃþçX¢9$@ P`/33/]33233105!5!Xáüá%ÛÛþ}ÛÛXË9+@=/3333339933105X¬ýTáüº=ðþþJÿå Ë%D@"   &' ##TY# OY?+?+3/_^]99393331054676654&#"'6324632#"&RmiC`V–ÀmßúÎódŒ`3þ×ZVS[\RT\åJ`ŽPK^:ADbÛ}Æ¥n dGJ<<þªTVXRO[YfÿfÇÉ4?Y@+9955 ;( !!--@A77 =  *1$*/3?399//33333993393393910#"&'##"&543232654&&#"!267! 4$!232677&#"Ç\¨oJrl§±Ì ØVÏCL@L†óœÊþÖŸ'jþ{Öþûþ„þWÙ‘ÜZ¼ü¬Z^ 3@}‹ðïˆG:Õ¹Ó!þ‹»—¡÷‚¦þÇÍþìþÙ/-À[d÷“å´þ´þªÓÝ œ…¼ C@!   LY  ?3?39/+3333933999910!!!!&'7jýëjþ²{ýþ“%!œ\þ¤¼úD`Ù|$€þ¸ô¶ V@, "!MY  LYLY?+?+9/_^]+93333393910! #!32654&##32654!¸Ç7{f‹{þßøýÝ6´~q{…£Ê€zþü¶±Áƒ¨ ªÈàsNZTIýÅþƒbe¶wÿìÑË1@ LY LY ?+3?+3333310"!27# 4$32&&%¯ÀošÛ´ÞþÁþ®¦7ÑÕ×dR¦ÉþùëþMþüKƒjäW·gü':¸u¶(@   LY LY?+?+333310!!! !#3 uþeþ|þbËfŒþ¾þ`¥…Àéþ—þ€¶þ†þ¥×üH¸¶ E@$    LY  LY LY?+?+9/_^]+33333310!!!!!!!ü¶Jýìïþ¶þþ¿þþ‡¸þ¶ 4@   LYLY??+9/+3333310!!!!!!éþÏFýëðþ¶þþ‡ýwÿì'ËL@'  LYLY LY?3+3?9/++3339333910!# !2&#"327!ãDù‚þµþ£•gáÑg ­Éòúadþë5ý .%…lbŒZøPþòäîû1¸f¶ 7@   LYL ?3?39/]+33333310!!!!!!!fþËý½þÊ6C5wý‰¶ýÃ=BÛ¶ 2@   ?33?3393333310!!57'5!Ûýg²²™²²°R²R°°RüNRÿhþRî¶ @ LY ?Ä+333310"'3265!iNPBfX6êþR‡Zú¨ÿþô¸P¶ B@    ?3?9339333233339310!!!!7!Pþ þƒþÊ6zŒXþh^ýö¶ýc¬ñýy¸?¶@LY?+?333103!!¸6Q¶ûJÿ¸Ó¶:@    ?33?3993323393310!#!!3!!46##þ  þë¦Zo¦þß þ‡{þ¢uýX¶û¢^úJ´1€û‡¸É¶6@   ?3?39932393399910!!#!!35!Éþvý„ þë‡{RþÛ}ýP¶û¹v´wÿìçÍ (@  LY LY?+?+333310! ! 3 !"çþ˜þ°þ°þ˜iQQeûÕº¹sþ¹¼Ýþ•þz†mmþ|þ”õøíîù¸ª¶4@  LY LY??+9/+333331032654&##!#!! îfŽw¼þÙþð…þÊÓ qlmhÊìúýø¶åwþ¤çÍB@"   LY LY?Æ+?+9333393310!# ! 3 !"ç·±`þsþôþ°þ˜iQQeûÕº¹sþ¹¼Ýþþþ£QþwH†mmþ|þ”õøíîù¸H¶N@&    MY LY  ?3?+9/+9333Ä293931032654&##!! !îd“Œ–^þʪ*Ž‚Jdþ¨þ£-bihXýyý϶ÙÝÉ9þ1^ÿìË'E@"!! ()! !  LY LY?+?+9933993339310#"'32654&&'.54$32&&#"þãþê´”ÍUfm0]††PèrÏqdu™JX^&S›Í˜–ÆäX B6NM+C>D?tšgÂÞ61ñ0&RB)=9JbÅ)y¶&@ LY??+3933310!!!!!ìþÊþsPþs´þþ®ÿì^¶%@  LY?+?3333310# 5!3265^‘þî»þæþÈ5ˆ˜‰¶üN¢ô‚!û®ü©žŸª}3¶ *@    ?3?3333393310!!!67ú9þþ®þ91 @¶úJ¶üšMÍ(\漶F@"     ?333?3333333933333310!!&'!!667!667!HþŸÆ 50 Åþ þ‹1»1+Õ%Õ* ,º1),6ï3ý¶üâÝ¢9ïB3üÍ7âQNéHV¶ D@       ?3?3933332339933933310!!!!!Vþžþ¬þ¬þ´åþ:V;5Nþ5)ý×òÄýòý+þ¶6@ ??3933939233310!!!1NþþÌþP\ZüƒýÇ/‡1q¶ ;@ LYLY?+9?+999333310!!5!!!qûÀ½ýVýDÏÉíÈüþ¼s¶@  $?3?3329310!!#3sþäààþ¼úÓú¬ B¶@ ??333310!!!þëý߶úJ¶3þ¼¶ @ $?3?33393103#5!!3ßßäþqTÓù=¾-@?39/32333933103#¶ïïþ¾þè¶üJƒý}ÿüþ¼NÿH¶$?33310!5!Nü®Rþ¼ŒLÙ!@ @ €/Ý93Ê210&&'5!Ã?ôDV?¬Ù,ÅBeÈVÿì;u"J@&  ""$# KY FYFY??+3?+9/+333392910!'##"&5467754#"'6323265f;M£ƒ¡¹ùû®†µeÁëáðþÑv…‚”j˜aK¸ª²© 1ªQÎeÄÈýXZze ÿì´B@!!    GYGY?+?+99??3339933102#"'##!36"32654&ÆàçÇÅp3é1 kpqhkt^opsþËþóþëþÐ{þ–E˜¦ô‹ !´œ­¥¥¥\ÿìÝs*@   GYGY?+?+333910 !2&&#"3267fýö šZH|>îîX–KJ—=-Lì%þ®þ¸/2þû/$\ÿìq@@!  !   GYGY?+?+99??3333910"323&5!#'#'26754&#"ÅáåÉÓo 2ê; hjumo}fqr23¤}bfùì‘¥óˆ£!´œ­¥¥¥\ÿìbsF@# JY JY FY?+?+9/+933333910"!&& 32!3267oan¬r6þòþÐøíý/‚e´bP¶š{qq{üR*3þò’*.ì(')u<@ FY GY ??+?3+3339333310!!#5754632&#"! þøþϨ¨¼Ïž{N\NA:yü‡y“RR¿°/àMþÏ1••GOû^ÿ}þß /@ IY GY?+3??+3333310"'53265!432#"FuTFIMG1Îp¦¦SS¦þðVTªû)²Ák••GO öI@#    ??39393?3339333393107!!!!Å…9XþD×þ þ¾ƒþÏ1`ªTþý‡Åiþ¤ýJþ Ñ·??3310!!!ÑþÏ1 Bs#M@& % $  GY  ?33??3+39333933939310!!4&#"!33663236632!4&#"‰þÏQWujþÏé)-ªnûY-¯n¾ÃþÎQWpoyy¬Åýò^MW¤NVÃ×ý'yy ® ¨s1@  GY  ?3??+93393310!!4&#"!336632¨þÏV^€rþÏé)3³rÃÊyy«Æýò^QSÓÇ\ÿì˜s (@  GYGY?+?+33331032654&#"!"&5!2“m{zkl{zlþàþÿ¡ö„¡ö„1¦ª©§¦¦¥§þïþÌ°0Œþú þ´sC@"  ! GY GY?+???+99993333310"'#!33632"324&ÅpþÏø+kÒÆàiÂÝqhktÍeŒþ;J‘¦þÎþð³þøŠ“‹ !´œR¥¥\þqs B@!" ! GY GY ?+?+99??333399310%26754&#""3237!!47#otlo{×kÆàåÇjž<þÎ 1¢Û…¦%´œþ®¨¦ï14PTù¶Õ=kQT ws%@    ?29??3393102&#"!3366>)%5’£þÏç-4±s þâ –‡ýÇ^¼^s\ÿì¬s%?@ '&   FY FY?+?+993333339910#"&'53254&&'.54632&&#"¬ïîz¬KUÕQ¦,lZy7çÔÊ¿\T’L‡W“ƒz:L¬´! ü(6`$-9&6\wW•£XÜ$.I)<;5\x/ÿì7L=@   FY GY?+?3Á+3993333910%27#"&5#5773!!wPpr¦·§’¨XÃ9þÇIß#ã3¹¹fìîåýåA>šÿì¢^2@  GY??+9?33333910!'##"&5!3265!¸)1´sÅÈ1V^€r1NUÓÆÙýsyy«Æû¢^ ,@   ?2?3333393310!!367!ªþV?Ø$ (×?þV^ýƒyl`…}û¢Å^J@$   ?3?339933333933333310!#!!3677!3667!7VtÌþ¸þÂ0 ŠPƒ  . †+þ¾‡îü‹^þ…êL¥UýèVa]Hû,ïû¢ –^ L@$    ?3?3933333339933939910!!!!…þ˜ZÙÛZþ”}þ¥ëìþ¦;#þœdýÝýÅþþ^L@%    GY ?2?+3?39333333939310!367!#"'532677NÓ  ÏGþ'Añ¡OL7AQy"^ý‹Rpg[uû¯®ò cd77ª^ =@  FYFY?+9?+933399310!!5!5!!ªüþBþ ´ÁéÆýQþ¼Õ¶6@ ! $ ?3?393333933339104춯463"&5ƒ}~‚ÂôcKäêJdôÂW\ïXR>™}áFDþÕ¼" #± þÕDFâ}šÇþ/¢·?/93103#ÇÛÛø!Rþ¼¶"6@ $#$?3?39333393333910#566554675&'4&'523"R½§cKvsãJd§¾Q{…}ƒ-pr5âDG+ Vk "¼+FDá5snþ TTïRaX'9}7@  /32}/3333333993310"56323267#"&'&B7}6g™IKb5~6e›BxZƒ C6çm 7@9çm%8uþÓ^&@  TY "??+39333103!#"&54632¨ô3þ¦^ZVS[]QT\^ü1%TVXRQYXÿìËD@#  OYOY??99//99++9939333210%$753&&#"3267#3þ\ÑÓ²¦…ZH|>ytíR„dŠ²°;ú¦ž Aë$§«þ¹-þ= ¼RjËX@,   QY NYOY?+?+99/3+39939933399102&#"!!!!56655#53546¼ÃÃ]sNTwþ‰—ÎûègM²²åËRæ@YSÁÛªNþüø,rd‘ÛÃÉÙqþ!ª'<@"  "() %/3Æ2993Â291047'76327'#"''7&732654&#"¼6“[ji[–55}’_esT}‘6ÏmPQoqONoÓf_“57Ynk\}‘}33{‘}]hMonNPnp‰¶q@8   RY RY  ??39/3+3Æ29+333339339933399310!3#3#!5#535#53!H9þÃöööþá÷÷÷¾þ‡<\Zý²Š²ÝݲŠ²ëÇþ/¢#@ ?/99//9333103#3#ÇÛÛÛÛüÑþüÑjÿì)-8U@* ."'39:6611**%%KYKY?+?+993333993333333910467&54632&&#"#"'53254&&'&&7654&'yH=…߶ªÁRDNQJcr£š}>?ïÉË’QÆFÂ%ZP·Šß‚tNe…%5%Oƒ(T•ƒžT¾ 3.01J-@©m±S(iJ”¯OÏ)9u'03"J‹Ch.9YD^1OøÅ  @   /33393Ì2104632#"&%4632#"&K@BKLA@K“Q?^\X9 6@   /33333/39333333310!5!3!!#5!Ûþ}ƒÛƒþ}Ûþ}á¢Û…þ{ÛþþßÛÛ/J¾Ë(@   ?39?399333310!576654&#"'632!¾ýyàf90(Qc{“½‰ž^i`J¨ÛdY2&(X˜…uU–u_;9¶É%>@    &' # !?3?39/399933933910#"'53254&##532654&#"'6632šª^h°º‚”{XNp\SQ23/T9e>—g¢á7 nOy‹F¾Zk55 49&2&(/>€LÙ!@ @ €/Í93É210567!L¬?V4ûGÙÈe4Í2 þ¨^?@   GY ??+99??33339339103265!#'##"&'!!ÑX^~r1ç+*xX>h þÏ1Ñyy­Äû¢–UU.,UþÀJqþü/@ MY/3/+9/93Ä2910####"&563!¡¦¢>TØËÚè\þüPù°3úûþu)Ó} @   TY/+33104632#"&uZVS[]QT\ÓTVXRQYXÿÛþ¢4@      ?33/99|/9339310#"'53254'73¢—žND[H¦NÁJXú€r¨>Sš=e\JH¶ *@    ??3939339910#77'%3Hî0Nm-¿J¾p_$*=ë9ðáÇ @  ?3Ä2993310#"&5463232654&#"á·Ÿ™¹³£˜ºþ#AHH??HHA\«Áŧ©ÂŦdeeddccR^š Z@*       /3339/33393333333Ö2Á233Á23310'7'7šþÛþêÛsþþÛþêÛs#þ;w\\wþ9þ;w\\wþ9ÿÿ.’¶&{Ò'É<œý· ³?55ÿÿ.´¶&{Ò'Étöý·²?5ÿÿZ°É&u'<ºý· ³-?55=þy×^'F@$"() %%TY% OY#?+?+3/_^]3939333103267#"&54676655#"&54632ÉYlm9WYO´`fb÷jÜûa_5(ZVS[]QT\^JbŽMNX?9J:*Ý8EÁ©lžiFJ=;VTVXRQYXÿÿ…s&$CR³&+5ÿÿ…s&$vÑR³&+5ÿÿ…s&$KVR³&+5ÿÿ…`&$RVR³&+5ÿÿ…V&$jVR ´#&+55ÿÿ… &$PuX ³#?55%¶o@<  LY LY      LYLY?+??+399//_^]++3333393339310!!!!!!!!!!#%ü—þ–þÅ–ýÍýò3ûz\þ¤¶þþ¿þþ‡`NÿÿwþÑË&&zÿÿ¸s&(Cÿ·R³&+5ÿÿ¸s&(v\R³&+5ÿÿ¯s&(KÿõR³&+5ÿÿ¸V&(jÿùR ´!&+55ÿÿ*Ûs&,CþÞR³&+5ÿÿB.s&,vÿ¡R³&+5ÿÿÿÜAs&,Kÿ"R³&+5ÿÿ9çV&,jÿ"R ´!&+55/u¶ H@$    LY  LY LY?+?+9/3+333333333103! !!#%4&##3#3 /‰ËfŒþeþ|þb‰ÐÒ£ííƒÂRdþ†þ­þ—þ€Tèïþšþþ¬ÿÿ¸É`&1RÓR³&+5ÿÿwÿìçs&2CuR³&+5ÿÿwÿìçs&2vFR³&+5ÿÿwÿìçs&2KÃR³#&+5ÿÿwÿìç`&2RÃR³&+5ÿÿwÿìçV&2jÃR ´+&+55 š @  /2229333107'¬þÕ˜-1™þÏ-•þÏþÓ–Ó-šþÕ+–þÏþј-þÕ˜wÿ¦ç"9@  #$! LY !LY?+?+9999339910!"''7&!27&#"4'3 çþ˜þ°Å‹Z¢ZÆiQÆ’T XÂûÕ8úTi¹¼æ3þ LhsÝþ•þzA‡lˆÂƒmF}hƒÂþ†¿tô-ùõ´uý'ÿÿ®ÿì^s&8C+R³&+5ÿÿ®ÿì^s&8vR³&+5ÿÿ®ÿì^s&8KšR³ &+5ÿÿ®ÿì^V&8jšR ´(&+55ÿÿþs&<vR³&+5¸ª¶ 6@  MY MY  ??99//++33333310!#!!3232654&##ªþãþú™þÊ6²þ ýDd‘Žˆ|åøþÛ¶åîþdt‚þÏ%ô&Ù@aL:0*4([bzN¬®"ò$2{)3<*HwQ@j17P.^þ;þyxHN‹ !´œR¥¥ÿÿþ&\jÜ ´,&+55ÿÿ…þ&$MXR³&+5ÿÿVÿì;¬&DM ³&&+5ÿÿ…}&$NVR³&+5ÿÿVÿì;+&DN ³&&+5ÿÿþ…¼&$Q{ÿÿVþLu&DQ¬ÿÿwÿìÑs&&v R³&+5ÿÿ\ÿìü!&Fvo³&+5ÿÿwÿìÑs&&KªR³$&+5ÿÿ\ÿì!&FKï³#&+5ÿÿwÿìÑf&&OÙR³&+5ÿÿ\ÿìÝ&FO;³&+5ÿÿwÿìÑs&&L¬R³&+5ÿÿ\ÿì!&FL³&+5ÿÿ¸us&'LhR³&+5ÿÿ\ÿì%&G8oÿÿ/u¶’\ÿì (`@1  *&) #GYJYGY?+??99//3+3+993333333399910"323&55!5!5!3##'#'26754&#"øÀÜÆàl©5 þÅ;2››ø@ hLnie…oSd  TPƒe3Ç¡¡ÇûT‘¥ó{–°Š©•–ÿÿ¸þ&(Mÿ÷R³&+5ÿÿ\ÿìb¬&HMû³&+5ÿÿ¸}&(NÿêR³&+5ÿÿ\ÿìb+&HN³&+5ÿÿ¸I&(O/5³&+5ÿÿ\ÿìb&HO?³#&+5ÿÿ¸þ¶&(Q5ÿÿ\þ(bs&HQ?ÿÿ¯s&(LÿõR³&+5ÿÿ\ÿìb!&HL³!&+5ÿÿwÿì's&*K¸R³(&+5ÿÿþm!&JKܳN&+5ÿÿwÿì'}&*N¾R³&+5ÿÿþm+&JNâ³D&+5ÿÿwÿì'f&*OüR³"&+5ÿÿþm&JO³H&+5ÿÿwþ;'Ë&*9ÿÿþm!&J:Z³E&+5ÿÿ¸fs&+K R³&+5ÿÿ ¨ª&KK5‰ ´## ?Þ5¶Q@( LY     ?3?399//33333+333333333333103#!!!#535!!5!5!f¹¹þËý½þʸ¸6C5þËý½ôÇûÓwý‰-ÇÂÂÂýô´¨T@*  GY JY    ?3?99//3+3+9333333933910!!4#"!#535!!!3632¨þÏ´sþÏœœ1;þÅfÞÅÊPò¯Âþ/¬Ç¡¡ÇS¶¤ÒÇÿÿÿñ.`&,Rÿ"R³&+5ÿÿÿ›Ø&óRþ̳&+5ÿÿ?åþ&,Mÿ$R³&+5ÿÿÿé¬&óMþγ&+5ÿÿ}&,Nÿ$R³&+5ÿÿÿ¯Â+&óNþ̳&+5ÿÿBþÛ¶&,Qwÿÿ+þß&LQ!ÿÿBÛf&,OTR³&+5 Ñ^·??3310!!!ÑþÏ1^ÿÿBþR ¶&,-ÿÿ“þ)&LMJÿÿÿhþR s&-KþêR³&+5ÿÿÿ}þç!&7Kþȳ&+5ÿÿ¸þ;P¶&.9œÿÿ þ;ö&N9u ö^A@    ??39393?333333293107!!!!Ï:EþHÓþ¤þÆþÏ1Fªnþý¢ªZþ°^þÛ¡Rÿÿ¸?s&/vÿ¿R³&+5ÿÿ ô¬&Ovÿg‹ ´ ?Þ5ÿÿ¸þ;?¶&/9Jÿÿcþ;Ñ&O9ÿÿÿ¸?·&/8uÿ£² ?5ÿÿ …&O8Ïÿÿ¸?¶&/O/ýpÿÿ —&OO¸ý8?¶ E@!       LY?+?993993993333333103'7!7!¸Eq¶6uþüQì)ÄoÀýüXÄžþXÿ¤ K@#    ??99//33933333999999107!'7!éFu»þÏGq¸1¢+ÅpýhÝ+Åp-ÿÿ¸És&1vDR³&+5ÿÿ ¨!&Qvª³&+5ÿÿ¸þ;ɶ&19øÿÿ þ;¨s&Q9uÿÿ¸És&1LîR³&+5ÿÿ ¨!&QLN³&+5ÿÿ¢¶'Qúí¸þRɶH@#   LY'?+3?33?39932933999910"'3267#!!3'&5!ørS]Imv üþ þë‡{ñþR[SNþÛ}ýP¶ü…—mçúJÏß þ¨sA@!  GYGY?+3???+933933910"'53254#"!336632=kM;<{´€rþÏé)2°tÃʼþðªðÛ«Æýò^OUÓÇü®³Àÿÿwÿìçþ&2MÃR³&+5ÿÿ\ÿ올&RM ³&+5ÿÿwÿìç}&2NÅR³&+5ÿÿ\ÿì˜+&RN ³&+5ÿÿwÿìçs&2SBR ´(&+55ÿÿ\ÿì˜!&RS{ ´,&+55wÿìPÍ#e@6  %$LY   LY  LY LYLY?+?+?+?+9/_^]+333339333310!!# !2!!!!!"3267&&Pü—&Ž-þÁþ°S>=„#dýÍýò3û¸¦¬¬¤Az&#… Šikƒ þþ¿þþ‡Ëûóôù‹\ÿì{s+2p@:/0&&004 3/JY//,JY )GY FY#GY?+3+?+99?+9/+9333339399910 '#"&5!2632!326732654&#"%"!&&¦þñ•ú¢ø…pÈGïôý•…kºdQ½ûfm{zkl{zlê^| Âu››Œ±-OMœþòî”*.ì'(E¦ª©§¦¦¥Âsyo}ÿÿ¸Hs&5v‘R³ &+5ÿÿ “!&Uv³&+5ÿÿ¸þ;H¶&59´ÿÿcþ;ws&U9ÿÿÿ¸Hs&5L3R³&+5ÿÿS¸!&UL™³&+5ÿÿ^ÿìs&6vNR³0&+5ÿÿ\ÿì¬!&Vv ³.&+5ÿÿ^ÿìs&6KÿêR³5&+5ÿÿ\ÿìÂ!&VK£³3&+5ÿÿ^þË&6zbÿÿ\þ¬s&Vz-ÿÿ^ÿìs&6LÿêR³-&+5ÿÿ\ÿìÌ!&VL­³+&+5ÿÿ)þ;y¶&79)ÿÿ/þ;7L&W9Îÿÿ)ys&7LÿæR³ &+5ÿÿ/ÿìÄ(&W8²?5)y¶F@#   LYLY ??9/3+3+39333339910!!#53!!!3#ìþÊøøþsPþs÷÷Tþbþþþžþ/ÿì7L]@/     FY JY GY?+?3Á9/3+3+39933399333910%27#"&55#535#5773!!!!wPp4•Iºª’¨XÃ9þÇþêIß#㶼”ÆÁfìîåÁÆ”A>ÿÿ®ÿì^`&8RœR³&+5ÿÿšÿì¢&XR1³&+5ÿÿ®ÿì^þ&8MšR³&+5ÿÿšÿ좬&XM/³&+5ÿÿ®ÿì^}&8NšR³&+5ÿÿšÿì¢+&XN1³&+5ÿÿ®ÿì^&8P¸R ´&+55ÿÿšÿ좲&XPN ´&+55ÿÿ®ÿì^s&8SR ´%&+55ÿÿšÿìÕ!&XS¼ ´'&+55ÿÿ®þ^¶&8QHÿÿšþ¢^&XQøÿÿ¼s&:KqR³+&+5ÿÿÅ!&ZK³+&+5ÿÿþs&<KR³&+5ÿÿþ!&\Kܳ$&+5ÿÿþV&<jR ´&+55ÿÿ1qs&=vNR³&+5ÿÿ7ª!&]v³&+5ÿÿ1qf&=OR³&+5ÿÿ7ª&]O¶³&+5ÿÿ1qs&=LÿñR³&+5ÿÿ7¸!&]L™³&+5 ? "@  GY??+333310"!4632&Pþϼ͞xG\-‰û\°¿°/àÅþ/ËI@$   FYGYGY?+Ä+9/3+39333333910#"'5325#5754632&#"3#é¼°kM;;}¨¨¯Â–pHR?määy±Âðªq“RR½²/à‰Få…ª!-w@;! "(@ ((  /.LY +!%?3?3Ì9Î2239/+333393393Ê293É2999910!!!&54632&'5667!4&#"366¾/öþ´jýélþ´ô+ˆpm1fVDpL.jV·l6**7V&2¶U>úÝJþ¶#:Wn€ü-!æEGÄþ¿‹*x t7þÛ-33-\3Vÿì;ª",8D~@?'(#,##3--9?3??  ""FE,66'<0B@ KY FYFY??+3?+9/+Ü2ÞÌ39333392993Ê293É210!'##"&5467754#"'63232655667!#"&546324&#"326f;M£ƒ¡¹ùû®†µeÁëáðþÑv…‚”jþË.jV¤€ÏŽppˆ‡qnž6**710*6˜aK¸ª²© 1ªQÎeÄÈýXZze/*x iDþÅl„€nl„i-33--44ÿÿ%s&ˆv R³&+5ÿÿVÿìþ!&¨vѳA&+5ÿÿwÿ¦çs&šv1R³+&+5ÿÿ\ÿ´˜!&ºv{³,&+5ÿÿ^þ;Ë&69ûÿÿ\þ;¬s&V9ȺÙ! *@  €/2Í2933333310&'#567!TMN—˽Ce™HÙ]SQ_½p4³FºÙ!*@   € /3Í2933333310!&&'5367Tþ›lwË“RT–!T§2/ƒ{]SWYÙÁ¬¶/39É10!!¦ýZ¬ÓãÙö+ &@ @o€ /3Í]293Ê210#"&'3327ö ܦ®Ïª/UUÎ+š¸¶œ/6}“é߶ /39É10432#"“¦¦SS¦••GOT×J²  @   /33/]39310#"&546324&#"326JŽppˆ‡qnž6**600*6Çl„€nl„i-33--44 þ · ?3/9910327#"&54673Ý-#7o- äJì‹8-ÉlÙU¯)5È6Àm+·Q×ÙD^@  /Í93É210667!#×5 Nm²ø6ÜTº³ºøã´ 2@  ! /333Ì999393É23104632#"&%432#"&'667!#ºG:9JJ9:G#ƒ9JJ9+5ÿÿu'Ó{Bÿÿÿ‘õ'(TýÆÿ— ·2>+5ÿÿÿõõ'+TýÆÿ— ·2>+5ÿÿÿ×õ',üTýÆÿ— ·2>+5ÿÿÿÆÿì9õ&2RTýïÿ— ·2 >+5ÿÿÿˆõ'<Tý±ÿ— · 2 >+5ÿÿÿÆlõ&vZTýïÿ— ·$2$$>+5ÿÿÿÉÿì´&†Uÿ µ"&+555ÿÿ…¼$ÿÿ¸ô¶%¸T¶@LY??+33310!!TýšþʶÿûJ¶ÿÿ9 ¼(ÿÿ¸¶(ÿÿ1q¶=ÿÿ¸f¶+wÿìçÍG@% LY   LY LY?+?+9/_^]+33333310!5! ! 32654&#"3ýø¼þ˜þ°þ°þ˜iQQeûÏ¿º½¼¼»»Àfþþ‰þ•þz†mmþ|þ”òûûòòüûÿÿBÛ¶,ÿÿ¸P¶.3¶ /@  LY ?3?+333393310!!!&&š 3 þëþÇðRñþÇþï <²>Þ)ü“¶úJoðÿÿ¸Ó¶0ÿÿ¸É¶1R?¶ C@#  LY    LY LY?+?+9/_^]+33333310!!!!!ÍøýRœüdÄüwþ=þüHÿÿÿwÿìçÍ2¸=¶#@ LY?3?+333310!!!!!=þËýæþÊ…´ûL¶ÿÿ¸ª¶3Ny¶S@)      LY  LY?+99?+93993339939310355!!"'63!N×þ5ãþJ3°Æþ#ð-Ïô Ëíþ þ=ýô ÿÿÿ)y¶7ÿÿþ¶<\ÿì…Ë"+V@+""+ -',+ +MY! $$MY    ??99//3+33+333339333331032654&##5#"$546$335!32###"33ü¡·ª“)þéºþè¡·55¶¡þèºþé)“ª´¤¼©“ˆ¥ûÇრ›ù´´ù› þúƒá9¤‰¬ÿÿV¶;m–¶@@  MY ??339/3+33333933310!#!# !33!3265!–þÖþÓ3þê3þÏþÛ"–²®š#×þçþöþL´ ãþ!Œüø‘”ã7Í W@+  " !  LY  LY?3+3?+993333333333993310"!!&54$3 !!654&%µÄ„†ýs˜¥«<Ñ?y¦›vý}‹„ÅËÜÈËýHþé]AƸ–þ²þçÆþÄ`þüHÈÇÛÿÿ9çV&,jÿ"R ´!&+55ÿÿþV&<jR ´&+55ÿÿ\ÿì^&~T1³3&+5ÿÿNÿì%^&‚T%³/&+5ÿÿ þ¨^&„Tw³&+5ÿÿ ÿì^&†Tÿ ³&+5ÿÿÿî¼´&’UD µ*&+555\ÿìq *K@&)", +GY%HY%) GY ?+93+?+9?3333339910%26754&#""323673327#"&'#ovko{×kÍéóÚv™2+ü 'T [pv"nß³ ´œþ¬¥¥ó00TT^7aûhþÈv ð MZ§ þ)X@," '' +*"##"GY## GY GY?+?+9/+9?333393339102#"'!4$"32654&##532654&¶ë˜¼¹þûäÈ~þÏöÝ0Œ<€|…H5cnnй•­Á®Òò?ýé4à÷îþúüú'|pnsòmf\dþ‹^<@  ??33333333939310!47!3667!‹þ½8,þV=¤B9¤=þc-6þV„Rþ>òI,åYüû´tþç\ÿì˜)k@5!!$+$*$$!''GY!!   FY?+3?99323+9933333993393910&54632&&#"!"$5464&'326åíñÕoÑy\¬XIJŠŠ¸­þæþ÷ôþÛÁC_i{‡xioz–—¿£-B×-76.6iF^ö þýþïøÒ¶ðþ]–:#µ~e}ˆNÿì%s&b@2## ('&&JY& &&   FY FY ?+?+999/_^]+933333933910#"!267! $54675&54632&&#"3H¨’“ gÜY¬þúþöþç€ÕþêséX^wŠMqn…°ÓAH}-)ôM¥¤k† 1ј.&Ý026B7\þ…ò P@' " ! !FY"??+99339333333399310!6654&'$4%#!5!òŠþÍEOOfþH43þÞVÉþø…'IgA¦ž%•Á]›/ )M~Ѧü ߶§þÖþç“JZ5 !} þ¨s2@  GY  ????+93393310!4&#"!336632¨þÏV^€rþÏé)3³rÃÊþyyy«Æýò^QSÓÇ\ÿì–+ ?@ FY FY  FY?+?+9/+33333310! ! 267!"!&&–þóþîþ÷þî  ýáukþ7iyln Æi þkþu›…—ˆþiü5éîëì…Õöæå ÿì^ !@   GY ?+?33910327#"&5ÑI#ã3¹¹ÿÿ ö^úÿìá!"b@2 ""$"# HY HY ??+?+393333339939393103'&&#"5632327#"&'&'#Ù#$\_24OWs£s3%L7!$r'nŒ)r+ .Î!\ZJ üF“Žüühb ì lwC…4šLþÿÿ þ¨^ws^ *@  ?2?9323393310!36!!9ÚEsf4X¿ þî^ý”䙌+ÿþþµ \þ…ò.e@2%&&))#  ##0/!++/JY &" JY ?+33?9/+9333339933339333104675&5467##5!#"33#"!6654&'&&\’‰Û‡™ÍC$K¹ë“¦¨­š/aˆ¦žŠþÍEOOfÙ߶~¿6 4Êk% ßÒ‰u_RÒ{{GU5!}f•Á]›/ )&Úÿÿ\ÿì˜sRÿì¢^B@!  FY GY?+??+333339933910%27#"&5!!#57!#C?)6–þ®þÏé²×ì6Û#Û¤£Bü‹uƒféýÊ31yþ–s/@  GY GY?+??+3333310#"'#!32%"32654&–õÚšþÍÿ›ì‚ýñqj+t#ã3¹¹fåÿî¼^-@  GY?+?333333310 !32654&'!‘þýÿ2ir}r+3(þï `ý–’ºËkÖ·ívþÆþÊ\þúw #P@)## %$FY FY"  ??3+3?393?+33339333104&#"66$5474632Õ^Z9@‰¨ý´þíþænxÝZJÖºá•þñ²Nœ§Oaýú Ìüaà#ö›’zÏyþê4¹×þÜû«þû›þ ÿÏþÉm X@,"!  HYHY?+3??+3?93333333339333102!327#"&'!&&#"56ðZrP)J3þ9ÃF=14Un}Ÿ4hþÆþ»ö†F88;rm3q{Ýíýþ%@5 Fý•u`F>ôþFA@   FY ??3+3?3?33339333106654!!$!ð°PNþÓþ×þåþÞþÜ#€£úÇ¥³à<þçþúþîþÒþ&Ú !3ýÅ­“ ;mÿì{^'?@ %%) (! FY?3+33?39/333393910"&'##"47!3265!3265!¸zœ) .›wÖì0@%}c`SLLT^d}%@1îiind.š¡þúþѤ¬t†'þÙ‡s©£3¢þþ›þùþÔÿÿ ÿì&†jþõ ´#&+55ÿÿÿî¼&’j' ´+&+55ÿÿ\ÿì˜^&RTB³"&+5ÿÿÿî¼^&’TN³&+5ÿÿmÿì{^&–T5³0&+5ÿÿ¸V&(jÿñR ´!&+55)ÿî¶R@*   LYLYMY?+??+39/+3339392910"'3266554&#!!!!!!2mtWcI62S_þ°þËþ‘ZþJ\ä÷Í&+D7YGý^´þþþðνÑÙÿÿ¸Ts&av…R³&+5wÿì#Ë?@  LYLY LY?+?+9/+33339910"!!327# 4$32'&JªÖ yý… ɼ«ójÍzþ¨þ”²Mâ‚ÝloWŽÉ¿ªþ²ÂMþü(#ƒjãW¸70ü%<ÿÿ^ÿìË6ÿÿBÛ¶,ÿÿ9çV&,jÿ"R ´!&+55ÿÿÿhþRî¶-ÿꢶ#Q@* %$#LY LYLYLY?+?+?+9/+33399333103 !!!'"'5326!32654&##ús'þÚþàþiþÝ>_¶›T@:35>7[ X^ƒƒ£H…èÔäå´†þþc¨þaW ûHefc[¸¨¶R@*   LY LY LY?+??39/+Ä+33333933310!!!!!!!3 32654&##¨þÚþàþiþ#þÊ6Ý5s'ýX^„‡ HÉäåwý‰¶ýÃ=ýÏèþaefeY)¶F@#   LY LY ?3?+39/+333933910!4&#!!!!!!2ÏFPþ”þËþ‘ZþJÐæYGý^´þþþðѺýçÿÿ¸`s&´vøR³&+5ÿÿÿì9‘&½6^R³&+5¸þV=¶ 2@  LY'??3+?333339310!!!!!!!=þTþÕþR65þVª¶ûL´ÿÿ…¼$¸¾¶ ?@  LY LY LY?+?+9/+333339103 !!!!32654&##îz8ý¤þVœýšh’”´O…èÔþ7¶ÿüHefeYÿÿ¸ô¶%ÿÿ¸T¶a þVô¶ Q@(     ' LY LY?+?+33?33333939393103!3!!!! q‘¨)TÃþÕülþÕÉ •];"COûLýTªþV^åþͲÿÿ¸¶(‹¶T@(       ?33?339333333332333393333310!!!!!!þ?Ù!Ù@þþ´þþßþþ´ø¾ý<Äý<ÄýBýåýåý^ÿì×Ë&J@% !(!'MY $$MY$ MY ?+?+9/+93339933910! '3 54&##532654&#"'6$32ªÈ«É×þ¹þßþ¾Ã^ýnqíè‰{èÔ……ÎÀ‡}«ï`¸¶’ÊêO-3×ahòXfKYwÏSMȸݶ,@  ?2?39933339910!3!!4#!¸ £sþìýZþ‹¶ý>½×VúJ¾û ÿÿ¸Ý‘&²6üR³&+5¸`¶ 4@    ?3?39333233333310!!!!!`þ ýîþÊ6 Jýëåý¶ý<ÄýBÿê=¶1@  LY LY??+?+3339310!!!'"'5326!=þËþš>_¶›T@:35>7[ ›´†þþc¨þaW ÿÿ¸Ó¶0ÿÿ¸f¶+ÿÿwÿìçÍ2ÿÿ¸=¶nÿÿ¸ª¶3ÿÿwÿìÑË&ÿÿ)y¶7ÿì9¶E@!    LY?+?39333393939310#"'3267!379þ@    LY '??+33?33/3333339310!!3!!!!!ìÆ5ÚþÕù"6Æ8´´û@ý`ª¶ûL´úJu¶ A@!  LY LY LY?+?+9/+33393310!!!!3 32654&##uþÏþÕþVþ‘¤{8ý/h’”³PÉäå´ýÏèþaefeY¸‡¶ A@   LY LY?+?39/+?333339310!!!3 32654&##!! þÑþ×þp6d5ýNQ™Ž‰¬C™þË5Éäå¶ýÏéþbeffXýy¶¸¾¶ 2@ LY LY?+?9/+3333310!!!3 32654&##¾ý¤þV6z8ý0h’”´OÉþ7¶ýÏèþaefeYHÿì×ËI@&  LY    LY LY?+?+9/_^]+33333910"'63 !"'3267!5!&&)c¿]bèÿEcþ“þ¨íÃó«¿É ý†xÀÉ8'úgþqþþ–þ}KMººþª¿¸ÿìÍQ@+    LY LY    LY?+??9/_^]+?+3333393310! !!!!! 3 4&#"þ¯þÅþßþ´þèþÊ6"I<Nü+¨¡L¥£¤©Ýþ˜þwM>ý‰¶ýÃ!3þxþ˜ôùíôúúÿöš¶ Q@(   MY LY  ?3?+9/+933339339310!&&54$!!!#"33¤þªþ¨ |„ ÜþÊ™x„€„‘1ýσ2ÑŽÉÙúJ1‡VdapÿÿVÿì;uD\ÿìž%#D@"% !!$ FYGYHY?+?+9/+933333310%6%36632! 2#"\%7—,#‚þµ~|=5®dÏæþÝÿÿþá1ÙÄ6kY‚ž5(þö1P”{RXýìþðþÓox+#2Q)Ë× Ë^ N@'" !JY JY  JY ?+?+9/+93333393910#!!24&##3264#!326¨qnw‹ÿîýÃ=æåþçffòøae¢ÿÝad9Z‡c£«^•ý•B;þøIfÝ8 ¤^@FY??+33310!!¤þ-þÏ^åü‡^þo1^I@%   FY # FY ?+33?3?+333399339310%#!!!36!3\åWMwþîýþî^`‚¤ßšºþ²’ý‘þop•Æ$üÿÿ\ÿìbsHü^R@'      ?33?339333333223333393333310!!!!!!ðŽ;þdÃþºþVþäþVþºÃþd;?ýáýèýº7ýÉ7ýÉFNÿì#s(L@&'  #*)('('JY((  FY FY ?+?+9/+933399339102654&#"'6632# '532654&##5¶­‘jzMÃPZwàŠÑü߉u„ú©þè–VÍ`•”œ¢v°8=66&!Õ-' ‰½9 "}efžVEü(.C>DAÓ #^ ,@     ?3?39932339910!!47!ÇoþÙýþþ’^þFFþðû¢¾wÙüò^ÿÿ #?&Ò6–³&+5 ô^ 6@   ?3?39333233333310!!!!}PþEâþ¦þ7þÏ1^ýèýº7ýÉ^ýáÿì‰^5@  FY  HY??+3?+3339310!!!#"'5326!‰þÏþç \™|jD119M=Nyþ‰þ¥ ô¤O !^:@     ?33?3993323393310!!#&''!!>!!þã6+ÆÙÉ+1þä¤À3 !%,± q>Ólþ ønÇDü^þ#MÈG–ƒn² ¬^ 3@  FY   ?3?39/+33333310!!!!!Ѫ1þÏþVþÏ^þR®û¢Íþ3^ÿÿ\ÿì˜sR ˜^#@ FY?3?+333310!!!˜þÎþkþÏ^û¢yü‡^ÿÿ þ´sSÿÿ\ÿìÝsF/=^(@ FY??+3339310!!!5=þ’þÏþ‘^åü‡yåÿÿþ^\\þ'P@( ! FY FY ??3+3?3+3?333393333310!$54%!4&'66Ñ>þÆþäþåþåþÁ4&ýÅš†ŸX–‡…˜dþÔò÷þ×þä/îý%°ü± ¸‡„µýd²ÿÿ –^[ þod^ 4@   FY#??+3?333339310%3!!!!!Á£þîüN1¾2ßý‘^ü‡y{ ^-@ FY  ??39/+33333103267!!#"&5¬‡X—M1þÏj¶U·È^þg’( ãû¢¼8.»­  !^ 5@  FY?+3?3333339310!!!!!!!!ù1w1w1^ü‡yü‡y þoÅ^>@    FY#??+33?33/3333339310%3!!!!!!!!¤þíùî1w1w1 ßý‘^ü‡yü‡yû¢f^ A@!  JY FY JY?+?+9/+333933103 !!!54&##32–×÷þýëþœ5ghÐÔË^þP¤¦þœyåýA:þø -^ C@! JY JY?+?39/+?3333393103 #!!4&##32!!Ñ“ööõþ11Xhg‰ËþÏ1®¤¦±³^ýA:þøÓ^ ¢^ 2@ JYJY?+?9/+33333103 !!!4&##32Ñ×øþýì1 hgÑÕË®¤¦þœ^ýA:þøJÿì¼s?@   JY FYFY?+?+9/+33333910"'53267!5!&&#"'663 ¢Ò†®™nx þZ¦kdwVK½^þñEîP€€Ë{|?Ñ#-þäþäþÜþÕ ÿì¨sI@&   GY FY  GY?+??9/+?+3333393310#"$'#!!36$3232654&#"¨þêöÝþ÷ÉþÏ1ÍÖíý%bqobcpob1þíþÎøéþ3^þRÖíþÉþõ§©©§§¥¦^ M@&     JYJY ?3?+9/+933339329310!!&&5463!!#33#"Jþ¶-loóÒþϨÉnYªÑKUº-ªs¢¸û¢ bFOIÿÿ\ÿìb&Hj ´1&+55þ¨&j@6$$$('' GYJY  GY?+3??99//3+3+93333399339910"'53254&#"!#535!!!3632=kM;<{^VsþÏœœ1;þÅfÞÅʼþðª²nn¯Âþ/¬Ç¡¡ÇS¶¤ÒÇüë³Àÿÿ ª!&Ív³&+5\ÿìðsA@! JY FYFY?+?+9/+333339910 !2&#"!!3267þêþå!¸­Xªkis¥þ[ngOŸfŽ#* JÙAz}˃}$,êIÿÿ\ÿì¬sVÿÿ“ßLÿÿÿå“&ójþÎ ´&+55ÿÿÿ}þßMÿìÓ^Q@* ! JYFY HYJY?+?+?+9/+3339933310!##"'5326!32!4&##32-î \™|jD119M=#Žøïþ°ba…¿yþ‰þ¥ ô¤OþP¤¦þœ`A:þø Ó^Q@)   FYJY JY ?3+?39/+Å+3333393331032!!!!!!!4&##32^Žøïþþ;þ¤þÏ1\1Dba…¿®¤¦þœÍþ3^þR®ýA:þø¨V@+   GY JY    ?3?99//3+3+9333339933910!!4#"!#535!!!3632¨þÏ´sþÏœœ1;þÅfÞÅÊPò¯Âþ/¬Ç¡¡ÇS¶¤ÒÇÿÿ ô!&Ôv®³&+5ÿÿþ?&\6û³&+5 þoÁ^ 6@   #FY?+3?3?333393103!!!!! 1¾2þxþî^ü‡yû¢þo‘¸}ì#@ LY??Æ+333310!!!!!îþʹ ýq¶6ýÊ Ï#@ FY??Æ+333310!!!!!ÑþÏþ^1ýêÿÿ¼s&:CüR³&&+5ÿÿÅ!&ZC‡³&&+5ÿÿ¼s&:vºR³&&+5ÿÿÅ!&Zvd³&&+5ÿÿ¼V&:joR ´3&+55ÿÿÅ&Zjþ ´3&+55ÿÿþs&<Cÿ|R³&+5ÿÿþ!&\CÿY³&+5R´®šµ/333105!R\´ææR´®šµ/333105!R\´ææR´®šµ/333105!R\´ææÿüþ1NÿÓ @  /39/3233310!5!5!5!Nü®Rü®Rþ1‹Œ‹Á¤¶@  ?Í33Â210'673'e5ÛB#Á[qþõêÁ¤¶@ ?Æ33Â210#7–2~ÛE¶Åþæ(Í?þøËî@ /Í33Â210%#7!Ë4|ÜA$×Êþë ìÁ¤¶@  ?Í33Â210#&'7?%@Û;a¶õÿ UÁw¶%@  ?3Í233Â2Ô2Â210673!%673!ìe5ÛB#þèþe5ÛB#þè×[qþõê[qþõêÁw¶ #@    ?3Æ233Â2Ô2Â210#7!#7!¤2~ÛEá2~ÛE Åþæ(ÍÅþæ(Í?þøžî "@    /3Æ233Â2Ô2Â210%#7!#7!Ë4|ÜA$â4|ÜA$×Êþë ìÊþë ì{¦ N@%     ??9/3339933339333993310%!5!%¦þ´7þê7þÉ777L üB¾ñ¡þ_{º}@>           ??99//3339933333993333339333933333310%%!5'75!%%oKþµ7þé8þ´L//þ´L87Kþµ/-òþ‡yòåÕñxþˆñÕb® ) ¶ /Í93104632#"&b”‹‰–—ˆŠ•욣¤™˜¦¦uÿåb9 #,@ $ TY! ?33+3333Ô2Ä21074632#"&%4632#"&%4632#"&uZVS[\RT\GZWS[\RU\HZVS[\RT\TVXRO[YQTVXRO[YQTVXRO[Y?ÿî Ë "-7BCd@1.>8388E D)###C5 @+1;& ?3Ä2???333Ä223/33À29333À29333À2103254#"#"&5!2%#3254#"#"&5!23254#"#"&5!2;-2``2-»²¬¥´Y©µ°üÕð+…-2``2-»²¬¥´Y©µP,2``2,º°®¤´X©µý5}üú{}æçíàÉíØúJ¶ü}üú{}åçíßÉíÞ}üú{}äèíßÉíýjÿÿ…¦œ¶ ÿÿ…¦B¶R^ 0@/39/39333333Á210RsÛþéÛþ=Çwþ¤þ¤wÅR^ 0@/39/393333Á23310'7 þÛþêÛs#þ;w\\wþ9ÿÿuÿå¶'Hþw‘¶@ ??33Á210#‘üÕï+¶úJ¶fü Ç*@     ??39Ä299339104&#"#3363 D<9ZHÇ¢IŽü‘L@`qþ´ºTeúþ/#'¶V@+  RYNY NY ??+9/+9/3+333333333910!!!#53!!!!é<þÄþÏ••oýÂý縲þú²þþþ°þRjË%y@=  " &' ! RY !RYNYOY?+?+99/3+3Æ2+3993399333333939102&&#"!!!!!!5667#535#53546Á¾Ã]NƒEPLgþ™gþ—FJÎûèdK²²²²äËRæ#VVq°s²Jl'þüø*jU²s°sÎÔ¸ÿìé¶)q@< #''% + +*QY NY&#&QY#!PY # # #NY??+99//3++3+?+3339339933391032654&##!#!! 27#"&5#5773!!ÙB‹~ˆTþÏþç5þßuðNSaŠ£–’¨XšþðHhumhÊìúýø¶åûú#Ï3¦­>lgëíÑþÍGD==DG>ýZ§¾¶­ud7f@IIŒtZO¶úJ¶û¢¬ÀĨªÁǤdeeddcc8¸ª²¹2›)f_¾+¤-)ÿîßÉ$F@ "  %&""   /3/9/93399399333339310%2673#"&5556746324#"66+5X9Z@-       /33333Ä22323333399392910'7#5!7!5!3!!1ÉYêPPþ`ƒÉ\íþ®O¡¢þíT¿ÛªÙVÃÙªÛV9= :@     /2/9/339333333331035!5VáüáýT¬ÛÛ¶ïïþÂþèX9= 6@    /2/39/39333333331035! 5Xáü¬ýTáüÛÛø>ïþþJXPÁ B@    ??9333993393333310#3Pþ=rþ=Ãr»ôôôßý!ßâýšþfþgÿÿ)ø&ILÿÿ)ê&IOhÙ3? @  /3Í293Ê210#"&'!32673ôæíãYsec ?»«¤ÂgS[_ÿ}þÑ^ !@  GY?+3?33310"'53265!FuTFIMG1ÎþðVTªû)²Á^Ͷ@  ?É93É210667!#^'PV²ç1¼@°ƒ^þ;¶ÿƒ@  /Í93É210667!#^'K[²þV1¼@¨ŒNÙ¦!@  €/Í93Á210!5673¦'þæNX²1¼@ª‰)5ßË  @   !?3?399331032654&#"!"&5!2%-12..21-ºþ¢¤´X©µ}|€{{}þ3íàÉí Jö¼ B@     ??9/3392999333399310##5!533!547ö}îþì}þ• 5á——šAýͤVbl¿T9˶L@$  !?3?39/3393993939393102#"'53254&#"'!!6¯¾·žd2…7¬WQ?8m%þœ8•€‘ 4À *ƒ?@+¸¸‡-5Ù×8@   !?3?39/39993399310#"&5%366322654&#"Ù¯›žÄ#C¯¶ YJt„þ¨;><9Dm¨¿¢¤¢5„W+/ŒþôG?6DjBT;J׶(@ ??399939310!5!šTþMœþ¿J´¸•ý)-5ÛË!-F@!%+%+  ./ (( !"?2?393939933993399102#"&5467&54632654'"6654&…¨CLKB#¿—¡·GW®:9;<…eu+-4&&2*Ëyi?d+*=I,u•ŒxAj.Y~hzýn-99-Q,,£/)22+/+9ÕÉ"2@ #$ !?3?39/3999339210#"'53267##"&54632%"32654&ÕöçI613Œ‹G~zŠ¶”¤¼þ¬5B8;7FD3þü¼pƒb”ƒ‰ªÕ#GA7A?+CSTþÁî #'+/37;?CGS[kt|‰ @‡@<0A=1 NTcpp``ll€zggv„vkkH„HX„‡‡XT E)% D($  Š‹‚}}kduullvvkVKKkk\ ZQQ…t\\ -  $1'2D=G>(A+B BA>=21 , 84 95!/333333333/3339333333333333339/333/39/3/339/393/399333333333933939332933333333333310!#%5!#533!5353!5!!5!5!#3#35!#35!35!#35#3#3#"&546323254#"%32##32654&##32654#"'53253T/ÀÎ0mùoÀÃmýIûáþò·mmmmûÂü0ooÀwú¨ooooþmmûŸ‡‡‡~ˆþs‡‡‡‡á¬mp.,;0m^Ï{B.$*/;J1%Z^4+V}i¾0oÁÁoþÐÁù/ÂmmÂþÑmmmmþooú¨ú;mm¦Jooooü/yýhI‘œœ‘’›š“ÅÅÄaCS1D D8QYb" "ãš+%Jþú fV’þr_cTþÁª*X@)%  +, (("""//99//3333/9933999939333210 54676654&#"63232654&#"þ¬üTüVë,AgI»¥OºGR Z?>1HT;GFBIHCHEüVüW©û/2A1R~X‡š8*²P:/5K6DpJ;þí?HI>@IHÿÿÿ}þé!&7Lþʳ&+5ÿÿÁ¤¶)ÿìž)6v@="4 1 1*..((6  78GY44 **FY11FY1%FY?+?+9/+339/+9933939399333310&&#"!"&54654&#"'63232655'&$&546323ß‹e;FÏöþÃþÎÛÛ *0L•˜Zga\‘“àþÈ¢áÅñ,’ß©¼89r€ç+-þ®þœ¥¦5i+*¶V^X?†GKOæ÷!tÑŒ¡¿þÛþÛåÃF@"   MY?+3??9333333393310>32&#"!!}>xhu_UB,(5C¶6þÌþPTˆõ°Bå +'`þœŽýÕ/‡3ÿìË^(l@5 ##  * )!!  FY &FY?3+39?+339/3339939393993310"'##"547!57!!4'!32655!326FíS RîÝå?þú®êþþ?å3@ü >\gTLLTg\ÒÒü²ÑfåѲüþò©ÔÉ°–‘s‡‰‰‡sÿÿ¸Óu&0vÃT³&+5ÿÿ B!&Pvî³,&+5ÿÿý¨…¼&$[sÿÿVý¨;u&D[ÿÿþrÿì9Í&2R\ýùXý¨Nÿƒ  @  /39/393Ì210#"&546324&#"326NŽppˆ‡qnž6**600*6þ˜l„€nl„i-33--44yh+Ç1@ ?Æ2ÔÄ9393Â9Ð2Á210467#"&767!#y˜IE%-%?BCJZ**¥‰òRpJ%%-J'C“W^Õÿÿ)&I'IL/ÿÿ)&I'IO/wÿì×H@#     LY @ LY?+?Î+993/3393339910! ! 65!3 !"çþ˜þ°þ°þ˜jRZ²]-$Ž{=ûÕº¹sþ¹¼¢Ýþ•þz†mkƒË=Õ±É2ŸÖõøíîùü.\ÿìÍ"#H@# $#   GY@ GY?+?Î+993/3393339910!"&5!265!32654&#"˜þàþÿ¡ö„pÈG•-WŽi4üûm{zkl{zla1þïþÌ°0EE-ð†k}š¦ª©§¦¦¥ý(®ÿì)9@  @LY?+?Î39/3/333Â23310665!# 5!3265^JF- k¶Š‘þî»þæþÈ5˜˜‰ã¶¼–jš§gý¢ô‚!û®üiœ“™˜•úJšÿìsJ@%  @KY GY??+9?3Æ9/+/3393Ê23310!'##"&5!3265!665!3¸)0³sÅÈ1V^€r1GN- l·Ž MVÓÆÙýsyy«Æu“tœ¨füÏÿÿüÙþW!CúÊÿÿüÐÙÿ!vû„ÿÿûà×ÿRûüÙÃþ ¤· /ÉÌ23910#'6654&#"56632þ ¢ ®K6*"AJi)Œ‹Ïœ)G“ 3% "¨ oüÙþRþ%ÿ}±/É10432#"üÙ¦¦TR¦þç––GNÿÿ¸s&(CÿzR³&+5ÿÿ¸Ýs&²CTR³&+5ÿÿ\ÿìb!&HC©³$&+5ÿÿ #!&ÒC ³&+5wÿì=É2b@1++((00 4#3))  MY-&&LY ?3+39?3+3339/33339393310"'663 !"&'# !2&&#"327!3254&þ'ZDl@°K )þ¸þÖt²MM®tþ×þ·) J¯BlD[&€Žº°SU6Hl°¸Ó!-×1<þŠþ­þ‰þcHKKHœxRw:3×-!óâûþ÷EŒþtE ûáôÅ^U@)      ?2?33?3993333939339993310!!367!36!!‘þu@Â! g]4ÈÐþ^ýdS’lý”䛓"þýÞÌ}þƒO@(  MY LY   LY?+?99//+3+3333333339103 !!!5!5!!32654&##5{8ý¤þVÿ5yþ‡i’”´PdßèÔþ7dæÊÊæüšefeY'J@&  FYJY JY?+?Æ39/++3333333339103 !!!5!5!!4&##323×øþýëþþ1g9hgÑÕËyˤ¦þœyåÉÉåýçA:þø¸ÿìRË"U@,!$#LYLY! LY ?+??9/3+3?+333399339910!3267# #!!3!2&&#"!fýš ЪaÁrhÉwþÅþÎþÊ6×,|$æÛdZ´W£ÐdwµÔ(%þü(#N=ý‰¶ýÃ:gü':®¢ ÿìs W@- " ! FY  FY FY?+??9/3+3?+333393339910"$'#!!36$32&#"!!327ÅðþòÝþÏ1Ýé[¿MVxdk¦þZ ts˜°ˆòïþ3^þRáâ,$Ñ?qpã€~PîE×¼ E@#     MY  ?33?39/+3333999222210!#!#!!!'ªÑdþïfÏþÑ-{/üu9† wý‰wý‰¼úDdYE4^ L@%    JY  ?33?39/+3333393333999910#!#!!!!'&'bNþøP—þÛ×oÙþÛþ #H¦þZ¦þZ^û¢uPœW]¸ ¼t@9     LY  ?3333?9/+3393?3333339/39333399999910!#!#!!!!!!!'&'ÝÑdþðgÏþÑðþËþÊ6—Û{/üu93\ wý‰wý‰wý‰¶ýÃCúDd‰î'4 7^x@;  FY   ?3333??39/+339333339/339333399999910#!#!!!!!!!3&'oBþøB¦þÜÂþÍþø‘·nÙþÛþ#ê`Ëþ5Ëþ5Íþ3^þR®û¢šÚDI)F¶„@B    LY MY ?22?9/33+39333+93333393339393393931036675!!&&'!!)˜:¨„þ‰þ‡¨9˜þÈ{)TCþÍGV({×þþųº$Õ‹‹þ+%¿­þ;|dýqe{þ{9ç^„@B    JY JY ?22?9/33+39333+93333393339393393931036675!!&&'!7!u(}[þß4þÛYy*tþþ^8/þø6<^h´þšZ} mjjþ‘ {þ¦'MB þ?à DNþÙ®á¸m¶"#©@V"  ! % $#% " "LYMY LY   ?333??9/39/++39333+93Ä3333233933393933939310!67!!!!5!!&&'!!P—,3þ¨þÊ6Cþ¦þ‡¨9˜þÈ{)TCþÍGV({×þþýÅÅ3ý‰¶ýò‹‹þ+%¿­þ;|dýqe{þ{9ûL ö^"#¨@U"  ! % $#% " "JYJY FY  ?333??9/9/+3+39333+93Ä3333233933393933939310!67!!!!5!!&&'!7!#u þÓþøÏÿ3þÛYz)uþþ^ÃJ0>]_¨¸·Ÿ¸Ëþ¯þØ\b)‘YhšŒZ6µï²Íìÿìíè‰{èÔ……ϾˆS·w`ƒÑ6›NWeð— š"¸€Œ¹·‘Éë')X)嬓­œenahòXfKYwÏ6Lwƒ(›dN.þ/#dLª@Y4* 99 GEECCIIIB@ *0N?@@**M?{H3"6TJ~†ihoþÜþñlaKYUON0ˆV4D³|±±æí„„œ¢vp­‘jzMÃPZA>]WÄ9˜RVcd˜ o"a_{ "}e¨²'44*)噚¯¥@ADAÓ8=66&!Õ! l_)šfL-ÿÿm–¶uÿÿþF•wÿìçÍ ?@ LY LY  LY?+?+9/+33339910! ! 267!"!&&çþ˜þ°þ°þ˜iQQeýH£½ý·¬žºà·Ýþ•þz†mmþ|ü§À½´ÉÛ®®©³\ÿì˜s ?@ JY GY GY?+?+9/+33333310!"&5!2267!"!&&˜þàþÿ¡ö„¡ö„ýãapþ>ndbpÂm1þïþÌ°0Œþúþttttœqppq¦ÃA@  LY ?3??+933333393310"!!67>32&B.@*þ˜þ®þ9!+6ª7\xVtF3ÁGvûü¶üs ‹€««œK'òÑf@@    GY ??+?3933333393310!367>32&#"!?Í2 ,{3LkULH+' 3þÌþÉ^ýŽ£Oo|XŽj1ì,7üòÿÿ¦s&€v'R ´)&+55ÿÿÑ!&vË ´*&+55wþ Í".k@7  0)0#/ ,LY &LY  MY ?2?+3?393?+?+33Ä222333939310!367!#"'532677! ! 326&#"NÓ  ÏGþ'Añ¡NM7AQy"ýÚþ¶þºþ¼þµLECKü ¤¬­£¡­¯£^ý‹Rpg[uû¯®ò cd7Õþþ‚{xxvþ‡þ‰þÿìåéî\þ )s"0k@7  2##2**1- GY-&GY&  GY ?2?+3?393?+?+33Ä222333939310!367!#"'53267732654&#"!"&5!2œMÓ  ÏHþ'Añ¡MO9@Qy"û;m{zkl{zlþàþÿ¡ö„¡ö„^ý‹Kwg[uû¯®ò cd7)¦ª©§¦¦¥§þïþÌ°0Œþúwÿƒ91(P@*#'  !!* )#' 'LY@ LY?3É+3?É3+3333393910#"'$%66326632$%#"'9þÓþâ#qvþáþÏ.$D=5H1û}Ž‹E0-Eþí'ff)þëÝþ¿þ‚(ss$FC{&<2,B&þ„þ¼Æò%**J“ŽMKKM\ÿ‘´+T@, $$** !!- ,'$**FY@ FY ?3É+33?É3+33333393910#"&'&54763266326654&'#"&'ïæ H69G ßòóænjàýüž99+>SOPI>=6D–1ëþà&5:;6'%ãí#!RR"þÛêþò>'+!3±~‚¥/816Awÿì=1GY @PLO=þŠþ­þ‰þcGRKNœxRw>/×-!óâøþðpcenöáôAÂ6) 3;1bt6&-&þ³]ŒV:5:Z\ÿìÃR)@R¤@RDH54MH+AAHH# (##TS@,AHHEPEDDP,P,P15511;@   FY (@FY&?2+Ê39?3+333Ì23/99//9/393333339333933ØÊ2910 32&&#"3273265#"'632!"'#"'&&#"#54>32356654.54632fþþþøìõ•|V?B%ºwl’‚‚“mvº'A>V|”öìþúþû­|z&´ˆg2.+ ¶":fT:pw…Nþþ¶2B%,%NGNT)&<Ñ þª²º‡‡»±VÑ<þâþæþÝþÔppíÂ6) 4;2Ee>$&-&þ²^‹V ;4:Ywÿì=B2@@H?<;4788;;++((00 B#A4??@95=<8<<@@))  MY-&&LY ?3+39?3+3339/Î23É2293333393933Ê2Ê2310"'663 !"&'# !2&&#"327!3254&#'##'##'5þ'ZDX<›P )þ¸þÖk²TM°tþ×þ·) QšþŠþ­þ‰þcGRKNœxRw>/×-!óâûþ÷J‡þƒT ûáôoY¬gggg¬YŤ*‡@A  )&%!""%%    ,+))&#''"&&* ?223?33Î23333933333939339993393Ê2Ê29910!!366!36!!#'##'##'5 þf@Â% ¥‹?É j`4Çßþã…˜'R71š171š17P^ýƒov6œuý”>?;—Š/þŒýÿéþ¤X¬ffff¬Xwþ#Ë3@  LYLY?+?+?3339310 4$32&&#"!267!Zþ™þ„²Mâáêe[¹ZÃמ:³Nþ˃jãW¸gü':þúìþý\þðs3@ GYGY?+?+?3339310&!2&#"327!Züþþ!¸­X­h~rw}ƒþÏ* PèB©©œ¬%ý hÿúy ¶?/9910%'%7%7%LGþã´´þåFÆþäG¶¶Jþå°¦{¤þÇJ;¤{¤Z¤}¤9IþĤ{¤´{ÅÍ @  /É3È93É210#"&543!632#‹6083mË bm69Ù+3G8u^s9Hô× @  /Ì29/39Ê2102>32#&&#"##5N…wp:in?¶ +.IJ†·œ%-&6ua1;47ÃÍÃX$@  /Ì39393È9102&&546oGN%-%D1~·UX:5 : V‰`MYËÃX$@ /3Ì9393È91056654.54632¶0E%-%NGNT²^‹V ; 5:Y)þÁÁ‘ (6DR_mš@JP4,H,,ck:&B&&^ k^VkVnod^WjgS``gIA;O7EE>LLZ-%3))"00ZZgg  /3Ê2/3Ê29/39/333Ê2229/333Ê22233Ê22299È93È293È2È93È2102#&&#"#62#&&#"#662#&&#"#66!2#&&#"#662#&&#"#66!2#&&#"#662#&&#"#6!2#&&#"#66é]qOb@3/2),!$6::$,2?@ #037;(++;3# /3/393333339993333333210#6736673#&'5&&'5'766'677'&&&'7BF$a5‹ÑIa4‹¼GÈAÝûZB¿OÝìE±xbC¾ûE±xb›˜C{LbR×C‚&b'Z1B¿OݦGÈAÜ‚þ!Ia5‹ÑF$a5‹ÝDnXb'XúüDnXbYîFÆcbŒûxF2Ã4bE¸þV+‘!"[@-! #  " LY  '!?2Þ2Í2??993+/33Á293339993Â210!3!!!!4#!#"&'!3267¸ £sN²þ¨¼þìýZþ‹wôæíãYsce {¶ý>½×VûTýLª¾û ‘»«¤ÂgS[_øo þoN? !_@/  "  ! @  FY  #??+??399Þ2Í2/33Á293339993À210!!!!47!#"&&'!3267Ço+’þÞ‰þÙýþþ’)óæ¡Ëg  Yqgd^þFFþðüý‘¾wÙüò^ὩJ–†lN_[ùÁ/¾¶N@( LY  LY  LY ?+?99//3+3+33333333910!!3 !!#535!32654&##î+þÕz8ý¤þV‰‰6h’”´OþœèÔþ7!þ—ûHefeY¢P@) JYJYJY??+9/39/++33333333391035!!!3 !!#4&##32œ1yþ‡×øþýìœmhgÑÕË5ßßÆþ?¤¦þœoüñA:þø¸ª¶u@;    LY LY  ??9/Ê2++99399399333393293999910'##!! 37'7654&##ª_]X˜sVr…þÊÓ ýD‘:šR)wîÉ>}p¤ýø¶åþ5Rou5Zmh þ´s(@A!"$"##&&* )!$##"&"&GY GY?Ê2+???99+9939939933992393393999910"'#!336632'"337'7654&ÅpþÏø+6¢cÆà‘^žl4—qhktf§ReŒþ;J‘SSþÎþðþÑ {v‹“‹ !´œ{dNl¥¥/P¶ A@   LY  LY ??+9/3+3333333910!!!!#53Pýž‘þoþʉ‰¶þþšþý¬Tþd¾^ A@   FY  GY ??+9/3+3333333910!!!!#53¾þLþ´þω‰^øÙëþ^¢ëѸþy¶U@+  LY LY LY??+9/+?+393333393910"!!!632#"&'32654&m5Jþʘýžk•Á1™‹û™n‹J…‹¢æ ýô¶þþo ªþÑÍÃþס/Í°ÄÈ þ ‰^Y@-  HYGY  HY?+3??+9/+93333339910%#"'3265!"!!!632‰zà“Žr-y1t}þÅ*.þÏ1þJKžûŠD³þþ…3£—1þ^øñ ŒþüþV¶n@6   LY  '?33??39333333+3/333333333933333910!!!!!#!!!þ?Ù!Ù@þR=þÕ¨þþßþþ´‹ø¾ý<Äý<ÄýBþýLªåýåýþoX^i@4    FY  #??+?3?33933333/333333393333333910!!!!#!!!ðŽ;þd þîþVþäþVþºÃþd;š?ýáýèþ™ý‘7ýÉ7ýÉFû¢ÿÿ^þ×Ë&±žÿÿNþ#s&Ñ1¸þVã¶J@$    LY'??33+?3933/333333233910!!#!!!œGþÕ¸ýîþÊ6 Jýë1 ýLªåý¶ý<ÄýBý þo5^M@&    FY#??+3??3933/333333233910!3!#!!}PþE)úþî‰þ7þÏ1#^ýèþ™ý‘7ýÉ^ýáýÁ¸P¶a@/      ?3?93333233393333339999910!!773!!#j|þÊ6z†Xþþ ÿ†dZýö¶ýc¬bºGýyüќޠË^U@)        ?2?39333333Ê2233333999910!737!!#'! c‘¸<þEâþº×‘aþä^ýá{<éýèýº °dyýÉ%¶`@/      LY ?33?9/3+3393933333333322931035!3#7!!!#‰6‰‰zŒXþþ þƒþʉ/‡‡þþè¬ñýyüÑh^ýö1öh@3    JY ??9/3+3?39393333333933339931035!!!37!!!#œ1;þÅ…9XþD×þ þ¾ƒþÏœs¡¡Çþ²þªTþý‡Åiþ¤¬Ý¶Q@'     LY?+3?3939333333Ä2339910!7!!!!{{‹Xþþ þƒþËþº¶ýc¬ñýyüÑh^ýö´ûL^ F@"   FY?+??3933Ä23333333310!!!!!¬;þFáþ»þ7þãþœÄ^ýáýèýº7ýÉyü‡¸þV‘¶F@#    LY  LY '??3+?39/+/3333333310!!!!!!!!f+þÕþËý½þÊ6C5¹ ýLªwý‰¶ýÃ=úJ þoÁ^G@$   FY  FY #??+??39/+/3333333310!!!!!!!Ѫ1þíþÍþVþϬ^þR®üý‘Íþ3^û¢¸¬¶ B@!   LY  LY ?3??+9/+/333333310!!!!!!!¬þºþËý½þÊ6C{´ûLwý‰¶ýÃ=úJ ^ A@    FY FY?+?39/+?/333333310!!!!!!Ѫ•þœþÏþVþϬ^þR®åü‡Íþ3^û¢¸þš¶ ]@/ "!LYLY LY ?+3?3?+9/+933333933910632#"&'32654&#"!!!!s¦¹"’‹û™m‡P…ƒªÕå:bþËþþÊ\#«þÓÎÃþס/Õ¨ÄÈýü´ûL¶ þ Õ^]@/@   HYFY  HY?+3?3?+9/+9333339Ê3310%#"'32654&##!!!!72Õyà•Žr-y1s›–þÏþ‰þÏÙP—ñ„D³ÿ‡3£—•œþ‡yü‡^þþýwÿ¬úÍ)4z@? 22/*/$$**65$/*/*,2',MY'LY 22!LY MY ?Ä++3399?+?+993333333993933310327#"'# !2&# 327&&546324#"66Íbq.BLD>t­‘h’þÊþE>8’.N\Nþ¶È±?MÇ¿»Ðþëp7>8&=J¦÷pñb"†W}‡ðþæûLó}Úãòßé{jz¯18¹\ÿ¸ús*3Ž@H" 220+0%%+++54+%0+0.2(.FY((GY 22 ""  GY JY ?Ä+3+3/399?+9/+9933333339393933310327#"'#"32&#"327&&546324&#"6ÝVN*;@HT“b†íþåù*y0CX8ohol *¦¥˜²ñ,-ZLgüvº4ÓV"74䦸˜¨OM§±¹¥9Hƒ~W@ÿÿwþÑË&&9ÿÿ\þÝs&F )þVy¶ 6@  LYLY'??+?+393333310!!!!!!ì+þÕþÊþsPþs ýLª´þþ/þo=^ :@   FY FY#??+?+333933310!!!!!5=þ’þîþÏþ‘^åýfý‘yåÿÿþ¶<þ˜^5@  ??33?33333933310!!367!åþÍþNP° $"²NþMþì^þI<´`øû¢þ¶^@.   LY  ??39/3939+33333933339910!!!!!!5!1Nþ?þÁþÌþÁ?þP\Züƒ)þþþò‡þ˜^L@%    FY??33+3?33339939333310!!!!5!!367!þÝþÍþÝ#þNP° $"²NþMåþùå^þI<´`øû¢þVɶ^@.      LY'??3+3?39333/33332993239333910!!#!!!¤%þÕªþ¬þ¬þ´åþ:V;5Nþ5î ýLª)ý×òÄýòý+ý þo^g@3    FY  #?3??+39333?/33333399339399910!!!!#!!3…þ˜ZÙÛZþ”çþîµëìþ¦Œ ;#þœdýÝþ¤ý‘þ)þVH¶K@%@  ' LY LY?+?3+39/?333993Ê310!!!!!!!!˜þ‘;þi6+þÕ´þþüN´ûTýLª/þo7^D@"   FY FY  #??+3?3+3333993Â310!!!!!!#5…þÙ–1þîüþ^åýlyüý‘yåmþVF¶@@   LY  LY'??+?39/+/333333310!!!#"&5!3267!+þÕþÊšÍ]Ñã5buR£w6¸ ýLª54&ɶ\ýüjk!)úJ{þo²^@@  FY FY #??+?39/+/3333333103267!!!!#"&5¬‡X—M1þîþÏj¶U·ÈÄ^þg’( ãüý‘¼8.»­ û¢m¶J@$    LY?3?9/333+3933333933310#"&5!367!!#q((Ñã5bm…Y–6þÊn…Ýɶ\ýüneHþ 3úJ5-þ¼{ ^J@$    FY?3?9/333+3933333933310#"&5!33367!!#F3·È1‡}N^1þÏiC}Z»­ þg’ñ)ãû¢¼6ò¸f¶+@ LY ??39/+3333310!6632!4&#"!¸6“Ö[ÎæþËbuO§vþʶýË3'Ǹý¤jk *ýq Å^-@  FY ?3?9/+3333310!4#"!!6632“‡«þÏ1j´W·È¤‡Hþ^þD8.»­þ`ÿìòÍ!(c@3% &*) $""LY%@ LY LY?+3?9/3+È3+99333333933310%2$7# #"&547333! !"!4&bŠLn}þã¬þÂþ‚?£¥5ê`)%d%\[ûÕ Ò•ŸÅ å¶î]DþêKBU6ŠztYHX8þuþ|GÁÈݳŸ°¢ÿì`s%g@5"#'&$! !  FYJY"@JY?+?9/È3+3+99393333339333106$32!3267# ' 54733%"!&&N!Ûòý•‡j»bN¾†þýþÏþ¸)Í`%^| Ãw®Ûêþó’+-ì'(òà`E75Nìsyp|þVòÍ$+}@@#$$))!( - ,$''%%LY( @LY"MY"?3+3?9/3+È3+99?3333933339939310&#"&547333! !32$7!"!4&¼öþÛ?£¥5ê`)%d%\[ûÕ Ò¼ŠLnmÖ~þןŠå¶(IŠztYHX8þuþ|GÁÈ]Dþê@> þdu³Ÿ°¢þo`s '‚@C %%$  ) ( #&##!FY JY$@  !JY?+?9/È3+3+9939?3333933339939310&&' 5473336$32!3267!"!&&ݵÑþ¸)Í`!Ûòý•‡j»b²þí…^| Ãw(øÅà`E75NÛêþó’+-ì? þ+syp|ÿÿBÛ¶,ÿÿ‹‘&°6uR³&+5ÿÿü?&Ð6/³&+5¸þ®¶X@,  !  LY MY  ??39/3+3?+33333393399310"!!7!32#"&'32654&¨KoþÊ6‘‰Xý¿È/”‹û™n‹J…ŽŸâþ¶ý@ÏñýPœþäÁÃþס/Í°ÃÉ þ ø^X@, GY  HY?+3??39/3+33333339939310%#"'32654&#"!!!2øyà•Žr-y1t~ž™2zþÏ1²Xþ'åD³ÿ‡3¥•” þ¨^þíþ þÛþV‹¶I@%  'LY LYLY?+?+?+?/333Á2939310!!!'"'5326!!!=þËþš>_¶›T@:35>7[ ›N²þ¨u´†þþc¨þaW ûTýLªþo´^N@(FY HY FY#??+?+3?+/33Á29339310%!!!!#"'5326!‰+‘þ݉þÏþç \™|jD119M=N ßý‘yþ‰þ¥ ô¤Oû¢¸þf¶C@" LY  LY?+3??39/+333333910%#"'3265!!!!!f†÷¡¿…K„R~Žý½þÊ6C5Z±þì•/Á¬úý‰¶ýÃ= þ ¬^E@"  HY FY??39/+?+3333Ä33310!!!!#"&'3267ÑþÏ1ª1þøèLv@prloÍþ3^þR®û¹÷þê :”ž¸þV´¶L@&    LY  LY '??3+?39/+/33Á293333310!!!!!!!!fN²þ¨¼þËý½þÊ6C5¹ ýLªwý‰¶ýÃ=úJ þo×^M@'    FY  FY #??+??39/+/33Á293333310!!!!!!!Ѫ1+‘þ݉þÏþVþϬ^þR®üý‘Íþ3^û¢mþV¶=@  LY  'LY?+??39/+333333310!!!3#"&5!3267!þþþÕ÷šÍ]Ñã5buR£w6þV´+4&ɶ\ýüjk!){þo ^=@  FY  # FY ?+??39/+3333333103267!!!35#"&5¬‡X—M1þüþíæj¶U·È^þg’( ãû¢þopÝ8.»­ ¸þV!¶T@*   '   LY?33+?3993?/33Á2933393310!#!!3!!!!46#!#þ  þë¦Zo¦N²þ¨¼þß þ‡L{þ¢uýX¶û¢^ûTýLª´1€û‡ þoL^U@+  FY#??+?3?3993/33Á2933393310%!!!#&''!!>!!+’þÞ‰þã6+ÆÙÉ+1þä¤À3 !%,±  ßý‘q>Ólþ ønÇDü^þ#MÈG–ƒn²û¢ÿÿBÛ¶,ÿÿ…‘&$6uR³&+5ÿÿVÿì\?&D6)³&&+5ÿÿ…V&$jVR ´#&+55ÿÿVÿì;&Djû ´8&+55ÿÿ%¶ˆÿÿVÿìþu¨ÿÿvA‘&(6R³&+5ÿÿ\ÿìb?&H6³&+5¤ÿìÍ=@ LY  LY LY?+?+9/+33333310"6$3 ! 5!&&267!3”þÁp‹£Zƒþ”þ´þ¨þ¢+ Ó•£Ã ý´Ë[G SEþnþžþžþu‡‡HÀÉü#¶›¯¢\ÿìws=@ JY  JY FY?+?+9/+33333310%267! !"55!&&#"566Zcv þ>t<6þåÿñþñè–†c¹kX¾Åvun}®þÕþïþéþÌ 𔂒&2ì,$ÿÿ¤ÿìV&ájîR ´1&+55ÿÿ\ÿìw&âjÿ ´1&+55ÿÿ‹V&°jXR ´'&+55ÿÿü&Ðj ´'&+55ÿÿ^ÿì×V&±j-R ´<&+55ÿÿNÿì#&ÑjÎ ´>&+559ÿìj¶P@( MY  MY LY?+9?+9/+33339939310!!! '32654&##hýç¿þPñþ»þ×þýÀ]ëh§¥ÐÏ{Z\Æþd ÜÄÐîO,5irf_9þV^R@) FY  GY FY?+9?+9/+33333939310!5!#"'32654&##•ý²ÇþFíúþîÁûÀ\ãež¦ÊÆvöéÆþbþà—ßxP-3‡Šƒÿÿ¸Ýþ&²MÛR³&+5ÿÿ #¬&ÒMu³&+5ÿÿ¸ÝV&²jÝR ´%&+55ÿÿ #&Òju ´#&+55ÿÿwÿìçV&2jÃR ´+&+55ÿÿ\ÿì˜&Rj ´/&+55wÿìçÍ ?@ LY LY  LY?+?+9/+33339910! ! 267!"!&&çþ˜þ°þ°þ˜iQQeýH£½ý·¬žºà·Ýþ•þz†mmþ|ü§À½´ÉÛ®®©³\ÿì˜s ?@ JY GY GY?+?+9/+33333310!"&5!2267!"!&&˜þàþÿ¡ö„¡ö„ýãapþ>ndbpÂm1þïþÌ°0ŒþúþttttœqppqÿÿwÿìçV&~jÅR ´/&+55ÿÿ\ÿì˜&j ´1&+55ÿÿHÿì×V&Çj#R ´/&+55ÿÿJÿì¼&çj— ´/&+55ÿÿÿì9þ&½M1R³&+5ÿÿþ¬&\Mܳ&+5ÿÿÿì9V&½j1R ´)&+55ÿÿþ&\jÜ ´,&+55ÿÿÿì9s&½S¸R ´&&+55ÿÿþ!&\SR ´)&+55ÿÿmV&ÁjVR ´)&+55ÿÿ{ &áj# ´(&+55¸þVT¶ /@  LY LY'??+?+3333310!!!!Týš+þÕþʶÿüTýLª¶ þo¤^ /@  FY FY#??+?+3333310!!!!¤þ-þîþÏ^åýfý‘^ÿÿ¸‡V&Åj5R ´-&+55ÿÿ -&åjú ´,&+55ÿÿ/þP¶&›€ì ·>+5ÿÿþ¾^&œ¼ ·>+5ÿÿþ²¶&;€‰±¸ÿæ´>+5ÿÿ þ ^&[㱸ÿü´>+5V¶a@1      LY?3?9/3+3399333393393333310!!!!!!!!q)þ…V;5Nþ‹'þÓžþžþ¬þ¬þ´þähNýòý²þý–)ý×j –^i@5       FY?3?9/3+33993333933939393103!!3#!!#f×þàZÙÛZþÛÙÑ.þ¥ëìþ¦+Ϩ¶þœdþJåþ=þÃ\b¶ 4@ LYLY??+9/+33333104$!3!! #"33\8{5þVý¤ÑP´“’hÉÔè1úJ‡Yefeÿÿ\ÿìqG\ÿ캶&S@)&& ( ' ##LYLY??9/+39/+3933339339104$!3!3265!#"&'#"&#"3265\* s5OVZN1ðílÁ'+®}èï¨H‰][Tb¶Ø÷1û¹BAfqþ-ÃÎN=?Jë®il`fA;\ÿìÉ ,W@- $ .*-  (GYHY!GY?+3+?+999/?333393910"323&&5!32655!#"&''26754&#"^÷þõÙÃËj 1PXWK-ëèx˜>.ÄZofjqÉb(6¤&*fûiKFfqùþÁÄÍ=L7Ró‰¢!¶šþ®¥¥ÿì Ë(R@)$ *$)MY&&!MY& LY?+?+9/3/+9333933339103265!#"&54&##53 54&#"'6!2ô¦–±¶SUYO1ðéêôùªªXkqœ™›Èæo‰À$«‘eYfqþ-ÅÌäÚjmÙÑNXdλ9ÿì\s(V@+'" * )('('JY (( HY  FY ?+?+99//9+9333933339102654&#"'663232655!#"&54&##5“ž‡erM²OZxׄËòÑí¨WK-ëäÝü’ˆš°8=66%"Õ.& ‰½9 '½zfqùþÁÅÌ™efÓþVsË[@.  !  MY MY LY  '??+?+9/+99333333933910!!!4&##53 54#"'6!2¦–±¶+þÕþÊÑȶ¶u›Ñ*ño‰À$«‘ ýLªªjmÙѦdλNþo-s"]@/" $ #!""!JY "" FY# FY ?+??+9/9+99333333939102654&#"'6632!!!4&##5²ªjzMÃPZwàŠÑüÑoþîþ×™¡¤°8=66&!Õ-' ‰½9 "}egý‘FNIÓÿê–¶!D@!   #" LY LY ?3+3?+9/3339933103265!#"&5!'"'5326!OWZN2ðêëòþÃ>_¶›T@:35>7[ rwHCfqþ-ÅÌÈÃ=†þþc¨þaW ÿìá^D@! ! FYHY ?3+3?+9/33399331032655!#"&5##"'5326!jPXWK-ëäëîú \™|jD119M=/yJCfqùþÁÅÌÈÅþ‰þ¥ ô¤O¸ÿ쪶Z@-  LY LY ?+??99//+3933333333933103265!#"&'!!!!!=IUUI1ëäæëýæþÊ65}KFfqþ-ÄÍÈÁý‰¶ýÃ= ÿì^Z@-  FY  HY?+??99//+393333333393310!!32655!#"&'5!!Ñ•2NQUI-éâçêþkþÏ^þR®ýHCfqùþÁÆËÉÂVþ3^wÿìðË@@! LYLY LY?+?9/++333393910!! 4$3 &&#"32655!5»þ¯þ»þœþ¯Mãäkr¿h½×ÙÓš®þ‹5{þšþ˜ŠgåTµkú9*þøêëþ§—\ÿìòs@@!   GYFY GY?+?9/++333393910!! !2&&#"!265!–\ý¼þæþÈE,âÄ\KµH£›“þܘ]ý±*0Vê#'§³þºtc)ÿìb¶?@  LY  LY ?+?9/+3333939103265!#"&5!!!ìKVXL1íæëîþsPþs}KFfqþ-ÅÌ˾?þþ/ÿìF^?@  FY HY?+?9/+333393910!32655!#"&'!5=þ’PXVL-ëäéîþ‘^åþKFfqùþÁÅÌÇÄåXÿìÑË(R@)% "*"")%MYLY LY?+?+9/+93333933991046632&#"33#"32$7! $54675&&…ŠúŸ°v‡ÀÎ……Õèz‰ê릪€ aÁþ¿þßþ¶Ì·Ÿ·`i§[COåwQKfXòhaga1/þíOêÊ’·¹Nÿì%s$N@'!! &%$$JY$$ FY FY ?+?+9/+93339993310#"!267! $54675&54$32&#"3H¨’“oáX¬þúþöþç€Õëoæ[R©­ã…°ÓDIy.(ôM¥¤k† 1ј,(ÕGhB7ÿÿþb¶&µ€9 ·>+5ÿÿþ®^&Õ… ·>+5ÿÿþR…¼&$gDÿÿVþR;u&DgÇÿÿ…ö&$f#R³&+5ÿÿVÿì;¤&Df˳'&+5ÿÿ…Ñ&$w!R ´&+55ÿÿVÿìþ&DwÅ ´)&+55ÿÿ…Ñ&$xR ´&+55ÿÿÿÓÿì;&DxÇ ´0&+55ÿÿ…J&$y!R ´'&+55ÿÿVÿì¨ø&DyÉ ´<&+55ÿÿ…b&$zR ´,&+55ÿÿVÿì;&DzÅ ´A&+55ÿÿþR…s&$'KXRgD ´&+5ÿÿVþR; &D&KûÿgÓ ´##&+5ÿÿ…&${)R ´&+55ÿÿVÿì;Á&D{Í ´.&+55ÿÿ…&$|'R ´ &+55ÿÿVÿì;Á&D|Ë ´5&+55ÿÿ…X&$}'R ´+&+55ÿÿVÿì;&D}Í ´@&+55ÿÿ…b&$~'R ´&+55ÿÿVÿì;&D~Í ´,&+55þR…} $!!!!&'#"&'3327432#"7jýëjþ²{ýþ“%!œF ܦ®Ïª/UUÎþ¦¦TR¦\þ¤¼úD`Ù|$€þš¸¶œ/6}÷j––GNÿÿVþR;+&D'gÉNû³/&+5ÿÿ¸þR¶&(gÛÿÿ\þRbs&HgÝÿÿ¸ö&(fÅR³&+5ÿÿ\ÿìb¤&HfÛ³ &+5ÿÿ¸`&(RÿïR³&+5ÿÿ\ÿìb&HRû³ &+5ÿÿ¸õÑ&(w¼R ´&+55ÿÿ\ÿì&HwË ´"&+55ÿÿÿÍÑ&(xÁR ´&+55ÿÿÿßÿìb&HxÓ ´)&+55ÿÿ¸›J&(y¼R ´%&+55ÿÿ\ÿìªø&HyË ´5&+55ÿÿ¸b&(z¼R ´*&+55ÿÿ\ÿìb&HzË ´:&+55ÿÿ«þRs&('KÿñRgÛ³&+5ÿÿ\þTb!&H&Kógݳ)&+5ÿÿBÛö&,fîR³&+5ÿÿu<¤&ófœ³&+5ÿÿBþRÛ¶&,gÿÿ‘þRß&Lg¸ÿÿwþRçÍ&2g°ÿÿ\þR˜s&Rgøÿÿwÿìçö&2f‘R³&+5ÿÿ\ÿ오&RfÛ³&+5ÿÿwÿìçÑ&2w…R ´&+55ÿÿ\ÿì &RwÑ ´ &+55ÿÿwÿìçÑ&2x‡R ´#&+55ÿÿÿßÿì˜&RxÓ ´'&+55ÿÿwÿìçJ&2y…R ´/&+55ÿÿ\ÿì°ø&RyÑ ´3&+55ÿÿwÿìçb&2z‡R ´4&+55ÿÿ\ÿì˜&RzÕ ´8&+55ÿÿwþRçs&2'g°KÁR³&+5ÿÿ\þR˜!&R'güK ³#&+5ÿÿwÿì×s&_vR³&+5ÿÿ\ÿìÍ!&`v}³$&+5ÿÿwÿì×s&_CdR³'&+5ÿÿ\ÿìÍ!&`C¥³,&+5ÿÿwÿì×ö&_f¦R³"&+5ÿÿ\ÿìͤ&`fç³'&+5ÿÿwÿì×`&_RËR³"&+5ÿÿ\ÿìÍ&`R³'&+5ÿÿwþR×&_g²ÿÿ\þRÍ&`gþÿÿ®þR^¶&8g‡ÿÿšþR¢^&Xgÿÿ®ÿì^ö&8f^R³&+5ÿÿšÿ좤&Xfø³&+5ÿÿ®ÿì)s&avR³&&+5ÿÿšÿìs!&bvª³ &+5ÿÿ®ÿì)s&aCR³&&+5ÿÿšÿìs!&bC£³ &+5ÿÿ®ÿì)ö&afdR³!&+5ÿÿšÿìs¤&bfþ³$&+5ÿÿ®ÿì)`&aRšR³!&+5ÿÿšÿìs&bR3³#&+5ÿÿ®þR)&ag}ÿÿšþRs&bgÿÿþRþ¶&<gþÿÿþ^&\gVÿÿþö&<fÙR³ &+5ÿÿþ¤&\f¢³&+5ÿÿþ`&<RR³ &+5ÿÿþ&\Rà³&+5ÿÿ\þ¼ &ÓBÙûÙþç! ¶ /2Í]210&&'5!!&&'5!þF>Ú"-!d)ýÑIÑ-!d)Ù1Ë7H­89È2H­8ü-Ù9 @   /3Í]29/Ì10#&'#567!'673#é¢pcra¢pg;5‡YU5ñC ˜ÙK[eA‚–N«Â[nYuû Ùÿ @  /Í]239/Í1067!#&'#7#&'53ü/pg<1~(¢arji¢X—¤@ò6Sô‚–H¤,Ae`FÃwWpYü-Ùÿßø %@ /3Í]29/Ì239310#'6654&#"5632#&'#567!!} 7B%+#%F^qÈ¢pcra¢pg;5‡`r=t Hþ)K[eA‚–N«ü1Ùÿ%)@ ! !!!/3Ý]2Ì2/39/3/310".#"#663232673#&'#567!þ7$KHC(+ q kS%MHB))q j“ŽZS•ªB0€<!1o‚$0t}þºGQJN¤`E„;ü1ÙÿÁ@   /Ý]2Ì3910673#%#"&'33267ý7F/Ý\sƒÏ ॺ–sXXr øi`naNž´¬¦WS^Lü1ÙÿÁ@   /3Ý]2Ì910#&'53%32673#"&'þƒjeÝ/FþËrY[p• ¹¤¡Ã ÝUz`i3K_WS§«³Ÿü1Ùÿ -@   /33/Ì]2393Í]210#'6654#"563232673#"&'þ126k 3';5FVdþšrY[p• ¹¤¡Ã 4A)n )hC˜K_WS§«³Ÿü1Ùÿ $+@"@ H"     /3Ý]2Æ2/3Ì+2/3103273#"&'%".#"#663232673üËjbÅ• ¸¥£Á $KHC+( q b\%MHB))q h;F’—ŸŠ1$.dy$0mp þ +@  /?39393393104&'3#"'5326ÍNF³OB#ŠpJR<7#-ã4mB54&#"'6632!?üpZ,PTT X¡‰ë‡×òz³¼ ÏmTP03@MHÆwZ° x³{Nþ¨B‡&V@-"( ""'PY |  $$OY$& OY %?+?+9/_^]+93333933910!"'32654&##532654#"'6!2¦–±¶þÎþäî¸UÌd™’¨¸oqªÐH•[Èã+‰À$«‘ÓëO+6hsgVíYl¦0;Õ¸þ¨ys F@"  PY %??39/3+3933393339910%#!!5!3!5467#y°þÄýŠ•°þ#VéþsÌŒü—Û2Û"0†%þÑdþ¨5rP@(OYNY OY%?+?+9/+33333933993102!"'3 54!"'!!76fÔûþÒþçô–OÒ^þÛ5€({7ýö#=bîÏõþøO *5èÝ BéþúþáÿÿHÿìPÇ7þ¼Pp,@NY$??+93339310!!ã%ý/ý×þ¼°ÂûÿÿHÿìJÉBþªJ…%F@# ##&'  PYOY&PY%?+?+9/+999399210!"'532667##"&5432%"32654&Jþ”þ‚CT\›Èj :˜r¿Ü æ¢ó‚ýï`lbd^†}þPþVø[ë^LõÚë˜þßÁ„|j|{Pw¤ÿÿ)Ž&IIRÝ…Á#4@@4$,+,-0&(() )200//)562&&,*$$)  0))*5-*?33/339/33/3399333/993939Ê223399333310#"'532654&'.54632&&#"##33#7#‹uoXsX-/#%lH'€r_p48<'%-*JiF‡¦¤ø ªï¨®²dq+6'#&5ÿ®7@ÿ®7Cÿq7Dÿ\7Fÿ\7Gÿ×7Hÿq7Jÿ…7ûÿ×7ýÿ×7ÿ®7ÿ®7ÿ®7ÿ…7 ÿ…7Wÿš7Xÿq7Yÿ\7_ÿ×7`ÿq7bÿš7ÿq7ÿ\7ÿq7 ÿ\7!ÿq7"ÿ\7#ÿq7%ÿq7&ÿ\7'ÿq7(ÿ\7)ÿq7*ÿ\7+ÿq7,ÿ\7-ÿq7.ÿ\7/ÿq70ÿ\71ÿq72ÿ\73ÿq74ÿ\76ÿq78ÿq7:ÿq7<ÿq7@ÿq7Bÿq7Dÿq7Iÿ×7Jÿq7Kÿ×7Lÿq7Mÿ×7Nÿq7Oÿ×7Qÿ×7Rÿq7Sÿ×7Tÿq7Uÿ×7Vÿq7Wÿ×7Xÿq7Yÿ×7Zÿq7[ÿ×7\ÿq7]ÿ×7^ÿq7_ÿ×7`ÿq7bÿš7dÿš7fÿš7hÿš7jÿš7lÿš7nÿš7pÿ×7)8ÿ×8ÿ×8$ÿì8‚ÿì8ƒÿì8„ÿì8…ÿì8†ÿì8‡ÿì8Âÿì8Äÿì8Æÿì8Cÿì8ÿ×8 ÿ×8Xÿì8ÿì8ÿì8!ÿì8#ÿì8%ÿì8'ÿì8)ÿì8+ÿì8-ÿì8/ÿì81ÿì83ÿì9ÿš9ÿš9")9$ÿ®9&ÿì9*ÿì92ÿì94ÿì9Dÿ×9Fÿ×9Gÿ×9Hÿ×9Jÿì9Pÿì9Qÿì9Rÿ×9Sÿì9Tÿ×9Uÿì9Vÿì9Xÿì9‚ÿ®9ƒÿ®9„ÿ®9…ÿ®9†ÿ®9‡ÿ®9‰ÿì9”ÿì9•ÿì9–ÿì9—ÿì9˜ÿì9šÿì9¢ÿ×9£ÿ×9¤ÿ×9¥ÿ×9¦ÿ×9§ÿ×9¨ÿ×9©ÿ×9ªÿ×9«ÿ×9¬ÿ×9­ÿ×9´ÿ×9µÿ×9¶ÿ×9·ÿ×9¸ÿ×9ºÿ×9»ÿì9¼ÿì9½ÿì9¾ÿì9Âÿ®9Ãÿ×9Äÿ®9Åÿ×9Æÿ®9Çÿ×9Èÿì9Éÿ×9Êÿì9Ëÿ×9Ìÿì9Íÿ×9Îÿì9Ïÿ×9Ñÿ×9Óÿ×9Õÿ×9×ÿ×9Ùÿ×9Ûÿ×9Ýÿ×9Þÿì9ßÿì9àÿì9áÿì9âÿì9ãÿì9äÿì9åÿì9úÿì9ÿì9ÿì9 ÿì9ÿì9ÿ×9ÿì9ÿ×9ÿì9ÿ×9ÿì9ÿ×9ÿì9ÿì9ÿì9!ÿì9+ÿì9-ÿì9/ÿì91ÿì93ÿì95ÿì9Cÿ®9Dÿ×9Fÿ×9Gÿì9Hÿ×9Jÿì9ÿš9 ÿš9Wÿì9Xÿ®9Yÿ×9_ÿì9`ÿ×9bÿì9ÿ®9ÿ×9ÿ®9 ÿ×9!ÿ®9"ÿ×9#ÿ®9%ÿ®9&ÿ×9'ÿ®9(ÿ×9)ÿ®9*ÿ×9+ÿ®9,ÿ×9-ÿ®9.ÿ×9/ÿ®90ÿ×91ÿ®92ÿ×93ÿ®94ÿ×96ÿ×98ÿ×9:ÿ×9<ÿ×9@ÿ×9Bÿ×9Dÿ×9Iÿì9Jÿ×9Kÿì9Lÿ×9Mÿì9Nÿ×9Oÿì9Qÿì9Rÿ×9Sÿì9Tÿ×9Uÿì9Vÿ×9Wÿì9Xÿ×9Yÿì9Zÿ×9[ÿì9\ÿ×9]ÿì9^ÿ×9_ÿì9`ÿ×9bÿì9dÿì9fÿì9hÿì9jÿì9lÿì9nÿì:ÿš:ÿš:"):$ÿ®:&ÿì:*ÿì:2ÿì:4ÿì:Dÿ×:Fÿ×:Gÿ×:Hÿ×:Jÿì:Pÿì:Qÿì:Rÿ×:Sÿì:Tÿ×:Uÿì:Vÿì:Xÿì:‚ÿ®:ƒÿ®:„ÿ®:…ÿ®:†ÿ®:‡ÿ®:‰ÿì:”ÿì:•ÿì:–ÿì:—ÿì:˜ÿì:šÿì:¢ÿ×:£ÿ×:¤ÿ×:¥ÿ×:¦ÿ×:§ÿ×:¨ÿ×:©ÿ×:ªÿ×:«ÿ×:¬ÿ×:­ÿ×:´ÿ×:µÿ×:¶ÿ×:·ÿ×:¸ÿ×:ºÿ×:»ÿì:¼ÿì:½ÿì:¾ÿì:Âÿ®:Ãÿ×:Äÿ®:Åÿ×:Æÿ®:Çÿ×:Èÿì:Éÿ×:Êÿì:Ëÿ×:Ìÿì:Íÿ×:Îÿì:Ïÿ×:Ñÿ×:Óÿ×:Õÿ×:×ÿ×:Ùÿ×:Ûÿ×:Ýÿ×:Þÿì:ßÿì:àÿì:áÿì:âÿì:ãÿì:äÿì:åÿì:úÿì:ÿì:ÿì: ÿì:ÿì:ÿ×:ÿì:ÿ×:ÿì:ÿ×:ÿì:ÿ×:ÿì:ÿì:ÿì:!ÿì:+ÿì:-ÿì:/ÿì:1ÿì:3ÿì:5ÿì:Cÿ®:Dÿ×:Fÿ×:Gÿì:Hÿ×:Jÿì:ÿš: ÿš:Wÿì:Xÿ®:Yÿ×:_ÿì:`ÿ×:bÿì:ÿ®:ÿ×:ÿ®: ÿ×:!ÿ®:"ÿ×:#ÿ®:%ÿ®:&ÿ×:'ÿ®:(ÿ×:)ÿ®:*ÿ×:+ÿ®:,ÿ×:-ÿ®:.ÿ×:/ÿ®:0ÿ×:1ÿ®:2ÿ×:3ÿ®:4ÿ×:6ÿ×:8ÿ×::ÿ×:<ÿ×:@ÿ×:Bÿ×:Dÿ×:Iÿì:Jÿ×:Kÿì:Lÿ×:Mÿì:Nÿ×:Oÿì:Qÿì:Rÿ×:Sÿì:Tÿ×:Uÿì:Vÿ×:Wÿì:Xÿ×:Yÿì:Zÿ×:[ÿì:\ÿ×:]ÿì:^ÿ×:_ÿì:`ÿ×:bÿì:dÿì:fÿì:hÿì:jÿì:lÿì:nÿì;&ÿ×;*ÿ×;2ÿ×;4ÿ×;‰ÿ×;”ÿ×;•ÿ×;–ÿ×;—ÿ×;˜ÿ×;šÿ×;Èÿ×;Êÿ×;Ìÿ×;Îÿ×;Þÿ×;àÿ×;âÿ×;äÿ×;ÿ×;ÿ×;ÿ×;ÿ×;Gÿ×;_ÿ×;Iÿ×;Kÿ×;Mÿ×;Oÿ×;Qÿ×;Sÿ×;Uÿ×;Wÿ×;Yÿ×;[ÿ×;]ÿ×;_ÿ×<ÿ…<ÿ…<")<$ÿ…<&ÿ×<*ÿ×<2ÿ×<4ÿ×<Dÿš<Fÿš<Gÿš<Hÿš<Jÿ×<PÿÃ<QÿÃ<Rÿš<SÿÃ<Tÿš<UÿÃ<Vÿ®<XÿÃ<]ÿ×<‚ÿ…<ƒÿ…<„ÿ…<…ÿ…<†ÿ…<‡ÿ…<‰ÿ×<”ÿ×<•ÿ×<–ÿ×<—ÿ×<˜ÿ×<šÿ×<¢ÿš<£ÿš<¤ÿš<¥ÿš<¦ÿš<§ÿš<¨ÿš<©ÿš<ªÿš<«ÿš<¬ÿš<­ÿš<´ÿš<µÿš<¶ÿš<·ÿš<¸ÿš<ºÿš<»ÿÃ<¼ÿÃ<½ÿÃ<¾ÿÃ<Âÿ…<Ãÿš<Äÿ…<Åÿš<Æÿ…<Çÿš<Èÿ×<Éÿš<Êÿ×<Ëÿš<Ìÿ×<Íÿš<Îÿ×<Ïÿš<Ñÿš<Óÿš<Õÿš<×ÿš<Ùÿš<Ûÿš<Ýÿš<Þÿ×<ßÿ×<àÿ×<áÿ×<âÿ×<ãÿ×<äÿ×<åÿ×<úÿÃ<ÿÃ<ÿÃ< ÿÃ<ÿ×<ÿš<ÿ×<ÿš<ÿ×<ÿš<ÿ×<ÿš<ÿÃ<ÿÃ<ÿ®<!ÿ®<+ÿÃ<-ÿÃ</ÿÃ<1ÿÃ<3ÿÃ<5ÿÃ<<ÿ×<>ÿ×<@ÿ×<Cÿ…<Dÿš<Fÿš<Gÿ×<Hÿš<Jÿ®<ÿ…< ÿ…<WÿÃ<Xÿ…<Yÿš<_ÿ×<`ÿš<bÿÃ<ÿ…<ÿš<ÿ…< ÿš<!ÿ…<"ÿš<#ÿ…<%ÿ…<&ÿš<'ÿ…<(ÿš<)ÿ…<*ÿš<+ÿ…<,ÿš<-ÿ…<.ÿš</ÿ…<0ÿš<1ÿ…<2ÿš<3ÿ…<4ÿš<6ÿš<8ÿš<:ÿš<<ÿš<@ÿš<Bÿš<Dÿš<Iÿ×<Jÿš<Kÿ×<Lÿš<Mÿ×<Nÿš<Oÿ×<Qÿ×<Rÿš<Sÿ×<Tÿš<Uÿ×<Vÿš<Wÿ×<Xÿš<Yÿ×<Zÿš<[ÿ×<\ÿš<]ÿ×<^ÿš<_ÿ×<`ÿš<bÿÃ<dÿÃ<fÿÃ<hÿÃ<jÿÃ<lÿÃ<nÿÃ=&ÿì=*ÿì=2ÿì=4ÿì=‰ÿì=”ÿì=•ÿì=–ÿì=—ÿì=˜ÿì=šÿì=Èÿì=Êÿì=Ìÿì=Îÿì=Þÿì=àÿì=âÿì=äÿì=ÿì=ÿì=ÿì=ÿì=Gÿì=_ÿì=Iÿì=Kÿì=Mÿì=Oÿì=Qÿì=Sÿì=Uÿì=Wÿì=Yÿì=[ÿì=]ÿì=_ÿì>-¸DÿìD ÿìDÿìD ÿìEÿìE ÿìEYÿ×EZÿ×E[ÿ×E\ÿ×E]ÿìE¿ÿ×E7ÿ×E<ÿìE>ÿìE@ÿìEûÿ×Eýÿ×EÿìE ÿìEpÿ×F)F )F)F )HÿìH ÿìHYÿ×HZÿ×H[ÿ×H\ÿ×H]ÿìH¿ÿ×H7ÿ×H<ÿìH>ÿìH@ÿìHûÿ×Hýÿ×HÿìH ÿìHpÿ×I{I {I{I {KÿìK ÿìKÿìK ÿìNFÿ×NGÿ×NHÿ×NRÿ×NTÿ×N¢ÿ×N©ÿ×Nªÿ×N«ÿ×N¬ÿ×N­ÿ×N´ÿ×Nµÿ×N¶ÿ×N·ÿ×N¸ÿ×Nºÿ×NÉÿ×NËÿ×NÍÿ×NÏÿ×NÑÿ×NÓÿ×NÕÿ×N×ÿ×NÙÿ×NÛÿ×NÝÿ×Nÿ×Nÿ×Nÿ×Nÿ×NHÿ×N`ÿ×N6ÿ×N8ÿ×N:ÿ×N<ÿ×N@ÿ×NBÿ×NDÿ×NJÿ×NLÿ×NNÿ×NRÿ×NTÿ×NVÿ×NXÿ×NZÿ×N\ÿ×N^ÿ×N`ÿ×PÿìP ÿìPÿìP ÿìQÿìQ ÿìQÿìQ ÿìRÿìR ÿìRYÿ×RZÿ×R[ÿ×R\ÿ×R]ÿìR¿ÿ×R7ÿ×R<ÿìR>ÿìR@ÿìRûÿ×Rýÿ×RÿìR ÿìRpÿ×SÿìS ÿìSYÿ×SZÿ×S[ÿ×S\ÿ×S]ÿìS¿ÿ×S7ÿ×S<ÿìS>ÿìS@ÿìSûÿ×Sýÿ×SÿìS ÿìSpÿ×URU RUDÿ×UFÿ×UGÿ×UHÿ×UJÿìURÿ×UTÿ×U¢ÿ×U£ÿ×U¤ÿ×U¥ÿ×U¦ÿ×U§ÿ×U¨ÿ×U©ÿ×Uªÿ×U«ÿ×U¬ÿ×U­ÿ×U´ÿ×Uµÿ×U¶ÿ×U·ÿ×U¸ÿ×Uºÿ×UÃÿ×UÅÿ×UÇÿ×UÉÿ×UËÿ×UÍÿ×UÏÿ×UÑÿ×UÓÿ×UÕÿ×U×ÿ×UÙÿ×UÛÿ×UÝÿ×UßÿìUáÿìUãÿìUåÿìUÿ×Uÿ×Uÿ×Uÿ×UDÿ×UFÿ×UHÿ×URU RUYÿ×U`ÿ×Uÿ×U ÿ×U"ÿ×U&ÿ×U(ÿ×U*ÿ×U,ÿ×U.ÿ×U0ÿ×U2ÿ×U4ÿ×U6ÿ×U8ÿ×U:ÿ×U<ÿ×U@ÿ×UBÿ×UDÿ×UJÿ×ULÿ×UNÿ×URÿ×UTÿ×UVÿ×UXÿ×UZÿ×U\ÿ×U^ÿ×U`ÿ×W)W )W)W )YRY RYÿ®Yÿ®Y")YRYÿ®Y RY ÿ®ZRZ RZÿ®Zÿ®Z")ZRZÿ®Z RZ ÿ®[Fÿ×[Gÿ×[Hÿ×[Rÿ×[Tÿ×[¢ÿ×[©ÿ×[ªÿ×[«ÿ×[¬ÿ×[­ÿ×[´ÿ×[µÿ×[¶ÿ×[·ÿ×[¸ÿ×[ºÿ×[Éÿ×[Ëÿ×[Íÿ×[Ïÿ×[Ñÿ×[Óÿ×[Õÿ×[×ÿ×[Ùÿ×[Ûÿ×[Ýÿ×[ÿ×[ÿ×[ÿ×[ÿ×[Hÿ×[`ÿ×[6ÿ×[8ÿ×[:ÿ×[<ÿ×[@ÿ×[Bÿ×[Dÿ×[Jÿ×[Lÿ×[Nÿ×[Rÿ×[Tÿ×[Vÿ×[Xÿ×[Zÿ×[\ÿ×[^ÿ×[`ÿ×\R\ R\ÿ®\ÿ®\")\R\ÿ®\ R\ ÿ®^-¸‚ÿq‚ ÿq‚&ÿׂ*ÿׂ- ‚2ÿׂ4ÿׂ7ÿq‚9ÿ®‚:ÿ®‚<ÿ…‚‰ÿׂ”ÿׂ•ÿׂ–ÿׂ—ÿׂ˜ÿׂšÿׂŸÿ…‚ÈÿׂÊÿׂÌÿׂÎÿׂÞÿׂàÿׂâÿׂäÿׂÿׂÿׂÿׂÿׂ$ÿq‚&ÿq‚6ÿ®‚8ÿ…‚:ÿ…‚Gÿׂúÿ®‚üÿ®‚þÿ®‚ÿ…‚ÿq‚ ÿq‚_ÿׂIÿׂKÿׂMÿׂOÿׂQÿׂSÿׂUÿׂWÿׂYÿׂ[ÿׂ]ÿׂ_ÿׂoÿ…‚qÿ…‚sÿ…‚ÿqƒÿqƒ ÿqƒ&ÿ׃*ÿ׃- ƒ2ÿ׃4ÿ׃7ÿqƒ9ÿ®ƒ:ÿ®ƒ<ÿ…ƒ‰ÿ׃”ÿ׃•ÿ׃–ÿ׃—ÿ׃˜ÿ׃šÿ׃Ÿÿ…ƒÈÿ׃Êÿ׃Ìÿ׃Îÿ׃Þÿ׃àÿ׃âÿ׃äÿ׃ÿ׃ÿ׃ÿ׃ÿ׃$ÿqƒ&ÿqƒ6ÿ®ƒ8ÿ…ƒ:ÿ…ƒGÿ׃úÿ®ƒüÿ®ƒþÿ®ƒÿ…ƒÿqƒ ÿqƒ_ÿ׃Iÿ׃Kÿ׃Mÿ׃Oÿ׃Qÿ׃Sÿ׃Uÿ׃Wÿ׃Yÿ׃[ÿ׃]ÿ׃_ÿ׃oÿ…ƒqÿ…ƒsÿ…ƒÿq„ÿq„ ÿq„&ÿׄ*ÿׄ- „2ÿׄ4ÿׄ7ÿq„9ÿ®„:ÿ®„<ÿ…„‰ÿׄ”ÿׄ•ÿׄ–ÿׄ—ÿׄ˜ÿׄšÿׄŸÿ…„ÈÿׄÊÿׄÌÿׄÎÿׄÞÿׄàÿׄâÿׄäÿׄÿׄÿׄÿׄÿׄ$ÿq„&ÿq„6ÿ®„8ÿ…„:ÿ…„Gÿׄúÿ®„üÿ®„þÿ®„ÿ…„ÿq„ ÿq„_ÿׄIÿׄKÿׄMÿׄOÿׄQÿׄSÿׄUÿׄWÿׄYÿׄ[ÿׄ]ÿׄ_ÿׄoÿ…„qÿ…„sÿ…„ÿq…ÿq… ÿq…&ÿ×…*ÿ×…- …2ÿ×…4ÿ×…7ÿq…9ÿ®…:ÿ®…<ÿ……‰ÿ×…”ÿ×…•ÿ×…–ÿ×…—ÿ×…˜ÿ×…šÿ×…Ÿÿ……Èÿ×…Êÿ×…Ìÿ×…Îÿ×…Þÿ×…àÿ×…âÿ×…äÿ×…ÿ×…ÿ×…ÿ×…ÿ×…$ÿq…&ÿq…6ÿ®…8ÿ……:ÿ……Gÿ×…úÿ®…üÿ®…þÿ®…ÿ……ÿq… ÿq…_ÿ×…Iÿ×…Kÿ×…Mÿ×…Oÿ×…Qÿ×…Sÿ×…Uÿ×…Wÿ×…Yÿ×…[ÿ×…]ÿ×…_ÿ×…oÿ……qÿ……sÿ……ÿq†ÿq† ÿq†&ÿ׆*ÿ׆- †2ÿ׆4ÿ׆7ÿq†9ÿ®†:ÿ®†<ÿ…†‰ÿ׆”ÿ׆•ÿ׆–ÿ׆—ÿ׆˜ÿ׆šÿ׆Ÿÿ…†Èÿ׆Êÿ׆Ìÿ׆Îÿ׆Þÿ׆àÿ׆âÿ׆äÿ׆ÿ׆ÿ׆ÿ׆ÿ׆$ÿq†&ÿq†6ÿ®†8ÿ…†:ÿ…†Gÿ׆úÿ®†üÿ®†þÿ®†ÿ…†ÿq† ÿq†_ÿ׆Iÿ׆Kÿ׆Mÿ׆Oÿ׆Qÿ׆Sÿ׆Uÿ׆Wÿ׆Yÿ׆[ÿ׆]ÿ׆_ÿ׆oÿ…†qÿ…†sÿ…†ÿq‡ÿq‡ ÿq‡&ÿׇ*ÿׇ- ‡2ÿׇ4ÿׇ7ÿq‡9ÿ®‡:ÿ®‡<ÿ…‡‰ÿׇ”ÿׇ•ÿׇ–ÿׇ—ÿׇ˜ÿׇšÿׇŸÿ…‡ÈÿׇÊÿׇÌÿׇÎÿׇÞÿׇàÿׇâÿׇäÿׇÿׇÿׇÿׇÿׇ$ÿq‡&ÿq‡6ÿ®‡8ÿ…‡:ÿ…‡Gÿׇúÿ®‡üÿ®‡þÿ®‡ÿ…‡ÿq‡ ÿq‡_ÿׇIÿׇKÿׇMÿׇOÿׇQÿׇSÿׇUÿׇWÿׇYÿׇ[ÿׇ]ÿׇ_ÿׇoÿ…‡qÿ…‡sÿ…‡ÿqˆ-{‰&ÿ׉*ÿ׉2ÿ׉4ÿ׉‰ÿ׉”ÿ׉•ÿ׉–ÿ׉—ÿ׉˜ÿ׉šÿ׉Èÿ׉Êÿ׉Ìÿ׉Îÿ׉Þÿ׉àÿ׉âÿ׉äÿ׉ÿ׉ÿ׉ÿ׉ÿ׉Gÿ׉_ÿ׉Iÿ׉Kÿ׉Mÿ׉Oÿ׉Qÿ׉Sÿ׉Uÿ׉Wÿ׉Yÿ׉[ÿ׉]ÿ׉_ÿ׊-{‹-{Œ-{-{’ÿ®’ÿ®’$ÿ×’7ÿÃ’9ÿì’:ÿì’;ÿ×’<ÿì’=ÿì’‚ÿ×’ƒÿ×’„ÿ×’…ÿ×’†ÿ×’‡ÿ×’Ÿÿì’Âÿ×’Äÿ×’Æÿ×’$ÿÃ’&ÿÃ’6ÿì’8ÿì’:ÿì’;ÿì’=ÿì’?ÿì’Cÿ×’ ÿì’úÿì’üÿì’þÿì’ÿì’ÿ®’ ÿ®’Xÿ×’ÿ×’ÿ×’!ÿ×’#ÿ×’%ÿ×’'ÿ×’)ÿ×’+ÿ×’-ÿ×’/ÿ×’1ÿ×’3ÿ×’oÿì’qÿì’sÿì’ÿÔÿ®”ÿ®”$ÿ×”7ÿÔ9ÿì”:ÿì”;ÿ×”<ÿì”=ÿ씂ÿ×”ƒÿ×”„ÿ×”…ÿ×”†ÿ×”‡ÿ×”Ÿÿì”Âÿ×”Äÿ×”Æÿ×”$ÿÔ&ÿÔ6ÿì”8ÿì”:ÿì”;ÿì”=ÿì”?ÿì”Cÿ×” ÿì”úÿì”üÿì”þÿì”ÿì”ÿ®” ÿ®”Xÿ×”ÿ×”ÿ×”!ÿ×”#ÿ×”%ÿ×”'ÿ×”)ÿ×”+ÿ×”-ÿ×”/ÿ×”1ÿ×”3ÿ×”oÿì”qÿì”sÿì”ÿÕÿ®•ÿ®•$ÿו7ÿÕ9ÿì•:ÿì•;ÿו<ÿì•=ÿì•‚ÿוƒÿו„ÿו…ÿו†ÿו‡ÿוŸÿì•ÂÿוÄÿוÆÿו$ÿÕ&ÿÕ6ÿì•8ÿì•:ÿì•;ÿì•=ÿì•?ÿì•Cÿו ÿì•úÿì•üÿì•þÿì•ÿì•ÿ®• ÿ®•Xÿוÿוÿו!ÿו#ÿו%ÿו'ÿו)ÿו+ÿו-ÿו/ÿו1ÿו3ÿוoÿì•qÿì•sÿì•ÿÖÿ®–ÿ®–$ÿ×–7ÿÖ9ÿì–:ÿì–;ÿ×–<ÿì–=ÿì–‚ÿ×–ƒÿ×–„ÿ×–…ÿ×–†ÿ×–‡ÿ×–Ÿÿì–Âÿ×–Äÿ×–Æÿ×–$ÿÖ&ÿÖ6ÿì–8ÿì–:ÿì–;ÿì–=ÿì–?ÿì–Cÿ×– ÿì–úÿì–üÿì–þÿì–ÿì–ÿ®– ÿ®–Xÿ×–ÿ×–ÿ×–!ÿ×–#ÿ×–%ÿ×–'ÿ×–)ÿ×–+ÿ×–-ÿ×–/ÿ×–1ÿ×–3ÿ×–oÿì–qÿì–sÿì–ÿ×ÿ®—ÿ®—$ÿ×—7ÿ×9ÿì—:ÿì—;ÿ×—<ÿì—=ÿì—‚ÿ×—ƒÿ×—„ÿ×—…ÿ×—†ÿ×—‡ÿ×—Ÿÿì—Âÿ×—Äÿ×—Æÿ×—$ÿ×&ÿ×6ÿì—8ÿì—:ÿì—;ÿì—=ÿì—?ÿì—Cÿ×— ÿì—úÿì—üÿì—þÿì—ÿì—ÿ®— ÿ®—Xÿ×—ÿ×—ÿ×—!ÿ×—#ÿ×—%ÿ×—'ÿ×—)ÿ×—+ÿ×—-ÿ×—/ÿ×—1ÿ×—3ÿ×—oÿì—qÿì—sÿì—ÿØÿ®˜ÿ®˜$ÿט7ÿØ9ÿì˜:ÿì˜;ÿט<ÿì˜=ÿ옂ÿטƒÿט„ÿט…ÿט†ÿט‡ÿטŸÿì˜ÂÿטÄÿטÆÿט$ÿØ&ÿØ6ÿì˜8ÿì˜:ÿì˜;ÿì˜=ÿì˜?ÿì˜Cÿט ÿì˜úÿì˜üÿì˜þÿì˜ÿì˜ÿ®˜ ÿ®˜Xÿטÿטÿט!ÿט#ÿט%ÿט'ÿט)ÿט+ÿט-ÿט/ÿט1ÿט3ÿטoÿì˜qÿì˜sÿì˜ÿÚÿ®šÿ®š$ÿך7ÿÚ9ÿìš:ÿìš;ÿך<ÿìš=ÿìš‚ÿךƒÿך„ÿך…ÿך†ÿך‡ÿךŸÿìšÂÿךÄÿךÆÿך$ÿÚ&ÿÚ6ÿìš8ÿìš:ÿìš;ÿìš=ÿìš?ÿìšCÿך ÿìšúÿìšüÿìšþÿìšÿìšÿ®š ÿ®šXÿךÿךÿך!ÿך#ÿך%ÿך'ÿך)ÿך+ÿך-ÿך/ÿך1ÿך3ÿךoÿìšqÿìšsÿìšÿÛÿ×›ÿ×›$ÿ웂ÿ웃ÿ웄ÿì›…ÿ웆ÿ웇ÿì›Âÿì›Äÿì›Æÿì›Cÿì›ÿ×› ÿ×›Xÿì›ÿì›ÿì›!ÿì›#ÿì›%ÿì›'ÿì›)ÿì›+ÿì›-ÿì›/ÿì›1ÿì›3ÿìœÿלÿל$ÿ윂ÿ윃ÿ위ÿ윅ÿ윆ÿ윇ÿìœÂÿìœÄÿìœÆÿìœCÿìœÿל ÿלXÿìœÿìœÿìœ!ÿìœ#ÿìœ%ÿìœ'ÿìœ)ÿìœ+ÿìœ-ÿìœ/ÿìœ1ÿìœ3ÿìÿ×ÿ×$ÿì‚ÿìƒÿì„ÿì…ÿì†ÿì‡ÿìÂÿìÄÿìÆÿìCÿìÿ× ÿ×Xÿìÿìÿì!ÿì#ÿì%ÿì'ÿì)ÿì+ÿì-ÿì/ÿì1ÿì3ÿìžÿמÿמ$ÿìž‚ÿ잃ÿìž„ÿìž…ÿ잆ÿ잇ÿìžÂÿìžÄÿìžÆÿìžCÿìžÿמ ÿמXÿìžÿìžÿìž!ÿìž#ÿìž%ÿìž'ÿìž)ÿìž+ÿìž-ÿìž/ÿìž1ÿìž3ÿìŸÿ…Ÿÿ…Ÿ")Ÿ$ÿ…Ÿ&ÿן*ÿן2ÿן4ÿןDÿšŸFÿšŸGÿšŸHÿšŸJÿןPÿßQÿßRÿšŸSÿßTÿšŸUÿßVÿ®ŸXÿß]ÿן‚ÿ…Ÿƒÿ…Ÿ„ÿ…Ÿ…ÿ…Ÿ†ÿ…Ÿ‡ÿ…Ÿ‰ÿן”ÿן•ÿן–ÿן—ÿן˜ÿןšÿן¢ÿšŸ£ÿšŸ¤ÿšŸ¥ÿšŸ¦ÿšŸ§ÿšŸ¨ÿšŸ©ÿšŸªÿšŸ«ÿšŸ¬ÿšŸ­ÿšŸ´ÿšŸµÿšŸ¶ÿšŸ·ÿšŸ¸ÿšŸºÿšŸ»ÿß¼ÿß½ÿß¾ÿßÂÿ…ŸÃÿšŸÄÿ…ŸÅÿšŸÆÿ…ŸÇÿšŸÈÿןÉÿšŸÊÿןËÿšŸÌÿןÍÿšŸÎÿןÏÿšŸÑÿšŸÓÿšŸÕÿšŸ×ÿšŸÙÿšŸÛÿšŸÝÿšŸÞÿןßÿןàÿןáÿןâÿןãÿןäÿןåÿןúÿßÿßÿß ÿßÿןÿšŸÿןÿšŸÿןÿšŸÿןÿšŸÿßÿßÿ®Ÿ!ÿ®Ÿ+ÿß-ÿß/ÿß1ÿß3ÿß5ÿß<ÿן>ÿן@ÿןCÿ…ŸDÿšŸFÿšŸGÿןHÿšŸJÿ®Ÿÿ…Ÿ ÿ…ŸWÿßXÿ…ŸYÿšŸ_ÿן`ÿšŸbÿßÿ…ŸÿšŸÿ…Ÿ ÿšŸ!ÿ…Ÿ"ÿšŸ#ÿ…Ÿ%ÿ…Ÿ&ÿšŸ'ÿ…Ÿ(ÿšŸ)ÿ…Ÿ*ÿšŸ+ÿ…Ÿ,ÿšŸ-ÿ…Ÿ.ÿšŸ/ÿ…Ÿ0ÿšŸ1ÿ…Ÿ2ÿšŸ3ÿ…Ÿ4ÿšŸ6ÿšŸ8ÿšŸ:ÿšŸ<ÿšŸ@ÿšŸBÿšŸDÿšŸIÿןJÿšŸKÿןLÿšŸMÿןNÿšŸOÿןQÿןRÿšŸSÿןTÿšŸUÿןVÿšŸWÿןXÿšŸYÿןZÿšŸ[ÿן\ÿšŸ]ÿן^ÿšŸ_ÿן`ÿšŸbÿßdÿßfÿßhÿßjÿßlÿßnÿàþö þö $ÿš ;ÿ× =ÿì ‚ÿš ƒÿš „ÿš …ÿš †ÿš ‡ÿš Âÿš Äÿš Æÿš ;ÿì =ÿì ?ÿì Cÿš þö  þö Xÿš ÿš ÿš !ÿš #ÿš %ÿš 'ÿš )ÿš +ÿš -ÿš /ÿš 1ÿš 3ÿš¢ÿì¢ ÿì¢ÿì¢ ÿì£ÿì£ ÿì£ÿì£ ÿì¤ÿì¤ ÿì¤ÿì¤ ÿì¥ÿì¥ ÿì¥ÿì¥ ÿì¦ÿì¦ ÿì¦ÿì¦ ÿì§ÿì§ ÿì§ÿì§ ÿìªÿìª ÿìªYÿתZÿת[ÿת\ÿת]ÿ쪿ÿת7ÿת<ÿìª>ÿìª@ÿìªûÿתýÿתÿìª ÿìªpÿ׫ÿì« ÿì«Yÿ׫Zÿ׫[ÿ׫\ÿ׫]ÿì«¿ÿ׫7ÿ׫<ÿì«>ÿì«@ÿì«ûÿ׫ýÿ׫ÿì« ÿì«pÿ׬ÿì¬ ÿì¬Yÿ׬Zÿ׬[ÿ׬\ÿ׬]ÿ쬿ÿ׬7ÿ׬<ÿì¬>ÿì¬@ÿì¬ûÿ׬ýÿ׬ÿì¬ ÿì¬pÿ×­ÿì­ ÿì­Yÿ×­Zÿ×­[ÿ×­\ÿ×­]ÿì­¿ÿ×­7ÿ×­<ÿì­>ÿì­@ÿì­ûÿ×­ýÿ×­ÿì­ ÿì­pÿײÿì² ÿì²YÿײZÿײ[ÿײ\ÿײ]ÿ첿ÿײ7ÿײ<ÿì²>ÿì²@ÿì²ûÿײýÿײÿì² ÿì²pÿ×´ÿì´ ÿì´Yÿ×´Zÿ×´[ÿ×´\ÿ×´]ÿì´¿ÿ×´7ÿ×´<ÿì´>ÿì´@ÿì´ûÿ×´ýÿ×´ÿì´ ÿì´pÿ×µÿìµ ÿìµYÿ×µZÿ×µ[ÿ×µ\ÿ×µ]ÿ쵿ÿ×µ7ÿ×µ<ÿìµ>ÿìµ@ÿìµûÿ×µýÿ×µÿìµ ÿìµpÿ׶ÿì¶ ÿì¶Yÿ׶Zÿ׶[ÿ׶\ÿ׶]ÿ춿ÿ׶7ÿ׶<ÿì¶>ÿì¶@ÿì¶ûÿ׶ýÿ׶ÿì¶ ÿì¶pÿ׸ÿ׸ ÿ׸ÿ׸ ÿ׺ÿìº ÿìºYÿ׺Zÿ׺[ÿ׺\ÿ׺]ÿ캿ÿ׺7ÿ׺<ÿìº>ÿìº@ÿìºûÿ׺ýÿ׺ÿìº ÿìºpÿ׿R¿ R¿ÿ®¿ÿ®¿")¿R¿ÿ®¿ R¿ ÿ®ÀÿìÀ ÿìÀYÿ×ÀZÿ×À[ÿ×À\ÿ×À]ÿìÀ¿ÿ×À7ÿ×À<ÿìÀ>ÿìÀ@ÿìÀûÿ×Àýÿ×ÀÿìÀ ÿìÀpÿ×ÁRÁ RÁÿ®Áÿ®Á")ÁRÁÿ®Á RÁ ÿ®Âÿq ÿqÂ&ÿ×Â*ÿ×Â- Â2ÿ×Â4ÿ×Â7ÿqÂ9ÿ®Â:ÿ®Â<ÿ…‰ÿ×”ÿוÿ×–ÿ×—ÿטÿךÿןÿ…ÂÈÿ×ÂÊÿ×ÂÌÿ×ÂÎÿ×ÂÞÿ×Âàÿ×Ââÿ×Âäÿ×Âÿ×Âÿ×Âÿ×Âÿ×Â$ÿqÂ&ÿqÂ6ÿ®Â8ÿ…Â:ÿ…ÂGÿ×Âúÿ®Âüÿ®Âþÿ®Âÿ…Âÿq ÿqÂ_ÿ×ÂIÿ×ÂKÿ×ÂMÿ×ÂOÿ×ÂQÿ×ÂSÿ×ÂUÿ×ÂWÿ×ÂYÿ×Â[ÿ×Â]ÿ×Â_ÿ×Âoÿ…Âqÿ…Âsÿ…ÂÿqÃÿìà ÿìÃÿìà ÿìÄÿqÄ ÿqÄ&ÿ×Ä*ÿ×Ä- Ä2ÿ×Ä4ÿ×Ä7ÿqÄ9ÿ®Ä:ÿ®Ä<ÿ…ĉÿ×Ä”ÿ×Ä•ÿ×Ä–ÿ×Ä—ÿ×Ęÿ×Äšÿ×ÄŸÿ…ÄÈÿ×ÄÊÿ×ÄÌÿ×ÄÎÿ×ÄÞÿ×Äàÿ×Äâÿ×Ääÿ×Äÿ×Äÿ×Äÿ×Äÿ×Ä$ÿqÄ&ÿqÄ6ÿ®Ä8ÿ…Ä:ÿ…ÄGÿ×Äúÿ®Äüÿ®Äþÿ®Äÿ…ÄÿqÄ ÿqÄ_ÿ×ÄIÿ×ÄKÿ×ÄMÿ×ÄOÿ×ÄQÿ×ÄSÿ×ÄUÿ×ÄWÿ×ÄYÿ×Ä[ÿ×Ä]ÿ×Ä_ÿ×Äoÿ…Äqÿ…Äsÿ…ÄÿqÅÿìÅ ÿìÅÿìÅ ÿìÆÿqÆ ÿqÆ&ÿ×Æ*ÿ×Æ- Æ2ÿ×Æ4ÿ×Æ7ÿqÆ9ÿ®Æ:ÿ®Æ<ÿ…Ɖÿ×Æ”ÿ×Æ•ÿ×Æ–ÿ×Æ—ÿ×Ƙÿ×Æšÿ×ÆŸÿ…ÆÈÿ×ÆÊÿ×ÆÌÿ×ÆÎÿ×ÆÞÿ×Æàÿ×Æâÿ×Æäÿ×Æÿ×Æÿ×Æÿ×Æÿ×Æ$ÿqÆ&ÿqÆ6ÿ®Æ8ÿ…Æ:ÿ…ÆGÿ×Æúÿ®Æüÿ®Æþÿ®Æÿ…ÆÿqÆ ÿqÆ_ÿ×ÆIÿ×ÆKÿ×ÆMÿ×ÆOÿ×ÆQÿ×ÆSÿ×ÆUÿ×ÆWÿ×ÆYÿ×Æ[ÿ×Æ]ÿ×Æ_ÿ×Æoÿ…Æqÿ…Æsÿ…ÆÿqÇÿìÇ ÿìÇÿìÇ ÿìÈ&ÿ×È*ÿ×È2ÿ×È4ÿ×ȉÿ×È”ÿ×È•ÿ×È–ÿ×È—ÿ×Șÿ×Èšÿ×ÈÈÿ×ÈÊÿ×ÈÌÿ×ÈÎÿ×ÈÞÿ×Èàÿ×Èâÿ×Èäÿ×Èÿ×Èÿ×Èÿ×Èÿ×ÈGÿ×È_ÿ×ÈIÿ×ÈKÿ×ÈMÿ×ÈOÿ×ÈQÿ×ÈSÿ×ÈUÿ×ÈWÿ×ÈYÿ×È[ÿ×È]ÿ×È_ÿ×Ê&ÿ×Ê*ÿ×Ê2ÿ×Ê4ÿ×ʉÿ×Ê”ÿ×Ê•ÿ×Ê–ÿ×Ê—ÿ×ʘÿ×Êšÿ×ÊÈÿ×ÊÊÿ×ÊÌÿ×ÊÎÿ×ÊÞÿ×Êàÿ×Êâÿ×Êäÿ×Êÿ×Êÿ×Êÿ×Êÿ×ÊGÿ×Ê_ÿ×ÊIÿ×ÊKÿ×ÊMÿ×ÊOÿ×ÊQÿ×ÊSÿ×ÊUÿ×ÊWÿ×ÊYÿ×Ê[ÿ×Ê]ÿ×Ê_ÿ×Ì&ÿ×Ì*ÿ×Ì2ÿ×Ì4ÿ×̉ÿ×Ì”ÿ×Ì•ÿ×Ì–ÿ×Ì—ÿ×̘ÿ×Ìšÿ×ÌÈÿ×ÌÊÿ×ÌÌÿ×ÌÎÿ×ÌÞÿ×Ìàÿ×Ìâÿ×Ìäÿ×Ìÿ×Ìÿ×Ìÿ×Ìÿ×ÌGÿ×Ì_ÿ×ÌIÿ×ÌKÿ×ÌMÿ×ÌOÿ×ÌQÿ×ÌSÿ×ÌUÿ×ÌWÿ×ÌYÿ×Ì[ÿ×Ì]ÿ×Ì_ÿ×Î&ÿ×Î*ÿ×Î2ÿ×Î4ÿ×Ήÿ×Δÿ×Εÿ×Ζÿ×Ηÿ×Θÿ×Κÿ×ÎÈÿ×ÎÊÿ×ÎÌÿ×ÎÎÿ×ÎÞÿ×Îàÿ×Îâÿ×Îäÿ×Îÿ×Îÿ×Îÿ×Îÿ×ÎGÿ×Î_ÿ×ÎIÿ×ÎKÿ×ÎMÿ×ÎOÿ×ÎQÿ×ÎSÿ×ÎUÿ×ÎWÿ×ÎYÿ×Î[ÿ×Î]ÿ×Î_ÿ×Ðÿ®Ðÿ®Ð$ÿ×Ð7ÿÃÐ9ÿìÐ:ÿìÐ;ÿ×Ð<ÿìÐ=ÿìЂÿ×Ѓÿ×Єÿ×Ð…ÿ×Іÿ×Їÿ×ПÿìÐÂÿ×ÐÄÿ×ÐÆÿ×Ð$ÿÃÐ&ÿÃÐ6ÿìÐ8ÿìÐ:ÿìÐ;ÿìÐ=ÿìÐ?ÿìÐCÿ×РÿìÐúÿìÐüÿìÐþÿìÐÿìÐÿ®Ð ÿ®ÐXÿ×Ðÿ×Ðÿ×Ð!ÿ×Ð#ÿ×Ð%ÿ×Ð'ÿ×Ð)ÿ×Ð+ÿ×Ð-ÿ×Ð/ÿ×Ð1ÿ×Ð3ÿ×ÐoÿìÐqÿìÐsÿìÐÿÃÑRÑ RÑ Ñ"¤Ñ@ÑE=ÑK=ÑN=ÑO=Ñ`Ñç=Ñé{ÑRÑ RÒÿ®Òÿ®Ò$ÿ×Ò7ÿÃÒ9ÿìÒ:ÿìÒ;ÿ×Ò<ÿìÒ=ÿìÒ‚ÿ×Òƒÿ×Ò„ÿ×Ò…ÿ×Ò†ÿ×Ò‡ÿ×ÒŸÿìÒÂÿ×ÒÄÿ×ÒÆÿ×Ò$ÿÃÒ&ÿÃÒ6ÿìÒ8ÿìÒ:ÿìÒ;ÿìÒ=ÿìÒ?ÿìÒCÿ×Ò ÿìÒúÿìÒüÿìÒþÿìÒÿìÒÿ®Ò ÿ®ÒXÿ×Òÿ×Òÿ×Ò!ÿ×Ò#ÿ×Ò%ÿ×Ò'ÿ×Ò)ÿ×Ò+ÿ×Ò-ÿ×Ò/ÿ×Ò1ÿ×Ò3ÿ×ÒoÿìÒqÿìÒsÿìÒÿÃÔ-{ÕÿìÕ ÿìÕYÿ×ÕZÿ×Õ[ÿ×Õ\ÿ×Õ]ÿìÕ¿ÿ×Õ7ÿ×Õ<ÿìÕ>ÿìÕ@ÿìÕûÿ×Õýÿ×ÕÿìÕ ÿìÕpÿ×Ö-{×ÿì× ÿì×Yÿ××Zÿ××[ÿ××\ÿ××]ÿì׿ÿ××7ÿ××<ÿì×>ÿì×@ÿì×ûÿ××ýÿ××ÿì× ÿì×pÿ×Ø-{ÙÿìÙ ÿìÙYÿ×ÙZÿ×Ù[ÿ×Ù\ÿ×Ù]ÿìÙ¿ÿ×Ù7ÿ×Ù<ÿìÙ>ÿìÙ@ÿìÙûÿ×Ùýÿ×ÙÿìÙ ÿìÙpÿ×Ú-{ÛÿìÛ ÿìÛYÿ×ÛZÿ×Û[ÿ×Û\ÿ×Û]ÿìÛ¿ÿ×Û7ÿ×Û<ÿìÛ>ÿìÛ@ÿìÛûÿ×Ûýÿ×ÛÿìÛ ÿìÛpÿ×Ü-{ÝÿìÝ ÿìÝYÿ×ÝZÿ×Ý[ÿ×Ý\ÿ×Ý]ÿìÝ¿ÿ×Ý7ÿ×Ý<ÿìÝ>ÿìÝ@ÿìÝûÿ×Ýýÿ×ÝÿìÝ ÿìÝpÿ×çÿìç ÿìçÿìç ÿìø&ÿ×ø*ÿ×ø2ÿ×ø4ÿ×ø‰ÿ×ø”ÿ×ø•ÿ×ø–ÿ×ø—ÿ×ø˜ÿ×øšÿ×øÈÿ×øÊÿ×øÌÿ×øÎÿ×øÞÿ×øàÿ×øâÿ×øäÿ×øÿ×øÿ×øÿ×øÿ×øGÿ×ø_ÿ×øIÿ×øKÿ×øMÿ×øOÿ×øQÿ×øSÿ×øUÿ×øWÿ×øYÿ×ø[ÿ×ø]ÿ×ø_ÿ×ùFÿ×ùGÿ×ùHÿ×ùRÿ×ùTÿ×ù¢ÿ×ù©ÿ×ùªÿ×ù«ÿ×ù¬ÿ×ù­ÿ×ù´ÿ×ùµÿ×ù¶ÿ×ù·ÿ×ù¸ÿ×ùºÿ×ùÉÿ×ùËÿ×ùÍÿ×ùÏÿ×ùÑÿ×ùÓÿ×ùÕÿ×ù×ÿ×ùÙÿ×ùÛÿ×ùÝÿ×ùÿ×ùÿ×ùÿ×ùÿ×ùHÿ×ù`ÿ×ù6ÿ×ù8ÿ×ù:ÿ×ù<ÿ×ù@ÿ×ùBÿ×ùDÿ×ùJÿ×ùLÿ×ùNÿ×ùRÿ×ùTÿ×ùVÿ×ùXÿ×ùZÿ×ù\ÿ×ù^ÿ×ù`ÿ×úFÿ×úGÿ×úHÿ×úRÿ×úTÿ×ú¢ÿ×ú©ÿ×úªÿ×ú«ÿ×ú¬ÿ×ú­ÿ×ú´ÿ×úµÿ×ú¶ÿ×ú·ÿ×ú¸ÿ×úºÿ×úÉÿ×úËÿ×úÍÿ×úÏÿ×úÑÿ×úÓÿ×úÕÿ×ú×ÿ×úÙÿ×úÛÿ×úÝÿ×úÿ×úÿ×úÿ×úÿ×úHÿ×ú`ÿ×ú6ÿ×ú8ÿ×ú:ÿ×ú<ÿ×ú@ÿ×úBÿ×úDÿ×úJÿ×úLÿ×úNÿ×úRÿ×úTÿ×úVÿ×úXÿ×úZÿ×ú\ÿ×ú^ÿ×ú`ÿ×ûÿ\û ÿ\û&ÿ×û*ÿ×û2ÿ×û4ÿ×û7ÿ×û8ÿìû9ÿ×û:ÿ×û<ÿÃû‰ÿ×û”ÿ×û•ÿ×û–ÿ×û—ÿ×û˜ÿ×ûšÿ×û›ÿìûœÿìûÿìûžÿìûŸÿÃûÈÿ×ûÊÿ×ûÌÿ×ûÎÿ×ûÞÿ×ûàÿ×ûâÿ×ûäÿ×ûÿ×ûÿ×ûÿ×ûÿ×û$ÿ×û&ÿ×û*ÿìû,ÿìû.ÿìû0ÿìû2ÿìû4ÿìû6ÿ×û8ÿÃû:ÿÃûGÿ×ûúÿ×ûüÿ×ûþÿ×ûÿÃûÿ\û ÿ\û_ÿ×ûaÿìûIÿ×ûKÿ×ûMÿ×ûOÿ×ûQÿ×ûSÿ×ûUÿ×ûWÿ×ûYÿ×û[ÿ×û]ÿ×û_ÿ×ûaÿìûcÿìûeÿìûgÿìûiÿìûkÿìûmÿìûoÿÃûqÿÃûsÿÃûÿ×ýÿ\ý ÿ\ý&ÿ×ý*ÿ×ý2ÿ×ý4ÿ×ý7ÿ×ý8ÿìý9ÿ×ý:ÿ×ý<ÿÃý‰ÿ×ý”ÿ×ý•ÿ×ý–ÿ×ý—ÿ×ý˜ÿ×ýšÿ×ý›ÿìýœÿìýÿìýžÿìýŸÿÃýÈÿ×ýÊÿ×ýÌÿ×ýÎÿ×ýÞÿ×ýàÿ×ýâÿ×ýäÿ×ýÿ×ýÿ×ýÿ×ýÿ×ý$ÿ×ý&ÿ×ý*ÿìý,ÿìý.ÿìý0ÿìý2ÿìý4ÿìý6ÿ×ý8ÿÃý:ÿÃýGÿ×ýúÿ×ýüÿ×ýþÿ×ýÿÃýÿ\ý ÿ\ý_ÿ×ýaÿìýIÿ×ýKÿ×ýMÿ×ýOÿ×ýQÿ×ýSÿ×ýUÿ×ýWÿ×ýYÿ×ý[ÿ×ý]ÿ×ý_ÿ×ýaÿìýcÿìýeÿìýgÿìýiÿìýkÿìýmÿìýoÿÃýqÿÃýsÿÃýÿ×ÿÿ\ÿ ÿ\ÿ&ÿ×ÿ*ÿ×ÿ2ÿ×ÿ4ÿ×ÿ7ÿ×ÿ8ÿìÿ9ÿ×ÿ:ÿ×ÿ<ÿÃÿ‰ÿ×ÿ”ÿ×ÿ•ÿ×ÿ–ÿ×ÿ—ÿ×ÿ˜ÿ×ÿšÿ×ÿ›ÿìÿœÿìÿÿìÿžÿìÿŸÿÃÿÈÿ×ÿÊÿ×ÿÌÿ×ÿÎÿ×ÿÞÿ×ÿàÿ×ÿâÿ×ÿäÿ×ÿÿ×ÿÿ×ÿÿ×ÿÿ×ÿ$ÿ×ÿ&ÿ×ÿ*ÿìÿ,ÿìÿ.ÿìÿ0ÿìÿ2ÿìÿ4ÿìÿ6ÿ×ÿ8ÿÃÿ:ÿÃÿGÿ×ÿúÿ×ÿüÿ×ÿþÿ×ÿÿÃÿÿ\ÿ ÿ\ÿ_ÿ×ÿaÿìÿIÿ×ÿKÿ×ÿMÿ×ÿOÿ×ÿQÿ×ÿSÿ×ÿUÿ×ÿWÿ×ÿYÿ×ÿ[ÿ×ÿ]ÿ×ÿ_ÿ×ÿaÿìÿcÿìÿeÿìÿgÿìÿiÿìÿkÿìÿmÿìÿoÿÃÿqÿÃÿsÿÃÿÿ×R R "@E=K=N=O=`ç=éR Rÿ\ ÿ\&ÿ×*ÿ×2ÿ×4ÿ×7ÿ×8ÿì9ÿ×:ÿ×<ÿÉÿ×”ÿוÿ×–ÿ×—ÿטÿךÿ×›ÿìœÿìÿìžÿìŸÿÃÈÿ×Êÿ×Ìÿ×Îÿ×Þÿ×àÿ×âÿ×äÿ×ÿ×ÿ×ÿ×ÿ×$ÿ×&ÿ×*ÿì,ÿì.ÿì0ÿì2ÿì4ÿì6ÿ×8ÿÃ:ÿÃGÿ×úÿ×üÿ×þÿ×ÿÃÿ\ ÿ\_ÿ×aÿìIÿ×Kÿ×Mÿ×Oÿ×Qÿ×Sÿ×Uÿ×Wÿ×Yÿ×[ÿ×]ÿ×_ÿ×aÿìcÿìeÿìgÿìiÿìkÿìmÿìoÿÃqÿÃsÿÃÿ×ÿ\ ÿ\&ÿ×*ÿ×2ÿ×4ÿ×7ÿ×8ÿì9ÿ×:ÿ×<ÿÉÿ×”ÿוÿ×–ÿ×—ÿטÿךÿ×›ÿìœÿìÿìžÿìŸÿÃÈÿ×Êÿ×Ìÿ×Îÿ×Þÿ×àÿ×âÿ×äÿ×ÿ×ÿ×ÿ×ÿ×$ÿ×&ÿ×*ÿì,ÿì.ÿì0ÿì2ÿì4ÿì6ÿ×8ÿÃ:ÿÃGÿ×úÿ×üÿ×þÿ×ÿÃÿ\ ÿ\_ÿ×aÿìIÿ×Kÿ×Mÿ×Oÿ×Qÿ×Sÿ×Uÿ×Wÿ×Yÿ×[ÿ×]ÿ×_ÿ×aÿìcÿìeÿìgÿìiÿìkÿìmÿìoÿÃqÿÃsÿÃÿ×ÿì ÿìÿì ÿìÿ®ÿ®$ÿ×7ÿÃ9ÿì:ÿì;ÿ×<ÿì=ÿì‚ÿ׃ÿׄÿ×…ÿ׆ÿׇÿןÿìÂÿ×Äÿ×Æÿ×$ÿÃ&ÿÃ6ÿì8ÿì:ÿì;ÿì=ÿì?ÿìCÿ× ÿìúÿìüÿìþÿìÿìÿ® ÿ®Xÿ×ÿ×ÿ×!ÿ×#ÿ×%ÿ×'ÿ×)ÿ×+ÿ×-ÿ×/ÿ×1ÿ×3ÿ×oÿìqÿìsÿìÿÃÿ®ÿ®$ÿ×7ÿÃ9ÿì:ÿì;ÿ×<ÿì=ÿì‚ÿ׃ÿׄÿ×…ÿ׆ÿׇÿןÿìÂÿ×Äÿ×Æÿ×$ÿÃ&ÿÃ6ÿì8ÿì:ÿì;ÿì=ÿì?ÿìCÿ× ÿìúÿìüÿìþÿìÿìÿ® ÿ®Xÿ×ÿ×ÿ×!ÿ×#ÿ×%ÿ×'ÿ×)ÿ×+ÿ×-ÿ×/ÿ×1ÿ×3ÿ×oÿìqÿìsÿìÿÃÿ®ÿ®$ÿ×7ÿÃ9ÿì:ÿì;ÿ×<ÿì=ÿì‚ÿ׃ÿׄÿ×…ÿ׆ÿׇÿןÿìÂÿ×Äÿ×Æÿ×$ÿÃ&ÿÃ6ÿì8ÿì:ÿì;ÿì=ÿì?ÿìCÿ× ÿìúÿìüÿìþÿìÿìÿ® ÿ®Xÿ×ÿ×ÿ×!ÿ×#ÿ×%ÿ×'ÿ×)ÿ×+ÿ×-ÿ×/ÿ×1ÿ×3ÿ×oÿìqÿìsÿìÿÃ-{R RDÿ×Fÿ×Gÿ×Hÿ×JÿìRÿ×Tÿ×¢ÿ×£ÿפÿ×¥ÿצÿקÿרÿשÿתÿ׫ÿ׬ÿ×­ÿ×´ÿ×µÿ׶ÿ×·ÿ׸ÿ׺ÿ×Ãÿ×Åÿ×Çÿ×Éÿ×Ëÿ×Íÿ×Ïÿ×Ñÿ×Óÿ×Õÿ××ÿ×Ùÿ×Ûÿ×Ýÿ×ßÿìáÿìãÿìåÿìÿ×ÿ×ÿ×ÿ×Dÿ×Fÿ×Hÿ×R RYÿ×`ÿ×ÿ× ÿ×"ÿ×&ÿ×(ÿ×*ÿ×,ÿ×.ÿ×0ÿ×2ÿ×4ÿ×6ÿ×8ÿ×:ÿ×<ÿ×@ÿ×Bÿ×Dÿ×Jÿ×Lÿ×Nÿ×Rÿ×Tÿ×Vÿ×Xÿ×Zÿ×\ÿ×^ÿ×`ÿ×R RDÿ×Fÿ×Gÿ×Hÿ×JÿìRÿ×Tÿ×¢ÿ×£ÿפÿ×¥ÿצÿקÿרÿשÿתÿ׫ÿ׬ÿ×­ÿ×´ÿ×µÿ׶ÿ×·ÿ׸ÿ׺ÿ×Ãÿ×Åÿ×Çÿ×Éÿ×Ëÿ×Íÿ×Ïÿ×Ñÿ×Óÿ×Õÿ××ÿ×Ùÿ×Ûÿ×Ýÿ×ßÿìáÿìãÿìåÿìÿ×ÿ×ÿ×ÿ×Dÿ×Fÿ×Hÿ×R RYÿ×`ÿ×ÿ× ÿ×"ÿ×&ÿ×(ÿ×*ÿ×,ÿ×.ÿ×0ÿ×2ÿ×4ÿ×6ÿ×8ÿ×:ÿ×<ÿ×@ÿ×Bÿ×Dÿ×Jÿ×Lÿ×Nÿ×Rÿ×Tÿ×Vÿ×Xÿ×Zÿ×\ÿ×^ÿ×`ÿ×R RDÿ×Fÿ×Gÿ×Hÿ×JÿìRÿ×Tÿ×¢ÿ×£ÿפÿ×¥ÿצÿקÿרÿשÿתÿ׫ÿ׬ÿ×­ÿ×´ÿ×µÿ׶ÿ×·ÿ׸ÿ׺ÿ×Ãÿ×Åÿ×Çÿ×Éÿ×Ëÿ×Íÿ×Ïÿ×Ñÿ×Óÿ×Õÿ××ÿ×Ùÿ×Ûÿ×Ýÿ×ßÿìáÿìãÿìåÿìÿ×ÿ×ÿ×ÿ×Dÿ×Fÿ×Hÿ×R RYÿ×`ÿ×ÿ× ÿ×"ÿ×&ÿ×(ÿ×*ÿ×,ÿ×.ÿ×0ÿ×2ÿ×4ÿ×6ÿ×8ÿ×:ÿ×<ÿ×@ÿ×Bÿ×Dÿ×Jÿ×Lÿ×Nÿ×Rÿ×Tÿ×Vÿ×Xÿ×Zÿ×\ÿ×^ÿ×`ÿ×$ÿ…$ÿ®$ÿ…$")$$ÿq$&ÿ×$*ÿ×$2ÿ×$4ÿ×$7)$Dÿ\$Fÿq$Gÿq$Hÿq$Jÿq$Pÿš$Qÿš$Rÿq$Sÿš$Tÿq$Uÿš$Vÿ…$Xÿš$Yÿ×$Zÿ×$[ÿ×$\ÿ×$]ÿ®$‚ÿq$ƒÿq$„ÿq$…ÿq$†ÿq$‡ÿq$‰ÿ×$”ÿ×$•ÿ×$–ÿ×$—ÿ×$˜ÿ×$šÿ×$¢ÿq$£ÿ\$¤ÿ\$¥ÿ\$¦ÿ\$§ÿ\$¨ÿ\$©ÿq$ªÿq$«ÿq$¬ÿq$­ÿq$´ÿq$µÿq$¶ÿq$·ÿq$¸ÿq$ºÿq$»ÿš$¼ÿš$½ÿš$¾ÿš$¿ÿ×$Âÿq$Ãÿ\$Äÿq$Åÿ\$Æÿq$Çÿ\$Èÿ×$Éÿq$Êÿ×$Ëÿq$Ìÿ×$Íÿq$Îÿ×$Ïÿq$Ñÿq$Óÿq$Õÿq$×ÿq$Ùÿq$Ûÿq$Ýÿq$Þÿ×$ßÿq$àÿ×$áÿq$âÿ×$ãÿq$äÿ×$åÿq$úÿš$ÿš$ÿš$ ÿš$ÿ×$ÿq$ÿ×$ÿq$ÿ×$ÿq$ÿ×$ÿq$ÿš$ÿš$ÿ…$!ÿ…$$)$&)$+ÿš$-ÿš$/ÿš$1ÿš$3ÿš$5ÿš$7ÿ×$<ÿ®$>ÿ®$@ÿ®$Cÿq$Dÿ\$Fÿ\$Gÿ×$Hÿq$Jÿ…$ûÿ×$ýÿ×$ÿ®$ÿ®$ÿ®$ÿ…$ ÿ…$Wÿš$Xÿq$Yÿ\$_ÿ×$`ÿq$bÿš$ÿq$ÿ\$ÿq$ ÿ\$!ÿq$"ÿ\$#ÿq$%ÿq$&ÿ\$'ÿq$(ÿ\$)ÿq$*ÿ\$+ÿq$,ÿ\$-ÿq$.ÿ\$/ÿq$0ÿ\$1ÿq$2ÿ\$3ÿq$4ÿ\$6ÿq$8ÿq$:ÿq$<ÿq$@ÿq$Bÿq$Dÿq$Iÿ×$Jÿq$Kÿ×$Lÿq$Mÿ×$Nÿq$Oÿ×$Qÿ×$Rÿq$Sÿ×$Tÿq$Uÿ×$Vÿq$Wÿ×$Xÿq$Yÿ×$Zÿq$[ÿ×$\ÿq$]ÿ×$^ÿq$_ÿ×$`ÿq$bÿš$dÿš$fÿš$hÿš$jÿš$lÿš$nÿš$pÿ×$)%)% )%)% )&ÿ…&ÿ®&ÿ…&")&$ÿq&&ÿ×&*ÿ×&2ÿ×&4ÿ×&7)&Dÿ\&Fÿq&Gÿq&Hÿq&Jÿq&Pÿš&Qÿš&Rÿq&Sÿš&Tÿq&Uÿš&Vÿ…&Xÿš&Yÿ×&Zÿ×&[ÿ×&\ÿ×&]ÿ®&‚ÿq&ƒÿq&„ÿq&…ÿq&†ÿq&‡ÿq&‰ÿ×&”ÿ×&•ÿ×&–ÿ×&—ÿ×&˜ÿ×&šÿ×&¢ÿq&£ÿ\&¤ÿ\&¥ÿ\&¦ÿ\&§ÿ\&¨ÿ\&©ÿq&ªÿq&«ÿq&¬ÿq&­ÿq&´ÿq&µÿq&¶ÿq&·ÿq&¸ÿq&ºÿq&»ÿš&¼ÿš&½ÿš&¾ÿš&¿ÿ×&Âÿq&Ãÿ\&Äÿq&Åÿ\&Æÿq&Çÿ\&Èÿ×&Éÿq&Êÿ×&Ëÿq&Ìÿ×&Íÿq&Îÿ×&Ïÿq&Ñÿq&Óÿq&Õÿq&×ÿq&Ùÿq&Ûÿq&Ýÿq&Þÿ×&ßÿq&àÿ×&áÿq&âÿ×&ãÿq&äÿ×&åÿq&úÿš&ÿš&ÿš& ÿš&ÿ×&ÿq&ÿ×&ÿq&ÿ×&ÿq&ÿ×&ÿq&ÿš&ÿš&ÿ…&!ÿ…&$)&&)&+ÿš&-ÿš&/ÿš&1ÿš&3ÿš&5ÿš&7ÿ×&<ÿ®&>ÿ®&@ÿ®&Cÿq&Dÿ\&Fÿ\&Gÿ×&Hÿq&Jÿ…&ûÿ×&ýÿ×&ÿ®&ÿ®&ÿ®&ÿ…& ÿ…&Wÿš&Xÿq&Yÿ\&_ÿ×&`ÿq&bÿš&ÿq&ÿ\&ÿq& ÿ\&!ÿq&"ÿ\&#ÿq&%ÿq&&ÿ\&'ÿq&(ÿ\&)ÿq&*ÿ\&+ÿq&,ÿ\&-ÿq&.ÿ\&/ÿq&0ÿ\&1ÿq&2ÿ\&3ÿq&4ÿ\&6ÿq&8ÿq&:ÿq&<ÿq&@ÿq&Bÿq&Dÿq&Iÿ×&Jÿq&Kÿ×&Lÿq&Mÿ×&Nÿq&Oÿ×&Qÿ×&Rÿq&Sÿ×&Tÿq&Uÿ×&Vÿq&Wÿ×&Xÿq&Yÿ×&Zÿq&[ÿ×&\ÿq&]ÿ×&^ÿq&_ÿ×&`ÿq&bÿš&dÿš&fÿš&hÿš&jÿš&lÿš&nÿš&pÿ×&)')' )')' )(ÿ…(ÿ®(ÿ…(")($ÿq(&ÿ×(*ÿ×(2ÿ×(4ÿ×(7)(Dÿ\(Fÿq(Gÿq(Hÿq(Jÿq(Pÿš(Qÿš(Rÿq(Sÿš(Tÿq(Uÿš(Vÿ…(Xÿš(Yÿ×(Zÿ×([ÿ×(\ÿ×(]ÿ®(‚ÿq(ƒÿq(„ÿq(…ÿq(†ÿq(‡ÿq(‰ÿ×(”ÿ×(•ÿ×(–ÿ×(—ÿ×(˜ÿ×(šÿ×(¢ÿq(£ÿ\(¤ÿ\(¥ÿ\(¦ÿ\(§ÿ\(¨ÿ\(©ÿq(ªÿq(«ÿq(¬ÿq(­ÿq(´ÿq(µÿq(¶ÿq(·ÿq(¸ÿq(ºÿq(»ÿš(¼ÿš(½ÿš(¾ÿš(¿ÿ×(Âÿq(Ãÿ\(Äÿq(Åÿ\(Æÿq(Çÿ\(Èÿ×(Éÿq(Êÿ×(Ëÿq(Ìÿ×(Íÿq(Îÿ×(Ïÿq(Ñÿq(Óÿq(Õÿq(×ÿq(Ùÿq(Ûÿq(Ýÿq(Þÿ×(ßÿq(àÿ×(áÿq(âÿ×(ãÿq(äÿ×(åÿq(úÿš(ÿš(ÿš( ÿš(ÿ×(ÿq(ÿ×(ÿq(ÿ×(ÿq(ÿ×(ÿq(ÿš(ÿš(ÿ…(!ÿ…($)(&)(+ÿš(-ÿš(/ÿš(1ÿš(3ÿš(5ÿš(7ÿ×(<ÿ®(>ÿ®(@ÿ®(Cÿq(Dÿ\(Fÿ\(Gÿ×(Hÿq(Jÿ…(ûÿ×(ýÿ×(ÿ®(ÿ®(ÿ®(ÿ…( ÿ…(Wÿš(Xÿq(Yÿ\(_ÿ×(`ÿq(bÿš(ÿq(ÿ\(ÿq( ÿ\(!ÿq("ÿ\(#ÿq(%ÿq(&ÿ\('ÿq((ÿ\()ÿq(*ÿ\(+ÿq(,ÿ\(-ÿq(.ÿ\(/ÿq(0ÿ\(1ÿq(2ÿ\(3ÿq(4ÿ\(6ÿq(8ÿq(:ÿq(<ÿq(@ÿq(Bÿq(Dÿq(Iÿ×(Jÿq(Kÿ×(Lÿq(Mÿ×(Nÿq(Oÿ×(Qÿ×(Rÿq(Sÿ×(Tÿq(Uÿ×(Vÿq(Wÿ×(Xÿq(Yÿ×(Zÿq([ÿ×(\ÿq(]ÿ×(^ÿq(_ÿ×(`ÿq(bÿš(dÿš(fÿš(hÿš(jÿš(lÿš(nÿš(pÿ×()*ÿ×*ÿ×*$ÿì*‚ÿì*ƒÿì*„ÿì*…ÿì*†ÿì*‡ÿì*Âÿì*Äÿì*Æÿì*Cÿì*ÿ×* ÿ×*Xÿì*ÿì*ÿì*!ÿì*#ÿì*%ÿì*'ÿì*)ÿì*+ÿì*-ÿì*/ÿì*1ÿì*3ÿì,ÿ×,ÿ×,$ÿì,‚ÿì,ƒÿì,„ÿì,…ÿì,†ÿì,‡ÿì,Âÿì,Äÿì,Æÿì,Cÿì,ÿ×, ÿ×,Xÿì,ÿì,ÿì,!ÿì,#ÿì,%ÿì,'ÿì,)ÿì,+ÿì,-ÿì,/ÿì,1ÿì,3ÿì.ÿ×.ÿ×.$ÿì.‚ÿì.ƒÿì.„ÿì.…ÿì.†ÿì.‡ÿì.Âÿì.Äÿì.Æÿì.Cÿì.ÿ×. ÿ×.Xÿì.ÿì.ÿì.!ÿì.#ÿì.%ÿì.'ÿì.)ÿì.+ÿì.-ÿì./ÿì.1ÿì.3ÿì0ÿ×0ÿ×0$ÿì0‚ÿì0ƒÿì0„ÿì0…ÿì0†ÿì0‡ÿì0Âÿì0Äÿì0Æÿì0Cÿì0ÿ×0 ÿ×0Xÿì0ÿì0ÿì0!ÿì0#ÿì0%ÿì0'ÿì0)ÿì0+ÿì0-ÿì0/ÿì01ÿì03ÿì2ÿ×2ÿ×2$ÿì2‚ÿì2ƒÿì2„ÿì2…ÿì2†ÿì2‡ÿì2Âÿì2Äÿì2Æÿì2Cÿì2ÿ×2 ÿ×2Xÿì2ÿì2ÿì2!ÿì2#ÿì2%ÿì2'ÿì2)ÿì2+ÿì2-ÿì2/ÿì21ÿì23ÿì4ÿ×4ÿ×4$ÿì4‚ÿì4ƒÿì4„ÿì4…ÿì4†ÿì4‡ÿì4Âÿì4Äÿì4Æÿì4Cÿì4ÿ×4 ÿ×4Xÿì4ÿì4ÿì4!ÿì4#ÿì4%ÿì4'ÿì4)ÿì4+ÿì4-ÿì4/ÿì41ÿì43ÿì6ÿš6ÿš6")6$ÿ®6&ÿì6*ÿì62ÿì64ÿì6Dÿ×6Fÿ×6Gÿ×6Hÿ×6Jÿì6Pÿì6Qÿì6Rÿ×6Sÿì6Tÿ×6Uÿì6Vÿì6Xÿì6‚ÿ®6ƒÿ®6„ÿ®6…ÿ®6†ÿ®6‡ÿ®6‰ÿì6”ÿì6•ÿì6–ÿì6—ÿì6˜ÿì6šÿì6¢ÿ×6£ÿ×6¤ÿ×6¥ÿ×6¦ÿ×6§ÿ×6¨ÿ×6©ÿ×6ªÿ×6«ÿ×6¬ÿ×6­ÿ×6´ÿ×6µÿ×6¶ÿ×6·ÿ×6¸ÿ×6ºÿ×6»ÿì6¼ÿì6½ÿì6¾ÿì6Âÿ®6Ãÿ×6Äÿ®6Åÿ×6Æÿ®6Çÿ×6Èÿì6Éÿ×6Êÿì6Ëÿ×6Ìÿì6Íÿ×6Îÿì6Ïÿ×6Ñÿ×6Óÿ×6Õÿ×6×ÿ×6Ùÿ×6Ûÿ×6Ýÿ×6Þÿì6ßÿì6àÿì6áÿì6âÿì6ãÿì6äÿì6åÿì6úÿì6ÿì6ÿì6 ÿì6ÿì6ÿ×6ÿì6ÿ×6ÿì6ÿ×6ÿì6ÿ×6ÿì6ÿì6ÿì6!ÿì6+ÿì6-ÿì6/ÿì61ÿì63ÿì65ÿì6Cÿ®6Dÿ×6Fÿ×6Gÿì6Hÿ×6Jÿì6ÿš6 ÿš6Wÿì6Xÿ®6Yÿ×6_ÿì6`ÿ×6bÿì6ÿ®6ÿ×6ÿ®6 ÿ×6!ÿ®6"ÿ×6#ÿ®6%ÿ®6&ÿ×6'ÿ®6(ÿ×6)ÿ®6*ÿ×6+ÿ®6,ÿ×6-ÿ®6.ÿ×6/ÿ®60ÿ×61ÿ®62ÿ×63ÿ®64ÿ×66ÿ×68ÿ×6:ÿ×6<ÿ×6@ÿ×6Bÿ×6Dÿ×6Iÿì6Jÿ×6Kÿì6Lÿ×6Mÿì6Nÿ×6Oÿì6Qÿì6Rÿ×6Sÿì6Tÿ×6Uÿì6Vÿ×6Wÿì6Xÿ×6Yÿì6Zÿ×6[ÿì6\ÿ×6]ÿì6^ÿ×6_ÿì6`ÿ×6bÿì6dÿì6fÿì6hÿì6jÿì6lÿì6nÿì7R7 R7ÿ®7ÿ®7")7R7ÿ®7 R7 ÿ®8ÿ…8ÿ…8")8$ÿ…8&ÿ×8*ÿ×82ÿ×84ÿ×8Dÿš8Fÿš8Gÿš8Hÿš8Jÿ×8PÿÃ8QÿÃ8Rÿš8SÿÃ8Tÿš8UÿÃ8Vÿ®8XÿÃ8]ÿ×8‚ÿ…8ƒÿ…8„ÿ…8…ÿ…8†ÿ…8‡ÿ…8‰ÿ×8”ÿ×8•ÿ×8–ÿ×8—ÿ×8˜ÿ×8šÿ×8¢ÿš8£ÿš8¤ÿš8¥ÿš8¦ÿš8§ÿš8¨ÿš8©ÿš8ªÿš8«ÿš8¬ÿš8­ÿš8´ÿš8µÿš8¶ÿš8·ÿš8¸ÿš8ºÿš8»ÿÃ8¼ÿÃ8½ÿÃ8¾ÿÃ8Âÿ…8Ãÿš8Äÿ…8Åÿš8Æÿ…8Çÿš8Èÿ×8Éÿš8Êÿ×8Ëÿš8Ìÿ×8Íÿš8Îÿ×8Ïÿš8Ñÿš8Óÿš8Õÿš8×ÿš8Ùÿš8Ûÿš8Ýÿš8Þÿ×8ßÿ×8àÿ×8áÿ×8âÿ×8ãÿ×8äÿ×8åÿ×8úÿÃ8ÿÃ8ÿÃ8 ÿÃ8ÿ×8ÿš8ÿ×8ÿš8ÿ×8ÿš8ÿ×8ÿš8ÿÃ8ÿÃ8ÿ®8!ÿ®8+ÿÃ8-ÿÃ8/ÿÃ81ÿÃ83ÿÃ85ÿÃ8<ÿ×8>ÿ×8@ÿ×8Cÿ…8Dÿš8Fÿš8Gÿ×8Hÿš8Jÿ®8ÿ…8 ÿ…8WÿÃ8Xÿ…8Yÿš8_ÿ×8`ÿš8bÿÃ8ÿ…8ÿš8ÿ…8 ÿš8!ÿ…8"ÿš8#ÿ…8%ÿ…8&ÿš8'ÿ…8(ÿš8)ÿ…8*ÿš8+ÿ…8,ÿš8-ÿ…8.ÿš8/ÿ…80ÿš81ÿ…82ÿš83ÿ…84ÿš86ÿš88ÿš8:ÿš8<ÿš8@ÿš8Bÿš8Dÿš8Iÿ×8Jÿš8Kÿ×8Lÿš8Mÿ×8Nÿš8Oÿ×8Qÿ×8Rÿš8Sÿ×8Tÿš8Uÿ×8Vÿš8Wÿ×8Xÿš8Yÿ×8Zÿš8[ÿ×8\ÿš8]ÿ×8^ÿš8_ÿ×8`ÿš8bÿÃ8dÿÃ8fÿÃ8hÿÃ8jÿÃ8lÿÃ8nÿÃ9R9 R9ÿ®9ÿ®9")9R9ÿ®9 R9 ÿ®:ÿ…:ÿ…:"):$ÿ…:&ÿ×:*ÿ×:2ÿ×:4ÿ×:Dÿš:Fÿš:Gÿš:Hÿš:Jÿ×:PÿÃ:QÿÃ:Rÿš:SÿÃ:Tÿš:UÿÃ:Vÿ®:XÿÃ:]ÿ×:‚ÿ…:ƒÿ…:„ÿ…:…ÿ…:†ÿ…:‡ÿ…:‰ÿ×:”ÿ×:•ÿ×:–ÿ×:—ÿ×:˜ÿ×:šÿ×:¢ÿš:£ÿš:¤ÿš:¥ÿš:¦ÿš:§ÿš:¨ÿš:©ÿš:ªÿš:«ÿš:¬ÿš:­ÿš:´ÿš:µÿš:¶ÿš:·ÿš:¸ÿš:ºÿš:»ÿÃ:¼ÿÃ:½ÿÃ:¾ÿÃ:Âÿ…:Ãÿš:Äÿ…:Åÿš:Æÿ…:Çÿš:Èÿ×:Éÿš:Êÿ×:Ëÿš:Ìÿ×:Íÿš:Îÿ×:Ïÿš:Ñÿš:Óÿš:Õÿš:×ÿš:Ùÿš:Ûÿš:Ýÿš:Þÿ×:ßÿ×:àÿ×:áÿ×:âÿ×:ãÿ×:äÿ×:åÿ×:úÿÃ:ÿÃ:ÿÃ: ÿÃ:ÿ×:ÿš:ÿ×:ÿš:ÿ×:ÿš:ÿ×:ÿš:ÿÃ:ÿÃ:ÿ®:!ÿ®:+ÿÃ:-ÿÃ:/ÿÃ:1ÿÃ:3ÿÃ:5ÿÃ:<ÿ×:>ÿ×:@ÿ×:Cÿ…:Dÿš:Fÿš:Gÿ×:Hÿš:Jÿ®:ÿ…: ÿ…:WÿÃ:Xÿ…:Yÿš:_ÿ×:`ÿš:bÿÃ:ÿ…:ÿš:ÿ…: ÿš:!ÿ…:"ÿš:#ÿ…:%ÿ…:&ÿš:'ÿ…:(ÿš:)ÿ…:*ÿš:+ÿ…:,ÿš:-ÿ…:.ÿš:/ÿ…:0ÿš:1ÿ…:2ÿš:3ÿ…:4ÿš:6ÿš:8ÿš::ÿš:<ÿš:@ÿš:Bÿš:Dÿš:Iÿ×:Jÿš:Kÿ×:Lÿš:Mÿ×:Nÿš:Oÿ×:Qÿ×:Rÿš:Sÿ×:Tÿš:Uÿ×:Vÿš:Wÿ×:Xÿš:Yÿ×:Zÿš:[ÿ×:\ÿš:]ÿ×:^ÿš:_ÿ×:`ÿš:bÿÃ:dÿÃ:fÿÃ:hÿÃ:jÿÃ:lÿÃ:nÿÃ;&ÿì;*ÿì;2ÿì;4ÿì;‰ÿì;”ÿì;•ÿì;–ÿì;—ÿì;˜ÿì;šÿì;Èÿì;Êÿì;Ìÿì;Îÿì;Þÿì;àÿì;âÿì;äÿì;ÿì;ÿì;ÿì;ÿì;Gÿì;_ÿì;Iÿì;Kÿì;Mÿì;Oÿì;Qÿì;Sÿì;Uÿì;Wÿì;Yÿì;[ÿì;]ÿì;_ÿì=&ÿì=*ÿì=2ÿì=4ÿì=‰ÿì=”ÿì=•ÿì=–ÿì=—ÿì=˜ÿì=šÿì=Èÿì=Êÿì=Ìÿì=Îÿì=Þÿì=àÿì=âÿì=äÿì=ÿì=ÿì=ÿì=ÿì=Gÿì=_ÿì=Iÿì=Kÿì=Mÿì=Oÿì=Qÿì=Sÿì=Uÿì=Wÿì=Yÿì=[ÿì=]ÿì=_ÿì?&ÿì?*ÿì?2ÿì?4ÿì?‰ÿì?”ÿì?•ÿì?–ÿì?—ÿì?˜ÿì?šÿì?Èÿì?Êÿì?Ìÿì?Îÿì?Þÿì?àÿì?âÿì?äÿì?ÿì?ÿì?ÿì?ÿì?Gÿì?_ÿì?Iÿì?Kÿì?Mÿì?Oÿì?Qÿì?Sÿì?Uÿì?Wÿì?Yÿì?[ÿì?]ÿì?_ÿìCÿqC ÿqC&ÿ×C*ÿ×C- C2ÿ×C4ÿ×C7ÿqC9ÿ®C:ÿ®C<ÿ…C‰ÿ×C”ÿ×C•ÿ×C–ÿ×C—ÿ×C˜ÿ×Cšÿ×CŸÿ…CÈÿ×CÊÿ×CÌÿ×CÎÿ×CÞÿ×Càÿ×Câÿ×Cäÿ×Cÿ×Cÿ×Cÿ×Cÿ×C$ÿqC&ÿqC6ÿ®C8ÿ…C:ÿ…CGÿ×Cúÿ®Cüÿ®Cþÿ®Cÿ…CÿqC ÿqC_ÿ×CIÿ×CKÿ×CMÿ×COÿ×CQÿ×CSÿ×CUÿ×CWÿ×CYÿ×C[ÿ×C]ÿ×C_ÿ×Coÿ…Cqÿ…Csÿ…CÿqDÿìD ÿìDÿìD ÿìE-{Gÿ®Gÿ®G$ÿ×G7ÿÃG9ÿìG:ÿìG;ÿ×G<ÿìG=ÿìG‚ÿ×Gƒÿ×G„ÿ×G…ÿ×G†ÿ×G‡ÿ×GŸÿìGÂÿ×GÄÿ×GÆÿ×G$ÿÃG&ÿÃG6ÿìG8ÿìG:ÿìG;ÿìG=ÿìG?ÿìGCÿ×G ÿìGúÿìGüÿìGþÿìGÿìGÿ®G ÿ®GXÿ×Gÿ×Gÿ×G!ÿ×G#ÿ×G%ÿ×G'ÿ×G)ÿ×G+ÿ×G-ÿ×G/ÿ×G1ÿ×G3ÿ×GoÿìGqÿìGsÿìGÿÃVÿqV ÿqVfÿ×Vmÿ×VqÿqVrÿ…Vsÿ×Vuÿ®Vxÿ…VÿqV ÿqVTÿ…[ÿ®[ÿ®[Vÿ×[_ÿ×[bÿ×[dÿì[iÿ×[pÿì[qÿÃ[rÿì[tÿ×[uÿì[xÿì[ˆÿì[ÿ®[ ÿ®[Tÿì\ÿ…\ÿ…\Vÿ…\_ÿ…\bÿ…\fÿ×\iÿ…\mÿ×\sÿÃ\vÿì\yÿš\zÿ®\{ÿÃ\|ÿÃ\}ÿÃ\~ÿš\ÿÃ\‚ÿ®\„ÿÃ\†ÿÃ\‡ÿÃ\‰ÿÃ\Œÿš\Žÿš\ÿš\ÿš\’ÿÃ\“ÿš\•ÿÃ\–ÿÃ\˜ÿÃ\™ÿš\šÿÃ\›ÿÃ\ÿ…\ ÿ…\!ÿì]qÿ×]rÿì]xÿì]Tÿì^ÿ×^ ÿ×^ÿ×^ ÿ×_ÿq_ ÿq_fÿ×_mÿ×_qÿq_rÿ…_sÿ×_uÿ®_xÿ…_ÿq_ ÿq_Tÿ…`ÿ®`ÿ®`Vÿ×`_ÿ×`bÿ×`iÿ×`tÿ×`ÿ®` ÿ®aÿ…aÿ®aÿ…aVÿ\a_ÿ\abÿ\afÿÃaiÿ\amÿÃasÿšavÿÃayÿqazÿša{ÿša|ÿ®a}ÿša~ÿqa€ÿ×aÿÃa‚ÿša„ÿša†ÿ®a‡ÿša‰ÿšaŠÿ×aŒÿqaŽÿšaÿqaÿqa’ÿša“ÿqa”ÿ×a•ÿša–ÿša˜ÿša™ÿqašÿša›ÿšaÿ®aÿ®aÿ®aÿ…a ÿ…a!ÿÃaSÿ×bÿqb ÿqbfÿ×bmÿ×bqÿqbrÿ…bsÿ×buÿ®bxÿ…bÿqb ÿqbTÿ…dfÿìdmÿìdsÿÃfÿ®fÿ®fVÿ×f_ÿ×fbÿ×fdÿìfiÿ×fpÿìfqÿÃfrÿìftÿ×fuÿìfxÿìfˆÿìfÿ®f ÿ®fTÿìhfÿ×hmÿ×hsÿÃhÿìh‘ÿìiÿqi ÿqifÿ×imÿ×iqÿqirÿ…isÿ×iuÿ®ixÿ…iÿqi ÿqiTÿ…mÿ®mÿ®mVÿ×m_ÿ×mbÿ×mdÿìmiÿ×mpÿìmqÿÃmrÿìmtÿ×muÿìmxÿìmˆÿìmÿ®m ÿ®mTÿìoþöoþöoVÿšo_ÿšobÿšodÿìoiÿšotÿ×oˆÿ×oþöo þöqÿ…qÿ®qÿ…qVÿ\q_ÿ\qbÿ\qfÿÃqiÿ\qmÿÃqsÿšqvÿÃqyÿqqzÿšq{ÿšq|ÿ®q}ÿšq~ÿqq€ÿ×qÿÃq‚ÿšq„ÿšq†ÿ®q‡ÿšq‰ÿšqŠÿ×qŒÿqqŽÿšqÿqqÿqq’ÿšq“ÿqq”ÿ×q•ÿšq–ÿšq˜ÿšq™ÿqqšÿšq›ÿšqÿ®qÿ®qÿ®qÿ…q ÿ…q!ÿÃqSÿ×rÿ…rÿ…rVÿ…r_ÿ…rbÿ…rfÿ×riÿ…rmÿ×rsÿÃrvÿìryÿšrzÿ®r{ÿÃr|ÿÃr}ÿÃr~ÿšrÿÃr‚ÿ®r„ÿÃr†ÿÃr‡ÿÃr‰ÿÃrŒÿšrŽÿšrÿšrÿšr’ÿÃr“ÿšr•ÿÃr–ÿÃr˜ÿÃr™ÿšršÿÃr›ÿÃrÿ…r ÿ…r!ÿìsÿšsÿšsVÿ×s_ÿ×sbÿ×sdÿÃsiÿ×spÿìsqÿ®srÿÃstÿìsxÿÃsˆÿìsÿšs ÿšsTÿÃtfÿ×tmÿ×tsÿÃtÿìt‘ÿìuÿ…uÿ…uVÿ®u_ÿ®ubÿ®ufÿìuiÿ®umÿìuÿ…u ÿ…vqÿ×vrÿìvxÿìvTÿìxÿ…xÿ…xVÿ…x_ÿ…xbÿ…xfÿ×xiÿ…xmÿ×xsÿÃxvÿìxyÿšxzÿ®x{ÿÃx|ÿÃx}ÿÃx~ÿšxÿÃx‚ÿ®x„ÿÃx†ÿÃx‡ÿÃx‰ÿÃxŒÿšxŽÿšxÿšxÿšx’ÿÃx“ÿšx•ÿÃx–ÿÃx˜ÿÃx™ÿšxšÿÃx›ÿÃxÿ…x ÿ…x!ÿìyˆ){ÿì{ ÿì{ÿì{ ÿì|ÿ®| ÿ®|ÿì|‘ÿì|ÿ®| ÿ®~ˆ)€ÿ®€ÿ®€ˆÿì€ÿ®€ ÿ®ƒÿšƒyÿ׃~ÿ׃ÿ׃Œÿ׃ÿ׃ÿ׃ÿ׃‘ÿ׃“ÿ׃™ÿ׃ÿšƒÿšƒÿš„ÿì„ ÿì„ÿì„ ÿì…ÿ×…ÿ×…ÿ×… ÿ׆ÿ®† ÿ®†ÿ솑ÿì†ÿ®† ÿ®‡yÿׇ~ÿׇŒÿׇÿׇÿׇ“ÿׇ™ÿ׈ÿ…ˆ ÿ…ˆyÿìˆ~ÿ숀ÿ׈Šÿ׈Œÿìˆÿ׈ÿìˆÿ숑ÿ׈“ÿ숙ÿìˆÿ…ˆ ÿ…Šÿ®Šÿ®ŠˆÿìŠÿ®Š ÿ®ŒÿìŒ ÿ쌀ÿ׌Šÿ׌ÿìŒ ÿìŽÿìŽ ÿ쎀ÿ׎Šÿ׎ÿìŽ ÿìÿìÿìÿì ÿì“ÿì“ ÿì“€ÿדŠÿדÿì“ ÿì”ÿÔÿ×”ÿÔyÿ×”~ÿ×”ÿ×”Œÿ×”ÿ×”ÿ×”“ÿ×”™ÿ×”ÿ×”ÿ×”ÿ×”ÿÔ ÿ×ÿ×— ÿ×—ÿ×— ÿ×™ÿì™ ÿ와ÿ×™Šÿ×™ÿì™ ÿìÿ® ÿ®ÿ…¦ÿ…¨ÿ×¼ÿš½ÿ×ÁÿšÄÿ…Üÿ×Ýÿ×áÿ×äÿ×öÿ×ÿ® ÿ®nÿ®|ÿš€ÿ®‚ÿ®—ÿ®›ÿ®§ÿ®©ÿ…ªÿ×µÿš¶ÿ×·ÿš¸ÿ×¹ÿšºÿ×½ÿ…¾ÿ׿ÿšÀÿ×ÁÿšÂÿ×ÔÿšÕÿ×÷ÿ×øÿ×ùÿ×úÿ×ûÿ×üÿ×ýÿšþÿ×ÿ® ÿšÿÃÿšÿÃÿ…ÿמÿ…žÿ®žÿ…žŸÿמ¤ÿšžªÿqž®ÿšžµÿšž¸ÿמ»ÿמ¼)ž¾ÿ®žÌÿšžÍÿšžÎÿ…žÏÿqžÐÿמÑÿמÒÿšžÓÿšžÔÿšžÕÿ…žÖÿšž×ÿšžØÿqžÙÿšžÚÿšžÛÿqžÜÿ®žÝÿ®žÞÿqžßÿמàÿšžáÿšžâÿšžãÿšžäÿ®žåÿšžæÿšžçÿמèÿšžéÿÞêÿqžìÿšžíÿqžîÿ…žòÿ…žóÿšžõÿšžöÿ®ž÷ÿšžùÿšžÿ®žÿ®žÿ®žÿ…ž ÿ…žjÿqžkÿšžlÿמmÿמqÿšžrÿqžsÿ…žuÿšžwÿšžyÿšž}ÿšž~ÿמÿqžÿמƒÿמ„ÿמ…ÿqž†ÿמ‡ÿqžˆÿמ‰ÿqžŠÿמ‹ÿמŒÿמÿqž–ÿšžšÿšžžÿšž ÿמ¢ÿמ¤ÿšž¦ÿšžªÿ®ž¬ÿšž®ÿšž°ÿšž±ÿמ²ÿqž³ÿמ´ÿqžµ)ž¶ÿ®ž¸ÿ®žºÿ®ž¼ÿמ¾ÿ®žÀÿšžÂÿšžÄÿšžÅÿšžÆÿqžÇÿšžÈÿqžËÿמÍÿšžÎÿšžÏÿ…žÑÿšžÓÿšžÕÿšž×ÿšžÙÿqžÛÿqžÝÿqžàÿqžæÿמèÿמêÿÞìÿšžîÿšžïÿמðÿqžñÿמòÿqžóÿמôÿqžöÿמøÿ®žúÿ®žüÿ®žþÿšžÿšžÿšžÿמÿמ ÿqž ÿqž ÿqž ÿqžÿšžÿšžÿšžÿ…žÿšžÿמÿqžÿ®žÿqžÿšžÿ…ŸŸÿן¸ÿן»ÿן¾ÿןáÿןlÿן~ÿן„ÿן†ÿןˆÿןŠÿןŒÿן±ÿן³ÿןÀÿןÂÿןÅÿןÇÿןÕÿןïÿןñÿןóÿןþÿן ÿן ÿןÿןÿןÿ× ÿ× ÿפÿ®¤ ÿ®¤ÿ…¤¦ÿ…¤¨ÿפ¼ÿš¤½ÿפÁÿš¤Äÿ…¤ÜÿפÝÿפáÿפäÿפöÿפÿ®¤ ÿ®¤nÿ®¤|ÿš¤€ÿ®¤‚ÿ®¤—ÿ®¤›ÿ®¤§ÿ®¤©ÿ…¤ªÿפµÿš¤¶ÿפ·ÿš¤¸ÿפ¹ÿš¤ºÿפ½ÿ…¤¾ÿפ¿ÿš¤ÀÿפÁÿš¤ÂÿפÔÿš¤Õÿפ÷ÿפøÿפùÿפúÿפûÿפüÿפýÿš¤þÿפÿ®¤ ÿš¤ÿäÿš¤ÿäÿ…¤ÿ×¥ÿ®¥ ÿ®¥ÿ…¥¦ÿ…¥¨ÿ×¥¼ÿš¥½ÿ×¥Áÿš¥Äÿ…¥Üÿ×¥Ýÿ×¥áÿ×¥äÿ×¥öÿ×¥ÿ®¥ ÿ®¥nÿ®¥|ÿš¥€ÿ®¥‚ÿ®¥—ÿ®¥›ÿ®¥§ÿ®¥©ÿ…¥ªÿ×¥µÿš¥¶ÿ×¥·ÿš¥¸ÿ×¥¹ÿš¥ºÿ×¥½ÿ…¥¾ÿ×¥¿ÿš¥Àÿ×¥Áÿš¥Âÿ×¥Ôÿš¥Õÿ×¥÷ÿ×¥øÿ×¥ùÿ×¥úÿ×¥ûÿ×¥üÿ×¥ýÿš¥þÿ×¥ÿ®¥ ÿš¥ÿÃ¥ÿš¥ÿÃ¥ÿ…¥ÿצÿ®¦ ÿ®¦ÿ…¦¦ÿ…¦¨ÿצ¼ÿš¦½ÿצÁÿš¦Äÿ…¦ÜÿצÝÿצáÿצäÿצöÿצÿ®¦ ÿ®¦nÿ®¦|ÿš¦€ÿ®¦‚ÿ®¦—ÿ®¦›ÿ®¦§ÿ®¦©ÿ…¦ªÿצµÿš¦¶ÿצ·ÿš¦¸ÿצ¹ÿš¦ºÿצ½ÿ…¦¾ÿצ¿ÿš¦ÀÿצÁÿš¦ÂÿצÔÿš¦Õÿצ÷ÿצøÿצùÿצúÿצûÿצüÿצýÿš¦þÿצÿ®¦ ÿš¦ÿæÿš¦ÿæÿ…¦ÿקŸÿק¸ÿק»ÿק¾ÿקÁÿקáÿקlÿק|ÿק~ÿק„ÿק†ÿקˆÿקŠÿקŒÿק±ÿק³ÿק¿ÿקÀÿקÁÿקÂÿקÅÿš§Çÿš§ÔÿקÕÿקïÿקñÿקóÿקýÿקþÿק ÿק ÿקÿקÿקÿקÿì¨ÿ…¨ÿ…¨Ÿÿ쨤ÿš¨ªÿq¨®ÿš¨µÿš¨¸ÿ쨻ÿ쨾ÿèÉÿì¨Îÿ®¨ÏÿרÕÿ®¨ØÿרÛÿרÞÿרáÿרêÿרëf¨íÿרîÿì¨òÿ®¨ôf¨ÿ…¨ ÿ…¨jÿרlÿì¨rÿq¨sÿ®¨~ÿì¨ÿר„ÿ쨅ÿר†ÿ쨇ÿרˆÿ쨉ÿרŠÿ쨌ÿì¨ÿר˜f¨¨f¨±ÿ쨲ÿר³ÿ쨴ÿרÀÿרÂÿרÅÿרÆÿèÇÿרÈÿèÎÿš¨Ïÿ®¨ÕÿרÙÿq¨Ûÿq¨Ýÿq¨àÿרïÿì¨ðÿרñÿì¨òÿרóÿì¨ôÿרþÿר ÿq¨ ÿר ÿq¨ ÿרÿš¨ÿ®¨ÿì¨ÿרÿרÿš¨ÿ®ªÿqª ÿqªÿšª¦ÿšª¼ÿqª¾ÿתÁÿšªÄÿšªÜÿתáÿתäÿתÿqª ÿqªnÿת|ÿšª€ÿ®ª‚ÿ®ª—ÿת›ÿת§ÿת©ÿšªªÿתµÿqª¶ÿת·ÿ…ª¹ÿ…ª½ÿšª¾ÿת¿ÿšªÀÿתÁÿšªÂÿתÅÿšªÇÿšªÔÿšªÕÿתáÿתãÿתýÿšªþÿתÿת ÿqªÿתÿqªÿתÿšªÿ׫ÿ׫ ÿ׫ªÿì«Áÿ׫ÿ׫ ÿ׫rÿì«|ÿ׫¿ÿ׫Áÿ׫Åÿ׫Çÿ׫Ôÿ׫Ùÿì«Ûÿì«Ýÿì«ýÿ׬ÿ®¬ÿ®¬ÿ®¬ ÿ®¬€ÿ쬂ÿ쬷ÿ쬹ÿì¬ ÿ׬ÿ×­ÿ…­ÿ®­ÿ…­Ÿÿ×­¤ÿš­ªÿq­®ÿš­µÿš­¸ÿ×­»ÿ×­¼)­¾ÿ®­Ìÿš­Íÿš­Îÿ…­Ïÿq­Ðÿ×­Ñÿ×­Òÿš­Óÿš­Ôÿš­Õÿ…­Öÿš­×ÿš­Øÿq­Ùÿš­Úÿš­Ûÿq­Üÿ®­Ýÿ®­Þÿq­ßÿ×­àÿš­áÿš­âÿš­ãÿš­äÿ®­åÿš­æÿš­çÿ×­èÿš­éÿíêÿq­ìÿš­íÿq­îÿ…­òÿ…­óÿš­õÿš­öÿ®­÷ÿš­ùÿš­ÿ®­ÿ®­ÿ®­ÿ…­ ÿ…­jÿq­kÿš­lÿ×­mÿ×­qÿš­rÿq­sÿ…­uÿš­wÿš­yÿš­}ÿš­~ÿ×­ÿq­ÿ×­ƒÿ×­„ÿ×­…ÿq­†ÿ×­‡ÿq­ˆÿ×­‰ÿq­Šÿ×­‹ÿ×­Œÿ×­ÿq­–ÿš­šÿš­žÿš­ ÿ×­¢ÿ×­¤ÿš­¦ÿš­ªÿ®­¬ÿš­®ÿš­°ÿš­±ÿ×­²ÿq­³ÿ×­´ÿq­µ)­¶ÿ®­¸ÿ®­ºÿ®­¼ÿ×­¾ÿ®­Àÿš­Âÿš­Äÿš­Åÿš­Æÿq­Çÿš­Èÿq­Ëÿ×­Íÿš­Îÿš­Ïÿ…­Ñÿš­Óÿš­Õÿš­×ÿš­Ùÿq­Ûÿq­Ýÿq­àÿq­æÿ×­èÿ×­êÿíìÿš­îÿš­ïÿ×­ðÿq­ñÿ×­òÿq­óÿ×­ôÿq­öÿ×­øÿ®­úÿ®­üÿ®­þÿš­ÿš­ÿš­ÿ×­ÿ×­ ÿq­ ÿq­ ÿq­ ÿq­ÿš­ÿš­ÿš­ÿ…­ÿš­ÿ×­ÿq­ÿ®­ÿq­ÿš­ÿ…®£á®ê)®ÿ×®ÿ×°Ÿÿ×°¸ÿ×°»ÿ×°¾ÿ×°Áÿ×°áÿ×°lÿ×°|ÿ×°~ÿ×°„ÿ×°†ÿ×°ˆÿ×°Šÿ×°Œÿ×°±ÿ×°³ÿ×°¿ÿ×°Àÿ×°Áÿ×°Âÿ×°Åÿš°Çÿš°Ôÿ×°Õÿ×°ïÿ×°ñÿ×°óÿ×°ýÿ×°þÿ×° ÿ×° ÿ×°ÿ×°ÿ×°ÿ×°ÿì±ÿ®±ÿ®±ÿ®± ÿ®±€ÿ챂ÿì±·ÿì±¹ÿì± ÿ×±ÿ×´Ÿÿ×´¸ÿ×´»ÿ×´¾ÿ×´Áÿ×´áÿ×´lÿ×´|ÿ×´~ÿ×´„ÿ×´†ÿ×´ˆÿ×´Šÿ×´Œÿ×´±ÿ×´³ÿ×´¿ÿ×´Àÿ×´Áÿ×´Âÿ×´Åÿš´Çÿš´Ôÿ×´Õÿ×´ïÿ×´ñÿ×´óÿ×´ýÿ×´þÿ×´ ÿ×´ ÿ×´ÿ×´ÿ×´ÿ×´ÿì¸ÿ®¸ÿ®¸ÿ츤ÿ׸¦ÿ츨ÿ׸ªÿ׸®ÿ׸°ÿ׸±ÿ층ÿ׸¼ÿø½ÿ׸¿ÿ׸Áÿ׸Äÿì¸Çÿì¸Îÿì¸Õÿì¸òÿì¸ÿ®¸ ÿ®¸rÿ׸sÿì¸zÿì¸|ÿ׸€ÿ츂ÿ츟ÿ׸¡ÿ츩ÿ층ÿø·ÿ츹ÿ츻ÿ׸½ÿ츿ÿ׸Áÿ׸Êÿ׸Îÿ׸Ïÿì¸Ôÿ׸Ùÿ׸Ûÿ׸Ýÿ׸åÿ׸çÿì¸õÿì¸÷ÿ׸ùÿ׸ûÿ׸ýÿ׸ÿ׸ÿ׸ ÿ׸ÿ׸ÿ׸ÿì¸ÿì¸ÿ׸ÿìºþöºþöº¤ÿ…ºªÿšº®ÿ…º°ÿ׺µÿ…º¿ÿ׺ÎÿšºÕÿšºòÿšºþöº þöºrÿšºsÿšºvÿ캟ÿ׺»ÿ׺Êÿ׺Îÿ…ºÏÿšºÙÿšºÛÿšºÝÿšºåÿ׺ÿ׺ÿ׺ ÿ®º ÿ®ºÿ…ºÿšºÿ…ºÿš»Ÿÿ×»¸ÿ×»»ÿ×»¾ÿ×»áÿ×»lÿ×»~ÿ×»„ÿ×»†ÿ×»ˆÿ×»Šÿ×»Œÿ×»±ÿ×»³ÿ×»Àÿ×»Âÿ×»Åÿ×»Çÿ×»Õÿ×»ïÿ×»ñÿ×»óÿ×»þÿ×» ÿ×» ÿ×»ÿ×»ÿ×»ÿ×¼ÿ…¼ÿ®¼ÿ…¼Ÿÿ×¼¤ÿš¼ªÿq¼®ÿš¼µÿš¼¸ÿ×¼»ÿ×¼¼)¼¾ÿ®¼Ìÿš¼Íÿš¼Îÿ…¼Ïÿq¼Ðÿ×¼Ñÿ×¼Òÿš¼Óÿš¼Ôÿš¼Õÿ…¼Öÿš¼×ÿš¼Øÿq¼Ùÿš¼Úÿš¼Ûÿq¼Üÿ®¼Ýÿ®¼Þÿq¼ßÿ×¼àÿš¼áÿš¼âÿš¼ãÿš¼äÿ®¼åÿš¼æÿš¼çÿ×¼èÿš¼éÿüêÿq¼ìÿš¼íÿq¼îÿ…¼òÿ…¼óÿš¼õÿš¼öÿ®¼÷ÿš¼ùÿš¼ÿ®¼ÿ®¼ÿ®¼ÿ…¼ ÿ…¼jÿq¼kÿš¼lÿ×¼mÿ×¼qÿš¼rÿq¼sÿ…¼uÿš¼wÿš¼yÿš¼}ÿš¼~ÿ×¼ÿq¼ÿ×¼ƒÿ×¼„ÿ×¼…ÿq¼†ÿ×¼‡ÿq¼ˆÿ×¼‰ÿq¼Šÿ×¼‹ÿ×¼Œÿ×¼ÿq¼–ÿš¼šÿš¼žÿš¼ ÿ×¼¢ÿ×¼¤ÿš¼¦ÿš¼ªÿ®¼¬ÿš¼®ÿš¼°ÿš¼±ÿ×¼²ÿq¼³ÿ×¼´ÿq¼µ)¼¶ÿ®¼¸ÿ®¼ºÿ®¼¼ÿ×¼¾ÿ®¼Àÿš¼Âÿš¼Äÿš¼Åÿš¼Æÿq¼Çÿš¼Èÿq¼Ëÿ×¼Íÿš¼Îÿš¼Ïÿ…¼Ñÿš¼Óÿš¼Õÿš¼×ÿš¼Ùÿq¼Ûÿq¼Ýÿq¼àÿq¼æÿ×¼èÿ×¼êÿüìÿš¼îÿš¼ïÿ×¼ðÿq¼ñÿ×¼òÿq¼óÿ×¼ôÿq¼öÿ×¼øÿ®¼úÿ®¼üÿ®¼þÿš¼ÿš¼ÿš¼ÿ×¼ÿ×¼ ÿq¼ ÿq¼ ÿq¼ ÿq¼ÿš¼ÿš¼ÿš¼ÿ…¼ÿš¼ÿ×¼ÿq¼ÿ®¼ÿq¼ÿš¼ÿ…½ÿ…½ÿ…½Ÿÿ콤ÿš½ªÿq½®ÿš½µÿš½¸ÿì½»ÿì½¾ÿýÉÿì½Îÿ®½Ïÿ×½Õÿ®½Øÿ×½Ûÿ×½Þÿ×½áÿ×½êÿ×½ëf½íÿ×½îÿì½òÿ®½ôf½ÿ…½ ÿ…½jÿ×½lÿì½rÿq½sÿ®½~ÿì½ÿ×½„ÿì½…ÿ×½†ÿ콇ÿ×½ˆÿ콉ÿ×½Šÿ콌ÿì½ÿ×½˜f½¨f½±ÿì½²ÿ×½³ÿì½´ÿ×½Àÿ×½Âÿ×½Åÿ×½ÆÿýÇÿ×½ÈÿýÎÿš½Ïÿ®½Õÿ×½Ùÿq½Ûÿq½Ýÿq½àÿ×½ïÿì½ðÿ×½ñÿì½òÿ×½óÿì½ôÿ×½þÿ×½ ÿq½ ÿ×½ ÿq½ ÿ×½ÿš½ÿ®½ÿì½ÿ×½ÿ×½ÿš½ÿ®¾ÿ®¾ÿ®¾ÿ×¾¤ÿ×¾¦ÿ×¾¨ÿþªÿ×¾®ÿ×¾°ÿ×¾±ÿ×¾µÿ×¾¼ÿþ½ÿþ¿ÿ×¾Äÿ×¾Çÿ×¾Îÿì¾Õÿì¾òÿì¾ÿ®¾ ÿ®¾rÿ×¾sÿì¾zÿ×¾€ÿ쾂ÿ쾟ÿ×¾¡ÿ×¾©ÿ×¾µÿþ·ÿþ¹ÿþ»ÿ×¾½ÿ×¾Êÿ×¾Îÿ×¾Ïÿì¾Ùÿ×¾Ûÿ×¾Ýÿ×¾åÿ×¾çÿ×¾õÿ×¾÷ÿþùÿþûÿþÿ×¾ÿ×¾ ÿ×¾ÿ×¾ÿ×¾ÿì¾ÿ×¾ÿ×¾ÿì¿Ÿÿ׿¸ÿ׿»ÿ׿¾ÿ׿Áÿ׿áÿ׿lÿ׿|ÿ׿~ÿ׿„ÿ׿†ÿ׿ˆÿ׿Šÿ׿Œÿ׿±ÿ׿³ÿ׿¿ÿ׿Àÿ׿Áÿ׿Âÿ׿Åÿš¿Çÿš¿Ôÿ׿Õÿ׿ïÿ׿ñÿ׿óÿ׿ýÿ׿þÿ׿ ÿ׿ ÿ׿ÿ׿ÿ׿ÿ׿ÿìÀ£áÀê)Àÿ×Àÿ×ãáÃê)Ãÿ×Ãÿ×Äÿ®Ä ÿ®Äÿ…Ħÿ…Ĩÿ×ļÿšÄ½ÿ×ÄÁÿšÄÄÿ…ÄÜÿ×ÄÝÿ×Äáÿ×Ääÿ×Äöÿ×Äÿ®Ä ÿ®Änÿ®Ä|ÿšÄ€ÿ®Ä‚ÿ®Ä—ÿ®Ä›ÿ®Ä§ÿ®Ä©ÿ…Īÿ×ĵÿšÄ¶ÿ×Ä·ÿšÄ¸ÿ×ĹÿšÄºÿ׼ÿ…ľÿ×Ä¿ÿšÄÀÿ×ÄÁÿšÄÂÿ×ÄÔÿšÄÕÿ×Ä÷ÿ×Äøÿ×Äùÿ×Äúÿ×Äûÿ×Äüÿ×ÄýÿšÄþÿ×Äÿ®Ä ÿšÄÿÃÄÿšÄÿÃÄÿ…Äÿ×Æÿ®Æ ÿ®Æÿ…Ʀÿ…ƨÿ×ƼÿšÆ½ÿ×ÆÁÿšÆÄÿ…ÆÜÿ×ÆÝÿ×Æáÿ×Æäÿ×Æöÿ×Æÿ®Æ ÿ®Ænÿ®Æ|ÿšÆ€ÿ®Æ‚ÿ®Æ—ÿ®Æ›ÿ®Æ§ÿ®Æ©ÿ…ƪÿ×ƵÿšÆ¶ÿ×Æ·ÿšÆ¸ÿ×ƹÿšÆºÿ×ƽÿ…ƾÿ×Æ¿ÿšÆÀÿ×ÆÁÿšÆÂÿ×ÆÔÿšÆÕÿ×Æ÷ÿ×Æøÿ×Æùÿ×Æúÿ×Æûÿ×Æüÿ×ÆýÿšÆþÿ×Æÿ®Æ ÿšÆÿÃÆÿšÆÿÃÆÿ…Æÿ×Çÿ®Çÿ®ÇÿìǤÿ×ǦÿìǨÿ×Ǫÿ×Ç®ÿ×Ç°ÿ×DZÿìǵÿ×ǼÿÃǽÿ×Ç¿ÿ×ÇÁÿ×ÇÄÿìÇÇÿìÇÎÿìÇÕÿìÇòÿìÇÿ®Ç ÿ®Çrÿ×ÇsÿìÇzÿìÇ|ÿ×Ç€ÿìÇ‚ÿìÇŸÿ×Ç¡ÿìÇ©ÿìǵÿÃÇ·ÿìǹÿìÇ»ÿ×ǽÿìÇ¿ÿ×ÇÁÿ×ÇÊÿ×ÇÎÿ×ÇÏÿìÇÔÿ×ÇÙÿ×ÇÛÿ×ÇÝÿ×Çåÿ×ÇçÿìÇõÿìÇ÷ÿ×Çùÿ×Çûÿ×Çýÿ×Çÿ×Çÿ×Ç ÿ×Çÿ×Çÿ×ÇÿìÇÿìÇÿ×ÇÿìÈÿ®Èÿ®ÈÿìȤÿ×ȦÿìȨÿ×Ȫÿ×È®ÿ×È°ÿ×ȱÿìȵÿ×ȼÿÃȽÿ×È¿ÿ×ÈÁÿ×ÈÄÿìÈÇÿìÈÎÿìÈÕÿìÈòÿìÈÿ®È ÿ®Èrÿ×ÈsÿìÈzÿìÈ|ÿ×È€ÿìÈ‚ÿìÈŸÿ×È¡ÿìÈ©ÿìȵÿÃÈ·ÿìȹÿìÈ»ÿ×ȽÿìÈ¿ÿ×ÈÁÿ×ÈÊÿ×ÈÎÿ×ÈÏÿìÈÔÿ×ÈÙÿ×ÈÛÿ×ÈÝÿ×Èåÿ×ÈçÿìÈõÿìÈ÷ÿ×Èùÿ×Èûÿ×Èýÿ×Èÿ×Èÿ×È ÿ×Èÿ×Èÿ×ÈÿìÈÿìÈÿ×ÈÿìÊÿìÊ ÿìÊÿìÊ ÿìÌé)ÍÿšÍÿ×ÍÿšÍÎÿÃÍÏÿìÍÕÿÃÍØÿìÍÛÿìÍÞÿìÍêÿìÍíÿìÍòÿÃÍÿ×Íÿ×Íÿ×ÍÿšÍ ÿšÍjÿìÍsÿÃÍÿìÍ…ÿì͇ÿì͉ÿìÍÿìͲÿìÍ´ÿìÍÏÿÃÍàÿìÍðÿìÍòÿìÍôÿìÍ ÿìÍ ÿìÍÿÃÍÿìÍÿìÍÿÃÎÿìÎ ÿìÎÿìÎ ÿìÏÿìÏ ÿìÏÿìÏ ÿìÐÏÿ×ÐØÿ×ÐÛÿ×ÐÞÿ×Ðáÿ×Ðêÿ×Ðíÿ×Ðjÿ×Ðÿ×Ð…ÿ×Їÿ×Љÿ×Ðÿ×вÿ×дÿ×ÐÀÿ×ÐÂÿ×ÐÆÿ×ÐÈÿ×ÐÕÿ×Ðàÿ×Ððÿ×Ðòÿ×Ðôÿ×Ðþÿ×Ð ÿ×Ð ÿ×Ðÿ×Ðÿ×Ñé)ÔÏÿ×ÔØÿ×ÔÛÿ×ÔÞÿ×Ôáÿ×Ôêÿ×Ôíÿ×Ôjÿ×Ôÿ×Ô…ÿ×Ô‡ÿ×Ô‰ÿ×Ôÿ×Ô²ÿ×Ô´ÿ×ÔÀÿ×ÔÂÿ×ÔÆÿ×ÔÈÿ×ÔÕÿ×Ôàÿ×Ôðÿ×Ôòÿ×Ôôÿ×Ôþÿ×Ô ÿ×Ô ÿ×Ôÿ×Ôÿ×ØÿìØ ÿìØÐÿ×ØÜÿìØÝÿìØßÿ×ØáÿìØäÿìØöÿìØÿìØ ÿìØ ÿ×تÿìضÿìؼÿ×ؾÿìØÀÿìØÂÿìØËÿ×ØÕÿìØæÿ×ØøÿìØúÿìØüÿìØþÿìØÿ×Øÿ×ØÿìØÿìØÿìÚÿìÚ ÿìÚÐÿ×ÚÜÿìÚÝÿìÚßÿ×ÚáÿìÚäÿìÚöÿìÚÿìÚ ÿìÚ ÿ×ÚªÿìÚ¶ÿìÚ¼ÿ×Ú¾ÿìÚÀÿìÚÂÿìÚËÿ×ÚÕÿìÚæÿ×ÚøÿìÚúÿìÚüÿìÚþÿìÚÿ×Úÿ×ÚÿìÚÿìÚÿìÜÿšÜÿ×ÜÿšÜÎÿÃÜÏÿìÜÕÿÃÜØÿìÜÛÿìÜÞÿìÜêÿìÜíÿìÜòÿÃÜÿ×Üÿ×Üÿ×ÜÿšÜ ÿšÜjÿìÜsÿÃÜÿìÜ…ÿì܇ÿì܉ÿìÜÿìܲÿìÜ´ÿìÜÏÿÃÜàÿìÜðÿìÜòÿìÜôÿìÜ ÿìÜ ÿìÜÿÃÜÿìÜÿìÜÿÃÝÿ®Ýÿ®ÝÎÿ×ÝÕÿ×Ýòÿ×Ýÿ®Ý ÿ®Ýsÿ×ÝÏÿ×Ýÿ×Ýÿ×ÞÿìÞ ÿìÞÐÿ×ÞÜÿìÞÝÿìÞßÿ×ÞáÿìÞäÿìÞöÿìÞÿìÞ ÿìÞ ÿ×ÞªÿìÞ¶ÿìÞ¼ÿ×Þ¾ÿìÞÀÿìÞÂÿìÞËÿ×ÞÕÿìÞæÿ×ÞøÿìÞúÿìÞüÿìÞþÿìÞÿ×Þÿ×ÞÿìÞÿìÞÿìßÏÿ×ßØÿ×ßÛÿ×ßÞÿ×ßáÿ×ßêÿ×ßíÿ×ßjÿ×ßÿ×ß…ÿ×߇ÿ×߉ÿ×ßÿ×ß²ÿ×ß´ÿ×ßÀÿ×ßÂÿ×ßÆÿ×ßÈÿ×ßÕÿ×ßàÿ×ßðÿ×ßòÿ×ßôÿ×ßþÿ×ß ÿ×ß ÿ×ßÿ×ßÿ×àÿìà ÿìàÿìà ÿìãÿìã ÿìãÿìã ÿìäÿ…ä ÿ…äÐÿ×äÜÿšäÝÿÃäßÿ×äáÿ®ääÿšäöÿÃäÿ…ä ÿ…ämÿ×äÿ×äƒÿ×ä‹ÿ×ä ÿ×äªÿšä¶ÿšä¸ÿÃäºÿÃä¼ÿ×ä¾ÿšäÀÿ®äÂÿ®äÆÿ×äÈÿ×äËÿ×äÕÿ®äæÿ×äêÿ×äøÿÃäúÿÃäüÿÃäþÿ®äÿ×äÿ×äÿšäÿšäÿšæÿ…æ ÿ…æÐÿ×æÜÿšæÝÿÃæßÿ×æáÿ®æäÿšæöÿÃæÿ…æ ÿ…æmÿ×æÿ×æƒÿ×æ‹ÿ×æ ÿ×æªÿšæ¶ÿšæ¸ÿÃæºÿÃæ¼ÿ×æ¾ÿšæÀÿ®æÂÿ®æÆÿ×æÈÿ×æËÿ×æÕÿ®ææÿ×æêÿ×æøÿÃæúÿÃæüÿÃæþÿ®æÿ×æÿ×æÿšæÿšæÿšçÿìç ÿìçÐÿ×çÜÿìçÝÿìçßÿ×çáÿìçäÿìçöÿìçÿìç ÿìç ÿ×çªÿìç¶ÿìç¼ÿ×ç¾ÿìçÀÿìçÂÿìçËÿ×çÕÿìçæÿ×çøÿìçúÿìçüÿìçþÿìçÿ×çÿ×çÿìçÿìçÿìèÿìè ÿìèÐÿ×èÜÿìèÝÿìèßÿ×èáÿìèäÿìèöÿìèÿìè ÿìè ÿ×èªÿìè¶ÿìè¼ÿ×è¾ÿìèÀÿìèÂÿìèËÿ×èÕÿìèæÿ×èøÿìèúÿìèüÿìèþÿìèÿ×èÿ×èÿìèÿìèÿìêÿìê ÿìêÿìê ÿìëÿìë ÿìëÿìë ÿìëÿ×ëÿ×ìÿšìÿ×ìÿšìÎÿÃìÏÿììÕÿÃìØÿììÛÿììÞÿììêÿììíÿììòÿÃìÿ×ìÿ×ìÿ×ìÿšì ÿšìjÿììsÿÃìÿìì…ÿìì‡ÿìì‰ÿììÿìì²ÿìì´ÿììÏÿÃìàÿììðÿììòÿììôÿìì ÿìì ÿììÿÃìÿììÿììÿÃòÿ…ò ÿ…òÐÿ×òÜÿšòÝÿÃòßÿ×òáÿ®òäÿšòöÿÃòÿ…ò ÿ…òmÿ×òÿ×òƒÿ×ò‹ÿ×ò ÿ×òªÿšò¶ÿšò¸ÿÃòºÿÃò¼ÿ×ò¾ÿšòÀÿ®òÂÿ®òÆÿ×òÈÿ×òËÿ×òÕÿ®òæÿ×òêÿ×òøÿÃòúÿÃòüÿÃòþÿ®òÿ×òÿ×òÿšòÿšòÿšóÿ…ó ÿ…óÐÿ×óÜÿšóÝÿÃóßÿ×óáÿ®óäÿšóöÿÃóÿ…ó ÿ…ómÿ×óÿ×óƒÿ×ó‹ÿ×ó ÿ×óªÿšó¶ÿšó¸ÿÃóºÿÃó¼ÿ×ó¾ÿšóÀÿ®óÂÿ®óÆÿ×óÈÿ×óËÿ×óÕÿ®óæÿ×óêÿ×óøÿÃóúÿÃóüÿÃóþÿ®óÿ×óÿ×óÿšóÿšóÿšôÿìô ÿìôÿìô ÿìôÿ×ôÿ×õÏÿ×õØÿ×õÛÿ×õÞÿ×õáÿ×õêÿ×õíÿ×õjÿ×õÿ×õ…ÿ×õ‡ÿ×õ‰ÿ×õÿ×õ²ÿ×õ´ÿ×õÀÿ×õÂÿ×õÆÿ×õÈÿ×õÕÿ×õàÿ×õðÿ×õòÿ×õôÿ×õþÿ×õ ÿ×õ ÿ×õÿ×õÿ×öÿ®öÿ®öÎÿ×öÕÿ×öòÿ×öÿ®ö ÿ®ösÿ×öÏÿ×öÿ×öÿ×øÿ…øÿ®øÿ…øŸÿ×ø¤ÿšøªÿqø®ÿšøµÿšø¸ÿ×ø»ÿ×ø¼)ø¾ÿ®øÌÿšøÍÿšøÎÿ…øÏÿqøÐÿ×øÑÿ×øÒÿšøÓÿšøÔÿšøÕÿ…øÖÿšø×ÿšøØÿqøÙÿšøÚÿšøÛÿqøÜÿ®øÝÿ®øÞÿqøßÿ×øàÿšøáÿšøâÿšøãÿšøäÿ®øåÿšøæÿšøçÿ×øèÿšøéÿÃøêÿqøìÿšøíÿqøîÿ…øòÿ…øóÿšøõÿšøöÿ®ø÷ÿšøùÿšøÿ®øÿ®øÿ®øÿ…ø ÿ…øjÿqøkÿšølÿ×ømÿ×øqÿšørÿqøsÿ…øuÿšøwÿšøyÿšø}ÿšø~ÿ×øÿqøÿ×øƒÿ×ø„ÿ×ø…ÿqø†ÿ×ø‡ÿqøˆÿ×ø‰ÿqøŠÿ×ø‹ÿ×øŒÿ×øÿqø–ÿšøšÿšøžÿšø ÿ×ø¢ÿ×ø¤ÿšø¦ÿšøªÿ®ø¬ÿšø®ÿšø°ÿšø±ÿ×ø²ÿqø³ÿ×ø´ÿqøµ)ø¶ÿ®ø¸ÿ®øºÿ®ø¼ÿ×ø¾ÿ®øÀÿšøÂÿšøÄÿšøÅÿšøÆÿqøÇÿšøÈÿqøËÿ×øÍÿšøÎÿšøÏÿ…øÑÿšøÓÿšøÕÿšø×ÿšøÙÿqøÛÿqøÝÿqøàÿqøæÿ×øèÿ×øêÿÃøìÿšøîÿšøïÿ×øðÿqøñÿ×øòÿqøóÿ×øôÿqøöÿ×øøÿ®øúÿ®øüÿ®øþÿšøÿšøÿšøÿ×øÿ×ø ÿqø ÿqø ÿqø ÿqøÿšøÿšøÿšøÿ…øÿšøÿ×øÿqøÿ®øÿqøÿšøÿ…ùÿšùÿ×ùÿšùÎÿÃùÏÿìùÕÿÃùØÿìùÛÿìùÞÿìùêÿìùíÿìùòÿÃùÿ×ùÿ×ùÿ×ùÿšù ÿšùjÿìùsÿÃùÿìù…ÿìù‡ÿìù‰ÿìùÿìù²ÿìù´ÿìùÏÿÃùàÿìùðÿìùòÿìùôÿìù ÿìù ÿìùÿÃùÿìùÿìùÿÃúÿšúÿšú")ú$ÿ®ú&ÿìú*ÿìú2ÿìú4ÿìúDÿ×úFÿ×úGÿ×úHÿ×úJÿìúPÿìúQÿìúRÿ×úSÿìúTÿ×úUÿìúVÿìúXÿìú‚ÿ®úƒÿ®ú„ÿ®ú…ÿ®ú†ÿ®ú‡ÿ®ú‰ÿìú”ÿìú•ÿìú–ÿìú—ÿìú˜ÿìúšÿìú¢ÿ×ú£ÿ×ú¤ÿ×ú¥ÿ×ú¦ÿ×ú§ÿ×ú¨ÿ×ú©ÿ×úªÿ×ú«ÿ×ú¬ÿ×ú­ÿ×ú´ÿ×úµÿ×ú¶ÿ×ú·ÿ×ú¸ÿ×úºÿ×ú»ÿìú¼ÿìú½ÿìú¾ÿìúÂÿ®úÃÿ×úÄÿ®úÅÿ×úÆÿ®úÇÿ×úÈÿìúÉÿ×úÊÿìúËÿ×úÌÿìúÍÿ×úÎÿìúÏÿ×úÑÿ×úÓÿ×úÕÿ×ú×ÿ×úÙÿ×úÛÿ×úÝÿ×úÞÿìúßÿìúàÿìúáÿìúâÿìúãÿìúäÿìúåÿìúúÿìúÿìúÿìú ÿìúÿìúÿ×úÿìúÿ×úÿìúÿ×úÿìúÿ×úÿìúÿìúÿìú!ÿìú+ÿìú-ÿìú/ÿìú1ÿìú3ÿìú5ÿìúCÿ®úDÿ×úFÿ×úGÿìúHÿ×úJÿìúÿšú ÿšúWÿìúXÿ®úYÿ×ú_ÿìú`ÿ×úbÿìúÿ®úÿ×úÿ®ú ÿ×ú!ÿ®ú"ÿ×ú#ÿ®ú%ÿ®ú&ÿ×ú'ÿ®ú(ÿ×ú)ÿ®ú*ÿ×ú+ÿ®ú,ÿ×ú-ÿ®ú.ÿ×ú/ÿ®ú0ÿ×ú1ÿ®ú2ÿ×ú3ÿ®ú4ÿ×ú6ÿ×ú8ÿ×ú:ÿ×ú<ÿ×ú@ÿ×úBÿ×úDÿ×úIÿìúJÿ×úKÿìúLÿ×úMÿìúNÿ×úOÿìúQÿìúRÿ×úSÿìúTÿ×úUÿìúVÿ×úWÿìúXÿ×úYÿìúZÿ×ú[ÿìú\ÿ×ú]ÿìú^ÿ×ú_ÿìú`ÿ×úbÿìúdÿìúfÿìúhÿìújÿìúlÿìúnÿìûRû Rûÿ®ûÿ®û")ûRûÿ®û Rû ÿ®üÿšüÿšü")ü$ÿ®ü&ÿìü*ÿìü2ÿìü4ÿìüDÿ×üFÿ×üGÿ×üHÿ×üJÿìüPÿìüQÿìüRÿ×üSÿìüTÿ×üUÿìüVÿìüXÿìü‚ÿ®üƒÿ®ü„ÿ®ü…ÿ®ü†ÿ®ü‡ÿ®ü‰ÿìü”ÿìü•ÿìü–ÿìü—ÿìü˜ÿìüšÿìü¢ÿ×ü£ÿ×ü¤ÿ×ü¥ÿ×ü¦ÿ×ü§ÿ×ü¨ÿ×ü©ÿ×üªÿ×ü«ÿ×ü¬ÿ×ü­ÿ×ü´ÿ×üµÿ×ü¶ÿ×ü·ÿ×ü¸ÿ×üºÿ×ü»ÿìü¼ÿìü½ÿìü¾ÿìüÂÿ®üÃÿ×üÄÿ®üÅÿ×üÆÿ®üÇÿ×üÈÿìüÉÿ×üÊÿìüËÿ×üÌÿìüÍÿ×üÎÿìüÏÿ×üÑÿ×üÓÿ×üÕÿ×ü×ÿ×üÙÿ×üÛÿ×üÝÿ×üÞÿìüßÿìüàÿìüáÿìüâÿìüãÿìüäÿìüåÿìüúÿìüÿìüÿìü ÿìüÿìüÿ×üÿìüÿ×üÿìüÿ×üÿìüÿ×üÿìüÿìüÿìü!ÿìü+ÿìü-ÿìü/ÿìü1ÿìü3ÿìü5ÿìüCÿ®üDÿ×üFÿ×üGÿìüHÿ×üJÿìüÿšü ÿšüWÿìüXÿ®üYÿ×ü_ÿìü`ÿ×übÿìüÿ®üÿ×üÿ®ü ÿ×ü!ÿ®ü"ÿ×ü#ÿ®ü%ÿ®ü&ÿ×ü'ÿ®ü(ÿ×ü)ÿ®ü*ÿ×ü+ÿ®ü,ÿ×ü-ÿ®ü.ÿ×ü/ÿ®ü0ÿ×ü1ÿ®ü2ÿ×ü3ÿ®ü4ÿ×ü6ÿ×ü8ÿ×ü:ÿ×ü<ÿ×ü@ÿ×üBÿ×üDÿ×üIÿìüJÿ×üKÿìüLÿ×üMÿìüNÿ×üOÿìüQÿìüRÿ×üSÿìüTÿ×üUÿìüVÿ×üWÿìüXÿ×üYÿìüZÿ×ü[ÿìü\ÿ×ü]ÿìü^ÿ×ü_ÿìü`ÿ×übÿìüdÿìüfÿìühÿìüjÿìülÿìünÿìýRý Rýÿ®ýÿ®ý")ýRýÿ®ý Rý ÿ®þÿšþÿšþ")þ$ÿ®þ&ÿìþ*ÿìþ2ÿìþ4ÿìþDÿ×þFÿ×þGÿ×þHÿ×þJÿìþPÿìþQÿìþRÿ×þSÿìþTÿ×þUÿìþVÿìþXÿìþ‚ÿ®þƒÿ®þ„ÿ®þ…ÿ®þ†ÿ®þ‡ÿ®þ‰ÿìþ”ÿìþ•ÿìþ–ÿìþ—ÿìþ˜ÿìþšÿìþ¢ÿ×þ£ÿ×þ¤ÿ×þ¥ÿ×þ¦ÿ×þ§ÿ×þ¨ÿ×þ©ÿ×þªÿ×þ«ÿ×þ¬ÿ×þ­ÿ×þ´ÿ×þµÿ×þ¶ÿ×þ·ÿ×þ¸ÿ×þºÿ×þ»ÿìþ¼ÿìþ½ÿìþ¾ÿìþÂÿ®þÃÿ×þÄÿ®þÅÿ×þÆÿ®þÇÿ×þÈÿìþÉÿ×þÊÿìþËÿ×þÌÿìþÍÿ×þÎÿìþÏÿ×þÑÿ×þÓÿ×þÕÿ×þ×ÿ×þÙÿ×þÛÿ×þÝÿ×þÞÿìþßÿìþàÿìþáÿìþâÿìþãÿìþäÿìþåÿìþúÿìþÿìþÿìþ ÿìþÿìþÿ×þÿìþÿ×þÿìþÿ×þÿìþÿ×þÿìþÿìþÿìþ!ÿìþ+ÿìþ-ÿìþ/ÿìþ1ÿìþ3ÿìþ5ÿìþCÿ®þDÿ×þFÿ×þGÿìþHÿ×þJÿìþÿšþ ÿšþWÿìþXÿ®þYÿ×þ_ÿìþ`ÿ×þbÿìþÿ®þÿ×þÿ®þ ÿ×þ!ÿ®þ"ÿ×þ#ÿ®þ%ÿ®þ&ÿ×þ'ÿ®þ(ÿ×þ)ÿ®þ*ÿ×þ+ÿ®þ,ÿ×þ-ÿ®þ.ÿ×þ/ÿ®þ0ÿ×þ1ÿ®þ2ÿ×þ3ÿ®þ4ÿ×þ6ÿ×þ8ÿ×þ:ÿ×þ<ÿ×þ@ÿ×þBÿ×þDÿ×þIÿìþJÿ×þKÿìþLÿ×þMÿìþNÿ×þOÿìþQÿìþRÿ×þSÿìþTÿ×þUÿìþVÿ×þWÿìþXÿ×þYÿìþZÿ×þ[ÿìþ\ÿ×þ]ÿìþ^ÿ×þ_ÿìþ`ÿ×þbÿìþdÿìþfÿìþhÿìþjÿìþlÿìþnÿìÿRÿ Rÿÿ®ÿÿ®ÿ")ÿRÿÿ®ÿ Rÿ ÿ®ÿ…ÿ…")$ÿ…&ÿ×*ÿ×2ÿ×4ÿ×DÿšFÿšGÿšHÿšJÿ×PÿÃQÿÃRÿšSÿÃTÿšUÿÃVÿ®XÿÃ]ÿׂÿ…ƒÿ…„ÿ……ÿ…†ÿ…‡ÿ…‰ÿ×”ÿוÿ×–ÿ×—ÿטÿךÿ×¢ÿš£ÿš¤ÿš¥ÿš¦ÿš§ÿš¨ÿš©ÿšªÿš«ÿš¬ÿš­ÿš´ÿšµÿš¶ÿš·ÿš¸ÿšºÿš»ÿüÿýÿþÿÃÂÿ…ÃÿšÄÿ…ÅÿšÆÿ…ÇÿšÈÿ×ÉÿšÊÿ×ËÿšÌÿ×ÍÿšÎÿ×ÏÿšÑÿšÓÿšÕÿš×ÿšÙÿšÛÿšÝÿšÞÿ×ßÿ×àÿ×áÿ×âÿ×ãÿ×äÿ×åÿ×úÿÃÿÃÿà ÿÃÿ×ÿšÿ×ÿšÿ×ÿšÿ×ÿšÿÃÿÃÿ®!ÿ®+ÿÃ-ÿÃ/ÿÃ1ÿÃ3ÿÃ5ÿÃ<ÿ×>ÿ×@ÿ×Cÿ…DÿšFÿšGÿ×HÿšJÿ®ÿ… ÿ…WÿÃXÿ…Yÿš_ÿ×`ÿšbÿÃÿ…ÿšÿ… ÿš!ÿ…"ÿš#ÿ…%ÿ…&ÿš'ÿ…(ÿš)ÿ…*ÿš+ÿ…,ÿš-ÿ….ÿš/ÿ…0ÿš1ÿ…2ÿš3ÿ…4ÿš6ÿš8ÿš:ÿš<ÿš@ÿšBÿšDÿšIÿ×JÿšKÿ×LÿšMÿ×NÿšOÿ×Qÿ×RÿšSÿ×TÿšUÿ×VÿšWÿ×XÿšYÿ×Zÿš[ÿ×\ÿš]ÿ×^ÿš_ÿ×`ÿšbÿÃdÿÃfÿÃhÿÃjÿÃlÿÃnÿÃR Rÿ®ÿ®")Rÿ® R ÿ®7ÿ®$ÿ®&ÿ®qÿ®ÿ®¦ÿ®¼ÿ®Äÿ®Üÿ×äÿשÿ®ªÿ×µÿ®¶ÿ×½ÿ®¾ÿ×ÿ®ÿ×ÿ®7ÿ®$ÿ®&ÿ®qÿ®ÿ®¦ÿ®¼ÿ®Äÿ®Üÿ×äÿשÿ®ªÿ×µÿ®¶ÿ×½ÿ®¾ÿ×ÿ®ÿ×ÿ®7ÿ®$ÿ®&ÿ®qÿ®ÿ®¦ÿ®¼ÿ®Äÿ®Üÿ×äÿשÿ®ªÿ×µÿ®¶ÿ×½ÿ®¾ÿ×ÿ®ÿ×ÿ®$ÿq7)9):)<Dÿ®Fÿ…Gÿ…Hÿ…JÿÃPÿÃQÿÃRÿ…SÿÃTÿ…UÿÃVÿÃXÿÂÿqƒÿq„ÿq…ÿq†ÿq‡ÿqŸ¢ÿ…£ÿ®¤ÿ®¥ÿ®¦ÿ®§ÿ®¨ÿ®©ÿ…ªÿ…«ÿ…¬ÿ…­ÿ…´ÿ…µÿ…¶ÿ…·ÿ…¸ÿ…ºÿ…»ÿüÿýÿþÿÃÂÿqÃÿ®ÄÿqÅÿ®ÆÿqÇÿ®Éÿ…Ëÿ…Íÿ…Ïÿ…Ñÿ…Óÿ…Õÿ…×ÿ…Ùÿ…Ûÿ…Ýÿ…ßÿÃáÿÃãÿÃåÿÃúÿÃÿÃÿà ÿÃÿ…ÿ…ÿ…ÿ…ÿÃÿÃÿÃ!ÿÃ$)&)+ÿÃ-ÿÃ/ÿÃ1ÿÃ3ÿÃ5ÿÃ6)8:CÿqDÿ®Fÿ®Hÿ…JÿÃVÿq_ÿqbÿqiÿqyÿ®zÿ×{ÿ×~ÿ®ÿÂÿ׃ÿׄÿׇÿ׉ÿ׌ÿ®ŽÿÃÿ®ÿ®“ÿ®™ÿ®¤ÿ…ªÿq®ÿ…µÿ…Êÿ×ÎÿqÏÿ…ÕÿqØÿ…Ûÿ…Þÿ…êÿ…íÿ…îÿÃòÿqú)ü)þ)WÿÃXÿqYÿ®`ÿ…bÿÃjÿ…rÿqsÿq}ÿìÿ……ÿ…‡ÿ…‰ÿ…ÿ…²ÿ…´ÿ…Îÿ…ÏÿqÙÿqÚÿ×ÛÿqÜÿ×ÝÿqÞÿ×àÿ…âÿ×äÿ×ðÿ…òÿ…ôÿ… ÿq ÿ… ÿq ÿ…ÿ…ÿqÿ…ÿ…ÿ…ÿqÿqÿ®ÿq ÿ®!ÿq"ÿ®#ÿq%ÿq&ÿ®'ÿq(ÿ®)ÿq*ÿ®+ÿq,ÿ®-ÿq.ÿ®/ÿq0ÿ®1ÿq2ÿ®3ÿq4ÿ®6ÿ…8ÿ…:ÿ…<ÿ…@ÿ…Bÿ…Dÿ…Jÿ…Lÿ…Nÿ…Rÿ…Tÿ…Vÿ…Xÿ…Zÿ…\ÿ…^ÿ…`ÿ…bÿÃdÿÃfÿÃhÿÃjÿÃlÿÃnÿÃoqs)$ÿq7)9):)<Dÿ®Fÿ…Gÿ…Hÿ…JÿÃPÿÃQÿÃRÿ…SÿÃTÿ…UÿÃVÿÃXÿÂÿqƒÿq„ÿq…ÿq†ÿq‡ÿqŸ¢ÿ…£ÿ®¤ÿ®¥ÿ®¦ÿ®§ÿ®¨ÿ®©ÿ…ªÿ…«ÿ…¬ÿ…­ÿ…´ÿ…µÿ…¶ÿ…·ÿ…¸ÿ…ºÿ…»ÿüÿýÿþÿÃÂÿqÃÿ®ÄÿqÅÿ®ÆÿqÇÿ®Éÿ…Ëÿ…Íÿ…Ïÿ…Ñÿ…Óÿ…Õÿ…×ÿ…Ùÿ…Ûÿ…Ýÿ…ßÿÃáÿÃãÿÃåÿÃúÿÃÿÃÿà ÿÃÿ…ÿ…ÿ…ÿ…ÿÃÿÃÿÃ!ÿÃ$)&)+ÿÃ-ÿÃ/ÿÃ1ÿÃ3ÿÃ5ÿÃ6)8:CÿqDÿ®Fÿ®Hÿ…JÿÃVÿq_ÿqbÿqiÿqyÿ®zÿ×{ÿ×~ÿ®ÿÂÿ׃ÿׄÿׇÿ׉ÿ׌ÿ®ŽÿÃÿ®ÿ®“ÿ®™ÿ®¤ÿ…ªÿq®ÿ…µÿ…Êÿ×ÎÿqÏÿ…ÕÿqØÿ…Ûÿ…Þÿ…êÿ…íÿ…îÿÃòÿqú)ü)þ)WÿÃXÿqYÿ®`ÿ…bÿÃjÿ…rÿqsÿq}ÿìÿ……ÿ…‡ÿ…‰ÿ…ÿ…²ÿ…´ÿ…Îÿ…ÏÿqÙÿqÚÿ×ÛÿqÜÿ×ÝÿqÞÿ×àÿ…âÿ×äÿ×ðÿ…òÿ…ôÿ… ÿq ÿ… ÿq ÿ…ÿ…ÿqÿ…ÿ…ÿ…ÿqÿqÿ®ÿq ÿ®!ÿq"ÿ®#ÿq%ÿq&ÿ®'ÿq(ÿ®)ÿq*ÿ®+ÿq,ÿ®-ÿq.ÿ®/ÿq0ÿ®1ÿq2ÿ®3ÿq4ÿ®6ÿ…8ÿ…:ÿ…<ÿ…@ÿ…Bÿ…Dÿ…Jÿ…Lÿ…Nÿ…Rÿ…Tÿ…Vÿ…Xÿ…Zÿ…\ÿ…^ÿ…`ÿ…bÿÃdÿÃfÿÃhÿÃjÿÃlÿÃnÿÃoqs)&ÿš*ÿš2ÿš4ÿš7ÿq8ÿ×9ÿ…:ÿ…<ÿ…‰ÿš”ÿš•ÿš–ÿš—ÿš˜ÿššÿš›ÿלÿ×ÿמÿןÿ…ÈÿšÊÿšÌÿšÎÿšÞÿšàÿšâÿšäÿšÿšÿšÿšÿš$ÿq&ÿq*ÿ×,ÿ×.ÿ×0ÿ×2ÿ×4ÿ×6ÿ…8ÿ…:ÿ…Gÿšfÿ®mÿ®qÿqrÿ…sÿšuÿ…xÿ……ÿ×ÿqŸÿš¦ÿq¸ÿš»ÿš¼ÿq¾ÿ®Áÿ\ÄÿqÜÿšáÿ…äÿšúÿ…üÿ…þÿ…ÿ…Tÿ…_ÿšaÿ×lÿš|ÿ\~ÿš€ÿ…‚ÿ…„ÿš†ÿšˆÿšŠÿšŒÿš©ÿqªÿš±ÿš³ÿšµÿq¶ÿš·ÿ…¹ÿ…½ÿq¾ÿš¿ÿ\Àÿ…Áÿ\Âÿ…Åÿ…Çÿ…Ôÿ\Õÿ…ïÿšñÿšóÿšýÿ\þÿ… ÿ…ÿšÿ…ÿšÿšÿqÿšIÿšKÿšMÿšOÿšQÿšSÿšUÿšWÿšYÿš[ÿš]ÿš_ÿšaÿ×cÿ×eÿ×gÿ×iÿ×kÿ×mÿ×oÿ…qÿ…sÿ…ÿq $ÿq 7) 9) :) < Dÿ® Fÿ… Gÿ… Hÿ… Jÿà Pÿà Qÿà Rÿ… Sÿà Tÿ… Uÿà Vÿà Xÿà ‚ÿq ƒÿq „ÿq …ÿq †ÿq ‡ÿq Ÿ ¢ÿ… £ÿ® ¤ÿ® ¥ÿ® ¦ÿ® §ÿ® ¨ÿ® ©ÿ… ªÿ… «ÿ… ¬ÿ… ­ÿ… ´ÿ… µÿ… ¶ÿ… ·ÿ… ¸ÿ… ºÿ… »ÿà ¼ÿà ½ÿà ¾ÿà Âÿq Ãÿ® Äÿq Åÿ® Æÿq Çÿ® Éÿ… Ëÿ… Íÿ… Ïÿ… Ñÿ… Óÿ… Õÿ… ×ÿ… Ùÿ… Ûÿ… Ýÿ… ßÿà áÿà ãÿà åÿà úÿà ÿà ÿà  ÿà ÿ… ÿ… ÿ… ÿ… ÿà ÿà ÿà !ÿà $) &) +ÿà -ÿà /ÿà 1ÿà 3ÿà 5ÿà 6) 8 : Cÿq Dÿ® Fÿ® Hÿ… Jÿà Vÿq _ÿq bÿq iÿq yÿ® zÿ× {ÿ× ~ÿ® ÿà ‚ÿ× ƒÿ× „ÿ× ‡ÿ× ‰ÿ× Œÿ® Žÿà ÿ® ÿ® “ÿ® ™ÿ® ¤ÿ… ªÿq ®ÿ… µÿ… Êÿ× Îÿq Ïÿ… Õÿq Øÿ… Ûÿ… Þÿ… êÿ… íÿ… îÿà òÿq ú) ü) þ)  Wÿà Xÿq Yÿ® `ÿ… bÿà jÿ… rÿq sÿq }ÿì ÿ… …ÿ… ‡ÿ… ‰ÿ… ÿ… ²ÿ… ´ÿ… Îÿ… Ïÿq Ùÿq Úÿ× Ûÿq Üÿ× Ýÿq Þÿ× àÿ… âÿ× äÿ× ðÿ… òÿ… ôÿ…  ÿq  ÿ…  ÿq  ÿ… ÿ… ÿq ÿ… ÿ… ÿ… ÿq ÿq ÿ® ÿq  ÿ® !ÿq "ÿ® #ÿq %ÿq &ÿ® 'ÿq (ÿ® )ÿq *ÿ® +ÿq ,ÿ® -ÿq .ÿ® /ÿq 0ÿ® 1ÿq 2ÿ® 3ÿq 4ÿ® 6ÿ… 8ÿ… :ÿ… <ÿ… @ÿ… Bÿ… Dÿ… Jÿ… Lÿ… Nÿ… Rÿ… Tÿ… Vÿ… Xÿ… Zÿ… \ÿ… ^ÿ… `ÿ… bÿà dÿà fÿà hÿà jÿà lÿà nÿà o q s ) &ÿš *ÿš 2ÿš 4ÿš 7ÿq 8ÿ× 9ÿ… :ÿ… <ÿ… ‰ÿš ”ÿš •ÿš –ÿš —ÿš ˜ÿš šÿš ›ÿ× œÿ× ÿ× žÿ× Ÿÿ… Èÿš Êÿš Ìÿš Îÿš Þÿš àÿš âÿš äÿš ÿš ÿš ÿš ÿš $ÿq &ÿq *ÿ× ,ÿ× .ÿ× 0ÿ× 2ÿ× 4ÿ× 6ÿ… 8ÿ… :ÿ… Gÿš fÿ® mÿ® qÿq rÿ… sÿš uÿ… xÿ… …ÿ× ÿq Ÿÿš ¦ÿq ¸ÿš »ÿš ¼ÿq ¾ÿ® Áÿ\ Äÿq Üÿš áÿ… äÿš úÿ… üÿ… þÿ… ÿ… Tÿ… _ÿš aÿ× lÿš |ÿ\ ~ÿš €ÿ… ‚ÿ… „ÿš †ÿš ˆÿš Šÿš Œÿš ©ÿq ªÿš ±ÿš ³ÿš µÿq ¶ÿš ·ÿ… ¹ÿ… ½ÿq ¾ÿš ¿ÿ\ Àÿ… Áÿ\ Âÿ… Åÿ… Çÿ… Ôÿ\ Õÿ… ïÿš ñÿš óÿš ýÿ\ þÿ…  ÿ… ÿš ÿ… ÿš ÿš ÿq ÿš Iÿš Kÿš Mÿš Oÿš Qÿš Sÿš Uÿš Wÿš Yÿš [ÿš ]ÿš _ÿš aÿ× cÿ× eÿ× gÿ× iÿ× kÿ× mÿ× oÿ… qÿ… sÿ… ÿq!qÿ×!rÿì!xÿì!TÿìSÿÃSÿÃSÿÃS ÿÃTÿ…Tÿ…TVÿ…T_ÿ…Tbÿ…Tfÿ×Tiÿ…Tmÿ×TsÿÃTvÿìTyÿšTzÿ®T{ÿÃT|ÿÃT}ÿÃT~ÿšTÿÃT‚ÿ®T„ÿÃT†ÿÃT‡ÿÃT‰ÿÃTŒÿšTŽÿšTÿšTÿšT’ÿÃT“ÿšT•ÿÃT–ÿÃT˜ÿÃT™ÿšTšÿÃT›ÿÃTÿ…T ÿ…T!ÿìXÿqX ÿqX&ÿ×X*ÿ×X- X2ÿ×X4ÿ×X7ÿqX9ÿ®X:ÿ®X<ÿ…X‰ÿ×X”ÿ×X•ÿ×X–ÿ×X—ÿ×X˜ÿ×Xšÿ×XŸÿ…XÈÿ×XÊÿ×XÌÿ×XÎÿ×XÞÿ×Xàÿ×Xâÿ×Xäÿ×Xÿ×Xÿ×Xÿ×Xÿ×X$ÿqX&ÿqX6ÿ®X8ÿ…X:ÿ…XGÿ×Xúÿ®Xüÿ®Xþÿ®Xÿ…XÿqX ÿqX_ÿ×XIÿ×XKÿ×XMÿ×XOÿ×XQÿ×XSÿ×XUÿ×XWÿ×XYÿ×X[ÿ×X]ÿ×X_ÿ×Xoÿ…Xqÿ…Xsÿ…XÿqYÿìY ÿìYÿìY ÿìZÿ®Zÿ®ZVÿ×Z_ÿ×Zbÿ×ZdÿìZiÿ×ZpÿìZqÿÃZrÿìZtÿ×ZuÿìZxÿìZˆÿìZÿ®Z ÿ®ZTÿì`IR`WR`Yf`Zf`[f`\f`¿f`%R`'R`7f`ûf`ýf`4R`5R`]R`^R`pf`R`RbIfbWfbYfbZfb[fb\fb¿fb%fb'fb7fbûfbýfb4fb5fb]fb^fbpfbfbfjÿìj ÿìjÿìj ÿìlÿ®lÿ®lÿìl¤ÿ×l¦ÿìl¨ÿ×lªÿ×l®ÿ×l°ÿ×l±ÿìlµÿ×l¼ÿÃl½ÿ×l¿ÿ×lÁÿ×lÄÿìlÇÿìlÎÿìlÕÿìlòÿìlÿ®l ÿ®lrÿ×lsÿìlzÿìl|ÿ×l€ÿìl‚ÿìlŸÿ×l¡ÿìl©ÿìlµÿÃl·ÿìl¹ÿìl»ÿ×l½ÿìl¿ÿ×lÁÿ×lÊÿ×lÎÿ×lÏÿìlÔÿ×lÙÿ×lÛÿ×lÝÿ×låÿ×lçÿìlõÿìl÷ÿ×lùÿ×lûÿ×lýÿ×lÿ×lÿ×l ÿ×lÿ×lÿ×lÿìlÿìlÿ×lÿìmÿ®mÿ®mÎÿ×mÕÿ×mòÿ×mÿ®m ÿ®msÿ×mÏÿ×mÿ×mÿ×nÿ®n ÿ®nÿ×n¦ÿ×n¼ÿ®nÁÿ®nÄÿ×nÜÿ×näÿ×nÿ®n ÿ®n|ÿ®n€ÿÃn‚ÿÃn©ÿ×nªÿ×nµÿ®n¶ÿ×n·ÿÃn¹ÿÃn½ÿ×n¾ÿ×n¿ÿ®nÁÿ®nÔÿ®nýÿ®n ÿšnÿšnÿ×nÿ×oÿ…o ÿ…oÐÿ×oÜÿšoÝÿÃoßÿ×oáÿ®oäÿšoöÿÃoÿ…o ÿ…omÿ×oÿ×oƒÿ×o‹ÿ×o ÿ×oªÿšo¶ÿšo¸ÿÃoºÿÃo¼ÿ×o¾ÿšoÀÿ®oÂÿ®oÆÿ×oÈÿ×oËÿ×oÕÿ®oæÿ×oêÿ×oøÿÃoúÿÃoüÿÃoþÿ®oÿ×oÿ×oÿšoÿšoÿšpŸÿ×p¸ÿ×p»ÿ×p¾ÿ×páÿ×plÿ×p~ÿ×p„ÿ×p†ÿ×pˆÿ×pŠÿ×pŒÿ×p±ÿ×p³ÿ×pÀÿ×pÂÿ×pÅÿ×pÇÿ×pÕÿ×pïÿ×pñÿ×póÿ×pþÿ×p ÿ×p ÿ×pÿ×pÿ×pÿ×rÿqr ÿqrÿšr¦ÿšr¼ÿqr¾ÿ×rÁÿšrÄÿšrÜÿ×ráÿ×räÿ×rÿqr ÿqrnÿ×r|ÿšr€ÿ®r‚ÿ®r—ÿ×r›ÿ×r§ÿ×r©ÿšrªÿ×rµÿqr¶ÿ×r·ÿ…r¹ÿ…r½ÿšr¾ÿ×r¿ÿšrÀÿ×rÁÿšrÂÿ×rÅÿšrÇÿšrÔÿšrÕÿ×ráÿ×rãÿ×rýÿšrþÿ×rÿ×r ÿqrÿ×rÿqrÿ×rÿšrÿ×sÿqs ÿqsÏÿ×sØÿ×sÛÿ×sÜÿšsÝÿÃsÞÿ×sáÿÃsäÿšsêÿ×síÿ×söÿÃsÿqs ÿqsjÿ×smÿ×s}ÿìsÿ×sÿ×sƒÿ×s…ÿ×s‡ÿ×s‰ÿ×s‹ÿ×sÿ×sªÿšs²ÿ×s´ÿ×s¶ÿšs¸ÿ×sºÿ×s¾ÿšsÀÿÃsÂÿÃsÆÿ×sÈÿ×sÕÿÃsàÿ×sðÿ×sòÿ×sôÿ×søÿÃsúÿÃsüÿÃsþÿÃs ÿ×s ÿ×sÿ…sÿ…sÿ×sÿšsÿ×tÿqt ÿqtÿšt¦ÿšt¼ÿqt¾ÿ×tÁÿštÄÿštÜÿ×táÿ×täÿ×tÿqt ÿqtnÿ×t|ÿšt€ÿ®t‚ÿ®t—ÿ×t›ÿ×t§ÿ×t©ÿštªÿ×tµÿqt¶ÿ×t·ÿ…t¹ÿ…t½ÿšt¾ÿ×t¿ÿštÀÿ×tÁÿštÂÿ×tÅÿštÇÿštÔÿštÕÿ×táÿ×tãÿ×týÿštþÿ×tÿ×t ÿqtÿ×tÿqtÿ×tÿštÿ×uÿqu ÿquÏÿ×uØÿ×uÛÿ×uÜÿšuÝÿÃuÞÿ×uáÿÃuäÿšuêÿ×uíÿ×uöÿÃuÿqu ÿqujÿ×umÿ×u}ÿìuÿ×uÿ×uƒÿ×u…ÿ×u‡ÿ×u‰ÿ×u‹ÿ×uÿ×uªÿšu²ÿ×u´ÿ×u¶ÿšu¸ÿ×uºÿ×u¾ÿšuÀÿÃuÂÿÃuÆÿ×uÈÿ×uÕÿÃuàÿ×uðÿ×uòÿ×uôÿ×uøÿÃuúÿÃuüÿÃuþÿÃu ÿ×u ÿ×uÿ…uÿ…uÿ×uÿšuÿ×v ÿìvÿìx ÿìxÿìzÿ®zÿ®zÿ®z ÿ®z€ÿìz‚ÿìz·ÿìz¹ÿìz ÿ×zÿ×|ÿq|ÿq|¤ÿÃ|ªÿ®|®ÿÃ|µÿÃ|Îÿ×|Õÿ×|òÿ×|ÿq| ÿq|rÿ®|sÿ×|ÎÿÃ|Ïÿ×|Ùÿ®|Ûÿ®|Ýÿ®| ÿ®| ÿ®|ÿÃ|ÿ×|ÿÃ|ÿ×}ÿì} ÿì}Ðÿ×}Üÿì}Ýÿì}ßÿ×}áÿì}äÿì}öÿì}ÿì} ÿì} ÿ×}ªÿì}¶ÿì}¼ÿ×}¾ÿì}Àÿì}Âÿì}Ëÿ×}Õÿì}æÿ×}øÿì}úÿì}üÿì}þÿì}ÿ×}ÿ×}ÿì}ÿì}ÿì~ÿ®~ÿ®~ÿì~¤ÿ×~¦ÿì~¨ÿ×~ªÿ×~®ÿ×~°ÿ×~±ÿì~µÿ×~¼ÿÃ~½ÿ×~¿ÿ×~Áÿ×~Äÿì~Çÿì~Îÿì~Õÿì~òÿì~ÿ®~ ÿ®~rÿ×~sÿì~zÿì~|ÿ×~€ÿì~‚ÿì~Ÿÿ×~¡ÿì~©ÿì~µÿÃ~·ÿì~¹ÿì~»ÿ×~½ÿì~¿ÿ×~Áÿ×~Êÿ×~Îÿ×~Ïÿì~Ôÿ×~Ùÿ×~Ûÿ×~Ýÿ×~åÿ×~çÿì~õÿì~÷ÿ×~ùÿ×~ûÿ×~ýÿ×~ÿ×~ÿ×~ ÿ×~ÿ×~ÿ×~ÿì~ÿì~ÿ×~ÿìÿì ÿìÐÿ×ÜÿìÝÿìßÿ×áÿìäÿìöÿìÿì ÿì ÿתÿì¶ÿì¼ÿ×¾ÿìÀÿìÂÿìËÿ×Õÿìæÿ×øÿìúÿìüÿìþÿìÿ×ÿ×ÿìÿìÿì€ÿ…€ÿ…€Ÿÿ쀤ÿš€ªÿq€®ÿš€µÿš€¸ÿ쀻ÿ쀾ÿÀÉÿì€Îÿ®€Ïÿ×€Õÿ®€Øÿ×€Ûÿ×€Þÿ×€áÿ×€êÿ×€ëf€íÿ×€îÿì€òÿ®€ôf€ÿ…€ ÿ…€jÿ×€lÿì€rÿq€sÿ®€~ÿì€ÿ×€„ÿ쀅ÿ×€†ÿ쀇ÿ×€ˆÿ쀉ÿ×€Šÿ쀌ÿì€ÿ×€˜f€¨f€±ÿ쀲ÿ×€³ÿ쀴ÿ×€Àÿ×€Âÿ×€Åÿ×€ÆÿÀÇÿ×€ÈÿÀÎÿš€Ïÿ®€Õÿ×€Ùÿq€Ûÿq€Ýÿq€àÿ×€ïÿì€ðÿ×€ñÿì€òÿ×€óÿì€ôÿ×€þÿ×€ ÿq€ ÿ×€ ÿq€ ÿ×€ÿš€ÿ®€ÿì€ÿ×€ÿ×€ÿš€ÿ®ÿ®ÿ®Îÿ×Õÿ×òÿ×ÿ® ÿ®sÿ×Ïÿ×ÿ×ÿׂÿ…‚ÿ…‚Ÿÿ삤ÿš‚ªÿq‚®ÿš‚µÿš‚¸ÿì‚»ÿ삾ÿÂÉÿì‚Îÿ®‚ÏÿׂÕÿ®‚ØÿׂÛÿׂÞÿׂáÿׂêÿׂëf‚íÿׂîÿì‚òÿ®‚ôf‚ÿ…‚ ÿ…‚jÿׂlÿì‚rÿq‚sÿ®‚~ÿì‚ÿׂ„ÿì‚…ÿׂ†ÿ삇ÿׂˆÿ삉ÿׂŠÿì‚Œÿì‚ÿׂ˜f‚¨f‚±ÿ삲ÿׂ³ÿì‚´ÿׂÀÿׂÂÿׂÅÿׂÆÿÂÇÿׂÈÿÂÎÿš‚Ïÿ®‚ÕÿׂÙÿq‚Ûÿq‚Ýÿq‚àÿׂïÿì‚ðÿׂñÿì‚òÿׂóÿì‚ôÿׂþÿׂ ÿq‚ ÿׂ ÿq‚ ÿׂÿš‚ÿ®‚ÿì‚ÿׂÿׂÿš‚ÿ®ƒÿ®ƒÿ®ƒÎÿ׃Õÿ׃òÿ׃ÿ®ƒ ÿ®ƒsÿ׃Ïÿ׃ÿ׃ÿׄÿ®„ÿ®„ÎÿׄÕÿׄòÿׄÿ®„ ÿ®„sÿׄÏÿׄÿׄÿ×…ÿ®…ÿ®…Îÿ×…Õÿ×…òÿ×…ÿ®… ÿ®…sÿ×…Ïÿ×…ÿ×…ÿ׆ÿ®†ÿ®†ÿ솤ÿ׆¦ÿ솨ÿ׆ªÿ׆®ÿ׆°ÿ׆±ÿ솵ÿ׆¼ÿƽÿ׆¿ÿ׆Áÿ׆Äÿì†Çÿì†Îÿì†Õÿì†òÿì†ÿ®† ÿ®†rÿ׆sÿì†zÿì†|ÿ׆€ÿ솂ÿ솟ÿ׆¡ÿ솩ÿ솵ÿÆ·ÿ솹ÿ솻ÿ׆½ÿ솿ÿ׆Áÿ׆Êÿ׆Îÿ׆Ïÿì†Ôÿ׆Ùÿ׆Ûÿ׆Ýÿ׆åÿ׆çÿì†õÿì†÷ÿ׆ùÿ׆ûÿ׆ýÿ׆ÿ׆ÿ׆ ÿ׆ÿ׆ÿ׆ÿì†ÿì†ÿ׆ÿì‡ÿì‡ ÿì‡ÐÿׇÜÿì‡Ýÿì‡ßÿׇáÿì‡äÿì‡öÿì‡ÿì‡ ÿ쇠ÿׇªÿ쇶ÿ쇼ÿׇ¾ÿì‡Àÿì‡Âÿì‡ËÿׇÕÿì‡æÿׇøÿì‡úÿì‡üÿì‡þÿì‡ÿׇÿׇÿì‡ÿì‡ÿìˆÿ®ˆÿ®ˆÿ숤ÿ׈¦ÿ숨ÿ׈ªÿ׈®ÿ׈°ÿ׈±ÿ숵ÿ׈¼ÿȽÿ׈¿ÿ׈Áÿ׈ÄÿìˆÇÿìˆÎÿìˆÕÿìˆòÿìˆÿ®ˆ ÿ®ˆrÿ׈sÿìˆzÿìˆ|ÿ׈€ÿ숂ÿ숟ÿ׈¡ÿ숩ÿ숵ÿÈ·ÿ숹ÿ숻ÿ׈½ÿ숿ÿ׈Áÿ׈Êÿ׈Îÿ׈ÏÿìˆÔÿ׈Ùÿ׈Ûÿ׈Ýÿ׈åÿ׈çÿìˆõÿìˆ÷ÿ׈ùÿ׈ûÿ׈ýÿ׈ÿ׈ÿ׈ ÿ׈ÿ׈ÿ׈ÿìˆÿìˆÿ׈ÿì‰ÿì‰ ÿì‰Ðÿ׉Üÿì‰Ýÿì‰ßÿ׉áÿì‰äÿì‰öÿì‰ÿì‰ ÿ쉠ÿ׉ªÿ쉶ÿ쉼ÿ׉¾ÿì‰Àÿì‰Âÿì‰Ëÿ׉Õÿì‰æÿ׉øÿì‰úÿì‰üÿì‰þÿì‰ÿ׉ÿ׉ÿì‰ÿì‰ÿìŠÿ®Šÿ®Šÿ스ÿ׊¦ÿ슨ÿ׊ªÿ׊®ÿ׊°ÿ׊±ÿ습ÿ׊¼ÿʽÿ׊¿ÿ׊Áÿ׊ÄÿìŠÇÿìŠÎÿìŠÕÿìŠòÿìŠÿ®Š ÿ®Šrÿ׊sÿìŠzÿìŠ|ÿ׊€ÿ슂ÿ슟ÿ׊¡ÿ슩ÿ습ÿÊ·ÿ승ÿ슻ÿ׊½ÿ슿ÿ׊Áÿ׊Êÿ׊Îÿ׊ÏÿìŠÔÿ׊Ùÿ׊Ûÿ׊Ýÿ׊åÿ׊çÿìŠõÿìŠ÷ÿ׊ùÿ׊ûÿ׊ýÿ׊ÿ׊ÿ׊ ÿ׊ÿ׊ÿ׊ÿìŠÿìŠÿ׊ÿì‹ÿ®‹ÿ®‹Îÿ׋Õÿ׋òÿ׋ÿ®‹ ÿ®‹sÿ׋Ïÿ׋ÿ׋ÿ׌Ÿÿ׌¸ÿ׌»ÿ׌¾ÿ׌áÿ׌lÿ׌~ÿ׌„ÿ׌†ÿ׌ˆÿ׌Šÿ׌Œÿ׌±ÿ׌³ÿ׌Àÿ׌Âÿ׌Åÿ׌Çÿ׌Õÿ׌ïÿ׌ñÿ׌óÿ׌þÿ׌ ÿ׌ ÿ׌ÿ׌ÿ׌ÿו£á•ê)•ÿוÿ×–ÿì– ÿì–ÿì– ÿì—ÿ®— ÿ®—ÿ×—¦ÿ×—¼ÿ®—Áÿ®—Äÿ×—Üÿ×—äÿ×—ÿ®— ÿ®—|ÿ®—€ÿׂÿשÿ×—ªÿ×—µÿ®—¶ÿ×—·ÿ×¹ÿ×½ÿ×—¾ÿ×—¿ÿ®—Áÿ®—Ôÿ®—ýÿ®— ÿš—ÿš—ÿ×—ÿטÿ…˜ ÿ…˜ÐÿטÜÿš˜ÝÿØßÿטáÿ®˜äÿš˜öÿØÿ…˜ ÿ…˜mÿטÿטƒÿט‹ÿט ÿטªÿš˜¶ÿš˜¸ÿغÿؼÿט¾ÿš˜Àÿ®˜Âÿ®˜ÆÿטÈÿטËÿטÕÿ®˜æÿטêÿטøÿØúÿØüÿØþÿ®˜ÿטÿטÿš˜ÿš˜ÿš™þö™þö™¤ÿ…™ªÿš™®ÿ…™°ÿ×™µÿ…™¿ÿ×™Îÿš™Õÿš™òÿš™þö™ þö™rÿš™sÿš™vÿ왟ÿ×™»ÿ×™Êÿ×™Îÿ…™Ïÿš™Ùÿš™Ûÿš™Ýÿš™åÿ×™ÿ×™ÿ×™ ÿ®™ ÿ®™ÿ…™ÿš™ÿ…™ÿššÿìš ÿìšÐÿךÜÿìšÝÿìšßÿךáÿìšäÿìšöÿìšÿìš ÿìš ÿךªÿ욶ÿìš¼ÿך¾ÿìšÀÿìšÂÿìšËÿךÕÿìšæÿךøÿìšúÿìšüÿìšþÿìšÿךÿךÿìšÿìšÿì›ÿš›ÿ×›ÿš›)›Ÿÿ×›¤ÿ®›¦)›ªÿ…›®ÿ®›µÿ®›¸ÿ×›»ÿ×›¼)›¾ÿÛÄ)›ÌÿÛÍÿÛÎÿš›Ïÿ®›Ðÿ×›Ñÿ×›ÒÿÛÓÿÛÔÿÛÕÿš›ÖÿÛ×ÿÛØÿ®›ÙÿÛÚÿÛÛÿ®›Þÿ®›ßÿ×›àÿÛáÿš›âÿÛãÿÛåÿÛæÿÛçÿ×›èÿÛêÿ®›ë)›ìÿÛíÿ®›îÿÛòÿš›óÿÛô)›õÿÛ÷ÿÛùÿÛÿ×›ÿ×›ÿ×›ÿš› ÿš›jÿ®›kÿÛlÿ×›qÿÛrÿ…›sÿš›uÿÛwÿ×›yÿÛ}ÿÛ~ÿ×›ÿ®›„ÿ×›…ÿ®›†ÿ×›‡ÿ®›ˆÿ×›‰ÿ®›Šÿ×›Œÿ×›ÿ®›–ÿÛ˜)›šÿÛžÿÛ ÿ×›¢ÿ×›¤ÿÛ¦ÿÛ¨)›©)›¬ÿÛ®ÿÛ°ÿÛ±ÿ×›²ÿ®›³ÿ×›´ÿ®›µ)›¼ÿ×›½)›Àÿš›Âÿš›ÄÿÛÅÿ×›ÆÿÛÇÿ×›ÈÿÛËÿ×›ÍÿÛÎÿ®›Ïÿš›ÑÿÛÓÿÛÕÿš›×ÿÛÙÿ…›Ûÿ…›Ýÿ…›àÿ®›æÿ×›èÿ×›ìÿÛîÿÛïÿ×›ðÿ®›ñÿ×›òÿ®›óÿ×›ôÿ®›öÿ×›þÿš›ÿÛÿÛÿ×›ÿ×› ÿš› ÿ®› ÿš› ÿ®›ÿ×›ÿ×›ÿ®›ÿš›ÿÛÿ×›ÿ®›)›ÿ®›ÿ®›ÿšœÿÃœÿÃœÎÿÃœÏÿלÕÿÃœØÿלÛÿלÞÿלêÿלíÿלòÿÃœÿÃœ ÿÃœjÿלsÿÃœÿל…ÿל‡ÿל‰ÿלÿל²ÿל´ÿלÏÿÃœàÿלðÿלòÿלôÿל ÿל ÿלÿÃœÿלÿלÿÃÿà ÿÃÿãf¦ÿüÿÃÁÿ®ÄÿÃÜÿ×áÿ×äÿ×ÿà ÿÃ|ÿ®€ÿÂÿéÿêÿ×µÿöÿ×·ÿ×¹ÿ×½ÿþÿ׿ÿ®Àÿ×Áÿ®Âÿ×Ôÿ®Õÿ×ýÿ®þÿ× ÿ×ÿÃÿ×ÿÃÿÃÿמÿÞ ÿÞÿÞ ÿÞÿמÿןŸÿן£áŸ¸ÿן»ÿן¾ÿßÜÿןáÿ®Ÿäÿןlÿן{=Ÿ}ÿìŸ~ÿן„ÿן†ÿןˆÿןŠÿןŒÿןªÿן±ÿן³ÿן¶ÿן¾ÿןÀÿ®ŸÂÿ®ŸÅÿßÆÿןÇÿßÈÿןÕÿ®Ÿïÿןñÿןóÿןþÿ®Ÿÿןÿןÿןÿ× Ïÿì Øÿì Ûÿì Þÿì áÿì êÿì íÿì jÿì ÿì …ÿì ‡ÿì ‰ÿì ÿì ²ÿì ´ÿì Àÿì Âÿì Õÿì àÿì ðÿì òÿì ôÿì þÿì  ÿì  ÿì ÿ× ÿ× ÿì ÿì¡ÿ®¡ÿ®¡ÿ®¡ ÿ®¡€ÿì¡‚ÿì¡·ÿ졹ÿì¡ ÿסÿ×¢é)£Ÿÿ×££á£¸ÿ×£»ÿ×£¾ÿãÜÿ×£áÿ®£äÿ×£lÿ×£{=£}ÿì£~ÿ×£„ÿ×£†ÿ×£ˆÿ×£Šÿ×£Œÿ×£ªÿ×£±ÿ×£³ÿ×£¶ÿ×£¾ÿ×£Àÿ®£Âÿ®£ÅÿãÆÿ×£ÇÿãÈÿ×£Õÿ®£ïÿ×£ñÿ×£óÿ×£þÿ®£ÿ×£ÿ×£ÿ×£ÿפÏÿì¤Øÿì¤Ûÿì¤Þÿì¤áÿì¤êÿì¤íÿì¤jÿì¤ÿ줅ÿ줇ÿ줉ÿì¤ÿ줲ÿ줴ÿì¤Àÿì¤Âÿì¤Õÿì¤àÿì¤ðÿì¤òÿì¤ôÿì¤þÿì¤ ÿì¤ ÿì¤ÿפÿפÿì¤ÿ쥟ÿ×¥¸ÿ×¥»ÿ×¥¾ÿ×¥Áÿ×¥áÿ×¥lÿ×¥|ÿ×¥~ÿ×¥„ÿ×¥†ÿ×¥ˆÿ×¥Šÿ×¥Œÿ×¥±ÿ×¥³ÿ×¥¿ÿ×¥Àÿ×¥Áÿ×¥Âÿ×¥Åÿš¥Çÿš¥Ôÿ×¥Õÿ×¥ïÿ×¥ñÿ×¥óÿ×¥ýÿ×¥þÿ×¥ ÿ×¥ ÿ×¥ÿ×¥ÿ×¥ÿ×¥ÿì¦ÏÿצØÿצÛÿצÞÿצáÿצêÿצíÿצjÿצÿצ…ÿצ‡ÿצ‰ÿצÿצ²ÿצ´ÿצÀÿצÂÿצÆÿצÈÿצÕÿצàÿצðÿצòÿצôÿצþÿצ ÿצ ÿצÿצÿקŸÿק¸ÿק»ÿק¾ÿקÁÿקáÿקlÿק|ÿק~ÿק„ÿק†ÿקˆÿקŠÿקŒÿק±ÿק³ÿק¿ÿקÀÿקÁÿקÂÿקÅÿš§Çÿš§ÔÿקÕÿקïÿקñÿקóÿקýÿקþÿק ÿק ÿקÿקÿקÿקÿì¨ÏÿרØÿרÛÿרÞÿרáÿרêÿרíÿרjÿרÿר…ÿר‡ÿר‰ÿרÿר²ÿר´ÿרÀÿרÂÿרÆÿרÈÿרÕÿרàÿרðÿרòÿרôÿרþÿר ÿר ÿרÿרÿשŸÿש¸ÿש»ÿש¾ÿשÁÿשáÿשlÿש|ÿש~ÿש„ÿש†ÿשˆÿשŠÿשŒÿש±ÿש³ÿש¿ÿשÀÿשÁÿשÂÿשÅÿš©Çÿš©ÔÿשÕÿשïÿשñÿשóÿשýÿשþÿש ÿש ÿשÿשÿשÿשÿìªÏÿתØÿתÛÿתÞÿתáÿתêÿתíÿתjÿתÿת…ÿת‡ÿת‰ÿתÿת²ÿת´ÿתÀÿתÂÿתÆÿתÈÿתÕÿתàÿתðÿתòÿתôÿתþÿת ÿת ÿתÿתÿ׫£á«ê)«ÿ׫ÿ׬ÿì¬ ÿì¬ÿì¬ ÿì­ÿš­ÿ×­ÿš­)­Ÿÿ×­¤ÿ®­¦)­ªÿ…­®ÿ®­µÿ®­¸ÿ×­»ÿ×­¼)­¾ÿíÄ)­ÌÿíÍÿíÎÿš­Ïÿ®­Ðÿ×­Ñÿ×­ÒÿíÓÿíÔÿíÕÿš­Öÿí×ÿíØÿ®­ÙÿíÚÿíÛÿ®­Þÿ®­ßÿ×­àÿíáÿš­âÿíãÿíåÿíæÿíçÿ×­èÿíêÿ®­ë)­ìÿííÿ®­îÿíòÿš­óÿíô)­õÿí÷ÿíùÿíÿ×­ÿ×­ÿ×­ÿš­ ÿš­jÿ®­kÿílÿ×­qÿírÿ…­sÿš­uÿíwÿ×­yÿí}ÿí~ÿ×­ÿ®­„ÿ×­…ÿ®­†ÿ×­‡ÿ®­ˆÿ×­‰ÿ®­Šÿ×­Œÿ×­ÿ®­–ÿí˜)­šÿížÿí ÿ×­¢ÿ×­¤ÿí¦ÿí¨)­©)­¬ÿí®ÿí°ÿí±ÿ×­²ÿ®­³ÿ×­´ÿ®­µ)­¼ÿ×­½)­Àÿš­Âÿš­ÄÿíÅÿ×­ÆÿíÇÿ×­ÈÿíËÿ×­ÍÿíÎÿ®­Ïÿš­ÑÿíÓÿíÕÿš­×ÿíÙÿ…­Ûÿ…­Ýÿ…­àÿ®­æÿ×­èÿ×­ìÿíîÿíïÿ×­ðÿ®­ñÿ×­òÿ®­óÿ×­ôÿ®­öÿ×­þÿš­ÿíÿíÿ×­ÿ×­ ÿš­ ÿ®­ ÿš­ ÿ®­ÿ×­ÿ×­ÿ®­ÿš­ÿíÿ×­ÿ®­)­ÿ®­ÿ®­ÿš®ÿš®ÿ×®ÿš®ÎÿîÏÿì®ÕÿîØÿì®Ûÿì®Þÿì®êÿì®íÿì®òÿîÿ×®ÿ×®ÿ×®ÿš® ÿš®jÿì®sÿîÿì®…ÿ쮇ÿ쮉ÿì®ÿ쮲ÿì®´ÿì®Ïÿîàÿì®ðÿì®òÿì®ôÿì® ÿì® ÿì®ÿîÿì®ÿì®ÿïÿ\¯ ÿ\¯ÿš¯£f¯¦ÿš¯¼ÿH¯Áÿ…¯Äÿš¯Üÿ®¯áÿׯäÿ®¯ÿ\¯ ÿ\¯|ÿ…¯€ÿq¯‚ÿq¯©ÿš¯ªÿ®¯µÿH¯¶ÿ®¯·ÿš¯¹ÿš¯½ÿš¯¾ÿ®¯¿ÿ…¯ÀÿׯÁÿ…¯ÂÿׯÅÿïÆÿׯÇÿïÈÿׯÔÿ…¯Õÿׯýÿ…¯þÿׯ ÿH¯ÿ®¯ÿH¯ÿ®¯ÿš¯ÿ®°ÿq° ÿq°Üÿš°áÿ×°äÿš°ÿq° ÿq°mÿ×°ÿ×°ƒÿ×°‹ÿ×°ªÿš°¶ÿš°¸ÿ×°ºÿ×°¾ÿš°Àÿ×°Âÿ×°Æÿ×°Èÿ×°Õÿ×°þÿ×°ÿq°ÿq°ÿš±ÿ×±¦ÿ×±¼ÿñÄÿ×±€ÿ챂ÿ챩ÿ×±µÿñ·ÿì±¹ÿì±½ÿ×± ÿ×±ÿ×±ÿײÿì² ÿì²ÐÿײÜÿì²Ýÿì²ßÿײáÿì²äÿì²öÿì²ÿì² ÿì² ÿײªÿ첶ÿì²¼ÿײ¾ÿì²Àÿì²Âÿì²ËÿײÕÿì²æÿײøÿì²úÿì²üÿì²þÿì²ÿײÿײÿì²ÿì²ÿ쳟ÿ׳¸ÿ׳»ÿ׳¾ÿ׳áÿ׳lÿ׳~ÿ׳„ÿ׳†ÿ׳ˆÿ׳Šÿ׳Œÿ׳±ÿ׳³ÿ׳Àÿ׳Âÿ׳Åÿ׳Çÿ׳Õÿ׳ïÿ׳ñÿ׳óÿ׳þÿ׳ ÿ׳ ÿ׳ÿ׳ÿ׳ÿ×µÿ…µÿ®µÿ…µŸÿ×µ¤ÿšµªÿqµ®ÿšµµÿšµ¸ÿ×µ»ÿ×µ¼)µ¾ÿ®µÌÿšµÍÿšµÎÿ…µÏÿqµÐÿ×µÑÿ×µÒÿšµÓÿšµÔÿšµÕÿ…µÖÿšµ×ÿšµØÿqµÙÿšµÚÿšµÛÿqµÜÿ®µÝÿ®µÞÿqµßÿ×µàÿšµáÿšµâÿšµãÿšµäÿ®µåÿšµæÿšµçÿ×µèÿšµéÿõêÿqµìÿšµíÿqµîÿ…µòÿ…µóÿšµõÿšµöÿ®µ÷ÿšµùÿšµÿ®µÿ®µÿ®µÿ…µ ÿ…µjÿqµkÿšµlÿ×µmÿ×µqÿšµrÿqµsÿ…µuÿšµwÿšµyÿšµ}ÿšµ~ÿ×µÿqµÿ×µƒÿ×µ„ÿ×µ…ÿqµ†ÿ×µ‡ÿqµˆÿ×µ‰ÿqµŠÿ×µ‹ÿ×µŒÿ×µÿqµ–ÿšµšÿšµžÿšµ ÿ×µ¢ÿ×µ¤ÿšµ¦ÿšµªÿ®µ¬ÿšµ®ÿšµ°ÿšµ±ÿ×µ²ÿqµ³ÿ×µ´ÿqµµ)µ¶ÿ®µ¸ÿ®µºÿ®µ¼ÿ×µ¾ÿ®µÀÿšµÂÿšµÄÿšµÅÿšµÆÿqµÇÿšµÈÿqµËÿ×µÍÿšµÎÿšµÏÿ…µÑÿšµÓÿšµÕÿšµ×ÿšµÙÿqµÛÿqµÝÿqµàÿqµæÿ×µèÿ×µêÿõìÿšµîÿšµïÿ×µðÿqµñÿ×µòÿqµóÿ×µôÿqµöÿ×µøÿ®µúÿ®µüÿ®µþÿšµÿšµÿšµÿ×µÿ×µ ÿqµ ÿqµ ÿqµ ÿqµÿšµÿšµÿšµÿ…µÿšµÿ×µÿqµÿ®µÿqµÿšµÿ…¶ÿš¶ÿ׶ÿš¶ÎÿöÏÿì¶ÕÿöØÿì¶Ûÿì¶Þÿì¶êÿì¶íÿì¶òÿöÿ׶ÿ׶ÿ׶ÿš¶ ÿš¶jÿì¶sÿöÿ춅ÿ춇ÿ춉ÿì¶ÿ춲ÿ춴ÿì¶Ïÿöàÿì¶ðÿì¶òÿì¶ôÿì¶ ÿì¶ ÿì¶ÿöÿì¶ÿì¶ÿ÷ÿ…·ÿ…·Ÿÿ×·¤ÿ®·ªÿ…·®ÿ®·µÿ®·¸ÿ×·»ÿ×·¾ÿ÷Êÿ®·Ìÿ÷Íÿ÷Îÿš·Ïÿš·Òÿ÷Óÿ÷Ôÿ÷Õÿš·Öÿ÷×ÿ÷Øÿš·Ùÿ÷Úÿ÷Ûÿš·Þÿš·àÿ÷áÿ®·âÿ÷ãÿ÷åÿ÷æÿ÷èÿ÷éÿ×·êÿš·ë)·ìÿ÷íÿš·îÿ®·òÿš·óÿ÷ô)·õÿ÷÷ÿ÷ùÿ÷ÿ…· ÿ…·jÿš·kÿ÷lÿ×·qÿ÷rÿ…·sÿš·uÿ÷wÿ×·yÿ÷}ÿ×·~ÿ×·ÿš·„ÿ×·…ÿš·†ÿ×·‡ÿš·ˆÿ×·‰ÿš·Šÿ×·Œÿ×·ÿš·–ÿ÷˜)·šÿ÷žÿ÷¤ÿ÷¦ÿ÷¨)·¬ÿ÷®ÿ÷°ÿ÷±ÿ×·²ÿš·³ÿ×·´ÿš·Àÿ®·Âÿ®·Äÿ÷Æÿ®·Èÿ®·Íÿ÷Îÿ®·Ïÿš·Ñÿ÷Óÿ÷Õÿ®·×ÿ÷Ùÿ…·Úÿ®·Ûÿ…·Üÿ®·Ýÿ…·Þÿ®·àÿš·áÿì·âÿ®·ãÿì·äÿ®·ìÿ÷îÿ÷ïÿ×·ðÿš·ñÿ×·òÿš·óÿ×·ôÿš·þÿ®·ÿ÷ÿ÷ ÿ®· ÿš· ÿ®· ÿš·ÿ×·ÿ×·ÿ®·ÿš·ÿ÷ÿ×·ÿš·ÿì·ÿš·ÿ®·ÿš¸ÿ®¸ÿ®¸Îÿì¸Õÿì¸òÿì¸ÿ®¸ ÿ®¸sÿì¸Ïÿì¸ÿì¸ÿì¹ÿ…¹ÿ…¹Ÿÿ×¹¤ÿ®¹ªÿ…¹®ÿ®¹µÿ®¹¸ÿ×¹»ÿ×¹¾ÿùÊÿ®¹ÌÿùÍÿùÎÿš¹Ïÿš¹ÒÿùÓÿùÔÿùÕÿš¹Öÿù×ÿùØÿš¹ÙÿùÚÿùÛÿš¹Þÿš¹àÿùáÿ®¹âÿùãÿùåÿùæÿùèÿùéÿ×¹êÿš¹ë)¹ìÿùíÿš¹îÿ®¹òÿš¹óÿùô)¹õÿù÷ÿùùÿùÿ…¹ ÿ…¹jÿš¹kÿùlÿ×¹qÿùrÿ…¹sÿš¹uÿùwÿ×¹yÿù}ÿ×¹~ÿ×¹ÿš¹„ÿ×¹…ÿš¹†ÿ×¹‡ÿš¹ˆÿ×¹‰ÿš¹Šÿ×¹Œÿ×¹ÿš¹–ÿù˜)¹šÿùžÿù¤ÿù¦ÿù¨)¹¬ÿù®ÿù°ÿù±ÿ×¹²ÿš¹³ÿ×¹´ÿš¹Àÿ®¹Âÿ®¹ÄÿùÆÿ®¹Èÿ®¹ÍÿùÎÿ®¹Ïÿš¹ÑÿùÓÿùÕÿ®¹×ÿùÙÿ…¹Úÿ®¹Ûÿ…¹Üÿ®¹Ýÿ…¹Þÿ®¹àÿš¹áÿì¹âÿ®¹ãÿì¹äÿ®¹ìÿùîÿùïÿ×¹ðÿš¹ñÿ×¹òÿš¹óÿ×¹ôÿš¹þÿ®¹ÿùÿù ÿ®¹ ÿš¹ ÿ®¹ ÿš¹ÿ×¹ÿ×¹ÿ®¹ÿš¹ÿùÿ×¹ÿš¹ÿì¹ÿš¹ÿ®¹ÿšºÿ®ºÿ®ºÎÿìºÕÿìºòÿìºÿ®º ÿ®ºsÿìºÏÿìºÿìºÿ컟ÿ×»£á»¸ÿ×»»ÿ×»¾ÿûÜÿ×»áÿ®»äÿ×»lÿ×»{=»}ÿì»~ÿ×»„ÿ×»†ÿ×»ˆÿ×»Šÿ×»Œÿ×»ªÿ×»±ÿ×»³ÿ×»¶ÿ×»¾ÿ×»Àÿ®»Âÿ®»ÅÿûÆÿ×»ÇÿûÈÿ×»Õÿ®»ïÿ×»ñÿ×»óÿ×»þÿ®»ÿ×»ÿ×»ÿ×»ÿ×¼Ïÿì¼Øÿì¼Ûÿì¼Þÿì¼áÿì¼êÿì¼íÿì¼jÿì¼ÿì¼…ÿ켇ÿ켉ÿì¼ÿì¼²ÿì¼´ÿì¼Àÿì¼Âÿì¼Õÿì¼àÿì¼ðÿì¼òÿì¼ôÿì¼þÿì¼ ÿì¼ ÿì¼ÿ×¼ÿ×¼ÿì¼ÿì½£á½ê)½ÿ×½ÿ×¾ÿì¾ ÿì¾ÿì¾ ÿì¿£á¿ê)¿ÿ׿ÿ×ÀÿìÀ ÿìÀÿìÀ ÿìÃÿÃà ÿÃÃÿ×æÿ×üÿ…ÃÁÿ®ÃÄÿ×ÃÜÿ×ÃÝÿìÃáÿìÃäÿ×ÃöÿìÃÿÃà ÿÃÃ|ÿ®Ã€ÿÃÂÿÃéÿ×êÿ×õÿ…öÿ×÷ÿšÃ¹ÿšÃ½ÿ×þÿ×ÿÿ®ÃÀÿìÃÁÿ®ÃÂÿìÃÔÿ®ÃÕÿìÃøÿìÃúÿìÃüÿìÃýÿ®Ãþÿìà ÿ®Ãÿ×Ãÿ®Ãÿ×Ãÿ×Ãÿ×ÄÿšÄ ÿšÄÜÿ×ÄÝÿ×Ääÿ×Äöÿ×ÄÿšÄ ÿšÄªÿ×Ķÿ×ĸÿ×ĺÿ׾ÿ×Äøÿ×Äúÿ×Äüÿ×Äÿ®Äÿ®Äÿ׿ÿ×Å€ÿìÅ‚ÿìŵÿ×Å·ÿìŹÿìÅ ÿìÅÿìÆÿìÆ ÿìÆÿìÆ ÿìǼÿ×Ç€ÿìÇ‚ÿìǵÿ×Ç·ÿìǹÿìÇ ÿìÇÿìÈÿìÈ ÿìÈÿìÈ ÿìÊŸÿ×ʸÿ×Ê»ÿ×ʾÿ×ÊÁÿ×Êáÿ×Êlÿ×Ê|ÿ×Ê~ÿ×Ê„ÿ×ʆÿ×ʈÿ×ÊŠÿ×ÊŒÿ×ʱÿ×ʳÿ×Ê¿ÿ×ÊÀÿ×ÊÁÿ×ÊÂÿ×ÊÅÿšÊÇÿšÊÔÿ×ÊÕÿ×Êïÿ×Êñÿ×Êóÿ×Êýÿ×Êþÿ×Ê ÿ×Ê ÿ×Êÿ×Êÿ×Êÿ×ÊÿìËÏÿ×ËØÿ×ËÛÿ×ËÞÿ×Ëáÿ×Ëêÿ×Ëíÿ×Ëjÿ×Ëÿ×Ë…ÿסÿ×ˉÿ×Ëÿ×˲ÿ×Ë´ÿ×ËÀÿ×ËÂÿ×ËÆÿ×ËÈÿ×ËÕÿ×Ëàÿ×Ëðÿ×Ëòÿ×Ëôÿ×Ëþÿ×Ë ÿ×Ë ÿ×Ëÿ×Ëÿ×ÌÿÃÌ ÿÃÌ£f̼ÿ×̾ÿ×ÌÁÿ®ÌÜÿÃÌáÿ×ÌäÿÃÌÿÃÌ ÿÃÌmÿìÌ|ÿ®Ì€ÿ×ÌÿìÌ‚ÿ×̃ÿìÌ‹ÿì̪ÿÃ̵ÿ×̶ÿÃÌ·ÿ×̸ÿì̹ÿ×̺ÿì̾ÿÃÌ¿ÿ®ÌÀÿ×ÌÁÿ®ÌÂÿ×ÌÅÿÃÌÆÿ×ÌÇÿÃÌÈÿ×ÌÔÿ®ÌÕÿ×Ìýÿ®Ìþÿ×Ì ÿ×ÌÿÃÌÿ×ÌÿÃÌÿÃÍáÿ×ÍÀÿ×ÍÂÿ×ÍÕÿ×Íþÿ×ΣáÎê)Îÿ×Îÿ×ÏÿìÏ ÿìÏÿìÏ ÿìÒ£áÒê)Òÿ×Òÿ×ÓÿìÓ ÿìÓÿìÓ ÿìÖ£áÖê)Öÿ×Öÿ××ÿì× ÿì×ÿì× ÿìÙÿqÙ ÿqÙÿšÙ¦ÿšÙ¼ÿqÙ¾ÿ×ÙÁÿšÙÄÿšÙÜÿ×Ùáÿ×Ùäÿ×ÙÿqÙ ÿqÙnÿ×Ù|ÿšÙ€ÿ®Ù‚ÿ®Ù—ÿ×Ù›ÿ×Ù§ÿ×Ù©ÿšÙªÿ×ÙµÿqÙ¶ÿ×Ù·ÿ…Ù¹ÿ…Ù½ÿšÙ¾ÿ×Ù¿ÿšÙÀÿ×ÙÁÿšÙÂÿ×ÙÅÿšÙÇÿšÙÔÿšÙÕÿ×Ùáÿ×Ùãÿ×ÙýÿšÙþÿ×Ùÿ×Ù ÿqÙÿ×ÙÿqÙÿ×ÙÿšÙÿ×ÚÿìÚ ÿìÚÿìÚ ÿìÛÿqÛ ÿqÛÿšÛ¦ÿšÛ¼ÿqÛ¾ÿ×ÛÁÿšÛÄÿšÛÜÿ×Ûáÿ×Ûäÿ×ÛÿqÛ ÿqÛnÿ×Û|ÿšÛ€ÿ®Û‚ÿ®Û—ÿ×Û›ÿ×Û§ÿ×Û©ÿšÛªÿ×ÛµÿqÛ¶ÿ×Û·ÿ…Û¹ÿ…Û½ÿšÛ¾ÿ×Û¿ÿšÛÀÿ×ÛÁÿšÛÂÿ×ÛÅÿšÛÇÿšÛÔÿšÛÕÿ×Ûáÿ×Ûãÿ×ÛýÿšÛþÿ×Ûÿ×Û ÿqÛÿ×ÛÿqÛÿ×ÛÿšÛÿ×ÜÿìÜ ÿìÜÿìÜ ÿìÞÿìÞ ÿìÞÿìÞ ÿìàÿìà ÿìàÿìà ÿìáÿ®áÿ®áÿìá¤ÿ×á¦ÿìá¨ÿ×áªÿ×á®ÿ×á°ÿ×á±ÿìáµÿ×á¼ÿÃá½ÿ×á¿ÿ×áÁÿ×áÄÿìáÇÿìáÎÿìáÕÿìáòÿìáÿ®á ÿ®árÿ×ásÿìázÿìá|ÿ×á€ÿìá‚ÿìáŸÿ×á¡ÿìá©ÿìáµÿÃá·ÿìá¹ÿìá»ÿ×á½ÿìá¿ÿ×áÁÿ×áÊÿ×áÎÿ×áÏÿìáÔÿ×áÙÿ×áÛÿ×áÝÿ×áåÿ×áçÿìáõÿìá÷ÿ×áùÿ×áûÿ×áýÿ×áÿ×áÿ×á ÿ×áÿ×áÿ×áÿìáÿìáÿ×áÿìâÿìâ ÿìâÐÿ×âÜÿìâÝÿìâßÿ×âáÿìâäÿìâöÿìâÿìâ ÿìâ ÿ×âªÿìâ¶ÿìâ¼ÿ×â¾ÿìâÀÿìâÂÿìâËÿ×âÕÿìâæÿ×âøÿìâúÿìâüÿìâþÿìâÿ×âÿ×âÿìâÿìâÿìãÿ®ãÿ®ãÿìã¤ÿ×ã¦ÿìã¨ÿ×ãªÿ×ã®ÿ×ã°ÿ×ã±ÿìãµÿ×ã¼ÿÃã½ÿ×ã¿ÿ×ãÁÿ×ãÄÿìãÇÿìãÎÿìãÕÿìãòÿìãÿ®ã ÿ®ãrÿ×ãsÿìãzÿìã|ÿ×ã€ÿìã‚ÿìãŸÿ×ã¡ÿìã©ÿìãµÿÃã·ÿìã¹ÿìã»ÿ×ã½ÿìã¿ÿ×ãÁÿ×ãÊÿ×ãÎÿ×ãÏÿìãÔÿ×ãÙÿ×ãÛÿ×ãÝÿ×ãåÿ×ãçÿìãõÿìã÷ÿ×ãùÿ×ãûÿ×ãýÿ×ãÿ×ãÿ×ã ÿ×ãÿ×ãÿ×ãÿìãÿìãÿ×ãÿìäÿìä ÿìäÐÿ×äÜÿìäÝÿìäßÿ×äáÿìääÿìäöÿìäÿìä ÿìä ÿ×äªÿìä¶ÿìä¼ÿ×ä¾ÿìäÀÿìäÂÿìäËÿ×äÕÿìäæÿ×äøÿìäúÿìäüÿìäþÿìäÿ×äÿ×äÿìäÿìäÿìåŸÿ×å¸ÿ×å»ÿ×å¾ÿ×åÁÿ×åáÿ×ålÿ×å|ÿ×å~ÿ×å„ÿ×å†ÿ×åˆÿ×åŠÿ×åŒÿ×å±ÿ×å³ÿ×å¿ÿ×åÀÿ×åÁÿ×åÂÿ×åÅÿšåÇÿšåÔÿ×åÕÿ×åïÿ×åñÿ×åóÿ×åýÿ×åþÿ×å ÿ×å ÿ×åÿ×åÿ×åÿ×åÿìæÏÿ×æØÿ×æÛÿ×æÞÿ×æáÿ×æêÿ×æíÿ×æjÿ×æÿ×æ…ÿ×æ‡ÿ×æ‰ÿ×æÿ×æ²ÿ×æ´ÿ×æÀÿ×æÂÿ×æÆÿ×æÈÿ×æÕÿ×æàÿ×æðÿ×æòÿ×æôÿ×æþÿ×æ ÿ×æ ÿ×æÿ×æÿ×çÿ®çÿ®çÿ®ç ÿ®ç€ÿìç‚ÿìç·ÿìç¹ÿìç ÿ×çÿ×èé)éÿìé ÿìéÿìé ÿìéÿ×éÿ×ïÿ®ïÿ®ïÿìï¤ÿ×ï¦ÿìï¨ÿ×ïªÿ×ï®ÿ×ï°ÿ×ï±ÿìïµÿ×ï¼ÿÃï½ÿ×ï¿ÿ×ïÁÿ×ïÄÿìïÇÿìïÎÿìïÕÿìïòÿìïÿ®ï ÿ®ïrÿ×ïsÿìïzÿìï|ÿ×ï€ÿìï‚ÿìïŸÿ×ï¡ÿìï©ÿìïµÿÃï·ÿìï¹ÿìï»ÿ×ï½ÿìï¿ÿ×ïÁÿ×ïÊÿ×ïÎÿ×ïÏÿìïÔÿ×ïÙÿ×ïÛÿ×ïÝÿ×ïåÿ×ïçÿìïõÿìï÷ÿ×ïùÿ×ïûÿ×ïýÿ×ïÿ×ïÿ×ï ÿ×ïÿ×ïÿ×ïÿìïÿìïÿ×ïÿìðÿìð ÿìðÐÿ×ðÜÿìðÝÿìðßÿ×ðáÿìðäÿìðöÿìðÿìð ÿìð ÿ×ðªÿìð¶ÿìð¼ÿ×ð¾ÿìðÀÿìðÂÿìðËÿ×ðÕÿìðæÿ×ðøÿìðúÿìðüÿìðþÿìðÿ×ðÿ×ðÿìðÿìðÿìñÿ®ñÿ®ñÿìñ¤ÿ×ñ¦ÿìñ¨ÿ×ñªÿ×ñ®ÿ×ñ°ÿ×ñ±ÿìñµÿ×ñ¼ÿÃñ½ÿ×ñ¿ÿ×ñÁÿ×ñÄÿìñÇÿìñÎÿìñÕÿìñòÿìñÿ®ñ ÿ®ñrÿ×ñsÿìñzÿìñ|ÿ×ñ€ÿìñ‚ÿìñŸÿ×ñ¡ÿìñ©ÿìñµÿÃñ·ÿìñ¹ÿìñ»ÿ×ñ½ÿìñ¿ÿ×ñÁÿ×ñÊÿ×ñÎÿ×ñÏÿìñÔÿ×ñÙÿ×ñÛÿ×ñÝÿ×ñåÿ×ñçÿìñõÿìñ÷ÿ×ñùÿ×ñûÿ×ñýÿ×ñÿ×ñÿ×ñ ÿ×ñÿ×ñÿ×ñÿìñÿìñÿ×ñÿìòÿìò ÿìòÐÿ×òÜÿìòÝÿìòßÿ×òáÿìòäÿìòöÿìòÿìò ÿìò ÿ×òªÿìò¶ÿìò¼ÿ×ò¾ÿìòÀÿìòÂÿìòËÿ×òÕÿìòæÿ×òøÿìòúÿìòüÿìòþÿìòÿ×òÿ×òÿìòÿìòÿìóÿ®óÿ®óÿìó¤ÿ×ó¦ÿìó¨ÿ×óªÿ×ó®ÿ×ó°ÿ×ó±ÿìóµÿ×ó¼ÿÃó½ÿ×ó¿ÿ×óÁÿ×óÄÿìóÇÿìóÎÿìóÕÿìóòÿìóÿ®ó ÿ®órÿ×ósÿìózÿìó|ÿ×ó€ÿìó‚ÿìóŸÿ×ó¡ÿìó©ÿìóµÿÃó·ÿìó¹ÿìó»ÿ×ó½ÿìó¿ÿ×óÁÿ×óÊÿ×óÎÿ×óÏÿìóÔÿ×óÙÿ×óÛÿ×óÝÿ×óåÿ×óçÿìóõÿìó÷ÿ×óùÿ×óûÿ×óýÿ×óÿ×óÿ×ó ÿ×óÿ×óÿ×óÿìóÿìóÿ×óÿìôÿìô ÿìôÐÿ×ôÜÿìôÝÿìôßÿ×ôáÿìôäÿìôöÿìôÿìô ÿìô ÿ×ôªÿìô¶ÿìô¼ÿ×ô¾ÿìôÀÿìôÂÿìôËÿ×ôÕÿìôæÿ×ôøÿìôúÿìôüÿìôþÿìôÿ×ôÿ×ôÿìôÿìôÿìõÿ®õÿ®õÿìõ¤ÿ×õ¦ÿìõ¨ÿ×õªÿ×õ®ÿ×õ°ÿ×õ±ÿìõµÿ×õ¼ÿÃõ½ÿ×õ¿ÿ×õÁÿ×õÄÿìõÇÿìõÎÿìõÕÿìõòÿìõÿ®õ ÿ®õrÿ×õsÿìõzÿìõ|ÿ×õ€ÿìõ‚ÿìõŸÿ×õ¡ÿìõ©ÿìõµÿÃõ·ÿìõ¹ÿìõ»ÿ×õ½ÿìõ¿ÿ×õÁÿ×õÊÿ×õÎÿ×õÏÿìõÔÿ×õÙÿ×õÛÿ×õÝÿ×õåÿ×õçÿìõõÿìõ÷ÿ×õùÿ×õûÿ×õýÿ×õÿ×õÿ×õ ÿ×õÿ×õÿ×õÿìõÿìõÿ×õÿìöÿìö ÿìöÐÿ×öÜÿìöÝÿìößÿ×öáÿìöäÿìööÿìöÿìö ÿìö ÿ×öªÿìö¶ÿìö¼ÿ×ö¾ÿìöÀÿìöÂÿìöËÿ×öÕÿìöæÿ×öøÿìöúÿìöüÿìöþÿìöÿ×öÿ×öÿìöÿìöÿì÷ÿ…÷ÿ…÷Ÿÿì÷¤ÿš÷ªÿq÷®ÿš÷µÿš÷¸ÿì÷»ÿì÷¾ÿÃ÷Éÿì÷Îÿ®÷Ïÿ×÷Õÿ®÷Øÿ×÷Ûÿ×÷Þÿ×÷áÿ×÷êÿ×÷ëf÷íÿ×÷îÿì÷òÿ®÷ôf÷ÿ…÷ ÿ…÷jÿ×÷lÿì÷rÿq÷sÿ®÷~ÿì÷ÿ×÷„ÿì÷…ÿ×÷†ÿì÷‡ÿ×÷ˆÿì÷‰ÿ×÷Šÿì÷Œÿì÷ÿ×÷˜f÷¨f÷±ÿì÷²ÿ×÷³ÿì÷´ÿ×÷Àÿ×÷Âÿ×÷Åÿ×÷ÆÿÃ÷Çÿ×÷ÈÿÃ÷Îÿš÷Ïÿ®÷Õÿ×÷Ùÿq÷Ûÿq÷Ýÿq÷àÿ×÷ïÿì÷ðÿ×÷ñÿì÷òÿ×÷óÿì÷ôÿ×÷þÿ×÷ ÿq÷ ÿ×÷ ÿq÷ ÿ×÷ÿš÷ÿ®÷ÿì÷ÿ×÷ÿ×÷ÿš÷ÿ®øÿ®øÿ®øÎÿ×øÕÿ×øòÿ×øÿ®ø ÿ®øsÿ×øÏÿ×øÿ×øÿ×ùÿ…ùÿ…ùŸÿìù¤ÿšùªÿqù®ÿšùµÿšù¸ÿìù»ÿìù¾ÿÃùÉÿìùÎÿ®ùÏÿ×ùÕÿ®ùØÿ×ùÛÿ×ùÞÿ×ùáÿ×ùêÿ×ùëfùíÿ×ùîÿìùòÿ®ùôfùÿ…ù ÿ…ùjÿ×ùlÿìùrÿqùsÿ®ù~ÿìùÿ×ù„ÿìù…ÿ×ù†ÿìù‡ÿ×ùˆÿìù‰ÿ×ùŠÿìùŒÿìùÿ×ù˜fù¨fù±ÿìù²ÿ×ù³ÿìù´ÿ×ùÀÿ×ùÂÿ×ùÅÿ×ùÆÿÃùÇÿ×ùÈÿÃùÎÿšùÏÿ®ùÕÿ×ùÙÿqùÛÿqùÝÿqùàÿ×ùïÿìùðÿ×ùñÿìùòÿ×ùóÿìùôÿ×ùþÿ×ù ÿqù ÿ×ù ÿqù ÿ×ùÿšùÿ®ùÿìùÿ×ùÿ×ùÿšùÿ®úÿ®úÿ®úÎÿ×úÕÿ×úòÿ×úÿ®ú ÿ®úsÿ×úÏÿ×úÿ×úÿ×ûÿ…ûÿ…ûŸÿìû¤ÿšûªÿqû®ÿšûµÿšû¸ÿìû»ÿìû¾ÿÃûÉÿìûÎÿ®ûÏÿ×ûÕÿ®ûØÿ×ûÛÿ×ûÞÿ×ûáÿ×ûêÿ×ûëfûíÿ×ûîÿìûòÿ®ûôfûÿ…û ÿ…ûjÿ×ûlÿìûrÿqûsÿ®û~ÿìûÿ×û„ÿìû…ÿ×û†ÿìû‡ÿ×ûˆÿìû‰ÿ×ûŠÿìûŒÿìûÿ×û˜fû¨fû±ÿìû²ÿ×û³ÿìû´ÿ×ûÀÿ×ûÂÿ×ûÅÿ×ûÆÿÃûÇÿ×ûÈÿÃûÎÿšûÏÿ®ûÕÿ×ûÙÿqûÛÿqûÝÿqûàÿ×ûïÿìûðÿ×ûñÿìûòÿ×ûóÿìûôÿ×ûþÿ×û ÿqû ÿ×û ÿqû ÿ×ûÿšûÿ®ûÿìûÿ×ûÿ×ûÿšûÿ®üÿ®üÿ®üÎÿ×üÕÿ×üòÿ×üÿ®ü ÿ®üsÿ×üÏÿ×üÿ×üÿ×ÿÿ…ÿÿ®ÿÿ…ÿŸÿ×ÿ¤ÿšÿªÿqÿ®ÿšÿµÿšÿ¸ÿ×ÿ»ÿ×ÿ¼)ÿ¾ÿ®ÿÌÿšÿÍÿšÿÎÿ…ÿÏÿqÿÐÿ×ÿÑÿ×ÿÒÿšÿÓÿšÿÔÿšÿÕÿ…ÿÖÿšÿ×ÿšÿØÿqÿÙÿšÿÚÿšÿÛÿqÿÜÿ®ÿÝÿ®ÿÞÿqÿßÿ×ÿàÿšÿáÿšÿâÿšÿãÿšÿäÿ®ÿåÿšÿæÿšÿçÿ×ÿèÿšÿéÿÃÿêÿqÿìÿšÿíÿqÿîÿ…ÿòÿ…ÿóÿšÿõÿšÿöÿ®ÿ÷ÿšÿùÿšÿÿ®ÿÿ®ÿÿ®ÿÿ…ÿ ÿ…ÿjÿqÿkÿšÿlÿ×ÿmÿ×ÿqÿšÿrÿqÿsÿ…ÿuÿšÿwÿšÿyÿšÿ}ÿšÿ~ÿ×ÿÿqÿÿ×ÿƒÿ×ÿ„ÿ×ÿ…ÿqÿ†ÿ×ÿ‡ÿqÿˆÿ×ÿ‰ÿqÿŠÿ×ÿ‹ÿ×ÿŒÿ×ÿÿqÿ–ÿšÿšÿšÿžÿšÿ ÿ×ÿ¢ÿ×ÿ¤ÿšÿ¦ÿšÿªÿ®ÿ¬ÿšÿ®ÿšÿ°ÿšÿ±ÿ×ÿ²ÿqÿ³ÿ×ÿ´ÿqÿµ)ÿ¶ÿ®ÿ¸ÿ®ÿºÿ®ÿ¼ÿ×ÿ¾ÿ®ÿÀÿšÿÂÿšÿÄÿšÿÅÿšÿÆÿqÿÇÿšÿÈÿqÿËÿ×ÿÍÿšÿÎÿšÿÏÿ…ÿÑÿšÿÓÿšÿÕÿšÿ×ÿšÿÙÿqÿÛÿqÿÝÿqÿàÿqÿæÿ×ÿèÿ×ÿêÿÃÿìÿšÿîÿšÿïÿ×ÿðÿqÿñÿ×ÿòÿqÿóÿ×ÿôÿqÿöÿ×ÿøÿ®ÿúÿ®ÿüÿ®ÿþÿšÿÿšÿÿšÿÿ×ÿÿ×ÿ ÿqÿ ÿqÿ ÿqÿ ÿqÿÿšÿÿšÿÿšÿÿ…ÿÿšÿÿ×ÿÿqÿÿ®ÿÿqÿÿšÿÿ…ÿšÿ×ÿšÎÿÃÏÿìÕÿÃØÿìÛÿìÞÿìêÿìíÿìòÿÃÿ×ÿ×ÿ×ÿš ÿšjÿìsÿÃÿì…ÿì‡ÿì‰ÿìÿì²ÿì´ÿìÏÿÃàÿìðÿìòÿìôÿì ÿì ÿìÿÃÿìÿìÿÃÿšÿ×ÿš)Ÿÿפÿ®¦)ªÿ…®ÿ®µÿ®¸ÿ×»ÿ×¼)¾ÿÃÄ)ÌÿÃÍÿÃÎÿšÏÿ®Ðÿ×Ñÿ×ÒÿÃÓÿÃÔÿÃÕÿšÖÿÃ×ÿÃØÿ®ÙÿÃÚÿÃÛÿ®Þÿ®ßÿ×àÿÃáÿšâÿÃãÿÃåÿÃæÿÃçÿ×èÿÃêÿ®ë)ìÿÃíÿ®îÿÃòÿšóÿÃô)õÿÃ÷ÿÃùÿÃÿ×ÿ×ÿ×ÿš ÿšjÿ®kÿÃlÿ×qÿÃrÿ…sÿšuÿÃwÿ×yÿÃ}ÿÃ~ÿ×ÿ®„ÿ×…ÿ®†ÿׇÿ®ˆÿ׉ÿ®Šÿ׌ÿ×ÿ®–ÿØ)šÿÞÿàÿ×¢ÿפÿæÿè)©)¬ÿîÿðÿñÿײÿ®³ÿ×´ÿ®µ)¼ÿ×½)ÀÿšÂÿšÄÿÃÅÿ×ÆÿÃÇÿ×ÈÿÃËÿ×ÍÿÃÎÿ®ÏÿšÑÿÃÓÿÃÕÿš×ÿÃÙÿ…Ûÿ…Ýÿ…àÿ®æÿ×èÿ×ìÿÃîÿÃïÿ×ðÿ®ñÿ×òÿ®óÿ×ôÿ®öÿ×þÿšÿÃÿÃÿ×ÿ× ÿš ÿ® ÿš ÿ®ÿ×ÿ×ÿ®ÿšÿÃÿ×ÿ®)ÿ®ÿ®ÿšÿÃÿÃÎÿÃÏÿ×ÕÿÃØÿ×Ûÿ×Þÿ×êÿ×íÿ×òÿÃÿà ÿÃjÿ×sÿÃÿ×…ÿׇÿ׉ÿ×ÿײÿ×´ÿ×ÏÿÃàÿ×ðÿ×òÿ×ôÿ× ÿ× ÿ×ÿÃÿ×ÿ×ÿßÿ×£á¸ÿ×»ÿ×¾ÿÃÜÿ×áÿ®äÿ×lÿ×{=}ÿì~ÿׄÿ׆ÿ׈ÿ׊ÿ׌ÿתÿ×±ÿ׳ÿ׶ÿ×¾ÿ×Àÿ®Âÿ®ÅÿÃÆÿ×ÇÿÃÈÿ×Õÿ®ïÿ×ñÿ×óÿ×þÿ®ÿ×ÿ×ÿ×ÿ×ÏÿìØÿìÛÿìÞÿìáÿìêÿìíÿìjÿìÿì…ÿì‡ÿì‰ÿìÿì²ÿì´ÿìÀÿìÂÿìÕÿìàÿìðÿìòÿìôÿìþÿì ÿì ÿìÿ×ÿ×ÿìÿìŸÿ׸ÿ×»ÿ×¾ÿ×Áÿ×áÿ×lÿ×|ÿ×~ÿׄÿ׆ÿ׈ÿ׊ÿ׌ÿ×±ÿ׳ÿ׿ÿ×Àÿ×Áÿ×Âÿ×ÅÿšÇÿšÔÿ×Õÿ×ïÿ×ñÿ×óÿ×ýÿ×þÿ× ÿ× ÿ×ÿ×ÿ×ÿ×ÿìÏÿìØÿìÛÿìÞÿìáÿìêÿìíÿìjÿìÿì…ÿì‡ÿì‰ÿìÿì²ÿì´ÿìÀÿìÂÿìÕÿìàÿìðÿìòÿìôÿìþÿì ÿì ÿìÿ×ÿ×ÿìÿì ÿš ÿš ÿ® ¦ÿ® ¨ÿà ªÿà °ÿà ¼ÿq ½ÿà ¿ÿà Áÿà Äÿ® Ðÿ× Üÿà ßÿ× áÿ× äÿà ÿš  ÿš rÿà vÿ× |ÿà €ÿà ‚ÿà Ÿÿà  ÿ× ©ÿ® ªÿà µÿq ¶ÿà ·ÿà ¹ÿà »ÿà ¼ÿ× ½ÿ® ¾ÿà ¿ÿà Àÿ× Áÿà Âÿ× Êÿà Ëÿ× Ôÿà Õÿ× Ùÿà Ûÿà Ýÿà åÿà æÿ× ÷ÿà ùÿà ûÿà ýÿà þÿ× ÿà ÿ× ÿà ÿ×  ÿ× ÿ× ÿ× ÿ× ÿ® ÿà ÿš ÿš Ðÿ× Üÿà Ýÿ× ßÿ× áÿ× äÿà öÿ× ÿš  ÿš  ÿ× ªÿà ¶ÿà ¼ÿ× ¾ÿà Àÿ× Âÿ× Ëÿ× Õÿ× æÿ× øÿ× úÿ× üÿ× þÿ× ÿ× ÿ× ÿš ÿš ÿà ÿš ÿš ÿ® ¦ÿ® ¨ÿà ªÿà °ÿà ¼ÿq ½ÿà ¿ÿà Áÿà Äÿ® Ðÿ× Üÿà ßÿ× áÿ× äÿà ÿš  ÿš rÿà vÿ× |ÿà €ÿà ‚ÿà Ÿÿà  ÿ× ©ÿ® ªÿà µÿq ¶ÿà ·ÿà ¹ÿà »ÿà ¼ÿ× ½ÿ® ¾ÿà ¿ÿà Àÿ× Áÿà Âÿ× Êÿà Ëÿ× Ôÿà Õÿ× Ùÿà Ûÿà Ýÿà åÿà æÿ× ÷ÿà ùÿà ûÿà ýÿà þÿ× ÿà ÿ× ÿà ÿ×  ÿ× ÿ× ÿ× ÿ× ÿ® ÿÃÿš ÿšÐÿ×ÜÿÃÝÿ×ßÿ×áÿ×äÿÃöÿ×ÿš ÿš ÿתÿöÿüÿ×¾ÿÃÀÿ×Âÿ×Ëÿ×Õÿ×æÿ×øÿ×úÿ×üÿ×þÿ×ÿ×ÿ×ÿšÿšÿãáê)ÿ×ÿ×ÿì ÿìÿì ÿìÿš ÿšÿ®¦ÿ®¨ÿêÿðÿüÿq½ÿÿÿÃÁÿÃÄÿ®Ðÿ×ÜÿÃßÿ×áÿ×äÿÃÿš ÿšrÿÃvÿ×|ÿÀÿÂÿßÿàÿשÿ®ªÿõÿq¶ÿ÷ÿùÿûÿüÿ×½ÿ®¾ÿÿÿÃÀÿ×ÁÿÃÂÿ×ÊÿÃËÿ×ÔÿÃÕÿ×ÙÿÃÛÿÃÝÿÃåÿÃæÿ×÷ÿÃùÿÃûÿÃýÿÃþÿ×ÿÃÿ×ÿÃÿ× ÿ×ÿ×ÿ×ÿ×ÿ®ÿÃÿš ÿšÐÿ×ÜÿÃÝÿ×ßÿ×áÿ×äÿÃöÿ×ÿš ÿš ÿתÿöÿüÿ×¾ÿÃÀÿ×Âÿ×Ëÿ×Õÿ×æÿ×øÿ×úÿ×üÿ×þÿ×ÿ×ÿ×ÿšÿšÿÃÿš ÿšÿ®¦ÿ®¨ÿêÿðÿüÿq½ÿÿÿÃÁÿÃÄÿ®Ðÿ×ÜÿÃßÿ×áÿ×äÿÃÿš ÿšrÿÃvÿ×|ÿÀÿÂÿßÿàÿשÿ®ªÿõÿq¶ÿ÷ÿùÿûÿüÿ×½ÿ®¾ÿÿÿÃÀÿ×ÁÿÃÂÿ×ÊÿÃËÿ×ÔÿÃÕÿ×ÙÿÃÛÿÃÝÿÃåÿÃæÿ×÷ÿÃùÿÃûÿÃýÿÃþÿ×ÿÃÿ×ÿÃÿ× ÿ×ÿ×ÿ×ÿ×ÿ®ÿÃÿš ÿšÐÿ×ÜÿÃÝÿ×ßÿ×áÿ×äÿÃöÿ×ÿš ÿš ÿתÿöÿüÿ×¾ÿÃÀÿ×Âÿ×Ëÿ×Õÿ×æÿ×øÿ×úÿ×üÿ×þÿ×ÿ×ÿ×ÿšÿšÿÃÿ®ÿ®ªÿì°ÿ×¼ÿ׿ÿ×ÿ® ÿ®rÿì€ÿì‚ÿìŸÿ×µÿ×·ÿì¹ÿì»ÿ×Êÿ×ÙÿìÛÿìÝÿìåÿ×ÿ×ÿ×ÿ× ÿ×ÐÿìÝÿìßÿìöÿìÿ× ÿ× ÿì¼ÿìËÿìæÿìøÿìúÿìüÿìÿìÿìÿ×ÿ×ÿ® ÿ®ÿæÿêÿ×°ÿ×¼ÿÿÿ×Áÿ×ÄÿÃÜÿ×äÿ×ÿ® ÿ®rÿ×|ÿ×€ÿׂÿןÿשÿêÿ×µÿöÿ×·ÿ×¹ÿ×»ÿ×½ÿþÿ׿ÿ×Áÿ×Êÿ×Ôÿ×Ùÿ×Ûÿ×Ýÿ×åÿ×ýÿ×ÿ×ÿ× ÿ×ÿ×ÿÃÿ×ÿš ÿšÐÿ×ÜÿÃÝÿ×ßÿ×áÿ×äÿÃöÿ×ÿš ÿš ÿתÿöÿüÿ×¾ÿÃÀÿ×Âÿ×Ëÿ×Õÿ×æÿ×øÿ×úÿ×üÿ×þÿ×ÿ×ÿ×ÿšÿšÿÃáÿ×Àÿ×Âÿ×Õÿ×þÿ×£áê)ÿ×ÿ×ÿì ÿìÿì ÿìÿq ÿq&ÿ×*ÿ×- 2ÿ×4ÿ×7ÿq9ÿ®:ÿ®<ÿ…‰ÿ×”ÿוÿ×–ÿ×—ÿטÿךÿןÿ…Èÿ×Êÿ×Ìÿ×Îÿ×Þÿ×àÿ×âÿ×äÿ×ÿ×ÿ×ÿ×ÿ×$ÿq&ÿq6ÿ®8ÿ…:ÿ…Gÿ×úÿ®üÿ®þÿ®ÿ…ÿq ÿq_ÿ×Iÿ×Kÿ×Mÿ×Oÿ×Qÿ×Sÿ×Uÿ×Wÿ×Yÿ×[ÿ×]ÿ×_ÿ×oÿ…qÿ…sÿ…ÿqÿì ÿìÿì ÿìÿq ÿq&ÿ×*ÿ×- 2ÿ×4ÿ×7ÿq9ÿ®:ÿ®<ÿ…‰ÿ×”ÿוÿ×–ÿ×—ÿטÿךÿןÿ…Èÿ×Êÿ×Ìÿ×Îÿ×Þÿ×àÿ×âÿ×äÿ×ÿ×ÿ×ÿ×ÿ×$ÿq&ÿq6ÿ®8ÿ…:ÿ…Gÿ×úÿ®üÿ®þÿ®ÿ…ÿq ÿq_ÿ×Iÿ×Kÿ×Mÿ×Oÿ×Qÿ×Sÿ×Uÿ×Wÿ×Yÿ×[ÿ×]ÿ×_ÿ×oÿ…qÿ…sÿ…ÿq ÿì ÿì ÿì  ÿì!ÿq! ÿq!&ÿ×!*ÿ×!- !2ÿ×!4ÿ×!7ÿq!9ÿ®!:ÿ®!<ÿ…!‰ÿ×!”ÿ×!•ÿ×!–ÿ×!—ÿ×!˜ÿ×!šÿ×!Ÿÿ…!Èÿ×!Êÿ×!Ìÿ×!Îÿ×!Þÿ×!àÿ×!âÿ×!äÿ×!ÿ×!ÿ×!ÿ×!ÿ×!$ÿq!&ÿq!6ÿ®!8ÿ…!:ÿ…!Gÿ×!úÿ®!üÿ®!þÿ®!ÿ…!ÿq! ÿq!_ÿ×!Iÿ×!Kÿ×!Mÿ×!Oÿ×!Qÿ×!Sÿ×!Uÿ×!Wÿ×!Yÿ×![ÿ×!]ÿ×!_ÿ×!oÿ…!qÿ…!sÿ…!ÿq"ÿì" ÿì"ÿì" ÿì#ÿq# ÿq#&ÿ×#*ÿ×#- #2ÿ×#4ÿ×#7ÿq#9ÿ®#:ÿ®#<ÿ…#‰ÿ×#”ÿ×#•ÿ×#–ÿ×#—ÿ×#˜ÿ×#šÿ×#Ÿÿ…#Èÿ×#Êÿ×#Ìÿ×#Îÿ×#Þÿ×#àÿ×#âÿ×#äÿ×#ÿ×#ÿ×#ÿ×#ÿ×#$ÿq#&ÿq#6ÿ®#8ÿ…#:ÿ…#Gÿ×#úÿ®#üÿ®#þÿ®#ÿ…#ÿq# ÿq#_ÿ×#Iÿ×#Kÿ×#Mÿ×#Oÿ×#Qÿ×#Sÿ×#Uÿ×#Wÿ×#Yÿ×#[ÿ×#]ÿ×#_ÿ×#oÿ…#qÿ…#sÿ…#ÿq$ÿì$ ÿì$ÿì$ ÿì%ÿq% ÿq%&ÿ×%*ÿ×%- %2ÿ×%4ÿ×%7ÿq%9ÿ®%:ÿ®%<ÿ…%‰ÿ×%”ÿ×%•ÿ×%–ÿ×%—ÿ×%˜ÿ×%šÿ×%Ÿÿ…%Èÿ×%Êÿ×%Ìÿ×%Îÿ×%Þÿ×%àÿ×%âÿ×%äÿ×%ÿ×%ÿ×%ÿ×%ÿ×%$ÿq%&ÿq%6ÿ®%8ÿ…%:ÿ…%Gÿ×%úÿ®%üÿ®%þÿ®%ÿ…%ÿq% ÿq%_ÿ×%Iÿ×%Kÿ×%Mÿ×%Oÿ×%Qÿ×%Sÿ×%Uÿ×%Wÿ×%Yÿ×%[ÿ×%]ÿ×%_ÿ×%oÿ…%qÿ…%sÿ…%ÿq&ÿì& ÿì&ÿì& ÿì'ÿq' ÿq'&ÿ×'*ÿ×'- '2ÿ×'4ÿ×'7ÿq'9ÿ®':ÿ®'<ÿ…'‰ÿ×'”ÿ×'•ÿ×'–ÿ×'—ÿ×'˜ÿ×'šÿ×'Ÿÿ…'Èÿ×'Êÿ×'Ìÿ×'Îÿ×'Þÿ×'àÿ×'âÿ×'äÿ×'ÿ×'ÿ×'ÿ×'ÿ×'$ÿq'&ÿq'6ÿ®'8ÿ…':ÿ…'Gÿ×'úÿ®'üÿ®'þÿ®'ÿ…'ÿq' ÿq'_ÿ×'Iÿ×'Kÿ×'Mÿ×'Oÿ×'Qÿ×'Sÿ×'Uÿ×'Wÿ×'Yÿ×'[ÿ×']ÿ×'_ÿ×'oÿ…'qÿ…'sÿ…'ÿq(ÿì( ÿì(ÿì( ÿì)ÿq) ÿq)&ÿ×)*ÿ×)- )2ÿ×)4ÿ×)7ÿq)9ÿ®):ÿ®)<ÿ…)‰ÿ×)”ÿ×)•ÿ×)–ÿ×)—ÿ×)˜ÿ×)šÿ×)Ÿÿ…)Èÿ×)Êÿ×)Ìÿ×)Îÿ×)Þÿ×)àÿ×)âÿ×)äÿ×)ÿ×)ÿ×)ÿ×)ÿ×)$ÿq)&ÿq)6ÿ®)8ÿ…):ÿ…)Gÿ×)úÿ®)üÿ®)þÿ®)ÿ…)ÿq) ÿq)_ÿ×)Iÿ×)Kÿ×)Mÿ×)Oÿ×)Qÿ×)Sÿ×)Uÿ×)Wÿ×)Yÿ×)[ÿ×)]ÿ×)_ÿ×)oÿ…)qÿ…)sÿ…)ÿq*ÿì* ÿì*ÿì* ÿì+ÿq+ ÿq+&ÿ×+*ÿ×+- +2ÿ×+4ÿ×+7ÿq+9ÿ®+:ÿ®+<ÿ…+‰ÿ×+”ÿ×+•ÿ×+–ÿ×+—ÿ×+˜ÿ×+šÿ×+Ÿÿ…+Èÿ×+Êÿ×+Ìÿ×+Îÿ×+Þÿ×+àÿ×+âÿ×+äÿ×+ÿ×+ÿ×+ÿ×+ÿ×+$ÿq+&ÿq+6ÿ®+8ÿ…+:ÿ…+Gÿ×+úÿ®+üÿ®+þÿ®+ÿ…+ÿq+ ÿq+_ÿ×+Iÿ×+Kÿ×+Mÿ×+Oÿ×+Qÿ×+Sÿ×+Uÿ×+Wÿ×+Yÿ×+[ÿ×+]ÿ×+_ÿ×+oÿ…+qÿ…+sÿ…+ÿq,ÿì, ÿì,ÿì, ÿì-ÿq- ÿq-&ÿ×-*ÿ×-- -2ÿ×-4ÿ×-7ÿq-9ÿ®-:ÿ®-<ÿ…-‰ÿ×-”ÿ×-•ÿ×-–ÿ×-—ÿ×-˜ÿ×-šÿ×-Ÿÿ…-Èÿ×-Êÿ×-Ìÿ×-Îÿ×-Þÿ×-àÿ×-âÿ×-äÿ×-ÿ×-ÿ×-ÿ×-ÿ×-$ÿq-&ÿq-6ÿ®-8ÿ…-:ÿ…-Gÿ×-úÿ®-üÿ®-þÿ®-ÿ…-ÿq- ÿq-_ÿ×-Iÿ×-Kÿ×-Mÿ×-Oÿ×-Qÿ×-Sÿ×-Uÿ×-Wÿ×-Yÿ×-[ÿ×-]ÿ×-_ÿ×-oÿ…-qÿ…-sÿ…-ÿq.ÿì. ÿì.ÿì. ÿì/ÿq/ ÿq/&ÿ×/*ÿ×/- /2ÿ×/4ÿ×/7ÿq/9ÿ®/:ÿ®/<ÿ…/‰ÿ×/”ÿ×/•ÿ×/–ÿ×/—ÿ×/˜ÿ×/šÿ×/Ÿÿ…/Èÿ×/Êÿ×/Ìÿ×/Îÿ×/Þÿ×/àÿ×/âÿ×/äÿ×/ÿ×/ÿ×/ÿ×/ÿ×/$ÿq/&ÿq/6ÿ®/8ÿ…/:ÿ…/Gÿ×/úÿ®/üÿ®/þÿ®/ÿ…/ÿq/ ÿq/_ÿ×/Iÿ×/Kÿ×/Mÿ×/Oÿ×/Qÿ×/Sÿ×/Uÿ×/Wÿ×/Yÿ×/[ÿ×/]ÿ×/_ÿ×/oÿ…/qÿ…/sÿ…/ÿq0ÿì0 ÿì0ÿì0 ÿì1ÿq1 ÿq1&ÿ×1*ÿ×1- 12ÿ×14ÿ×17ÿq19ÿ®1:ÿ®1<ÿ…1‰ÿ×1”ÿ×1•ÿ×1–ÿ×1—ÿ×1˜ÿ×1šÿ×1Ÿÿ…1Èÿ×1Êÿ×1Ìÿ×1Îÿ×1Þÿ×1àÿ×1âÿ×1äÿ×1ÿ×1ÿ×1ÿ×1ÿ×1$ÿq1&ÿq16ÿ®18ÿ…1:ÿ…1Gÿ×1úÿ®1üÿ®1þÿ®1ÿ…1ÿq1 ÿq1_ÿ×1Iÿ×1Kÿ×1Mÿ×1Oÿ×1Qÿ×1Sÿ×1Uÿ×1Wÿ×1Yÿ×1[ÿ×1]ÿ×1_ÿ×1oÿ…1qÿ…1sÿ…1ÿq2ÿì2 ÿì2ÿì2 ÿì3ÿq3 ÿq3&ÿ×3*ÿ×3- 32ÿ×34ÿ×37ÿq39ÿ®3:ÿ®3<ÿ…3‰ÿ×3”ÿ×3•ÿ×3–ÿ×3—ÿ×3˜ÿ×3šÿ×3Ÿÿ…3Èÿ×3Êÿ×3Ìÿ×3Îÿ×3Þÿ×3àÿ×3âÿ×3äÿ×3ÿ×3ÿ×3ÿ×3ÿ×3$ÿq3&ÿq36ÿ®38ÿ…3:ÿ…3Gÿ×3úÿ®3üÿ®3þÿ®3ÿ…3ÿq3 ÿq3_ÿ×3Iÿ×3Kÿ×3Mÿ×3Oÿ×3Qÿ×3Sÿ×3Uÿ×3Wÿ×3Yÿ×3[ÿ×3]ÿ×3_ÿ×3oÿ…3qÿ…3sÿ…3ÿq4ÿì4 ÿì4ÿì4 ÿì5-{6ÿì6 ÿì6Yÿ×6Zÿ×6[ÿ×6\ÿ×6]ÿì6¿ÿ×67ÿ×6<ÿì6>ÿì6@ÿì6ûÿ×6ýÿ×6ÿì6 ÿì6pÿ×7-{8ÿì8 ÿì8Yÿ×8Zÿ×8[ÿ×8\ÿ×8]ÿì8¿ÿ×87ÿ×8<ÿì8>ÿì8@ÿì8ûÿ×8ýÿ×8ÿì8 ÿì8pÿ×9-{:ÿì: ÿì:Yÿ×:Zÿ×:[ÿ×:\ÿ×:]ÿì:¿ÿ×:7ÿ×:<ÿì:>ÿì:@ÿì:ûÿ×:ýÿ×:ÿì: ÿì:pÿ×;-{<ÿì< ÿì<Yÿ×<Zÿ×<[ÿ×<\ÿ×<]ÿì<¿ÿ×<7ÿ×<<ÿì<>ÿì<@ÿì<ûÿ×<ýÿ×<ÿì< ÿì<pÿ×=-{>ÿì> ÿì>Yÿ×>Zÿ×>[ÿ×>\ÿ×>]ÿì>¿ÿ×>7ÿ×><ÿì>>ÿì>@ÿì>ûÿ×>ýÿ×>ÿì> ÿì>pÿ×?-{@ÿì@ ÿì@Yÿ×@Zÿ×@[ÿ×@\ÿ×@]ÿì@¿ÿ×@7ÿ×@<ÿì@>ÿì@@ÿì@ûÿ×@ýÿ×@ÿì@ ÿì@pÿ×A-{BÿìB ÿìBYÿ×BZÿ×B[ÿ×B\ÿ×B]ÿìB¿ÿ×B7ÿ×B<ÿìB>ÿìB@ÿìBûÿ×Býÿ×BÿìB ÿìBpÿ×C-{DÿìD ÿìDYÿ×DZÿ×D[ÿ×D\ÿ×D]ÿìD¿ÿ×D7ÿ×D<ÿìD>ÿìD@ÿìDûÿ×Dýÿ×DÿìD ÿìDpÿ×Iÿ®Iÿ®I$ÿ×I7ÿÃI9ÿìI:ÿìI;ÿ×I<ÿìI=ÿìI‚ÿ×Iƒÿ×I„ÿ×I…ÿ×I†ÿ×I‡ÿ×IŸÿìIÂÿ×IÄÿ×IÆÿ×I$ÿÃI&ÿÃI6ÿìI8ÿìI:ÿìI;ÿìI=ÿìI?ÿìICÿ×I ÿìIúÿìIüÿìIþÿìIÿìIÿ®I ÿ®IXÿ×Iÿ×Iÿ×I!ÿ×I#ÿ×I%ÿ×I'ÿ×I)ÿ×I+ÿ×I-ÿ×I/ÿ×I1ÿ×I3ÿ×IoÿìIqÿìIsÿìIÿÃJÿìJ ÿìJYÿ×JZÿ×J[ÿ×J\ÿ×J]ÿìJ¿ÿ×J7ÿ×J<ÿìJ>ÿìJ@ÿìJûÿ×Jýÿ×JÿìJ ÿìJpÿ×Kÿ®Kÿ®K$ÿ×K7ÿÃK9ÿìK:ÿìK;ÿ×K<ÿìK=ÿìK‚ÿ×Kƒÿ×K„ÿ×K…ÿ×K†ÿ×K‡ÿ×KŸÿìKÂÿ×KÄÿ×KÆÿ×K$ÿÃK&ÿÃK6ÿìK8ÿìK:ÿìK;ÿìK=ÿìK?ÿìKCÿ×K ÿìKúÿìKüÿìKþÿìKÿìKÿ®K ÿ®KXÿ×Kÿ×Kÿ×K!ÿ×K#ÿ×K%ÿ×K'ÿ×K)ÿ×K+ÿ×K-ÿ×K/ÿ×K1ÿ×K3ÿ×KoÿìKqÿìKsÿìKÿÃLÿìL ÿìLYÿ×LZÿ×L[ÿ×L\ÿ×L]ÿìL¿ÿ×L7ÿ×L<ÿìL>ÿìL@ÿìLûÿ×Lýÿ×LÿìL ÿìLpÿ×Mÿ®Mÿ®M$ÿ×M7ÿÃM9ÿìM:ÿìM;ÿ×M<ÿìM=ÿìM‚ÿ×Mƒÿ×M„ÿ×M…ÿ×M†ÿ×M‡ÿ×MŸÿìMÂÿ×MÄÿ×MÆÿ×M$ÿÃM&ÿÃM6ÿìM8ÿìM:ÿìM;ÿìM=ÿìM?ÿìMCÿ×M ÿìMúÿìMüÿìMþÿìMÿìMÿ®M ÿ®MXÿ×Mÿ×Mÿ×M!ÿ×M#ÿ×M%ÿ×M'ÿ×M)ÿ×M+ÿ×M-ÿ×M/ÿ×M1ÿ×M3ÿ×MoÿìMqÿìMsÿìMÿÃOÿ®Oÿ®O$ÿ×O7ÿÃO9ÿìO:ÿìO;ÿ×O<ÿìO=ÿìO‚ÿ×Oƒÿ×O„ÿ×O…ÿ×O†ÿ×O‡ÿ×OŸÿìOÂÿ×OÄÿ×OÆÿ×O$ÿÃO&ÿÃO6ÿìO8ÿìO:ÿìO;ÿìO=ÿìO?ÿìOCÿ×O ÿìOúÿìOüÿìOþÿìOÿìOÿ®O ÿ®OXÿ×Oÿ×Oÿ×O!ÿ×O#ÿ×O%ÿ×O'ÿ×O)ÿ×O+ÿ×O-ÿ×O/ÿ×O1ÿ×O3ÿ×OoÿìOqÿìOsÿìOÿÃQÿ®Qÿ®Q$ÿ×Q7ÿÃQ9ÿìQ:ÿìQ;ÿ×Q<ÿìQ=ÿìQ‚ÿ×Qƒÿ×Q„ÿ×Q…ÿ×Q†ÿ×Q‡ÿ×QŸÿìQÂÿ×QÄÿ×QÆÿ×Q$ÿÃQ&ÿÃQ6ÿìQ8ÿìQ:ÿìQ;ÿìQ=ÿìQ?ÿìQCÿ×Q ÿìQúÿìQüÿìQþÿìQÿìQÿ®Q ÿ®QXÿ×Qÿ×Qÿ×Q!ÿ×Q#ÿ×Q%ÿ×Q'ÿ×Q)ÿ×Q+ÿ×Q-ÿ×Q/ÿ×Q1ÿ×Q3ÿ×QoÿìQqÿìQsÿìQÿÃSÿ®Sÿ®S$ÿ×S7ÿÃS9ÿìS:ÿìS;ÿ×S<ÿìS=ÿìS‚ÿ×Sƒÿ×S„ÿ×S…ÿ×S†ÿ×S‡ÿ×SŸÿìSÂÿ×SÄÿ×SÆÿ×S$ÿÃS&ÿÃS6ÿìS8ÿìS:ÿìS;ÿìS=ÿìS?ÿìSCÿ×S ÿìSúÿìSüÿìSþÿìSÿìSÿ®S ÿ®SXÿ×Sÿ×Sÿ×S!ÿ×S#ÿ×S%ÿ×S'ÿ×S)ÿ×S+ÿ×S-ÿ×S/ÿ×S1ÿ×S3ÿ×SoÿìSqÿìSsÿìSÿÃUÿ®Uÿ®U$ÿ×U7ÿÃU9ÿìU:ÿìU;ÿ×U<ÿìU=ÿìU‚ÿ×Uƒÿ×U„ÿ×U…ÿ×U†ÿ×U‡ÿ×UŸÿìUÂÿ×UÄÿ×UÆÿ×U$ÿÃU&ÿÃU6ÿìU8ÿìU:ÿìU;ÿìU=ÿìU?ÿìUCÿ×U ÿìUúÿìUüÿìUþÿìUÿìUÿ®U ÿ®UXÿ×Uÿ×Uÿ×U!ÿ×U#ÿ×U%ÿ×U'ÿ×U)ÿ×U+ÿ×U-ÿ×U/ÿ×U1ÿ×U3ÿ×UoÿìUqÿìUsÿìUÿÃXIRXWRXYfXZfX[fX\fX¿fX%RX'RX7fXûfXýfX4RX5RX]RX^RXpfXRXRZIRZWRZYfZZfZ[fZ\fZ¿fZ%RZ'RZ7fZûfZýfZ4RZ5RZ]RZ^RZpfZRZR\IR\WR\Yf\Zf\[f\\f\¿f\%R\'R\7f\ûf\ýf\4R\5R\]R\^R\pf\R\R^IR^WR^Yf^Zf^[f^\f^¿f^%R^'R^7f^ûf^ýf^4R^5R^]R^^R^pf^R^R`IR`WR`Yf`Zf`[f`\f`¿f`%R`'R`7f`ûf`ýf`4R`5R`]R`^R`pf`R`Raÿ×aÿ×a$ÿìa‚ÿìaƒÿìa„ÿìa…ÿìa†ÿìa‡ÿìaÂÿìaÄÿìaÆÿìaCÿìaÿ×a ÿ×aXÿìaÿìaÿìa!ÿìa#ÿìa%ÿìa'ÿìa)ÿìa+ÿìa-ÿìa/ÿìa1ÿìa3ÿìfIffWffYffZff[ff\ff¿ff%ff'ff7ffûffýff4ff5ff]ff^ffpfffffhIfhWfhYfhZfh[fh\fh¿fh%fh'fh7fhûfhýfh4fh5fh]fh^fhpfhfhfjIfjWfjYfjZfj[fj\fj¿fj%fj'fj7fjûfjýfj4fj5fj]fj^fjpfjfjflIflWflYflZfl[fl\fl¿fl%fl'fl7flûflýfl4fl5fl]fl^flpflflfnIfnWfnYfnZfn[fn\fn¿fn%fn'fn7fnûfnýfn4fn5fn]fn^fnpfnfnfoÿ…oÿ…o")o$ÿ…o&ÿ×o*ÿ×o2ÿ×o4ÿ×oDÿšoFÿšoGÿšoHÿšoJÿ×oPÿÃoQÿÃoRÿšoSÿÃoTÿšoUÿÃoVÿ®oXÿÃo]ÿ×o‚ÿ…oƒÿ…o„ÿ…o…ÿ…o†ÿ…o‡ÿ…o‰ÿ×o”ÿ×o•ÿ×o–ÿ×o—ÿ×o˜ÿ×ošÿ×o¢ÿšo£ÿšo¤ÿšo¥ÿšo¦ÿšo§ÿšo¨ÿšo©ÿšoªÿšo«ÿšo¬ÿšo­ÿšo´ÿšoµÿšo¶ÿšo·ÿšo¸ÿšoºÿšo»ÿÃo¼ÿÃo½ÿÃo¾ÿÃoÂÿ…oÃÿšoÄÿ…oÅÿšoÆÿ…oÇÿšoÈÿ×oÉÿšoÊÿ×oËÿšoÌÿ×oÍÿšoÎÿ×oÏÿšoÑÿšoÓÿšoÕÿšo×ÿšoÙÿšoÛÿšoÝÿšoÞÿ×oßÿ×oàÿ×oáÿ×oâÿ×oãÿ×oäÿ×oåÿ×oúÿÃoÿÃoÿÃo ÿÃoÿ×oÿšoÿ×oÿšoÿ×oÿšoÿ×oÿšoÿÃoÿÃoÿ®o!ÿ®o+ÿÃo-ÿÃo/ÿÃo1ÿÃo3ÿÃo5ÿÃo<ÿ×o>ÿ×o@ÿ×oCÿ…oDÿšoFÿšoGÿ×oHÿšoJÿ®oÿ…o ÿ…oWÿÃoXÿ…oYÿšo_ÿ×o`ÿšobÿÃoÿ…oÿšoÿ…o ÿšo!ÿ…o"ÿšo#ÿ…o%ÿ…o&ÿšo'ÿ…o(ÿšo)ÿ…o*ÿšo+ÿ…o,ÿšo-ÿ…o.ÿšo/ÿ…o0ÿšo1ÿ…o2ÿšo3ÿ…o4ÿšo6ÿšo8ÿšo:ÿšo<ÿšo@ÿšoBÿšoDÿšoIÿ×oJÿšoKÿ×oLÿšoMÿ×oNÿšoOÿ×oQÿ×oRÿšoSÿ×oTÿšoUÿ×oVÿšoWÿ×oXÿšoYÿ×oZÿšo[ÿ×o\ÿšo]ÿ×o^ÿšo_ÿ×o`ÿšobÿÃodÿÃofÿÃohÿÃojÿÃolÿÃonÿÃpRp Rpÿ®pÿ®p")pRpÿ®p Rp ÿ®qÿ…qÿ…q")q$ÿ…q&ÿ×q*ÿ×q2ÿ×q4ÿ×qDÿšqFÿšqGÿšqHÿšqJÿ×qPÿÃqQÿÃqRÿšqSÿÃqTÿšqUÿÃqVÿ®qXÿÃq]ÿ×q‚ÿ…qƒÿ…q„ÿ…q…ÿ…q†ÿ…q‡ÿ…q‰ÿ×q”ÿ×q•ÿ×q–ÿ×q—ÿ×q˜ÿ×qšÿ×q¢ÿšq£ÿšq¤ÿšq¥ÿšq¦ÿšq§ÿšq¨ÿšq©ÿšqªÿšq«ÿšq¬ÿšq­ÿšq´ÿšqµÿšq¶ÿšq·ÿšq¸ÿšqºÿšq»ÿÃq¼ÿÃq½ÿÃq¾ÿÃqÂÿ…qÃÿšqÄÿ…qÅÿšqÆÿ…qÇÿšqÈÿ×qÉÿšqÊÿ×qËÿšqÌÿ×qÍÿšqÎÿ×qÏÿšqÑÿšqÓÿšqÕÿšq×ÿšqÙÿšqÛÿšqÝÿšqÞÿ×qßÿ×qàÿ×qáÿ×qâÿ×qãÿ×qäÿ×qåÿ×qúÿÃqÿÃqÿÃq ÿÃqÿ×qÿšqÿ×qÿšqÿ×qÿšqÿ×qÿšqÿÃqÿÃqÿ®q!ÿ®q+ÿÃq-ÿÃq/ÿÃq1ÿÃq3ÿÃq5ÿÃq<ÿ×q>ÿ×q@ÿ×qCÿ…qDÿšqFÿšqGÿ×qHÿšqJÿ®qÿ…q ÿ…qWÿÃqXÿ…qYÿšq_ÿ×q`ÿšqbÿÃqÿ…qÿšqÿ…q ÿšq!ÿ…q"ÿšq#ÿ…q%ÿ…q&ÿšq'ÿ…q(ÿšq)ÿ…q*ÿšq+ÿ…q,ÿšq-ÿ…q.ÿšq/ÿ…q0ÿšq1ÿ…q2ÿšq3ÿ…q4ÿšq6ÿšq8ÿšq:ÿšq<ÿšq@ÿšqBÿšqDÿšqIÿ×qJÿšqKÿ×qLÿšqMÿ×qNÿšqOÿ×qQÿ×qRÿšqSÿ×qTÿšqUÿ×qVÿšqWÿ×qXÿšqYÿ×qZÿšq[ÿ×q\ÿšq]ÿ×q^ÿšq_ÿ×q`ÿšqbÿÃqdÿÃqfÿÃqhÿÃqjÿÃqlÿÃqnÿÃrRr Rrÿ®rÿ®r")rRrÿ®r Rr ÿ®sÿ…sÿ…s")s$ÿ…s&ÿ×s*ÿ×s2ÿ×s4ÿ×sDÿšsFÿšsGÿšsHÿšsJÿ×sPÿÃsQÿÃsRÿšsSÿÃsTÿšsUÿÃsVÿ®sXÿÃs]ÿ×s‚ÿ…sƒÿ…s„ÿ…s…ÿ…s†ÿ…s‡ÿ…s‰ÿ×s”ÿ×s•ÿ×s–ÿ×s—ÿ×s˜ÿ×sšÿ×s¢ÿšs£ÿšs¤ÿšs¥ÿšs¦ÿšs§ÿšs¨ÿšs©ÿšsªÿšs«ÿšs¬ÿšs­ÿšs´ÿšsµÿšs¶ÿšs·ÿšs¸ÿšsºÿšs»ÿÃs¼ÿÃs½ÿÃs¾ÿÃsÂÿ…sÃÿšsÄÿ…sÅÿšsÆÿ…sÇÿšsÈÿ×sÉÿšsÊÿ×sËÿšsÌÿ×sÍÿšsÎÿ×sÏÿšsÑÿšsÓÿšsÕÿšs×ÿšsÙÿšsÛÿšsÝÿšsÞÿ×sßÿ×sàÿ×sáÿ×sâÿ×sãÿ×säÿ×såÿ×súÿÃsÿÃsÿÃs ÿÃsÿ×sÿšsÿ×sÿšsÿ×sÿšsÿ×sÿšsÿÃsÿÃsÿ®s!ÿ®s+ÿÃs-ÿÃs/ÿÃs1ÿÃs3ÿÃs5ÿÃs<ÿ×s>ÿ×s@ÿ×sCÿ…sDÿšsFÿšsGÿ×sHÿšsJÿ®sÿ…s ÿ…sWÿÃsXÿ…sYÿšs_ÿ×s`ÿšsbÿÃsÿ…sÿšsÿ…s ÿšs!ÿ…s"ÿšs#ÿ…s%ÿ…s&ÿšs'ÿ…s(ÿšs)ÿ…s*ÿšs+ÿ…s,ÿšs-ÿ…s.ÿšs/ÿ…s0ÿšs1ÿ…s2ÿšs3ÿ…s4ÿšs6ÿšs8ÿšs:ÿšs<ÿšs@ÿšsBÿšsDÿšsIÿ×sJÿšsKÿ×sLÿšsMÿ×sNÿšsOÿ×sQÿ×sRÿšsSÿ×sTÿšsUÿ×sVÿšsWÿ×sXÿšsYÿ×sZÿšs[ÿ×s\ÿšs]ÿ×s^ÿšs_ÿ×s`ÿšsbÿÃsdÿÃsfÿÃshÿÃsjÿÃslÿÃsnÿÃtRt Rtÿ®tÿ®t")tRtÿ®t Rt ÿ®{ {{ {ÿ…ÿ®ÿ…")$ÿq&ÿ×*ÿ×2ÿ×4ÿ×7)Dÿ\FÿqGÿqHÿqJÿqPÿšQÿšRÿqSÿšTÿqUÿšVÿ…XÿšYÿ×Zÿ×[ÿ×\ÿ×]ÿ®‚ÿqƒÿq„ÿq…ÿq†ÿq‡ÿq‰ÿ×”ÿוÿ×–ÿ×—ÿטÿךÿ×¢ÿq£ÿ\¤ÿ\¥ÿ\¦ÿ\§ÿ\¨ÿ\©ÿqªÿq«ÿq¬ÿq­ÿq´ÿqµÿq¶ÿq·ÿq¸ÿqºÿq»ÿš¼ÿš½ÿš¾ÿš¿ÿ×ÂÿqÃÿ\ÄÿqÅÿ\ÆÿqÇÿ\Èÿ×ÉÿqÊÿ×ËÿqÌÿ×ÍÿqÎÿ×ÏÿqÑÿqÓÿqÕÿq×ÿqÙÿqÛÿqÝÿqÞÿ×ßÿqàÿ×áÿqâÿ×ãÿqäÿ×åÿqúÿšÿšÿš ÿšÿ×ÿqÿ×ÿqÿ×ÿqÿ×ÿqÿšÿšÿ…!ÿ…$)&)+ÿš-ÿš/ÿš1ÿš3ÿš5ÿš7ÿ×<ÿ®>ÿ®@ÿ®CÿqDÿ\Fÿ\Gÿ×HÿqJÿ…ûÿ×ýÿ×ÿ®ÿ®ÿ®ÿ… ÿ…WÿšXÿqYÿ\_ÿ×`ÿqbÿšÿqÿ\ÿq ÿ\!ÿq"ÿ\#ÿq%ÿq&ÿ\'ÿq(ÿ\)ÿq*ÿ\+ÿq,ÿ\-ÿq.ÿ\/ÿq0ÿ\1ÿq2ÿ\3ÿq4ÿ\6ÿq8ÿq:ÿq<ÿq@ÿqBÿqDÿqIÿ×JÿqKÿ×LÿqMÿ×NÿqOÿ×Qÿ×RÿqSÿ×TÿqUÿ×VÿqWÿ×XÿqYÿ×Zÿq[ÿ×\ÿq]ÿ×^ÿq_ÿ×`ÿqbÿšdÿšfÿšhÿšjÿšlÿšnÿšpÿ×)) )) )>9 9B#FQ i uR‚Ô è . .2*` rŠ ü  F , \ t ¤Ž (2 8Z \’ \î TJDigitized data copyright © 2010-2011, Google Corporation.Open SansBoldAscender - Open Sans Bold Build 100Version 1.10OpenSans-BoldOpen Sans is a trademark of Google and may be registered in certain jurisdictions.Ascender Corporationhttp://www.ascendercorp.com/http://www.ascendercorp.com/typedesigners.htmlLicensed under the Apache License, Version 2.0http://www.apache.org/licenses/LICENSE-2.0Digitized data copyright © 2010-2011, Google Corporation.Open SansBoldAscender - Open Sans Bold Build 100Version 1.10OpenSans-BoldOpen Sans is a trademark of Google and may be registered in certain jurisdictions.Ascender Corporationhttp://www.ascendercorp.com/http://www.ascendercorp.com/typedesigners.htmlLicensed under the Apache License, Version 2.0http://www.apache.org/licenses/LICENSE-2.0ÿffª      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«.notdefnullnonmarkingreturnspaceexclamquotedbl numbersigndollarpercent ampersand quotesingle parenleft parenrightasteriskpluscommahyphenperiodslashzeroonetwothreefourfivesixseveneightninecolon semicolonlessequalgreaterquestionatABCDEFGHI.altJKLMNOPQRSTUVWXYZ bracketleft backslash bracketright asciicircum underscoregraveabcdefghijklmnopqrstuvwxyz braceleftbar braceright asciitildenonbreakingspace exclamdowncentsterlingcurrencyyen brokenbarsectiondieresis copyright ordfeminine guillemotleft logicalnotuni00AD registered overscoredegree plusminus twosuperior threesuperioracutemu paragraphperiodcenteredcedilla onesuperior ordmasculineguillemotright onequarteronehalf threequarters questiondownAgraveAacute AcircumflexAtilde AdieresisAringAECcedillaEgraveEacute Ecircumflex Edieresis Igrave.alt Iacute.altIcircumflex.alt Idieresis.altEthNtildeOgraveOacute OcircumflexOtilde OdieresismultiplyOslashUgraveUacute Ucircumflex UdieresisYacuteThorn germandblsagraveaacute acircumflexatilde adieresisaringaeccedillaegraveeacute ecircumflex edieresisigraveiacute icircumflex idieresisethntildeograveoacute ocircumflexotilde odieresisdivideoslashugraveuacute ucircumflex udieresisyacutethorn ydieresisAmacronamacronAbreveabreveAogonekaogonekCacutecacute Ccircumflex ccircumflexCdotcdotCcaronccaronDcarondcaronDcroatdcroatEmacronemacronEbreveebreve Edotaccent edotaccentEogonekeogonekEcaronecaron Gcircumflex gcircumflexGbrevegbreveGdotgdot Gcommaaccent gcommaaccent Hcircumflex hcircumflexHbarhbar Itilde.altitilde Imacron.altimacron Ibreve.altibreve Iogonek.altiogonekIdotaccent.altdotlessiIJ.altij Jcircumflex jcircumflex Kcommaaccent kcommaaccent kgreenlandicLacutelacute Lcommaaccent lcommaaccentLcaronlcaronLdotldotLslashlslashNacutenacute Ncommaaccent ncommaaccentNcaronncaron napostropheEngengOmacronomacronObreveobreve Ohungarumlaut ohungarumlautOEoeRacuteracute Rcommaaccent rcommaaccentRcaronrcaronSacutesacute Scircumflex scircumflexScedillascedillaScaronscaron Tcommaaccent tcommaaccentTcarontcaronTbartbarUtildeutildeUmacronumacronUbreveubreveUringuring Uhungarumlaut uhungarumlautUogonekuogonek Wcircumflex wcircumflex Ycircumflex ycircumflex YdieresisZacutezacute Zdotaccent zdotaccentZcaronzcaronlongsflorin Aringacute aringacuteAEacuteaeacute Oslashacute oslashacute Scommaaccent scommaaccent circumflexcaronmacronbreve dotaccentringogonektilde hungarumlauttonos dieresistonos Alphatonos anoteleia EpsilontonosEtatonos Iotatonos.alt Omicrontonos Upsilontonos OmegatonosiotadieresistonosAlphaBetaGammauni0394EpsilonZetaEtaThetaIota.altKappaLambdaMuNuXiOmicronPiRhoSigmaTauUpsilonPhiChiPsiuni03A9Iotadieresis.altUpsilondieresis alphatonos epsilontonosetatonos iotatonosupsilondieresistonosalphabetagammadeltaepsilonzetaetathetaiotakappalambdauni03BCnuxiomicronpirhosigma1sigmatauupsilonphichipsiomega iotadieresisupsilondieresis omicrontonos upsilontonos omegatonos afii10023 afii10051 afii10052 afii10053 afii10054 afii10055.alt afii10056.alt afii10057 afii10058 afii10059 afii10060 afii10061 afii10062 afii10145 afii10017 afii10018 afii10019 afii10020 afii10021 afii10022 afii10024 afii10025 afii10026 afii10027 afii10028 afii10029 afii10030 afii10031 afii10032 afii10033 afii10034 afii10035 afii10036 afii10037 afii10038 afii10039 afii10040 afii10041 afii10042 afii10043 afii10044 afii10045 afii10046 afii10047 afii10048 afii10049 afii10065 afii10066 afii10067 afii10068 afii10069 afii10070 afii10072 afii10073 afii10074 afii10075 afii10076 afii10077 afii10078 afii10079 afii10080 afii10081 afii10082 afii10083 afii10084 afii10085 afii10086 afii10087 afii10088 afii10089 afii10090 afii10091 afii10092 afii10093 afii10094 afii10095 afii10096 afii10097 afii10071 afii10099 afii10100 afii10101 afii10102 afii10103 afii10104 afii10105 afii10106 afii10107 afii10108 afii10109 afii10110 afii10193 afii10050 afii10098WgravewgraveWacutewacute Wdieresis wdieresisYgraveygraveendashemdash afii00208 underscoredbl quoteleft quoterightquotesinglbase quotereversed quotedblleft quotedblright quotedblbasedagger daggerdblbulletellipsis perthousandminutesecond guilsinglleftguilsinglright exclamdblfraction nsuperiorfranc afii08941pesetaEuro afii61248 afii61289 afii61352 trademarkOmega estimated oneeighth threeeighths fiveeighths seveneighths partialdiffDeltaproduct summationminusradicalinfinityintegral approxequalnotequal lessequal greaterequallozengeuniFB01uniFB02 cyrillicbrevedotlessjcaroncommaaccent commaaccentcommaaccentrotate zerosuperior foursuperior fivesuperior sixsuperior sevensuperior eightsuperior ninesuperioruni2000uni2001uni2002uni2003uni2004uni2005uni2006uni2007uni2008uni2009uni200Auni200BuniFEFFuniFFFCuniFFFDuni01F0uni02BCuni03D1uni03D2uni03D6uni1E3Euni1E3Funi1E00uni1E01uni1F4Duni02F3 dasiaoxiauniFB03uniFB04OhornohornUhornuhornuni0300uni0301uni0303hookdotbelowuni0400uni040Duni0450uni045Duni0460uni0461uni0462uni0463uni0464uni0465uni0466uni0467uni0468uni0469uni046Auni046Buni046Cuni046Duni046Euni046Funi0470uni0471uni0472uni0473uni0474uni0475uni0476uni0477uni0478uni0479uni047Auni047Buni047Cuni047Duni047Euni047Funi0480uni0481uni0482uni0483uni0484uni0485uni0486uni0488uni0489uni048Auni048Buni048Cuni048Duni048Euni048Funi0492uni0493uni0494uni0495uni0496uni0497uni0498uni0499uni049Auni049Buni049Cuni049Duni049Euni049Funi04A0uni04A1uni04A2uni04A3uni04A4uni04A5uni04A6uni04A7uni04A8uni04A9uni04AAuni04ABuni04ACuni04ADuni04AEuni04AFuni04B0uni04B1uni04B2uni04B3uni04B4uni04B5uni04B6uni04B7uni04B8uni04B9uni04BAuni04BBuni04BCuni04BDuni04BEuni04BF uni04C0.altuni04C1uni04C2uni04C3uni04C4uni04C5uni04C6uni04C7uni04C8uni04C9uni04CAuni04CBuni04CCuni04CDuni04CE uni04CF.altuni04D0uni04D1uni04D2uni04D3uni04D4uni04D5uni04D6uni04D7uni04D8uni04D9uni04DAuni04DBuni04DCuni04DDuni04DEuni04DFuni04E0uni04E1uni04E2uni04E3uni04E4uni04E5uni04E6uni04E7uni04E8uni04E9uni04EAuni04EBuni04ECuni04EDuni04EEuni04EFuni04F0uni04F1uni04F2uni04F3uni04F4uni04F5uni04F6uni04F7uni04F8uni04F9uni04FAuni04FBuni04FCuni04FDuni04FEuni04FFuni0500uni0501uni0502uni0503uni0504uni0505uni0506uni0507uni0508uni0509uni050Auni050Buni050Cuni050Duni050Euni050Funi0510uni0511uni0512uni0513uni1EA0uni1EA1uni1EA2uni1EA3uni1EA4uni1EA5uni1EA6uni1EA7uni1EA8uni1EA9uni1EAAuni1EABuni1EACuni1EADuni1EAEuni1EAFuni1EB0uni1EB1uni1EB2uni1EB3uni1EB4uni1EB5uni1EB6uni1EB7uni1EB8uni1EB9uni1EBAuni1EBBuni1EBCuni1EBDuni1EBEuni1EBFuni1EC0uni1EC1uni1EC2uni1EC3uni1EC4uni1EC5uni1EC6uni1EC7 uni1EC8.altuni1EC9 uni1ECA.altuni1ECBuni1ECCuni1ECDuni1ECEuni1ECFuni1ED0uni1ED1uni1ED2uni1ED3uni1ED4uni1ED5uni1ED6uni1ED7uni1ED8uni1ED9uni1EDAuni1EDBuni1EDCuni1EDDuni1EDEuni1EDFuni1EE0uni1EE1uni1EE2uni1EE3uni1EE4uni1EE5uni1EE6uni1EE7uni1EE8uni1EE9uni1EEAuni1EEBuni1EECuni1EEDuni1EEEuni1EEFuni1EF0uni1EF1uni1EF4uni1EF5uni1EF6uni1EF7uni1EF8uni1EF9uni20ABuni030Fcircumflexacutecombcircumflexgravecombcircumflexhookcombcircumflextildecombbreveacutecombbrevegravecomb brevehookcombbrevetildecombcyrillichookleftcyrillicbighookUCcyrillicbighookLCone.pnumzero.osone.ostwo.osthree.osfour.osfive.ossix.osseven.oseight.osnine.osffuni2120Tcedillatcedillag.altgcircumflex.alt gbreve.altgdot.altgcommaaccent.altIIgraveIacute Icircumflex IdieresisItildeImacronIbreveIogonek IdotaccentIJ IotatonosIota Iotadieresis afii10055 afii10056uni04C0uni04CFuni1EC8uni1ECA ÿÿ © 46latnMOL ROM ÿÿÿÿÿÿ nälatnMOL (ROM Bÿÿ  ÿÿ  ÿÿ  liga°liga¶liga¼lnumÂlnumÈlnumÎloclÔloclÚonumàonumèonumðpnumøpnumþpnumsalt saltsaltss01"ss01*ss012ss02:ss02@ss02Fss03Lss03Rss03Xtnum^tnumftnumn    &.6>FNV^PzªÆîô2H‘’“”•JJßßááããåå.,Ž‘êìîðòôZgw¡¢ÉØEG–© ƒ„…†‡ˆ‰Š‹Œ ƒ…†‡ˆ‰Š‹Œ„‚‚ ‚ ƒŒ‚ ‚ƒŒ !$%IJ6 "(^IO]ILI5O4LI^V0‚R *†H†÷  ‚C0‚?1 0 +0a +‚7 S0Q0, +‚7¢€<<<Obsolete>>>0!0 +iV“žÅ˱ÅHÜê,ñ[¦ð¯  ‚]0‚z0‚b 8%×úøa¯žôç&µÖZÕ0  *†H†÷ 0S1 0 UUS10U VeriSign, Inc.1+0)U"VeriSign Time Stamping Services CA0 070615000000Z 120614235959Z0\1 0 UUS10U VeriSign, Inc.1402U+VeriSign Time Stamping Services Signer - G20Ÿ0  *†H†÷ 0‰ĵòR¼ˆ†`)J[/K‘k‡‘ó5TX5êÑ6^bMRQ4qÂ{f‰ÈÝ*Äj ö7Ù˜t‘ö’®°µv–ñ©JcEG.k ’NK+ŒîXJ‹Ôä,ø‚ªXÙÍBó-ÀuÞ«ÇŽšlL•ÞÛïgárÂIž`<áâ¾£cxi{­-£Ä0Á04+(0&0$+0†http://ocsp.verisign.com0 Uÿ003U,0*0( & $†"http://crl.verisign.com/tss-ca.crl0U%ÿ 0 +0UÿÀ0U0¤010 UTSA1-20  *†H†÷ ‚PÅKÈ$€ßä $ÂÞ±¡¡¦‚- ƒ7 ‚,°ZaµØþˆÛñ‘‘³V@¦ë’¾89°u6t:˜Oä7º™‰Ê•B°¹Ç WàúÕdB5NÑ3¢ÈMª'Çòá†L8MƒxÆüSàëà‡Ý¤–ž^ ˜â¥¾¿‚…Ã`áß­(ØÇ¥KdÚÇ[½¬9Õ8"¡3‹/Ššë¼!?DA µe$¼HÓD€ë¡ÏÉ´ÏTÇ£€\ùy>]r}ˆž,C¢ÊSÎ}=ö*:¸O”¥m ƒ]ù^Sô³WpÃûõ­• ÞÄ€`É+n†ñëôx'ÑÅî4[^¹I2ò30‚Ä0‚- G¿•ßRFC÷ÛmH 1¤0  *†H†÷ 0‹1 0 UZA10U Western Cape10U Durbanville10 U Thawte10U Thawte Certification10UThawte Timestamping CA0 031204000000Z 131203235959Z0S1 0 UUS10U VeriSign, Inc.1+0)U"VeriSign Time Stamping Services CA0‚"0  *†H†÷ ‚0‚ ‚©Ê²¤ÌÍ ¯ }‰¬‡uð´NñßÁ¿ga½£dÚ»ùÊ3«„0‰X~ŒÛkÝ6ž¿Ñìxòw¦~o<¿“¯ ºhôl”ʽR-«H=õ¶Õ]_Ÿú/k¤÷£š¦ÈáLRã`ì@~¹ Þ?Ǵ߇½_zj1.™¨G Î1s W-Íx43•™¹Þh/ªæ㊌*Ë!‡f½ƒXWou¿<ª&‡]Ê<Ÿ„êTÁ nÄþÅJݹ—"|Û>'ÑxìŸ1Éñæ"ÛijGCš_ ä^õî|ñ}«bõM ÞÐ"V¨•Í®ˆv®îº óäMÙ ûh ®;³‡Á»£Û0Ø04+(0&0$+0†http://ocsp.verisign.com0Uÿ0ÿ0AU:0806 4 2†0http://crl.verisign.com/ThawteTimestampingCA.crl0U% 0 +0Uÿ0$U0¤010U TSA2048-1-530  *†H†÷ JkùêXÂD1‰y™+–¿‚¬ÖLÍ°ŠXnß)£^ÈÊ“çR ïG'/8°äÉ“NšÔ"b÷?7!Op1€ñ‹8‡³èè—þÏU–N$Ò©'Nz®·aAó*ÎçÉÙ^Ý»+…>µµÙáWÿ¾´Å~õÏ žð—þ+Ó;R8'÷?J0‚ü0‚e eR&á².áY)…¬"ç\0  *†H†÷ 0_1 0 UUS10U VeriSign, Inc.1705U .Class 3 Public Primary Certification Authority0 090521000000Z 190520235959Z0¶1 0 UUS10U VeriSign, Inc.10U VeriSign Trust Network1;09U 2Terms of use at https://www.verisign.com/rpa (c)09100.U'VeriSign Class 3 Code Signing 2009-2 CA0‚"0  *†H†÷ ‚0‚ ‚¾g´`ªIoV|fÉ^† Õñ¬§qƒŽ‹‰øˆ‰º-„!•äÑœPLûÒ"½Úò²5;à ûü.Z¿‰|=;%öóX{œôµÆ ¸€Î¾'tag'MjåìaXy£à'°áM4+G D¹Þf$fŠÍOºÅ8ÈTáröfuj¹IhÏ8y ª0¨Û,`Hž×ª©ƒ×8‘09–:|@T¶­à/ƒÜ¨R>³×+ý!¶§\£ ©¦P4.M§ÎÉ^%ÔŒ¼ón|)¼]ü1‡ZÕŒ…gXˆ ¿5ðê+£!çöƒå¨í`x^{`ƒýW ]A cT`ÖC!Û0‚×0Uÿ0ÿ0pU i0g0e `†H†øE0V0(+https://www.verisign.com/cps0*+0https://www.verisign.com/rpa0Uÿ0m+ a0_¡] [0Y0W0U image/gif0!00+åÓ†¬ŽkÃÏ€jÔH,{.0%#http://logo.verisign.com/vslogo.gif0U%0++04+(0&0$+0†http://ocsp.verisign.com01U*0(0& $ "† http://crl.verisign.com/pca3.crl0)U"0 ¤010UClass3CA2048-1-550U—Ðk¨&pÈ¡?”-Ä5›¤¡ò0  *†H†÷ ‹ÀÝ”ØA¢ai°¨xÇ0Æ<~B÷$¶äƒsœ¡âú/ëÀÊDçràP¶U ƒn–’äšQj´71Ü¥-ëŒÇOçM2º…øN¾úgUeðj¾zÊd8xEv1ó†z`³]ö‹fv‚Yáƒå½I¥8VåÞAwX0‚0‚û fãðgyÊmPSoˆƒ0  *†H†÷ 0¶1 0 UUS10U VeriSign, Inc.10U VeriSign Trust Network1;09U 2Terms of use at https://www.verisign.com/rpa (c)09100.U'VeriSign Class 3 Code Signing 2009-2 CA0 100729000000Z 120808235959Z0Ð1 0 UUS10U Massachusetts10 UWoburn10U Monotype Imaging Inc.1>0<U 5Digital ID Class 3 - Microsoft Software Validation v210U Type Operations10UMonotype Imaging Inc.0Ÿ0  *†H†÷ 0‰”D •i|U ÐÛ25ŠL3«^ ¡L×*‡8ט¥@ðI "SOÂC¦Ê‹©VïnH¨9c;$¹˜ÏÊ5}rãGWýyËŠJç@p-5c®€ÏįØû÷Éü‰Øפ Û ò¢ò{ïÍuÁ÷ePd"½}¼­¸KÌXEMÑYLM£‚ƒ0‚0 U00Uÿ€0DU=0;09 7 5†3http://csc3-2009-2-crl.verisign.com/CSC3-2009-2.crl0DU =0;09 `†H†øE0*0(+https://www.verisign.com/rpa0U% 0 +0u+i0g0$+0†http://ocsp.verisign.com0?+0†3http://csc3-2009-2-aia.verisign.com/CSC3-2009-2.cer0U#0€—Ðk¨&pÈ¡?”-Ä5›¤¡ò0 `†H†øB0 +‚70ÿ0  *†H†÷ ‚Næ"‡ßgAâÒî~ΙÖc½ðµ“åjrbáõÒ<8î¨=_ºG‚_[KIô ú“ ÐVD¢ˆóû®÷ 5Þ< ¬D”`E*›þ›oL;±4gp†ÿZ9\Zãl‚«5|eKý˜mµ”Iœˆp¾=±b•´Û´ÔÚèA~þ}¹¤’ënò"ŠÆw6MŠZ S1Ó+(¯RázkµwD½ ­ô]%,ãÍŠ0>KœyʦN® ÂÌ$ Á”‚öñº¶›šØ\<ñê'M<‰o3ŠÓ†ÞéX3u=ë“iâDoNlÏÕ…ÚV¦š¦?ËL!hò`ºáè]9!2í1‚g0‚c0Ë0¶1 0 UUS10U VeriSign, Inc.10U VeriSign Trust Network1;09U 2Terms of use at https://www.verisign.com/rpa (c)09100.U'VeriSign Class 3 Code Signing 2009-2 CAfãðgyÊmPSoˆƒ0 + p0 +‚7 100 *†H†÷  1  +‚70 +‚7 10  +‚70# *†H†÷  1ù79±:Sz3ÇkH9 ”0ÎL0  *†H†÷ €}4ñn[Ax0\b25[Ñv ¦KÎHÛ5zk“ëé&%°b3ž•Â´U}/žÌ‘NÈ‹vÿ‰j楹‹Ÿ£øi‡¢†ê7ϱV Œ(~ê‡ö†DäTuÏš/gªOý õì!®ñ©Ü´O:ؼö>U,¾:ÿ&lDO¶™w( ¡‚0‚{ *†H†÷  1‚l0‚h0g0S1 0 UUS10U VeriSign, Inc.1+0)U"VeriSign Time Stamping Services CA8%×úøa¯žôç&µÖZÕ0 + ]0 *†H†÷  1  *†H†÷ 0 *†H†÷  1 110505165508Z0# *†H†÷  1ñ¤Ÿ“á ÓÚA{l˨í‘ßó`0  *†H†÷ €‘‹b=èD•¬™Îªi›Æ?=ºÕ¤ÖZ ¤Þ'W‚×BÊ…„½‹šm“o*õs^szê×-Aå•ç×È&FxµÕÓ‚¸kõVôGû¦}öÖ|¶ò•`¸Aª_-ðªù`E4÷QVÈÄÁàÀ 2ÁågSgu§ŸOpenSans-Italic.ttf000077500000000000000000006376401321131462300375620ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/web/client/resources/fonts/Open_Sans0DSIGZwý@*,tGDEF&¯& GPOS 77&,8GSUB+=·&dÆOS/2¡M–=¸`cmap)«/h´cvt À fpgm~a¶Ð´gasp#%üglyfPXòT%ˆheadøGùc<6hhea àt$hmtxÙÍãškernT+ ~C¨¶6locaM…©0VmaxpC ˜ nameSt"Îùàîpost7ïlÿÐ&+prepT–“„ šßåŸ_<õ ÉcHÀÉèKÎüýÛ Ùb ý¨ yüþ Ù³£ªŠW/\kš3š3Ñf àï@ [(1ASC ÿýþ„X ŸH¶ ÍÁ+á+?hHX¨\B¼áHRHÿ`j×hìÿœ7+Íÿ¢hyh/h h/hhPh…h®h`hb+ÿœhyhhyjžÇoqÿ‹ÉV®–TVVÇVj–mV‹ÿÙ#þÁuVËV²TžTÖ‡VÖV'üºh¤b¼Ñß'ÿ˜¼?ÿðJÿðÍÝJÿj#5'ÿDo?…bž;šbžbòbÿÿž;;þþç99ú;ž;}bžÿÕžb+;m˜Zžq²b¼uÓÿ¶²ÿ;ÿãËhËÿ¶hsÿòháhÿéh¨hhã;oɨ‹®ª¾Xh7¨‹ãm×hÍ`ÍwoªÿÕ=Ǫ¤ÿVÍ°¨¾î{îBWjÿüqÿ‹qÿ‹qÿ‹qÿ‹qÿ‹qÿ‹‰ÿ‰®–VVVV‹ÿÙ‹ÿÙ‹ÿÙ‹ÿÙTHžTÖÖÖÖÖh¨Ãwh¤h¤h¤h¤¼‡Vžÿ…b…b…b…b…b…b…bšbòbòbòbòb;;;;Zž;}b}b}b}b}bh}=žqžqžqžq²ÿ;žÿÕ²ÿ;qÿ‹…bqÿ‹…bqÿ‹…b®–šb®–šb®–šb®–šbTVžbTHžbVòbVòbVòbVòbVòbj–ÿj–ÿj–ÿj–ÿmVž;mVž;‹ÿÙ;‹ÿÙ;‹ÿÙ;‹ÿÙÿš‹ÿÙ;¬ÿÙ;#þÁþþuVç9ç9ËV9ËVÿŸËV9ËVD9ËžTž;žTž;žTž;)]žTž;Ö}bÖ}bÖ}b×–ébV+;V+ÿ™V+;'m'm'm'mü‘˜;üº˜Züª˜+h¤žqh¤žqh¤žqh¤žqh¤žqh¤žqÑß¼u¼²ÿ;¼?ÿðÿã?ÿðÿã?ÿðÿã3þühqÿ…b‰ÿ‰…bÃw}='mooÓH–oÛòDž'uÿooPooÁqÿ‹ª‹GG…`\GBTqhqÿ‹ÉVÏVwÿÉV?ÿðmVÖ‹ÿÙuVwÿ‹²TžT#ÿåÖoV‡V+ÿãüº¼ô–'ÿ˜áÇÝÿð‹ÿÙ¼b?ž;qhœ…bžÿÓ¬TmJ? bž;Xbqhç9Ýÿ‹ªÿÕébR}bÍL‘ÿÕ b¦bXLœ…\bÿ¶×bqhœ…}bœ…×bVVºÏV®–'‹ÿÙ‹ÿÙ#þÁÿ¾7VVºyV“ÿüoVqÿ‹ƒZÉVÏVøÿVV5ÿœBÿú“V“VyV'ÿ¾²TmVÖoV‡V®–üº“ÿüô–'ÿ˜RTú¤T¨TºJVoV®ÕVÿ´…bTdNb¨7bòb¬ÿÝ}ÿüžqžqÑ;Lÿ¢…=Ë;}bž;žÿÕšbú;²ÿ;NbÓÿ¶Ãqqžúqq¼TÅ'¦?;7ÿÕòbž;¨7šbm;;þþÿ¢9ž;Ñ;²ÿ;žqÏV;Ñß¼uÑß¼uÑß¼u¼²ÿ;×7®7®7'ÿ1\{\}ìÿœ\åÏ{Ï}ZÿœºÙÏNÇ+ð¨¼ááDXD×ÿæ þò¨h-hÿéÍ7h?9Ë š;þyÝÿðôVS]R¦wwÿÉîö Ãhdb¨˜'hshhhª˜ÿÿ\þþÑÑœÑøÍ“Í\͇ͦÍ®̓ͪVy!šÍTTþþ\}/¼Vm²Tú;qÿ‹…b;ÿsªÿºZ3ÿÿ¶–}bǤðqý.ýæüµý¾ü¬V“Vòbžq –¾hô–j\ãV;Ïÿ‹;ÿ¤ºVÅ;Hÿ®Óÿ‘RVh;Bÿ¸“ÿ¢áǶÖ}by¼…`y¼…` y–bé– b –b –¾h®–šbßu{T¤w¤}¤˜é)¦) V¢qmV'‡VžÿÕÅN ÓVî;“ÿœ´ÿÝBÿú}ÿüÍT+;yTÍ5uVÓ9º{NjVË; V;øV‹;ÖËb®–šbüº;¼²bm²ÿåÿ˜+ÿò7ºBZøZœøoœTœ;¾P¾P‹ÿÙ5ÿœ¬ÿÝV;3ÿ¾Jÿ¢mVË;yVË;ø Ë¼Tƒ=‹ÿÙqÿ‹…bqÿ‹…b‰ÿ‰…bVòbJTò;JTò;5ÿœ¬ÿÝBÿú}ÿü5¦ÿu“Vžq“VžqÖ}bÖ}bÖ}b®¦“ÿü²ÿ;“ÿü²ÿ;“ÿü²ÿ;úqžÏV;JVÅÅÿúÿ˜Áÿ¶'ÿ˜Óÿ¶‡`žb¦fÍb´øò˜öØ+ÿ¾sÿ¢ Vð;‘–¶bDº²VPy?ÿ¾7ÿ¢qÿ‹…bqÿ‹…bqÿ‹…bqÿ‹…bqÿ‹…bqÿ‹…bqÿ‹…bqÿ‹…bqÿ‹…bqÿ‹…bqÿ‹…bqÿ‹…bVòbVòbVòbVòbVòbVòbVòbVòb‹ÿÙ;‹ÿÙÿúÖ}bÖ}bÖ}bÖ}bÖ}bÖ}bÖ}b¶–}b¶–}b¶–}b¶–}b¶–}bh¤žqh¤žqǤðqǤðqǤðqǤðqǤðq¼²ÿ;¼²ÿ;¼²ÿ;žüüçüVüçüéý ý ý üö¤ÿTÿãÿãˆobßJßÿÕßÿxRÿÇÿÞRoËÿÿF<9 ÿRü•˜/ž5ž5ž5ž5ž5/V/V/V/V/V/V/V/V/ÿµ/VRVé`/VVVVVVV °€0HI~ËÏ'2a’¡°ðÿ7¼ÇÉÝó #ŠŒ¡ªÎÒÖ O_†‘¿Ï?…ÇÊñùM   " & 0 3 : < D p y  ¤ § ¬!!!! !"!&!.!^"""""""+"H"`"e%Êûþÿÿýÿÿ IJ ÌÐ(3b’ ¯ðú7¼ÆÉØó #„ŒŽ£«ÑÖP`ˆ’ÀÐ>€ ÈËòM   & 0 2 9 < D p t  £ § «!!!! !"!&!.!["""""""+"H"`"d%ÊûþÿÿüÿÿÿãÿãÿÂÿÂÿÂÿ°¿²aÿIÿ–þ…þ„þvÿhÿcÿbÿ]gÿDýÏýÍþ‚þýšþ þ þ äXäãzä}ä}ã âBáïáîáíáêáááàáÛáÚáÓáËáÈá™ávátáá á ânàþàûàôàÈà%à"àààààßçßÐßÍÜiOS®ª®Àðàê0L\pr`<–—˜™š›ëœíïžñŸó &'()*+,-./0123456789:;<=>?@AIJ$%TUVWXY¡\]^_`abcdef¢hijklmnopqrstuv£hœžŸ ¤¥£¤¥¦§ijêëìíîïðñòóôõkö÷“”•–—˜™šøù¦ÊËÌÍÎÏÐÑÒÓÔÕÖק¨F©opqrstu45]^@G[ZYXUTSRQPONMLKJIHGFEDCBA@?>=<;:9876510/.-,('&%$#"! , °`E°% Fa#E#aH-, EhD-,E#F`° a °F`°&#HH-,E#F#a° ` °&a° a°&#HH-,E#F`°@a °f`°&#HH-,E#F#a°@` °&a°@a°&#HH-, <<-, E# °ÍD# ¸ZQX# °D#Y °íQX# °MD#Y °&QX# ° D#Y!!-, EhD °` E°FvhŠE`D-,± C#Ce -,± C#C -,°(#p±(>°(#p±(E:± -, E°%Ead°PQXED!!Y-,I°#D-, E°C`D-,°C°Ce -, i°@a°‹ ±,ÀŠŒ¸b`+ d#da\X°aY-,ŠEŠŠ‡°+°)#D°)zä-,Ee°,#DE°+#D-,KRXED!!Y-,KQXED!!Y-,°%# Šõ°`#íì-,°%# Šõ°a#íì-,°%õíì-,°C°RX!!!!!F#F`ŠŠF# FŠ`Ša¸ÿ€b# #Š± ŠpE` °PX°a¸ÿº‹°FŒY°`h:Y-, E°%FRK°Q[X°%F ha°%°%?#!8!Y-, E°%FPX°%F ha°%°%?#!8!Y-,°C°C -,!! d#d‹¸@b-,!°€QX d#d‹¸ b²@/+Y°`-,!°ÀQX d#d‹¸Ub²€/+Y°`-, d#d‹¸@b`#!-,KSXŠ°%Id#Ei°@‹a°€b° aj°#D#°ö!#Š 9/Y-,KSX °%Idi °&°%Id#a°€b° aj°#D°&°öŠ°#D°ö°#D°íŠ°& 9# 9//Y-,E#E`#E`#E`#vh°€b -,°H+-, E°TX°@D E°@aD!!Y-,E±0/E#Ea`°`iD-,KQX°/#p°#B!!Y-,KQX °%EiSXD!!Y!!Y-,E°C°`c°`iD-,°/ED-,E# EŠ`D-,E#E`D-,K#QX¹3ÿà±4 ³34YDD-,°CX°&EŠXdf°`d° `f X!°@Y°aY#XeY°)#D#°)à!!!!!Y-,°CTXKS#KQZX8!!Y!!!!Y-,°CX°%Ed° `f X!°@Y°a#XeY°)#D°%°% XY°%°% F°%#B<°%°%°%°% F°%°`#B< XY°%°%°)à°) EeD°%°%°)à°%°% XY°%°%CH°%°%°%°%°`CH!Y!!!!!!!-,°% F°%#B°%°%EH!!!!-,°% °%°%CH!!!-,E# E °P X#e#Y#h °@PX!°@Y#XeYŠ`D-,KS#KQZX EŠ`D!!Y-,KTX EŠ`D!!Y-,KS#KQZX8!!Y-,°!KTX8!!Y-,°CTX°F+!!!!Y-,°CTX°G+!!!Y-,°CTX°H+!!!!Y-,°CTX°I+!!!Y-, Š#KSŠKQZX#8!!Y-,°%I°SX °@8!Y-,F#F`#Fa#  FŠa¸ÿ€bŠ±@@ŠpE`h:-, Š#IdŠ#SX<!Y-,KRX}zY-,°KKTB-,±B±#ˆQ±@ˆSZX¹ ˆTX²C`BY±$ˆQX¹ @ˆTX²C`B±$ˆTX² C`BKKRX²C`BY¹@€ˆTX²C`BY¹@€c¸ˆTX²C`BY¹@c¸ˆTX²C`BY±&ˆQX¹@c¸ˆTX²@C`BY¹@c¸ˆTX²€C`BYYYYYY±CTX@ @@ @  ±CTX²@º ³  ±€CRX²@¸€± @²@º€ @Y¹@€ˆU¹@c¸ˆUZX³ ³ YYYBBBBB-,Eh#KQX# E d°@PX|YhŠ`YD-,°°%°%°#>°#>± ° #eB° #B°#?°#?± °#eB°#B°-,°€°CP°°CT[X!#° ÉŠíY-,°Y+-,Šå-@™ !H U UHU?¯MK&LK3KF%&4U%3$UÿÿÿJI3IF%3UU3U?¯GFëF#"33U3UU3UOÏÿU3Uo¯ï€¸±TS++K¸ÿRK° P[°ˆ°%S°ˆ°@QZ°ˆ°UZ[X±ŽY…BK°2SX° YK°dSX°±BYss++^stu+++++t+st+++++++++++++st+++^N¶u¶ÍH‘ÿìÿìÿìþÿì¶ü”ÿëþ…þ^þ¨ÿëþ¼‹Ý˜Ž™ˆIf½%“ÿ3S}œ²Äàõ/PŒÞ`·Õ9¿ê (KšF“Ê.TœÃî  ; U Œ · ö * v ´ ÿ  P s ³ Û û # ? S n Š œ ´ ý I } ÈZâ!Cx§¹J…ÑN•Ô .ršÒúDV ÑÑûA‹Û%D­×F„¹ÎÖFX…µæ&@~¨±Õõ"Vl—äö,?Y¢®ÀÒä÷ -@Œž°ÂÔæù%“¥·Ê܉š«¼Íßñt€‘¢³Å×éûrƒ”¥¶ÇÙ h y Š › ­ ¾!! !2!C!U!f!r!~!!¡!³!Ä!Ö!è!ú" "")"1"‘"£"´"Æ"×"é"û###%#6#H#Y#k#|#Ž# #¬#½#Ï#á$'$r$„$–$¨$º$Ì$Þ$ê$õ%%%$%0%B%T%`%k%™%«%½%É%Õ%á%ì%ø&&4&^&p&&&˜&ª&»&Ç''P'b's'…'–'©'»((‡(™(ª(¶(Â(Ô(æ(ø) ))-)9)E)W)i)t))‘))Ò*$*6*G*Y*j*|** *²*Å*×*ã*ï+++$+6+I+[+l+~++¢+´+é,2,”--$-6-H-Y-d-o-’-¶-È-ê..4.W.….°.Ê////'/4/A/M/Z/f/z/‚/Š/£/«/³/»/Ã000!0A0I0Q0‚0Š0©0±0â0ê0ò1E1M1“1à1ó222(292K2^2¾33H33î444o4º4â4ê51595^5¿5Ç66K6Ž6Î7737…7Ñ88e8x8Š8›8¬8¾8Ñ99.9s9{9ƒ9–9ž9ò:7:t:†:˜:Á:É;; ;;R;Z;’;ã<< .>a>©>ÿ?FF‡FF¢FªGGaGiGzG‹GÐGñHH#H4HFHXHkH}HH¡H³HÅHÍHÚHñI I I7I]I…I©IØJ'JAJQJìJôJüKK9KEKZK‹KÈL2LMMaM­NNSN[NœN³NÊNáNøOJOuO“O¿OÐOðPJPsPÌQQ3Q`Q„QQœQ¿QâQüRR/R_R’RËSS.S„SËSËSËSËSËSËSËSËSËSËSËSËSËSËTßU1UCUKUÃUôVTVfVxV„VVœVÈVýW•XXmX¼XþYFYOYXYaY‡Y¢Y´YÆYØYéZUZZÚ[/[‡[Ú\\F\\Õ],]]ç^I^ä_y__‰_Ú`"`\`‘`¤`·`Ã`Ïa:a¢b?bÖcac¼cõd,dcd‡d³dÖd÷eÍfWfªg gQg¦góhVh†hµhÿiJiŽjjjjPj‚j¾jùk3ktk£kÒll9lklœlêm8m«nn#n/nYnÈnÐn÷o-oeo™oÍpp[ppâq,qzq±qërVr¹s,s™s¡s³sÅt tPttÕuuLuu³uõv9v|v¾vÆvØvévüwwww0wAwwÚwíwÿxx%x8xKxxÒxäxõyyy-y?yGyOybyty‡yšy¬y½yÐyâyõzzz,zRzwzŠzzé{5{y{½{ù|4|e|m|Â}'}‡}ã~5~Š~Ú6É€€U€’€Ó%-{ÐÜèú‚ ‚‚2‚E‚X‚k‚~‚‘‚¤‚º‚Ï‚â‚õƒƒƒ.ƒAƒTƒgƒ}ƒ’ƒžƒªƒ¼ƒÎƒàƒñ„„„*„=„P„c„v„‰„Ÿ„´„Æ„Ø„ä„ð„ü………,…?…R…e…x…‹…ž…±…Ä…Ú…÷† ††,†=†O†a†s†„††œ†¨†´†Æ†Ø†ê†û‡ ‡‡0‡B‡T‡e‡q‡}‡‰‡•‡§‡¹‡Ë‡Ü‡èˆˆHˆ}ˆÂ‰‰@‰r‰²‰üŠŠ>Š^ŠgŠ¡ŠÃŠþ‹P‹‰‹Ï‹×‹ö‹þŒTŒÎ,8Dž¯ÀÒãöŽŽŽ,Ž?ŽQŽcŽuŽ€Ž’ŽžŽ«Ž³ŽÆŽÎŽáŽéŽñÁ ¶ ³/2/310!!7!!ÁIü·hyý‡¶úJhæ+ÿã+¶@ OY?+?9/10#4632#"&+þîm1þÏOD-8NB17¶ûÝ3ðú˜LX76D^8á¦B¶ ´?3Í210#!#å™kHškH¶ýðýð?;¶3@   ?3?39/333339/3333310!!#!#!7!!7!3!3!!! b þË}‹þÑ…yþû eþë -{‹}1…} üÅ/`þуþ¬þR®þR®T´þL´þLþ¬THÿ‰/%,:@ )", % KY&&KY//99//3+3+92310#7&'53&&546773&'6654&'®áÅ1…1ÃxR»Ib‹}Ø¿'…'Ÿ|?y^•þwk~BQlvEIì¢Êáß:š)-Ä1•rŸÀ°² @‡? þH7Œþ¢ |\6T J tb5Y¨ÿìüË+:%@%118 ?3?3??9/39/310#"32654#"&54632"32>54#"&54632¼ûØ>!Ci?jAhE‹?eVnze¬rtxü#Bj@k4T?&Œ@eŒWmze¬rtx¶úJ¶ýNøt­‚ g¦—kþþ±c•‘¦1˜\~ùw¬O•ÉG¦˜lþý°b–‘¦1˜BÿìÍ 50@**'(0-/JY3 JY3?+?+?999/10">54&267%467&54632673#'#"&áitR‹h>Uþ¥W¢rþ΀p;…þØ´ÕgÔ¯•¯An‘QH¨e¶ËÉux܉¨ÊDxnxsGN\:MYû3B[±CbuIjß”Ûf¥¤Éž…NvbR*þ{n¹ì°þò¦dVÀá¦å¶ ²?Í10#å™kH¶ýðRþ¼ç¶ ³ '??103#Rðöûrƒ“S@þòý¨þÂþ­þý ÿ`þ¼ô¶ ³'??10#3ôóþûœðqƒ’`þ«ý¿þò'}Uþó×j ³?3/10%%'%7V{¦þw´¦qþþt5þ‹7s)øþ/þ4–þ¨ymš¹  ´ /33310!5!3!!#þ{…†þz‹Ž‡þyŽþ}ÿœþø+î±/Í10%#7#q~NîëôØ7Õ9s±/3107!7#ß"Õžž+ÿã#ò µ OY ?+1074632#"&+QG+5PD.6JM[45G_4ÿ¢}¶ ³??10#}üÓ®-¶úJ¶yÿìDÍ @ KY KY?+?+10#"&5$3 "3265Dþñ³°¼¤ ­mþ‰qÀwdos¼qöþÙþûÿòéùçþaج¸ä¬ïC/…¶ ¶ ??9910!#7'3L¬Ä;2Y²PÁ•‘b5:n 7Ë@ KYLY?+?+310!!7>54&#"'632!ü}Ñf•a/xgM“YR¿Þ°ÍO·Ëþ ¦“¤]}{Kct9Dsš±›oºÐ±þÍ/ÿì1Ë(-@KY && KY& KY ?+?+9/+910#"'532654&##732654&#"'6321ʳ|Ž|î¤Ò¯^ÒU¢´žƒ‹¥ÚtcPšbPÃå³Ä‡œÙ §}…ËrO¤15ŸŠƒ‡®Œ\l6Bv®L¾ %@LY ??9/3+33310##!733!6#+éH¤JýpBÄÏèþu.@TcýëNþ²NžÒü)Ü2$‡ýPÿìH¶-@MYLY KY?+?+9/+9102#"'532654&#"'!!6V¶×’þú±Á‰¤ª¿Ö“ƒ0bZJÅœ!ýöW}Ѳ¡ôyO¤fÀ¬~“ 9¬™þI…ÿìZË(-@ !MY KYKY?+?+9/+9104$32&#"36632#"&26654#"…yθoI#DfÔþßD;¯jš´…䓶Ç^“QÝB|`0y¨Ñœ#“‘þÖþÚO^Ŭ¡þõæYl¾qø9_rb‰ž®y¶@ LY?+?3103!7!®ý1{ý!•‹úÕ`ÿìVÍ%12@)# ,KY,, &KY KY ?+?+9/+9102#"&5467&&546632654&"6654&å®Ãœ¼jxᘾؾÉ_QmÆ ¹™Šp‹¦hrˆNX¡†sÍ­•ÀPN®sz¿fÅ©”ØLE—`o¯aüï<§wk~”zc–½ƒnR|654&+p·þü¬ˆj†pÊú@ 3£c©¸ç´Çþ–¶mlL€Y)v ÂþWþÙŒ"ž/,KWž™ÿåWâ±|„9jzZƒ™+ÿãÃd @ OY OY ?+?+1074632#"&4632#"&+QG+5PD.6 PGaSA.6JM[45G_4¥M[hI]5ÿœþøÃd@ @ OY ?+/Î10%#74632#"&#q~NcPGaSA.6îëôØÎM[hI]5yòÙ@ //3293310%5üi—ýëò¦bß•þþ¸¼å·/33/]3105!5!˜üh˜Z‹‹þbŽŽyòÙ@ //33933105yéý—üi‰Hs•þ!bþZžÿãšË&%@$$OY$ IY?+?+9/910667>54&#"'66324632#"&es€P.g`Q”B=\ÈR§¸ƒ }XíPG,5SA.6“‚§[dXd>]e332¨š{Ïx[qhþ·M[45I]4oÿF´5A*@&+ 6==   +2?3Ä99//33339310#"'##"&546632326654#"!27# $!2"32&nÈzÅo´sƒˆñŒA}X@DfNJÿòäþ›Å ÅßÛàþÆþ—ý² ¿‘ýJ^ \BA»UF?T³þÞ¤¸¸—†þ$òü.u†éïÖþ‡äþòþ×VZqAÁö—þì_nÄr]S;ÿ‹¶@ IY?3?9/+310!#3#&'-þõ½®¸ªK#%WÎÑþ/¶úJm+³«X®þ}V²¶ -@  JY JY JY ?+?+9/+910 #!32654&##!2654&##°®žs{þÐÿþ15'øœº…Óú µÂ•Œì¶þ°Â nÔñ¶ýŽ’~hgûn¡“t{–ÿì Ë@ IY IY ?+?+10"327#"$32&®®þí¡Ã«‹·VœnòþìÓdáÅ—EŠ3Âþ‰Ý»ß9•+ÁìPEV¶ @ JYJY?+?+10!!! 2$54&##Òþzþúþ 5Vü­Ê2£ÎDzúmþûþpضþÕü·N××ÝûpVj¶ &@ IYIY IY?+?+9/+10!!!!!!!5ý!5ß ýÊbýïr5¶™þ+˜ýèVj¶ @ IYIY?+?9/+10!#!!!!¬5ßýÈn ýﶙýë™–ÿìNË&@IY IY IY?+?+9/+10!# $32&&#"327!5ËšØËþøþÛËhÛuÍhBM±j©þëšÍ¸šj`þßþý9K! ¹õ(,˜"2Ëþ”á¾Ú'¼Vs¶ @ IY ?3?39/+10!#!#3!3=§ýl‘ª5ªƒ”…¨°ýP¶ý’nÿÙ¶ @ JY  JY?+3?+310!!77'7!Ëþ¬œò¯ÿž\%´#^^#ûL%þÁþ5¶ · IY"?+?10"'732673¦i0ELdƒ3ªþËOþ“}xªúDþ…V+¶ @  ?3?39910!#&'#33 ºH•H®}ª5ª—¼Ñýµe·ƒý²¶ý:ÆýƒVV¶·IY?+?1033!V5ªþì5!¶úäšT¸¶@  ?33?3910!##33!#7#¤¦+¾¢5ô• “ þÑ®~†ý3HûJü}¶ûL´úJNwMúîT¨¶@  ?3?39910!###33673sµþ4 *¬¢5´Ë*®¤ÇÝÅüÛ¶û<àµ/–ÿìƒÍ @ IY IY?+?+10# $32%"32654&ƒ°þ¸×ÿþâÀOÒôýçø‰Ä¨˜ñŒ¼‹þóþWé+´ìþÌœÊþ˜ÚÇßÃlÝÇßV‡¶ @ JY JY?+?9/+10!##!232654&##‡þ¸þÇ{ª5JÖÜý…Øà‹£=øþúýÁ¶½ýض°}o–þ¤ƒÍ #@IYIY?+?+9Æ10"32654&# $32#jø‰Ä¨žò…¼þÄÿþâÀOÒôþêìÛ5Êþ˜ÚÇßÈiÛÇßú¹+´ìþÌþòþ³þNþšV‰¶ &@JY  IY?+?39/+910#! #32654&#ª5@¾þïºÑif¨ÁЇ˜`ý ¶þ’þ¤eýy`ÁþAªŸym'ÿì#Ë& @ IY IY?+?+9910#"&'532654&'&&54$32&&#"‘þçÿj¡G¢²¢¾i—u×c«_BB¤E†£"Ji“g5¨Óé"ªT—„NwQUªt»ë&.–&,‹w6MD=Xdyº´¶@ IY?+3?10!#!7!!ç¬þj!Ùþh——¤ÿì¶@  IY?+?310#"&54733267Í7þãöæÞ½ª¿’‘¬¿,Ͷü:þùýÐÃQxnü…jRu‡¯Êº¼¶ ¶ ??3310%673#3ß=eß¿ü󴢪aÅŸúJ¶ü^ċ߶@    ?3?33910!#&5##336733673éª1Hþ,®>ª YC•²+  K8ƒ¶ň’H¥ü¶ü{Xb óŒ`ü¤™—Sà‚}ÿ˜Ñ¶ @  ?3?39910!##33¼´ÕþºTþù¬Ë»ºýÕý®ýÍ3ýJ¼Ã¶¶??39103#3éÁýq¬wîªËëügýã%‘ÿ𓶠@IYIY?+?+3310!!7!7!!uü{œýq Züd¹‰’›‹ûoÿðþ¼ð¶µ'?3?310!!#3sþ}}ƒãþÂãþ¼úú!ÝP¶ ³??10#wÙšÙ¶úJ¶ÿjþ¼j¶µ'?3?3103#7!!wá@ã…þ„þ|¶ßù5)Á´//33103#5Vm ‘Éþ-)˜ühëýÿDþ¼ÿH±/310!7!oüÕ+þ¼Œ?Ù‡!±/Í10#&&'53‡h=‡µ+hÙ=º<ˆ§bÿì`\ '@  FY FY ?+?+??99102373#7##"&5462654&#"\( C酳ƋžŽú)aÀxp[h³f^\c]¬û¸ÑåƬÐdÊü¹)•gz¬þÚ£rq;ÿì9"'@ FYFY?+?+??9910"&'##336632"32654!a“% F}J¨370 ]µ`ž‰õ `Çuoic«hfXªòþÿ¬voÆ­ÑþÇã¾þà—nu¢+¨ãbÿìª\@  FYFY?+?+10"&54$32&#"3267úÂÖ”£‰ƒ/xcp¹i…uH€>|ÖÃÈR½33™þï €Ž(?bÿìÃ!'@  FYFY?+?+??991023673#7##"&5462654&#"ÂW N¦þ¶‹e°^‹œõ&^Èulge­iZ¾›wfùìÑ}hÄ®ÖdÂü»#—ot¥þÕ¥ãbÿì´\"&@FYFYFY?+?+9/+10"&54632!#3267"32654&ì¸Ò•ö”™šþ´þË!{?…c^4gµ0 äóIÚÁ¼YÀ…w´ÍPƒ“$0’,#ἧwq5Fÿþƒ *@  FYGYFY?+?+?+3310"'53267#?6632&#"3#hE8@0LRãÁ Î.£ (t +L=W]îíè'¢þ|s:CBdÈ¥alû¶½®ÿþL\(5CH@(33FY9GY &33(&@GY&(GY(,GY?+?+?+99//9++310#"'!"&5467&5467&&5463232654&''326654&#"LÓ)éÃ7‹B?uµ£þÜþ÷ÂÜ¡Nf[?PïºNLýJ‚€¶Íl‚Ÿx€ZPOv?XRNuAHk>`¿ã5N)„€¸Ê“†iš6)PEc+ }SÂøúõMZt>H~UYT“VRVQ‘;)@  FY?+?3?910!654#"#336632Ù”“Y©!e¨J¨!#) ^·dƒ'j´^)”váŸþ'RšŸ®f{j„>hÁþ!;ßµ ??Ä2103#34632#"&ã¨ê¨y@3XC,(4H8GZ7L1þþþß @ FY?+?Ä210"'532734632#"&‡E6=:}+¦þö$T@3VC,&4þÍÛû«ŸL8GZ7L19!@    ?3??99103##3JÉþ+'»ë˜RªJªHr-/þ-ý‹ {þoþ°ýì9- ³??103#3á¨L¨;‡\,'@  ! 'FY?3+3?33?9910!654&#"#33663236632#654&#"¸”>KTŸy!e¨ê‹ W­\qz VÂc‹ª”EJQžwk´^)FNxßþ%HËwh‚t}yˆ‚Dný`´h*>KtÕ’þ ;)\@   FY?+?3?910!654&#"#336632Ù”GNY©!e¨ê‹ `³`“´h(?LxÞžþ%HËze‹}Oeý`bÿðV @ FYFY?+?+102#"&5464&#"326ƒ¾Üö›ÀÚ’øƒ}km­_wh¦]Váżþ²¶âľO³þqs”þù¡ƒ’ ÿÕþ9Z"'@   FYFY?+?+??9910"&'##33632"32654!a’( k¦P‹³Á‰žŠô `Çuoic«hdZ&Zþ4ÑãðÔþžÅã¾þà—nu¢+¨ãbþ`\"'@ FYFY?+?+??99102373#67##"&5462654&#"^% C}þ°¦e 0_´`ŒŸ‘÷)\Äymbe°h\e[¬ùÌà-°ylïÔhÂü¸"›iz©þ×£ã;h\@   FY?+??9102&#"#33>ðE3$54[Ÿwk¨ê‹ H^g\– xÕ‚þ HË_S-ÿìD\$ @ FY FY?+?+9910#"'532654&'&&54632'&#"ßÝÉ©ˆF¢E~€Ft‚lÊ¥«Ÿ68ew]jGok].7œ¯Ež*.dN9NDIŒ`Š©J‰+WE8P?n¤bH µ ?2?31033373ß}¨@4E²ý±Hý›þþh`\û¸uH@    ?3?33910!&55##33673363?  2SþÝÊ+¤/Z'¶%n ²þZ^Nœv½ý‘Hý®X“z|Æuý®¨^5*V Xû¸ÿ¶H @  ?3?39910#33#Óþ¦ÃÛ类JÂþ9ü¨²þN5þdœýåýÓÿ;þH@  FY?+?3910336673#"'532677b¨J #hE²ýH]¶€HD?DRu7LHýßEþóRWâ+aúþ¬†‡ecˆÿã}H @GYGY?+?+3310!!7!7!!²ý1¶þ!‘ýXuV}ŒüÁþ¼/¶'@  &'??329/3910"&54766'4#72676633"3º—!%Ñ vD"§«!i\G~h—/ISþ¼iw4Y’£WhF €IWþ¿{z)¬;HÓ:(51Žþ¨ ³??103#‹‹÷üÿ¶þ¼Á¶'@  &'??239/391023"##52676675&5477654™1Ñ!wŽC$¦µ shH~k–2Qc¶iv0]ÛD+Vhþº¤}ŽHWBu}*©;HÕA"51sP3T¶€ /33Í2210"56323267#"&'&&\62b‘EtV@a273dH~HKZÉE4—m%B7–n! ÿòþ‹ò^@ " OY?+?9/103#4632#"&m°ÏQF,5QA06¬ûß+L\46G]3áÿì)Ë(@ MYKY   ??99//++3310#7&&546773&#"3267F}+„æ‘#{%wb/mnp¹i„vH€>{£×"Ïš¹>Ǫ¨ (Ž4™þï }’(>ÿéšÉ1@ NYKYLY?+3?+9/3+3102&#"!!!!7677#73J¸˜B’„Õ2Erþ/XPÕ!üGÍ5/ÈÉLKÉV…OíþºÛb‰+š.óÝ^a¨!‡'$@  %/3Ä2Î2Î291047'76327'#"''7&732654&#"åD\grre\FFZbuwbZDgh’’hfÓub\FFZhqwbZDFZ`wggh’‘ì¶=@! MYMY  ??399//]92+33+31033!!!#!7!7!733Fë»ýëçþ×!)þÙ9š8þÝ"!þÝáÊ£Ëëüþ… …þö … …þ¨@ ??9/9/103#3#‹‹‹‹üøþ ü÷;ÿøå,8-@3--603'$GY GY?+?+9331047&54632&#"#"'532654&'&&6654&®îwÏ°½„5”vfyL|db4zoräÌ°w8¡L…ŽefŠpTRje”P_cÉjF…žD{EÎŒ‹Xq¨¾ !@    //3399333310X‡Nþ׬qç‹oVþåžq×HvQþ¸þ}1º•Eþ“þ¢1 ²/3/10#!5Œüôýÿÿ7Õ9s‹ÿìjË-5-@%))5** #''..  ?3?39/399/39/3104$32#"$732$54$#"%###323254&##‹È^ÊÅZÐÉþ§ÍÏþ¢Ãi®-¬®*¯®þ×°®þÖ¯¶_Uã•Ïqå£þZ\Ã_fZÛÈ^ÊÂþ¢ÐÌþ§ÊÏZÆ­þÓ­®)°®*¯®þ×N~#þ`þ p~þå•L>㘱/310!7!ôüï!„×^FË  ³ /3/3104632#"&732654&#"×µ‚S‘Tµƒƒ´qtRSrsRPv“€¸S‘T€µµ€PtuORuu˜ !@     //399//33310!5!3!!#5!þ{…†þzþ{˜ƒˆþxþ}ÿ`JöÉ·  ?33?310!7%>54&#"'632!‘ýÏsW(>;Zi;}•m}i‘Ý‹JjädcW/5@PZeq^c¡}»w9ôÉ"@ " !?3?39/3910#"'53254##732654&#"'632%EN¶¢}l}rͲZ_atE;f^7mŸr€Ï fE„“8Hª‰kRG<=D]Xp_´6Ùº! ± /Í106673#8‹%¾&ÌKiô<·:1Ì6ÿÕþjH @  FY?+???39910326673#7##"'##3'“Y¦ƒ"i£é‹ ]´bp3 H¤P¨” “vàÞû¸Íyh`NŒþ¢4ýI\Çþü¶@ IY/+/39/910####"&563!¶rÕs>TØËÚè-þü}ùƒ3úûþÿÿªK¢ZhÿVþÓ ³/3Ì210#"'53254&'73Ó¢…)-&®NZÆW¨¶„Ÿ„QîQG+5PC/6¨‚¤]K”]f304§š|ÐwbmdJM[44G_3ÿÿÿ‹s&$CÿØR ´&+5ÿÿÿ‹Ms&$v“R ´&+5ÿÿÿ‹8s&$KBR ´&+5ÿÿÿ‹/&$R`R ´&+5ÿÿÿ‹+%&$jBR µ""&+55ÿÿÿ‹&$P@ïßo]]]]55ÿ‰Ý¶<@ IY IY IYIY?+?+3?9/+9/+10!!!#!!!!!#¨ýbþJþÛŪª!ýËdýïs6ý“TþNÑþ/¶™þ+–ýæÕ°ýPÿÿ–þ Ë&&z#ÿÿVjs&(CÿûR ´ &+5ÿÿVjs&(v}R ´&+5ÿÿVjs&(KFR ´&+5ÿÿVj%&(jBR µ&+55ÿÿÿÙs&,CþóR ´ &+5ÿÿÿÙks&,vÿ±R ´&+5ÿÿÿÙIs&,KÿSR ´&+5ÿÿÿÙ>%&,jÿUR µ&+55H¶ -@IY JY JY?+?+9/3+310!!#73! 2$54&##!!Òþzþúþ ‡• –Vü­Ê2£ÎDzoJ!þ¶jmþûþp؉–—þÕü·N××Ýýü–þ ÿÿT¨/&1RR ´&+5ÿÿ–ÿìƒs&2ChR ´&+5ÿÿ–ÿìƒs&2v!R ´%%&+5ÿÿ–ÿìƒs&2KÕR ´""&+5ÿÿ–ÿìƒ/&2RåR ´%%&+5ÿÿ–ÿìƒ%&2jÏR µ//&+55¨1ðw @   /3/39107'çþÁb@Ccþ¼Baþ½þÀ`ÓAcþÀ@`þ¼þ¾`@þÂ`wÿ¬¶ )#@#$&IY&IY?+?+910#"''7&5$327"&4'326ƒ°þ¸×È„p‰jÀOÒcŸHƒr•02ýçø‰)áZÑ!ý#[Ž˜ñŒ‹þóþWé` \ªˆë´ì69¦\¸>¼?Êþ˜Ú‡\—XþZvWüqJÃlÿÿ¤ÿìs&8CXR ´&+5ÿÿ¤ÿìs&8v#R ´&+5ÿÿ¤ÿìs&8KËR ´&+5ÿÿ¤ÿì%&8jºR µ))&+55ÿÿ¼Ãs&<vTR ´&+5VR¶ %@ JY  JY ??9/+9/+10!##33232654&##Rþ¸þÁ…Fª5ª5 ÕÝý‡×⌑¦=øþúþÁ¶ÿ¾ýÙ¶°~nÿþX?,@6' 9FY $FYFY?+?+?+910"'532676632#"'532654&&'&&54667>54&#"…E6=2AT+⢴*QŠn_/l3Ù¸¯]3‡>qˆ.BXE%>]P>"iYw†þî(¢þ_n"ÈÆŽ}9c[iSD8B"kqC¯ÇG )3te(>87En<5VGE8?C%@I}€úé½®ÿÿbÿì`!&DC± ´""&+5ÿÿbÿì`!&DvD ´**&+5ÿÿbÿì`!&DK÷ ´''&+5ÿÿbÿì`Ý&DR ´**&+5ÿÿbÿì`Ó&Djý µ44&+55ÿÿbÿì`&DPÚ µ$$&+55bÿìX\*8BB@$ õy=<:?>=ÿ´P“'0@ "!FY$FY?+?+9ÆÆ10#"''7&546327%"&4'326‹ôš’dbimD“ô–’jhiw>þpl¯d6Œ ýþ9eg«_Á½þª¾A}R‡g¢ÂN°DOai’þþ—\-…/þåT#ý-ÿÿqÿì^!&XC™ ´&+5ÿÿqÿì^!&Xvh ´""&+5ÿÿqÿì^!&XK ´&+5ÿÿqÿì^Ó&Xj µ,,&+55ÿÿÿ;þ!&\và ´""&+5ÿÕþ9$'@  FYFY?+?+??9910"&'##336632"32654!b”' f¦°¨_( e°_‹žŠô `Çuoic«hfXhHþþG¢D}hðÔþžÅã¾þà—nu¢+¨ãÿÿÿ;þÓ&\j† µ,,&+55ÿÿÿ‹7¸&$MbR ´&+5ÿÿbÿì`f&DM# ´$$&+5ÿÿÿ‹N7&$N3R ´&+5ÿÿbÿì`å&DN ´$$&+5ÿÿÿ‹þH¶&$Q-ÿÿbþH`\&DQ¨ÿÿ–ÿì s&&v9R ´""&+5ÿÿbÿì!&FvF ´""&+5ÿÿ–ÿì s&&KÕR ´&+5ÿÿbÿìÄ!&FKÎ ´&+5ÿÿ–ÿì 1&&OòR ´!!&+5ÿÿbÿìªß&FO ´!!&+5ÿÿ–ÿì s&&L¦R ´%%&+5ÿÿbÿìø!&FL¿ ´%%&+5ÿÿVs&'L^R ´ &+5ÿÿbÿì&G8ÕÿÿH¶’bÿì/*9@ GY %FYFY?+?+??9/3+3991023?!7!733##7##"&5462654&#"{a“) þ‹y'¦)••þú‹e°^‹œˆö^Étqfg©gbdZW_ººû'Ñ}hÄ®ÕcÌüÁ#—pu¨þÖ«ãÿÿVj¸&(MZR ´&+5ÿÿbÿìÕf&HM ´&&&+5ÿÿVj7&(N=R ´&+5ÿÿbÿìíå&HNÒ ´&&&+5ÿÿVj&(O\5 ´&+5ÿÿbÿì´ß&HO ´++&+5ÿÿVþHj¶&(QLÿÿbþg´\&HQ!ÿÿVjs&(L/R ´&+5ÿÿbÿìû!&HL ´//&+5ÿÿ–ÿìNs&*KÍR ´$$&+5ÿÿÿþL!&JK ´JJ&+5ÿÿ–ÿìN7&*NºR ´!!&+5ÿÿÿþLå&JN¹ ´GG&+5ÿÿ–ÿìN1&*OR ´&&&+5ÿÿÿþLß&JO ´LL&+5ÿÿ–þ;NË&*9-ÿÿÿþL!&J:u ´HH&+5ÿÿVss&+KºR ´&+5ÿÿ;3ª&KK=‰ ´$$&+5Vþ¶4@ JY IY  ?3?39/+9/33+33103##!##7373!737!Dº¾á¬ýl‘ªáºº5ª5“8¬þÏ1ýj/¼ûÓ°ýP-úúúý’åå;%/@   GY FY?+?3?9/3+3910!654#"##7373!!3632Ù‘”Xª‚!a¨ ˜•'¨)^þ£X ¥Ñ†¦Y.˜xáþ1Ùººþ‘擆:lýoÿÿÿÙ£/&,RÿtR ´&+5ÿÿ;Ý&óRþï ´ &+5ÿÿÿÙE¸&,MÿpR ´&+5ÿÿ;¿f&óMþê ´&+5ÿÿÿÙ`7&,NÿER ´&+5ÿÿ;Øå&óNþ½ ´&+5ÿÿÿÙþH¶&,Q¢ÿÿÿšþHß&LQ+ÿÿÿÙ1&,O…R ´&+5;ÍH ³??103#3ã¨ê¨HÿÿÿÙþ¾¶&,-‰ÿÿ;þ%ß&LMÿÿþÁþs&-Kÿ&R ´&+5ÿÿþþþ¼!&7KþÆ ´&+5ÿÿVþ;+¶&.9ÿÿ9þ;!&N9F9!H@    ?3?399103##3JÉþ+'»ë˜Rªèª>2/þ-ý‹ {þoHþç;¦ÿÿV[s&/vÿ¡R ´&+5ÿÿ9<¬&Ovÿ‚‹ ´ &+5ÿÿVþ;V¶&/9œÿÿÿŸþ;-&O9ÿÿÿV$·&/8éÿ£ÿÿ9z&O8?ÿÿVv¶&/Ohýeÿÿ9¸&OOªý‚V¶ %@  IY?+?99//9103'737!Tmo;ʨ¬‘í<þ¶b5!ú@muýV‡j¿þ0šJ @  ??99//9107#'73˜|6Õ˜¨w9Ѭ¨fJhý7THi ÿÿT¨s&1v+R ´&+5ÿÿ;+!&Qvq ´##&+5ÿÿTþ;¨¶&19áÿÿ;þ;)\&Q9VÿÿT¨s&1L¶R ´&+5ÿÿ;2!&QLù ´&&&+5ÿÿ]´¶'Q‹àTþ¨¶@ IY"?+??39910"'73267##3363Íh2@Rfþ) ' ¬¢5¶Ç1±¦þËRþ“xoÇþ÷™üÛ¶ûB{5úJþ;þ)\"%@ FYFY?+?+??910"'5327654&#"#336632C8@6|*³GNY©!e¨ê‹ `³`“²$þÏEh(?LxÞžþ%HËze‹}Lhü¼¬œÿÿ–ÿ샸&2MçR ´&+5ÿÿbÿðf&RM ´&+5ÿÿ–ÿìƒ7&2N¦R ´&+5ÿÿbÿðå&RNÒ ´&+5ÿÿ–ÿìœs&2S'R µ//&+55ÿÿbÿðŒ!&RS µ//&+55–ÿì)Í!9@ IY IY  IY IYIY+??+?+?+9/+10!!# $32!!!!!27&#"ôý^NPÿþâÀOÒ˜UÅýËdýðs5ü¤E6öLsø‰Ä+´ì™þ+–ýæ‰Êþ˜ÚÇßbÿì¬\!.8;@ 2FY22 /" "FY ))FY?3+3?3+39/+9910 '#"&5463 6632!#3267"324&%"32654&ãþòVEÍ{¸Ø–ü›YKÍw‹œþ·þÐ){KŒP¢ým®`|n±Êw‰}¿,çð@ákräÂÁN±ámzƒy·ÊPƒ“1#–KÝ’þþ›’A |†½¦zt0EÿÿV‰s&5v‘R ´&+5ÿÿ;ž!&Uvä ´&+5ÿÿVþ;‰¶&59žÿÿÿ™þ;h\&U9þýÿÿV‰s&5L3R ´""&+5ÿÿ;±!&ULÿx ´&+5ÿÿ'ÿì's&6vmR ´00&+5ÿÿÿìŒ!&VvÒ ´..&+5ÿÿ'ÿì#s&6KR ´--&+5ÿÿÿìU!&VKÿ_ ´++&+5ÿÿ'þ#Ë&6zFÿÿþD\&Vzÿÿ'ÿì#s&6LÿÒR ´33&+5ÿÿÿì‚!&VLÿI ´11&+5ÿÿ‘þ;´¶&79õÿÿ;þ;ÛD&W9Ÿÿÿº´s&7LR ´&+5ÿÿZÿìÀ&W8…ÿÿª´¶(@JY  IY ?+3?9/3+310!!#!7!!7!!“'þÙ¬þßkþj!Ùþh/‰ýZ¦‰ð——+ÿìÛD":@@  GYGYFY?+?+39/3+3Í310%27#"&5467#737#?3!!3#‹7Y"d}… 2‰‰7¬¹}b7þï7ôô4 :uwv#^ðþINäüþõJ"8<ÿÿ¤ÿì/&8RÝR ´&+5ÿÿqÿì`Ý&XR1 ´""&+5ÿÿ¤ÿì¸&8MÝR ´&+5ÿÿqÿì^f&XM- ´&+5ÿÿ¤ÿì7&8NªR ´&+5ÿÿqÿì^å&XNõ ´&+5ÿÿ¤ÿìÓ&8PR µ&+55ÿÿqÿì^&XPÚ µ&+55ÿÿ¤ÿìs&8S R µ))&+55ÿÿqÿì²!&XS= µ,,&+55ÿÿ¤þH¶&8QwÿÿqþH^H&XQ¨ÿÿßs&:KjR ´$$&+5ÿÿu!&ZK} ´&&&+5ÿÿ¼Ãs&<KÿæR ´&+5ÿÿÿ;þ!&\Kÿp ´&+5ÿÿ¼Ã%&<jÿûR µ&+55ÿÿÿð“s&=v“R ´&+5ÿÿÿã±!&]v÷ ´&+5ÿÿÿð“1&=OTR ´&+5ÿÿÿã}ß&]O° ´&+5ÿÿÿð“s&=L#R ´&+5ÿÿÿã±!&]Lÿx ´&+5þüþd@ FY FY?+?+10"'53276632&#"‰A:@1‚2(¤¥)q$+L=X^þè(¤þï#êe}ú˾­þXË,@FY GY@FY?+Ì9/+33+10"'5327#?6632&#"3#E6=4‚2É¿ Í&«¢*r +L=X^!îíÍ'¡þï¹AB“êc›}ü7¼¯ÿbª%,/@ &&#)IY#))#?3Ä9////+399310#!#&54632%673#4&#"326!'ÏZ›¨7þ÷»·-}^dyþÛg|Õ+ÎHwº?32A;83?¡%U¶Š3 ˜v?ûÓþ-6Z_us»[.¡-þú6<<66==¨O¨þ¬º‘bÿì`ª 3A7@*$-! !&)!;FY!-4FY-?+?+??Ä2Ä2Ä9/9910673##"&546324&#"3262373#7##"&5462654&#"“vnÕ1Ö=uybb{}`byhB13@:91BÇ\( C酳ƋžŽú)aÀxp[h³f^²m‹3£$þåcrpcatsb6==65>>ðc]¬û¸ÑåƬÐdÊü¹)•gz¬þÚ£rqÿÿÿ‰Ýs&ˆvTR ´&+5ÿÿbÿìX!&¨v… ´LL&+5ÿÿwÿ¬¶s&švR ´33&+5ÿÿ=ÿ´P!&ºv9 ´11&+5ÿÿ'þ;#Ë&69ÿÿþ;D\&V9ÄÙö! ³ /3Í210#&'#56673ög9h†lm‘wž%[*Ù0wF…'cˆBÓÙ9! ³ /3Í2103673#&''Ód)O*{{jW§  "[+! d9mPM¬4_ŒB–ÙÕf±/310!!´!ýàfÛÙå´€ /3Ì210#"&5573327"¢„q‡bJ\©"劂wj;B}Dß ±/Í104632#"&D@2XC+&6`5JZ7L1'ÙÝ @  / ?  /3Ì]210#"&546324&#"326Ýxcev|_evh@31B;83@°ctsb^ura5>>56==ÿoþH¸ ² /Ì2103327#"&54667¸RD(E')*DS_*P[AJM*F kSN5YO:PÙ/ݶ € /Ä2ÝÆ310".#"#3232673F(KGC ,3d:­,OG>,3dBÛ#+#9:$+$6?þþÙu!  ³  /3Í2106673#%6673#,‹/¬3ÄEVV/‹,¬3ÄEVô-µKAÀ23´FAÀ2oÙ×u ± /Í106673#o.m¶ GhöTë@<ïTÁ´@    /3Ì99//310673#4632#"&%4632#"&šj3Ã2šIKÙ9-N=&#.“8.N;'#/ƒ»vE«C 1@P2C,(.CP1D,ÿÿÿ‹ &$Tþÿ—ÿÿªK¢ZhÿÿGá &(wTýØÿ—ÿÿG  '+šTýØÿ—ÿÿ`ú ',úTýñÿ—ÿÿ\ÿìÏ &2LTýíÿ—ÿÿGÜ '<TýØÿ—ÿÿTó 'Týÿÿ—vdÿÿhÿìд&†Uþȶ..&+555ÿÿÿ‹¶$ÿÿV²¶%Vj¶·IY?+?10!#!!¬5ßý˶™ÿÿÿÉð´(ÿÿVj¶(ÿÿÿð“¶=ÿÿVs¶+–ÿìƒÍ&@IYIYIY?+?+9/+10!7%# $32%"32654&!ýìw°þ¸×ÿþâÀOÒôýçø‰Ä¨˜ñŒ¼3••XþóþWé+´ìþÌœÊþ˜ÚÇßÃlÝÇßÿÿÿÙ¶,ÿÿV+¶.ÿ‹´ µ?2?310#3#&'u!²»¨qHhþ´úL¦›½§¿ühÿÿT¸¶0ÿÿT¨¶1ÿåo¶ &@IY IY IY ?+?+9/+10!!!!!7ýL-!üÓ`!ü…H–™û{˜˜ÿÿ–ÿìƒÍ2Vy¶@ IY?+?310!#!#!D®ýjþìª5îúá¶ÿÿV‡¶3ÿ㶠(@ IY IY?+?+339910#77!!!þô^!ý\ þÝ!‹i9‰™ýÊý±˜ÿÿº´¶7ÿÿ¼Ã¶<–ÿì´Ë!0@IY !JY!!??9/3+39/3+3107&&5%73654&'#")1ÙëaM$±%×é©þÎÏ1Päù “°˜Øo¡’áíÏ"S ´´ êʾþÙœát ÚŸwב“«ÿÿÿ˜Ñ¶;ÇD¶!@JY ??339/3+310###"&547333332673b'^°^ÒäT²X–¸°¸¹Ý+fµi5þÅÁþ?ÁÑÂ]r“þZoG†‚düœ¶Ëãþþ÷ûÿðÍ!&@ IY IY ?3+33?+310"!7!&4$32!!7654&dœíerýÙ\ƺEΩöÞÔký¦÷ùÃ5§þÔ¾ªþûrƒ˜ËKáuÉŠþÿ¬æþtŒ˜ƒ”‘ôÅÔÿÿÿÙ>%&,jÿUR µ&+55ÿÿ¼Ã%&<jÿûR µ&+55ÿÿbÿì‰u&~T ´;;&+5ÿÿ?ÿìœu&‚T» ´22&+5ÿÿ;þ)u&„T ´##&+5ÿÿhÿì±u&†TþÚ ´&+5ÿÿ…ÿìJ´&’Uè¶00&+555bÿì‰\#1*@+FY$$FY?3+3?+?991023673327#"55##"&5462654&#"wc‘& 6.‡%XH"&N² Y©\ŠŸŒô!`¼up[f­f^\a]x2Lþèuþ¾D-#& y Á maÅ­ÑeÈü¸)–gz¦þݬrqÿÓþ+6@ $%%$FY%%FYFY?+?+?9/+9910>32#"&'"32665!#732654&-R'|ÀŠ¬Á°®|‚þôÞV•R}…w“)½5–Pf›QþÕDH«µoþ0®Åh¸¢¢Ð(±†ßþô3?ý¶–»ü‹&2ZŸ_Ž§œcvTþ H¶ ??3910#633673°*ŽªªPJV?²ý¹‹þæ<ý°Ó’¸§VûÌýJÿìj+#@&& FY FY?+?+9/310&&54632&&#"#"&542654&'TaQÇ¡·©Ckz:ae>Ts„òŸ¸Û ™¿DNÚè´N”Q‹­sy>%ZU,EECr؇žþýÖ±Ø&ýêºeC2ó°“?ÿìœZ(-@''FY'' !FY FY ?+?+9/+910#"327#"&54675&&546632&&#"33p›Ÿrg“¹FÁ_©¼”—JOg¶r´ˆ>/Œ;w‚hZ}ðleTVZ&-”„¡sN_KHƒ"`YFMbþ^3@ # FY?+39?99104##7!#6654&'&&bP¢s•Í•²þ·þòXw–hN\°nJC{ŸzÔÜ^ ‘…þáþqªku3>uYGˆN`p6-?2C¨;þ)\@   FY?+???910654&#"#336632oþGNY©!e¨ê‹ `³`“ûþ h(?LxÞžþ%HËze‹}Oeûtbÿì1+ &@FYFY FY?+?+9/+10"&53 '2!"!65¬­¶ÂE°þꪇÂJýÓ!\u…ÁK+ÏØ nþFùýšþÚ#=©Œž!þøþÙ€Š%hÿìH· FY?+?10%27#"&5463}0[c&yœ§›u wv!kãý L0wÿÿ9!Húÿ‹ÿì! "@  FY FY?+?+?910'&&#"'632327#"&'&5#ú HC70?H`w@w :""AZS +7Bþ—°5”m` …<xûçb } ci–™ ŽxýÿÿÿÕþjHwbþH ¶  ??2310363#b¨J ²íJ¦Kþãü±Hý¡£¢ÇNþ“þÝRþ^é04@-&//GY//&#(!%&&%FY&?+92?9/+99910#"#6654&'&&54675&&5467##7!#"!37PŠá~\ôI_¶mKG€€ãËlm¶”.DY9^‡ì‹/\îY¦r^k3W­E‡S_l91C07§†­ð, …_tº$‘…R”_×ÿÿbÿðVRLÿìöH"@ FYFY?+?+33?10%27#"&547!##77!#°,(F?[_‡þuͪÍÝ ÅÙÑ‹ !u…]Q=RüJ¶BP’ýc:)$ÿÕþ-Z"@ FYFY?+?+?910#"&'#!2%"32654&-Œë•XG\¦ò_„½Æþsy—,Rn’k¨^uª»þ¬¯9E/nþGwÏÜQ§Æþƒn— ’“bþRª\!@  #FY?+?9910#6654&'&&54$32&&#"-]^…dM]´^ZDn™Œš£……/*pGn²l¶VsN$4yYF‰TS€?4=)9Ö™¾H°3"ŒþübÿðÃH@  FY FY?+?+310#"&5!!!"3254'üŠå—ÇÍF%öþö+"þË×â|x£±HX®þÛ•æÞ5_’O]kþùùœŸö½vLÿì˜H@  FYFY?+?+310%27#"&547!77!!5[!e }…qþÉ Å{þ´u:uwvA‚BP’ýào>::…ÿìJH@  FY?+?3?10"&54633263üµÂz¨n!udƒ¸a¨»«0Eýó”MxmÖ²Kû¤bþúZ#(@FY  FY?+33?+3?10&&5476632#4#"66կĞ°k’ì‡'­Œ þãÄb¦áGP……Äoã¹ÆF¦dŒþò¢þ僸¨À¬áþ¦½ þ+Óæh‚ý” œÿþLJ'@FY FY?+?+??991023327#"&'#&&#"'6öem)š°ýÛC9;&)B?fr/þ9¾`< 5.3FJtˆþ Züéþ]F }~™sýv@áO?{þf @  FY ?3+3??3?10663#&&5473þÑ©Ùe¬“þÏîd¦fºÇj¨jzz/úmÑ’Uþyþ+ìþ"Þů\yüþuHƒ —bÿìwH'$@% FY"?2+3?39/910"&547332332654'3#"&'y„“ˆ~±þõ’Ÿ:A¦=C­³‘“«Ùþ}ÂaOXXÿÿhÿì«Ó&†jþ µ%%&+55ÿÿ…ÿìJÓ&’jù µ''&+55ÿÿbÿðu&RT ´%%&+5ÿÿ…ÿìJu&’Tó ´&+5ÿÿbÿìwu&–T® ´11&+5ÿÿVj%&(jBR µ&+55ºÿìö+@IYIYIY?+?+3?9/+10"'53267654&#!#!7!!! %FCYÃ×9•%ÁìPEÿÿ'ÿì#Ë6ÿÿÿÙ¶,ÿÿÿÙ>%&,jÿUR µ&+55ÿÿþÁþ5¶-ÿ¾ÿ餶!0@ IYIY!JY IY?+?+?+9/+10 #"'53266!3 !! 4&##åK°®€L143Si^‘˜šƒm¸þÖþìþ½Js‡ŽtþÜý›þÖ–XÐØ5ýþ›çúût@snýßV¾¶)@  IY   JY ?+??39/3+31033 !!!#3! 4&##sª…n¸þØþëþ¼ýÄ‘ª5ªƒ<®r{‹u¶ý’þ™æû°ýP¶ý’ýI@poýáºÃ¶#@ IY   IY ?+3?39/+104&#!#!7!!!2#6ilþ霬þ¾!…þfZ¸­Z¬Z;ZPý——þ^œ›'qþR ]ÿÿV1s&´vÃR ´&+5ÿÿÿüÿìPb&½6qR ´&+5Vþƒy¶ @  " IY ?3+??3103!3!#!‹¬þ앬þËþZP¢RþX¶úâúJþƒ}ÿÿÿ‹¶$Zj¶ &@ IY  IYJY?+?+9/+10 !!!! 4&##N¸þØþëþ‘5Û ýÑe-s}‰¸uFþ›æû¶™þ)ýK@roýßÿÿV²¶%ÿÿVj¶aÿVþ…î¶$@" IY  IY?+33?+?310!#367!3#!PüuPžqf‹¼'DþëºrúMþ§“=þ…{þ…ÀõÅ¢úäýë–ùýEÍÿÿVj¶(ÿœð¶@  ?33?33910333###Hþ“»h“¦“}Ïý^w¿þ–š¦šýwѶýFºýFºý!ý)Ûý%Ûý%ÿúÿì'Ë'-@JY %%JY% JY ?+?+9/+910#"'532654!#732654&#"'6632'ɬšþ÷´á¦N×p¹Ïþ¾×È»Ù}i¨¸Hq׬ɇšÖ#¦‰‚ÎpO¦-;«ø¦’jbv{J?­Vž¶@  ?3?29910333#7##‹¤®Z¬ÇþÊ¡®<"üNǶüÏþu¼úJ9!yû-ÿÿVžb&²6òR ´&+5V1¶ @  ?3?3910!##33)Åþ4˜ª5ª—ÀÓýÕý+¶ý8Èý%ÿ¾ÿé1¶@IY IY?+?+?10 #"'53266!#åK°®€L143Si^‘˜ÉþɬþÜý›þÖ–XÐØ5úJÿÿT¸¶0ÿÿVs¶+ÿÿ–ÿìƒÍ2ÿÿVy¶nÿÿV‡¶3ÿÿ–ÿì Ë&ÿÿº´¶7ÿüÿìP¶@  IY?+?3910"&'532673673¢'`[Ij bþˬ²1=@•ÃýV|ë ¨'{ ý}¶kˆn®û°Ë¯ÿÿ–ÿì´Ësÿÿÿ˜Ñ¶;Tþ…X¶ @ " IY?+3??310%#!3!3ér¢Pü/5¬þìw¬þìœýé{¶úäúæú'¶@ IY ??39/+910!#"&547332673FÇÉœŸmªkRdKµ‡–¬þËXX…J^úþd%NO!.ÏúJT®¶ @ IY?+3?331033!3!3T5¬þêªþëªþ˶úäúäúJTþ…®¶@ " IY?+33??3310%#!3!3!3?r¢PùÙ5¬þêªþëªþìœýé{¶úäúäú溇¶ &@ IY  IY JY?+?+9/+10 !!!7! 4&##ϸþØþëþþ¾!î… s}‰¬uFþ›æû—ýýK@roýßVT¶ "@IY   JY ?+??39/+10!#3!3 !! 4&##ª5ªûã…‹¹þÖþìþž5Hsˆ¬t¶ýþ›çú¶úÛ@snýßVö¶ @IY JY?+?9/+103 !! 4&##7…‹¹þÖþìþž5Hsˆ¬t¶ýþ›çú¶úÛ@snýßÿìoË&@IY IYIY?+?+9/+10%2!7!74&#"'632#"&'5wã-ý‘d¹¥?‚€+ǵö»þ¨ôd£Oj\cƒ˜\ºÑ)HþàþýþÕþLÝ%*¦0Vÿì–Í#*@ IY  IYIY?+?+??9/+10#"47!#3!!2%"32654&–ªþÃÒüþðþº‘ª5ªƒ>Btç ý÷–§“ä…±‹þóþXê+DGýP¶ý’(]þÏ™ÊþšÜÉݾoßÉÝÿ´˜¶ &@JY JY?+?39/+910#&54$!!##"33Rþ1ÏÀ}þ̬˜¶¼¹•Š•býžžeààóúJbÁ›”|„ÿÿbÿì`\Ddÿìš($@ "FYFY?+?9/+910476$76632#"&26654&#"dé”JpZjþövþþoJÁg››ç›¼É”`‘VXX\ÅI¸ßØ+BŠ,%UþhXcîÉþÊžé^ö‰‚v{gsfþÅbÿìZ'-@!!FY!! FY FY ?+?+9/+9102#"&54$!2654&#"32654&¤¯¿þènahÉŠÑÛë|‚Œ˜É&á°¸fZŠŠÝ@r[`˜WæÞÆ:ªý/þÍi[QMð·®kbHP7ÿìmZ$ @ "FYFY?+?+99106632327#"&54667>54#"Ët¬L—Ÿ˜º£d3bi‡²Ÿ°¥ºL‹”…g5š€± ,"€zj£G=?M7DOT–K’€Tc93>I/wHbÿì5))-@ #GY FYFY?+?+9/+910#"&54632375&#"'66322&&#"5¦þ겨½‰êe-‰‹pg+8Ÿ?ÖÔý¤‰×1ƒY[¥ai´ÿþ.÷Ѻ²B°S[ ø/z$þÊû†/p~“üz†ÿÿbÿì´\HÿÝÿìç\<G@':GY  <(FY#/  FY4?3+3?3+3??9/_^]3+310##"'732654&#"5632333>32&#"327#"&547##¢!’Ô…C85/i«chc1?W2ª´¨dši¤™ÏzO>67h¤bbd9:S4¬²ªg—é˜å€‹š‘‹’‰×ÏLÞþ"“ìs‰–þí“Š’‹ÙÌ8 þÿüÿìF\&-@%&&%FY&& FY FY?+?+9/+910 54&#"'6632#"'532654&##7{#VVB‚S5[¤c˜¦ƒº÷Ö´G®Qfk•!Ã?J &+)‡ym”1º¤ÀEž+-qbYM‘ÿÿqÿì^HXÿÿqÿìl&X67 ´&+5;3H @  ?3?39103##3^ÕýÛwËþœs¨è¦qHýãýÕ#ýÝHýïÿ¢ÿòP@FY FY ?+?+?10!#&#"#"'5326676632#ªÏ''M`RSTtŒd/'@[W@Wz¦„~xº =—íðÇY‘ L«»¾W=FH@    ?33?3910!#&'#3673ɼeþy{nº’èºs"WœÇêq#ªý\¦qXü‘Hý+ŽAM”Ãû¸;‹H @ FY   ?3?39/+10!3#!#Ëab¨çªhýêi¨êHþ5Ëû¸îþHÿÿbÿðVRÿÿ;)\QÿÿÿÕþ9ZSÿÿbÿìª\Fÿÿ;‡\Pÿÿÿ;þH\bþð#+@ #FY FY ?3+3?3+3??10##&&54$73>54&'j½É¡þá³fšd¹Æš»^œýC„n´ÀeŽ€½k€tXêÆ»þÊ®þ$ÚïÌ·-­¼û¯“­PŠéþ)…ñ‘‘¦ ÿÿÿ¶H[qþ…^H!!@ !"FY?3+3??3910326673327#&&5##"&547Ö“Xª‚"d¦¤N3q¬P>9œÙ‚’’HýIY2xàžÛüúN3NþkdeÝ>n¤ž3H@ FY  ??39/+910326773#67## 477–''PG”Ð0¨é¬A+‘Øþê6H¹º5SAïÜqû¸5‚ˆÀ7€þqÿì¼H,%@, ''FY?3+3??339910326673#7##"&'##"&547332667?“=LTŸy!d¨é‹ W­\qz TÃd‹ª”EJPœzkHýK\+ENxßÛû¸Ëwh‚sz{ˆ‚Dn ýKf+>KrØ‘ôqþ…¼H6)@!$6 *"1$1FY$?33+33??3399103266733267#&&5##"&'##"&547332667B–=LTŸy!d¨£+#' q¬P?<™Éqz ©Ò‹ª”EJPžxkHýIY,GLxßÛüúQ0'' þkdeÝ‚sõˆ‚?s ýId+>KtÔ“ôTÿì;H-@FYFYFY?+?+9/+910632#"&547!7!"32654&}_©¦ÞǪ·bþ¦Gegadr„bh–‹©Ë ™_cÏ’ý¬j>a]vcTNÿì…H )@ FY FY ?+??39/+910!#3!632#"&547"32654&œ¦ç¨ü>g}^©§àƪ¶ñdiads‚bHþ –‹©Ë¡˜_caý¬n:a]vcUMÿì¦H$@ FY  FY ?+?9/+910632#"&5473"32654&Z‡m¨°mÉ„±ºªfkij|Œih‘m«\Ÿž[caý¬lM`B11D7 UF]dåÇžè¦]Œpy×¼N²Fnƒ[, …>pDe`Ÿ»û¸²j\¨nÿÿbÿì½Ó&HjÔ µ66&+55;þ!*<@$ &'&GY''$) FY $)$FY?+??9/+9/3+3910!!3632#"'5327654#"##7373^þ¦&  –à…Žª$œ‡E6;;|*ª–X©‚!\¨ ˜•'¨Z±€Tá’„>hüå«ŸÏc$”wßžþLÙºÿÿ7ÿìÄ!&Ív ´..&+5bÿìª\&@FY FYFY?+?+9/+10"&54$32&#"!!3267úÂÖ˜£‰ƒ/xc}À2×!þ+ƒw9r[|ÖÃÇ\´33°¢”#A{“)?ÿÿÿìD\Vÿÿ;ßLÿÿ;ÁÓ&ójþØ µ&+55ÿÿþþþßMÿ¢ÿì˜P(45@&)FY&&FY&/FY?+33?+9/+910632#"&547&#"#"'532667>32"32654&j€^©§àƪ·`!¾vcTN9ÿìþH"2@FYFYFY?+??399//++910632#"&547!#3!3"32654&Ó{`©§àƪ¶þn¤V¤á@ IY?+?Æ103!#Á?¤býÕþë¬7¶+þ:úå¶;¢‡@ GY?+?Æ10!#!3Bþnͨê‹F¬Ëü5H?ÿÿßs&:CR ´&+5ÿÿu!&ZC ´!!&+5ÿÿßs&:váR ´''&+5ÿÿu!&Zvð ´))&+5ÿÿß%&:jmR µ11&+55ÿÿuÓ&Zj{ µ33&+55ÿÿ¼Ãs&<CÿzR ´ &+5ÿÿÿ;þ!&\Cÿ ´&+57Õ‘u±/3107!7#7"Õ  7Õhu±/3107!7#"Õ  ÿÿ7Õhuÿÿÿ1þ0²ÿÕ'BÿíÿtB%{Á¶ ²?Í10'63b¬“8ÁÓ þ§œ}Á ¶ ²?Æ10#7(ŽX†E¶[ÿ…*Ëÿœþø+î±/Í10%#7#q~NîëôØåÁ¬¶ ²?Í10#&'7œw=¶þïäàÿ{Á{¶ ´ ?3Í210'63!'63ôPÀ¢)ýÑb¬“8Áµ*þ…zÓ þ§œ}Á¶ ´ ?3Æ210#7!#67(ŽX†E- ^´9u¶[ÿ…*ËÎþï~%Rÿœþøœî ³ /Í3210%#7!#7#q~N+ _°Œ?îëôØÍþî<ºÙË "@  ??9/333910%#73%¨þǦÏþÏ#%%ÎFãûþ!® £þ] Né?@!       ??99//3333339910%%#773%%F%þÅÏ…þ½%7gþ¼'7Ï…G&þÆç¬þ‡y¬+!® zþ† ®!þåÇì‘é ± /Í104632#"&Ç“}\^”€Y]¬‘¬b\²cÿÿ+ÿã5ò''¨ÿì“Ë,;GV1@<<TT&22 9 BBM?333?3??9/39/33310#"32>54#"&54632"32>54#"&54632"32654#"&54632¼ûØ>wBj@k4T?&‹?eVmze¬rtwùŒBj@k4T?&Œ@eŒWmze¬rtxíCi?jAhE‹?eVnze¬rtx¶úJ¶ýN~öy­O•ÉG¦—kþþ±c•‘¦1˜\~ùw¬O•ÉG¦˜lþý°b–‘¦1˜ýÉøt­‚ g¦—kþþ±c•‘¦1˜ÿÿá¦å¶ ÿÿá¦B¶Xq-¾¶//93310X‡Nþ׬qçB|Qþ²þƒ1´sìÁ¶//93310'7ìþxM(¬qèðþƒRM}2þKÿÿÿæÿã5¶&» þ𶠳??10#ðû™=¶úJ¶¨!Ç@  ?3?Í2910654#"#3632=VLO“=wehDVN!}D*T®yþ虚NP1iþ’-¨¶2@LY NY  LY ?+?9/3+39/+10!!##73!!!!šþå9¢7®®áÏ!ýÕs !ýú‰ƒþúƒ-™ýå˜ÿéšÉ'S@/"#"MY#&'&MY'''?'O' #'#'LY KY?+?+399//_^]3+33+31076632&&#"!!!!!!76677#737#7f6(Ö°[´AB9œAiƒ/sþ%rþ\KÕ!üGny¾Á!Çsõ´­/'…!.q|Ý…¢…ƒ)št…¢…7ÿ쨶$-H@%$ NY$%"KY%%$-KYMY?+?+?9/+9/+339/10%27#"&547#?33#32!##32654&##²6EIa`gPš¦dh-ÅÄT*üãÌÏÛþÈþÜ1{¦BÊÕ‰‰1w a[5ywNK·ÏþV-&,?¼¶÷þòýÁѶ¦w?ÿì×É&K@) NYMY !!LY! LY?+?+99//_^]3+33+310"!!!!!27#"55#7367#7332& ŒäKªþG }þ—){…—Ô骚—ŸaEÏYŽFPq1ÆÇ…Acƒþ‹7“; õ ƒPT… +1ŠNËÿúª¾2%@-(#?3?3??9/39/310##"&546632%"326654%"&546632&#"3267ªû¼›Gºžu‚S˜iv…þúYm=¥Yƒ üyBo63nHNbb¦Bo95pGNbd̓·âgt¬…´pqip«þ»[da]lTUhwZda^pQPl'þ ³ /2/3102&#"#"'53265˜R(/?²ª¤F7<3^`‰ïúë¹À‹ytrs}3/!@ '$*/3/Í232Í322310"56323267#"&'&&"56323267#"&'&&\37b‘EtV@a273eH~HKZ046b‘AO@a273dH~HBbö@9—m%B7•o! A7—m "B7–n! ¦'@  //99//33333310#5!!5!3!!!'{ü=þDþ…jþþÀÁýý¼Ž‹9ä‹þðŽþê5Ñ %@//39/3393310%5 5!üh˜ýìüh˜é¦cß–þŽþ¸þÑ %@//39/339331055!îý˜üh˜Hp˜þ!cþZé˜fà ´ /33/10#3 fþÂHþÇþÇ9áýßäý ýóýòÿÿÿþ¢&ILƒÿÿÿþ°&IOƒ\Ù5 ³ /3Í210!"&5473326759þœœ  ’®pqþÉzx %"XbþþþËH ·FY?+?10"'53273‡E6=:}+¦þö$þÍÛû«ŸÍ; ²?Í106673#%^ŸŽ7\ç7Á57Ç5œþ;Ïÿƒ ± /Í106673#œX ˆ9\þV0¯N;Â7øÙ+! ± /Í10#56673+$\ Š=\6¿8.É<“5üÍ µ !?3?310#"&54632"3254übªmt|c§kôúBk>7?j‚¨´þÖ•žž¤%“w‡æx`e,Ò¬\Jß¼ !@   ??9/3333310##7!733#7É++þ“á…yþEZÍÊÊeCýÍBI$qö‡9¶@  !?3?39/39102#"'532654&#"'!!6Ép¾¦s\wdhoYJCC5{ªþÇA+jp”®4…HkZ?N-¤yß ¦7Á%@   !?3?39/39106632#"&54632&#"2654#"Je8`qP_s‚Õ”C>;Fp #bQaw/X3B-/~ha¡Zƒª8•sž•þ‹`1ODIU®J-¶¶ ?3?310!7!®Óþyþ-Júr^üòƒ9Ç"/@ )) # !?3?29/399102#"&547&&54632654&">54&j}m^I<­Œu‹á=/ $dTP@H[EGJ*8D<$BÇpYQy /f@t’ve´U.U?j~þ&\<;@QD1Y•I6*B%,=)06=úÇ%@   !?3?39/3910#"&546632#"'53267"326654&Vf7`qP‘^s„Ó•C>=Sy¥#bOcw/X3Bá-/|ia¢ZƒªþÈ•{ž•ub1ODIUTþÁî #'+/37;?CGS[kt|‰@N*B)AF>E=&2%1 VKcuult\ZQ‚} vk K}kl…\QQ\…lk}K -, 48!59/333/3339/////////333333933Ä2Ä2Ä2Æ2Æ2Æ210!#%5!#533!5353!5!!5!5!#3#35!#35!35!#35#3#3#"&546323254#"%32##32654&##32654#"'53253T/ÀÎ0mùoÀÃmýIûáþò·mmmmûÂü0ooÀwú¨ooooþmmûŸ‡‡‡~ˆþs‡‡‡‡á¬mp.,;0m^Ï{B.$*/;J1%Z^4+V}i¾0oÁÁoþÐÁù/ÂmmÂþÑmmmmþooú¨ú;mm¦Jooooü/yýhI‘œœ‘’›š“ÅÅÄaCS1D D8QYb" "ãš+%Jþú fV’þr_cTþÁª*@ (""//9////310 54676654&#"63232654&#"þ¬üTüVë,AgI»¥OºGR Z?>1HT;GFBIHCHEüVüW©û/2A1R~X‡š8*²P:/5K6DpJ;þí?HI>@IHÿÿþþþÿ!&7LþÆ ´&+5ÿÿ}Á ¶/ÿì¾+1;<@%5%GY/55*FY**9FY*!FY?+?+9/+9/3+310#"&54676654&#"76323267$46323365#"%¾þø¡–¥*9 NHJV$"¤p»‹ýóÞ­»ýn°ÃÀWbPþöþkÅ’†K…C&K" ƒ VGR‡N°°‘A˜BP’~~Êþª®cWºÒ…sþ²þæjk´—K:RT¡ÿÿT¸u&0vÁT ´&+5ÿÿ;‡!&Pv˜ ´66&+5ÿÿÿ‹ýÛ¶&$[ÿÿbýÛ`\&D[/ÿÿÿsÿìüÍ&2y\þ@ÿºýÛyÿƒ  ³ /3Ì210#"&546324&#"326ydewvfdq?33@:93?þ°atrabsv_6==65>>3^{ŵ   /ÌÄÆ310673#'467#"&+V@º`®Bø‘‚>A 4.07›š‚²eZ„V0 "2>ÿþ-=ALJ@&JE@@(?3$$FY- (: ( GY7(FY?3+3?3+333?3+3?3Ä210"'53267!#"'53267#?6632&#"!76632&#"3##34632#"&!G6=6DVãþè'¢„E8@0FXãÁ Î.£ (t +L=W]â-¢¢)q$-L=Y\ïîç+¡O¨é¨y@3XC,&6þs|:û¶½®t{:CBdÈ¥allŦf|lû¶Ã¨ìH6IZ7L1ÿþ;AA@"7("(FY1">,,GY;, FY?3+3?3+333?3+3??10!#3"'53267!#"'53267#?6632&#"!76632&#"3#ð¨K¨úæG6=6DVãþè'¢„E8@0FXãÁ Î.£ (t +L=W]â-¢¢)q$-L=Y\ïîç+¡øs|:û¶½®t{:CBdÈ¥allŦf|lû¶Ã¨–ÿì¦%%@ IY IY?+?+Æ9310# $326673"32654&ƒ°þ¸×ÿþâÀOÒ”ÜBQV»!¢-ýçø‰Ä¨˜ñŒ¼‹þóþWé+´ìqj!€Š«8uÊþ˜ÚÇßÃlÝÇßbÿðHð$%@ FY!FY?+?+Æ931026673#"&5464&#"326ƒØnOX¸ !£Š#ö›ÀÚ’øƒ}km­_wh¦]V!ƒ…†°4Vi¼þ²¶âľO³þqs”þù¡ƒ’ ¤ÿìå@  IY ?+?3Æ931063#"&5473!267+©(¸"Ý«‰7þæòç佪¿#©À.ͶÆ$™Ê"ýwþöúÔÃVonüƒhDþö®Í¸qÿì×ð #@  FY?+??3Æ9931032667363#7##"&546Ö“Xª‚"d¦«(¸"⨴‹ b²_‚–HýIY,•xàžÛ"›É!ü¬Ë}b…,j´ÿÿý.Ùþv!CúïÿÿýæÙÿŒ!vûÒÿÿüµÙÿ”ÝRûeý¾¶ÿ ² /Ì210#76654&#"5632éncj^^@4'82AowìR^o¹5.*d Tü¬þ ýwÿ} ± /Í104632#"&ü¬@3.*C,&6þþ4K4&7L1ÿÿVjs&(CÿûR ´ &+5ÿÿVžs&²CfR ´&+5ÿÿbÿì´!&HCÿU ´$$&+5ÿÿqÿì^!&XCŽ ´&+5–ÿì`É8/@,,!!IY2((IY?3+3?3+39/910"'632#"&'#"&54$32&&#"32677332654&ß6^4H„¡¯½u½è’rœ!1±tÈѱ ´¯hR3Z6|Ä~m€5®6 ²’ÜŽl/+ŽVðÛ·þfþÎ]SR^ýðþóÿXŠ"&åþ[À­µŠõÿE®÷¹Ë™˜hßH@  ???33910333663##섪F ?9¦C oœq:¨Kþòܪ5þïHýv§ôÍý²Àžtþ3þŠýûͬþT–{1@IY IY @JY?+Í99//+3+310!!!7!3!!3232654&##{þ·þÊþáîþË"4=¬=r!þŽ>ÖÜý+uÔÜŽ“áê÷`œþèœþæ´þªœrc\ÿìé'#8@ FY FY FY ?+?3+39/+Æ910!63 #"&547#7373!"32654&þáI‚qXñɬ¾báá/¨-¸}oij{Žm¶þ²þß©Ëœ¡UiÏ’ßßý¬s5c[teWKVÿìBË%1@IY!IY! IY?+?+??9/3+310"!!327#"47!#3!6$32&ãÉþÔBoý Á®Š·Vœnöþòþ¼‘ª5ªƒB5Ø,¶ÃœH‡3þüç˜>U¿Û9•$ Z=ýP¶ý’Ã'™PE;ÿì\%1@ FY  FY FY?+?+??9/3+310"&547!#336$32&#"!!3267ÝÃÒþþi¨ê¦aþ;‡…/xc~¿2Ø!þ-†vNz<~ÕÄ45þHþ5âý33²¢’6|’(?ÿ‹q´ #@ IY ?33?9/+3310!###3##7'&'Rž”{þp²Züªow^C†°ýP´úL°š›œh;}çÿ¤¶H !@FY   ?3?339/+310#####&'ú¼¨P\fžo\þ߬…JsHû¸òþòþHþ1³‹ÅVZ¶+@ IY   ?3?39/3+33310!###!#3!3##7'&';•}þs´•þ‡¬5¬…°m‘úªnw\ F€°ýP°ýP¶ý’lúL°š—•xI‡Ô;=H,@  FY ?3?3?9/3+3310#######3!¼§L^gžm\þá®!üi¬êª`3 ‡1¼Hû¸îþîþîþHþ5Ëþ1Pþ°ÿ®{¶!4@ !JY !IY?+?339/3+3333310#>77!#&&####"!RÑPt–kþþ)g{>¬ \f˜ª–IcQ6×…¦ýw¼ª‹Iì‹‹þM•þ7É’hý=Ã,cqþ=\Ãÿ‘¤H4@  GYFY?+?339/3+3333310#>77!#&&###"!oÃ8d„]á þŒQc:1¨/Wcq›n [r<´)7þjjg< ^iiþ¢ @opþªTlTýìMqþ¬ƒ1V{¶$'=@! '%   IY   'IY ?+?3?9/3+333310!667!#3!7!#&&+##"!®Õ"D+þ}‘ª5ªƒùþ)g{>ª\f˜ª–m}I×…¦ýwÅHx+ýP¶ý’ã‹‹þM•þ7ɉqý=Ãf˜þ;\Ã;FH #?@" # GY! FY   #FY ?+?3?9/+3+333310!67!#3!7!#&&###"!3Å.4þöi¬êª`ä¢þ‹ws1§0Y`qœm \l>µ)8þmW*þHþ5biiþ¢€™þªVpNýìMsþ®ƒ1ÿ¸þZ'ÍJd@8?9IY??A00GIY)JY00AA5IYA" JY/ # JY?+33Ô_^]Ä+?+99//+9+9/+104!#732654&#"'67&''53>32&#"327632&#"&5467>þ¾×È»Ù}i¨¸H®Á'J$xTBPAF'&*%7>54##7‘#®D€P6‡w0_yAPZh6/'%"C?[aƒWcdÄ¿’^:;Z˜L0Z0\`š¨}Ep‹G˜rBÑ”É##>Y~HjtFq3Z{[m”xViŒY6,#) 'kYN^76SBš‘ÿÿÇD¶uÿÿþf•–ÿìƒÍ &@IY IY IY?+?+9/+10# $3227!"!654&ƒ°þ¸×ÿþâÀOÒôý5º5üœÄZ¹þì5a¼‹þóþWé+´ìþÌûêü#RÇß²þìî,0ÇßbÿðV &@FY FY FY?+?+9/+10#"&54632267!"!74&ô™ÂÚ’ø—¿Ùýéx¸$ý¼úw·*>uÁÁþ«»ä¾O³ÙüþÈ©AƒN±›J{‡¼dÃ@  JYJY?++??3102&#"#3767>î0F*<&>>Aýü¹¢ªa)b``pÉ+^…ûÓ¶üX¸“Ó&Ì‚8`!N@  GY ?3?+?103367>32&#"#`ª@FVž=MaF)%'*=0þ}æHýŸË?d±½T„c,y;aüÉÿÿ¼ds&€v+R µ""&+55ÿÿ`!!&v µ""&+55ÿÿ–þ ÙÍ&2\ÇÿÿbþhV&R\V–ÿƒª1.9@% @--IY (# #IY ?+33?+33ÍÍ2310#"&'&54$7632%"&'6326'ªŸþØÄJ6;>²Æ£+½'p;>¸¿ýÕ3B€Èntu0^1AÄóæ-{ôþsñ>1K6+%ßìúlC82þÞg/-!Òþ¿ºžÕ(P1,0Ÿ!>^Rbÿ‘;¶05@%/ @(##FY /FY ?+3?3+3Í32Í210#"&'&&546766322654&'#"&'6;jÆ„F328‘œpÍ„E638Œ’ýî"2 vŽFG(Q#6 N€IQM.°ªþÛÅ ;0;2ᮜ(Æ;-;3"Óý|%-'Ù`…A"™å†nF–ÿì`3!UC@!$>' .  H4.4IYN.A;';IY"'?3+3?3+3Ä23Ä2Ô299Ä210#".#"#63237654&'&&5432"'#"54$32&&#"326732654&#"'632fQuc^9dƒ2à=kjnAþáør!\9B‘ ‘Nž`Àͱ ´¯hR3Z6|À|S¨:5›O£Ü‘la6^4H„¡¯½yÂîÁy$*$rë$*$Õ˜DJ,. GCøÉX'1íþóÿXŠ"&åþ[À°²F9Š“…í{}C[+cƒ‘h>kimAþì{s'$1+;B;;ÖÅËX°#Œ0Šþ럅PP”$·Ó-‰$¸²ìþ˜°£x9ryp#+#×Hq"J.. #&E–ÿì`ü FE@") ::") @ )/)/IY)@6"6IY"?3+3?3+3ÔÍ339/33910#'##'##'7"'632#"&'#"&54$32&&#"32677332654&Nw¿H¾J-Ñ6^4H„¡¯½u½è’rœ!1±tÈѱ ´¯hR3Z6|Ä~m€5®6 ²’ÜŽlü¬gggg¬þ3+ŽVðÛ·þfþÎ]SR^ýðþóÿXŠ"&åþ[À­µŠõÿE®÷¹Ë™˜hߤ&*@$  #???33Ö23Í22910#'##'##'733663##ßw¾HÁH+´„ªF ?9¦C oœq:¨Kþòܪ5þï¤ ¬gggg¬ú\Hýv§ôÍý²Àžtþ3þŠýûͬþT–þ Ë@ IYIY?+?+?10&5$32&#"327gàÿÓdáÅ—EŠ®þí¡Ç¥MCŒþÚ (÷ÁìPEÂþ‰Ý¾Úýrbþª\@ FYFY?+?+?10"&54$32&#"327‘eÀÔ–¦‰ƒ/xcq¸iƒwgXŽþØÓ¼Ë_·33›þ뢀|/ýduÿú… @  ?Í910%'%7%7%XHþã´´þæEÇþãH··Jþæ°¦{¤þÇJ;¤{¤Z¤}¤9IþĤ{¤T‘N¶´ /Ì9/310#"&543!632Y(,‰°Z*,CHð_1w^'">=wåhÑ´ /3Í23102>32#754&#"##7˜Q‡ys>dj{5)+p…—Q ^$+$_O$"%+%y}Ùj/ ²/Ì3104632&}A>*,#xí¸9>("0.JC˜Ù}/ ² /Ì3105654'&&5432}srp)"^9B´Hq"J,. HC)þÁÁ‘ (6DR_me@4 >7ELHZS`gc")0,,,%3Vcc\j:HHAO3jOOj3  /3/39///333333333Ä2Ä2Ä2Ä2Ä210&&#"#632&&#"#6632&&#"#6632!&&#"#6632&&#"#6632!&&#"#6632&&#"#632!&&#"#6632o3@,/2('$ < 8//99//Ä2Ä2ÄÆÄÄÄÄÆÄ10#677&''6673&&'7%'67'&'7%'766&&'57 F$a5sGÈAÝýR Ia4!‚&b'Zü›©E±x+REC{L%E±xbC¾ûWB¿OÝ#B¿OÝ® Ia5uGÈAÜ‚ú¸2Ã4bEÂ<ºY?DnXÞŒ·FÆcÓDnXb'Xý< F$a5Vþƒžb",@"@ " IY ?+???3Ö2Ì299103333##7##!"&54733267‹¤®Z¬Çþë¬úÈï›®<"üNÇÑ9þ››  ‘®qr¶üÏþu¼úäýé}9!yû-bþÉ{w %"[_qþ…o,1@,$@) " FYFY?+?+??3Ö2Ì29103266733##7##"&547!"&54733267Ö“Xª‚"d¦È£ã¨Ç‰ ]³c‚’V9þ››  ‘®qrHýIZ1xàžÛüIýô{Ëze‹>n¤ÈþÉ{w %"[_Vò¶3@IY IY  JY ?+?9/+9/3+310!!3 !!#73732654&##5'/ þÑ<³þ¹þÊþáîš!™)ntÓÞŽ”¶¶˜þÞþ›éøh˜¶úÝ©rcÿì¤"9@ GY FY  FY ?+?9/+9/3+3910!!63 # 47#7373"32654&ìþúy„pXóÈþš“–”5¨}ohk|ŒmƒýÌþߪÊ=[cµƒõûàn:c[udWKV‡¶9@  JY JY?+?9/+99//9933102'###327'7654&##ÕÖÜÿJRu‡‡{ª5…`BDJ‘‹’£¶½¼þÉ}›@ªýÁ¶ý”=ž\É}oÿÕþ9Z)?@ "%"%$$$  FY FY?+?+??9999//993310"&'##33632'"327'7654!b”' m¦P‹³Á‰žœ‹JL=‰`ÇurhJHWgfXV9ýù4ÑãðÞþŠ`™@ ã¾þà—mv¤;—S,¨ãNb¶ $@ IY  IY ?+?9/3+310!!!##73b ýÕmF!þº‡¬‰‘‘¶›þ–ýw‰–— ^H $@ GY FY?+?9/3+3103#73!!!!;i˜—g9þoJþôié}âþ®}þVþj¶.@  JY IYIY?+?+?9/+910"#!!632#"'532654& \%‡¬5ßýËq?Jì¥þÕÁ˜q}w‘ှýy¶™ý÷ þãþæþž¾/œ5˜&¶¹Ì;þ hH.@ FYFYFY?+?+?9/+910"&'53254&#"#!!632ND^+)[?¦ÌrK4c¨êCþdFS3l«]òþ ž$,ð þ)Hþ²nˆËþÅ®ÿœþƒð¶)@  " IY?+??3?339103333####Hþ“»h“¦“}Ïý^%¸s¡O`þ–š¦šýwѶýFºýFºý!ýÅýç}Ûý%Ûý%ÿÝþ‡ç\<@@":GY<<3"(FY#/  FY4?3+3?3+3???9/3+310##"'732654&#"5632333>32&#"327#&&547##¢!’Ô…C85/i«chc1?W2ª´¨dši¤™ÏzO>67h¤bbdNBo¤JŸšªg—é˜å€‹š‘‹’‰×ÏLÞþ"“ìs‰–þí“Š’ýúg Û½8 þÿÿÿúþH'Ë&±dÿÿÿüþHF\&ÑTþ…/¶"@  "IY?+???3910%3###33ÁŸp¢R<þ4˜¬5¬—ÀÑý!œýé{Õý+¶ý8Èý%;þ…#H"@   "FY?+???391033###3^ÅýÛ°q PNþœs¨è¦oHýåþ`ýø{#ýÝHý÷T-¶+@      ?3?399//99910!###3733 ºô+‰P}}¬5¬—‡Eˆ‡ÓýfÍy`ý´¶ý8‡?ý^5?F(@  ?3?39999//9103#373%3##'Û¦æ¨o{E‚% Äýð\¿¼)JLFý÷uD¬üþlþÅXsV)¶)@ IY  ?3?39/3+39910!###73733#3 ºþÛ®}ªì”!“)ª'¿!¾P¼ÏýƒÑý°f˜¸¸˜þŠÆý…9!*@  GY  ?3??9/3+39910373!!33###Ç•)¨)þþ=40Éþ+'»ë˜Rª ˜\¸¸ƒþÙâ¡þ-ý‹ {þoٺǶ !@   IY?+?3?910!##!7!3¾Äþ3—ªþº!ð˜ÁÓýÕý+—ý8Èý%NËH !@   FY ?+?3?9103##!7!ÅýÙÁþšs¦Çþ¤oHýåýÓ#ýݶ’ý÷Vþƒs¶%@ IY   "IY?+???39/+10%3##!#3!3^ q¡O¥ýl‘ª5ªƒ”…¨œýç}°ýP¶ý’n;þ…‹H%@ FY " FY ?+???39/+10!33##!#Ëab¨Ê‘q¬P‹hýêi¨êHþ5ËüEýø{îþHV¾¶ $@ IY   IY ?+?3?9/+10#!#3!!Tþé§ýl‘ª5ªƒ”…óúá°ýP¶ý’n—;çH $@ FY   FY?+?3?9/+10!!!#!#Ëabþ¤Éªhýêi¨êHþ5Ë’üJîþHVþN¶0@ JY IYIY?+?+?39/+910!#!#!632#"'532654&#"'®ý‡þìª5Ñ‘?Jî ¥þÔÁ—q}w‘ှ­\%úá¶ý^ þâýæþŸ¿/œ5˜&¶¹Ì;þ þH!0@FY  FY  FY ?+?+?39/+910632#"'5326654&#"#!#!üS:m¬\€ñ¤qY*X>mª\qP5bªËþɨê=jmʈËþÄ­3ž$‡ú› þ+¶üJH–ÿ¬yÍ-93@ %.++4JY IY IY#IY?+?+Ä++910327#"&'#"$32&#"327&54632654&#"y¾¤.@CJ@WQ‹.9Z4ûþç¿VÔy}:]aŸþüŽ¾¨*VuÉ€‹Žþ!‰ 9<¾<å{yÃþ½E óÓÀA©Žƒþü¦‰¢o›‡Ü|ŽzšþïQ‹ÿÿ–þH Ë&&7ÿÿbþHª\&Fwºþƒ´¶ @" IYIY?+?+3?10%3##!7!!šq P¦þj!Ùþhœýç}——;þ…°\92@&-#*$#"*FY1*GY?+?3+3??3?9910%327#&547654#"#654&#"#33663236632%-3n¬O…\Qžwk¨”>KTŸy!e¨ê‹ W­\qz VÂc‹X º 'ýþk$Š0<ª].tÕ’þ ´^)FNxßþ%HËwh‚t}y‹‹)P-þl,ÿÿ¼Ã¶<bþH ¶  ??3910%673#3u3…3²ýŒg¨g”¨D Çyëû´þèLýénümö%@  IY  ??39/3+39103!!#!7!73éÁý " þáJ¬Lþî îªËëüg#šþ `š+‘ÿåþH!@   GY ?3+3??3910%673!!##733u3…3²ýŽþþL¨Löô’¨D Çyëû¸}þ‘o}Hýénüÿ˜þƒÑ¶ @  "IY?+???39910%3###33¤q¢R\ÓþºTþù¬Ë»ºýÕœýç}ý®ýÍ3ýJÿòþ…?H @ " FY?+???39910#333##þ¤ÀÙJÂþ:¼–q¢R=²þN5þdœýåþ`ýø{ºþ…=¶'@ " IY  IY?+3?+3??10%#!!7!!!3Íq¢Pü/þjß þdôu¬þì˜ýí{™™û}úâZþ…øH'/@% "$%$FY%FY?3+3?+3??910326673327#&&5##"&547!7!;v”Y«!d¨° #-3n®Q?@\±aƒrþɶýÛU0•zá›ÛüÆ,& )ýþkdexeŽ„0v’’øþ…'¶)@ IY "IY?+??39/+910###"&5473326733;¡O£Ù­§ uªqR`W®ˆ–¬þëœþ…{XX‘4TýäK(GH0Ïúæœþ…3H)@FY " FY?+??39/+9103267733##67##"&546–>“—Ð3¨Ë’q¬PS#©È… EHþß^)”íàoüEýø{ƒ„?Ç’‚&JEø'¶2@  IY ??39/+9/9/33910!# 47333673F”bB‡>þ´ yªw WeJ‰G_˜–¬þËX:þÍ'1;3ýË.(KHZþ²5ÏúJœ1H4@ FY ??39/+9/9/339103673#67##7"&546–>‡?=ÐS¨é¬A-mƒ75€’AHþÝZ+’#þìJrsû¸5„Ž-þøüˆŠ+\0Tƒ¶@IY?3?9/+91063 #654&#"#3¸Þ¥H w¬y T`Y¨Š˜¬5¬\Zþè3:ýÏ3.*II1ý3¶;ÓH@ FY  ?3?9/+910!654#"#336632Ù>“šÖ,¨ê¬U!Y±`ƒ’9#[,“øÛjHþl~2i\„±ÌwQJa¨è¦oHþݸÇþɬ3ž$!÷Ž¥þ/Hý÷ÿ¾þ…1¶$@"IY IYIY ??++?+?103##! #"'532661þêªöÉð¨þK°®€L143Si^‘˜¶úâýí{þÜý›þÖ–XÐØ5ÿ¢þ…P&@"FYFYFY?+?+?+?10%3##&#"#"'5326676632B£å¦Ç¨Ï''M`RSTtŒd/'@[W@Wz¦„~x‘ýô{º =—íðÇY‘ L«»¾WVþs¶"@ IY   IY?+??39/+10"'5326!#3!3Ë”t}‡Ôß8sýl‘ª5ªƒ”…¨þãDþÆþ1¤5à 'ýP¶ý’nú·þ½þÖ;þ ‹H"@FY FY?+??39/+10!3#"'53267!#Ëab¨á?ßÅy`[|“/\ýêi¨êHþ5ËûÙþÜó1¢?¹ä³þHVþƒs¶%@ IY   "IY?+???39/+10%3##!#3!3^°÷Éï§ýl‘ª5ªƒ”…¨šýé}°ýP¶ý’n;þ…‹H%@ FY " FY ?+???39/+10!33##!#Ëab¨È£ã¨Ç¨hýêi¨êHþ5ËüIýô{îþHøþ…'¶)@IY "IY?+??39/+910!#3# 47332673NR q™_Ù­þ¹ yªw R`X°ƒ˜¬þËþ…¼X1;3ýË.(JI /ÏúJËþ…`H)@FY " FY ?+??39/+910326773##3667##"&546Å>‘›Õ.¦ç‰RªlŒ/! “؇AHþß^)”òßkû¸þ…æ~F¸…*V5Tþ…¸¶%@  "IY?+?33?3910!##33!3##7#¤¦+¾¢5ô• “ þð¬öÈïª~†ý3HûJü}¶ûL´úâýí{NwMúî=þ‡FH%@ " FY?+33??3910#&'#36733##…eþy{nº’èºs"WœÇˤâªÇ‘q#ªý\¦qXü‘Hý+ŽAM”ÃüGýøyÿÿÿÙ¶,ÿÿÿ‹´b&$6R ´&+5ÿÿbÿì…&D6P ´##&+5ÿÿÿ‹+%&$jBR µ""&+55ÿÿbÿì`Ó&Djý µ44&+55ÿÿÿ‰Ý¶ˆÿÿbÿìX\¨ÿÿV¨b&(6sR ´&+5ÿÿbÿì,&H6÷ ´%%&+5TÿìÍ#&@IY IY IY ?+?+9/+10"56632#"&54$!36554&27# îÝÒyÌzõÉþ–ÕÈàºÕi»þcÇ(DjþŸþª~5` 2&þÔþûýþNþÿ°¡ûã9ÆâûPòš§Ze;ÿì\"&@FYFYFY?+?+9/+102#"&54$!374&#"566267#"ºÏ–õ“™›O2!‚zKŒPd‘:h¶. åòI\ݾ¾þ§¾…vµÌPŠ.&‘."ü¿£wp5FÿÿTÿì%&ájR µ77&+55ÿÿ;ÿìÓ&âjŒ µ66&+55ÿÿÿœð%&°j9R µ%%&+55ÿÿÿÝÿìçÓ&Ðj# µPP&+55ÿÿÿúÿì'%&±jR µ;;&+55ÿÿÿüÿìcÓ&Ñjÿz µ::&+55ÿìZ¶/@JYIY JY?+?+39/+310#"&'532654&##7!7!#ÁÔŒþô¶^»A³¶¸Ó’Ÿý» 3¾¦Úv-$¤h¯ts‰曋ÿuþ‹H/@GYFY FY?+?+9/+3310#"'532654&##7!7!¤É‰þþ«Å~“¹³Ò¬¨HçýåÝŠرŸõ‡FœXÓ¸’rü}ÿÿVž¸&²MðR ´&+5ÿÿqÿì^f&XM- ´&+5ÿÿVž%&²jÏR µ""&+55ÿÿqÿì^Ó&Xj µ,,&+55ÿÿ–ÿìƒ%&2jÏR µ//&+55ÿÿbÿðÓ&Rjè µ//&+55ÿÿ–ÿìƒÍ~ÿÿbÿðVÿÿ–ÿìƒ%&~jÏR µ33&+55ÿÿbÿðÓ&jè µ22&+55ÿÿÿìo%&ÇjÿõR µ22&+55ÿÿÿìBÓ&çjÿU µ//&+55ÿÿÿüÿìP¸&½M\R ´&+5ÿÿÿ;þf&\M™ ´&+5ÿÿÿüÿìP%&½jDR µ))&+55ÿÿÿ;þÓ&\jˆ µ,,&+55ÿÿÿüÿìPs&½S‡R µ))&+55ÿÿÿ;þ(!&\S³ µ,,&+55ÿÿú'%&ÁjR µ**&+55ÿÿž3Ó&ájÔ µ,,&+55Vþƒj¶ @" IY IY?+?+?10!3##jýËô›r¢P¤5¶™ûýç}¶;þ…^H @"FYFY?+?+?103!!3#;ê9þo¬n®PHüÕýø{ÿÿVT%&Åj'R µ))&+55ÿÿÿì…Ó&åj… µ44&+55þyb¶7@IYIYJY JY "?+?+?+9/3+310!!!3#"'532677##73b ýÕmF!þºh‹=scC%.4(5 ª‰‘‘¶›þ–þ þÕzuŽ>3‡‰–—ÿúþy^H7@GYFYFY FY"?+?+?+9/3+310%#"'532677##73!!!!=qbB&/3(6 ¦i˜—g9þoJþôL‹þÝpŽ>3‡é}âþ®}þ¢ÿ˜þyѶ'@JY JY"?+?+??39910%3#"'532677##33…‹=paB&02(6 ZÓþºTþù¬Ë»ºýÕ“þÕ~qŽ>3‡ý®ýÍ3ýJÿ¶þyH'@ FYFY"?+?+??39910#333#"'532677#Óþ¦ÃÛ类JÂþ9½=pcB&02(6 J²þN5þdœýåþ^þÝ{tŽ>3‡ÿ˜Ñ¶)@IY  ?3?39/93+3910##!7!33!¼´Óþºþì è¬Ë»ºþ !¼ýDý¼š`ýÍ3ý šÿ¶H)@  GY ?3?39/3+39910!33!!##!uÓª®JÂþwþòã¨Àþ¦Ã¨þüuÓþdœþ-}þ²þNø`‘¶ @ JYJY?+?9/+104$!33! #"!3`8²‡ªþËþÁþCâ±µÌ!ž{ÕöpúJ´Ÿ’ðÿÿbÿìÃGfÿìD¶%1@IY""IY?3+3?9/+9/910#"'#"&54!33327#"3267Dg(ɤÔG‚઻U$‹†¬êUO°/iý¶uÛájgo—PþÀºª¨¹¥í pû´ 'NRÙô¢µ¯[l{fbÿìH$10@!,FY%%FY ?3+3?+?9/991032673#"&'##"&5463236732654&#"ÁSVduB¤B+ij†žaÉpŠ›Œô™a“) L¦ôþ]Åyohd«h+Tbz=þÁÕ¼€m~o°×`ÅdZŠŒbûŽHãµ$œnu£þتãøÿìRË-:@ '',JY,JY,#IY,?+?+9/+9/99104654&##732654&#"'663232673# ò ›Ç˾Õup©¸GsÕ«ÉÆ®…lNXgo`¬f,À²þ¤'#U8ta¥‘dhv{K>®–™Ö$|ve\pŒÑþɱ˜ÿìm\*8@ !'FY !!FY! FY ?+?+9/+999/1032673# 74&##732654&#"'632é¦duB¦B+Ŷþ¿Vg¢kŠXVH‚H5°¡±ƒZ\dX—z=þÁÖ»ZTH‘c[DJ'T…{l–möþƒ3Ë%4@ JY%"JY"IY?+?+?9/+9910!#654!#732654&#"'6323#\¤LþèòÙ¬×raj²WGÎø¯ÈÁ¶‚€*œq¢dL+ѯ‘_e?7{‰®–˜Ð)ŽpfÁýç˜þ‡\\&4@#FY"FYFY?+?+?9/+99103##66'4&##732654&#"'632î‘nªM"%^_¢kŠXVH‚H5°¡±ƒZah,™ýúy©P@‘c[DJ'T…{l–lÿ¾ÿ鼶$'@ $$IY$IY?3+3?+9/1032673#"&547! #"'53266Õªeq `¨h+Ư™±°þ°K°®€L143Si^‘˜¶üw9 oÑþ˳žA‡>þÜý›þÖ–XÐØ5ÿ¢ÿìðP.)@**FY*" "FY?+33?+9/10326673#"&547&#"#"'5326676632jªD[:B¨Hg¦zš¥u''M`RSTtŒd/'@[W@Wz¦„~x¨2im=þªœO–Ž>H$ =—íðÇY‘ L«»¾WýRHVÿì3¶,@IY IY ?+??39/+9/1032673#"&547!#3!3‰¬gr`¨h-ð›³5ýl‘ª5ªƒ”…¬ß# tˆÑþ̲ž=XýP¶ý’nûâB;ÿìmH,@FYFY?+??39/+9/10!#3!3326673#"&546býêi¨ê¦ab¨•ªD[:B¨Hg¦z›¥îþHþ5Ëý;H¨2im=þªœO˜ŒD–ÿìNË&@IY IY IY?+?+9/+10!#"$32&&#"326!1+ þý½üþæÎeÝë½Bl¥U¨þ뻳¾Ö1þ“îyîþð‹'®òT˜/%Èþ›ÝÍÙÓbÿì\\&@FY FY FY?+?+9/+10!#"&54$32&#"3 !oí;þüäÔï *Äp¨J@Š˜ßþý•Œ"@þÁ?\þùðîÖÃ:¯&*…NþÓþ“¤?ºÿìÕ¶%@ IY IY?+?+39/107!!32673#"&547º!Ù!þiÁ¬eq `¦f-į›³º——üyH- oÑþ̲ž4asVÿì/H%@ FY FY ?+?+39/10326673#"&547!7!!ªªD[:A¨Hg§x›¥uþÏ þÑw¨2im=þªN˜Œ>H ’’ýÍDyÿì˜Ë(-@&JY JYJY?+?+9/+9104$32&&#"33#"3267#"&54675&&9Ó‚½M[W‡Q†§‘Ž¸µÚÜ™Šn¶S¿×ÐêáÅk{-»ãHFvC3˜~tz ›v‚6&˜Q°±Ú"œÿÿ?ÿìœZ‚ÿ¾þy1¶ +@ IY JYIY JY"?+?+?+?+103#"'53277#! #"'532661þè@o`F#,7MªþK°®€L143Si^‘˜¶úÝþÕnŽq‡þÜý›þÖ–XÐØ5ÿ¢þyP)+@'FY'FYFY FY"?+?+?+?+10%3#"'532677#&#"#"'5326676632?Ž>pbA(03(5 ¨Ï''M`RSTtŒd/'@[W@Wz¦„~x‹þÝ~qŽ>3‡º =—íðÇY‘ L«»¾Wÿÿÿ‹þ ¶&$g¬ÿÿbþ `\&Dg–ÿÿÿ‹ß&$fR ´&+5ÿÿbÿì`&Df¾ ´&&&+5ÿÿÿ‹XÑ&$wîR µ&+55ÿÿbÿì&Dw´ µ,,&+55ÿÿÿ‹%Ñ&$xîR µ&+55ÿÿbÿì`&Dx´ µ,,&+55ÿÿÿ‹ /&$yîR µ&+55ÿÿbÿìÑÝ&Dy´ µ,,&+55ÿÿÿ‹Íb&$zîR µ00&+55ÿÿbÿì“&Dz´ µBB&+55ÿÿÿ‹þ 8s&$'g¬KBR ´&+5ÿÿbþ `!&D'g–K÷ ´--&+5ÿÿÿ‹R&${ðR µ&+55ÿÿbÿì`Á&D{º µ!!&+55ÿÿÿ‹P&$|ðR µ&+55ÿÿbÿì`Á&D|º µ))&+55ÿÿÿ‹PX&$}ðR µ##&+55ÿÿbÿì`&D}º µ55&+55ÿÿÿ‹»b&$~ðR µ%%&+55ÿÿbÿì…&D~º µ77&+55ÿÿÿ‹þ N7&$'N3Rg¬ ´&+5ÿÿbþ `å&D&Ng– ´$$&+5ÿÿVþ j¶&(gÿÿbþ ´\&HguÿÿVjß&(fðR ´&+5ÿÿbÿì´&Hfƒ ´((&+5ÿÿVƒ/&(RTR ´&+5ÿÿbÿì Ý&HRÚ ´,,&+5ÿÿVVÑ&(wìR µ&+55ÿÿbÿìñ&Hw‡ µ..&+55ÿÿVjÑ&(xìR µ&+55ÿÿbÿì¾&Hx‡ µ..&+55ÿÿV /&(yìR µ&+55ÿÿbÿì¤Ý&Hy‡ µ..&+55ÿÿVËb&(zìR µ--&+55ÿÿbÿìf&Hz‡ µDD&+55ÿÿVþ js&('gKFR ´&+5ÿÿbþ Æ!&H'guKÐ ´//&+5ÿÿÿÙ)ß&,fR ´&+5ÿÿ;¦&óf ´ &+5ÿÿÿÙþ ¶&,g ÿÿÿúþ ß&LgNÿÿ–þ ƒÍ&2g5ÿÿbþ V&Rg²ÿÿ–ÿìƒß&2fªR ´!!&+5ÿÿbÿð&Rf¦ ´!!&+5ÿÿ–ÿìãÑ&2wyR µ''&+55ÿÿbÿðý&Rw“ µ''&+55ÿÿ–ÿìƒÑ&2xuR µ''&+55ÿÿbÿð&Rx“ µ''&+55ÿÿ–ÿì’/&2yuR µ''&+55ÿÿbÿð°Ý&Ry“ µ''&+55ÿÿ–ÿìƒb&2zuR µ==&+55ÿÿbÿðr&Rz“ µ==&+55ÿÿ–þ ƒs&2'g5KÍR ´((&+5ÿÿbþ !&R'g²Kï±-¸ÿh@ --%((&+5+5ÿÿ–ÿì¦s&_vR ´//&+5ÿÿbÿðH!&`v9 ´--&+5ÿÿ–ÿì¦s&_ChR ´''&+5ÿÿbÿðH!&`C† ´%%&+5ÿÿ–ÿì¦ß&_fªR ´**&+5ÿÿbÿðH&`f¦ ´**&+5ÿÿ–ÿì¦/&_RåR ´//&+5ÿÿbÿðHÝ&`R ´--&+5ÿÿ–þ ¦&_g5ÿÿbþ Hð&`g²ÿÿ¤þ ¶&8gÿÿqþ ^H&XgËÿÿ¤ÿìß&8fmR ´&+5ÿÿqÿì^&Xfà ´&+5ÿÿ¤ÿìås&avR ´&&&+5ÿÿqÿì×!&bvT ´))&+5ÿÿ¤ÿìås&aC=R ´&+5ÿÿqÿì×!&bCŽ ´!!&+5ÿÿ¤ÿìåß&afsR ´!!&+5ÿÿqÿì×&bfË ´%%&+5ÿÿ¤ÿìå/&aRÝR ´&&&+5ÿÿqÿì×Ý&bR1 ´))&+5ÿÿ¤þ å&agÿÿqþ ×ð&bgËÿÿ¼þ Ã¶&<gLÿÿÿ;þH&\gyÿÿ¼Ãß&<fªR ´&+5ÿÿÿ;þ&\f/ ´&+5ÿÿ¼Ã/&<RR ´&+5ÿÿÿ;þÝ&\R— ´""&+5ÿÿþ¼/&ÓBÃüÙþ®! ³ /3Í210#&&'53#&&'53ýPm;„ º(j^o;„ »,gÙ;¹?†©;¹?‘žüçÙj@  /3Ì99//3103#&'#7667673#ýô®V/9a^xJ K—8.^+©+E`ö5•<9ml:@–/^>+u*üVÙÿ7@  /3Ì99//3103#&'#766&''3ýô®V/9a^xJ K—ÌCk‰8Aö5•<9ml:@–.=p]üçÙÝ"@  /3Ì299//3103#&'#76676654&#"5632ýô®V/9a^xJ K—QED.(*BVXTHö5•<9ml:@– ^ (#N<9AE'üéÙÿß#'@   !/3Ì9///333Ä10".#"#632326733#&'#76þø'JD?+5e:®*LD<&3 d@þW®W/9[b…ƒJ¹5%.5Û$';Û=3›:7qi?Ÿý ÙÿbÁ @ /2Ì9/Í210"&'33273673#þx“kWM”5p"¨’iI¬,¡ELÙŠvA6w}ƒ_n,z'ý Ùÿ`Á@  /3Ì9/Í210&'73"&'33273þ'rH‹1HVx“kWM”5p"¨Ým`bgþüŠvA6w}ƒý Ùÿ` @  /3Ì29/Í21076654&#"5632"&'33273ýôEF.(%#:W\VH+x“kWM”5p"¨Ë` '(P=Ýþ¦ŠvA6w}ƒÿTþH¾ ² /Ì2102654'3#"'7B9@)u"‚{A,$þ¸IEfT)p4qzk ÿãþyy‹ ² /Í210%#"'53267yBqbA(7%-4;‹þÉolŽ3>ÿãþyy‹ ² /Í210%#"'53267yBqbA(7%-4;‹þÉolŽ3>ÿÿˆÞ¶ÿYbÿì q @ KY &MY?+?+10#"&54632%"32654& ðŸ½Ï‹üžµÎþsh¨_zrg _qÃËþ¥±éÉÏK¹åW–þò£˜¨‰“J{\ ¶ ??9910!#667'3£| <W¸N¦‹?:ø9Gl)ÿÕ‹q@ KY&LY?+3?+10!!7>54&#"'6632!%ü°®•y5WUJ—jRzÈn›¦BþêÑa…9ltg=JW?RodL˜…T‚Àÿxþ“zr(-@KY && KY&& KY %?+?+9/+910#"'532654&##732654&#"'632zʳ|Ž|î¤Ò¯^ÒU¢´žƒ‹¥ÚtcPšbPÃå³Ä.œÙ §}…ËrO¤15ŸŠƒ‡®Œ\l6Bv®ÿÇþ¨ß\ !@MY $??39/33+310%##!733!667'ÃÑN¢Lýy/ËËÑþ‹H@_9þþs{ÆüDNxãi‹@ý·ÿÞþ“Ö]-@MYLY KY%?+?+9/+9102#"'532654&#"'!!6ä¶×’þú±Á‰¤ª¿Ö“ƒ0bZJÅœ!ýöW$Ѳ¡ôyO¤fÀ¬~“ 9¬™þIÿÿoÿìDËêÿÿþ§Ê]@ $LY?+?310!7!ý1{ýþ§!•‹úÕÿÿ<ÿì2ÍÜþ“Ðr(-@ !MY!!KY& KY%?+?+9/+910#"'532##"&546632%"32>54&Ðp·þü¬ˆj†pÊú@ 3£c©¸ç´Çþ–¶mlL€Y)v±ÂþWþÙŒ"ž/,KWž™ÿåWâ±|„9jzZƒ™ÿþ=:@(3$$FY-: ( GY7(FY?3+3?3+33?3+3310"'53267!#"'53267#?6632&#"!76632&#"3#!G6=6DVãþè'¢„E8@0FXãÁ Î.£ (t +L=W]â-¢¢)q$-L=Y\ïîç+¡þs|:û¶½®t{:CBdÈ¥allŦf|lû¶Ã¨RÝVÁ1%@,$  )$?3?3Ä2Í22109##33#7#%#"'53254&'&&54632&#"¶¼w²¹ÀªyÇþŽy~B^b4^iK~em^#PO5B7TsJå'nþGÑýÓ-ý/®yýÙÑfs!l(j,2%+\DYn%c#/+(3"0Yÿÿ•þ´¶&7z?ÿÿ/þÛD&WzÙ5þb\ +.@ FYFY!'FY!?+?+?+?9910%2654&#"%##"&54632373#"'532676Á]Ãyife°hú_´`ŒŸ‘÷—½X Cú-ðÒ¶Ž>´PŒŸ$w»#—ot©þ×£ãZylïÔhÂÀ¬ûtØÐFœ$2ˆŠ¦ÿÿ5þb!&‘K ´22&+5ÿÿ5þbå&‘N ´//&+5ÿÿ5þbß&‘O# ´44&+5ÿÿ5þb!&‘:{ ´00&+5V5¶ ³??1033V7¨þɶúJÿÿVQs&–CþÊR ´&+5ÿÿVBs&–vÿˆR ´ &+5ÿÿV(s&–Kÿ2R ´ &+5ÿÿV)%&–jÿ@R µ&+55ÿÿVv/&–RÿGR ´ &+5ÿÿV¸&–MÿIR ´&+5ÿÿVA7&–Nÿ&R ´&+5ÿÿÿµþH5¶&–QFÿÿVt1&–OfR ´ &+5ÿÿVþd¶&–-/ÿÿ`í '–¸Týñÿ—ÿÿV5¶–ÿÿV%&–jÿ6R µ&+55ÿÿV5¶–ÿÿV%&–jÿ6R µ&+55ÿÿV5¶–ÿÿV5¶–ÿÿV ß&–fôR ´ &+5ÿÿþ 5¶&–gf¶2I€6$$ÿq7)9):)<Dÿ®Fÿ…Gÿ…Hÿ…JÿÃPÿÃQÿÃRÿ…SÿÃTÿ…UÿÃVÿÃXÿÂÿqƒÿq„ÿq…ÿq†ÿq‡ÿqŸ¢ÿ…£ÿ®¤ÿ®¥ÿ®¦ÿ®§ÿ®¨ÿ®©ÿ…ªÿ…«ÿ…¬ÿ…­ÿ…´ÿ…µÿ…¶ÿ…·ÿ…¸ÿ…ºÿ…»ÿüÿýÿþÿÃÂÿqÃÿ®ÄÿqÅÿ®ÆÿqÇÿ®Éÿ…Ëÿ…Íÿ…Ïÿ…Ñÿ…Óÿ…Õÿ…×ÿ…Ùÿ…Ûÿ…Ýÿ…ßÿÃáÿÃãÿÃåÿÃúÿÃÿÃÿà ÿÃÿ…ÿ…ÿ…ÿ…ÿÃÿÃÿÃ!ÿÃ$)&)+ÿÃ-ÿÃ/ÿÃ1ÿÃ3ÿÃ5ÿÃ6)8:CÿqDÿ®Fÿ®Hÿ…JÿÃVÿq_ÿqbÿqiÿqyÿ®zÿ×{ÿ×~ÿ®ÿÂÿ׃ÿׄÿׇÿ׉ÿ׌ÿ®ŽÿÃÿ®ÿ®“ÿ®™ÿ®¤ÿ…ªÿq®ÿ…µÿ…Êÿ×ÎÿqÏÿ…ÕÿqØÿ…Ûÿ…Þÿ…êÿ…íÿ…îÿÃòÿqú)ü)þ)WÿÃXÿqYÿ®`ÿ…bÿÃjÿ…rÿqsÿq}ÿìÿ……ÿ…‡ÿ…‰ÿ…ÿ…²ÿ…´ÿ…Îÿ…ÏÿqÙÿqÚÿ×ÛÿqÜÿ×ÝÿqÞÿ×àÿ…âÿ×äÿ×ðÿ…òÿ…ôÿ… ÿq ÿ… ÿq ÿ…ÿ…ÿqÿ…ÿ…ÿ…ÿqÿqÿ®ÿq ÿ®!ÿq"ÿ®#ÿq%ÿq&ÿ®'ÿq(ÿ®)ÿq*ÿ®+ÿq,ÿ®-ÿq.ÿ®/ÿq0ÿ®1ÿq2ÿ®3ÿq4ÿ®6ÿ…8ÿ…:ÿ…<ÿ…@ÿ…Bÿ…Dÿ…Jÿ…Lÿ…Nÿ…Rÿ…Tÿ…Vÿ…Xÿ…Zÿ…\ÿ…^ÿ…`ÿ…bÿÃdÿÃfÿÃhÿÃjÿÃlÿÃnÿÃoqs) $ÿq 7) 9) :) < Dÿ® Fÿ… Gÿ… Hÿ… Jÿà Pÿà Qÿà Rÿ… Sÿà Tÿ… Uÿà Vÿà Xÿà ‚ÿq ƒÿq „ÿq …ÿq †ÿq ‡ÿq Ÿ ¢ÿ… £ÿ® ¤ÿ® ¥ÿ® ¦ÿ® §ÿ® ¨ÿ® ©ÿ… ªÿ… «ÿ… ¬ÿ… ­ÿ… ´ÿ… µÿ… ¶ÿ… ·ÿ… ¸ÿ… ºÿ… »ÿà ¼ÿà ½ÿà ¾ÿà Âÿq Ãÿ® Äÿq Åÿ® Æÿq Çÿ® Éÿ… Ëÿ… Íÿ… Ïÿ… Ñÿ… Óÿ… Õÿ… ×ÿ… Ùÿ… Ûÿ… Ýÿ… ßÿà áÿà ãÿà åÿà úÿà ÿà ÿà  ÿà ÿ… ÿ… ÿ… ÿ… ÿà ÿà ÿà !ÿà $) &) +ÿà -ÿà /ÿà 1ÿà 3ÿà 5ÿà 6) 8 : Cÿq Dÿ® Fÿ® Hÿ… Jÿà Vÿq _ÿq bÿq iÿq yÿ® zÿ× {ÿ× ~ÿ® ÿà ‚ÿ× ƒÿ× „ÿ× ‡ÿ× ‰ÿ× Œÿ® Žÿà ÿ® ÿ® “ÿ® ™ÿ® ¤ÿ… ªÿq ®ÿ… µÿ… Êÿ× Îÿq Ïÿ… Õÿq Øÿ… Ûÿ… Þÿ… êÿ… íÿ… îÿà òÿq ú) ü) þ)  Wÿà Xÿq Yÿ® `ÿ… bÿà jÿ… rÿq sÿq }ÿì ÿ… …ÿ… ‡ÿ… ‰ÿ… ÿ… ²ÿ… ´ÿ… Îÿ… Ïÿq Ùÿq Úÿ× Ûÿq Üÿ× Ýÿq Þÿ× àÿ… âÿ× äÿ× ðÿ… òÿ… ôÿ…  ÿq  ÿ…  ÿq  ÿ… ÿ… ÿq ÿ… ÿ… ÿ… ÿq ÿq ÿ® ÿq  ÿ® !ÿq "ÿ® #ÿq %ÿq &ÿ® 'ÿq (ÿ® )ÿq *ÿ® +ÿq ,ÿ® -ÿq .ÿ® /ÿq 0ÿ® 1ÿq 2ÿ® 3ÿq 4ÿ® 6ÿ… 8ÿ… :ÿ… <ÿ… @ÿ… Bÿ… Dÿ… Jÿ… Lÿ… Nÿ… Rÿ… Tÿ… Vÿ… Xÿ… Zÿ… \ÿ… ^ÿ… `ÿ… bÿà dÿà fÿà hÿà jÿà lÿà nÿà o q s ) -¸&ÿš*ÿš2ÿš4ÿš7ÿq8ÿ×9ÿ…:ÿ…<ÿ…‰ÿš”ÿš•ÿš–ÿš—ÿš˜ÿššÿš›ÿלÿ×ÿמÿןÿ…ÈÿšÊÿšÌÿšÎÿšÞÿšàÿšâÿšäÿšÿšÿšÿšÿš$ÿq&ÿq*ÿ×,ÿ×.ÿ×0ÿ×2ÿ×4ÿ×6ÿ…8ÿ…:ÿ…Gÿšfÿ®mÿ®qÿqrÿ…sÿšuÿ…xÿ……ÿ×ÿqŸÿš¦ÿq¸ÿš»ÿš¼ÿq¾ÿ®Áÿ\ÄÿqÜÿšáÿ…äÿšúÿ…üÿ…þÿ…ÿ…Tÿ…_ÿšaÿ×lÿš|ÿ\~ÿš€ÿ…‚ÿ…„ÿš†ÿšˆÿšŠÿšŒÿš©ÿqªÿš±ÿš³ÿšµÿq¶ÿš·ÿ…¹ÿ…½ÿq¾ÿš¿ÿ\Àÿ…Áÿ\Âÿ…Åÿ…Çÿ…Ôÿ\Õÿ…ïÿšñÿšóÿšýÿ\þÿ… ÿ…ÿšÿ…ÿšÿšÿqÿšIÿšKÿšMÿšOÿšQÿšSÿšUÿšWÿšYÿš[ÿš]ÿš_ÿšaÿ×cÿ×eÿ×gÿ×iÿ×kÿ×mÿ×oÿ…qÿ…sÿ…ÿq7ÿ®$ÿ®&ÿ®qÿ®ÿ®¦ÿ®¼ÿ®Äÿ®Üÿ×äÿשÿ®ªÿ×µÿ®¶ÿ×½ÿ®¾ÿ×ÿ®ÿ×ÿ®&ÿš*ÿš2ÿš4ÿš7ÿq8ÿ×9ÿ…:ÿ…<ÿ…‰ÿš”ÿš•ÿš–ÿš—ÿš˜ÿššÿš›ÿלÿ×ÿמÿןÿ…ÈÿšÊÿšÌÿšÎÿšÞÿšàÿšâÿšäÿšÿšÿšÿšÿš$ÿq&ÿq*ÿ×,ÿ×.ÿ×0ÿ×2ÿ×4ÿ×6ÿ…8ÿ…:ÿ…Gÿšfÿ®mÿ®qÿqrÿ…sÿšuÿ…xÿ……ÿ×ÿqŸÿš¦ÿq¸ÿš»ÿš¼ÿq¾ÿ®Áÿ\ÄÿqÜÿšáÿ…äÿšúÿ…üÿ…þÿ…ÿ…Tÿ…_ÿšaÿ×lÿš|ÿ\~ÿš€ÿ…‚ÿ…„ÿš†ÿšˆÿšŠÿšŒÿš©ÿqªÿš±ÿš³ÿšµÿq¶ÿš·ÿ…¹ÿ…½ÿq¾ÿš¿ÿ\Àÿ…Áÿ\Âÿ…Åÿ…Çÿ…Ôÿ\Õÿ…ïÿšñÿšóÿšýÿ\þÿ… ÿ…ÿšÿ…ÿšÿšÿqÿšIÿšKÿšMÿšOÿšQÿšSÿšUÿšWÿšYÿš[ÿš]ÿš_ÿšaÿ×cÿ×eÿ×gÿ×iÿ×kÿ×mÿ×oÿ…qÿ…sÿ…ÿq$ÿq$ ÿq$&ÿ×$*ÿ×$- $2ÿ×$4ÿ×$7ÿq$9ÿ®$:ÿ®$<ÿ…$‰ÿ×$”ÿ×$•ÿ×$–ÿ×$—ÿ×$˜ÿ×$šÿ×$Ÿÿ…$Èÿ×$Êÿ×$Ìÿ×$Îÿ×$Þÿ×$àÿ×$âÿ×$äÿ×$ÿ×$ÿ×$ÿ×$ÿ×$$ÿq$&ÿq$6ÿ®$8ÿ…$:ÿ…$Gÿ×$úÿ®$üÿ®$þÿ®$ÿ…$ÿq$ ÿq$_ÿ×$Iÿ×$Kÿ×$Mÿ×$Oÿ×$Qÿ×$Sÿ×$Uÿ×$Wÿ×$Yÿ×$[ÿ×$]ÿ×$_ÿ×$oÿ…$qÿ…$sÿ…$ÿq%ÿ®%ÿ®%$ÿ×%7ÿÃ%9ÿì%:ÿì%;ÿ×%<ÿì%=ÿì%‚ÿ×%ƒÿ×%„ÿ×%…ÿ×%†ÿ×%‡ÿ×%Ÿÿì%Âÿ×%Äÿ×%Æÿ×%$ÿÃ%&ÿÃ%6ÿì%8ÿì%:ÿì%;ÿì%=ÿì%?ÿì%Cÿ×% ÿì%úÿì%üÿì%þÿì%ÿì%ÿ®% ÿ®%Xÿ×%ÿ×%ÿ×%!ÿ×%#ÿ×%%ÿ×%'ÿ×%)ÿ×%+ÿ×%-ÿ×%/ÿ×%1ÿ×%3ÿ×%oÿì%qÿì%sÿì%ÿÃ&&ÿ×&*ÿ×&2ÿ×&4ÿ×&‰ÿ×&”ÿ×&•ÿ×&–ÿ×&—ÿ×&˜ÿ×&šÿ×&Èÿ×&Êÿ×&Ìÿ×&Îÿ×&Þÿ×&àÿ×&âÿ×&äÿ×&ÿ×&ÿ×&ÿ×&ÿ×&Gÿ×&_ÿ×&Iÿ×&Kÿ×&Mÿ×&Oÿ×&Qÿ×&Sÿ×&Uÿ×&Wÿ×&Yÿ×&[ÿ×&]ÿ×&_ÿ×'ÿ®'ÿ®'$ÿ×'7ÿÃ'9ÿì':ÿì';ÿ×'<ÿì'=ÿì'‚ÿ×'ƒÿ×'„ÿ×'…ÿ×'†ÿ×'‡ÿ×'Ÿÿì'Âÿ×'Äÿ×'Æÿ×'$ÿÃ'&ÿÃ'6ÿì'8ÿì':ÿì';ÿì'=ÿì'?ÿì'Cÿ×' ÿì'úÿì'üÿì'þÿì'ÿì'ÿ®' ÿ®'Xÿ×'ÿ×'ÿ×'!ÿ×'#ÿ×'%ÿ×''ÿ×')ÿ×'+ÿ×'-ÿ×'/ÿ×'1ÿ×'3ÿ×'oÿì'qÿì'sÿì'ÿÃ(-{)ÿ…)ÿ…)"))$ÿ×)‚ÿ×)ƒÿ×)„ÿ×)…ÿ×)†ÿ×)‡ÿ×)Âÿ×)Äÿ×)Æÿ×)Cÿ×)ÿ…) ÿ…)Xÿ×)ÿ×)ÿ×)!ÿ×)#ÿ×)%ÿ×)'ÿ×))ÿ×)+ÿ×)-ÿ×)/ÿ×)1ÿ×)3ÿ×.&ÿ×.*ÿ×.2ÿ×.4ÿ×.‰ÿ×.”ÿ×.•ÿ×.–ÿ×.—ÿ×.˜ÿ×.šÿ×.Èÿ×.Êÿ×.Ìÿ×.Îÿ×.Þÿ×.àÿ×.âÿ×.äÿ×.ÿ×.ÿ×.ÿ×.ÿ×.Gÿ×._ÿ×.Iÿ×.Kÿ×.Mÿ×.Oÿ×.Qÿ×.Sÿ×.Uÿ×.Wÿ×.Yÿ×.[ÿ×.]ÿ×._ÿ×/ÿ\/ ÿ\/&ÿ×/*ÿ×/2ÿ×/4ÿ×/7ÿ×/8ÿì/9ÿ×/:ÿ×/<ÿÃ/‰ÿ×/”ÿ×/•ÿ×/–ÿ×/—ÿ×/˜ÿ×/šÿ×/›ÿì/œÿì/ÿì/žÿì/ŸÿÃ/Èÿ×/Êÿ×/Ìÿ×/Îÿ×/Þÿ×/àÿ×/âÿ×/äÿ×/ÿ×/ÿ×/ÿ×/ÿ×/$ÿ×/&ÿ×/*ÿì/,ÿì/.ÿì/0ÿì/2ÿì/4ÿì/6ÿ×/8ÿÃ/:ÿÃ/Gÿ×/úÿ×/üÿ×/þÿ×/ÿÃ/ÿ\/ ÿ\/_ÿ×/aÿì/Iÿ×/Kÿ×/Mÿ×/Oÿ×/Qÿ×/Sÿ×/Uÿ×/Wÿ×/Yÿ×/[ÿ×/]ÿ×/_ÿ×/aÿì/cÿì/eÿì/gÿì/iÿì/kÿì/mÿì/oÿÃ/qÿÃ/sÿÃ/ÿ×2ÿ®2ÿ®2$ÿ×27ÿÃ29ÿì2:ÿì2;ÿ×2<ÿì2=ÿì2‚ÿ×2ƒÿ×2„ÿ×2…ÿ×2†ÿ×2‡ÿ×2Ÿÿì2Âÿ×2Äÿ×2Æÿ×2$ÿÃ2&ÿÃ26ÿì28ÿì2:ÿì2;ÿì2=ÿì2?ÿì2Cÿ×2 ÿì2úÿì2üÿì2þÿì2ÿì2ÿ®2 ÿ®2Xÿ×2ÿ×2ÿ×2!ÿ×2#ÿ×2%ÿ×2'ÿ×2)ÿ×2+ÿ×2-ÿ×2/ÿ×21ÿ×23ÿ×2oÿì2qÿì2sÿì2ÿÃ3þö3þö3$ÿš3;ÿ×3=ÿì3‚ÿš3ƒÿš3„ÿš3…ÿš3†ÿš3‡ÿš3Âÿš3Äÿš3Æÿš3;ÿì3=ÿì3?ÿì3Cÿš3þö3 þö3Xÿš3ÿš3ÿš3!ÿš3#ÿš3%ÿš3'ÿš3)ÿš3+ÿš3-ÿš3/ÿš31ÿš33ÿš4ÿ®4ÿ®4$ÿ×47ÿÃ49ÿì4:ÿì4;ÿ×4<ÿì4=ÿì4‚ÿ×4ƒÿ×4„ÿ×4…ÿ×4†ÿ×4‡ÿ×4Ÿÿì4Âÿ×4Äÿ×4Æÿ×4$ÿÃ4&ÿÃ46ÿì48ÿì4:ÿì4;ÿì4=ÿì4?ÿì4Cÿ×4 ÿì4úÿì4üÿì4þÿì4ÿì4ÿ®4 ÿ®4Xÿ×4ÿ×4ÿ×4!ÿ×4#ÿ×4%ÿ×4'ÿ×4)ÿ×4+ÿ×4-ÿ×4/ÿ×41ÿ×43ÿ×4oÿì4qÿì4sÿì4ÿÃ7ÿ…7ÿ®7ÿ…7")7$ÿq7&ÿ×7*ÿ×72ÿ×74ÿ×77)7Dÿ\7Fÿq7Gÿq7Hÿq7Jÿq7Pÿš7Qÿš7Rÿq7Sÿš7Tÿq7Uÿš7Vÿ…7Xÿš7Yÿ×7Zÿ×7[ÿ×7\ÿ×7]ÿ®7‚ÿq7ƒÿq7„ÿq7…ÿq7†ÿq7‡ÿq7‰ÿ×7”ÿ×7•ÿ×7–ÿ×7—ÿ×7˜ÿ×7šÿ×7¢ÿq7£ÿ\7¤ÿ\7¥ÿ\7¦ÿ\7§ÿ\7¨ÿ\7©ÿq7ªÿq7«ÿq7¬ÿq7­ÿq7´ÿq7µÿq7¶ÿq7·ÿq7¸ÿq7ºÿq7»ÿš7¼ÿš7½ÿš7¾ÿš7¿ÿ×7Âÿq7Ãÿ\7Äÿq7Åÿ\7Æÿq7Çÿ\7Èÿ×7Éÿq7Êÿ×7Ëÿq7Ìÿ×7Íÿq7Îÿ×7Ïÿq7Ñÿq7Óÿq7Õÿq7×ÿq7Ùÿq7Ûÿq7Ýÿq7Þÿ×7ßÿq7àÿ×7áÿq7âÿ×7ãÿq7äÿ×7åÿq7úÿš7ÿš7ÿš7 ÿš7ÿ×7ÿq7ÿ×7ÿq7ÿ×7ÿq7ÿ×7ÿq7ÿš7ÿš7ÿ…7!ÿ…7$)7&)7+ÿš7-ÿš7/ÿš71ÿš73ÿš75ÿš77ÿ×7<ÿ®7>ÿ®7@ÿ®7Cÿq7Dÿ\7Fÿ\7Gÿ×7Hÿq7Jÿ…7ûÿ×7ýÿ×7ÿ®7ÿ®7ÿ®7ÿ…7 ÿ…7Wÿš7Xÿq7Yÿ\7_ÿ×7`ÿq7bÿš7ÿq7ÿ\7ÿq7 ÿ\7!ÿq7"ÿ\7#ÿq7%ÿq7&ÿ\7'ÿq7(ÿ\7)ÿq7*ÿ\7+ÿq7,ÿ\7-ÿq7.ÿ\7/ÿq70ÿ\71ÿq72ÿ\73ÿq74ÿ\76ÿq78ÿq7:ÿq7<ÿq7@ÿq7Bÿq7Dÿq7Iÿ×7Jÿq7Kÿ×7Lÿq7Mÿ×7Nÿq7Oÿ×7Qÿ×7Rÿq7Sÿ×7Tÿq7Uÿ×7Vÿq7Wÿ×7Xÿq7Yÿ×7Zÿq7[ÿ×7\ÿq7]ÿ×7^ÿq7_ÿ×7`ÿq7bÿš7dÿš7fÿš7hÿš7jÿš7lÿš7nÿš7pÿ×7)8ÿ×8ÿ×8$ÿì8‚ÿì8ƒÿì8„ÿì8…ÿì8†ÿì8‡ÿì8Âÿì8Äÿì8Æÿì8Cÿì8ÿ×8 ÿ×8Xÿì8ÿì8ÿì8!ÿì8#ÿì8%ÿì8'ÿì8)ÿì8+ÿì8-ÿì8/ÿì81ÿì83ÿì9ÿš9ÿš9")9$ÿ®9&ÿì9*ÿì92ÿì94ÿì9Dÿ×9Fÿ×9Gÿ×9Hÿ×9Jÿì9Pÿì9Qÿì9Rÿ×9Sÿì9Tÿ×9Uÿì9Vÿì9Xÿì9‚ÿ®9ƒÿ®9„ÿ®9…ÿ®9†ÿ®9‡ÿ®9‰ÿì9”ÿì9•ÿì9–ÿì9—ÿì9˜ÿì9šÿì9¢ÿ×9£ÿ×9¤ÿ×9¥ÿ×9¦ÿ×9§ÿ×9¨ÿ×9©ÿ×9ªÿ×9«ÿ×9¬ÿ×9­ÿ×9´ÿ×9µÿ×9¶ÿ×9·ÿ×9¸ÿ×9ºÿ×9»ÿì9¼ÿì9½ÿì9¾ÿì9Âÿ®9Ãÿ×9Äÿ®9Åÿ×9Æÿ®9Çÿ×9Èÿì9Éÿ×9Êÿì9Ëÿ×9Ìÿì9Íÿ×9Îÿì9Ïÿ×9Ñÿ×9Óÿ×9Õÿ×9×ÿ×9Ùÿ×9Ûÿ×9Ýÿ×9Þÿì9ßÿì9àÿì9áÿì9âÿì9ãÿì9äÿì9åÿì9úÿì9ÿì9ÿì9 ÿì9ÿì9ÿ×9ÿì9ÿ×9ÿì9ÿ×9ÿì9ÿ×9ÿì9ÿì9ÿì9!ÿì9+ÿì9-ÿì9/ÿì91ÿì93ÿì95ÿì9Cÿ®9Dÿ×9Fÿ×9Gÿì9Hÿ×9Jÿì9ÿš9 ÿš9Wÿì9Xÿ®9Yÿ×9_ÿì9`ÿ×9bÿì9ÿ®9ÿ×9ÿ®9 ÿ×9!ÿ®9"ÿ×9#ÿ®9%ÿ®9&ÿ×9'ÿ®9(ÿ×9)ÿ®9*ÿ×9+ÿ®9,ÿ×9-ÿ®9.ÿ×9/ÿ®90ÿ×91ÿ®92ÿ×93ÿ®94ÿ×96ÿ×98ÿ×9:ÿ×9<ÿ×9@ÿ×9Bÿ×9Dÿ×9Iÿì9Jÿ×9Kÿì9Lÿ×9Mÿì9Nÿ×9Oÿì9Qÿì9Rÿ×9Sÿì9Tÿ×9Uÿì9Vÿ×9Wÿì9Xÿ×9Yÿì9Zÿ×9[ÿì9\ÿ×9]ÿì9^ÿ×9_ÿì9`ÿ×9bÿì9dÿì9fÿì9hÿì9jÿì9lÿì9nÿì:ÿš:ÿš:"):$ÿ®:&ÿì:*ÿì:2ÿì:4ÿì:Dÿ×:Fÿ×:Gÿ×:Hÿ×:Jÿì:Pÿì:Qÿì:Rÿ×:Sÿì:Tÿ×:Uÿì:Vÿì:Xÿì:‚ÿ®:ƒÿ®:„ÿ®:…ÿ®:†ÿ®:‡ÿ®:‰ÿì:”ÿì:•ÿì:–ÿì:—ÿì:˜ÿì:šÿì:¢ÿ×:£ÿ×:¤ÿ×:¥ÿ×:¦ÿ×:§ÿ×:¨ÿ×:©ÿ×:ªÿ×:«ÿ×:¬ÿ×:­ÿ×:´ÿ×:µÿ×:¶ÿ×:·ÿ×:¸ÿ×:ºÿ×:»ÿì:¼ÿì:½ÿì:¾ÿì:Âÿ®:Ãÿ×:Äÿ®:Åÿ×:Æÿ®:Çÿ×:Èÿì:Éÿ×:Êÿì:Ëÿ×:Ìÿì:Íÿ×:Îÿì:Ïÿ×:Ñÿ×:Óÿ×:Õÿ×:×ÿ×:Ùÿ×:Ûÿ×:Ýÿ×:Þÿì:ßÿì:àÿì:áÿì:âÿì:ãÿì:äÿì:åÿì:úÿì:ÿì:ÿì: ÿì:ÿì:ÿ×:ÿì:ÿ×:ÿì:ÿ×:ÿì:ÿ×:ÿì:ÿì:ÿì:!ÿì:+ÿì:-ÿì:/ÿì:1ÿì:3ÿì:5ÿì:Cÿ®:Dÿ×:Fÿ×:Gÿì:Hÿ×:Jÿì:ÿš: ÿš:Wÿì:Xÿ®:Yÿ×:_ÿì:`ÿ×:bÿì:ÿ®:ÿ×:ÿ®: ÿ×:!ÿ®:"ÿ×:#ÿ®:%ÿ®:&ÿ×:'ÿ®:(ÿ×:)ÿ®:*ÿ×:+ÿ®:,ÿ×:-ÿ®:.ÿ×:/ÿ®:0ÿ×:1ÿ®:2ÿ×:3ÿ®:4ÿ×:6ÿ×:8ÿ×::ÿ×:<ÿ×:@ÿ×:Bÿ×:Dÿ×:Iÿì:Jÿ×:Kÿì:Lÿ×:Mÿì:Nÿ×:Oÿì:Qÿì:Rÿ×:Sÿì:Tÿ×:Uÿì:Vÿ×:Wÿì:Xÿ×:Yÿì:Zÿ×:[ÿì:\ÿ×:]ÿì:^ÿ×:_ÿì:`ÿ×:bÿì:dÿì:fÿì:hÿì:jÿì:lÿì:nÿì;&ÿ×;*ÿ×;2ÿ×;4ÿ×;‰ÿ×;”ÿ×;•ÿ×;–ÿ×;—ÿ×;˜ÿ×;šÿ×;Èÿ×;Êÿ×;Ìÿ×;Îÿ×;Þÿ×;àÿ×;âÿ×;äÿ×;ÿ×;ÿ×;ÿ×;ÿ×;Gÿ×;_ÿ×;Iÿ×;Kÿ×;Mÿ×;Oÿ×;Qÿ×;Sÿ×;Uÿ×;Wÿ×;Yÿ×;[ÿ×;]ÿ×;_ÿ×<ÿ…<ÿ…<")<$ÿ…<&ÿ×<*ÿ×<2ÿ×<4ÿ×<Dÿš<Fÿš<Gÿš<Hÿš<Jÿ×<PÿÃ<QÿÃ<Rÿš<SÿÃ<Tÿš<UÿÃ<Vÿ®<XÿÃ<]ÿ×<‚ÿ…<ƒÿ…<„ÿ…<…ÿ…<†ÿ…<‡ÿ…<‰ÿ×<”ÿ×<•ÿ×<–ÿ×<—ÿ×<˜ÿ×<šÿ×<¢ÿš<£ÿš<¤ÿš<¥ÿš<¦ÿš<§ÿš<¨ÿš<©ÿš<ªÿš<«ÿš<¬ÿš<­ÿš<´ÿš<µÿš<¶ÿš<·ÿš<¸ÿš<ºÿš<»ÿÃ<¼ÿÃ<½ÿÃ<¾ÿÃ<Âÿ…<Ãÿš<Äÿ…<Åÿš<Æÿ…<Çÿš<Èÿ×<Éÿš<Êÿ×<Ëÿš<Ìÿ×<Íÿš<Îÿ×<Ïÿš<Ñÿš<Óÿš<Õÿš<×ÿš<Ùÿš<Ûÿš<Ýÿš<Þÿ×<ßÿ×<àÿ×<áÿ×<âÿ×<ãÿ×<äÿ×<åÿ×<úÿÃ<ÿÃ<ÿÃ< ÿÃ<ÿ×<ÿš<ÿ×<ÿš<ÿ×<ÿš<ÿ×<ÿš<ÿÃ<ÿÃ<ÿ®<!ÿ®<+ÿÃ<-ÿÃ</ÿÃ<1ÿÃ<3ÿÃ<5ÿÃ<<ÿ×<>ÿ×<@ÿ×<Cÿ…<Dÿš<Fÿš<Gÿ×<Hÿš<Jÿ®<ÿ…< ÿ…<WÿÃ<Xÿ…<Yÿš<_ÿ×<`ÿš<bÿÃ<ÿ…<ÿš<ÿ…< ÿš<!ÿ…<"ÿš<#ÿ…<%ÿ…<&ÿš<'ÿ…<(ÿš<)ÿ…<*ÿš<+ÿ…<,ÿš<-ÿ…<.ÿš</ÿ…<0ÿš<1ÿ…<2ÿš<3ÿ…<4ÿš<6ÿš<8ÿš<:ÿš<<ÿš<@ÿš<Bÿš<Dÿš<Iÿ×<Jÿš<Kÿ×<Lÿš<Mÿ×<Nÿš<Oÿ×<Qÿ×<Rÿš<Sÿ×<Tÿš<Uÿ×<Vÿš<Wÿ×<Xÿš<Yÿ×<Zÿš<[ÿ×<\ÿš<]ÿ×<^ÿš<_ÿ×<`ÿš<bÿÃ<dÿÃ<fÿÃ<hÿÃ<jÿÃ<lÿÃ<nÿÃ=&ÿì=*ÿì=2ÿì=4ÿì=‰ÿì=”ÿì=•ÿì=–ÿì=—ÿì=˜ÿì=šÿì=Èÿì=Êÿì=Ìÿì=Îÿì=Þÿì=àÿì=âÿì=äÿì=ÿì=ÿì=ÿì=ÿì=Gÿì=_ÿì=Iÿì=Kÿì=Mÿì=Oÿì=Qÿì=Sÿì=Uÿì=Wÿì=Yÿì=[ÿì=]ÿì=_ÿì>-¸DÿìD ÿìDÿìD ÿìEÿìE ÿìEYÿ×EZÿ×E[ÿ×E\ÿ×E]ÿìE¿ÿ×E7ÿ×E<ÿìE>ÿìE@ÿìEûÿ×Eýÿ×EÿìE ÿìEpÿ×F)F )F)F )HÿìH ÿìHYÿ×HZÿ×H[ÿ×H\ÿ×H]ÿìH¿ÿ×H7ÿ×H<ÿìH>ÿìH@ÿìHûÿ×Hýÿ×HÿìH ÿìHpÿ×I{I {I{I {KÿìK ÿìKÿìK ÿìNFÿ×NGÿ×NHÿ×NRÿ×NTÿ×N¢ÿ×N©ÿ×Nªÿ×N«ÿ×N¬ÿ×N­ÿ×N´ÿ×Nµÿ×N¶ÿ×N·ÿ×N¸ÿ×Nºÿ×NÉÿ×NËÿ×NÍÿ×NÏÿ×NÑÿ×NÓÿ×NÕÿ×N×ÿ×NÙÿ×NÛÿ×NÝÿ×Nÿ×Nÿ×Nÿ×Nÿ×NHÿ×N`ÿ×N6ÿ×N8ÿ×N:ÿ×N<ÿ×N@ÿ×NBÿ×NDÿ×NJÿ×NLÿ×NNÿ×NRÿ×NTÿ×NVÿ×NXÿ×NZÿ×N\ÿ×N^ÿ×N`ÿ×PÿìP ÿìPÿìP ÿìQÿìQ ÿìQÿìQ ÿìRÿìR ÿìRYÿ×RZÿ×R[ÿ×R\ÿ×R]ÿìR¿ÿ×R7ÿ×R<ÿìR>ÿìR@ÿìRûÿ×Rýÿ×RÿìR ÿìRpÿ×SÿìS ÿìSYÿ×SZÿ×S[ÿ×S\ÿ×S]ÿìS¿ÿ×S7ÿ×S<ÿìS>ÿìS@ÿìSûÿ×Sýÿ×SÿìS ÿìSpÿ×URU RUDÿ×UFÿ×UGÿ×UHÿ×UJÿìURÿ×UTÿ×U¢ÿ×U£ÿ×U¤ÿ×U¥ÿ×U¦ÿ×U§ÿ×U¨ÿ×U©ÿ×Uªÿ×U«ÿ×U¬ÿ×U­ÿ×U´ÿ×Uµÿ×U¶ÿ×U·ÿ×U¸ÿ×Uºÿ×UÃÿ×UÅÿ×UÇÿ×UÉÿ×UËÿ×UÍÿ×UÏÿ×UÑÿ×UÓÿ×UÕÿ×U×ÿ×UÙÿ×UÛÿ×UÝÿ×UßÿìUáÿìUãÿìUåÿìUÿ×Uÿ×Uÿ×Uÿ×UDÿ×UFÿ×UHÿ×URU RUYÿ×U`ÿ×Uÿ×U ÿ×U"ÿ×U&ÿ×U(ÿ×U*ÿ×U,ÿ×U.ÿ×U0ÿ×U2ÿ×U4ÿ×U6ÿ×U8ÿ×U:ÿ×U<ÿ×U@ÿ×UBÿ×UDÿ×UJÿ×ULÿ×UNÿ×URÿ×UTÿ×UVÿ×UXÿ×UZÿ×U\ÿ×U^ÿ×U`ÿ×W)W )W)W )YRY RYÿ®Yÿ®Y")YRYÿ®Y RY ÿ®ZRZ RZÿ®Zÿ®Z")ZRZÿ®Z RZ ÿ®[Fÿ×[Gÿ×[Hÿ×[Rÿ×[Tÿ×[¢ÿ×[©ÿ×[ªÿ×[«ÿ×[¬ÿ×[­ÿ×[´ÿ×[µÿ×[¶ÿ×[·ÿ×[¸ÿ×[ºÿ×[Éÿ×[Ëÿ×[Íÿ×[Ïÿ×[Ñÿ×[Óÿ×[Õÿ×[×ÿ×[Ùÿ×[Ûÿ×[Ýÿ×[ÿ×[ÿ×[ÿ×[ÿ×[Hÿ×[`ÿ×[6ÿ×[8ÿ×[:ÿ×[<ÿ×[@ÿ×[Bÿ×[Dÿ×[Jÿ×[Lÿ×[Nÿ×[Rÿ×[Tÿ×[Vÿ×[Xÿ×[Zÿ×[\ÿ×[^ÿ×[`ÿ×\R\ R\ÿ®\ÿ®\")\R\ÿ®\ R\ ÿ®^-¸‚ÿq‚ ÿq‚&ÿׂ*ÿׂ- ‚2ÿׂ4ÿׂ7ÿq‚9ÿ®‚:ÿ®‚<ÿ…‚‰ÿׂ”ÿׂ•ÿׂ–ÿׂ—ÿׂ˜ÿׂšÿׂŸÿ…‚ÈÿׂÊÿׂÌÿׂÎÿׂÞÿׂàÿׂâÿׂäÿׂÿׂÿׂÿׂÿׂ$ÿq‚&ÿq‚6ÿ®‚8ÿ…‚:ÿ…‚Gÿׂúÿ®‚üÿ®‚þÿ®‚ÿ…‚ÿq‚ ÿq‚_ÿׂIÿׂKÿׂMÿׂOÿׂQÿׂSÿׂUÿׂWÿׂYÿׂ[ÿׂ]ÿׂ_ÿׂoÿ…‚qÿ…‚sÿ…‚ÿqƒÿqƒ ÿqƒ&ÿ׃*ÿ׃- ƒ2ÿ׃4ÿ׃7ÿqƒ9ÿ®ƒ:ÿ®ƒ<ÿ…ƒ‰ÿ׃”ÿ׃•ÿ׃–ÿ׃—ÿ׃˜ÿ׃šÿ׃Ÿÿ…ƒÈÿ׃Êÿ׃Ìÿ׃Îÿ׃Þÿ׃àÿ׃âÿ׃äÿ׃ÿ׃ÿ׃ÿ׃ÿ׃$ÿqƒ&ÿqƒ6ÿ®ƒ8ÿ…ƒ:ÿ…ƒGÿ׃úÿ®ƒüÿ®ƒþÿ®ƒÿ…ƒÿqƒ ÿqƒ_ÿ׃Iÿ׃Kÿ׃Mÿ׃Oÿ׃Qÿ׃Sÿ׃Uÿ׃Wÿ׃Yÿ׃[ÿ׃]ÿ׃_ÿ׃oÿ…ƒqÿ…ƒsÿ…ƒÿq„ÿq„ ÿq„&ÿׄ*ÿׄ- „2ÿׄ4ÿׄ7ÿq„9ÿ®„:ÿ®„<ÿ…„‰ÿׄ”ÿׄ•ÿׄ–ÿׄ—ÿׄ˜ÿׄšÿׄŸÿ…„ÈÿׄÊÿׄÌÿׄÎÿׄÞÿׄàÿׄâÿׄäÿׄÿׄÿׄÿׄÿׄ$ÿq„&ÿq„6ÿ®„8ÿ…„:ÿ…„Gÿׄúÿ®„üÿ®„þÿ®„ÿ…„ÿq„ ÿq„_ÿׄIÿׄKÿׄMÿׄOÿׄQÿׄSÿׄUÿׄWÿׄYÿׄ[ÿׄ]ÿׄ_ÿׄoÿ…„qÿ…„sÿ…„ÿq…ÿq… ÿq…&ÿ×…*ÿ×…- …2ÿ×…4ÿ×…7ÿq…9ÿ®…:ÿ®…<ÿ……‰ÿ×…”ÿ×…•ÿ×…–ÿ×…—ÿ×…˜ÿ×…šÿ×…Ÿÿ……Èÿ×…Êÿ×…Ìÿ×…Îÿ×…Þÿ×…àÿ×…âÿ×…äÿ×…ÿ×…ÿ×…ÿ×…ÿ×…$ÿq…&ÿq…6ÿ®…8ÿ……:ÿ……Gÿ×…úÿ®…üÿ®…þÿ®…ÿ……ÿq… ÿq…_ÿ×…Iÿ×…Kÿ×…Mÿ×…Oÿ×…Qÿ×…Sÿ×…Uÿ×…Wÿ×…Yÿ×…[ÿ×…]ÿ×…_ÿ×…oÿ……qÿ……sÿ……ÿq†ÿq† ÿq†&ÿ׆*ÿ׆- †2ÿ׆4ÿ׆7ÿq†9ÿ®†:ÿ®†<ÿ…†‰ÿ׆”ÿ׆•ÿ׆–ÿ׆—ÿ׆˜ÿ׆šÿ׆Ÿÿ…†Èÿ׆Êÿ׆Ìÿ׆Îÿ׆Þÿ׆àÿ׆âÿ׆äÿ׆ÿ׆ÿ׆ÿ׆ÿ׆$ÿq†&ÿq†6ÿ®†8ÿ…†:ÿ…†Gÿ׆úÿ®†üÿ®†þÿ®†ÿ…†ÿq† ÿq†_ÿ׆Iÿ׆Kÿ׆Mÿ׆Oÿ׆Qÿ׆Sÿ׆Uÿ׆Wÿ׆Yÿ׆[ÿ׆]ÿ׆_ÿ׆oÿ…†qÿ…†sÿ…†ÿq‡ÿq‡ ÿq‡&ÿׇ*ÿׇ- ‡2ÿׇ4ÿׇ7ÿq‡9ÿ®‡:ÿ®‡<ÿ…‡‰ÿׇ”ÿׇ•ÿׇ–ÿׇ—ÿׇ˜ÿׇšÿׇŸÿ…‡ÈÿׇÊÿׇÌÿׇÎÿׇÞÿׇàÿׇâÿׇäÿׇÿׇÿׇÿׇÿׇ$ÿq‡&ÿq‡6ÿ®‡8ÿ…‡:ÿ…‡Gÿׇúÿ®‡üÿ®‡þÿ®‡ÿ…‡ÿq‡ ÿq‡_ÿׇIÿׇKÿׇMÿׇOÿׇQÿׇSÿׇUÿׇWÿׇYÿׇ[ÿׇ]ÿׇ_ÿׇoÿ…‡qÿ…‡sÿ…‡ÿqˆ-{‰&ÿ׉*ÿ׉2ÿ׉4ÿ׉‰ÿ׉”ÿ׉•ÿ׉–ÿ׉—ÿ׉˜ÿ׉šÿ׉Èÿ׉Êÿ׉Ìÿ׉Îÿ׉Þÿ׉àÿ׉âÿ׉äÿ׉ÿ׉ÿ׉ÿ׉ÿ׉Gÿ׉_ÿ׉Iÿ׉Kÿ׉Mÿ׉Oÿ׉Qÿ׉Sÿ׉Uÿ׉Wÿ׉Yÿ׉[ÿ׉]ÿ׉_ÿ׊-{‹-{Œ-{-{’ÿ®’ÿ®’$ÿ×’7ÿÃ’9ÿì’:ÿì’;ÿ×’<ÿì’=ÿì’‚ÿ×’ƒÿ×’„ÿ×’…ÿ×’†ÿ×’‡ÿ×’Ÿÿì’Âÿ×’Äÿ×’Æÿ×’$ÿÃ’&ÿÃ’6ÿì’8ÿì’:ÿì’;ÿì’=ÿì’?ÿì’Cÿ×’ ÿì’úÿì’üÿì’þÿì’ÿì’ÿ®’ ÿ®’Xÿ×’ÿ×’ÿ×’!ÿ×’#ÿ×’%ÿ×’'ÿ×’)ÿ×’+ÿ×’-ÿ×’/ÿ×’1ÿ×’3ÿ×’oÿì’qÿì’sÿì’ÿÔÿ®”ÿ®”$ÿ×”7ÿÔ9ÿì”:ÿì”;ÿ×”<ÿì”=ÿ씂ÿ×”ƒÿ×”„ÿ×”…ÿ×”†ÿ×”‡ÿ×”Ÿÿì”Âÿ×”Äÿ×”Æÿ×”$ÿÔ&ÿÔ6ÿì”8ÿì”:ÿì”;ÿì”=ÿì”?ÿì”Cÿ×” ÿì”úÿì”üÿì”þÿì”ÿì”ÿ®” ÿ®”Xÿ×”ÿ×”ÿ×”!ÿ×”#ÿ×”%ÿ×”'ÿ×”)ÿ×”+ÿ×”-ÿ×”/ÿ×”1ÿ×”3ÿ×”oÿì”qÿì”sÿì”ÿÕÿ®•ÿ®•$ÿו7ÿÕ9ÿì•:ÿì•;ÿו<ÿì•=ÿì•‚ÿוƒÿו„ÿו…ÿו†ÿו‡ÿוŸÿì•ÂÿוÄÿוÆÿו$ÿÕ&ÿÕ6ÿì•8ÿì•:ÿì•;ÿì•=ÿì•?ÿì•Cÿו ÿì•úÿì•üÿì•þÿì•ÿì•ÿ®• ÿ®•Xÿוÿוÿו!ÿו#ÿו%ÿו'ÿו)ÿו+ÿו-ÿו/ÿו1ÿו3ÿוoÿì•qÿì•sÿì•ÿÖÿ®–ÿ®–$ÿ×–7ÿÖ9ÿì–:ÿì–;ÿ×–<ÿì–=ÿì–‚ÿ×–ƒÿ×–„ÿ×–…ÿ×–†ÿ×–‡ÿ×–Ÿÿì–Âÿ×–Äÿ×–Æÿ×–$ÿÖ&ÿÖ6ÿì–8ÿì–:ÿì–;ÿì–=ÿì–?ÿì–Cÿ×– ÿì–úÿì–üÿì–þÿì–ÿì–ÿ®– ÿ®–Xÿ×–ÿ×–ÿ×–!ÿ×–#ÿ×–%ÿ×–'ÿ×–)ÿ×–+ÿ×–-ÿ×–/ÿ×–1ÿ×–3ÿ×–oÿì–qÿì–sÿì–ÿ×ÿ®—ÿ®—$ÿ×—7ÿ×9ÿì—:ÿì—;ÿ×—<ÿì—=ÿì—‚ÿ×—ƒÿ×—„ÿ×—…ÿ×—†ÿ×—‡ÿ×—Ÿÿì—Âÿ×—Äÿ×—Æÿ×—$ÿ×&ÿ×6ÿì—8ÿì—:ÿì—;ÿì—=ÿì—?ÿì—Cÿ×— ÿì—úÿì—üÿì—þÿì—ÿì—ÿ®— ÿ®—Xÿ×—ÿ×—ÿ×—!ÿ×—#ÿ×—%ÿ×—'ÿ×—)ÿ×—+ÿ×—-ÿ×—/ÿ×—1ÿ×—3ÿ×—oÿì—qÿì—sÿì—ÿØÿ®˜ÿ®˜$ÿט7ÿØ9ÿì˜:ÿì˜;ÿט<ÿì˜=ÿ옂ÿטƒÿט„ÿט…ÿט†ÿט‡ÿטŸÿì˜ÂÿטÄÿטÆÿט$ÿØ&ÿØ6ÿì˜8ÿì˜:ÿì˜;ÿì˜=ÿì˜?ÿì˜Cÿט ÿì˜úÿì˜üÿì˜þÿì˜ÿì˜ÿ®˜ ÿ®˜Xÿטÿטÿט!ÿט#ÿט%ÿט'ÿט)ÿט+ÿט-ÿט/ÿט1ÿט3ÿטoÿì˜qÿì˜sÿì˜ÿÚÿ®šÿ®š$ÿך7ÿÚ9ÿìš:ÿìš;ÿך<ÿìš=ÿìš‚ÿךƒÿך„ÿך…ÿך†ÿך‡ÿךŸÿìšÂÿךÄÿךÆÿך$ÿÚ&ÿÚ6ÿìš8ÿìš:ÿìš;ÿìš=ÿìš?ÿìšCÿך ÿìšúÿìšüÿìšþÿìšÿìšÿ®š ÿ®šXÿךÿךÿך!ÿך#ÿך%ÿך'ÿך)ÿך+ÿך-ÿך/ÿך1ÿך3ÿךoÿìšqÿìšsÿìšÿÛÿ×›ÿ×›$ÿ웂ÿ웃ÿ웄ÿì›…ÿ웆ÿ웇ÿì›Âÿì›Äÿì›Æÿì›Cÿì›ÿ×› ÿ×›Xÿì›ÿì›ÿì›!ÿì›#ÿì›%ÿì›'ÿì›)ÿì›+ÿì›-ÿì›/ÿì›1ÿì›3ÿìœÿלÿל$ÿ윂ÿ윃ÿ위ÿ윅ÿ윆ÿ윇ÿìœÂÿìœÄÿìœÆÿìœCÿìœÿל ÿלXÿìœÿìœÿìœ!ÿìœ#ÿìœ%ÿìœ'ÿìœ)ÿìœ+ÿìœ-ÿìœ/ÿìœ1ÿìœ3ÿìÿ×ÿ×$ÿì‚ÿìƒÿì„ÿì…ÿì†ÿì‡ÿìÂÿìÄÿìÆÿìCÿìÿ× ÿ×Xÿìÿìÿì!ÿì#ÿì%ÿì'ÿì)ÿì+ÿì-ÿì/ÿì1ÿì3ÿìžÿמÿמ$ÿìž‚ÿ잃ÿìž„ÿìž…ÿ잆ÿ잇ÿìžÂÿìžÄÿìžÆÿìžCÿìžÿמ ÿמXÿìžÿìžÿìž!ÿìž#ÿìž%ÿìž'ÿìž)ÿìž+ÿìž-ÿìž/ÿìž1ÿìž3ÿìŸÿ…Ÿÿ…Ÿ")Ÿ$ÿ…Ÿ&ÿן*ÿן2ÿן4ÿןDÿšŸFÿšŸGÿšŸHÿšŸJÿןPÿßQÿßRÿšŸSÿßTÿšŸUÿßVÿ®ŸXÿß]ÿן‚ÿ…Ÿƒÿ…Ÿ„ÿ…Ÿ…ÿ…Ÿ†ÿ…Ÿ‡ÿ…Ÿ‰ÿן”ÿן•ÿן–ÿן—ÿן˜ÿןšÿן¢ÿšŸ£ÿšŸ¤ÿšŸ¥ÿšŸ¦ÿšŸ§ÿšŸ¨ÿšŸ©ÿšŸªÿšŸ«ÿšŸ¬ÿšŸ­ÿšŸ´ÿšŸµÿšŸ¶ÿšŸ·ÿšŸ¸ÿšŸºÿšŸ»ÿß¼ÿß½ÿß¾ÿßÂÿ…ŸÃÿšŸÄÿ…ŸÅÿšŸÆÿ…ŸÇÿšŸÈÿןÉÿšŸÊÿןËÿšŸÌÿןÍÿšŸÎÿןÏÿšŸÑÿšŸÓÿšŸÕÿšŸ×ÿšŸÙÿšŸÛÿšŸÝÿšŸÞÿןßÿןàÿןáÿןâÿןãÿןäÿןåÿןúÿßÿßÿß ÿßÿןÿšŸÿןÿšŸÿןÿšŸÿןÿšŸÿßÿßÿ®Ÿ!ÿ®Ÿ+ÿß-ÿß/ÿß1ÿß3ÿß5ÿß<ÿן>ÿן@ÿןCÿ…ŸDÿšŸFÿšŸGÿןHÿšŸJÿ®Ÿÿ…Ÿ ÿ…ŸWÿßXÿ…ŸYÿšŸ_ÿן`ÿšŸbÿßÿ…ŸÿšŸÿ…Ÿ ÿšŸ!ÿ…Ÿ"ÿšŸ#ÿ…Ÿ%ÿ…Ÿ&ÿšŸ'ÿ…Ÿ(ÿšŸ)ÿ…Ÿ*ÿšŸ+ÿ…Ÿ,ÿšŸ-ÿ…Ÿ.ÿšŸ/ÿ…Ÿ0ÿšŸ1ÿ…Ÿ2ÿšŸ3ÿ…Ÿ4ÿšŸ6ÿšŸ8ÿšŸ:ÿšŸ<ÿšŸ@ÿšŸBÿšŸDÿšŸIÿןJÿšŸKÿןLÿšŸMÿןNÿšŸOÿןQÿןRÿšŸSÿןTÿšŸUÿןVÿšŸWÿןXÿšŸYÿןZÿšŸ[ÿן\ÿšŸ]ÿן^ÿšŸ_ÿן`ÿšŸbÿßdÿßfÿßhÿßjÿßlÿßnÿàþö þö $ÿš ;ÿ× =ÿì ‚ÿš ƒÿš „ÿš …ÿš †ÿš ‡ÿš Âÿš Äÿš Æÿš ;ÿì =ÿì ?ÿì Cÿš þö  þö Xÿš ÿš ÿš !ÿš #ÿš %ÿš 'ÿš )ÿš +ÿš -ÿš /ÿš 1ÿš 3ÿš¢ÿì¢ ÿì¢ÿì¢ ÿì£ÿì£ ÿì£ÿì£ ÿì¤ÿì¤ ÿì¤ÿì¤ ÿì¥ÿì¥ ÿì¥ÿì¥ ÿì¦ÿì¦ ÿì¦ÿì¦ ÿì§ÿì§ ÿì§ÿì§ ÿìªÿìª ÿìªYÿתZÿת[ÿת\ÿת]ÿ쪿ÿת7ÿת<ÿìª>ÿìª@ÿìªûÿתýÿתÿìª ÿìªpÿ׫ÿì« ÿì«Yÿ׫Zÿ׫[ÿ׫\ÿ׫]ÿì«¿ÿ׫7ÿ׫<ÿì«>ÿì«@ÿì«ûÿ׫ýÿ׫ÿì« ÿì«pÿ׬ÿì¬ ÿì¬Yÿ׬Zÿ׬[ÿ׬\ÿ׬]ÿ쬿ÿ׬7ÿ׬<ÿì¬>ÿì¬@ÿì¬ûÿ׬ýÿ׬ÿì¬ ÿì¬pÿ×­ÿì­ ÿì­Yÿ×­Zÿ×­[ÿ×­\ÿ×­]ÿì­¿ÿ×­7ÿ×­<ÿì­>ÿì­@ÿì­ûÿ×­ýÿ×­ÿì­ ÿì­pÿײÿì² ÿì²YÿײZÿײ[ÿײ\ÿײ]ÿ첿ÿײ7ÿײ<ÿì²>ÿì²@ÿì²ûÿײýÿײÿì² ÿì²pÿ×´ÿì´ ÿì´Yÿ×´Zÿ×´[ÿ×´\ÿ×´]ÿì´¿ÿ×´7ÿ×´<ÿì´>ÿì´@ÿì´ûÿ×´ýÿ×´ÿì´ ÿì´pÿ×µÿìµ ÿìµYÿ×µZÿ×µ[ÿ×µ\ÿ×µ]ÿ쵿ÿ×µ7ÿ×µ<ÿìµ>ÿìµ@ÿìµûÿ×µýÿ×µÿìµ ÿìµpÿ׶ÿì¶ ÿì¶Yÿ׶Zÿ׶[ÿ׶\ÿ׶]ÿ춿ÿ׶7ÿ׶<ÿì¶>ÿì¶@ÿì¶ûÿ׶ýÿ׶ÿì¶ ÿì¶pÿ׸ÿ׸ ÿ׸ÿ׸ ÿ׺ÿìº ÿìºYÿ׺Zÿ׺[ÿ׺\ÿ׺]ÿ캿ÿ׺7ÿ׺<ÿìº>ÿìº@ÿìºûÿ׺ýÿ׺ÿìº ÿìºpÿ׿R¿ R¿ÿ®¿ÿ®¿")¿R¿ÿ®¿ R¿ ÿ®ÀÿìÀ ÿìÀYÿ×ÀZÿ×À[ÿ×À\ÿ×À]ÿìÀ¿ÿ×À7ÿ×À<ÿìÀ>ÿìÀ@ÿìÀûÿ×Àýÿ×ÀÿìÀ ÿìÀpÿ×ÁRÁ RÁÿ®Áÿ®Á")ÁRÁÿ®Á RÁ ÿ®Âÿq ÿqÂ&ÿ×Â*ÿ×Â- Â2ÿ×Â4ÿ×Â7ÿqÂ9ÿ®Â:ÿ®Â<ÿ…‰ÿ×”ÿוÿ×–ÿ×—ÿטÿךÿןÿ…ÂÈÿ×ÂÊÿ×ÂÌÿ×ÂÎÿ×ÂÞÿ×Âàÿ×Ââÿ×Âäÿ×Âÿ×Âÿ×Âÿ×Âÿ×Â$ÿqÂ&ÿqÂ6ÿ®Â8ÿ…Â:ÿ…ÂGÿ×Âúÿ®Âüÿ®Âþÿ®Âÿ…Âÿq ÿqÂ_ÿ×ÂIÿ×ÂKÿ×ÂMÿ×ÂOÿ×ÂQÿ×ÂSÿ×ÂUÿ×ÂWÿ×ÂYÿ×Â[ÿ×Â]ÿ×Â_ÿ×Âoÿ…Âqÿ…Âsÿ…ÂÿqÃÿìà ÿìÃÿìà ÿìÄÿqÄ ÿqÄ&ÿ×Ä*ÿ×Ä- Ä2ÿ×Ä4ÿ×Ä7ÿqÄ9ÿ®Ä:ÿ®Ä<ÿ…ĉÿ×Ä”ÿ×Ä•ÿ×Ä–ÿ×Ä—ÿ×Ęÿ×Äšÿ×ÄŸÿ…ÄÈÿ×ÄÊÿ×ÄÌÿ×ÄÎÿ×ÄÞÿ×Äàÿ×Äâÿ×Ääÿ×Äÿ×Äÿ×Äÿ×Äÿ×Ä$ÿqÄ&ÿqÄ6ÿ®Ä8ÿ…Ä:ÿ…ÄGÿ×Äúÿ®Äüÿ®Äþÿ®Äÿ…ÄÿqÄ ÿqÄ_ÿ×ÄIÿ×ÄKÿ×ÄMÿ×ÄOÿ×ÄQÿ×ÄSÿ×ÄUÿ×ÄWÿ×ÄYÿ×Ä[ÿ×Ä]ÿ×Ä_ÿ×Äoÿ…Äqÿ…Äsÿ…ÄÿqÅÿìÅ ÿìÅÿìÅ ÿìÆÿqÆ ÿqÆ&ÿ×Æ*ÿ×Æ- Æ2ÿ×Æ4ÿ×Æ7ÿqÆ9ÿ®Æ:ÿ®Æ<ÿ…Ɖÿ×Æ”ÿ×Æ•ÿ×Æ–ÿ×Æ—ÿ×Ƙÿ×Æšÿ×ÆŸÿ…ÆÈÿ×ÆÊÿ×ÆÌÿ×ÆÎÿ×ÆÞÿ×Æàÿ×Æâÿ×Æäÿ×Æÿ×Æÿ×Æÿ×Æÿ×Æ$ÿqÆ&ÿqÆ6ÿ®Æ8ÿ…Æ:ÿ…ÆGÿ×Æúÿ®Æüÿ®Æþÿ®Æÿ…ÆÿqÆ ÿqÆ_ÿ×ÆIÿ×ÆKÿ×ÆMÿ×ÆOÿ×ÆQÿ×ÆSÿ×ÆUÿ×ÆWÿ×ÆYÿ×Æ[ÿ×Æ]ÿ×Æ_ÿ×Æoÿ…Æqÿ…Æsÿ…ÆÿqÇÿìÇ ÿìÇÿìÇ ÿìÈ&ÿ×È*ÿ×È2ÿ×È4ÿ×ȉÿ×È”ÿ×È•ÿ×È–ÿ×È—ÿ×Șÿ×Èšÿ×ÈÈÿ×ÈÊÿ×ÈÌÿ×ÈÎÿ×ÈÞÿ×Èàÿ×Èâÿ×Èäÿ×Èÿ×Èÿ×Èÿ×Èÿ×ÈGÿ×È_ÿ×ÈIÿ×ÈKÿ×ÈMÿ×ÈOÿ×ÈQÿ×ÈSÿ×ÈUÿ×ÈWÿ×ÈYÿ×È[ÿ×È]ÿ×È_ÿ×Ê&ÿ×Ê*ÿ×Ê2ÿ×Ê4ÿ×ʉÿ×Ê”ÿ×Ê•ÿ×Ê–ÿ×Ê—ÿ×ʘÿ×Êšÿ×ÊÈÿ×ÊÊÿ×ÊÌÿ×ÊÎÿ×ÊÞÿ×Êàÿ×Êâÿ×Êäÿ×Êÿ×Êÿ×Êÿ×Êÿ×ÊGÿ×Ê_ÿ×ÊIÿ×ÊKÿ×ÊMÿ×ÊOÿ×ÊQÿ×ÊSÿ×ÊUÿ×ÊWÿ×ÊYÿ×Ê[ÿ×Ê]ÿ×Ê_ÿ×Ì&ÿ×Ì*ÿ×Ì2ÿ×Ì4ÿ×̉ÿ×Ì”ÿ×Ì•ÿ×Ì–ÿ×Ì—ÿ×̘ÿ×Ìšÿ×ÌÈÿ×ÌÊÿ×ÌÌÿ×ÌÎÿ×ÌÞÿ×Ìàÿ×Ìâÿ×Ìäÿ×Ìÿ×Ìÿ×Ìÿ×Ìÿ×ÌGÿ×Ì_ÿ×ÌIÿ×ÌKÿ×ÌMÿ×ÌOÿ×ÌQÿ×ÌSÿ×ÌUÿ×ÌWÿ×ÌYÿ×Ì[ÿ×Ì]ÿ×Ì_ÿ×Î&ÿ×Î*ÿ×Î2ÿ×Î4ÿ×Ήÿ×Δÿ×Εÿ×Ζÿ×Ηÿ×Θÿ×Κÿ×ÎÈÿ×ÎÊÿ×ÎÌÿ×ÎÎÿ×ÎÞÿ×Îàÿ×Îâÿ×Îäÿ×Îÿ×Îÿ×Îÿ×Îÿ×ÎGÿ×Î_ÿ×ÎIÿ×ÎKÿ×ÎMÿ×ÎOÿ×ÎQÿ×ÎSÿ×ÎUÿ×ÎWÿ×ÎYÿ×Î[ÿ×Î]ÿ×Î_ÿ×Ðÿ®Ðÿ®Ð$ÿ×Ð7ÿÃÐ9ÿìÐ:ÿìÐ;ÿ×Ð<ÿìÐ=ÿìЂÿ×Ѓÿ×Єÿ×Ð…ÿ×Іÿ×Їÿ×ПÿìÐÂÿ×ÐÄÿ×ÐÆÿ×Ð$ÿÃÐ&ÿÃÐ6ÿìÐ8ÿìÐ:ÿìÐ;ÿìÐ=ÿìÐ?ÿìÐCÿ×РÿìÐúÿìÐüÿìÐþÿìÐÿìÐÿ®Ð ÿ®ÐXÿ×Ðÿ×Ðÿ×Ð!ÿ×Ð#ÿ×Ð%ÿ×Ð'ÿ×Ð)ÿ×Ð+ÿ×Ð-ÿ×Ð/ÿ×Ð1ÿ×Ð3ÿ×ÐoÿìÐqÿìÐsÿìÐÿÃÑRÑ RÑ Ñ"¤Ñ@ÑE=ÑK=ÑN=ÑO=Ñ`Ñç=Ñé{ÑRÑ RÒÿ®Òÿ®Ò$ÿ×Ò7ÿÃÒ9ÿìÒ:ÿìÒ;ÿ×Ò<ÿìÒ=ÿìÒ‚ÿ×Òƒÿ×Ò„ÿ×Ò…ÿ×Ò†ÿ×Ò‡ÿ×ÒŸÿìÒÂÿ×ÒÄÿ×ÒÆÿ×Ò$ÿÃÒ&ÿÃÒ6ÿìÒ8ÿìÒ:ÿìÒ;ÿìÒ=ÿìÒ?ÿìÒCÿ×Ò ÿìÒúÿìÒüÿìÒþÿìÒÿìÒÿ®Ò ÿ®ÒXÿ×Òÿ×Òÿ×Ò!ÿ×Ò#ÿ×Ò%ÿ×Ò'ÿ×Ò)ÿ×Ò+ÿ×Ò-ÿ×Ò/ÿ×Ò1ÿ×Ò3ÿ×ÒoÿìÒqÿìÒsÿìÒÿÃÔ-{ÕÿìÕ ÿìÕYÿ×ÕZÿ×Õ[ÿ×Õ\ÿ×Õ]ÿìÕ¿ÿ×Õ7ÿ×Õ<ÿìÕ>ÿìÕ@ÿìÕûÿ×Õýÿ×ÕÿìÕ ÿìÕpÿ×Ö-{×ÿì× ÿì×Yÿ××Zÿ××[ÿ××\ÿ××]ÿì׿ÿ××7ÿ××<ÿì×>ÿì×@ÿì×ûÿ××ýÿ××ÿì× ÿì×pÿ×Ø-{ÙÿìÙ ÿìÙYÿ×ÙZÿ×Ù[ÿ×Ù\ÿ×Ù]ÿìÙ¿ÿ×Ù7ÿ×Ù<ÿìÙ>ÿìÙ@ÿìÙûÿ×Ùýÿ×ÙÿìÙ ÿìÙpÿ×Ú-{ÛÿìÛ ÿìÛYÿ×ÛZÿ×Û[ÿ×Û\ÿ×Û]ÿìÛ¿ÿ×Û7ÿ×Û<ÿìÛ>ÿìÛ@ÿìÛûÿ×Ûýÿ×ÛÿìÛ ÿìÛpÿ×Ü-{ÝÿìÝ ÿìÝYÿ×ÝZÿ×Ý[ÿ×Ý\ÿ×Ý]ÿìÝ¿ÿ×Ý7ÿ×Ý<ÿìÝ>ÿìÝ@ÿìÝûÿ×Ýýÿ×ÝÿìÝ ÿìÝpÿ×çÿìç ÿìçÿìç ÿìø&ÿ×ø*ÿ×ø2ÿ×ø4ÿ×ø‰ÿ×ø”ÿ×ø•ÿ×ø–ÿ×ø—ÿ×ø˜ÿ×øšÿ×øÈÿ×øÊÿ×øÌÿ×øÎÿ×øÞÿ×øàÿ×øâÿ×øäÿ×øÿ×øÿ×øÿ×øÿ×øGÿ×ø_ÿ×øIÿ×øKÿ×øMÿ×øOÿ×øQÿ×øSÿ×øUÿ×øWÿ×øYÿ×ø[ÿ×ø]ÿ×ø_ÿ×ùFÿ×ùGÿ×ùHÿ×ùRÿ×ùTÿ×ù¢ÿ×ù©ÿ×ùªÿ×ù«ÿ×ù¬ÿ×ù­ÿ×ù´ÿ×ùµÿ×ù¶ÿ×ù·ÿ×ù¸ÿ×ùºÿ×ùÉÿ×ùËÿ×ùÍÿ×ùÏÿ×ùÑÿ×ùÓÿ×ùÕÿ×ù×ÿ×ùÙÿ×ùÛÿ×ùÝÿ×ùÿ×ùÿ×ùÿ×ùÿ×ùHÿ×ù`ÿ×ù6ÿ×ù8ÿ×ù:ÿ×ù<ÿ×ù@ÿ×ùBÿ×ùDÿ×ùJÿ×ùLÿ×ùNÿ×ùRÿ×ùTÿ×ùVÿ×ùXÿ×ùZÿ×ù\ÿ×ù^ÿ×ù`ÿ×úFÿ×úGÿ×úHÿ×úRÿ×úTÿ×ú¢ÿ×ú©ÿ×úªÿ×ú«ÿ×ú¬ÿ×ú­ÿ×ú´ÿ×úµÿ×ú¶ÿ×ú·ÿ×ú¸ÿ×úºÿ×úÉÿ×úËÿ×úÍÿ×úÏÿ×úÑÿ×úÓÿ×úÕÿ×ú×ÿ×úÙÿ×úÛÿ×úÝÿ×úÿ×úÿ×úÿ×úÿ×úHÿ×ú`ÿ×ú6ÿ×ú8ÿ×ú:ÿ×ú<ÿ×ú@ÿ×úBÿ×úDÿ×úJÿ×úLÿ×úNÿ×úRÿ×úTÿ×úVÿ×úXÿ×úZÿ×ú\ÿ×ú^ÿ×ú`ÿ×ûÿ\û ÿ\û&ÿ×û*ÿ×û2ÿ×û4ÿ×û7ÿ×û8ÿìû9ÿ×û:ÿ×û<ÿÃû‰ÿ×û”ÿ×û•ÿ×û–ÿ×û—ÿ×û˜ÿ×ûšÿ×û›ÿìûœÿìûÿìûžÿìûŸÿÃûÈÿ×ûÊÿ×ûÌÿ×ûÎÿ×ûÞÿ×ûàÿ×ûâÿ×ûäÿ×ûÿ×ûÿ×ûÿ×ûÿ×û$ÿ×û&ÿ×û*ÿìû,ÿìû.ÿìû0ÿìû2ÿìû4ÿìû6ÿ×û8ÿÃû:ÿÃûGÿ×ûúÿ×ûüÿ×ûþÿ×ûÿÃûÿ\û ÿ\û_ÿ×ûaÿìûIÿ×ûKÿ×ûMÿ×ûOÿ×ûQÿ×ûSÿ×ûUÿ×ûWÿ×ûYÿ×û[ÿ×û]ÿ×û_ÿ×ûaÿìûcÿìûeÿìûgÿìûiÿìûkÿìûmÿìûoÿÃûqÿÃûsÿÃûÿ×ýÿ\ý ÿ\ý&ÿ×ý*ÿ×ý2ÿ×ý4ÿ×ý7ÿ×ý8ÿìý9ÿ×ý:ÿ×ý<ÿÃý‰ÿ×ý”ÿ×ý•ÿ×ý–ÿ×ý—ÿ×ý˜ÿ×ýšÿ×ý›ÿìýœÿìýÿìýžÿìýŸÿÃýÈÿ×ýÊÿ×ýÌÿ×ýÎÿ×ýÞÿ×ýàÿ×ýâÿ×ýäÿ×ýÿ×ýÿ×ýÿ×ýÿ×ý$ÿ×ý&ÿ×ý*ÿìý,ÿìý.ÿìý0ÿìý2ÿìý4ÿìý6ÿ×ý8ÿÃý:ÿÃýGÿ×ýúÿ×ýüÿ×ýþÿ×ýÿÃýÿ\ý ÿ\ý_ÿ×ýaÿìýIÿ×ýKÿ×ýMÿ×ýOÿ×ýQÿ×ýSÿ×ýUÿ×ýWÿ×ýYÿ×ý[ÿ×ý]ÿ×ý_ÿ×ýaÿìýcÿìýeÿìýgÿìýiÿìýkÿìýmÿìýoÿÃýqÿÃýsÿÃýÿ×ÿÿ\ÿ ÿ\ÿ&ÿ×ÿ*ÿ×ÿ2ÿ×ÿ4ÿ×ÿ7ÿ×ÿ8ÿìÿ9ÿ×ÿ:ÿ×ÿ<ÿÃÿ‰ÿ×ÿ”ÿ×ÿ•ÿ×ÿ–ÿ×ÿ—ÿ×ÿ˜ÿ×ÿšÿ×ÿ›ÿìÿœÿìÿÿìÿžÿìÿŸÿÃÿÈÿ×ÿÊÿ×ÿÌÿ×ÿÎÿ×ÿÞÿ×ÿàÿ×ÿâÿ×ÿäÿ×ÿÿ×ÿÿ×ÿÿ×ÿÿ×ÿ$ÿ×ÿ&ÿ×ÿ*ÿìÿ,ÿìÿ.ÿìÿ0ÿìÿ2ÿìÿ4ÿìÿ6ÿ×ÿ8ÿÃÿ:ÿÃÿGÿ×ÿúÿ×ÿüÿ×ÿþÿ×ÿÿÃÿÿ\ÿ ÿ\ÿ_ÿ×ÿaÿìÿIÿ×ÿKÿ×ÿMÿ×ÿOÿ×ÿQÿ×ÿSÿ×ÿUÿ×ÿWÿ×ÿYÿ×ÿ[ÿ×ÿ]ÿ×ÿ_ÿ×ÿaÿìÿcÿìÿeÿìÿgÿìÿiÿìÿkÿìÿmÿìÿoÿÃÿqÿÃÿsÿÃÿÿ×R R "@E=K=N=O=`ç=éR Rÿ\ ÿ\&ÿ×*ÿ×2ÿ×4ÿ×7ÿ×8ÿì9ÿ×:ÿ×<ÿÉÿ×”ÿוÿ×–ÿ×—ÿטÿךÿ×›ÿìœÿìÿìžÿìŸÿÃÈÿ×Êÿ×Ìÿ×Îÿ×Þÿ×àÿ×âÿ×äÿ×ÿ×ÿ×ÿ×ÿ×$ÿ×&ÿ×*ÿì,ÿì.ÿì0ÿì2ÿì4ÿì6ÿ×8ÿÃ:ÿÃGÿ×úÿ×üÿ×þÿ×ÿÃÿ\ ÿ\_ÿ×aÿìIÿ×Kÿ×Mÿ×Oÿ×Qÿ×Sÿ×Uÿ×Wÿ×Yÿ×[ÿ×]ÿ×_ÿ×aÿìcÿìeÿìgÿìiÿìkÿìmÿìoÿÃqÿÃsÿÃÿ×ÿ\ ÿ\&ÿ×*ÿ×2ÿ×4ÿ×7ÿ×8ÿì9ÿ×:ÿ×<ÿÉÿ×”ÿוÿ×–ÿ×—ÿטÿךÿ×›ÿìœÿìÿìžÿìŸÿÃÈÿ×Êÿ×Ìÿ×Îÿ×Þÿ×àÿ×âÿ×äÿ×ÿ×ÿ×ÿ×ÿ×$ÿ×&ÿ×*ÿì,ÿì.ÿì0ÿì2ÿì4ÿì6ÿ×8ÿÃ:ÿÃGÿ×úÿ×üÿ×þÿ×ÿÃÿ\ ÿ\_ÿ×aÿìIÿ×Kÿ×Mÿ×Oÿ×Qÿ×Sÿ×Uÿ×Wÿ×Yÿ×[ÿ×]ÿ×_ÿ×aÿìcÿìeÿìgÿìiÿìkÿìmÿìoÿÃqÿÃsÿÃÿ×ÿì ÿìÿì ÿìÿ®ÿ®$ÿ×7ÿÃ9ÿì:ÿì;ÿ×<ÿì=ÿì‚ÿ׃ÿׄÿ×…ÿ׆ÿׇÿןÿìÂÿ×Äÿ×Æÿ×$ÿÃ&ÿÃ6ÿì8ÿì:ÿì;ÿì=ÿì?ÿìCÿ× ÿìúÿìüÿìþÿìÿìÿ® ÿ®Xÿ×ÿ×ÿ×!ÿ×#ÿ×%ÿ×'ÿ×)ÿ×+ÿ×-ÿ×/ÿ×1ÿ×3ÿ×oÿìqÿìsÿìÿÃÿ®ÿ®$ÿ×7ÿÃ9ÿì:ÿì;ÿ×<ÿì=ÿì‚ÿ׃ÿׄÿ×…ÿ׆ÿׇÿןÿìÂÿ×Äÿ×Æÿ×$ÿÃ&ÿÃ6ÿì8ÿì:ÿì;ÿì=ÿì?ÿìCÿ× ÿìúÿìüÿìþÿìÿìÿ® ÿ®Xÿ×ÿ×ÿ×!ÿ×#ÿ×%ÿ×'ÿ×)ÿ×+ÿ×-ÿ×/ÿ×1ÿ×3ÿ×oÿìqÿìsÿìÿÃÿ®ÿ®$ÿ×7ÿÃ9ÿì:ÿì;ÿ×<ÿì=ÿì‚ÿ׃ÿׄÿ×…ÿ׆ÿׇÿןÿìÂÿ×Äÿ×Æÿ×$ÿÃ&ÿÃ6ÿì8ÿì:ÿì;ÿì=ÿì?ÿìCÿ× ÿìúÿìüÿìþÿìÿìÿ® ÿ®Xÿ×ÿ×ÿ×!ÿ×#ÿ×%ÿ×'ÿ×)ÿ×+ÿ×-ÿ×/ÿ×1ÿ×3ÿ×oÿìqÿìsÿìÿÃ-{R RDÿ×Fÿ×Gÿ×Hÿ×JÿìRÿ×Tÿ×¢ÿ×£ÿפÿ×¥ÿצÿקÿרÿשÿתÿ׫ÿ׬ÿ×­ÿ×´ÿ×µÿ׶ÿ×·ÿ׸ÿ׺ÿ×Ãÿ×Åÿ×Çÿ×Éÿ×Ëÿ×Íÿ×Ïÿ×Ñÿ×Óÿ×Õÿ××ÿ×Ùÿ×Ûÿ×Ýÿ×ßÿìáÿìãÿìåÿìÿ×ÿ×ÿ×ÿ×Dÿ×Fÿ×Hÿ×R RYÿ×`ÿ×ÿ× ÿ×"ÿ×&ÿ×(ÿ×*ÿ×,ÿ×.ÿ×0ÿ×2ÿ×4ÿ×6ÿ×8ÿ×:ÿ×<ÿ×@ÿ×Bÿ×Dÿ×Jÿ×Lÿ×Nÿ×Rÿ×Tÿ×Vÿ×Xÿ×Zÿ×\ÿ×^ÿ×`ÿ×R RDÿ×Fÿ×Gÿ×Hÿ×JÿìRÿ×Tÿ×¢ÿ×£ÿפÿ×¥ÿצÿקÿרÿשÿתÿ׫ÿ׬ÿ×­ÿ×´ÿ×µÿ׶ÿ×·ÿ׸ÿ׺ÿ×Ãÿ×Åÿ×Çÿ×Éÿ×Ëÿ×Íÿ×Ïÿ×Ñÿ×Óÿ×Õÿ××ÿ×Ùÿ×Ûÿ×Ýÿ×ßÿìáÿìãÿìåÿìÿ×ÿ×ÿ×ÿ×Dÿ×Fÿ×Hÿ×R RYÿ×`ÿ×ÿ× ÿ×"ÿ×&ÿ×(ÿ×*ÿ×,ÿ×.ÿ×0ÿ×2ÿ×4ÿ×6ÿ×8ÿ×:ÿ×<ÿ×@ÿ×Bÿ×Dÿ×Jÿ×Lÿ×Nÿ×Rÿ×Tÿ×Vÿ×Xÿ×Zÿ×\ÿ×^ÿ×`ÿ×R RDÿ×Fÿ×Gÿ×Hÿ×JÿìRÿ×Tÿ×¢ÿ×£ÿפÿ×¥ÿצÿקÿרÿשÿתÿ׫ÿ׬ÿ×­ÿ×´ÿ×µÿ׶ÿ×·ÿ׸ÿ׺ÿ×Ãÿ×Åÿ×Çÿ×Éÿ×Ëÿ×Íÿ×Ïÿ×Ñÿ×Óÿ×Õÿ××ÿ×Ùÿ×Ûÿ×Ýÿ×ßÿìáÿìãÿìåÿìÿ×ÿ×ÿ×ÿ×Dÿ×Fÿ×Hÿ×R RYÿ×`ÿ×ÿ× ÿ×"ÿ×&ÿ×(ÿ×*ÿ×,ÿ×.ÿ×0ÿ×2ÿ×4ÿ×6ÿ×8ÿ×:ÿ×<ÿ×@ÿ×Bÿ×Dÿ×Jÿ×Lÿ×Nÿ×Rÿ×Tÿ×Vÿ×Xÿ×Zÿ×\ÿ×^ÿ×`ÿ×$ÿ…$ÿ®$ÿ…$")$$ÿq$&ÿ×$*ÿ×$2ÿ×$4ÿ×$7)$Dÿ\$Fÿq$Gÿq$Hÿq$Jÿq$Pÿš$Qÿš$Rÿq$Sÿš$Tÿq$Uÿš$Vÿ…$Xÿš$Yÿ×$Zÿ×$[ÿ×$\ÿ×$]ÿ®$‚ÿq$ƒÿq$„ÿq$…ÿq$†ÿq$‡ÿq$‰ÿ×$”ÿ×$•ÿ×$–ÿ×$—ÿ×$˜ÿ×$šÿ×$¢ÿq$£ÿ\$¤ÿ\$¥ÿ\$¦ÿ\$§ÿ\$¨ÿ\$©ÿq$ªÿq$«ÿq$¬ÿq$­ÿq$´ÿq$µÿq$¶ÿq$·ÿq$¸ÿq$ºÿq$»ÿš$¼ÿš$½ÿš$¾ÿš$¿ÿ×$Âÿq$Ãÿ\$Äÿq$Åÿ\$Æÿq$Çÿ\$Èÿ×$Éÿq$Êÿ×$Ëÿq$Ìÿ×$Íÿq$Îÿ×$Ïÿq$Ñÿq$Óÿq$Õÿq$×ÿq$Ùÿq$Ûÿq$Ýÿq$Þÿ×$ßÿq$àÿ×$áÿq$âÿ×$ãÿq$äÿ×$åÿq$úÿš$ÿš$ÿš$ ÿš$ÿ×$ÿq$ÿ×$ÿq$ÿ×$ÿq$ÿ×$ÿq$ÿš$ÿš$ÿ…$!ÿ…$$)$&)$+ÿš$-ÿš$/ÿš$1ÿš$3ÿš$5ÿš$7ÿ×$<ÿ®$>ÿ®$@ÿ®$Cÿq$Dÿ\$Fÿ\$Gÿ×$Hÿq$Jÿ…$ûÿ×$ýÿ×$ÿ®$ÿ®$ÿ®$ÿ…$ ÿ…$Wÿš$Xÿq$Yÿ\$_ÿ×$`ÿq$bÿš$ÿq$ÿ\$ÿq$ ÿ\$!ÿq$"ÿ\$#ÿq$%ÿq$&ÿ\$'ÿq$(ÿ\$)ÿq$*ÿ\$+ÿq$,ÿ\$-ÿq$.ÿ\$/ÿq$0ÿ\$1ÿq$2ÿ\$3ÿq$4ÿ\$6ÿq$8ÿq$:ÿq$<ÿq$@ÿq$Bÿq$Dÿq$Iÿ×$Jÿq$Kÿ×$Lÿq$Mÿ×$Nÿq$Oÿ×$Qÿ×$Rÿq$Sÿ×$Tÿq$Uÿ×$Vÿq$Wÿ×$Xÿq$Yÿ×$Zÿq$[ÿ×$\ÿq$]ÿ×$^ÿq$_ÿ×$`ÿq$bÿš$dÿš$fÿš$hÿš$jÿš$lÿš$nÿš$pÿ×$)%)% )%)% )&ÿ…&ÿ®&ÿ…&")&$ÿq&&ÿ×&*ÿ×&2ÿ×&4ÿ×&7)&Dÿ\&Fÿq&Gÿq&Hÿq&Jÿq&Pÿš&Qÿš&Rÿq&Sÿš&Tÿq&Uÿš&Vÿ…&Xÿš&Yÿ×&Zÿ×&[ÿ×&\ÿ×&]ÿ®&‚ÿq&ƒÿq&„ÿq&…ÿq&†ÿq&‡ÿq&‰ÿ×&”ÿ×&•ÿ×&–ÿ×&—ÿ×&˜ÿ×&šÿ×&¢ÿq&£ÿ\&¤ÿ\&¥ÿ\&¦ÿ\&§ÿ\&¨ÿ\&©ÿq&ªÿq&«ÿq&¬ÿq&­ÿq&´ÿq&µÿq&¶ÿq&·ÿq&¸ÿq&ºÿq&»ÿš&¼ÿš&½ÿš&¾ÿš&¿ÿ×&Âÿq&Ãÿ\&Äÿq&Åÿ\&Æÿq&Çÿ\&Èÿ×&Éÿq&Êÿ×&Ëÿq&Ìÿ×&Íÿq&Îÿ×&Ïÿq&Ñÿq&Óÿq&Õÿq&×ÿq&Ùÿq&Ûÿq&Ýÿq&Þÿ×&ßÿq&àÿ×&áÿq&âÿ×&ãÿq&äÿ×&åÿq&úÿš&ÿš&ÿš& ÿš&ÿ×&ÿq&ÿ×&ÿq&ÿ×&ÿq&ÿ×&ÿq&ÿš&ÿš&ÿ…&!ÿ…&$)&&)&+ÿš&-ÿš&/ÿš&1ÿš&3ÿš&5ÿš&7ÿ×&<ÿ®&>ÿ®&@ÿ®&Cÿq&Dÿ\&Fÿ\&Gÿ×&Hÿq&Jÿ…&ûÿ×&ýÿ×&ÿ®&ÿ®&ÿ®&ÿ…& ÿ…&Wÿš&Xÿq&Yÿ\&_ÿ×&`ÿq&bÿš&ÿq&ÿ\&ÿq& ÿ\&!ÿq&"ÿ\&#ÿq&%ÿq&&ÿ\&'ÿq&(ÿ\&)ÿq&*ÿ\&+ÿq&,ÿ\&-ÿq&.ÿ\&/ÿq&0ÿ\&1ÿq&2ÿ\&3ÿq&4ÿ\&6ÿq&8ÿq&:ÿq&<ÿq&@ÿq&Bÿq&Dÿq&Iÿ×&Jÿq&Kÿ×&Lÿq&Mÿ×&Nÿq&Oÿ×&Qÿ×&Rÿq&Sÿ×&Tÿq&Uÿ×&Vÿq&Wÿ×&Xÿq&Yÿ×&Zÿq&[ÿ×&\ÿq&]ÿ×&^ÿq&_ÿ×&`ÿq&bÿš&dÿš&fÿš&hÿš&jÿš&lÿš&nÿš&pÿ×&)')' )')' )(ÿ…(ÿ®(ÿ…(")($ÿq(&ÿ×(*ÿ×(2ÿ×(4ÿ×(7)(Dÿ\(Fÿq(Gÿq(Hÿq(Jÿq(Pÿš(Qÿš(Rÿq(Sÿš(Tÿq(Uÿš(Vÿ…(Xÿš(Yÿ×(Zÿ×([ÿ×(\ÿ×(]ÿ®(‚ÿq(ƒÿq(„ÿq(…ÿq(†ÿq(‡ÿq(‰ÿ×(”ÿ×(•ÿ×(–ÿ×(—ÿ×(˜ÿ×(šÿ×(¢ÿq(£ÿ\(¤ÿ\(¥ÿ\(¦ÿ\(§ÿ\(¨ÿ\(©ÿq(ªÿq(«ÿq(¬ÿq(­ÿq(´ÿq(µÿq(¶ÿq(·ÿq(¸ÿq(ºÿq(»ÿš(¼ÿš(½ÿš(¾ÿš(¿ÿ×(Âÿq(Ãÿ\(Äÿq(Åÿ\(Æÿq(Çÿ\(Èÿ×(Éÿq(Êÿ×(Ëÿq(Ìÿ×(Íÿq(Îÿ×(Ïÿq(Ñÿq(Óÿq(Õÿq(×ÿq(Ùÿq(Ûÿq(Ýÿq(Þÿ×(ßÿq(àÿ×(áÿq(âÿ×(ãÿq(äÿ×(åÿq(úÿš(ÿš(ÿš( ÿš(ÿ×(ÿq(ÿ×(ÿq(ÿ×(ÿq(ÿ×(ÿq(ÿš(ÿš(ÿ…(!ÿ…($)(&)(+ÿš(-ÿš(/ÿš(1ÿš(3ÿš(5ÿš(7ÿ×(<ÿ®(>ÿ®(@ÿ®(Cÿq(Dÿ\(Fÿ\(Gÿ×(Hÿq(Jÿ…(ûÿ×(ýÿ×(ÿ®(ÿ®(ÿ®(ÿ…( ÿ…(Wÿš(Xÿq(Yÿ\(_ÿ×(`ÿq(bÿš(ÿq(ÿ\(ÿq( ÿ\(!ÿq("ÿ\(#ÿq(%ÿq(&ÿ\('ÿq((ÿ\()ÿq(*ÿ\(+ÿq(,ÿ\(-ÿq(.ÿ\(/ÿq(0ÿ\(1ÿq(2ÿ\(3ÿq(4ÿ\(6ÿq(8ÿq(:ÿq(<ÿq(@ÿq(Bÿq(Dÿq(Iÿ×(Jÿq(Kÿ×(Lÿq(Mÿ×(Nÿq(Oÿ×(Qÿ×(Rÿq(Sÿ×(Tÿq(Uÿ×(Vÿq(Wÿ×(Xÿq(Yÿ×(Zÿq([ÿ×(\ÿq(]ÿ×(^ÿq(_ÿ×(`ÿq(bÿš(dÿš(fÿš(hÿš(jÿš(lÿš(nÿš(pÿ×()*ÿ×*ÿ×*$ÿì*‚ÿì*ƒÿì*„ÿì*…ÿì*†ÿì*‡ÿì*Âÿì*Äÿì*Æÿì*Cÿì*ÿ×* ÿ×*Xÿì*ÿì*ÿì*!ÿì*#ÿì*%ÿì*'ÿì*)ÿì*+ÿì*-ÿì*/ÿì*1ÿì*3ÿì,ÿ×,ÿ×,$ÿì,‚ÿì,ƒÿì,„ÿì,…ÿì,†ÿì,‡ÿì,Âÿì,Äÿì,Æÿì,Cÿì,ÿ×, ÿ×,Xÿì,ÿì,ÿì,!ÿì,#ÿì,%ÿì,'ÿì,)ÿì,+ÿì,-ÿì,/ÿì,1ÿì,3ÿì.ÿ×.ÿ×.$ÿì.‚ÿì.ƒÿì.„ÿì.…ÿì.†ÿì.‡ÿì.Âÿì.Äÿì.Æÿì.Cÿì.ÿ×. ÿ×.Xÿì.ÿì.ÿì.!ÿì.#ÿì.%ÿì.'ÿì.)ÿì.+ÿì.-ÿì./ÿì.1ÿì.3ÿì0ÿ×0ÿ×0$ÿì0‚ÿì0ƒÿì0„ÿì0…ÿì0†ÿì0‡ÿì0Âÿì0Äÿì0Æÿì0Cÿì0ÿ×0 ÿ×0Xÿì0ÿì0ÿì0!ÿì0#ÿì0%ÿì0'ÿì0)ÿì0+ÿì0-ÿì0/ÿì01ÿì03ÿì2ÿ×2ÿ×2$ÿì2‚ÿì2ƒÿì2„ÿì2…ÿì2†ÿì2‡ÿì2Âÿì2Äÿì2Æÿì2Cÿì2ÿ×2 ÿ×2Xÿì2ÿì2ÿì2!ÿì2#ÿì2%ÿì2'ÿì2)ÿì2+ÿì2-ÿì2/ÿì21ÿì23ÿì4ÿ×4ÿ×4$ÿì4‚ÿì4ƒÿì4„ÿì4…ÿì4†ÿì4‡ÿì4Âÿì4Äÿì4Æÿì4Cÿì4ÿ×4 ÿ×4Xÿì4ÿì4ÿì4!ÿì4#ÿì4%ÿì4'ÿì4)ÿì4+ÿì4-ÿì4/ÿì41ÿì43ÿì6ÿš6ÿš6")6$ÿ®6&ÿì6*ÿì62ÿì64ÿì6Dÿ×6Fÿ×6Gÿ×6Hÿ×6Jÿì6Pÿì6Qÿì6Rÿ×6Sÿì6Tÿ×6Uÿì6Vÿì6Xÿì6‚ÿ®6ƒÿ®6„ÿ®6…ÿ®6†ÿ®6‡ÿ®6‰ÿì6”ÿì6•ÿì6–ÿì6—ÿì6˜ÿì6šÿì6¢ÿ×6£ÿ×6¤ÿ×6¥ÿ×6¦ÿ×6§ÿ×6¨ÿ×6©ÿ×6ªÿ×6«ÿ×6¬ÿ×6­ÿ×6´ÿ×6µÿ×6¶ÿ×6·ÿ×6¸ÿ×6ºÿ×6»ÿì6¼ÿì6½ÿì6¾ÿì6Âÿ®6Ãÿ×6Äÿ®6Åÿ×6Æÿ®6Çÿ×6Èÿì6Éÿ×6Êÿì6Ëÿ×6Ìÿì6Íÿ×6Îÿì6Ïÿ×6Ñÿ×6Óÿ×6Õÿ×6×ÿ×6Ùÿ×6Ûÿ×6Ýÿ×6Þÿì6ßÿì6àÿì6áÿì6âÿì6ãÿì6äÿì6åÿì6úÿì6ÿì6ÿì6 ÿì6ÿì6ÿ×6ÿì6ÿ×6ÿì6ÿ×6ÿì6ÿ×6ÿì6ÿì6ÿì6!ÿì6+ÿì6-ÿì6/ÿì61ÿì63ÿì65ÿì6Cÿ®6Dÿ×6Fÿ×6Gÿì6Hÿ×6Jÿì6ÿš6 ÿš6Wÿì6Xÿ®6Yÿ×6_ÿì6`ÿ×6bÿì6ÿ®6ÿ×6ÿ®6 ÿ×6!ÿ®6"ÿ×6#ÿ®6%ÿ®6&ÿ×6'ÿ®6(ÿ×6)ÿ®6*ÿ×6+ÿ®6,ÿ×6-ÿ®6.ÿ×6/ÿ®60ÿ×61ÿ®62ÿ×63ÿ®64ÿ×66ÿ×68ÿ×6:ÿ×6<ÿ×6@ÿ×6Bÿ×6Dÿ×6Iÿì6Jÿ×6Kÿì6Lÿ×6Mÿì6Nÿ×6Oÿì6Qÿì6Rÿ×6Sÿì6Tÿ×6Uÿì6Vÿ×6Wÿì6Xÿ×6Yÿì6Zÿ×6[ÿì6\ÿ×6]ÿì6^ÿ×6_ÿì6`ÿ×6bÿì6dÿì6fÿì6hÿì6jÿì6lÿì6nÿì7R7 R7ÿ®7ÿ®7")7R7ÿ®7 R7 ÿ®8ÿ…8ÿ…8")8$ÿ…8&ÿ×8*ÿ×82ÿ×84ÿ×8Dÿš8Fÿš8Gÿš8Hÿš8Jÿ×8PÿÃ8QÿÃ8Rÿš8SÿÃ8Tÿš8UÿÃ8Vÿ®8XÿÃ8]ÿ×8‚ÿ…8ƒÿ…8„ÿ…8…ÿ…8†ÿ…8‡ÿ…8‰ÿ×8”ÿ×8•ÿ×8–ÿ×8—ÿ×8˜ÿ×8šÿ×8¢ÿš8£ÿš8¤ÿš8¥ÿš8¦ÿš8§ÿš8¨ÿš8©ÿš8ªÿš8«ÿš8¬ÿš8­ÿš8´ÿš8µÿš8¶ÿš8·ÿš8¸ÿš8ºÿš8»ÿÃ8¼ÿÃ8½ÿÃ8¾ÿÃ8Âÿ…8Ãÿš8Äÿ…8Åÿš8Æÿ…8Çÿš8Èÿ×8Éÿš8Êÿ×8Ëÿš8Ìÿ×8Íÿš8Îÿ×8Ïÿš8Ñÿš8Óÿš8Õÿš8×ÿš8Ùÿš8Ûÿš8Ýÿš8Þÿ×8ßÿ×8àÿ×8áÿ×8âÿ×8ãÿ×8äÿ×8åÿ×8úÿÃ8ÿÃ8ÿÃ8 ÿÃ8ÿ×8ÿš8ÿ×8ÿš8ÿ×8ÿš8ÿ×8ÿš8ÿÃ8ÿÃ8ÿ®8!ÿ®8+ÿÃ8-ÿÃ8/ÿÃ81ÿÃ83ÿÃ85ÿÃ8<ÿ×8>ÿ×8@ÿ×8Cÿ…8Dÿš8Fÿš8Gÿ×8Hÿš8Jÿ®8ÿ…8 ÿ…8WÿÃ8Xÿ…8Yÿš8_ÿ×8`ÿš8bÿÃ8ÿ…8ÿš8ÿ…8 ÿš8!ÿ…8"ÿš8#ÿ…8%ÿ…8&ÿš8'ÿ…8(ÿš8)ÿ…8*ÿš8+ÿ…8,ÿš8-ÿ…8.ÿš8/ÿ…80ÿš81ÿ…82ÿš83ÿ…84ÿš86ÿš88ÿš8:ÿš8<ÿš8@ÿš8Bÿš8Dÿš8Iÿ×8Jÿš8Kÿ×8Lÿš8Mÿ×8Nÿš8Oÿ×8Qÿ×8Rÿš8Sÿ×8Tÿš8Uÿ×8Vÿš8Wÿ×8Xÿš8Yÿ×8Zÿš8[ÿ×8\ÿš8]ÿ×8^ÿš8_ÿ×8`ÿš8bÿÃ8dÿÃ8fÿÃ8hÿÃ8jÿÃ8lÿÃ8nÿÃ9R9 R9ÿ®9ÿ®9")9R9ÿ®9 R9 ÿ®:ÿ…:ÿ…:"):$ÿ…:&ÿ×:*ÿ×:2ÿ×:4ÿ×:Dÿš:Fÿš:Gÿš:Hÿš:Jÿ×:PÿÃ:QÿÃ:Rÿš:SÿÃ:Tÿš:UÿÃ:Vÿ®:XÿÃ:]ÿ×:‚ÿ…:ƒÿ…:„ÿ…:…ÿ…:†ÿ…:‡ÿ…:‰ÿ×:”ÿ×:•ÿ×:–ÿ×:—ÿ×:˜ÿ×:šÿ×:¢ÿš:£ÿš:¤ÿš:¥ÿš:¦ÿš:§ÿš:¨ÿš:©ÿš:ªÿš:«ÿš:¬ÿš:­ÿš:´ÿš:µÿš:¶ÿš:·ÿš:¸ÿš:ºÿš:»ÿÃ:¼ÿÃ:½ÿÃ:¾ÿÃ:Âÿ…:Ãÿš:Äÿ…:Åÿš:Æÿ…:Çÿš:Èÿ×:Éÿš:Êÿ×:Ëÿš:Ìÿ×:Íÿš:Îÿ×:Ïÿš:Ñÿš:Óÿš:Õÿš:×ÿš:Ùÿš:Ûÿš:Ýÿš:Þÿ×:ßÿ×:àÿ×:áÿ×:âÿ×:ãÿ×:äÿ×:åÿ×:úÿÃ:ÿÃ:ÿÃ: ÿÃ:ÿ×:ÿš:ÿ×:ÿš:ÿ×:ÿš:ÿ×:ÿš:ÿÃ:ÿÃ:ÿ®:!ÿ®:+ÿÃ:-ÿÃ:/ÿÃ:1ÿÃ:3ÿÃ:5ÿÃ:<ÿ×:>ÿ×:@ÿ×:Cÿ…:Dÿš:Fÿš:Gÿ×:Hÿš:Jÿ®:ÿ…: ÿ…:WÿÃ:Xÿ…:Yÿš:_ÿ×:`ÿš:bÿÃ:ÿ…:ÿš:ÿ…: ÿš:!ÿ…:"ÿš:#ÿ…:%ÿ…:&ÿš:'ÿ…:(ÿš:)ÿ…:*ÿš:+ÿ…:,ÿš:-ÿ…:.ÿš:/ÿ…:0ÿš:1ÿ…:2ÿš:3ÿ…:4ÿš:6ÿš:8ÿš::ÿš:<ÿš:@ÿš:Bÿš:Dÿš:Iÿ×:Jÿš:Kÿ×:Lÿš:Mÿ×:Nÿš:Oÿ×:Qÿ×:Rÿš:Sÿ×:Tÿš:Uÿ×:Vÿš:Wÿ×:Xÿš:Yÿ×:Zÿš:[ÿ×:\ÿš:]ÿ×:^ÿš:_ÿ×:`ÿš:bÿÃ:dÿÃ:fÿÃ:hÿÃ:jÿÃ:lÿÃ:nÿÃ;&ÿì;*ÿì;2ÿì;4ÿì;‰ÿì;”ÿì;•ÿì;–ÿì;—ÿì;˜ÿì;šÿì;Èÿì;Êÿì;Ìÿì;Îÿì;Þÿì;àÿì;âÿì;äÿì;ÿì;ÿì;ÿì;ÿì;Gÿì;_ÿì;Iÿì;Kÿì;Mÿì;Oÿì;Qÿì;Sÿì;Uÿì;Wÿì;Yÿì;[ÿì;]ÿì;_ÿì=&ÿì=*ÿì=2ÿì=4ÿì=‰ÿì=”ÿì=•ÿì=–ÿì=—ÿì=˜ÿì=šÿì=Èÿì=Êÿì=Ìÿì=Îÿì=Þÿì=àÿì=âÿì=äÿì=ÿì=ÿì=ÿì=ÿì=Gÿì=_ÿì=Iÿì=Kÿì=Mÿì=Oÿì=Qÿì=Sÿì=Uÿì=Wÿì=Yÿì=[ÿì=]ÿì=_ÿì?&ÿì?*ÿì?2ÿì?4ÿì?‰ÿì?”ÿì?•ÿì?–ÿì?—ÿì?˜ÿì?šÿì?Èÿì?Êÿì?Ìÿì?Îÿì?Þÿì?àÿì?âÿì?äÿì?ÿì?ÿì?ÿì?ÿì?Gÿì?_ÿì?Iÿì?Kÿì?Mÿì?Oÿì?Qÿì?Sÿì?Uÿì?Wÿì?Yÿì?[ÿì?]ÿì?_ÿìCÿqC ÿqC&ÿ×C*ÿ×C- C2ÿ×C4ÿ×C7ÿqC9ÿ®C:ÿ®C<ÿ…C‰ÿ×C”ÿ×C•ÿ×C–ÿ×C—ÿ×C˜ÿ×Cšÿ×CŸÿ…CÈÿ×CÊÿ×CÌÿ×CÎÿ×CÞÿ×Càÿ×Câÿ×Cäÿ×Cÿ×Cÿ×Cÿ×Cÿ×C$ÿqC&ÿqC6ÿ®C8ÿ…C:ÿ…CGÿ×Cúÿ®Cüÿ®Cþÿ®Cÿ…CÿqC ÿqC_ÿ×CIÿ×CKÿ×CMÿ×COÿ×CQÿ×CSÿ×CUÿ×CWÿ×CYÿ×C[ÿ×C]ÿ×C_ÿ×Coÿ…Cqÿ…Csÿ…CÿqDÿìD ÿìDÿìD ÿìE-{Gÿ®Gÿ®G$ÿ×G7ÿÃG9ÿìG:ÿìG;ÿ×G<ÿìG=ÿìG‚ÿ×Gƒÿ×G„ÿ×G…ÿ×G†ÿ×G‡ÿ×GŸÿìGÂÿ×GÄÿ×GÆÿ×G$ÿÃG&ÿÃG6ÿìG8ÿìG:ÿìG;ÿìG=ÿìG?ÿìGCÿ×G ÿìGúÿìGüÿìGþÿìGÿìGÿ®G ÿ®GXÿ×Gÿ×Gÿ×G!ÿ×G#ÿ×G%ÿ×G'ÿ×G)ÿ×G+ÿ×G-ÿ×G/ÿ×G1ÿ×G3ÿ×GoÿìGqÿìGsÿìGÿÃVÿqV ÿqVfÿ×Vmÿ×VqÿqVrÿ…Vsÿ×Vuÿ®Vxÿ…VÿqV ÿqVTÿ…[ÿ®[ÿ®[Vÿ×[_ÿ×[bÿ×[dÿì[iÿ×[pÿì[qÿÃ[rÿì[tÿ×[uÿì[xÿì[ˆÿì[ÿ®[ ÿ®[Tÿì\ÿ…\ÿ…\Vÿ…\_ÿ…\bÿ…\fÿ×\iÿ…\mÿ×\sÿÃ\vÿì\yÿš\zÿ®\{ÿÃ\|ÿÃ\}ÿÃ\~ÿš\ÿÃ\‚ÿ®\„ÿÃ\†ÿÃ\‡ÿÃ\‰ÿÃ\Œÿš\Žÿš\ÿš\ÿš\’ÿÃ\“ÿš\•ÿÃ\–ÿÃ\˜ÿÃ\™ÿš\šÿÃ\›ÿÃ\ÿ…\ ÿ…\!ÿì]qÿ×]rÿì]xÿì]Tÿì^ÿ×^ ÿ×^ÿ×^ ÿ×_ÿq_ ÿq_fÿ×_mÿ×_qÿq_rÿ…_sÿ×_uÿ®_xÿ…_ÿq_ ÿq_Tÿ…`ÿ®`ÿ®`Vÿ×`_ÿ×`bÿ×`iÿ×`tÿ×`ÿ®` ÿ®aÿ…aÿ®aÿ…aVÿ\a_ÿ\abÿ\afÿÃaiÿ\amÿÃasÿšavÿÃayÿqazÿša{ÿša|ÿ®a}ÿša~ÿqa€ÿ×aÿÃa‚ÿša„ÿša†ÿ®a‡ÿša‰ÿšaŠÿ×aŒÿqaŽÿšaÿqaÿqa’ÿša“ÿqa”ÿ×a•ÿša–ÿša˜ÿša™ÿqašÿša›ÿšaÿ®aÿ®aÿ®aÿ…a ÿ…a!ÿÃaSÿ×bÿqb ÿqbfÿ×bmÿ×bqÿqbrÿ…bsÿ×buÿ®bxÿ…bÿqb ÿqbTÿ…dfÿìdmÿìdsÿÃfÿ®fÿ®fVÿ×f_ÿ×fbÿ×fdÿìfiÿ×fpÿìfqÿÃfrÿìftÿ×fuÿìfxÿìfˆÿìfÿ®f ÿ®fTÿìhfÿ×hmÿ×hsÿÃhÿìh‘ÿìiÿqi ÿqifÿ×imÿ×iqÿqirÿ…isÿ×iuÿ®ixÿ…iÿqi ÿqiTÿ…mÿ®mÿ®mVÿ×m_ÿ×mbÿ×mdÿìmiÿ×mpÿìmqÿÃmrÿìmtÿ×muÿìmxÿìmˆÿìmÿ®m ÿ®mTÿìoþöoþöoVÿšo_ÿšobÿšodÿìoiÿšotÿ×oˆÿ×oþöo þöqÿ…qÿ®qÿ…qVÿ\q_ÿ\qbÿ\qfÿÃqiÿ\qmÿÃqsÿšqvÿÃqyÿqqzÿšq{ÿšq|ÿ®q}ÿšq~ÿqq€ÿ×qÿÃq‚ÿšq„ÿšq†ÿ®q‡ÿšq‰ÿšqŠÿ×qŒÿqqŽÿšqÿqqÿqq’ÿšq“ÿqq”ÿ×q•ÿšq–ÿšq˜ÿšq™ÿqqšÿšq›ÿšqÿ®qÿ®qÿ®qÿ…q ÿ…q!ÿÃqSÿ×rÿ…rÿ…rVÿ…r_ÿ…rbÿ…rfÿ×riÿ…rmÿ×rsÿÃrvÿìryÿšrzÿ®r{ÿÃr|ÿÃr}ÿÃr~ÿšrÿÃr‚ÿ®r„ÿÃr†ÿÃr‡ÿÃr‰ÿÃrŒÿšrŽÿšrÿšrÿšr’ÿÃr“ÿšr•ÿÃr–ÿÃr˜ÿÃr™ÿšršÿÃr›ÿÃrÿ…r ÿ…r!ÿìsÿšsÿšsVÿ×s_ÿ×sbÿ×sdÿÃsiÿ×spÿìsqÿ®srÿÃstÿìsxÿÃsˆÿìsÿšs ÿšsTÿÃtfÿ×tmÿ×tsÿÃtÿìt‘ÿìuÿ…uÿ…uVÿ®u_ÿ®ubÿ®ufÿìuiÿ®umÿìuÿ…u ÿ…vqÿ×vrÿìvxÿìvTÿìxÿ…xÿ…xVÿ…x_ÿ…xbÿ…xfÿ×xiÿ…xmÿ×xsÿÃxvÿìxyÿšxzÿ®x{ÿÃx|ÿÃx}ÿÃx~ÿšxÿÃx‚ÿ®x„ÿÃx†ÿÃx‡ÿÃx‰ÿÃxŒÿšxŽÿšxÿšxÿšx’ÿÃx“ÿšx•ÿÃx–ÿÃx˜ÿÃx™ÿšxšÿÃx›ÿÃxÿ…x ÿ…x!ÿìyˆ){ÿì{ ÿì{ÿì{ ÿì|ÿ®| ÿ®|ÿì|‘ÿì|ÿ®| ÿ®~ˆ)€ÿ®€ÿ®€ˆÿì€ÿ®€ ÿ®ƒÿšƒyÿ׃~ÿ׃ÿ׃Œÿ׃ÿ׃ÿ׃ÿ׃‘ÿ׃“ÿ׃™ÿ׃ÿšƒÿšƒÿš„ÿì„ ÿì„ÿì„ ÿì…ÿ×…ÿ×…ÿ×… ÿ׆ÿ®† ÿ®†ÿ솑ÿì†ÿ®† ÿ®‡yÿׇ~ÿׇŒÿׇÿׇÿׇ“ÿׇ™ÿ׈ÿ…ˆ ÿ…ˆyÿìˆ~ÿ숀ÿ׈Šÿ׈Œÿìˆÿ׈ÿìˆÿ숑ÿ׈“ÿ숙ÿìˆÿ…ˆ ÿ…Šÿ®Šÿ®ŠˆÿìŠÿ®Š ÿ®ŒÿìŒ ÿ쌀ÿ׌Šÿ׌ÿìŒ ÿìŽÿìŽ ÿ쎀ÿ׎Šÿ׎ÿìŽ ÿìÿìÿìÿì ÿì“ÿì“ ÿì“€ÿדŠÿדÿì“ ÿì”ÿÔÿ×”ÿÔyÿ×”~ÿ×”ÿ×”Œÿ×”ÿ×”ÿ×”“ÿ×”™ÿ×”ÿ×”ÿ×”ÿ×”ÿÔ ÿ×ÿ×— ÿ×—ÿ×— ÿ×™ÿì™ ÿ와ÿ×™Šÿ×™ÿì™ ÿìÿ® ÿ®ÿ…¦ÿ…¨ÿ×¼ÿš½ÿ×ÁÿšÄÿ…Üÿ×Ýÿ×áÿ×äÿ×öÿ×ÿ® ÿ®nÿ®|ÿš€ÿ®‚ÿ®—ÿ®›ÿ®§ÿ®©ÿ…ªÿ×µÿš¶ÿ×·ÿš¸ÿ×¹ÿšºÿ×½ÿ…¾ÿ׿ÿšÀÿ×ÁÿšÂÿ×ÔÿšÕÿ×÷ÿ×øÿ×ùÿ×úÿ×ûÿ×üÿ×ýÿšþÿ×ÿ® ÿšÿÃÿšÿÃÿ…ÿמÿ…žÿ®žÿ…žŸÿמ¤ÿšžªÿqž®ÿšžµÿšž¸ÿמ»ÿמ¼)ž¾ÿ®žÌÿšžÍÿšžÎÿ…žÏÿqžÐÿמÑÿמÒÿšžÓÿšžÔÿšžÕÿ…žÖÿšž×ÿšžØÿqžÙÿšžÚÿšžÛÿqžÜÿ®žÝÿ®žÞÿqžßÿמàÿšžáÿšžâÿšžãÿšžäÿ®žåÿšžæÿšžçÿמèÿšžéÿÞêÿqžìÿšžíÿqžîÿ…žòÿ…žóÿšžõÿšžöÿ®ž÷ÿšžùÿšžÿ®žÿ®žÿ®žÿ…ž ÿ…žjÿqžkÿšžlÿמmÿמqÿšžrÿqžsÿ…žuÿšžwÿšžyÿšž}ÿšž~ÿמÿqžÿמƒÿמ„ÿמ…ÿqž†ÿמ‡ÿqžˆÿמ‰ÿqžŠÿמ‹ÿמŒÿמÿqž–ÿšžšÿšžžÿšž ÿמ¢ÿמ¤ÿšž¦ÿšžªÿ®ž¬ÿšž®ÿšž°ÿšž±ÿמ²ÿqž³ÿמ´ÿqžµ)ž¶ÿ®ž¸ÿ®žºÿ®ž¼ÿמ¾ÿ®žÀÿšžÂÿšžÄÿšžÅÿšžÆÿqžÇÿšžÈÿqžËÿמÍÿšžÎÿšžÏÿ…žÑÿšžÓÿšžÕÿšž×ÿšžÙÿqžÛÿqžÝÿqžàÿqžæÿמèÿמêÿÞìÿšžîÿšžïÿמðÿqžñÿמòÿqžóÿמôÿqžöÿמøÿ®žúÿ®žüÿ®žþÿšžÿšžÿšžÿמÿמ ÿqž ÿqž ÿqž ÿqžÿšžÿšžÿšžÿ…žÿšžÿמÿqžÿ®žÿqžÿšžÿ…ŸŸÿן¸ÿן»ÿן¾ÿןáÿןlÿן~ÿן„ÿן†ÿןˆÿןŠÿןŒÿן±ÿן³ÿןÀÿןÂÿןÅÿןÇÿןÕÿןïÿןñÿןóÿןþÿן ÿן ÿןÿןÿןÿ× ÿ× ÿפÿ®¤ ÿ®¤ÿ…¤¦ÿ…¤¨ÿפ¼ÿš¤½ÿפÁÿš¤Äÿ…¤ÜÿפÝÿפáÿפäÿפöÿפÿ®¤ ÿ®¤nÿ®¤|ÿš¤€ÿ®¤‚ÿ®¤—ÿ®¤›ÿ®¤§ÿ®¤©ÿ…¤ªÿפµÿš¤¶ÿפ·ÿš¤¸ÿפ¹ÿš¤ºÿפ½ÿ…¤¾ÿפ¿ÿš¤ÀÿפÁÿš¤ÂÿפÔÿš¤Õÿפ÷ÿפøÿפùÿפúÿפûÿפüÿפýÿš¤þÿפÿ®¤ ÿš¤ÿäÿš¤ÿäÿ…¤ÿ×¥ÿ®¥ ÿ®¥ÿ…¥¦ÿ…¥¨ÿ×¥¼ÿš¥½ÿ×¥Áÿš¥Äÿ…¥Üÿ×¥Ýÿ×¥áÿ×¥äÿ×¥öÿ×¥ÿ®¥ ÿ®¥nÿ®¥|ÿš¥€ÿ®¥‚ÿ®¥—ÿ®¥›ÿ®¥§ÿ®¥©ÿ…¥ªÿ×¥µÿš¥¶ÿ×¥·ÿš¥¸ÿ×¥¹ÿš¥ºÿ×¥½ÿ…¥¾ÿ×¥¿ÿš¥Àÿ×¥Áÿš¥Âÿ×¥Ôÿš¥Õÿ×¥÷ÿ×¥øÿ×¥ùÿ×¥úÿ×¥ûÿ×¥üÿ×¥ýÿš¥þÿ×¥ÿ®¥ ÿš¥ÿÃ¥ÿš¥ÿÃ¥ÿ…¥ÿצÿ®¦ ÿ®¦ÿ…¦¦ÿ…¦¨ÿצ¼ÿš¦½ÿצÁÿš¦Äÿ…¦ÜÿצÝÿצáÿצäÿצöÿצÿ®¦ ÿ®¦nÿ®¦|ÿš¦€ÿ®¦‚ÿ®¦—ÿ®¦›ÿ®¦§ÿ®¦©ÿ…¦ªÿצµÿš¦¶ÿצ·ÿš¦¸ÿצ¹ÿš¦ºÿצ½ÿ…¦¾ÿצ¿ÿš¦ÀÿצÁÿš¦ÂÿצÔÿš¦Õÿצ÷ÿצøÿצùÿצúÿצûÿצüÿצýÿš¦þÿצÿ®¦ ÿš¦ÿæÿš¦ÿæÿ…¦ÿקŸÿק¸ÿק»ÿק¾ÿקÁÿקáÿקlÿק|ÿק~ÿק„ÿק†ÿקˆÿקŠÿקŒÿק±ÿק³ÿק¿ÿקÀÿקÁÿקÂÿקÅÿš§Çÿš§ÔÿקÕÿקïÿקñÿקóÿקýÿקþÿק ÿק ÿקÿקÿקÿקÿì¨ÿ…¨ÿ…¨Ÿÿ쨤ÿš¨ªÿq¨®ÿš¨µÿš¨¸ÿ쨻ÿ쨾ÿèÉÿì¨Îÿ®¨ÏÿרÕÿ®¨ØÿרÛÿרÞÿרáÿרêÿרëf¨íÿרîÿì¨òÿ®¨ôf¨ÿ…¨ ÿ…¨jÿרlÿì¨rÿq¨sÿ®¨~ÿì¨ÿר„ÿ쨅ÿר†ÿ쨇ÿרˆÿ쨉ÿרŠÿ쨌ÿì¨ÿר˜f¨¨f¨±ÿ쨲ÿר³ÿ쨴ÿרÀÿרÂÿרÅÿרÆÿèÇÿרÈÿèÎÿš¨Ïÿ®¨ÕÿרÙÿq¨Ûÿq¨Ýÿq¨àÿרïÿì¨ðÿרñÿì¨òÿרóÿì¨ôÿרþÿר ÿq¨ ÿר ÿq¨ ÿרÿš¨ÿ®¨ÿì¨ÿרÿרÿš¨ÿ®ªÿqª ÿqªÿšª¦ÿšª¼ÿqª¾ÿתÁÿšªÄÿšªÜÿתáÿתäÿתÿqª ÿqªnÿת|ÿšª€ÿ®ª‚ÿ®ª—ÿת›ÿת§ÿת©ÿšªªÿתµÿqª¶ÿת·ÿ…ª¹ÿ…ª½ÿšª¾ÿת¿ÿšªÀÿתÁÿšªÂÿתÅÿšªÇÿšªÔÿšªÕÿתáÿתãÿתýÿšªþÿתÿת ÿqªÿתÿqªÿתÿšªÿ׫ÿ׫ ÿ׫ªÿì«Áÿ׫ÿ׫ ÿ׫rÿì«|ÿ׫¿ÿ׫Áÿ׫Åÿ׫Çÿ׫Ôÿ׫Ùÿì«Ûÿì«Ýÿì«ýÿ׬ÿ®¬ÿ®¬ÿ®¬ ÿ®¬€ÿ쬂ÿ쬷ÿ쬹ÿì¬ ÿ׬ÿ×­ÿ…­ÿ®­ÿ…­Ÿÿ×­¤ÿš­ªÿq­®ÿš­µÿš­¸ÿ×­»ÿ×­¼)­¾ÿ®­Ìÿš­Íÿš­Îÿ…­Ïÿq­Ðÿ×­Ñÿ×­Òÿš­Óÿš­Ôÿš­Õÿ…­Öÿš­×ÿš­Øÿq­Ùÿš­Úÿš­Ûÿq­Üÿ®­Ýÿ®­Þÿq­ßÿ×­àÿš­áÿš­âÿš­ãÿš­äÿ®­åÿš­æÿš­çÿ×­èÿš­éÿíêÿq­ìÿš­íÿq­îÿ…­òÿ…­óÿš­õÿš­öÿ®­÷ÿš­ùÿš­ÿ®­ÿ®­ÿ®­ÿ…­ ÿ…­jÿq­kÿš­lÿ×­mÿ×­qÿš­rÿq­sÿ…­uÿš­wÿš­yÿš­}ÿš­~ÿ×­ÿq­ÿ×­ƒÿ×­„ÿ×­…ÿq­†ÿ×­‡ÿq­ˆÿ×­‰ÿq­Šÿ×­‹ÿ×­Œÿ×­ÿq­–ÿš­šÿš­žÿš­ ÿ×­¢ÿ×­¤ÿš­¦ÿš­ªÿ®­¬ÿš­®ÿš­°ÿš­±ÿ×­²ÿq­³ÿ×­´ÿq­µ)­¶ÿ®­¸ÿ®­ºÿ®­¼ÿ×­¾ÿ®­Àÿš­Âÿš­Äÿš­Åÿš­Æÿq­Çÿš­Èÿq­Ëÿ×­Íÿš­Îÿš­Ïÿ…­Ñÿš­Óÿš­Õÿš­×ÿš­Ùÿq­Ûÿq­Ýÿq­àÿq­æÿ×­èÿ×­êÿíìÿš­îÿš­ïÿ×­ðÿq­ñÿ×­òÿq­óÿ×­ôÿq­öÿ×­øÿ®­úÿ®­üÿ®­þÿš­ÿš­ÿš­ÿ×­ÿ×­ ÿq­ ÿq­ ÿq­ ÿq­ÿš­ÿš­ÿš­ÿ…­ÿš­ÿ×­ÿq­ÿ®­ÿq­ÿš­ÿ…®£á®ê)®ÿ×®ÿ×°Ÿÿ×°¸ÿ×°»ÿ×°¾ÿ×°Áÿ×°áÿ×°lÿ×°|ÿ×°~ÿ×°„ÿ×°†ÿ×°ˆÿ×°Šÿ×°Œÿ×°±ÿ×°³ÿ×°¿ÿ×°Àÿ×°Áÿ×°Âÿ×°Åÿš°Çÿš°Ôÿ×°Õÿ×°ïÿ×°ñÿ×°óÿ×°ýÿ×°þÿ×° ÿ×° ÿ×°ÿ×°ÿ×°ÿ×°ÿì±ÿ®±ÿ®±ÿ®± ÿ®±€ÿ챂ÿì±·ÿì±¹ÿì± ÿ×±ÿ×´Ÿÿ×´¸ÿ×´»ÿ×´¾ÿ×´Áÿ×´áÿ×´lÿ×´|ÿ×´~ÿ×´„ÿ×´†ÿ×´ˆÿ×´Šÿ×´Œÿ×´±ÿ×´³ÿ×´¿ÿ×´Àÿ×´Áÿ×´Âÿ×´Åÿš´Çÿš´Ôÿ×´Õÿ×´ïÿ×´ñÿ×´óÿ×´ýÿ×´þÿ×´ ÿ×´ ÿ×´ÿ×´ÿ×´ÿ×´ÿì¸ÿ®¸ÿ®¸ÿ츤ÿ׸¦ÿ츨ÿ׸ªÿ׸®ÿ׸°ÿ׸±ÿ층ÿ׸¼ÿø½ÿ׸¿ÿ׸Áÿ׸Äÿì¸Çÿì¸Îÿì¸Õÿì¸òÿì¸ÿ®¸ ÿ®¸rÿ׸sÿì¸zÿì¸|ÿ׸€ÿ츂ÿ츟ÿ׸¡ÿ츩ÿ층ÿø·ÿ츹ÿ츻ÿ׸½ÿ츿ÿ׸Áÿ׸Êÿ׸Îÿ׸Ïÿì¸Ôÿ׸Ùÿ׸Ûÿ׸Ýÿ׸åÿ׸çÿì¸õÿì¸÷ÿ׸ùÿ׸ûÿ׸ýÿ׸ÿ׸ÿ׸ ÿ׸ÿ׸ÿ׸ÿì¸ÿì¸ÿ׸ÿìºþöºþöº¤ÿ…ºªÿšº®ÿ…º°ÿ׺µÿ…º¿ÿ׺ÎÿšºÕÿšºòÿšºþöº þöºrÿšºsÿšºvÿ캟ÿ׺»ÿ׺Êÿ׺Îÿ…ºÏÿšºÙÿšºÛÿšºÝÿšºåÿ׺ÿ׺ÿ׺ ÿ®º ÿ®ºÿ…ºÿšºÿ…ºÿš»Ÿÿ×»¸ÿ×»»ÿ×»¾ÿ×»áÿ×»lÿ×»~ÿ×»„ÿ×»†ÿ×»ˆÿ×»Šÿ×»Œÿ×»±ÿ×»³ÿ×»Àÿ×»Âÿ×»Åÿ×»Çÿ×»Õÿ×»ïÿ×»ñÿ×»óÿ×»þÿ×» ÿ×» ÿ×»ÿ×»ÿ×»ÿ×¼ÿ…¼ÿ®¼ÿ…¼Ÿÿ×¼¤ÿš¼ªÿq¼®ÿš¼µÿš¼¸ÿ×¼»ÿ×¼¼)¼¾ÿ®¼Ìÿš¼Íÿš¼Îÿ…¼Ïÿq¼Ðÿ×¼Ñÿ×¼Òÿš¼Óÿš¼Ôÿš¼Õÿ…¼Öÿš¼×ÿš¼Øÿq¼Ùÿš¼Úÿš¼Ûÿq¼Üÿ®¼Ýÿ®¼Þÿq¼ßÿ×¼àÿš¼áÿš¼âÿš¼ãÿš¼äÿ®¼åÿš¼æÿš¼çÿ×¼èÿš¼éÿüêÿq¼ìÿš¼íÿq¼îÿ…¼òÿ…¼óÿš¼õÿš¼öÿ®¼÷ÿš¼ùÿš¼ÿ®¼ÿ®¼ÿ®¼ÿ…¼ ÿ…¼jÿq¼kÿš¼lÿ×¼mÿ×¼qÿš¼rÿq¼sÿ…¼uÿš¼wÿš¼yÿš¼}ÿš¼~ÿ×¼ÿq¼ÿ×¼ƒÿ×¼„ÿ×¼…ÿq¼†ÿ×¼‡ÿq¼ˆÿ×¼‰ÿq¼Šÿ×¼‹ÿ×¼Œÿ×¼ÿq¼–ÿš¼šÿš¼žÿš¼ ÿ×¼¢ÿ×¼¤ÿš¼¦ÿš¼ªÿ®¼¬ÿš¼®ÿš¼°ÿš¼±ÿ×¼²ÿq¼³ÿ×¼´ÿq¼µ)¼¶ÿ®¼¸ÿ®¼ºÿ®¼¼ÿ×¼¾ÿ®¼Àÿš¼Âÿš¼Äÿš¼Åÿš¼Æÿq¼Çÿš¼Èÿq¼Ëÿ×¼Íÿš¼Îÿš¼Ïÿ…¼Ñÿš¼Óÿš¼Õÿš¼×ÿš¼Ùÿq¼Ûÿq¼Ýÿq¼àÿq¼æÿ×¼èÿ×¼êÿüìÿš¼îÿš¼ïÿ×¼ðÿq¼ñÿ×¼òÿq¼óÿ×¼ôÿq¼öÿ×¼øÿ®¼úÿ®¼üÿ®¼þÿš¼ÿš¼ÿš¼ÿ×¼ÿ×¼ ÿq¼ ÿq¼ ÿq¼ ÿq¼ÿš¼ÿš¼ÿš¼ÿ…¼ÿš¼ÿ×¼ÿq¼ÿ®¼ÿq¼ÿš¼ÿ…½ÿ…½ÿ…½Ÿÿ콤ÿš½ªÿq½®ÿš½µÿš½¸ÿì½»ÿì½¾ÿýÉÿì½Îÿ®½Ïÿ×½Õÿ®½Øÿ×½Ûÿ×½Þÿ×½áÿ×½êÿ×½ëf½íÿ×½îÿì½òÿ®½ôf½ÿ…½ ÿ…½jÿ×½lÿì½rÿq½sÿ®½~ÿì½ÿ×½„ÿì½…ÿ×½†ÿ콇ÿ×½ˆÿ콉ÿ×½Šÿ콌ÿì½ÿ×½˜f½¨f½±ÿì½²ÿ×½³ÿì½´ÿ×½Àÿ×½Âÿ×½Åÿ×½ÆÿýÇÿ×½ÈÿýÎÿš½Ïÿ®½Õÿ×½Ùÿq½Ûÿq½Ýÿq½àÿ×½ïÿì½ðÿ×½ñÿì½òÿ×½óÿì½ôÿ×½þÿ×½ ÿq½ ÿ×½ ÿq½ ÿ×½ÿš½ÿ®½ÿì½ÿ×½ÿ×½ÿš½ÿ®¾ÿ®¾ÿ®¾ÿ×¾¤ÿ×¾¦ÿ×¾¨ÿþªÿ×¾®ÿ×¾°ÿ×¾±ÿ×¾µÿ×¾¼ÿþ½ÿþ¿ÿ×¾Äÿ×¾Çÿ×¾Îÿì¾Õÿì¾òÿì¾ÿ®¾ ÿ®¾rÿ×¾sÿì¾zÿ×¾€ÿ쾂ÿ쾟ÿ×¾¡ÿ×¾©ÿ×¾µÿþ·ÿþ¹ÿþ»ÿ×¾½ÿ×¾Êÿ×¾Îÿ×¾Ïÿì¾Ùÿ×¾Ûÿ×¾Ýÿ×¾åÿ×¾çÿ×¾õÿ×¾÷ÿþùÿþûÿþÿ×¾ÿ×¾ ÿ×¾ÿ×¾ÿ×¾ÿì¾ÿ×¾ÿ×¾ÿì¿Ÿÿ׿¸ÿ׿»ÿ׿¾ÿ׿Áÿ׿áÿ׿lÿ׿|ÿ׿~ÿ׿„ÿ׿†ÿ׿ˆÿ׿Šÿ׿Œÿ׿±ÿ׿³ÿ׿¿ÿ׿Àÿ׿Áÿ׿Âÿ׿Åÿš¿Çÿš¿Ôÿ׿Õÿ׿ïÿ׿ñÿ׿óÿ׿ýÿ׿þÿ׿ ÿ׿ ÿ׿ÿ׿ÿ׿ÿ׿ÿìÀ£áÀê)Àÿ×Àÿ×ãáÃê)Ãÿ×Ãÿ×Äÿ®Ä ÿ®Äÿ…Ħÿ…Ĩÿ×ļÿšÄ½ÿ×ÄÁÿšÄÄÿ…ÄÜÿ×ÄÝÿ×Äáÿ×Ääÿ×Äöÿ×Äÿ®Ä ÿ®Änÿ®Ä|ÿšÄ€ÿ®Ä‚ÿ®Ä—ÿ®Ä›ÿ®Ä§ÿ®Ä©ÿ…Īÿ×ĵÿšÄ¶ÿ×Ä·ÿšÄ¸ÿ×ĹÿšÄºÿ׼ÿ…ľÿ×Ä¿ÿšÄÀÿ×ÄÁÿšÄÂÿ×ÄÔÿšÄÕÿ×Ä÷ÿ×Äøÿ×Äùÿ×Äúÿ×Äûÿ×Äüÿ×ÄýÿšÄþÿ×Äÿ®Ä ÿšÄÿÃÄÿšÄÿÃÄÿ…Äÿ×Æÿ®Æ ÿ®Æÿ…Ʀÿ…ƨÿ×ƼÿšÆ½ÿ×ÆÁÿšÆÄÿ…ÆÜÿ×ÆÝÿ×Æáÿ×Æäÿ×Æöÿ×Æÿ®Æ ÿ®Ænÿ®Æ|ÿšÆ€ÿ®Æ‚ÿ®Æ—ÿ®Æ›ÿ®Æ§ÿ®Æ©ÿ…ƪÿ×ƵÿšÆ¶ÿ×Æ·ÿšÆ¸ÿ×ƹÿšÆºÿ×ƽÿ…ƾÿ×Æ¿ÿšÆÀÿ×ÆÁÿšÆÂÿ×ÆÔÿšÆÕÿ×Æ÷ÿ×Æøÿ×Æùÿ×Æúÿ×Æûÿ×Æüÿ×ÆýÿšÆþÿ×Æÿ®Æ ÿšÆÿÃÆÿšÆÿÃÆÿ…Æÿ×Çÿ®Çÿ®ÇÿìǤÿ×ǦÿìǨÿ×Ǫÿ×Ç®ÿ×Ç°ÿ×DZÿìǵÿ×ǼÿÃǽÿ×Ç¿ÿ×ÇÁÿ×ÇÄÿìÇÇÿìÇÎÿìÇÕÿìÇòÿìÇÿ®Ç ÿ®Çrÿ×ÇsÿìÇzÿìÇ|ÿ×Ç€ÿìÇ‚ÿìÇŸÿ×Ç¡ÿìÇ©ÿìǵÿÃÇ·ÿìǹÿìÇ»ÿ×ǽÿìÇ¿ÿ×ÇÁÿ×ÇÊÿ×ÇÎÿ×ÇÏÿìÇÔÿ×ÇÙÿ×ÇÛÿ×ÇÝÿ×Çåÿ×ÇçÿìÇõÿìÇ÷ÿ×Çùÿ×Çûÿ×Çýÿ×Çÿ×Çÿ×Ç ÿ×Çÿ×Çÿ×ÇÿìÇÿìÇÿ×ÇÿìÈÿ®Èÿ®ÈÿìȤÿ×ȦÿìȨÿ×Ȫÿ×È®ÿ×È°ÿ×ȱÿìȵÿ×ȼÿÃȽÿ×È¿ÿ×ÈÁÿ×ÈÄÿìÈÇÿìÈÎÿìÈÕÿìÈòÿìÈÿ®È ÿ®Èrÿ×ÈsÿìÈzÿìÈ|ÿ×È€ÿìÈ‚ÿìÈŸÿ×È¡ÿìÈ©ÿìȵÿÃÈ·ÿìȹÿìÈ»ÿ×ȽÿìÈ¿ÿ×ÈÁÿ×ÈÊÿ×ÈÎÿ×ÈÏÿìÈÔÿ×ÈÙÿ×ÈÛÿ×ÈÝÿ×Èåÿ×ÈçÿìÈõÿìÈ÷ÿ×Èùÿ×Èûÿ×Èýÿ×Èÿ×Èÿ×È ÿ×Èÿ×Èÿ×ÈÿìÈÿìÈÿ×ÈÿìÊÿìÊ ÿìÊÿìÊ ÿìÌé)ÍÿšÍÿ×ÍÿšÍÎÿÃÍÏÿìÍÕÿÃÍØÿìÍÛÿìÍÞÿìÍêÿìÍíÿìÍòÿÃÍÿ×Íÿ×Íÿ×ÍÿšÍ ÿšÍjÿìÍsÿÃÍÿìÍ…ÿì͇ÿì͉ÿìÍÿìͲÿìÍ´ÿìÍÏÿÃÍàÿìÍðÿìÍòÿìÍôÿìÍ ÿìÍ ÿìÍÿÃÍÿìÍÿìÍÿÃÎÿìÎ ÿìÎÿìÎ ÿìÏÿìÏ ÿìÏÿìÏ ÿìÐÏÿ×ÐØÿ×ÐÛÿ×ÐÞÿ×Ðáÿ×Ðêÿ×Ðíÿ×Ðjÿ×Ðÿ×Ð…ÿ×Їÿ×Љÿ×Ðÿ×вÿ×дÿ×ÐÀÿ×ÐÂÿ×ÐÆÿ×ÐÈÿ×ÐÕÿ×Ðàÿ×Ððÿ×Ðòÿ×Ðôÿ×Ðþÿ×Ð ÿ×Ð ÿ×Ðÿ×Ðÿ×Ñé)ÔÏÿ×ÔØÿ×ÔÛÿ×ÔÞÿ×Ôáÿ×Ôêÿ×Ôíÿ×Ôjÿ×Ôÿ×Ô…ÿ×Ô‡ÿ×Ô‰ÿ×Ôÿ×Ô²ÿ×Ô´ÿ×ÔÀÿ×ÔÂÿ×ÔÆÿ×ÔÈÿ×ÔÕÿ×Ôàÿ×Ôðÿ×Ôòÿ×Ôôÿ×Ôþÿ×Ô ÿ×Ô ÿ×Ôÿ×Ôÿ×ØÿìØ ÿìØÐÿ×ØÜÿìØÝÿìØßÿ×ØáÿìØäÿìØöÿìØÿìØ ÿìØ ÿ×تÿìضÿìؼÿ×ؾÿìØÀÿìØÂÿìØËÿ×ØÕÿìØæÿ×ØøÿìØúÿìØüÿìØþÿìØÿ×Øÿ×ØÿìØÿìØÿìÚÿìÚ ÿìÚÐÿ×ÚÜÿìÚÝÿìÚßÿ×ÚáÿìÚäÿìÚöÿìÚÿìÚ ÿìÚ ÿ×ÚªÿìÚ¶ÿìÚ¼ÿ×Ú¾ÿìÚÀÿìÚÂÿìÚËÿ×ÚÕÿìÚæÿ×ÚøÿìÚúÿìÚüÿìÚþÿìÚÿ×Úÿ×ÚÿìÚÿìÚÿìÜÿšÜÿ×ÜÿšÜÎÿÃÜÏÿìÜÕÿÃÜØÿìÜÛÿìÜÞÿìÜêÿìÜíÿìÜòÿÃÜÿ×Üÿ×Üÿ×ÜÿšÜ ÿšÜjÿìÜsÿÃÜÿìÜ…ÿì܇ÿì܉ÿìÜÿìܲÿìÜ´ÿìÜÏÿÃÜàÿìÜðÿìÜòÿìÜôÿìÜ ÿìÜ ÿìÜÿÃÜÿìÜÿìÜÿÃÝÿ®Ýÿ®ÝÎÿ×ÝÕÿ×Ýòÿ×Ýÿ®Ý ÿ®Ýsÿ×ÝÏÿ×Ýÿ×Ýÿ×ÞÿìÞ ÿìÞÐÿ×ÞÜÿìÞÝÿìÞßÿ×ÞáÿìÞäÿìÞöÿìÞÿìÞ ÿìÞ ÿ×ÞªÿìÞ¶ÿìÞ¼ÿ×Þ¾ÿìÞÀÿìÞÂÿìÞËÿ×ÞÕÿìÞæÿ×ÞøÿìÞúÿìÞüÿìÞþÿìÞÿ×Þÿ×ÞÿìÞÿìÞÿìßÏÿ×ßØÿ×ßÛÿ×ßÞÿ×ßáÿ×ßêÿ×ßíÿ×ßjÿ×ßÿ×ß…ÿ×߇ÿ×߉ÿ×ßÿ×ß²ÿ×ß´ÿ×ßÀÿ×ßÂÿ×ßÆÿ×ßÈÿ×ßÕÿ×ßàÿ×ßðÿ×ßòÿ×ßôÿ×ßþÿ×ß ÿ×ß ÿ×ßÿ×ßÿ×àÿìà ÿìàÿìà ÿìãÿìã ÿìãÿìã ÿìäÿ…ä ÿ…äÐÿ×äÜÿšäÝÿÃäßÿ×äáÿ®ääÿšäöÿÃäÿ…ä ÿ…ämÿ×äÿ×äƒÿ×ä‹ÿ×ä ÿ×äªÿšä¶ÿšä¸ÿÃäºÿÃä¼ÿ×ä¾ÿšäÀÿ®äÂÿ®äÆÿ×äÈÿ×äËÿ×äÕÿ®äæÿ×äêÿ×äøÿÃäúÿÃäüÿÃäþÿ®äÿ×äÿ×äÿšäÿšäÿšæÿ…æ ÿ…æÐÿ×æÜÿšæÝÿÃæßÿ×æáÿ®æäÿšæöÿÃæÿ…æ ÿ…æmÿ×æÿ×æƒÿ×æ‹ÿ×æ ÿ×æªÿšæ¶ÿšæ¸ÿÃæºÿÃæ¼ÿ×æ¾ÿšæÀÿ®æÂÿ®æÆÿ×æÈÿ×æËÿ×æÕÿ®ææÿ×æêÿ×æøÿÃæúÿÃæüÿÃæþÿ®æÿ×æÿ×æÿšæÿšæÿšçÿìç ÿìçÐÿ×çÜÿìçÝÿìçßÿ×çáÿìçäÿìçöÿìçÿìç ÿìç ÿ×çªÿìç¶ÿìç¼ÿ×ç¾ÿìçÀÿìçÂÿìçËÿ×çÕÿìçæÿ×çøÿìçúÿìçüÿìçþÿìçÿ×çÿ×çÿìçÿìçÿìèÿìè ÿìèÐÿ×èÜÿìèÝÿìèßÿ×èáÿìèäÿìèöÿìèÿìè ÿìè ÿ×èªÿìè¶ÿìè¼ÿ×è¾ÿìèÀÿìèÂÿìèËÿ×èÕÿìèæÿ×èøÿìèúÿìèüÿìèþÿìèÿ×èÿ×èÿìèÿìèÿìêÿìê ÿìêÿìê ÿìëÿìë ÿìëÿìë ÿìëÿ×ëÿ×ìÿšìÿ×ìÿšìÎÿÃìÏÿììÕÿÃìØÿììÛÿììÞÿììêÿììíÿììòÿÃìÿ×ìÿ×ìÿ×ìÿšì ÿšìjÿììsÿÃìÿìì…ÿìì‡ÿìì‰ÿììÿìì²ÿìì´ÿììÏÿÃìàÿììðÿììòÿììôÿìì ÿìì ÿììÿÃìÿììÿììÿÃòÿ…ò ÿ…òÐÿ×òÜÿšòÝÿÃòßÿ×òáÿ®òäÿšòöÿÃòÿ…ò ÿ…òmÿ×òÿ×òƒÿ×ò‹ÿ×ò ÿ×òªÿšò¶ÿšò¸ÿÃòºÿÃò¼ÿ×ò¾ÿšòÀÿ®òÂÿ®òÆÿ×òÈÿ×òËÿ×òÕÿ®òæÿ×òêÿ×òøÿÃòúÿÃòüÿÃòþÿ®òÿ×òÿ×òÿšòÿšòÿšóÿ…ó ÿ…óÐÿ×óÜÿšóÝÿÃóßÿ×óáÿ®óäÿšóöÿÃóÿ…ó ÿ…ómÿ×óÿ×óƒÿ×ó‹ÿ×ó ÿ×óªÿšó¶ÿšó¸ÿÃóºÿÃó¼ÿ×ó¾ÿšóÀÿ®óÂÿ®óÆÿ×óÈÿ×óËÿ×óÕÿ®óæÿ×óêÿ×óøÿÃóúÿÃóüÿÃóþÿ®óÿ×óÿ×óÿšóÿšóÿšôÿìô ÿìôÿìô ÿìôÿ×ôÿ×õÏÿ×õØÿ×õÛÿ×õÞÿ×õáÿ×õêÿ×õíÿ×õjÿ×õÿ×õ…ÿ×õ‡ÿ×õ‰ÿ×õÿ×õ²ÿ×õ´ÿ×õÀÿ×õÂÿ×õÆÿ×õÈÿ×õÕÿ×õàÿ×õðÿ×õòÿ×õôÿ×õþÿ×õ ÿ×õ ÿ×õÿ×õÿ×öÿ®öÿ®öÎÿ×öÕÿ×öòÿ×öÿ®ö ÿ®ösÿ×öÏÿ×öÿ×öÿ×øÿ…øÿ®øÿ…øŸÿ×ø¤ÿšøªÿqø®ÿšøµÿšø¸ÿ×ø»ÿ×ø¼)ø¾ÿ®øÌÿšøÍÿšøÎÿ…øÏÿqøÐÿ×øÑÿ×øÒÿšøÓÿšøÔÿšøÕÿ…øÖÿšø×ÿšøØÿqøÙÿšøÚÿšøÛÿqøÜÿ®øÝÿ®øÞÿqøßÿ×øàÿšøáÿšøâÿšøãÿšøäÿ®øåÿšøæÿšøçÿ×øèÿšøéÿÃøêÿqøìÿšøíÿqøîÿ…øòÿ…øóÿšøõÿšøöÿ®ø÷ÿšøùÿšøÿ®øÿ®øÿ®øÿ…ø ÿ…øjÿqøkÿšølÿ×ømÿ×øqÿšørÿqøsÿ…øuÿšøwÿšøyÿšø}ÿšø~ÿ×øÿqøÿ×øƒÿ×ø„ÿ×ø…ÿqø†ÿ×ø‡ÿqøˆÿ×ø‰ÿqøŠÿ×ø‹ÿ×øŒÿ×øÿqø–ÿšøšÿšøžÿšø ÿ×ø¢ÿ×ø¤ÿšø¦ÿšøªÿ®ø¬ÿšø®ÿšø°ÿšø±ÿ×ø²ÿqø³ÿ×ø´ÿqøµ)ø¶ÿ®ø¸ÿ®øºÿ®ø¼ÿ×ø¾ÿ®øÀÿšøÂÿšøÄÿšøÅÿšøÆÿqøÇÿšøÈÿqøËÿ×øÍÿšøÎÿšøÏÿ…øÑÿšøÓÿšøÕÿšø×ÿšøÙÿqøÛÿqøÝÿqøàÿqøæÿ×øèÿ×øêÿÃøìÿšøîÿšøïÿ×øðÿqøñÿ×øòÿqøóÿ×øôÿqøöÿ×øøÿ®øúÿ®øüÿ®øþÿšøÿšøÿšøÿ×øÿ×ø ÿqø ÿqø ÿqø ÿqøÿšøÿšøÿšøÿ…øÿšøÿ×øÿqøÿ®øÿqøÿšøÿ…ùÿšùÿ×ùÿšùÎÿÃùÏÿìùÕÿÃùØÿìùÛÿìùÞÿìùêÿìùíÿìùòÿÃùÿ×ùÿ×ùÿ×ùÿšù ÿšùjÿìùsÿÃùÿìù…ÿìù‡ÿìù‰ÿìùÿìù²ÿìù´ÿìùÏÿÃùàÿìùðÿìùòÿìùôÿìù ÿìù ÿìùÿÃùÿìùÿìùÿÃúÿšúÿšú")ú$ÿ®ú&ÿìú*ÿìú2ÿìú4ÿìúDÿ×úFÿ×úGÿ×úHÿ×úJÿìúPÿìúQÿìúRÿ×úSÿìúTÿ×úUÿìúVÿìúXÿìú‚ÿ®úƒÿ®ú„ÿ®ú…ÿ®ú†ÿ®ú‡ÿ®ú‰ÿìú”ÿìú•ÿìú–ÿìú—ÿìú˜ÿìúšÿìú¢ÿ×ú£ÿ×ú¤ÿ×ú¥ÿ×ú¦ÿ×ú§ÿ×ú¨ÿ×ú©ÿ×úªÿ×ú«ÿ×ú¬ÿ×ú­ÿ×ú´ÿ×úµÿ×ú¶ÿ×ú·ÿ×ú¸ÿ×úºÿ×ú»ÿìú¼ÿìú½ÿìú¾ÿìúÂÿ®úÃÿ×úÄÿ®úÅÿ×úÆÿ®úÇÿ×úÈÿìúÉÿ×úÊÿìúËÿ×úÌÿìúÍÿ×úÎÿìúÏÿ×úÑÿ×úÓÿ×úÕÿ×ú×ÿ×úÙÿ×úÛÿ×úÝÿ×úÞÿìúßÿìúàÿìúáÿìúâÿìúãÿìúäÿìúåÿìúúÿìúÿìúÿìú ÿìúÿìúÿ×úÿìúÿ×úÿìúÿ×úÿìúÿ×úÿìúÿìúÿìú!ÿìú+ÿìú-ÿìú/ÿìú1ÿìú3ÿìú5ÿìúCÿ®úDÿ×úFÿ×úGÿìúHÿ×úJÿìúÿšú ÿšúWÿìúXÿ®úYÿ×ú_ÿìú`ÿ×úbÿìúÿ®úÿ×úÿ®ú ÿ×ú!ÿ®ú"ÿ×ú#ÿ®ú%ÿ®ú&ÿ×ú'ÿ®ú(ÿ×ú)ÿ®ú*ÿ×ú+ÿ®ú,ÿ×ú-ÿ®ú.ÿ×ú/ÿ®ú0ÿ×ú1ÿ®ú2ÿ×ú3ÿ®ú4ÿ×ú6ÿ×ú8ÿ×ú:ÿ×ú<ÿ×ú@ÿ×úBÿ×úDÿ×úIÿìúJÿ×úKÿìúLÿ×úMÿìúNÿ×úOÿìúQÿìúRÿ×úSÿìúTÿ×úUÿìúVÿ×úWÿìúXÿ×úYÿìúZÿ×ú[ÿìú\ÿ×ú]ÿìú^ÿ×ú_ÿìú`ÿ×úbÿìúdÿìúfÿìúhÿìújÿìúlÿìúnÿìûRû Rûÿ®ûÿ®û")ûRûÿ®û Rû ÿ®üÿšüÿšü")ü$ÿ®ü&ÿìü*ÿìü2ÿìü4ÿìüDÿ×üFÿ×üGÿ×üHÿ×üJÿìüPÿìüQÿìüRÿ×üSÿìüTÿ×üUÿìüVÿìüXÿìü‚ÿ®üƒÿ®ü„ÿ®ü…ÿ®ü†ÿ®ü‡ÿ®ü‰ÿìü”ÿìü•ÿìü–ÿìü—ÿìü˜ÿìüšÿìü¢ÿ×ü£ÿ×ü¤ÿ×ü¥ÿ×ü¦ÿ×ü§ÿ×ü¨ÿ×ü©ÿ×üªÿ×ü«ÿ×ü¬ÿ×ü­ÿ×ü´ÿ×üµÿ×ü¶ÿ×ü·ÿ×ü¸ÿ×üºÿ×ü»ÿìü¼ÿìü½ÿìü¾ÿìüÂÿ®üÃÿ×üÄÿ®üÅÿ×üÆÿ®üÇÿ×üÈÿìüÉÿ×üÊÿìüËÿ×üÌÿìüÍÿ×üÎÿìüÏÿ×üÑÿ×üÓÿ×üÕÿ×ü×ÿ×üÙÿ×üÛÿ×üÝÿ×üÞÿìüßÿìüàÿìüáÿìüâÿìüãÿìüäÿìüåÿìüúÿìüÿìüÿìü ÿìüÿìüÿ×üÿìüÿ×üÿìüÿ×üÿìüÿ×üÿìüÿìüÿìü!ÿìü+ÿìü-ÿìü/ÿìü1ÿìü3ÿìü5ÿìüCÿ®üDÿ×üFÿ×üGÿìüHÿ×üJÿìüÿšü ÿšüWÿìüXÿ®üYÿ×ü_ÿìü`ÿ×übÿìüÿ®üÿ×üÿ®ü ÿ×ü!ÿ®ü"ÿ×ü#ÿ®ü%ÿ®ü&ÿ×ü'ÿ®ü(ÿ×ü)ÿ®ü*ÿ×ü+ÿ®ü,ÿ×ü-ÿ®ü.ÿ×ü/ÿ®ü0ÿ×ü1ÿ®ü2ÿ×ü3ÿ®ü4ÿ×ü6ÿ×ü8ÿ×ü:ÿ×ü<ÿ×ü@ÿ×üBÿ×üDÿ×üIÿìüJÿ×üKÿìüLÿ×üMÿìüNÿ×üOÿìüQÿìüRÿ×üSÿìüTÿ×üUÿìüVÿ×üWÿìüXÿ×üYÿìüZÿ×ü[ÿìü\ÿ×ü]ÿìü^ÿ×ü_ÿìü`ÿ×übÿìüdÿìüfÿìühÿìüjÿìülÿìünÿìýRý Rýÿ®ýÿ®ý")ýRýÿ®ý Rý ÿ®þÿšþÿšþ")þ$ÿ®þ&ÿìþ*ÿìþ2ÿìþ4ÿìþDÿ×þFÿ×þGÿ×þHÿ×þJÿìþPÿìþQÿìþRÿ×þSÿìþTÿ×þUÿìþVÿìþXÿìþ‚ÿ®þƒÿ®þ„ÿ®þ…ÿ®þ†ÿ®þ‡ÿ®þ‰ÿìþ”ÿìþ•ÿìþ–ÿìþ—ÿìþ˜ÿìþšÿìþ¢ÿ×þ£ÿ×þ¤ÿ×þ¥ÿ×þ¦ÿ×þ§ÿ×þ¨ÿ×þ©ÿ×þªÿ×þ«ÿ×þ¬ÿ×þ­ÿ×þ´ÿ×þµÿ×þ¶ÿ×þ·ÿ×þ¸ÿ×þºÿ×þ»ÿìþ¼ÿìþ½ÿìþ¾ÿìþÂÿ®þÃÿ×þÄÿ®þÅÿ×þÆÿ®þÇÿ×þÈÿìþÉÿ×þÊÿìþËÿ×þÌÿìþÍÿ×þÎÿìþÏÿ×þÑÿ×þÓÿ×þÕÿ×þ×ÿ×þÙÿ×þÛÿ×þÝÿ×þÞÿìþßÿìþàÿìþáÿìþâÿìþãÿìþäÿìþåÿìþúÿìþÿìþÿìþ ÿìþÿìþÿ×þÿìþÿ×þÿìþÿ×þÿìþÿ×þÿìþÿìþÿìþ!ÿìþ+ÿìþ-ÿìþ/ÿìþ1ÿìþ3ÿìþ5ÿìþCÿ®þDÿ×þFÿ×þGÿìþHÿ×þJÿìþÿšþ ÿšþWÿìþXÿ®þYÿ×þ_ÿìþ`ÿ×þbÿìþÿ®þÿ×þÿ®þ ÿ×þ!ÿ®þ"ÿ×þ#ÿ®þ%ÿ®þ&ÿ×þ'ÿ®þ(ÿ×þ)ÿ®þ*ÿ×þ+ÿ®þ,ÿ×þ-ÿ®þ.ÿ×þ/ÿ®þ0ÿ×þ1ÿ®þ2ÿ×þ3ÿ®þ4ÿ×þ6ÿ×þ8ÿ×þ:ÿ×þ<ÿ×þ@ÿ×þBÿ×þDÿ×þIÿìþJÿ×þKÿìþLÿ×þMÿìþNÿ×þOÿìþQÿìþRÿ×þSÿìþTÿ×þUÿìþVÿ×þWÿìþXÿ×þYÿìþZÿ×þ[ÿìþ\ÿ×þ]ÿìþ^ÿ×þ_ÿìþ`ÿ×þbÿìþdÿìþfÿìþhÿìþjÿìþlÿìþnÿìÿRÿ Rÿÿ®ÿÿ®ÿ")ÿRÿÿ®ÿ Rÿ ÿ®ÿ…ÿ…")$ÿ…&ÿ×*ÿ×2ÿ×4ÿ×DÿšFÿšGÿšHÿšJÿ×PÿÃQÿÃRÿšSÿÃTÿšUÿÃVÿ®XÿÃ]ÿׂÿ…ƒÿ…„ÿ……ÿ…†ÿ…‡ÿ…‰ÿ×”ÿוÿ×–ÿ×—ÿטÿךÿ×¢ÿš£ÿš¤ÿš¥ÿš¦ÿš§ÿš¨ÿš©ÿšªÿš«ÿš¬ÿš­ÿš´ÿšµÿš¶ÿš·ÿš¸ÿšºÿš»ÿüÿýÿþÿÃÂÿ…ÃÿšÄÿ…ÅÿšÆÿ…ÇÿšÈÿ×ÉÿšÊÿ×ËÿšÌÿ×ÍÿšÎÿ×ÏÿšÑÿšÓÿšÕÿš×ÿšÙÿšÛÿšÝÿšÞÿ×ßÿ×àÿ×áÿ×âÿ×ãÿ×äÿ×åÿ×úÿÃÿÃÿà ÿÃÿ×ÿšÿ×ÿšÿ×ÿšÿ×ÿšÿÃÿÃÿ®!ÿ®+ÿÃ-ÿÃ/ÿÃ1ÿÃ3ÿÃ5ÿÃ<ÿ×>ÿ×@ÿ×Cÿ…DÿšFÿšGÿ×HÿšJÿ®ÿ… ÿ…WÿÃXÿ…Yÿš_ÿ×`ÿšbÿÃÿ…ÿšÿ… ÿš!ÿ…"ÿš#ÿ…%ÿ…&ÿš'ÿ…(ÿš)ÿ…*ÿš+ÿ…,ÿš-ÿ….ÿš/ÿ…0ÿš1ÿ…2ÿš3ÿ…4ÿš6ÿš8ÿš:ÿš<ÿš@ÿšBÿšDÿšIÿ×JÿšKÿ×LÿšMÿ×NÿšOÿ×Qÿ×RÿšSÿ×TÿšUÿ×VÿšWÿ×XÿšYÿ×Zÿš[ÿ×\ÿš]ÿ×^ÿš_ÿ×`ÿšbÿÃdÿÃfÿÃhÿÃjÿÃlÿÃnÿÃR Rÿ®ÿ®")Rÿ® R ÿ®7ÿ®$ÿ®&ÿ®qÿ®ÿ®¦ÿ®¼ÿ®Äÿ®Üÿ×äÿשÿ®ªÿ×µÿ®¶ÿ×½ÿ®¾ÿ×ÿ®ÿ×ÿ®7ÿ®$ÿ®&ÿ®qÿ®ÿ®¦ÿ®¼ÿ®Äÿ®Üÿ×äÿשÿ®ªÿ×µÿ®¶ÿ×½ÿ®¾ÿ×ÿ®ÿ×ÿ®7ÿ®$ÿ®&ÿ®qÿ®ÿ®¦ÿ®¼ÿ®Äÿ®Üÿ×äÿשÿ®ªÿ×µÿ®¶ÿ×½ÿ®¾ÿ×ÿ®ÿ×ÿ®$ÿq7)9):)<Dÿ®Fÿ…Gÿ…Hÿ…JÿÃPÿÃQÿÃRÿ…SÿÃTÿ…UÿÃVÿÃXÿÂÿqƒÿq„ÿq…ÿq†ÿq‡ÿqŸ¢ÿ…£ÿ®¤ÿ®¥ÿ®¦ÿ®§ÿ®¨ÿ®©ÿ…ªÿ…«ÿ…¬ÿ…­ÿ…´ÿ…µÿ…¶ÿ…·ÿ…¸ÿ…ºÿ…»ÿüÿýÿþÿÃÂÿqÃÿ®ÄÿqÅÿ®ÆÿqÇÿ®Éÿ…Ëÿ…Íÿ…Ïÿ…Ñÿ…Óÿ…Õÿ…×ÿ…Ùÿ…Ûÿ…Ýÿ…ßÿÃáÿÃãÿÃåÿÃúÿÃÿÃÿà ÿÃÿ…ÿ…ÿ…ÿ…ÿÃÿÃÿÃ!ÿÃ$)&)+ÿÃ-ÿÃ/ÿÃ1ÿÃ3ÿÃ5ÿÃ6)8:CÿqDÿ®Fÿ®Hÿ…JÿÃVÿq_ÿqbÿqiÿqyÿ®zÿ×{ÿ×~ÿ®ÿÂÿ׃ÿׄÿׇÿ׉ÿ׌ÿ®ŽÿÃÿ®ÿ®“ÿ®™ÿ®¤ÿ…ªÿq®ÿ…µÿ…Êÿ×ÎÿqÏÿ…ÕÿqØÿ…Ûÿ…Þÿ…êÿ…íÿ…îÿÃòÿqú)ü)þ)WÿÃXÿqYÿ®`ÿ…bÿÃjÿ…rÿqsÿq}ÿìÿ……ÿ…‡ÿ…‰ÿ…ÿ…²ÿ…´ÿ…Îÿ…ÏÿqÙÿqÚÿ×ÛÿqÜÿ×ÝÿqÞÿ×àÿ…âÿ×äÿ×ðÿ…òÿ…ôÿ… ÿq ÿ… ÿq ÿ…ÿ…ÿqÿ…ÿ…ÿ…ÿqÿqÿ®ÿq ÿ®!ÿq"ÿ®#ÿq%ÿq&ÿ®'ÿq(ÿ®)ÿq*ÿ®+ÿq,ÿ®-ÿq.ÿ®/ÿq0ÿ®1ÿq2ÿ®3ÿq4ÿ®6ÿ…8ÿ…:ÿ…<ÿ…@ÿ…Bÿ…Dÿ…Jÿ…Lÿ…Nÿ…Rÿ…Tÿ…Vÿ…Xÿ…Zÿ…\ÿ…^ÿ…`ÿ…bÿÃdÿÃfÿÃhÿÃjÿÃlÿÃnÿÃoqs)$ÿq7)9):)<Dÿ®Fÿ…Gÿ…Hÿ…JÿÃPÿÃQÿÃRÿ…SÿÃTÿ…UÿÃVÿÃXÿÂÿqƒÿq„ÿq…ÿq†ÿq‡ÿqŸ¢ÿ…£ÿ®¤ÿ®¥ÿ®¦ÿ®§ÿ®¨ÿ®©ÿ…ªÿ…«ÿ…¬ÿ…­ÿ…´ÿ…µÿ…¶ÿ…·ÿ…¸ÿ…ºÿ…»ÿüÿýÿþÿÃÂÿqÃÿ®ÄÿqÅÿ®ÆÿqÇÿ®Éÿ…Ëÿ…Íÿ…Ïÿ…Ñÿ…Óÿ…Õÿ…×ÿ…Ùÿ…Ûÿ…Ýÿ…ßÿÃáÿÃãÿÃåÿÃúÿÃÿÃÿà ÿÃÿ…ÿ…ÿ…ÿ…ÿÃÿÃÿÃ!ÿÃ$)&)+ÿÃ-ÿÃ/ÿÃ1ÿÃ3ÿÃ5ÿÃ6)8:CÿqDÿ®Fÿ®Hÿ…JÿÃVÿq_ÿqbÿqiÿqyÿ®zÿ×{ÿ×~ÿ®ÿÂÿ׃ÿׄÿׇÿ׉ÿ׌ÿ®ŽÿÃÿ®ÿ®“ÿ®™ÿ®¤ÿ…ªÿq®ÿ…µÿ…Êÿ×ÎÿqÏÿ…ÕÿqØÿ…Ûÿ…Þÿ…êÿ…íÿ…îÿÃòÿqú)ü)þ)WÿÃXÿqYÿ®`ÿ…bÿÃjÿ…rÿqsÿq}ÿìÿ……ÿ…‡ÿ…‰ÿ…ÿ…²ÿ…´ÿ…Îÿ…ÏÿqÙÿqÚÿ×ÛÿqÜÿ×ÝÿqÞÿ×àÿ…âÿ×äÿ×ðÿ…òÿ…ôÿ… ÿq ÿ… ÿq ÿ…ÿ…ÿqÿ…ÿ…ÿ…ÿqÿqÿ®ÿq ÿ®!ÿq"ÿ®#ÿq%ÿq&ÿ®'ÿq(ÿ®)ÿq*ÿ®+ÿq,ÿ®-ÿq.ÿ®/ÿq0ÿ®1ÿq2ÿ®3ÿq4ÿ®6ÿ…8ÿ…:ÿ…<ÿ…@ÿ…Bÿ…Dÿ…Jÿ…Lÿ…Nÿ…Rÿ…Tÿ…Vÿ…Xÿ…Zÿ…\ÿ…^ÿ…`ÿ…bÿÃdÿÃfÿÃhÿÃjÿÃlÿÃnÿÃoqs)&ÿš*ÿš2ÿš4ÿš7ÿq8ÿ×9ÿ…:ÿ…<ÿ…‰ÿš”ÿš•ÿš–ÿš—ÿš˜ÿššÿš›ÿלÿ×ÿמÿןÿ…ÈÿšÊÿšÌÿšÎÿšÞÿšàÿšâÿšäÿšÿšÿšÿšÿš$ÿq&ÿq*ÿ×,ÿ×.ÿ×0ÿ×2ÿ×4ÿ×6ÿ…8ÿ…:ÿ…Gÿšfÿ®mÿ®qÿqrÿ…sÿšuÿ…xÿ……ÿ×ÿqŸÿš¦ÿq¸ÿš»ÿš¼ÿq¾ÿ®Áÿ\ÄÿqÜÿšáÿ…äÿšúÿ…üÿ…þÿ…ÿ…Tÿ…_ÿšaÿ×lÿš|ÿ\~ÿš€ÿ…‚ÿ…„ÿš†ÿšˆÿšŠÿšŒÿš©ÿqªÿš±ÿš³ÿšµÿq¶ÿš·ÿ…¹ÿ…½ÿq¾ÿš¿ÿ\Àÿ…Áÿ\Âÿ…Åÿ…Çÿ…Ôÿ\Õÿ…ïÿšñÿšóÿšýÿ\þÿ… ÿ…ÿšÿ…ÿšÿšÿqÿšIÿšKÿšMÿšOÿšQÿšSÿšUÿšWÿšYÿš[ÿš]ÿš_ÿšaÿ×cÿ×eÿ×gÿ×iÿ×kÿ×mÿ×oÿ…qÿ…sÿ…ÿq $ÿq 7) 9) :) < Dÿ® Fÿ… Gÿ… Hÿ… Jÿà Pÿà Qÿà Rÿ… Sÿà Tÿ… Uÿà Vÿà Xÿà ‚ÿq ƒÿq „ÿq …ÿq †ÿq ‡ÿq Ÿ ¢ÿ… £ÿ® ¤ÿ® ¥ÿ® ¦ÿ® §ÿ® ¨ÿ® ©ÿ… ªÿ… «ÿ… ¬ÿ… ­ÿ… ´ÿ… µÿ… ¶ÿ… ·ÿ… ¸ÿ… ºÿ… »ÿà ¼ÿà ½ÿà ¾ÿà Âÿq Ãÿ® Äÿq Åÿ® Æÿq Çÿ® Éÿ… Ëÿ… Íÿ… Ïÿ… Ñÿ… Óÿ… Õÿ… ×ÿ… Ùÿ… Ûÿ… Ýÿ… ßÿà áÿà ãÿà åÿà úÿà ÿà ÿà  ÿà ÿ… ÿ… ÿ… ÿ… ÿà ÿà ÿà !ÿà $) &) +ÿà -ÿà /ÿà 1ÿà 3ÿà 5ÿà 6) 8 : Cÿq Dÿ® Fÿ® Hÿ… Jÿà Vÿq _ÿq bÿq iÿq yÿ® zÿ× {ÿ× ~ÿ® ÿà ‚ÿ× ƒÿ× „ÿ× ‡ÿ× ‰ÿ× Œÿ® Žÿà ÿ® ÿ® “ÿ® ™ÿ® ¤ÿ… ªÿq ®ÿ… µÿ… Êÿ× Îÿq Ïÿ… Õÿq Øÿ… Ûÿ… Þÿ… êÿ… íÿ… îÿà òÿq ú) ü) þ)  Wÿà Xÿq Yÿ® `ÿ… bÿà jÿ… rÿq sÿq }ÿì ÿ… …ÿ… ‡ÿ… ‰ÿ… ÿ… ²ÿ… ´ÿ… Îÿ… Ïÿq Ùÿq Úÿ× Ûÿq Üÿ× Ýÿq Þÿ× àÿ… âÿ× äÿ× ðÿ… òÿ… ôÿ…  ÿq  ÿ…  ÿq  ÿ… ÿ… ÿq ÿ… ÿ… ÿ… ÿq ÿq ÿ® ÿq  ÿ® !ÿq "ÿ® #ÿq %ÿq &ÿ® 'ÿq (ÿ® )ÿq *ÿ® +ÿq ,ÿ® -ÿq .ÿ® /ÿq 0ÿ® 1ÿq 2ÿ® 3ÿq 4ÿ® 6ÿ… 8ÿ… :ÿ… <ÿ… @ÿ… Bÿ… Dÿ… Jÿ… Lÿ… Nÿ… Rÿ… Tÿ… Vÿ… Xÿ… Zÿ… \ÿ… ^ÿ… `ÿ… bÿà dÿà fÿà hÿà jÿà lÿà nÿà o q s ) &ÿš *ÿš 2ÿš 4ÿš 7ÿq 8ÿ× 9ÿ… :ÿ… <ÿ… ‰ÿš ”ÿš •ÿš –ÿš —ÿš ˜ÿš šÿš ›ÿ× œÿ× ÿ× žÿ× Ÿÿ… Èÿš Êÿš Ìÿš Îÿš Þÿš àÿš âÿš äÿš ÿš ÿš ÿš ÿš $ÿq &ÿq *ÿ× ,ÿ× .ÿ× 0ÿ× 2ÿ× 4ÿ× 6ÿ… 8ÿ… :ÿ… Gÿš fÿ® mÿ® qÿq rÿ… sÿš uÿ… xÿ… …ÿ× ÿq Ÿÿš ¦ÿq ¸ÿš »ÿš ¼ÿq ¾ÿ® Áÿ\ Äÿq Üÿš áÿ… äÿš úÿ… üÿ… þÿ… ÿ… Tÿ… _ÿš aÿ× lÿš |ÿ\ ~ÿš €ÿ… ‚ÿ… „ÿš †ÿš ˆÿš Šÿš Œÿš ©ÿq ªÿš ±ÿš ³ÿš µÿq ¶ÿš ·ÿ… ¹ÿ… ½ÿq ¾ÿš ¿ÿ\ Àÿ… Áÿ\ Âÿ… Åÿ… Çÿ… Ôÿ\ Õÿ… ïÿš ñÿš óÿš ýÿ\ þÿ…  ÿ… ÿš ÿ… ÿš ÿš ÿq ÿš Iÿš Kÿš Mÿš Oÿš Qÿš Sÿš Uÿš Wÿš Yÿš [ÿš ]ÿš _ÿš aÿ× cÿ× eÿ× gÿ× iÿ× kÿ× mÿ× oÿ… qÿ… sÿ… ÿq!qÿ×!rÿì!xÿì!TÿìSÿÃSÿÃSÿÃS ÿÃTÿ…Tÿ…TVÿ…T_ÿ…Tbÿ…Tfÿ×Tiÿ…Tmÿ×TsÿÃTvÿìTyÿšTzÿ®T{ÿÃT|ÿÃT}ÿÃT~ÿšTÿÃT‚ÿ®T„ÿÃT†ÿÃT‡ÿÃT‰ÿÃTŒÿšTŽÿšTÿšTÿšT’ÿÃT“ÿšT•ÿÃT–ÿÃT˜ÿÃT™ÿšTšÿÃT›ÿÃTÿ…T ÿ…T!ÿìXÿqX ÿqX&ÿ×X*ÿ×X- X2ÿ×X4ÿ×X7ÿqX9ÿ®X:ÿ®X<ÿ…X‰ÿ×X”ÿ×X•ÿ×X–ÿ×X—ÿ×X˜ÿ×Xšÿ×XŸÿ…XÈÿ×XÊÿ×XÌÿ×XÎÿ×XÞÿ×Xàÿ×Xâÿ×Xäÿ×Xÿ×Xÿ×Xÿ×Xÿ×X$ÿqX&ÿqX6ÿ®X8ÿ…X:ÿ…XGÿ×Xúÿ®Xüÿ®Xþÿ®Xÿ…XÿqX ÿqX_ÿ×XIÿ×XKÿ×XMÿ×XOÿ×XQÿ×XSÿ×XUÿ×XWÿ×XYÿ×X[ÿ×X]ÿ×X_ÿ×Xoÿ…Xqÿ…Xsÿ…XÿqYÿìY ÿìYÿìY ÿìZÿ®Zÿ®ZVÿ×Z_ÿ×Zbÿ×ZdÿìZiÿ×ZpÿìZqÿÃZrÿìZtÿ×ZuÿìZxÿìZˆÿìZÿ®Z ÿ®ZTÿì`IR`WR`Yf`Zf`[f`\f`¿f`%R`'R`7f`ûf`ýf`4R`5R`]R`^R`pf`R`RbIfbWfbYfbZfb[fb\fb¿fb%fb'fb7fbûfbýfb4fb5fb]fb^fbpfbfbfjÿìj ÿìjÿìj ÿìlÿ®lÿ®lÿìl¤ÿ×l¦ÿìl¨ÿ×lªÿ×l®ÿ×l°ÿ×l±ÿìlµÿ×l¼ÿÃl½ÿ×l¿ÿ×lÁÿ×lÄÿìlÇÿìlÎÿìlÕÿìlòÿìlÿ®l ÿ®lrÿ×lsÿìlzÿìl|ÿ×l€ÿìl‚ÿìlŸÿ×l¡ÿìl©ÿìlµÿÃl·ÿìl¹ÿìl»ÿ×l½ÿìl¿ÿ×lÁÿ×lÊÿ×lÎÿ×lÏÿìlÔÿ×lÙÿ×lÛÿ×lÝÿ×låÿ×lçÿìlõÿìl÷ÿ×lùÿ×lûÿ×lýÿ×lÿ×lÿ×l ÿ×lÿ×lÿ×lÿìlÿìlÿ×lÿìmÿ®mÿ®mÎÿ×mÕÿ×mòÿ×mÿ®m ÿ®msÿ×mÏÿ×mÿ×mÿ×nÿ®n ÿ®nÿ×n¦ÿ×n¼ÿ®nÁÿ®nÄÿ×nÜÿ×näÿ×nÿ®n ÿ®n|ÿ®n€ÿÃn‚ÿÃn©ÿ×nªÿ×nµÿ®n¶ÿ×n·ÿÃn¹ÿÃn½ÿ×n¾ÿ×n¿ÿ®nÁÿ®nÔÿ®nýÿ®n ÿšnÿšnÿ×nÿ×oÿ…o ÿ…oÐÿ×oÜÿšoÝÿÃoßÿ×oáÿ®oäÿšoöÿÃoÿ…o ÿ…omÿ×oÿ×oƒÿ×o‹ÿ×o ÿ×oªÿšo¶ÿšo¸ÿÃoºÿÃo¼ÿ×o¾ÿšoÀÿ®oÂÿ®oÆÿ×oÈÿ×oËÿ×oÕÿ®oæÿ×oêÿ×oøÿÃoúÿÃoüÿÃoþÿ®oÿ×oÿ×oÿšoÿšoÿšpŸÿ×p¸ÿ×p»ÿ×p¾ÿ×páÿ×plÿ×p~ÿ×p„ÿ×p†ÿ×pˆÿ×pŠÿ×pŒÿ×p±ÿ×p³ÿ×pÀÿ×pÂÿ×pÅÿ×pÇÿ×pÕÿ×pïÿ×pñÿ×póÿ×pþÿ×p ÿ×p ÿ×pÿ×pÿ×pÿ×rÿqr ÿqrÿšr¦ÿšr¼ÿqr¾ÿ×rÁÿšrÄÿšrÜÿ×ráÿ×räÿ×rÿqr ÿqrnÿ×r|ÿšr€ÿ®r‚ÿ®r—ÿ×r›ÿ×r§ÿ×r©ÿšrªÿ×rµÿqr¶ÿ×r·ÿ…r¹ÿ…r½ÿšr¾ÿ×r¿ÿšrÀÿ×rÁÿšrÂÿ×rÅÿšrÇÿšrÔÿšrÕÿ×ráÿ×rãÿ×rýÿšrþÿ×rÿ×r ÿqrÿ×rÿqrÿ×rÿšrÿ×sÿqs ÿqsÏÿ×sØÿ×sÛÿ×sÜÿšsÝÿÃsÞÿ×sáÿÃsäÿšsêÿ×síÿ×söÿÃsÿqs ÿqsjÿ×smÿ×s}ÿìsÿ×sÿ×sƒÿ×s…ÿ×s‡ÿ×s‰ÿ×s‹ÿ×sÿ×sªÿšs²ÿ×s´ÿ×s¶ÿšs¸ÿ×sºÿ×s¾ÿšsÀÿÃsÂÿÃsÆÿ×sÈÿ×sÕÿÃsàÿ×sðÿ×sòÿ×sôÿ×søÿÃsúÿÃsüÿÃsþÿÃs ÿ×s ÿ×sÿ…sÿ…sÿ×sÿšsÿ×tÿqt ÿqtÿšt¦ÿšt¼ÿqt¾ÿ×tÁÿštÄÿštÜÿ×táÿ×täÿ×tÿqt ÿqtnÿ×t|ÿšt€ÿ®t‚ÿ®t—ÿ×t›ÿ×t§ÿ×t©ÿštªÿ×tµÿqt¶ÿ×t·ÿ…t¹ÿ…t½ÿšt¾ÿ×t¿ÿštÀÿ×tÁÿštÂÿ×tÅÿštÇÿštÔÿštÕÿ×táÿ×tãÿ×týÿštþÿ×tÿ×t ÿqtÿ×tÿqtÿ×tÿštÿ×uÿqu ÿquÏÿ×uØÿ×uÛÿ×uÜÿšuÝÿÃuÞÿ×uáÿÃuäÿšuêÿ×uíÿ×uöÿÃuÿqu ÿqujÿ×umÿ×u}ÿìuÿ×uÿ×uƒÿ×u…ÿ×u‡ÿ×u‰ÿ×u‹ÿ×uÿ×uªÿšu²ÿ×u´ÿ×u¶ÿšu¸ÿ×uºÿ×u¾ÿšuÀÿÃuÂÿÃuÆÿ×uÈÿ×uÕÿÃuàÿ×uðÿ×uòÿ×uôÿ×uøÿÃuúÿÃuüÿÃuþÿÃu ÿ×u ÿ×uÿ…uÿ…uÿ×uÿšuÿ×v ÿìvÿìx ÿìxÿìzÿ®zÿ®zÿ®z ÿ®z€ÿìz‚ÿìz·ÿìz¹ÿìz ÿ×zÿ×|ÿq|ÿq|¤ÿÃ|ªÿ®|®ÿÃ|µÿÃ|Îÿ×|Õÿ×|òÿ×|ÿq| ÿq|rÿ®|sÿ×|ÎÿÃ|Ïÿ×|Ùÿ®|Ûÿ®|Ýÿ®| ÿ®| ÿ®|ÿÃ|ÿ×|ÿÃ|ÿ×}ÿì} ÿì}Ðÿ×}Üÿì}Ýÿì}ßÿ×}áÿì}äÿì}öÿì}ÿì} ÿì} ÿ×}ªÿì}¶ÿì}¼ÿ×}¾ÿì}Àÿì}Âÿì}Ëÿ×}Õÿì}æÿ×}øÿì}úÿì}üÿì}þÿì}ÿ×}ÿ×}ÿì}ÿì}ÿì~ÿ®~ÿ®~ÿì~¤ÿ×~¦ÿì~¨ÿ×~ªÿ×~®ÿ×~°ÿ×~±ÿì~µÿ×~¼ÿÃ~½ÿ×~¿ÿ×~Áÿ×~Äÿì~Çÿì~Îÿì~Õÿì~òÿì~ÿ®~ ÿ®~rÿ×~sÿì~zÿì~|ÿ×~€ÿì~‚ÿì~Ÿÿ×~¡ÿì~©ÿì~µÿÃ~·ÿì~¹ÿì~»ÿ×~½ÿì~¿ÿ×~Áÿ×~Êÿ×~Îÿ×~Ïÿì~Ôÿ×~Ùÿ×~Ûÿ×~Ýÿ×~åÿ×~çÿì~õÿì~÷ÿ×~ùÿ×~ûÿ×~ýÿ×~ÿ×~ÿ×~ ÿ×~ÿ×~ÿ×~ÿì~ÿì~ÿ×~ÿìÿì ÿìÐÿ×ÜÿìÝÿìßÿ×áÿìäÿìöÿìÿì ÿì ÿתÿì¶ÿì¼ÿ×¾ÿìÀÿìÂÿìËÿ×Õÿìæÿ×øÿìúÿìüÿìþÿìÿ×ÿ×ÿìÿìÿì€ÿ…€ÿ…€Ÿÿ쀤ÿš€ªÿq€®ÿš€µÿš€¸ÿ쀻ÿ쀾ÿÀÉÿì€Îÿ®€Ïÿ×€Õÿ®€Øÿ×€Ûÿ×€Þÿ×€áÿ×€êÿ×€ëf€íÿ×€îÿì€òÿ®€ôf€ÿ…€ ÿ…€jÿ×€lÿì€rÿq€sÿ®€~ÿì€ÿ×€„ÿ쀅ÿ×€†ÿ쀇ÿ×€ˆÿ쀉ÿ×€Šÿ쀌ÿì€ÿ×€˜f€¨f€±ÿ쀲ÿ×€³ÿ쀴ÿ×€Àÿ×€Âÿ×€Åÿ×€ÆÿÀÇÿ×€ÈÿÀÎÿš€Ïÿ®€Õÿ×€Ùÿq€Ûÿq€Ýÿq€àÿ×€ïÿì€ðÿ×€ñÿì€òÿ×€óÿì€ôÿ×€þÿ×€ ÿq€ ÿ×€ ÿq€ ÿ×€ÿš€ÿ®€ÿì€ÿ×€ÿ×€ÿš€ÿ®ÿ®ÿ®Îÿ×Õÿ×òÿ×ÿ® ÿ®sÿ×Ïÿ×ÿ×ÿׂÿ…‚ÿ…‚Ÿÿ삤ÿš‚ªÿq‚®ÿš‚µÿš‚¸ÿì‚»ÿ삾ÿÂÉÿì‚Îÿ®‚ÏÿׂÕÿ®‚ØÿׂÛÿׂÞÿׂáÿׂêÿׂëf‚íÿׂîÿì‚òÿ®‚ôf‚ÿ…‚ ÿ…‚jÿׂlÿì‚rÿq‚sÿ®‚~ÿì‚ÿׂ„ÿì‚…ÿׂ†ÿ삇ÿׂˆÿ삉ÿׂŠÿì‚Œÿì‚ÿׂ˜f‚¨f‚±ÿ삲ÿׂ³ÿì‚´ÿׂÀÿׂÂÿׂÅÿׂÆÿÂÇÿׂÈÿÂÎÿš‚Ïÿ®‚ÕÿׂÙÿq‚Ûÿq‚Ýÿq‚àÿׂïÿì‚ðÿׂñÿì‚òÿׂóÿì‚ôÿׂþÿׂ ÿq‚ ÿׂ ÿq‚ ÿׂÿš‚ÿ®‚ÿì‚ÿׂÿׂÿš‚ÿ®ƒÿ®ƒÿ®ƒÎÿ׃Õÿ׃òÿ׃ÿ®ƒ ÿ®ƒsÿ׃Ïÿ׃ÿ׃ÿׄÿ®„ÿ®„ÎÿׄÕÿׄòÿׄÿ®„ ÿ®„sÿׄÏÿׄÿׄÿ×…ÿ®…ÿ®…Îÿ×…Õÿ×…òÿ×…ÿ®… ÿ®…sÿ×…Ïÿ×…ÿ×…ÿ׆ÿ®†ÿ®†ÿ솤ÿ׆¦ÿ솨ÿ׆ªÿ׆®ÿ׆°ÿ׆±ÿ솵ÿ׆¼ÿƽÿ׆¿ÿ׆Áÿ׆Äÿì†Çÿì†Îÿì†Õÿì†òÿì†ÿ®† ÿ®†rÿ׆sÿì†zÿì†|ÿ׆€ÿ솂ÿ솟ÿ׆¡ÿ솩ÿ솵ÿÆ·ÿ솹ÿ솻ÿ׆½ÿ솿ÿ׆Áÿ׆Êÿ׆Îÿ׆Ïÿì†Ôÿ׆Ùÿ׆Ûÿ׆Ýÿ׆åÿ׆çÿì†õÿì†÷ÿ׆ùÿ׆ûÿ׆ýÿ׆ÿ׆ÿ׆ ÿ׆ÿ׆ÿ׆ÿì†ÿì†ÿ׆ÿì‡ÿì‡ ÿì‡ÐÿׇÜÿì‡Ýÿì‡ßÿׇáÿì‡äÿì‡öÿì‡ÿì‡ ÿ쇠ÿׇªÿ쇶ÿ쇼ÿׇ¾ÿì‡Àÿì‡Âÿì‡ËÿׇÕÿì‡æÿׇøÿì‡úÿì‡üÿì‡þÿì‡ÿׇÿׇÿì‡ÿì‡ÿìˆÿ®ˆÿ®ˆÿ숤ÿ׈¦ÿ숨ÿ׈ªÿ׈®ÿ׈°ÿ׈±ÿ숵ÿ׈¼ÿȽÿ׈¿ÿ׈Áÿ׈ÄÿìˆÇÿìˆÎÿìˆÕÿìˆòÿìˆÿ®ˆ ÿ®ˆrÿ׈sÿìˆzÿìˆ|ÿ׈€ÿ숂ÿ숟ÿ׈¡ÿ숩ÿ숵ÿÈ·ÿ숹ÿ숻ÿ׈½ÿ숿ÿ׈Áÿ׈Êÿ׈Îÿ׈ÏÿìˆÔÿ׈Ùÿ׈Ûÿ׈Ýÿ׈åÿ׈çÿìˆõÿìˆ÷ÿ׈ùÿ׈ûÿ׈ýÿ׈ÿ׈ÿ׈ ÿ׈ÿ׈ÿ׈ÿìˆÿìˆÿ׈ÿì‰ÿì‰ ÿì‰Ðÿ׉Üÿì‰Ýÿì‰ßÿ׉áÿì‰äÿì‰öÿì‰ÿì‰ ÿ쉠ÿ׉ªÿ쉶ÿ쉼ÿ׉¾ÿì‰Àÿì‰Âÿì‰Ëÿ׉Õÿì‰æÿ׉øÿì‰úÿì‰üÿì‰þÿì‰ÿ׉ÿ׉ÿì‰ÿì‰ÿìŠÿ®Šÿ®Šÿ스ÿ׊¦ÿ슨ÿ׊ªÿ׊®ÿ׊°ÿ׊±ÿ습ÿ׊¼ÿʽÿ׊¿ÿ׊Áÿ׊ÄÿìŠÇÿìŠÎÿìŠÕÿìŠòÿìŠÿ®Š ÿ®Šrÿ׊sÿìŠzÿìŠ|ÿ׊€ÿ슂ÿ슟ÿ׊¡ÿ슩ÿ습ÿÊ·ÿ승ÿ슻ÿ׊½ÿ슿ÿ׊Áÿ׊Êÿ׊Îÿ׊ÏÿìŠÔÿ׊Ùÿ׊Ûÿ׊Ýÿ׊åÿ׊çÿìŠõÿìŠ÷ÿ׊ùÿ׊ûÿ׊ýÿ׊ÿ׊ÿ׊ ÿ׊ÿ׊ÿ׊ÿìŠÿìŠÿ׊ÿì‹ÿ®‹ÿ®‹Îÿ׋Õÿ׋òÿ׋ÿ®‹ ÿ®‹sÿ׋Ïÿ׋ÿ׋ÿ׌Ÿÿ׌¸ÿ׌»ÿ׌¾ÿ׌áÿ׌lÿ׌~ÿ׌„ÿ׌†ÿ׌ˆÿ׌Šÿ׌Œÿ׌±ÿ׌³ÿ׌Àÿ׌Âÿ׌Åÿ׌Çÿ׌Õÿ׌ïÿ׌ñÿ׌óÿ׌þÿ׌ ÿ׌ ÿ׌ÿ׌ÿ׌ÿו£á•ê)•ÿוÿ×–ÿì– ÿì–ÿì– ÿì—ÿ®— ÿ®—ÿ×—¦ÿ×—¼ÿ®—Áÿ®—Äÿ×—Üÿ×—äÿ×—ÿ®— ÿ®—|ÿ®—€ÿׂÿשÿ×—ªÿ×—µÿ®—¶ÿ×—·ÿ×¹ÿ×½ÿ×—¾ÿ×—¿ÿ®—Áÿ®—Ôÿ®—ýÿ®— ÿš—ÿš—ÿ×—ÿטÿ…˜ ÿ…˜ÐÿטÜÿš˜ÝÿØßÿטáÿ®˜äÿš˜öÿØÿ…˜ ÿ…˜mÿטÿטƒÿט‹ÿט ÿטªÿš˜¶ÿš˜¸ÿغÿؼÿט¾ÿš˜Àÿ®˜Âÿ®˜ÆÿטÈÿטËÿטÕÿ®˜æÿטêÿטøÿØúÿØüÿØþÿ®˜ÿטÿטÿš˜ÿš˜ÿš™þö™þö™¤ÿ…™ªÿš™®ÿ…™°ÿ×™µÿ…™¿ÿ×™Îÿš™Õÿš™òÿš™þö™ þö™rÿš™sÿš™vÿ왟ÿ×™»ÿ×™Êÿ×™Îÿ…™Ïÿš™Ùÿš™Ûÿš™Ýÿš™åÿ×™ÿ×™ÿ×™ ÿ®™ ÿ®™ÿ…™ÿš™ÿ…™ÿššÿìš ÿìšÐÿךÜÿìšÝÿìšßÿךáÿìšäÿìšöÿìšÿìš ÿìš ÿךªÿ욶ÿìš¼ÿך¾ÿìšÀÿìšÂÿìšËÿךÕÿìšæÿךøÿìšúÿìšüÿìšþÿìšÿךÿךÿìšÿìšÿì›ÿš›ÿ×›ÿš›)›Ÿÿ×›¤ÿ®›¦)›ªÿ…›®ÿ®›µÿ®›¸ÿ×›»ÿ×›¼)›¾ÿÛÄ)›ÌÿÛÍÿÛÎÿš›Ïÿ®›Ðÿ×›Ñÿ×›ÒÿÛÓÿÛÔÿÛÕÿš›ÖÿÛ×ÿÛØÿ®›ÙÿÛÚÿÛÛÿ®›Þÿ®›ßÿ×›àÿÛáÿš›âÿÛãÿÛåÿÛæÿÛçÿ×›èÿÛêÿ®›ë)›ìÿÛíÿ®›îÿÛòÿš›óÿÛô)›õÿÛ÷ÿÛùÿÛÿ×›ÿ×›ÿ×›ÿš› ÿš›jÿ®›kÿÛlÿ×›qÿÛrÿ…›sÿš›uÿÛwÿ×›yÿÛ}ÿÛ~ÿ×›ÿ®›„ÿ×›…ÿ®›†ÿ×›‡ÿ®›ˆÿ×›‰ÿ®›Šÿ×›Œÿ×›ÿ®›–ÿÛ˜)›šÿÛžÿÛ ÿ×›¢ÿ×›¤ÿÛ¦ÿÛ¨)›©)›¬ÿÛ®ÿÛ°ÿÛ±ÿ×›²ÿ®›³ÿ×›´ÿ®›µ)›¼ÿ×›½)›Àÿš›Âÿš›ÄÿÛÅÿ×›ÆÿÛÇÿ×›ÈÿÛËÿ×›ÍÿÛÎÿ®›Ïÿš›ÑÿÛÓÿÛÕÿš›×ÿÛÙÿ…›Ûÿ…›Ýÿ…›àÿ®›æÿ×›èÿ×›ìÿÛîÿÛïÿ×›ðÿ®›ñÿ×›òÿ®›óÿ×›ôÿ®›öÿ×›þÿš›ÿÛÿÛÿ×›ÿ×› ÿš› ÿ®› ÿš› ÿ®›ÿ×›ÿ×›ÿ®›ÿš›ÿÛÿ×›ÿ®›)›ÿ®›ÿ®›ÿšœÿÃœÿÃœÎÿÃœÏÿלÕÿÃœØÿלÛÿלÞÿלêÿלíÿלòÿÃœÿÃœ ÿÃœjÿלsÿÃœÿל…ÿל‡ÿל‰ÿלÿל²ÿל´ÿלÏÿÃœàÿלðÿלòÿלôÿל ÿל ÿלÿÃœÿלÿלÿÃÿà ÿÃÿãf¦ÿüÿÃÁÿ®ÄÿÃÜÿ×áÿ×äÿ×ÿà ÿÃ|ÿ®€ÿÂÿéÿêÿ×µÿöÿ×·ÿ×¹ÿ×½ÿþÿ׿ÿ®Àÿ×Áÿ®Âÿ×Ôÿ®Õÿ×ýÿ®þÿ× ÿ×ÿÃÿ×ÿÃÿÃÿמÿÞ ÿÞÿÞ ÿÞÿמÿןŸÿן£áŸ¸ÿן»ÿן¾ÿßÜÿןáÿ®Ÿäÿןlÿן{=Ÿ}ÿìŸ~ÿן„ÿן†ÿןˆÿןŠÿןŒÿןªÿן±ÿן³ÿן¶ÿן¾ÿןÀÿ®ŸÂÿ®ŸÅÿßÆÿןÇÿßÈÿןÕÿ®Ÿïÿןñÿןóÿןþÿ®Ÿÿןÿןÿןÿ× Ïÿì Øÿì Ûÿì Þÿì áÿì êÿì íÿì jÿì ÿì …ÿì ‡ÿì ‰ÿì ÿì ²ÿì ´ÿì Àÿì Âÿì Õÿì àÿì ðÿì òÿì ôÿì þÿì  ÿì  ÿì ÿ× ÿ× ÿì ÿì¡ÿ®¡ÿ®¡ÿ®¡ ÿ®¡€ÿì¡‚ÿì¡·ÿ졹ÿì¡ ÿסÿ×¢é)£Ÿÿ×££á£¸ÿ×£»ÿ×£¾ÿãÜÿ×£áÿ®£äÿ×£lÿ×£{=£}ÿì£~ÿ×£„ÿ×£†ÿ×£ˆÿ×£Šÿ×£Œÿ×£ªÿ×£±ÿ×£³ÿ×£¶ÿ×£¾ÿ×£Àÿ®£Âÿ®£ÅÿãÆÿ×£ÇÿãÈÿ×£Õÿ®£ïÿ×£ñÿ×£óÿ×£þÿ®£ÿ×£ÿ×£ÿ×£ÿפÏÿì¤Øÿì¤Ûÿì¤Þÿì¤áÿì¤êÿì¤íÿì¤jÿì¤ÿ줅ÿ줇ÿ줉ÿì¤ÿ줲ÿ줴ÿì¤Àÿì¤Âÿì¤Õÿì¤àÿì¤ðÿì¤òÿì¤ôÿì¤þÿì¤ ÿì¤ ÿì¤ÿפÿפÿì¤ÿ쥟ÿ×¥¸ÿ×¥»ÿ×¥¾ÿ×¥Áÿ×¥áÿ×¥lÿ×¥|ÿ×¥~ÿ×¥„ÿ×¥†ÿ×¥ˆÿ×¥Šÿ×¥Œÿ×¥±ÿ×¥³ÿ×¥¿ÿ×¥Àÿ×¥Áÿ×¥Âÿ×¥Åÿš¥Çÿš¥Ôÿ×¥Õÿ×¥ïÿ×¥ñÿ×¥óÿ×¥ýÿ×¥þÿ×¥ ÿ×¥ ÿ×¥ÿ×¥ÿ×¥ÿ×¥ÿì¦ÏÿצØÿצÛÿצÞÿצáÿצêÿצíÿצjÿצÿצ…ÿצ‡ÿצ‰ÿצÿצ²ÿצ´ÿצÀÿצÂÿצÆÿצÈÿצÕÿצàÿצðÿצòÿצôÿצþÿצ ÿצ ÿצÿצÿקŸÿק¸ÿק»ÿק¾ÿקÁÿקáÿקlÿק|ÿק~ÿק„ÿק†ÿקˆÿקŠÿקŒÿק±ÿק³ÿק¿ÿקÀÿקÁÿקÂÿקÅÿš§Çÿš§ÔÿקÕÿקïÿקñÿקóÿקýÿקþÿק ÿק ÿקÿקÿקÿקÿì¨ÏÿרØÿרÛÿרÞÿרáÿרêÿרíÿרjÿרÿר…ÿר‡ÿר‰ÿרÿר²ÿר´ÿרÀÿרÂÿרÆÿרÈÿרÕÿרàÿרðÿרòÿרôÿרþÿר ÿר ÿרÿרÿשŸÿש¸ÿש»ÿש¾ÿשÁÿשáÿשlÿש|ÿש~ÿש„ÿש†ÿשˆÿשŠÿשŒÿש±ÿש³ÿש¿ÿשÀÿשÁÿשÂÿשÅÿš©Çÿš©ÔÿשÕÿשïÿשñÿשóÿשýÿשþÿש ÿש ÿשÿשÿשÿשÿìªÏÿתØÿתÛÿתÞÿתáÿתêÿתíÿתjÿתÿת…ÿת‡ÿת‰ÿתÿת²ÿת´ÿתÀÿתÂÿתÆÿתÈÿתÕÿתàÿתðÿתòÿתôÿתþÿת ÿת ÿתÿתÿ׫£á«ê)«ÿ׫ÿ׬ÿì¬ ÿì¬ÿì¬ ÿì­ÿš­ÿ×­ÿš­)­Ÿÿ×­¤ÿ®­¦)­ªÿ…­®ÿ®­µÿ®­¸ÿ×­»ÿ×­¼)­¾ÿíÄ)­ÌÿíÍÿíÎÿš­Ïÿ®­Ðÿ×­Ñÿ×­ÒÿíÓÿíÔÿíÕÿš­Öÿí×ÿíØÿ®­ÙÿíÚÿíÛÿ®­Þÿ®­ßÿ×­àÿíáÿš­âÿíãÿíåÿíæÿíçÿ×­èÿíêÿ®­ë)­ìÿííÿ®­îÿíòÿš­óÿíô)­õÿí÷ÿíùÿíÿ×­ÿ×­ÿ×­ÿš­ ÿš­jÿ®­kÿílÿ×­qÿírÿ…­sÿš­uÿíwÿ×­yÿí}ÿí~ÿ×­ÿ®­„ÿ×­…ÿ®­†ÿ×­‡ÿ®­ˆÿ×­‰ÿ®­Šÿ×­Œÿ×­ÿ®­–ÿí˜)­šÿížÿí ÿ×­¢ÿ×­¤ÿí¦ÿí¨)­©)­¬ÿí®ÿí°ÿí±ÿ×­²ÿ®­³ÿ×­´ÿ®­µ)­¼ÿ×­½)­Àÿš­Âÿš­ÄÿíÅÿ×­ÆÿíÇÿ×­ÈÿíËÿ×­ÍÿíÎÿ®­Ïÿš­ÑÿíÓÿíÕÿš­×ÿíÙÿ…­Ûÿ…­Ýÿ…­àÿ®­æÿ×­èÿ×­ìÿíîÿíïÿ×­ðÿ®­ñÿ×­òÿ®­óÿ×­ôÿ®­öÿ×­þÿš­ÿíÿíÿ×­ÿ×­ ÿš­ ÿ®­ ÿš­ ÿ®­ÿ×­ÿ×­ÿ®­ÿš­ÿíÿ×­ÿ®­)­ÿ®­ÿ®­ÿš®ÿš®ÿ×®ÿš®ÎÿîÏÿì®ÕÿîØÿì®Ûÿì®Þÿì®êÿì®íÿì®òÿîÿ×®ÿ×®ÿ×®ÿš® ÿš®jÿì®sÿîÿì®…ÿ쮇ÿ쮉ÿì®ÿ쮲ÿì®´ÿì®Ïÿîàÿì®ðÿì®òÿì®ôÿì® ÿì® ÿì®ÿîÿì®ÿì®ÿïÿ\¯ ÿ\¯ÿš¯£f¯¦ÿš¯¼ÿH¯Áÿ…¯Äÿš¯Üÿ®¯áÿׯäÿ®¯ÿ\¯ ÿ\¯|ÿ…¯€ÿq¯‚ÿq¯©ÿš¯ªÿ®¯µÿH¯¶ÿ®¯·ÿš¯¹ÿš¯½ÿš¯¾ÿ®¯¿ÿ…¯ÀÿׯÁÿ…¯ÂÿׯÅÿïÆÿׯÇÿïÈÿׯÔÿ…¯Õÿׯýÿ…¯þÿׯ ÿH¯ÿ®¯ÿH¯ÿ®¯ÿš¯ÿ®°ÿq° ÿq°Üÿš°áÿ×°äÿš°ÿq° ÿq°mÿ×°ÿ×°ƒÿ×°‹ÿ×°ªÿš°¶ÿš°¸ÿ×°ºÿ×°¾ÿš°Àÿ×°Âÿ×°Æÿ×°Èÿ×°Õÿ×°þÿ×°ÿq°ÿq°ÿš±ÿ×±¦ÿ×±¼ÿñÄÿ×±€ÿ챂ÿ챩ÿ×±µÿñ·ÿì±¹ÿì±½ÿ×± ÿ×±ÿ×±ÿײÿì² ÿì²ÐÿײÜÿì²Ýÿì²ßÿײáÿì²äÿì²öÿì²ÿì² ÿì² ÿײªÿ첶ÿì²¼ÿײ¾ÿì²Àÿì²Âÿì²ËÿײÕÿì²æÿײøÿì²úÿì²üÿì²þÿì²ÿײÿײÿì²ÿì²ÿ쳟ÿ׳¸ÿ׳»ÿ׳¾ÿ׳áÿ׳lÿ׳~ÿ׳„ÿ׳†ÿ׳ˆÿ׳Šÿ׳Œÿ׳±ÿ׳³ÿ׳Àÿ׳Âÿ׳Åÿ׳Çÿ׳Õÿ׳ïÿ׳ñÿ׳óÿ׳þÿ׳ ÿ׳ ÿ׳ÿ׳ÿ׳ÿ×µÿ…µÿ®µÿ…µŸÿ×µ¤ÿšµªÿqµ®ÿšµµÿšµ¸ÿ×µ»ÿ×µ¼)µ¾ÿ®µÌÿšµÍÿšµÎÿ…µÏÿqµÐÿ×µÑÿ×µÒÿšµÓÿšµÔÿšµÕÿ…µÖÿšµ×ÿšµØÿqµÙÿšµÚÿšµÛÿqµÜÿ®µÝÿ®µÞÿqµßÿ×µàÿšµáÿšµâÿšµãÿšµäÿ®µåÿšµæÿšµçÿ×µèÿšµéÿõêÿqµìÿšµíÿqµîÿ…µòÿ…µóÿšµõÿšµöÿ®µ÷ÿšµùÿšµÿ®µÿ®µÿ®µÿ…µ ÿ…µjÿqµkÿšµlÿ×µmÿ×µqÿšµrÿqµsÿ…µuÿšµwÿšµyÿšµ}ÿšµ~ÿ×µÿqµÿ×µƒÿ×µ„ÿ×µ…ÿqµ†ÿ×µ‡ÿqµˆÿ×µ‰ÿqµŠÿ×µ‹ÿ×µŒÿ×µÿqµ–ÿšµšÿšµžÿšµ ÿ×µ¢ÿ×µ¤ÿšµ¦ÿšµªÿ®µ¬ÿšµ®ÿšµ°ÿšµ±ÿ×µ²ÿqµ³ÿ×µ´ÿqµµ)µ¶ÿ®µ¸ÿ®µºÿ®µ¼ÿ×µ¾ÿ®µÀÿšµÂÿšµÄÿšµÅÿšµÆÿqµÇÿšµÈÿqµËÿ×µÍÿšµÎÿšµÏÿ…µÑÿšµÓÿšµÕÿšµ×ÿšµÙÿqµÛÿqµÝÿqµàÿqµæÿ×µèÿ×µêÿõìÿšµîÿšµïÿ×µðÿqµñÿ×µòÿqµóÿ×µôÿqµöÿ×µøÿ®µúÿ®µüÿ®µþÿšµÿšµÿšµÿ×µÿ×µ ÿqµ ÿqµ ÿqµ ÿqµÿšµÿšµÿšµÿ…µÿšµÿ×µÿqµÿ®µÿqµÿšµÿ…¶ÿš¶ÿ׶ÿš¶ÎÿöÏÿì¶ÕÿöØÿì¶Ûÿì¶Þÿì¶êÿì¶íÿì¶òÿöÿ׶ÿ׶ÿ׶ÿš¶ ÿš¶jÿì¶sÿöÿ춅ÿ춇ÿ춉ÿì¶ÿ춲ÿ춴ÿì¶Ïÿöàÿì¶ðÿì¶òÿì¶ôÿì¶ ÿì¶ ÿì¶ÿöÿì¶ÿì¶ÿ÷ÿ…·ÿ…·Ÿÿ×·¤ÿ®·ªÿ…·®ÿ®·µÿ®·¸ÿ×·»ÿ×·¾ÿ÷Êÿ®·Ìÿ÷Íÿ÷Îÿš·Ïÿš·Òÿ÷Óÿ÷Ôÿ÷Õÿš·Öÿ÷×ÿ÷Øÿš·Ùÿ÷Úÿ÷Ûÿš·Þÿš·àÿ÷áÿ®·âÿ÷ãÿ÷åÿ÷æÿ÷èÿ÷éÿ×·êÿš·ë)·ìÿ÷íÿš·îÿ®·òÿš·óÿ÷ô)·õÿ÷÷ÿ÷ùÿ÷ÿ…· ÿ…·jÿš·kÿ÷lÿ×·qÿ÷rÿ…·sÿš·uÿ÷wÿ×·yÿ÷}ÿ×·~ÿ×·ÿš·„ÿ×·…ÿš·†ÿ×·‡ÿš·ˆÿ×·‰ÿš·Šÿ×·Œÿ×·ÿš·–ÿ÷˜)·šÿ÷žÿ÷¤ÿ÷¦ÿ÷¨)·¬ÿ÷®ÿ÷°ÿ÷±ÿ×·²ÿš·³ÿ×·´ÿš·Àÿ®·Âÿ®·Äÿ÷Æÿ®·Èÿ®·Íÿ÷Îÿ®·Ïÿš·Ñÿ÷Óÿ÷Õÿ®·×ÿ÷Ùÿ…·Úÿ®·Ûÿ…·Üÿ®·Ýÿ…·Þÿ®·àÿš·áÿì·âÿ®·ãÿì·äÿ®·ìÿ÷îÿ÷ïÿ×·ðÿš·ñÿ×·òÿš·óÿ×·ôÿš·þÿ®·ÿ÷ÿ÷ ÿ®· ÿš· ÿ®· ÿš·ÿ×·ÿ×·ÿ®·ÿš·ÿ÷ÿ×·ÿš·ÿì·ÿš·ÿ®·ÿš¸ÿ®¸ÿ®¸Îÿì¸Õÿì¸òÿì¸ÿ®¸ ÿ®¸sÿì¸Ïÿì¸ÿì¸ÿì¹ÿ…¹ÿ…¹Ÿÿ×¹¤ÿ®¹ªÿ…¹®ÿ®¹µÿ®¹¸ÿ×¹»ÿ×¹¾ÿùÊÿ®¹ÌÿùÍÿùÎÿš¹Ïÿš¹ÒÿùÓÿùÔÿùÕÿš¹Öÿù×ÿùØÿš¹ÙÿùÚÿùÛÿš¹Þÿš¹àÿùáÿ®¹âÿùãÿùåÿùæÿùèÿùéÿ×¹êÿš¹ë)¹ìÿùíÿš¹îÿ®¹òÿš¹óÿùô)¹õÿù÷ÿùùÿùÿ…¹ ÿ…¹jÿš¹kÿùlÿ×¹qÿùrÿ…¹sÿš¹uÿùwÿ×¹yÿù}ÿ×¹~ÿ×¹ÿš¹„ÿ×¹…ÿš¹†ÿ×¹‡ÿš¹ˆÿ×¹‰ÿš¹Šÿ×¹Œÿ×¹ÿš¹–ÿù˜)¹šÿùžÿù¤ÿù¦ÿù¨)¹¬ÿù®ÿù°ÿù±ÿ×¹²ÿš¹³ÿ×¹´ÿš¹Àÿ®¹Âÿ®¹ÄÿùÆÿ®¹Èÿ®¹ÍÿùÎÿ®¹Ïÿš¹ÑÿùÓÿùÕÿ®¹×ÿùÙÿ…¹Úÿ®¹Ûÿ…¹Üÿ®¹Ýÿ…¹Þÿ®¹àÿš¹áÿì¹âÿ®¹ãÿì¹äÿ®¹ìÿùîÿùïÿ×¹ðÿš¹ñÿ×¹òÿš¹óÿ×¹ôÿš¹þÿ®¹ÿùÿù ÿ®¹ ÿš¹ ÿ®¹ ÿš¹ÿ×¹ÿ×¹ÿ®¹ÿš¹ÿùÿ×¹ÿš¹ÿì¹ÿš¹ÿ®¹ÿšºÿ®ºÿ®ºÎÿìºÕÿìºòÿìºÿ®º ÿ®ºsÿìºÏÿìºÿìºÿ컟ÿ×»£á»¸ÿ×»»ÿ×»¾ÿûÜÿ×»áÿ®»äÿ×»lÿ×»{=»}ÿì»~ÿ×»„ÿ×»†ÿ×»ˆÿ×»Šÿ×»Œÿ×»ªÿ×»±ÿ×»³ÿ×»¶ÿ×»¾ÿ×»Àÿ®»Âÿ®»ÅÿûÆÿ×»ÇÿûÈÿ×»Õÿ®»ïÿ×»ñÿ×»óÿ×»þÿ®»ÿ×»ÿ×»ÿ×»ÿ×¼Ïÿì¼Øÿì¼Ûÿì¼Þÿì¼áÿì¼êÿì¼íÿì¼jÿì¼ÿì¼…ÿ켇ÿ켉ÿì¼ÿì¼²ÿì¼´ÿì¼Àÿì¼Âÿì¼Õÿì¼àÿì¼ðÿì¼òÿì¼ôÿì¼þÿì¼ ÿì¼ ÿì¼ÿ×¼ÿ×¼ÿì¼ÿì½£á½ê)½ÿ×½ÿ×¾ÿì¾ ÿì¾ÿì¾ ÿì¿£á¿ê)¿ÿ׿ÿ×ÀÿìÀ ÿìÀÿìÀ ÿìÃÿÃà ÿÃÃÿ×æÿ×üÿ…ÃÁÿ®ÃÄÿ×ÃÜÿ×ÃÝÿìÃáÿìÃäÿ×ÃöÿìÃÿÃà ÿÃÃ|ÿ®Ã€ÿÃÂÿÃéÿ×êÿ×õÿ…öÿ×÷ÿšÃ¹ÿšÃ½ÿ×þÿ×ÿÿ®ÃÀÿìÃÁÿ®ÃÂÿìÃÔÿ®ÃÕÿìÃøÿìÃúÿìÃüÿìÃýÿ®Ãþÿìà ÿ®Ãÿ×Ãÿ®Ãÿ×Ãÿ×Ãÿ×ÄÿšÄ ÿšÄÜÿ×ÄÝÿ×Ääÿ×Äöÿ×ÄÿšÄ ÿšÄªÿ×Ķÿ×ĸÿ×ĺÿ׾ÿ×Äøÿ×Äúÿ×Äüÿ×Äÿ®Äÿ®Äÿ׿ÿ×Å€ÿìÅ‚ÿìŵÿ×Å·ÿìŹÿìÅ ÿìÅÿìÆÿìÆ ÿìÆÿìÆ ÿìǼÿ×Ç€ÿìÇ‚ÿìǵÿ×Ç·ÿìǹÿìÇ ÿìÇÿìÈÿìÈ ÿìÈÿìÈ ÿìÊŸÿ×ʸÿ×Ê»ÿ×ʾÿ×ÊÁÿ×Êáÿ×Êlÿ×Ê|ÿ×Ê~ÿ×Ê„ÿ×ʆÿ×ʈÿ×ÊŠÿ×ÊŒÿ×ʱÿ×ʳÿ×Ê¿ÿ×ÊÀÿ×ÊÁÿ×ÊÂÿ×ÊÅÿšÊÇÿšÊÔÿ×ÊÕÿ×Êïÿ×Êñÿ×Êóÿ×Êýÿ×Êþÿ×Ê ÿ×Ê ÿ×Êÿ×Êÿ×Êÿ×ÊÿìËÏÿ×ËØÿ×ËÛÿ×ËÞÿ×Ëáÿ×Ëêÿ×Ëíÿ×Ëjÿ×Ëÿ×Ë…ÿסÿ×ˉÿ×Ëÿ×˲ÿ×Ë´ÿ×ËÀÿ×ËÂÿ×ËÆÿ×ËÈÿ×ËÕÿ×Ëàÿ×Ëðÿ×Ëòÿ×Ëôÿ×Ëþÿ×Ë ÿ×Ë ÿ×Ëÿ×Ëÿ×ÌÿÃÌ ÿÃÌ£f̼ÿ×̾ÿ×ÌÁÿ®ÌÜÿÃÌáÿ×ÌäÿÃÌÿÃÌ ÿÃÌmÿìÌ|ÿ®Ì€ÿ×ÌÿìÌ‚ÿ×̃ÿìÌ‹ÿì̪ÿÃ̵ÿ×̶ÿÃÌ·ÿ×̸ÿì̹ÿ×̺ÿì̾ÿÃÌ¿ÿ®ÌÀÿ×ÌÁÿ®ÌÂÿ×ÌÅÿÃÌÆÿ×ÌÇÿÃÌÈÿ×ÌÔÿ®ÌÕÿ×Ìýÿ®Ìþÿ×Ì ÿ×ÌÿÃÌÿ×ÌÿÃÌÿÃÍáÿ×ÍÀÿ×ÍÂÿ×ÍÕÿ×Íþÿ×ΣáÎê)Îÿ×Îÿ×ÏÿìÏ ÿìÏÿìÏ ÿìÒ£áÒê)Òÿ×Òÿ×ÓÿìÓ ÿìÓÿìÓ ÿìÖ£áÖê)Öÿ×Öÿ××ÿì× ÿì×ÿì× ÿìÙÿqÙ ÿqÙÿšÙ¦ÿšÙ¼ÿqÙ¾ÿ×ÙÁÿšÙÄÿšÙÜÿ×Ùáÿ×Ùäÿ×ÙÿqÙ ÿqÙnÿ×Ù|ÿšÙ€ÿ®Ù‚ÿ®Ù—ÿ×Ù›ÿ×Ù§ÿ×Ù©ÿšÙªÿ×ÙµÿqÙ¶ÿ×Ù·ÿ…Ù¹ÿ…Ù½ÿšÙ¾ÿ×Ù¿ÿšÙÀÿ×ÙÁÿšÙÂÿ×ÙÅÿšÙÇÿšÙÔÿšÙÕÿ×Ùáÿ×Ùãÿ×ÙýÿšÙþÿ×Ùÿ×Ù ÿqÙÿ×ÙÿqÙÿ×ÙÿšÙÿ×ÚÿìÚ ÿìÚÿìÚ ÿìÛÿqÛ ÿqÛÿšÛ¦ÿšÛ¼ÿqÛ¾ÿ×ÛÁÿšÛÄÿšÛÜÿ×Ûáÿ×Ûäÿ×ÛÿqÛ ÿqÛnÿ×Û|ÿšÛ€ÿ®Û‚ÿ®Û—ÿ×Û›ÿ×Û§ÿ×Û©ÿšÛªÿ×ÛµÿqÛ¶ÿ×Û·ÿ…Û¹ÿ…Û½ÿšÛ¾ÿ×Û¿ÿšÛÀÿ×ÛÁÿšÛÂÿ×ÛÅÿšÛÇÿšÛÔÿšÛÕÿ×Ûáÿ×Ûãÿ×ÛýÿšÛþÿ×Ûÿ×Û ÿqÛÿ×ÛÿqÛÿ×ÛÿšÛÿ×ÜÿìÜ ÿìÜÿìÜ ÿìÞÿìÞ ÿìÞÿìÞ ÿìàÿìà ÿìàÿìà ÿìáÿ®áÿ®áÿìá¤ÿ×á¦ÿìá¨ÿ×áªÿ×á®ÿ×á°ÿ×á±ÿìáµÿ×á¼ÿÃá½ÿ×á¿ÿ×áÁÿ×áÄÿìáÇÿìáÎÿìáÕÿìáòÿìáÿ®á ÿ®árÿ×ásÿìázÿìá|ÿ×á€ÿìá‚ÿìáŸÿ×á¡ÿìá©ÿìáµÿÃá·ÿìá¹ÿìá»ÿ×á½ÿìá¿ÿ×áÁÿ×áÊÿ×áÎÿ×áÏÿìáÔÿ×áÙÿ×áÛÿ×áÝÿ×áåÿ×áçÿìáõÿìá÷ÿ×áùÿ×áûÿ×áýÿ×áÿ×áÿ×á ÿ×áÿ×áÿ×áÿìáÿìáÿ×áÿìâÿìâ ÿìâÐÿ×âÜÿìâÝÿìâßÿ×âáÿìâäÿìâöÿìâÿìâ ÿìâ ÿ×âªÿìâ¶ÿìâ¼ÿ×â¾ÿìâÀÿìâÂÿìâËÿ×âÕÿìâæÿ×âøÿìâúÿìâüÿìâþÿìâÿ×âÿ×âÿìâÿìâÿìãÿ®ãÿ®ãÿìã¤ÿ×ã¦ÿìã¨ÿ×ãªÿ×ã®ÿ×ã°ÿ×ã±ÿìãµÿ×ã¼ÿÃã½ÿ×ã¿ÿ×ãÁÿ×ãÄÿìãÇÿìãÎÿìãÕÿìãòÿìãÿ®ã ÿ®ãrÿ×ãsÿìãzÿìã|ÿ×ã€ÿìã‚ÿìãŸÿ×ã¡ÿìã©ÿìãµÿÃã·ÿìã¹ÿìã»ÿ×ã½ÿìã¿ÿ×ãÁÿ×ãÊÿ×ãÎÿ×ãÏÿìãÔÿ×ãÙÿ×ãÛÿ×ãÝÿ×ãåÿ×ãçÿìãõÿìã÷ÿ×ãùÿ×ãûÿ×ãýÿ×ãÿ×ãÿ×ã ÿ×ãÿ×ãÿ×ãÿìãÿìãÿ×ãÿìäÿìä ÿìäÐÿ×äÜÿìäÝÿìäßÿ×äáÿìääÿìäöÿìäÿìä ÿìä ÿ×äªÿìä¶ÿìä¼ÿ×ä¾ÿìäÀÿìäÂÿìäËÿ×äÕÿìäæÿ×äøÿìäúÿìäüÿìäþÿìäÿ×äÿ×äÿìäÿìäÿìåŸÿ×å¸ÿ×å»ÿ×å¾ÿ×åÁÿ×åáÿ×ålÿ×å|ÿ×å~ÿ×å„ÿ×å†ÿ×åˆÿ×åŠÿ×åŒÿ×å±ÿ×å³ÿ×å¿ÿ×åÀÿ×åÁÿ×åÂÿ×åÅÿšåÇÿšåÔÿ×åÕÿ×åïÿ×åñÿ×åóÿ×åýÿ×åþÿ×å ÿ×å ÿ×åÿ×åÿ×åÿ×åÿìæÏÿ×æØÿ×æÛÿ×æÞÿ×æáÿ×æêÿ×æíÿ×æjÿ×æÿ×æ…ÿ×æ‡ÿ×æ‰ÿ×æÿ×æ²ÿ×æ´ÿ×æÀÿ×æÂÿ×æÆÿ×æÈÿ×æÕÿ×æàÿ×æðÿ×æòÿ×æôÿ×æþÿ×æ ÿ×æ ÿ×æÿ×æÿ×çÿ®çÿ®çÿ®ç ÿ®ç€ÿìç‚ÿìç·ÿìç¹ÿìç ÿ×çÿ×èé)éÿìé ÿìéÿìé ÿìéÿ×éÿ×ïÿ®ïÿ®ïÿìï¤ÿ×ï¦ÿìï¨ÿ×ïªÿ×ï®ÿ×ï°ÿ×ï±ÿìïµÿ×ï¼ÿÃï½ÿ×ï¿ÿ×ïÁÿ×ïÄÿìïÇÿìïÎÿìïÕÿìïòÿìïÿ®ï ÿ®ïrÿ×ïsÿìïzÿìï|ÿ×ï€ÿìï‚ÿìïŸÿ×ï¡ÿìï©ÿìïµÿÃï·ÿìï¹ÿìï»ÿ×ï½ÿìï¿ÿ×ïÁÿ×ïÊÿ×ïÎÿ×ïÏÿìïÔÿ×ïÙÿ×ïÛÿ×ïÝÿ×ïåÿ×ïçÿìïõÿìï÷ÿ×ïùÿ×ïûÿ×ïýÿ×ïÿ×ïÿ×ï ÿ×ïÿ×ïÿ×ïÿìïÿìïÿ×ïÿìðÿìð ÿìðÐÿ×ðÜÿìðÝÿìðßÿ×ðáÿìðäÿìðöÿìðÿìð ÿìð ÿ×ðªÿìð¶ÿìð¼ÿ×ð¾ÿìðÀÿìðÂÿìðËÿ×ðÕÿìðæÿ×ðøÿìðúÿìðüÿìðþÿìðÿ×ðÿ×ðÿìðÿìðÿìñÿ®ñÿ®ñÿìñ¤ÿ×ñ¦ÿìñ¨ÿ×ñªÿ×ñ®ÿ×ñ°ÿ×ñ±ÿìñµÿ×ñ¼ÿÃñ½ÿ×ñ¿ÿ×ñÁÿ×ñÄÿìñÇÿìñÎÿìñÕÿìñòÿìñÿ®ñ ÿ®ñrÿ×ñsÿìñzÿìñ|ÿ×ñ€ÿìñ‚ÿìñŸÿ×ñ¡ÿìñ©ÿìñµÿÃñ·ÿìñ¹ÿìñ»ÿ×ñ½ÿìñ¿ÿ×ñÁÿ×ñÊÿ×ñÎÿ×ñÏÿìñÔÿ×ñÙÿ×ñÛÿ×ñÝÿ×ñåÿ×ñçÿìñõÿìñ÷ÿ×ñùÿ×ñûÿ×ñýÿ×ñÿ×ñÿ×ñ ÿ×ñÿ×ñÿ×ñÿìñÿìñÿ×ñÿìòÿìò ÿìòÐÿ×òÜÿìòÝÿìòßÿ×òáÿìòäÿìòöÿìòÿìò ÿìò ÿ×òªÿìò¶ÿìò¼ÿ×ò¾ÿìòÀÿìòÂÿìòËÿ×òÕÿìòæÿ×òøÿìòúÿìòüÿìòþÿìòÿ×òÿ×òÿìòÿìòÿìóÿ®óÿ®óÿìó¤ÿ×ó¦ÿìó¨ÿ×óªÿ×ó®ÿ×ó°ÿ×ó±ÿìóµÿ×ó¼ÿÃó½ÿ×ó¿ÿ×óÁÿ×óÄÿìóÇÿìóÎÿìóÕÿìóòÿìóÿ®ó ÿ®órÿ×ósÿìózÿìó|ÿ×ó€ÿìó‚ÿìóŸÿ×ó¡ÿìó©ÿìóµÿÃó·ÿìó¹ÿìó»ÿ×ó½ÿìó¿ÿ×óÁÿ×óÊÿ×óÎÿ×óÏÿìóÔÿ×óÙÿ×óÛÿ×óÝÿ×óåÿ×óçÿìóõÿìó÷ÿ×óùÿ×óûÿ×óýÿ×óÿ×óÿ×ó ÿ×óÿ×óÿ×óÿìóÿìóÿ×óÿìôÿìô ÿìôÐÿ×ôÜÿìôÝÿìôßÿ×ôáÿìôäÿìôöÿìôÿìô ÿìô ÿ×ôªÿìô¶ÿìô¼ÿ×ô¾ÿìôÀÿìôÂÿìôËÿ×ôÕÿìôæÿ×ôøÿìôúÿìôüÿìôþÿìôÿ×ôÿ×ôÿìôÿìôÿìõÿ®õÿ®õÿìõ¤ÿ×õ¦ÿìõ¨ÿ×õªÿ×õ®ÿ×õ°ÿ×õ±ÿìõµÿ×õ¼ÿÃõ½ÿ×õ¿ÿ×õÁÿ×õÄÿìõÇÿìõÎÿìõÕÿìõòÿìõÿ®õ ÿ®õrÿ×õsÿìõzÿìõ|ÿ×õ€ÿìõ‚ÿìõŸÿ×õ¡ÿìõ©ÿìõµÿÃõ·ÿìõ¹ÿìõ»ÿ×õ½ÿìõ¿ÿ×õÁÿ×õÊÿ×õÎÿ×õÏÿìõÔÿ×õÙÿ×õÛÿ×õÝÿ×õåÿ×õçÿìõõÿìõ÷ÿ×õùÿ×õûÿ×õýÿ×õÿ×õÿ×õ ÿ×õÿ×õÿ×õÿìõÿìõÿ×õÿìöÿìö ÿìöÐÿ×öÜÿìöÝÿìößÿ×öáÿìöäÿìööÿìöÿìö ÿìö ÿ×öªÿìö¶ÿìö¼ÿ×ö¾ÿìöÀÿìöÂÿìöËÿ×öÕÿìöæÿ×öøÿìöúÿìöüÿìöþÿìöÿ×öÿ×öÿìöÿìöÿì÷ÿ…÷ÿ…÷Ÿÿì÷¤ÿš÷ªÿq÷®ÿš÷µÿš÷¸ÿì÷»ÿì÷¾ÿÃ÷Éÿì÷Îÿ®÷Ïÿ×÷Õÿ®÷Øÿ×÷Ûÿ×÷Þÿ×÷áÿ×÷êÿ×÷ëf÷íÿ×÷îÿì÷òÿ®÷ôf÷ÿ…÷ ÿ…÷jÿ×÷lÿì÷rÿq÷sÿ®÷~ÿì÷ÿ×÷„ÿì÷…ÿ×÷†ÿì÷‡ÿ×÷ˆÿì÷‰ÿ×÷Šÿì÷Œÿì÷ÿ×÷˜f÷¨f÷±ÿì÷²ÿ×÷³ÿì÷´ÿ×÷Àÿ×÷Âÿ×÷Åÿ×÷ÆÿÃ÷Çÿ×÷ÈÿÃ÷Îÿš÷Ïÿ®÷Õÿ×÷Ùÿq÷Ûÿq÷Ýÿq÷àÿ×÷ïÿì÷ðÿ×÷ñÿì÷òÿ×÷óÿì÷ôÿ×÷þÿ×÷ ÿq÷ ÿ×÷ ÿq÷ ÿ×÷ÿš÷ÿ®÷ÿì÷ÿ×÷ÿ×÷ÿš÷ÿ®øÿ®øÿ®øÎÿ×øÕÿ×øòÿ×øÿ®ø ÿ®øsÿ×øÏÿ×øÿ×øÿ×ùÿ…ùÿ…ùŸÿìù¤ÿšùªÿqù®ÿšùµÿšù¸ÿìù»ÿìù¾ÿÃùÉÿìùÎÿ®ùÏÿ×ùÕÿ®ùØÿ×ùÛÿ×ùÞÿ×ùáÿ×ùêÿ×ùëfùíÿ×ùîÿìùòÿ®ùôfùÿ…ù ÿ…ùjÿ×ùlÿìùrÿqùsÿ®ù~ÿìùÿ×ù„ÿìù…ÿ×ù†ÿìù‡ÿ×ùˆÿìù‰ÿ×ùŠÿìùŒÿìùÿ×ù˜fù¨fù±ÿìù²ÿ×ù³ÿìù´ÿ×ùÀÿ×ùÂÿ×ùÅÿ×ùÆÿÃùÇÿ×ùÈÿÃùÎÿšùÏÿ®ùÕÿ×ùÙÿqùÛÿqùÝÿqùàÿ×ùïÿìùðÿ×ùñÿìùòÿ×ùóÿìùôÿ×ùþÿ×ù ÿqù ÿ×ù ÿqù ÿ×ùÿšùÿ®ùÿìùÿ×ùÿ×ùÿšùÿ®úÿ®úÿ®úÎÿ×úÕÿ×úòÿ×úÿ®ú ÿ®úsÿ×úÏÿ×úÿ×úÿ×ûÿ…ûÿ…ûŸÿìû¤ÿšûªÿqû®ÿšûµÿšû¸ÿìû»ÿìû¾ÿÃûÉÿìûÎÿ®ûÏÿ×ûÕÿ®ûØÿ×ûÛÿ×ûÞÿ×ûáÿ×ûêÿ×ûëfûíÿ×ûîÿìûòÿ®ûôfûÿ…û ÿ…ûjÿ×ûlÿìûrÿqûsÿ®û~ÿìûÿ×û„ÿìû…ÿ×û†ÿìû‡ÿ×ûˆÿìû‰ÿ×ûŠÿìûŒÿìûÿ×û˜fû¨fû±ÿìû²ÿ×û³ÿìû´ÿ×ûÀÿ×ûÂÿ×ûÅÿ×ûÆÿÃûÇÿ×ûÈÿÃûÎÿšûÏÿ®ûÕÿ×ûÙÿqûÛÿqûÝÿqûàÿ×ûïÿìûðÿ×ûñÿìûòÿ×ûóÿìûôÿ×ûþÿ×û ÿqû ÿ×û ÿqû ÿ×ûÿšûÿ®ûÿìûÿ×ûÿ×ûÿšûÿ®üÿ®üÿ®üÎÿ×üÕÿ×üòÿ×üÿ®ü ÿ®üsÿ×üÏÿ×üÿ×üÿ×ÿÿ…ÿÿ®ÿÿ…ÿŸÿ×ÿ¤ÿšÿªÿqÿ®ÿšÿµÿšÿ¸ÿ×ÿ»ÿ×ÿ¼)ÿ¾ÿ®ÿÌÿšÿÍÿšÿÎÿ…ÿÏÿqÿÐÿ×ÿÑÿ×ÿÒÿšÿÓÿšÿÔÿšÿÕÿ…ÿÖÿšÿ×ÿšÿØÿqÿÙÿšÿÚÿšÿÛÿqÿÜÿ®ÿÝÿ®ÿÞÿqÿßÿ×ÿàÿšÿáÿšÿâÿšÿãÿšÿäÿ®ÿåÿšÿæÿšÿçÿ×ÿèÿšÿéÿÃÿêÿqÿìÿšÿíÿqÿîÿ…ÿòÿ…ÿóÿšÿõÿšÿöÿ®ÿ÷ÿšÿùÿšÿÿ®ÿÿ®ÿÿ®ÿÿ…ÿ ÿ…ÿjÿqÿkÿšÿlÿ×ÿmÿ×ÿqÿšÿrÿqÿsÿ…ÿuÿšÿwÿšÿyÿšÿ}ÿšÿ~ÿ×ÿÿqÿÿ×ÿƒÿ×ÿ„ÿ×ÿ…ÿqÿ†ÿ×ÿ‡ÿqÿˆÿ×ÿ‰ÿqÿŠÿ×ÿ‹ÿ×ÿŒÿ×ÿÿqÿ–ÿšÿšÿšÿžÿšÿ ÿ×ÿ¢ÿ×ÿ¤ÿšÿ¦ÿšÿªÿ®ÿ¬ÿšÿ®ÿšÿ°ÿšÿ±ÿ×ÿ²ÿqÿ³ÿ×ÿ´ÿqÿµ)ÿ¶ÿ®ÿ¸ÿ®ÿºÿ®ÿ¼ÿ×ÿ¾ÿ®ÿÀÿšÿÂÿšÿÄÿšÿÅÿšÿÆÿqÿÇÿšÿÈÿqÿËÿ×ÿÍÿšÿÎÿšÿÏÿ…ÿÑÿšÿÓÿšÿÕÿšÿ×ÿšÿÙÿqÿÛÿqÿÝÿqÿàÿqÿæÿ×ÿèÿ×ÿêÿÃÿìÿšÿîÿšÿïÿ×ÿðÿqÿñÿ×ÿòÿqÿóÿ×ÿôÿqÿöÿ×ÿøÿ®ÿúÿ®ÿüÿ®ÿþÿšÿÿšÿÿšÿÿ×ÿÿ×ÿ ÿqÿ ÿqÿ ÿqÿ ÿqÿÿšÿÿšÿÿšÿÿ…ÿÿšÿÿ×ÿÿqÿÿ®ÿÿqÿÿšÿÿ…ÿšÿ×ÿšÎÿÃÏÿìÕÿÃØÿìÛÿìÞÿìêÿìíÿìòÿÃÿ×ÿ×ÿ×ÿš ÿšjÿìsÿÃÿì…ÿì‡ÿì‰ÿìÿì²ÿì´ÿìÏÿÃàÿìðÿìòÿìôÿì ÿì ÿìÿÃÿìÿìÿÃÿšÿ×ÿš)Ÿÿפÿ®¦)ªÿ…®ÿ®µÿ®¸ÿ×»ÿ×¼)¾ÿÃÄ)ÌÿÃÍÿÃÎÿšÏÿ®Ðÿ×Ñÿ×ÒÿÃÓÿÃÔÿÃÕÿšÖÿÃ×ÿÃØÿ®ÙÿÃÚÿÃÛÿ®Þÿ®ßÿ×àÿÃáÿšâÿÃãÿÃåÿÃæÿÃçÿ×èÿÃêÿ®ë)ìÿÃíÿ®îÿÃòÿšóÿÃô)õÿÃ÷ÿÃùÿÃÿ×ÿ×ÿ×ÿš ÿšjÿ®kÿÃlÿ×qÿÃrÿ…sÿšuÿÃwÿ×yÿÃ}ÿÃ~ÿ×ÿ®„ÿ×…ÿ®†ÿׇÿ®ˆÿ׉ÿ®Šÿ׌ÿ×ÿ®–ÿØ)šÿÞÿàÿ×¢ÿפÿæÿè)©)¬ÿîÿðÿñÿײÿ®³ÿ×´ÿ®µ)¼ÿ×½)ÀÿšÂÿšÄÿÃÅÿ×ÆÿÃÇÿ×ÈÿÃËÿ×ÍÿÃÎÿ®ÏÿšÑÿÃÓÿÃÕÿš×ÿÃÙÿ…Ûÿ…Ýÿ…àÿ®æÿ×èÿ×ìÿÃîÿÃïÿ×ðÿ®ñÿ×òÿ®óÿ×ôÿ®öÿ×þÿšÿÃÿÃÿ×ÿ× ÿš ÿ® ÿš ÿ®ÿ×ÿ×ÿ®ÿšÿÃÿ×ÿ®)ÿ®ÿ®ÿšÿÃÿÃÎÿÃÏÿ×ÕÿÃØÿ×Ûÿ×Þÿ×êÿ×íÿ×òÿÃÿà ÿÃjÿ×sÿÃÿ×…ÿׇÿ׉ÿ×ÿײÿ×´ÿ×ÏÿÃàÿ×ðÿ×òÿ×ôÿ× ÿ× ÿ×ÿÃÿ×ÿ×ÿßÿ×£á¸ÿ×»ÿ×¾ÿÃÜÿ×áÿ®äÿ×lÿ×{=}ÿì~ÿׄÿ׆ÿ׈ÿ׊ÿ׌ÿתÿ×±ÿ׳ÿ׶ÿ×¾ÿ×Àÿ®Âÿ®ÅÿÃÆÿ×ÇÿÃÈÿ×Õÿ®ïÿ×ñÿ×óÿ×þÿ®ÿ×ÿ×ÿ×ÿ×ÏÿìØÿìÛÿìÞÿìáÿìêÿìíÿìjÿìÿì…ÿì‡ÿì‰ÿìÿì²ÿì´ÿìÀÿìÂÿìÕÿìàÿìðÿìòÿìôÿìþÿì ÿì ÿìÿ×ÿ×ÿìÿìŸÿ׸ÿ×»ÿ×¾ÿ×Áÿ×áÿ×lÿ×|ÿ×~ÿׄÿ׆ÿ׈ÿ׊ÿ׌ÿ×±ÿ׳ÿ׿ÿ×Àÿ×Áÿ×Âÿ×ÅÿšÇÿšÔÿ×Õÿ×ïÿ×ñÿ×óÿ×ýÿ×þÿ× ÿ× ÿ×ÿ×ÿ×ÿ×ÿìÏÿìØÿìÛÿìÞÿìáÿìêÿìíÿìjÿìÿì…ÿì‡ÿì‰ÿìÿì²ÿì´ÿìÀÿìÂÿìÕÿìàÿìðÿìòÿìôÿìþÿì ÿì ÿìÿ×ÿ×ÿìÿì ÿš ÿš ÿ® ¦ÿ® ¨ÿà ªÿà °ÿà ¼ÿq ½ÿà ¿ÿà Áÿà Äÿ® Ðÿ× Üÿà ßÿ× áÿ× äÿà ÿš  ÿš rÿà vÿ× |ÿà €ÿà ‚ÿà Ÿÿà  ÿ× ©ÿ® ªÿà µÿq ¶ÿà ·ÿà ¹ÿà »ÿà ¼ÿ× ½ÿ® ¾ÿà ¿ÿà Àÿ× Áÿà Âÿ× Êÿà Ëÿ× Ôÿà Õÿ× Ùÿà Ûÿà Ýÿà åÿà æÿ× ÷ÿà ùÿà ûÿà ýÿà þÿ× ÿà ÿ× ÿà ÿ×  ÿ× ÿ× ÿ× ÿ× ÿ® ÿà ÿš ÿš Ðÿ× Üÿà Ýÿ× ßÿ× áÿ× äÿà öÿ× ÿš  ÿš  ÿ× ªÿà ¶ÿà ¼ÿ× ¾ÿà Àÿ× Âÿ× Ëÿ× Õÿ× æÿ× øÿ× úÿ× üÿ× þÿ× ÿ× ÿ× ÿš ÿš ÿà ÿš ÿš ÿ® ¦ÿ® ¨ÿà ªÿà °ÿà ¼ÿq ½ÿà ¿ÿà Áÿà Äÿ® Ðÿ× Üÿà ßÿ× áÿ× äÿà ÿš  ÿš rÿà vÿ× |ÿà €ÿà ‚ÿà Ÿÿà  ÿ× ©ÿ® ªÿà µÿq ¶ÿà ·ÿà ¹ÿà »ÿà ¼ÿ× ½ÿ® ¾ÿà ¿ÿà Àÿ× Áÿà Âÿ× Êÿà Ëÿ× Ôÿà Õÿ× Ùÿà Ûÿà Ýÿà åÿà æÿ× ÷ÿà ùÿà ûÿà ýÿà þÿ× ÿà ÿ× ÿà ÿ×  ÿ× ÿ× ÿ× ÿ× ÿ® ÿÃÿš ÿšÐÿ×ÜÿÃÝÿ×ßÿ×áÿ×äÿÃöÿ×ÿš ÿš ÿתÿöÿüÿ×¾ÿÃÀÿ×Âÿ×Ëÿ×Õÿ×æÿ×øÿ×úÿ×üÿ×þÿ×ÿ×ÿ×ÿšÿšÿãáê)ÿ×ÿ×ÿì ÿìÿì ÿìÿš ÿšÿ®¦ÿ®¨ÿêÿðÿüÿq½ÿÿÿÃÁÿÃÄÿ®Ðÿ×ÜÿÃßÿ×áÿ×äÿÃÿš ÿšrÿÃvÿ×|ÿÀÿÂÿßÿàÿשÿ®ªÿõÿq¶ÿ÷ÿùÿûÿüÿ×½ÿ®¾ÿÿÿÃÀÿ×ÁÿÃÂÿ×ÊÿÃËÿ×ÔÿÃÕÿ×ÙÿÃÛÿÃÝÿÃåÿÃæÿ×÷ÿÃùÿÃûÿÃýÿÃþÿ×ÿÃÿ×ÿÃÿ× ÿ×ÿ×ÿ×ÿ×ÿ®ÿÃÿš ÿšÐÿ×ÜÿÃÝÿ×ßÿ×áÿ×äÿÃöÿ×ÿš ÿš ÿתÿöÿüÿ×¾ÿÃÀÿ×Âÿ×Ëÿ×Õÿ×æÿ×øÿ×úÿ×üÿ×þÿ×ÿ×ÿ×ÿšÿšÿÃÿš ÿšÿ®¦ÿ®¨ÿêÿðÿüÿq½ÿÿÿÃÁÿÃÄÿ®Ðÿ×ÜÿÃßÿ×áÿ×äÿÃÿš ÿšrÿÃvÿ×|ÿÀÿÂÿßÿàÿשÿ®ªÿõÿq¶ÿ÷ÿùÿûÿüÿ×½ÿ®¾ÿÿÿÃÀÿ×ÁÿÃÂÿ×ÊÿÃËÿ×ÔÿÃÕÿ×ÙÿÃÛÿÃÝÿÃåÿÃæÿ×÷ÿÃùÿÃûÿÃýÿÃþÿ×ÿÃÿ×ÿÃÿ× ÿ×ÿ×ÿ×ÿ×ÿ®ÿÃÿš ÿšÐÿ×ÜÿÃÝÿ×ßÿ×áÿ×äÿÃöÿ×ÿš ÿš ÿתÿöÿüÿ×¾ÿÃÀÿ×Âÿ×Ëÿ×Õÿ×æÿ×øÿ×úÿ×üÿ×þÿ×ÿ×ÿ×ÿšÿšÿÃÿ®ÿ®ªÿì°ÿ×¼ÿ׿ÿ×ÿ® ÿ®rÿì€ÿì‚ÿìŸÿ×µÿ×·ÿì¹ÿì»ÿ×Êÿ×ÙÿìÛÿìÝÿìåÿ×ÿ×ÿ×ÿ× ÿ×ÐÿìÝÿìßÿìöÿìÿ× ÿ× ÿì¼ÿìËÿìæÿìøÿìúÿìüÿìÿìÿìÿ×ÿ×ÿ® ÿ®ÿæÿêÿ×°ÿ×¼ÿÿÿ×Áÿ×ÄÿÃÜÿ×äÿ×ÿ® ÿ®rÿ×|ÿ×€ÿׂÿןÿשÿêÿ×µÿöÿ×·ÿ×¹ÿ×»ÿ×½ÿþÿ׿ÿ×Áÿ×Êÿ×Ôÿ×Ùÿ×Ûÿ×Ýÿ×åÿ×ýÿ×ÿ×ÿ× ÿ×ÿ×ÿÃÿ×ÿš ÿšÐÿ×ÜÿÃÝÿ×ßÿ×áÿ×äÿÃöÿ×ÿš ÿš ÿתÿöÿüÿ×¾ÿÃÀÿ×Âÿ×Ëÿ×Õÿ×æÿ×øÿ×úÿ×üÿ×þÿ×ÿ×ÿ×ÿšÿšÿÃáÿ×Àÿ×Âÿ×Õÿ×þÿ×£áê)ÿ×ÿ×ÿì ÿìÿì ÿìÿq ÿq&ÿ×*ÿ×- 2ÿ×4ÿ×7ÿq9ÿ®:ÿ®<ÿ…‰ÿ×”ÿוÿ×–ÿ×—ÿטÿךÿןÿ…Èÿ×Êÿ×Ìÿ×Îÿ×Þÿ×àÿ×âÿ×äÿ×ÿ×ÿ×ÿ×ÿ×$ÿq&ÿq6ÿ®8ÿ…:ÿ…Gÿ×úÿ®üÿ®þÿ®ÿ…ÿq ÿq_ÿ×Iÿ×Kÿ×Mÿ×Oÿ×Qÿ×Sÿ×Uÿ×Wÿ×Yÿ×[ÿ×]ÿ×_ÿ×oÿ…qÿ…sÿ…ÿqÿì ÿìÿì ÿìÿq ÿq&ÿ×*ÿ×- 2ÿ×4ÿ×7ÿq9ÿ®:ÿ®<ÿ…‰ÿ×”ÿוÿ×–ÿ×—ÿטÿךÿןÿ…Èÿ×Êÿ×Ìÿ×Îÿ×Þÿ×àÿ×âÿ×äÿ×ÿ×ÿ×ÿ×ÿ×$ÿq&ÿq6ÿ®8ÿ…:ÿ…Gÿ×úÿ®üÿ®þÿ®ÿ…ÿq ÿq_ÿ×Iÿ×Kÿ×Mÿ×Oÿ×Qÿ×Sÿ×Uÿ×Wÿ×Yÿ×[ÿ×]ÿ×_ÿ×oÿ…qÿ…sÿ…ÿq ÿì ÿì ÿì  ÿì!ÿq! ÿq!&ÿ×!*ÿ×!- !2ÿ×!4ÿ×!7ÿq!9ÿ®!:ÿ®!<ÿ…!‰ÿ×!”ÿ×!•ÿ×!–ÿ×!—ÿ×!˜ÿ×!šÿ×!Ÿÿ…!Èÿ×!Êÿ×!Ìÿ×!Îÿ×!Þÿ×!àÿ×!âÿ×!äÿ×!ÿ×!ÿ×!ÿ×!ÿ×!$ÿq!&ÿq!6ÿ®!8ÿ…!:ÿ…!Gÿ×!úÿ®!üÿ®!þÿ®!ÿ…!ÿq! ÿq!_ÿ×!Iÿ×!Kÿ×!Mÿ×!Oÿ×!Qÿ×!Sÿ×!Uÿ×!Wÿ×!Yÿ×![ÿ×!]ÿ×!_ÿ×!oÿ…!qÿ…!sÿ…!ÿq"ÿì" ÿì"ÿì" ÿì#ÿq# ÿq#&ÿ×#*ÿ×#- #2ÿ×#4ÿ×#7ÿq#9ÿ®#:ÿ®#<ÿ…#‰ÿ×#”ÿ×#•ÿ×#–ÿ×#—ÿ×#˜ÿ×#šÿ×#Ÿÿ…#Èÿ×#Êÿ×#Ìÿ×#Îÿ×#Þÿ×#àÿ×#âÿ×#äÿ×#ÿ×#ÿ×#ÿ×#ÿ×#$ÿq#&ÿq#6ÿ®#8ÿ…#:ÿ…#Gÿ×#úÿ®#üÿ®#þÿ®#ÿ…#ÿq# ÿq#_ÿ×#Iÿ×#Kÿ×#Mÿ×#Oÿ×#Qÿ×#Sÿ×#Uÿ×#Wÿ×#Yÿ×#[ÿ×#]ÿ×#_ÿ×#oÿ…#qÿ…#sÿ…#ÿq$ÿì$ ÿì$ÿì$ ÿì%ÿq% ÿq%&ÿ×%*ÿ×%- %2ÿ×%4ÿ×%7ÿq%9ÿ®%:ÿ®%<ÿ…%‰ÿ×%”ÿ×%•ÿ×%–ÿ×%—ÿ×%˜ÿ×%šÿ×%Ÿÿ…%Èÿ×%Êÿ×%Ìÿ×%Îÿ×%Þÿ×%àÿ×%âÿ×%äÿ×%ÿ×%ÿ×%ÿ×%ÿ×%$ÿq%&ÿq%6ÿ®%8ÿ…%:ÿ…%Gÿ×%úÿ®%üÿ®%þÿ®%ÿ…%ÿq% ÿq%_ÿ×%Iÿ×%Kÿ×%Mÿ×%Oÿ×%Qÿ×%Sÿ×%Uÿ×%Wÿ×%Yÿ×%[ÿ×%]ÿ×%_ÿ×%oÿ…%qÿ…%sÿ…%ÿq&ÿì& ÿì&ÿì& ÿì'ÿq' ÿq'&ÿ×'*ÿ×'- '2ÿ×'4ÿ×'7ÿq'9ÿ®':ÿ®'<ÿ…'‰ÿ×'”ÿ×'•ÿ×'–ÿ×'—ÿ×'˜ÿ×'šÿ×'Ÿÿ…'Èÿ×'Êÿ×'Ìÿ×'Îÿ×'Þÿ×'àÿ×'âÿ×'äÿ×'ÿ×'ÿ×'ÿ×'ÿ×'$ÿq'&ÿq'6ÿ®'8ÿ…':ÿ…'Gÿ×'úÿ®'üÿ®'þÿ®'ÿ…'ÿq' ÿq'_ÿ×'Iÿ×'Kÿ×'Mÿ×'Oÿ×'Qÿ×'Sÿ×'Uÿ×'Wÿ×'Yÿ×'[ÿ×']ÿ×'_ÿ×'oÿ…'qÿ…'sÿ…'ÿq(ÿì( ÿì(ÿì( ÿì)ÿq) ÿq)&ÿ×)*ÿ×)- )2ÿ×)4ÿ×)7ÿq)9ÿ®):ÿ®)<ÿ…)‰ÿ×)”ÿ×)•ÿ×)–ÿ×)—ÿ×)˜ÿ×)šÿ×)Ÿÿ…)Èÿ×)Êÿ×)Ìÿ×)Îÿ×)Þÿ×)àÿ×)âÿ×)äÿ×)ÿ×)ÿ×)ÿ×)ÿ×)$ÿq)&ÿq)6ÿ®)8ÿ…):ÿ…)Gÿ×)úÿ®)üÿ®)þÿ®)ÿ…)ÿq) ÿq)_ÿ×)Iÿ×)Kÿ×)Mÿ×)Oÿ×)Qÿ×)Sÿ×)Uÿ×)Wÿ×)Yÿ×)[ÿ×)]ÿ×)_ÿ×)oÿ…)qÿ…)sÿ…)ÿq*ÿì* ÿì*ÿì* ÿì+ÿq+ ÿq+&ÿ×+*ÿ×+- +2ÿ×+4ÿ×+7ÿq+9ÿ®+:ÿ®+<ÿ…+‰ÿ×+”ÿ×+•ÿ×+–ÿ×+—ÿ×+˜ÿ×+šÿ×+Ÿÿ…+Èÿ×+Êÿ×+Ìÿ×+Îÿ×+Þÿ×+àÿ×+âÿ×+äÿ×+ÿ×+ÿ×+ÿ×+ÿ×+$ÿq+&ÿq+6ÿ®+8ÿ…+:ÿ…+Gÿ×+úÿ®+üÿ®+þÿ®+ÿ…+ÿq+ ÿq+_ÿ×+Iÿ×+Kÿ×+Mÿ×+Oÿ×+Qÿ×+Sÿ×+Uÿ×+Wÿ×+Yÿ×+[ÿ×+]ÿ×+_ÿ×+oÿ…+qÿ…+sÿ…+ÿq,ÿì, ÿì,ÿì, ÿì-ÿq- ÿq-&ÿ×-*ÿ×-- -2ÿ×-4ÿ×-7ÿq-9ÿ®-:ÿ®-<ÿ…-‰ÿ×-”ÿ×-•ÿ×-–ÿ×-—ÿ×-˜ÿ×-šÿ×-Ÿÿ…-Èÿ×-Êÿ×-Ìÿ×-Îÿ×-Þÿ×-àÿ×-âÿ×-äÿ×-ÿ×-ÿ×-ÿ×-ÿ×-$ÿq-&ÿq-6ÿ®-8ÿ…-:ÿ…-Gÿ×-úÿ®-üÿ®-þÿ®-ÿ…-ÿq- ÿq-_ÿ×-Iÿ×-Kÿ×-Mÿ×-Oÿ×-Qÿ×-Sÿ×-Uÿ×-Wÿ×-Yÿ×-[ÿ×-]ÿ×-_ÿ×-oÿ…-qÿ…-sÿ…-ÿq.ÿì. ÿì.ÿì. ÿì/ÿq/ ÿq/&ÿ×/*ÿ×/- /2ÿ×/4ÿ×/7ÿq/9ÿ®/:ÿ®/<ÿ…/‰ÿ×/”ÿ×/•ÿ×/–ÿ×/—ÿ×/˜ÿ×/šÿ×/Ÿÿ…/Èÿ×/Êÿ×/Ìÿ×/Îÿ×/Þÿ×/àÿ×/âÿ×/äÿ×/ÿ×/ÿ×/ÿ×/ÿ×/$ÿq/&ÿq/6ÿ®/8ÿ…/:ÿ…/Gÿ×/úÿ®/üÿ®/þÿ®/ÿ…/ÿq/ ÿq/_ÿ×/Iÿ×/Kÿ×/Mÿ×/Oÿ×/Qÿ×/Sÿ×/Uÿ×/Wÿ×/Yÿ×/[ÿ×/]ÿ×/_ÿ×/oÿ…/qÿ…/sÿ…/ÿq0ÿì0 ÿì0ÿì0 ÿì1ÿq1 ÿq1&ÿ×1*ÿ×1- 12ÿ×14ÿ×17ÿq19ÿ®1:ÿ®1<ÿ…1‰ÿ×1”ÿ×1•ÿ×1–ÿ×1—ÿ×1˜ÿ×1šÿ×1Ÿÿ…1Èÿ×1Êÿ×1Ìÿ×1Îÿ×1Þÿ×1àÿ×1âÿ×1äÿ×1ÿ×1ÿ×1ÿ×1ÿ×1$ÿq1&ÿq16ÿ®18ÿ…1:ÿ…1Gÿ×1úÿ®1üÿ®1þÿ®1ÿ…1ÿq1 ÿq1_ÿ×1Iÿ×1Kÿ×1Mÿ×1Oÿ×1Qÿ×1Sÿ×1Uÿ×1Wÿ×1Yÿ×1[ÿ×1]ÿ×1_ÿ×1oÿ…1qÿ…1sÿ…1ÿq2ÿì2 ÿì2ÿì2 ÿì3ÿq3 ÿq3&ÿ×3*ÿ×3- 32ÿ×34ÿ×37ÿq39ÿ®3:ÿ®3<ÿ…3‰ÿ×3”ÿ×3•ÿ×3–ÿ×3—ÿ×3˜ÿ×3šÿ×3Ÿÿ…3Èÿ×3Êÿ×3Ìÿ×3Îÿ×3Þÿ×3àÿ×3âÿ×3äÿ×3ÿ×3ÿ×3ÿ×3ÿ×3$ÿq3&ÿq36ÿ®38ÿ…3:ÿ…3Gÿ×3úÿ®3üÿ®3þÿ®3ÿ…3ÿq3 ÿq3_ÿ×3Iÿ×3Kÿ×3Mÿ×3Oÿ×3Qÿ×3Sÿ×3Uÿ×3Wÿ×3Yÿ×3[ÿ×3]ÿ×3_ÿ×3oÿ…3qÿ…3sÿ…3ÿq4ÿì4 ÿì4ÿì4 ÿì5-{6ÿì6 ÿì6Yÿ×6Zÿ×6[ÿ×6\ÿ×6]ÿì6¿ÿ×67ÿ×6<ÿì6>ÿì6@ÿì6ûÿ×6ýÿ×6ÿì6 ÿì6pÿ×7-{8ÿì8 ÿì8Yÿ×8Zÿ×8[ÿ×8\ÿ×8]ÿì8¿ÿ×87ÿ×8<ÿì8>ÿì8@ÿì8ûÿ×8ýÿ×8ÿì8 ÿì8pÿ×9-{:ÿì: ÿì:Yÿ×:Zÿ×:[ÿ×:\ÿ×:]ÿì:¿ÿ×:7ÿ×:<ÿì:>ÿì:@ÿì:ûÿ×:ýÿ×:ÿì: ÿì:pÿ×;-{<ÿì< ÿì<Yÿ×<Zÿ×<[ÿ×<\ÿ×<]ÿì<¿ÿ×<7ÿ×<<ÿì<>ÿì<@ÿì<ûÿ×<ýÿ×<ÿì< ÿì<pÿ×=-{>ÿì> ÿì>Yÿ×>Zÿ×>[ÿ×>\ÿ×>]ÿì>¿ÿ×>7ÿ×><ÿì>>ÿì>@ÿì>ûÿ×>ýÿ×>ÿì> ÿì>pÿ×?-{@ÿì@ ÿì@Yÿ×@Zÿ×@[ÿ×@\ÿ×@]ÿì@¿ÿ×@7ÿ×@<ÿì@>ÿì@@ÿì@ûÿ×@ýÿ×@ÿì@ ÿì@pÿ×A-{BÿìB ÿìBYÿ×BZÿ×B[ÿ×B\ÿ×B]ÿìB¿ÿ×B7ÿ×B<ÿìB>ÿìB@ÿìBûÿ×Býÿ×BÿìB ÿìBpÿ×C-{DÿìD ÿìDYÿ×DZÿ×D[ÿ×D\ÿ×D]ÿìD¿ÿ×D7ÿ×D<ÿìD>ÿìD@ÿìDûÿ×Dýÿ×DÿìD ÿìDpÿ×Iÿ®Iÿ®I$ÿ×I7ÿÃI9ÿìI:ÿìI;ÿ×I<ÿìI=ÿìI‚ÿ×Iƒÿ×I„ÿ×I…ÿ×I†ÿ×I‡ÿ×IŸÿìIÂÿ×IÄÿ×IÆÿ×I$ÿÃI&ÿÃI6ÿìI8ÿìI:ÿìI;ÿìI=ÿìI?ÿìICÿ×I ÿìIúÿìIüÿìIþÿìIÿìIÿ®I ÿ®IXÿ×Iÿ×Iÿ×I!ÿ×I#ÿ×I%ÿ×I'ÿ×I)ÿ×I+ÿ×I-ÿ×I/ÿ×I1ÿ×I3ÿ×IoÿìIqÿìIsÿìIÿÃJÿìJ ÿìJYÿ×JZÿ×J[ÿ×J\ÿ×J]ÿìJ¿ÿ×J7ÿ×J<ÿìJ>ÿìJ@ÿìJûÿ×Jýÿ×JÿìJ ÿìJpÿ×Kÿ®Kÿ®K$ÿ×K7ÿÃK9ÿìK:ÿìK;ÿ×K<ÿìK=ÿìK‚ÿ×Kƒÿ×K„ÿ×K…ÿ×K†ÿ×K‡ÿ×KŸÿìKÂÿ×KÄÿ×KÆÿ×K$ÿÃK&ÿÃK6ÿìK8ÿìK:ÿìK;ÿìK=ÿìK?ÿìKCÿ×K ÿìKúÿìKüÿìKþÿìKÿìKÿ®K ÿ®KXÿ×Kÿ×Kÿ×K!ÿ×K#ÿ×K%ÿ×K'ÿ×K)ÿ×K+ÿ×K-ÿ×K/ÿ×K1ÿ×K3ÿ×KoÿìKqÿìKsÿìKÿÃLÿìL ÿìLYÿ×LZÿ×L[ÿ×L\ÿ×L]ÿìL¿ÿ×L7ÿ×L<ÿìL>ÿìL@ÿìLûÿ×Lýÿ×LÿìL ÿìLpÿ×Mÿ®Mÿ®M$ÿ×M7ÿÃM9ÿìM:ÿìM;ÿ×M<ÿìM=ÿìM‚ÿ×Mƒÿ×M„ÿ×M…ÿ×M†ÿ×M‡ÿ×MŸÿìMÂÿ×MÄÿ×MÆÿ×M$ÿÃM&ÿÃM6ÿìM8ÿìM:ÿìM;ÿìM=ÿìM?ÿìMCÿ×M ÿìMúÿìMüÿìMþÿìMÿìMÿ®M ÿ®MXÿ×Mÿ×Mÿ×M!ÿ×M#ÿ×M%ÿ×M'ÿ×M)ÿ×M+ÿ×M-ÿ×M/ÿ×M1ÿ×M3ÿ×MoÿìMqÿìMsÿìMÿÃOÿ®Oÿ®O$ÿ×O7ÿÃO9ÿìO:ÿìO;ÿ×O<ÿìO=ÿìO‚ÿ×Oƒÿ×O„ÿ×O…ÿ×O†ÿ×O‡ÿ×OŸÿìOÂÿ×OÄÿ×OÆÿ×O$ÿÃO&ÿÃO6ÿìO8ÿìO:ÿìO;ÿìO=ÿìO?ÿìOCÿ×O ÿìOúÿìOüÿìOþÿìOÿìOÿ®O ÿ®OXÿ×Oÿ×Oÿ×O!ÿ×O#ÿ×O%ÿ×O'ÿ×O)ÿ×O+ÿ×O-ÿ×O/ÿ×O1ÿ×O3ÿ×OoÿìOqÿìOsÿìOÿÃQÿ®Qÿ®Q$ÿ×Q7ÿÃQ9ÿìQ:ÿìQ;ÿ×Q<ÿìQ=ÿìQ‚ÿ×Qƒÿ×Q„ÿ×Q…ÿ×Q†ÿ×Q‡ÿ×QŸÿìQÂÿ×QÄÿ×QÆÿ×Q$ÿÃQ&ÿÃQ6ÿìQ8ÿìQ:ÿìQ;ÿìQ=ÿìQ?ÿìQCÿ×Q ÿìQúÿìQüÿìQþÿìQÿìQÿ®Q ÿ®QXÿ×Qÿ×Qÿ×Q!ÿ×Q#ÿ×Q%ÿ×Q'ÿ×Q)ÿ×Q+ÿ×Q-ÿ×Q/ÿ×Q1ÿ×Q3ÿ×QoÿìQqÿìQsÿìQÿÃSÿ®Sÿ®S$ÿ×S7ÿÃS9ÿìS:ÿìS;ÿ×S<ÿìS=ÿìS‚ÿ×Sƒÿ×S„ÿ×S…ÿ×S†ÿ×S‡ÿ×SŸÿìSÂÿ×SÄÿ×SÆÿ×S$ÿÃS&ÿÃS6ÿìS8ÿìS:ÿìS;ÿìS=ÿìS?ÿìSCÿ×S ÿìSúÿìSüÿìSþÿìSÿìSÿ®S ÿ®SXÿ×Sÿ×Sÿ×S!ÿ×S#ÿ×S%ÿ×S'ÿ×S)ÿ×S+ÿ×S-ÿ×S/ÿ×S1ÿ×S3ÿ×SoÿìSqÿìSsÿìSÿÃUÿ®Uÿ®U$ÿ×U7ÿÃU9ÿìU:ÿìU;ÿ×U<ÿìU=ÿìU‚ÿ×Uƒÿ×U„ÿ×U…ÿ×U†ÿ×U‡ÿ×UŸÿìUÂÿ×UÄÿ×UÆÿ×U$ÿÃU&ÿÃU6ÿìU8ÿìU:ÿìU;ÿìU=ÿìU?ÿìUCÿ×U ÿìUúÿìUüÿìUþÿìUÿìUÿ®U ÿ®UXÿ×Uÿ×Uÿ×U!ÿ×U#ÿ×U%ÿ×U'ÿ×U)ÿ×U+ÿ×U-ÿ×U/ÿ×U1ÿ×U3ÿ×UoÿìUqÿìUsÿìUÿÃXIRXWRXYfXZfX[fX\fX¿fX%RX'RX7fXûfXýfX4RX5RX]RX^RXpfXRXRZIRZWRZYfZZfZ[fZ\fZ¿fZ%RZ'RZ7fZûfZýfZ4RZ5RZ]RZ^RZpfZRZR\IR\WR\Yf\Zf\[f\\f\¿f\%R\'R\7f\ûf\ýf\4R\5R\]R\^R\pf\R\R^IR^WR^Yf^Zf^[f^\f^¿f^%R^'R^7f^ûf^ýf^4R^5R^]R^^R^pf^R^R`IR`WR`Yf`Zf`[f`\f`¿f`%R`'R`7f`ûf`ýf`4R`5R`]R`^R`pf`R`Raÿ×aÿ×a$ÿìa‚ÿìaƒÿìa„ÿìa…ÿìa†ÿìa‡ÿìaÂÿìaÄÿìaÆÿìaCÿìaÿ×a ÿ×aXÿìaÿìaÿìa!ÿìa#ÿìa%ÿìa'ÿìa)ÿìa+ÿìa-ÿìa/ÿìa1ÿìa3ÿìfIffWffYffZff[ff\ff¿ff%ff'ff7ffûffýff4ff5ff]ff^ffpfffffhIfhWfhYfhZfh[fh\fh¿fh%fh'fh7fhûfhýfh4fh5fh]fh^fhpfhfhfjIfjWfjYfjZfj[fj\fj¿fj%fj'fj7fjûfjýfj4fj5fj]fj^fjpfjfjflIflWflYflZfl[fl\fl¿fl%fl'fl7flûflýfl4fl5fl]fl^flpflflfnIfnWfnYfnZfn[fn\fn¿fn%fn'fn7fnûfnýfn4fn5fn]fn^fnpfnfnfoÿ…oÿ…o")o$ÿ…o&ÿ×o*ÿ×o2ÿ×o4ÿ×oDÿšoFÿšoGÿšoHÿšoJÿ×oPÿÃoQÿÃoRÿšoSÿÃoTÿšoUÿÃoVÿ®oXÿÃo]ÿ×o‚ÿ…oƒÿ…o„ÿ…o…ÿ…o†ÿ…o‡ÿ…o‰ÿ×o”ÿ×o•ÿ×o–ÿ×o—ÿ×o˜ÿ×ošÿ×o¢ÿšo£ÿšo¤ÿšo¥ÿšo¦ÿšo§ÿšo¨ÿšo©ÿšoªÿšo«ÿšo¬ÿšo­ÿšo´ÿšoµÿšo¶ÿšo·ÿšo¸ÿšoºÿšo»ÿÃo¼ÿÃo½ÿÃo¾ÿÃoÂÿ…oÃÿšoÄÿ…oÅÿšoÆÿ…oÇÿšoÈÿ×oÉÿšoÊÿ×oËÿšoÌÿ×oÍÿšoÎÿ×oÏÿšoÑÿšoÓÿšoÕÿšo×ÿšoÙÿšoÛÿšoÝÿšoÞÿ×oßÿ×oàÿ×oáÿ×oâÿ×oãÿ×oäÿ×oåÿ×oúÿÃoÿÃoÿÃo ÿÃoÿ×oÿšoÿ×oÿšoÿ×oÿšoÿ×oÿšoÿÃoÿÃoÿ®o!ÿ®o+ÿÃo-ÿÃo/ÿÃo1ÿÃo3ÿÃo5ÿÃo<ÿ×o>ÿ×o@ÿ×oCÿ…oDÿšoFÿšoGÿ×oHÿšoJÿ®oÿ…o ÿ…oWÿÃoXÿ…oYÿšo_ÿ×o`ÿšobÿÃoÿ…oÿšoÿ…o ÿšo!ÿ…o"ÿšo#ÿ…o%ÿ…o&ÿšo'ÿ…o(ÿšo)ÿ…o*ÿšo+ÿ…o,ÿšo-ÿ…o.ÿšo/ÿ…o0ÿšo1ÿ…o2ÿšo3ÿ…o4ÿšo6ÿšo8ÿšo:ÿšo<ÿšo@ÿšoBÿšoDÿšoIÿ×oJÿšoKÿ×oLÿšoMÿ×oNÿšoOÿ×oQÿ×oRÿšoSÿ×oTÿšoUÿ×oVÿšoWÿ×oXÿšoYÿ×oZÿšo[ÿ×o\ÿšo]ÿ×o^ÿšo_ÿ×o`ÿšobÿÃodÿÃofÿÃohÿÃojÿÃolÿÃonÿÃpRp Rpÿ®pÿ®p")pRpÿ®p Rp ÿ®qÿ…qÿ…q")q$ÿ…q&ÿ×q*ÿ×q2ÿ×q4ÿ×qDÿšqFÿšqGÿšqHÿšqJÿ×qPÿÃqQÿÃqRÿšqSÿÃqTÿšqUÿÃqVÿ®qXÿÃq]ÿ×q‚ÿ…qƒÿ…q„ÿ…q…ÿ…q†ÿ…q‡ÿ…q‰ÿ×q”ÿ×q•ÿ×q–ÿ×q—ÿ×q˜ÿ×qšÿ×q¢ÿšq£ÿšq¤ÿšq¥ÿšq¦ÿšq§ÿšq¨ÿšq©ÿšqªÿšq«ÿšq¬ÿšq­ÿšq´ÿšqµÿšq¶ÿšq·ÿšq¸ÿšqºÿšq»ÿÃq¼ÿÃq½ÿÃq¾ÿÃqÂÿ…qÃÿšqÄÿ…qÅÿšqÆÿ…qÇÿšqÈÿ×qÉÿšqÊÿ×qËÿšqÌÿ×qÍÿšqÎÿ×qÏÿšqÑÿšqÓÿšqÕÿšq×ÿšqÙÿšqÛÿšqÝÿšqÞÿ×qßÿ×qàÿ×qáÿ×qâÿ×qãÿ×qäÿ×qåÿ×qúÿÃqÿÃqÿÃq ÿÃqÿ×qÿšqÿ×qÿšqÿ×qÿšqÿ×qÿšqÿÃqÿÃqÿ®q!ÿ®q+ÿÃq-ÿÃq/ÿÃq1ÿÃq3ÿÃq5ÿÃq<ÿ×q>ÿ×q@ÿ×qCÿ…qDÿšqFÿšqGÿ×qHÿšqJÿ®qÿ…q ÿ…qWÿÃqXÿ…qYÿšq_ÿ×q`ÿšqbÿÃqÿ…qÿšqÿ…q ÿšq!ÿ…q"ÿšq#ÿ…q%ÿ…q&ÿšq'ÿ…q(ÿšq)ÿ…q*ÿšq+ÿ…q,ÿšq-ÿ…q.ÿšq/ÿ…q0ÿšq1ÿ…q2ÿšq3ÿ…q4ÿšq6ÿšq8ÿšq:ÿšq<ÿšq@ÿšqBÿšqDÿšqIÿ×qJÿšqKÿ×qLÿšqMÿ×qNÿšqOÿ×qQÿ×qRÿšqSÿ×qTÿšqUÿ×qVÿšqWÿ×qXÿšqYÿ×qZÿšq[ÿ×q\ÿšq]ÿ×q^ÿšq_ÿ×q`ÿšqbÿÃqdÿÃqfÿÃqhÿÃqjÿÃqlÿÃqnÿÃrRr Rrÿ®rÿ®r")rRrÿ®r Rr ÿ®sÿ…sÿ…s")s$ÿ…s&ÿ×s*ÿ×s2ÿ×s4ÿ×sDÿšsFÿšsGÿšsHÿšsJÿ×sPÿÃsQÿÃsRÿšsSÿÃsTÿšsUÿÃsVÿ®sXÿÃs]ÿ×s‚ÿ…sƒÿ…s„ÿ…s…ÿ…s†ÿ…s‡ÿ…s‰ÿ×s”ÿ×s•ÿ×s–ÿ×s—ÿ×s˜ÿ×sšÿ×s¢ÿšs£ÿšs¤ÿšs¥ÿšs¦ÿšs§ÿšs¨ÿšs©ÿšsªÿšs«ÿšs¬ÿšs­ÿšs´ÿšsµÿšs¶ÿšs·ÿšs¸ÿšsºÿšs»ÿÃs¼ÿÃs½ÿÃs¾ÿÃsÂÿ…sÃÿšsÄÿ…sÅÿšsÆÿ…sÇÿšsÈÿ×sÉÿšsÊÿ×sËÿšsÌÿ×sÍÿšsÎÿ×sÏÿšsÑÿšsÓÿšsÕÿšs×ÿšsÙÿšsÛÿšsÝÿšsÞÿ×sßÿ×sàÿ×sáÿ×sâÿ×sãÿ×säÿ×såÿ×súÿÃsÿÃsÿÃs ÿÃsÿ×sÿšsÿ×sÿšsÿ×sÿšsÿ×sÿšsÿÃsÿÃsÿ®s!ÿ®s+ÿÃs-ÿÃs/ÿÃs1ÿÃs3ÿÃs5ÿÃs<ÿ×s>ÿ×s@ÿ×sCÿ…sDÿšsFÿšsGÿ×sHÿšsJÿ®sÿ…s ÿ…sWÿÃsXÿ…sYÿšs_ÿ×s`ÿšsbÿÃsÿ…sÿšsÿ…s ÿšs!ÿ…s"ÿšs#ÿ…s%ÿ…s&ÿšs'ÿ…s(ÿšs)ÿ…s*ÿšs+ÿ…s,ÿšs-ÿ…s.ÿšs/ÿ…s0ÿšs1ÿ…s2ÿšs3ÿ…s4ÿšs6ÿšs8ÿšs:ÿšs<ÿšs@ÿšsBÿšsDÿšsIÿ×sJÿšsKÿ×sLÿšsMÿ×sNÿšsOÿ×sQÿ×sRÿšsSÿ×sTÿšsUÿ×sVÿšsWÿ×sXÿšsYÿ×sZÿšs[ÿ×s\ÿšs]ÿ×s^ÿšs_ÿ×s`ÿšsbÿÃsdÿÃsfÿÃshÿÃsjÿÃslÿÃsnÿÃtRt Rtÿ®tÿ®t")tRtÿ®t Rt ÿ®{ {{ {ÿ…ÿ®ÿ…")$ÿq&ÿ×*ÿ×2ÿ×4ÿ×7)Dÿ\FÿqGÿqHÿqJÿqPÿšQÿšRÿqSÿšTÿqUÿšVÿ…XÿšYÿ×Zÿ×[ÿ×\ÿ×]ÿ®‚ÿqƒÿq„ÿq…ÿq†ÿq‡ÿq‰ÿ×”ÿוÿ×–ÿ×—ÿטÿךÿ×¢ÿq£ÿ\¤ÿ\¥ÿ\¦ÿ\§ÿ\¨ÿ\©ÿqªÿq«ÿq¬ÿq­ÿq´ÿqµÿq¶ÿq·ÿq¸ÿqºÿq»ÿš¼ÿš½ÿš¾ÿš¿ÿ×ÂÿqÃÿ\ÄÿqÅÿ\ÆÿqÇÿ\Èÿ×ÉÿqÊÿ×ËÿqÌÿ×ÍÿqÎÿ×ÏÿqÑÿqÓÿqÕÿq×ÿqÙÿqÛÿqÝÿqÞÿ×ßÿqàÿ×áÿqâÿ×ãÿqäÿ×åÿqúÿšÿšÿš ÿšÿ×ÿqÿ×ÿqÿ×ÿqÿ×ÿqÿšÿšÿ…!ÿ…$)&)+ÿš-ÿš/ÿš1ÿš3ÿš5ÿš7ÿ×<ÿ®>ÿ®@ÿ®CÿqDÿ\Fÿ\Gÿ×HÿqJÿ…ûÿ×ýÿ×ÿ®ÿ®ÿ®ÿ… ÿ…WÿšXÿqYÿ\_ÿ×`ÿqbÿšÿqÿ\ÿq ÿ\!ÿq"ÿ\#ÿq%ÿq&ÿ\'ÿq(ÿ\)ÿq*ÿ\+ÿq,ÿ\-ÿq.ÿ\/ÿq0ÿ\1ÿq2ÿ\3ÿq4ÿ\6ÿq8ÿq:ÿq<ÿq@ÿqBÿqDÿqIÿ×JÿqKÿ×LÿqMÿ×NÿqOÿ×Qÿ×RÿqSÿ×TÿqUÿ×VÿqWÿ×XÿqYÿ×Zÿq[ÿ×\ÿq]ÿ×^ÿq_ÿ×`ÿqbÿšdÿšfÿšhÿšjÿšlÿšnÿšpÿ×)) )) )>9 9B%HS myRˆÚ î .  .8*f r    J   6 j ‚ ¤  (D 8l \¤ \ T\Digitized data copyright © 2010-2011, Google Corporation.Open SansItalicAscender - Open Sans Italic Build 100Version 1.10OpenSans-ItalicOpen Sans is a trademark of Google and may be registered in certain jurisdictions.Ascender Corporationhttp://www.ascendercorp.com/http://www.ascendercorp.com/typedesigners.htmlLicensed under the Apache License, Version 2.0http://www.apache.org/licenses/LICENSE-2.0Digitized data copyright © 2010-2011, Google Corporation.Open SansItalicAscender - Open Sans Italic Build 100Version 1.10OpenSans-ItalicOpen Sans is a trademark of Google and may be registered in certain jurisdictions.Ascender Corporationhttp://www.ascendercorp.com/http://www.ascendercorp.com/typedesigners.htmlLicensed under the Apache License, Version 2.0http://www.apache.org/licenses/LICENSE-2.0ÿôÿffª      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«.notdefnullnonmarkingreturnspaceexclamquotedbl numbersigndollarpercent ampersand quotesingle parenleft parenrightasteriskpluscommahyphenperiodslashzeroonetwothreefourfivesixseveneightninecolon semicolonlessequalgreaterquestionatABCDEFGHI.altJKLMNOPQRSTUVWXYZ bracketleft backslash bracketright asciicircum underscoregraveabcdefghijklmnopqrstuvwxyz braceleftbar braceright asciitildenonbreakingspace exclamdowncentsterlingcurrencyyen brokenbarsectiondieresis copyright ordfeminine guillemotleft logicalnotuni00AD registered overscoredegree plusminus twosuperior threesuperioracutemu paragraphperiodcenteredcedilla onesuperior ordmasculineguillemotright onequarteronehalf threequarters questiondownAgraveAacute AcircumflexAtilde AdieresisAringAECcedillaEgraveEacute Ecircumflex Edieresis Igrave.alt Iacute.altIcircumflex.alt Idieresis.altEthNtildeOgraveOacute OcircumflexOtilde OdieresismultiplyOslashUgraveUacute Ucircumflex UdieresisYacuteThorn germandblsagraveaacute acircumflexatilde adieresisaringaeccedillaegraveeacute ecircumflex edieresisigraveiacute icircumflex idieresisethntildeograveoacute ocircumflexotilde odieresisdivideoslashugraveuacute ucircumflex udieresisyacutethorn ydieresisAmacronamacronAbreveabreveAogonekaogonekCacutecacute Ccircumflex ccircumflexCdotcdotCcaronccaronDcarondcaronDcroatdcroatEmacronemacronEbreveebreve Edotaccent edotaccentEogonekeogonekEcaronecaron Gcircumflex gcircumflexGbrevegbreveGdotgdot Gcommaaccent gcommaaccent Hcircumflex hcircumflexHbarhbar Itilde.altitilde Imacron.altimacron Ibreve.altibreve Iogonek.altiogonekIdotaccent.altdotlessiIJ.altij Jcircumflex jcircumflex Kcommaaccent kcommaaccent kgreenlandicLacutelacute Lcommaaccent lcommaaccentLcaronlcaronLdotldotLslashlslashNacutenacute Ncommaaccent ncommaaccentNcaronncaron napostropheEngengOmacronomacronObreveobreve Ohungarumlaut ohungarumlautOEoeRacuteracute Rcommaaccent rcommaaccentRcaronrcaronSacutesacute Scircumflex scircumflexScedillascedillaScaronscaron Tcommaaccent tcommaaccentTcarontcaronTbartbarUtildeutildeUmacronumacronUbreveubreveUringuring Uhungarumlaut uhungarumlautUogonekuogonek Wcircumflex wcircumflex Ycircumflex ycircumflex YdieresisZacutezacute Zdotaccent zdotaccentZcaronzcaronlongsflorin Aringacute aringacuteAEacuteaeacute Oslashacute oslashacute Scommaaccent scommaaccent circumflexcaronmacronbreve dotaccentringogonektilde hungarumlauttonos dieresistonos Alphatonos anoteleia EpsilontonosEtatonos Iotatonos.alt Omicrontonos Upsilontonos OmegatonosiotadieresistonosAlphaBetaGammauni0394EpsilonZetaEtaThetaIota.altKappaLambdaMuNuXiOmicronPiRhoSigmaTauUpsilonPhiChiPsiuni03A9Iotadieresis.altUpsilondieresis alphatonos epsilontonosetatonos iotatonosupsilondieresistonosalphabetagammadeltaepsilonzetaetathetaiotakappalambdauni03BCnuxiomicronpirhosigma1sigmatauupsilonphichipsiomega iotadieresisupsilondieresis omicrontonos upsilontonos omegatonos afii10023 afii10051 afii10052 afii10053 afii10054 afii10055.alt afii10056.alt afii10057 afii10058 afii10059 afii10060 afii10061 afii10062 afii10145 afii10017 afii10018 afii10019 afii10020 afii10021 afii10022 afii10024 afii10025 afii10026 afii10027 afii10028 afii10029 afii10030 afii10031 afii10032 afii10033 afii10034 afii10035 afii10036 afii10037 afii10038 afii10039 afii10040 afii10041 afii10042 afii10043 afii10044 afii10045 afii10046 afii10047 afii10048 afii10049 afii10065 afii10066 afii10067 afii10068 afii10069 afii10070 afii10072 afii10073 afii10074 afii10075 afii10076 afii10077 afii10078 afii10079 afii10080 afii10081 afii10082 afii10083 afii10084 afii10085 afii10086 afii10087 afii10088 afii10089 afii10090 afii10091 afii10092 afii10093 afii10094 afii10095 afii10096 afii10097 afii10071 afii10099 afii10100 afii10101 afii10102 afii10103 afii10104 afii10105 afii10106 afii10107 afii10108 afii10109 afii10110 afii10193 afii10050 afii10098WgravewgraveWacutewacute Wdieresis wdieresisYgraveygraveendashemdash afii00208 underscoredbl quoteleft quoterightquotesinglbase quotereversed quotedblleft quotedblright quotedblbasedagger daggerdblbulletellipsis perthousandminutesecond guilsinglleftguilsinglright exclamdblfraction nsuperiorfranc afii08941pesetaEuro afii61248 afii61289 afii61352 trademarkOmega estimated oneeighth threeeighths fiveeighths seveneighths partialdiffDeltaproduct summationminusradicalinfinityintegral approxequalnotequal lessequal greaterequallozengeuniFB01uniFB02 cyrillicbrevedotlessjcaroncommaaccent commaaccentcommaaccentrotate zerosuperior foursuperior fivesuperior sixsuperior sevensuperior eightsuperior ninesuperioruni2000uni2001uni2002uni2003uni2004uni2005uni2006uni2007uni2008uni2009uni200Auni200BuniFEFFuniFFFCuniFFFDuni01F0uni02BCuni03D1uni03D2uni03D6uni1E3Euni1E3Funi1E00uni1E01uni1F4Duni02F3 dasiaoxiauniFB03uniFB04OhornohornUhornuhornuni0300uni0301uni0303hookdotbelowuni0400uni040Duni0450uni045Duni0460uni0461uni0462uni0463uni0464uni0465uni0466uni0467uni0468uni0469uni046Auni046Buni046Cuni046Duni046Euni046Funi0470uni0471uni0472uni0473uni0474uni0475uni0476uni0477uni0478uni0479uni047Auni047Buni047Cuni047Duni047Euni047Funi0480uni0481uni0482uni0483uni0484uni0485uni0486uni0488uni0489uni048Auni048Buni048Cuni048Duni048Euni048Funi0492uni0493uni0494uni0495uni0496uni0497uni0498uni0499uni049Auni049Buni049Cuni049Duni049Euni049Funi04A0uni04A1uni04A2uni04A3uni04A4uni04A5uni04A6uni04A7uni04A8uni04A9uni04AAuni04ABuni04ACuni04ADuni04AEuni04AFuni04B0uni04B1uni04B2uni04B3uni04B4uni04B5uni04B6uni04B7uni04B8uni04B9uni04BAuni04BBuni04BCuni04BDuni04BEuni04BF uni04C0.altuni04C1uni04C2uni04C3uni04C4uni04C5uni04C6uni04C7uni04C8uni04C9uni04CAuni04CBuni04CCuni04CDuni04CE uni04CF.altuni04D0uni04D1uni04D2uni04D3uni04D4uni04D5uni04D6uni04D7uni04D8uni04D9uni04DAuni04DBuni04DCuni04DDuni04DEuni04DFuni04E0uni04E1uni04E2uni04E3uni04E4uni04E5uni04E6uni04E7uni04E8uni04E9uni04EAuni04EBuni04ECuni04EDuni04EEuni04EFuni04F0uni04F1uni04F2uni04F3uni04F4uni04F5uni04F6uni04F7uni04F8uni04F9uni04FAuni04FBuni04FCuni04FDuni04FEuni04FFuni0500uni0501uni0502uni0503uni0504uni0505uni0506uni0507uni0508uni0509uni050Auni050Buni050Cuni050Duni050Euni050Funi0510uni0511uni0512uni0513uni1EA0uni1EA1uni1EA2uni1EA3uni1EA4uni1EA5uni1EA6uni1EA7uni1EA8uni1EA9uni1EAAuni1EABuni1EACuni1EADuni1EAEuni1EAFuni1EB0uni1EB1uni1EB2uni1EB3uni1EB4uni1EB5uni1EB6uni1EB7uni1EB8uni1EB9uni1EBAuni1EBBuni1EBCuni1EBDuni1EBEuni1EBFuni1EC0uni1EC1uni1EC2uni1EC3uni1EC4uni1EC5uni1EC6uni1EC7 uni1EC8.altuni1EC9 uni1ECA.altuni1ECBuni1ECCuni1ECDuni1ECEuni1ECFuni1ED0uni1ED1uni1ED2uni1ED3uni1ED4uni1ED5uni1ED6uni1ED7uni1ED8uni1ED9uni1EDAuni1EDBuni1EDCuni1EDDuni1EDEuni1EDFuni1EE0uni1EE1uni1EE2uni1EE3uni1EE4uni1EE5uni1EE6uni1EE7uni1EE8uni1EE9uni1EEAuni1EEBuni1EECuni1EEDuni1EEEuni1EEFuni1EF0uni1EF1uni1EF4uni1EF5uni1EF6uni1EF7uni1EF8uni1EF9uni20ABuni030Fcircumflexacutecombcircumflexgravecombcircumflexhookcombcircumflextildecombbreveacutecombbrevegravecomb brevehookcombbrevetildecombcyrillichookleftcyrillicbighookUCcyrillicbighookLCone.pnumzero.osone.ostwo.osthree.osfour.osfive.ossix.osseven.oseight.osnine.osffuni2120Tcedillatcedillag.altgcircumflex.alt gbreve.altgdot.altgcommaaccent.altIIgraveIacute Icircumflex IdieresisItildeImacronIbreveIogonek IdotaccentIJ IotatonosIota Iotadieresis afii10055 afii10056uni04C0uni04CFuni1EC8uni1ECA ÿÿ © 46latnMOL ROM ÿÿÿÿÿÿ nälatnMOL (ROM Bÿÿ  ÿÿ  ÿÿ  liga°liga¶liga¼lnumÂlnumÈlnumÎloclÔloclÚonumàonumèonumðpnumøpnumþpnumsalt saltsaltss01"ss01*ss012ss02:ss02@ss02Fss03Lss03Rss03Xtnum^tnumftnumn    &.6>FNV^PzªÆîô2H‘’“”•JJßßááããåå.,Ž‘êìîðòôZgw¡¢ÉØEG–© ƒ„…†‡ˆ‰Š‹Œ ƒ…†‡ˆ‰Š‹Œ„‚‚ ‚ ƒŒ‚ ‚ƒŒ !$%IJ6 "(^IO]ILI5O4LI^V0‚R *†H†÷  ‚C0‚?1 0 +0a +‚7 S0Q0, +‚7¢€<<<Obsolete>>>0!0 +ëU¼Îßaz£€Æ²IVv« ‚]0‚z0‚b 8%×úøa¯žôç&µÖZÕ0  *†H†÷ 0S1 0 UUS10U VeriSign, Inc.1+0)U"VeriSign Time Stamping Services CA0 070615000000Z 120614235959Z0\1 0 UUS10U VeriSign, Inc.1402U+VeriSign Time Stamping Services Signer - G20Ÿ0  *†H†÷ 0‰ĵòR¼ˆ†`)J[/K‘k‡‘ó5TX5êÑ6^bMRQ4qÂ{f‰ÈÝ*Äj ö7Ù˜t‘ö’®°µv–ñ©JcEG.k ’NK+ŒîXJ‹Ôä,ø‚ªXÙÍBó-ÀuÞ«ÇŽšlL•ÞÛïgárÂIž`<áâ¾£cxi{­-£Ä0Á04+(0&0$+0†http://ocsp.verisign.com0 Uÿ003U,0*0( & $†"http://crl.verisign.com/tss-ca.crl0U%ÿ 0 +0UÿÀ0U0¤010 UTSA1-20  *†H†÷ ‚PÅKÈ$€ßä $ÂÞ±¡¡¦‚- ƒ7 ‚,°ZaµØþˆÛñ‘‘³V@¦ë’¾89°u6t:˜Oä7º™‰Ê•B°¹Ç WàúÕdB5NÑ3¢ÈMª'Çòá†L8MƒxÆüSàëà‡Ý¤–ž^ ˜â¥¾¿‚…Ã`áß­(ØÇ¥KdÚÇ[½¬9Õ8"¡3‹/Ššë¼!?DA µe$¼HÓD€ë¡ÏÉ´ÏTÇ£€\ùy>]r}ˆž,C¢ÊSÎ}=ö*:¸O”¥m ƒ]ù^Sô³WpÃûõ­• ÞÄ€`É+n†ñëôx'ÑÅî4[^¹I2ò30‚Ä0‚- G¿•ßRFC÷ÛmH 1¤0  *†H†÷ 0‹1 0 UZA10U Western Cape10U Durbanville10 U Thawte10U Thawte Certification10UThawte Timestamping CA0 031204000000Z 131203235959Z0S1 0 UUS10U VeriSign, Inc.1+0)U"VeriSign Time Stamping Services CA0‚"0  *†H†÷ ‚0‚ ‚©Ê²¤ÌÍ ¯ }‰¬‡uð´NñßÁ¿ga½£dÚ»ùÊ3«„0‰X~ŒÛkÝ6ž¿Ñìxòw¦~o<¿“¯ ºhôl”ʽR-«H=õ¶Õ]_Ÿú/k¤÷£š¦ÈáLRã`ì@~¹ Þ?Ǵ߇½_zj1.™¨G Î1s W-Íx43•™¹Þh/ªæ㊌*Ë!‡f½ƒXWou¿<ª&‡]Ê<Ÿ„êTÁ nÄþÅJݹ—"|Û>'ÑxìŸ1Éñæ"ÛijGCš_ ä^õî|ñ}«bõM ÞÐ"V¨•Í®ˆv®îº óäMÙ ûh ®;³‡Á»£Û0Ø04+(0&0$+0†http://ocsp.verisign.com0Uÿ0ÿ0AU:0806 4 2†0http://crl.verisign.com/ThawteTimestampingCA.crl0U% 0 +0Uÿ0$U0¤010U TSA2048-1-530  *†H†÷ JkùêXÂD1‰y™+–¿‚¬ÖLÍ°ŠXnß)£^ÈÊ“çR ïG'/8°äÉ“NšÔ"b÷?7!Op1€ñ‹8‡³èè—þÏU–N$Ò©'Nz®·aAó*ÎçÉÙ^Ý»+…>µµÙáWÿ¾´Å~õÏ žð—þ+Ó;R8'÷?J0‚ü0‚e eR&á².áY)…¬"ç\0  *†H†÷ 0_1 0 UUS10U VeriSign, Inc.1705U .Class 3 Public Primary Certification Authority0 090521000000Z 190520235959Z0¶1 0 UUS10U VeriSign, Inc.10U VeriSign Trust Network1;09U 2Terms of use at https://www.verisign.com/rpa (c)09100.U'VeriSign Class 3 Code Signing 2009-2 CA0‚"0  *†H†÷ ‚0‚ ‚¾g´`ªIoV|fÉ^† Õñ¬§qƒŽ‹‰øˆ‰º-„!•äÑœPLûÒ"½Úò²5;à ûü.Z¿‰|=;%öóX{œôµÆ ¸€Î¾'tag'MjåìaXy£à'°áM4+G D¹Þf$fŠÍOºÅ8ÈTáröfuj¹IhÏ8y ª0¨Û,`Hž×ª©ƒ×8‘09–:|@T¶­à/ƒÜ¨R>³×+ý!¶§\£ ©¦P4.M§ÎÉ^%ÔŒ¼ón|)¼]ü1‡ZÕŒ…gXˆ ¿5ðê+£!çöƒå¨í`x^{`ƒýW ]A cT`ÖC!Û0‚×0Uÿ0ÿ0pU i0g0e `†H†øE0V0(+https://www.verisign.com/cps0*+0https://www.verisign.com/rpa0Uÿ0m+ a0_¡] [0Y0W0U image/gif0!00+åÓ†¬ŽkÃÏ€jÔH,{.0%#http://logo.verisign.com/vslogo.gif0U%0++04+(0&0$+0†http://ocsp.verisign.com01U*0(0& $ "† http://crl.verisign.com/pca3.crl0)U"0 ¤010UClass3CA2048-1-550U—Ðk¨&pÈ¡?”-Ä5›¤¡ò0  *†H†÷ ‹ÀÝ”ØA¢ai°¨xÇ0Æ<~B÷$¶äƒsœ¡âú/ëÀÊDçràP¶U ƒn–’äšQj´71Ü¥-ëŒÇOçM2º…øN¾úgUeðj¾zÊd8xEv1ó†z`³]ö‹fv‚Yáƒå½I¥8VåÞAwX0‚0‚û fãðgyÊmPSoˆƒ0  *†H†÷ 0¶1 0 UUS10U VeriSign, Inc.10U VeriSign Trust Network1;09U 2Terms of use at https://www.verisign.com/rpa (c)09100.U'VeriSign Class 3 Code Signing 2009-2 CA0 100729000000Z 120808235959Z0Ð1 0 UUS10U Massachusetts10 UWoburn10U Monotype Imaging Inc.1>0<U 5Digital ID Class 3 - Microsoft Software Validation v210U Type Operations10UMonotype Imaging Inc.0Ÿ0  *†H†÷ 0‰”D •i|U ÐÛ25ŠL3«^ ¡L×*‡8ט¥@ðI "SOÂC¦Ê‹©VïnH¨9c;$¹˜ÏÊ5}rãGWýyËŠJç@p-5c®€ÏįØû÷Éü‰Øפ Û ò¢ò{ïÍuÁ÷ePd"½}¼­¸KÌXEMÑYLM£‚ƒ0‚0 U00Uÿ€0DU=0;09 7 5†3http://csc3-2009-2-crl.verisign.com/CSC3-2009-2.crl0DU =0;09 `†H†øE0*0(+https://www.verisign.com/rpa0U% 0 +0u+i0g0$+0†http://ocsp.verisign.com0?+0†3http://csc3-2009-2-aia.verisign.com/CSC3-2009-2.cer0U#0€—Ðk¨&pÈ¡?”-Ä5›¤¡ò0 `†H†øB0 +‚70ÿ0  *†H†÷ ‚Næ"‡ßgAâÒî~ΙÖc½ðµ“åjrbáõÒ<8î¨=_ºG‚_[KIô ú“ ÐVD¢ˆóû®÷ 5Þ< ¬D”`E*›þ›oL;±4gp†ÿZ9\Zãl‚«5|eKý˜mµ”Iœˆp¾=±b•´Û´ÔÚèA~þ}¹¤’ënò"ŠÆw6MŠZ S1Ó+(¯RázkµwD½ ­ô]%,ãÍŠ0>KœyʦN® ÂÌ$ Á”‚öñº¶›šØ\<ñê'M<‰o3ŠÓ†ÞéX3u=ë“iâDoNlÏÕ…ÚV¦š¦?ËL!hò`ºáè]9!2í1‚g0‚c0Ë0¶1 0 UUS10U VeriSign, Inc.10U VeriSign Trust Network1;09U 2Terms of use at https://www.verisign.com/rpa (c)09100.U'VeriSign Class 3 Code Signing 2009-2 CAfãðgyÊmPSoˆƒ0 + p0 +‚7 100 *†H†÷  1  +‚70 +‚7 10  +‚70# *†H†÷  1Œý Ì¿&.:m ìQ؈~) €0  *†H†÷ €fø鎶Jô®ß›4Úåž®‘‘¤íüÅÒŠ³€Îzp2g¥+=¬”›®¶=¨DcõíDn»ž’ÚÜ®SÇî­ Êvò+DЫ#ë¾Àfðô΀OlÑ‚­ ïa_FíJ Ôñqù(ôl'R‡Í-éW¸IØ?ëËR›lü¡‚0‚{ *†H†÷  1‚l0‚h0g0S1 0 UUS10U VeriSign, Inc.1+0)U"VeriSign Time Stamping Services CA8%×úøa¯žôç&µÖZÕ0 + ]0 *†H†÷  1  *†H†÷ 0 *†H†÷  1 110505165510Z0# *†H†÷  1ÀïB¼ànÀ&á6á÷¼ˆûu0  *†H†÷ €3„–AÙóÕɾܱaÖÃoüI(*l*ø ò›¡¢ø¦|Ç ÖÐ/Mqy¬)Ìü)bîíÐuº'︓E½JíNÌ|:ž"M&Íí.¢ƒÛ ñ†OÖÁ÷¶›¡L škernT+ ~h”¶6loca=Zì‚lVmaxpjø˜ name 悤Ì-postCïl$ü&+prepÞŽ¢]„:šØÚfò_<õ ÉBÛÉèKôûÕýÙ b ý¨ ûÕþ¹ £ªŠX/\5ä‡,š3š3Ñfì àï@ [(1ASC ÿýþ„X Ÿ?¶ ÍÁì¤Ó…+7‘¤uq´{‰…-R-=hh‘o¸D“\確‘s‘Ç‘q‘^‘+‘‘ƒ‘m‘y‘oç¢çL‘o‘o‘o^9qÍÏø¦ÏjÏÏÉÁÏoZúÿH¦ÏÏçÏÅÏ®ÏÁÏ\o1 Á¾ž#3N9œR®º3‘XJÿüž‰=böÍwÃwdwf/-¸¶ϨÏÿž߶϶¶¸¶°wöÃw¶ºT®¸ª¬Éü7¬°RÓ=TüÓH‘o즑ӑN‘‘+Tü!žP¨d®NuR‘o“\¨dÿúm‹‘o°5°)ž‰Ŷ=q碤+°LãFuHì;ì ì)^JÍÍÍÍÍÍuÿþøjÏjÏjÏjÏo4oZoo:º/ÅÏ‘wÁ¾Á¾Á¾Á¾9®Ïª¶=b=b=b=b=b=bÃbÍwdwdwdwdwÏÿÞÏkÏÿÆÏÿë–u¸¶°w°w°w°w°w‘o°w¸ª¸ª¸ª¸ª¬ö¬Í=bÍ=bÍ=bøÍwøÍwøÍwøÍw¦ÏÃwº/ÃwjÏdwjÏdwjÏdwjÏdwjÏdwÉ/-É/-É/-É/-Áϸ¶Á¸oÿçÏÿ•o$ÏÿÔo$ÏÿÔoZÏ'oZ϶hZž¨úÿHÏÿž¦Ï߶߶ÏψÏÏaÏ϶ÏݶÏÅϸ¶Åϸ¶Åϸ¶Åϸ¶°w°w°w/–wÁ϶ÁÏmÁÏ£\oºT\oºT\oºT\oºT1 ®1 ®1 ®Á¾¸ªÁ¾¸ªÁ¾¸ªÁ¾¸ªÁ¾¸ªÁ¾¸ª#3É9¬9œR°RœR°RœR°Rs¶‘¾Íÿô=buÿþÃb°w\oºTž+ž+u%ž7㲞sd?žžžž5Íç¢ÅÿØÿØ!ÿØ)ÿØ)ÿØHÿØuÿÎÍÏÏ‘jÏœRÁÏoZ¦ÏÍçÏÅÏ?)¶Ï®Ïh=1 9oN{3Ro:9¸w ^¸¶u¦æ¸wݶ× ¦u ^¼w¸¶wu¦߶ÿôŶÿþ¬w°w嬰Íw²w‘æmwÿìŦßwuæ°wæßwjÏ‘ Ïø\ooZo:úÿHR“Ï– “Ï´ ¶ÏÍÃÏÏÏ9jÏ=yRÅÏÅÏ“ÏsçÏÁ϶ϮÏø1 ´ oNÁÏ\¶ ÏÏD …ÏÃÏòF9ϲ=b˜{‡¶^¶^)dwRžDͶͶ¬¶\f¶ã¶°w϶öÍw‘)¬\wü7Ƕ¤¤Ѷݶ+)ɶ¶îDb¶;)dw¸^¶áwºTϨÏÿëÏÿžw߶¸¬¶¬϶Ï^¶#3É#3É#3É9¬RRRJÿü))ÃD)ffDî{î{红 q‰…Ó… R H–¤öþ´þq‘h‘Nݪ‘JmsÏÍ 3Rôfìì ì5ìZ‘w‘ÝÏøV‘od%š{é‘o‘o‘o‘o¤w55žÏÿžœ‹˜°1°°D°+°=°3°%ªVyšÍTTÏÿž)¸ P3ç϶Í=b`þýª{3®œœ°wÙ¾îªüŒý<üQýýjjÏÅÏdwͶà bÙJÏ϶þ ãÏs¶‹Ù ‰Ïd¶yRž#{Ŧ°wºÍºÍ -wZÙwÃ!wà øÍw×suÛžžåžìé)¦)ÅÏͶÃ/®Ïö/^ ϶jƒyRžDþÏݶ¦Ï¬¶¦1ß' ^)ËÏã¶BÏ–¶bÏɶ×wøÍw1 ‘)9¬9¬“ 7¸ ƒ)\¶¤¤\¶¤¤H϶d=5d=5oZ=R=Ï?¶s\ÁÏã¶ÁÏã¶\¶¤¤çÏf¶oZÍ=bÍ=buÿþÃbjÏdw¢dw¢dw=RyRžDR®ÅÏͶÅÏͶ°w°w°wòFîD´ ¬´ ¬´ ¬\¶¤¤Ï^¶…Ïɶ/^¨ 7Nü7ÃoÃwßqéwîR P R×VsƒçÏ ¶ßéwj ð)‡s ^s\Í=bÍ=bÍ=bÍ=HÍ=bÍ=bÍ=bÍ=bÍ=bÍ=bÍ=bÍ=bjÏdwjÏdwjÏdwjÏdwj‘dkjÏdwjÏdwjÏdwoZÏpoZÏ¥°w°w°w°w°w°w°w°w°w°w°w°wÁ¾¸ªÁ¾¸ªÙ¾îªÙ¾îªÙ¾îªÙ¾îªÙ¾îª9¬9¬9¬Ãwü ü…ûÕü…üuü‰ü‰ü‰üu¢;¤1¤1é?‘wÍ3ú3*‰d‚‘ƒ-/‘{‘sÍ\1 ®ÃwÃwÃwÃwÃwÏÿÁ¿ÿàÿ²ÿïÿîAÂþÏZÿØÏÏÏÏ…À °€0HI~ËÏ'2a’¡°ðÿ7¼ÇÉÝó #ŠŒ¡ªÎÒÖ O_†‘¿Ï?…ÇÊñùM   " & 0 3 : < D p y  ¤ § ¬!!!! !"!&!.!^"""""""+"H"`"e%Êûþÿÿýÿÿ IJ ÌÐ(3b’ ¯ðú7¼ÆÉØó #„ŒŽ£«ÑÖP`ˆ’ÀÐ>€ ÈËòM   & 0 2 9 < D p t  £ § «!!!! !"!&!.!["""""""+"H"`"d%ÊûþÿÿüÿÿÿãÿãÿÂÿÂÿÂÿ°¿²aÿIÿ–þ…þ„þvÿhÿcÿbÿ]gÿDýÏýÍþ‚þýšþ þ þ äXäãzä}ä}ã âBáïáîáíáêáááàáÛáÚáÓáËáÈá™ávátáá á ânàþàûàôàÈà%à"àààààßçßÐßÍÜiOS®ª®Àðàê0L\pr`<–—˜™š›ëœíïžñŸó &'()*+,-./0123456789:;<=>?@AIJ$%TUVWXY¡\]^_`abcdef¢hijklmnopqrstuv£hœžŸ ¤¥£¤¥¦§ijêëìíîïðñòóôõkö÷“”•–—˜™šøù¦ÊËÌÍÎÏÐÑÒÓÔÕÖק¨F©opqrstu45]^@G[ZYXUTSRQPONMLKJIHGFEDCBA@?>=<;:9876510/.-,('&%$#"! , °`E°% Fa#E#aH-, EhD-,E#F`° a °F`°&#HH-,E#F#a° ` °&a° a°&#HH-,E#F`°@a °f`°&#HH-,E#F#a°@` °&a°@a°&#HH-, <<-, E# °ÍD# ¸ZQX# °D#Y °íQX# °MD#Y °&QX# ° D#Y!!-, EhD °` E°FvhŠE`D-,± C#Ce -,± C#C -,°(#p±(>°(#p±(E:± -, E°%Ead°PQXED!!Y-,I°#D-, E°C`D-,°C°Ce -, i°@a°‹ ±,ÀŠŒ¸b`+ d#da\X°aY-,ŠEŠŠ‡°+°)#D°)zä-,Ee°,#DE°+#D-,KRXED!!Y-,KQXED!!Y-,°%# Šõ°`#íì-,°%# Šõ°a#íì-,°%õíì-,°C°RX!!!!!F#F`ŠŠF# FŠ`Ša¸ÿ€b# #Š± ŠpE` °PX°a¸ÿº‹°FŒY°`h:Y-, E°%FRK°Q[X°%F ha°%°%?#!8!Y-, E°%FPX°%F ha°%°%?#!8!Y-,°C°C -,!! d#d‹¸@b-,!°€QX d#d‹¸ b²@/+Y°`-,!°ÀQX d#d‹¸Ub²€/+Y°`-, d#d‹¸@b`#!-,KSXŠ°%Id#Ei°@‹a°€b° aj°#D#°ö!#Š 9/Y-,KSX °%Idi °&°%Id#a°€b° aj°#D°&°öŠ°#D°ö°#D°íŠ°& 9# 9//Y-,E#E`#E`#E`#vh°€b -,°H+-, E°TX°@D E°@aD!!Y-,E±0/E#Ea`°`iD-,KQX°/#p°#B!!Y-,KQX °%EiSXD!!Y!!Y-,E°C°`c°`iD-,°/ED-,E# EŠ`D-,E#E`D-,K#QX¹3ÿà±4 ³34YDD-,°CX°&EŠXdf°`d° `f X!°@Y°aY#XeY°)#D#°)à!!!!!Y-,°CTXKS#KQZX8!!Y!!!!Y-,°CX°%Ed° `f X!°@Y°a#XeY°)#D°%°% XY°%°% F°%#B<°%°%°%°% F°%°`#B< XY°%°%°)à°) EeD°%°%°)à°%°% XY°%°%CH°%°%°%°%°`CH!Y!!!!!!!-,°% F°%#B°%°%EH!!!!-,°% °%°%CH!!!-,E# E °P X#e#Y#h °@PX!°@Y#XeYŠ`D-,KS#KQZX EŠ`D!!Y-,KTX EŠ`D!!Y-,KS#KQZX8!!Y-,°!KTX8!!Y-,°CTX°F+!!!!Y-,°CTX°G+!!!Y-,°CTX°H+!!!!Y-,°CTX°I+!!!Y-, Š#KSŠKQZX#8!!Y-,°%I°SX °@8!Y-,F#F`#Fa#  FŠa¸ÿ€bŠ±@@ŠpE`h:-, Š#IdŠ#SX<!Y-,KRX}zY-,°KKTB-,±B±#ˆQ±@ˆSZX¹ ˆTX²C`BY±$ˆQX¹ @ˆTX²C`B±$ˆTX² C`BKKRX²C`BY¹@€ˆTX²C`BY¹@€c¸ˆTX²C`BY¹@c¸ˆTX²C`BY±&ˆQX¹@c¸ˆTX²@C`BY¹@c¸ˆTX²€C`BYYYYYY±CTX@ @@ @  ±CTX²@º ³  ±€CRX²@¸€± @²@º€ @Y¹@€ˆU¹@c¸ˆUZX³ ³ YYYBBBBB-,Eh#KQX# E d°@PX|YhŠ`YD-,°°%°%°#>°#>± ° #eB° #B°#?°#?± °#eB°#B°-,°€°CP°°CT[X!#° ÉŠíY-,°Y+-,Šå-@À TF!SRÿRFXPFƒ!H U UHUÿOMXNMRMFQ'3&U&2%3$U3U3UÿLJOKJxJF:3UU3U?¯IFXHF‚GF” FF7»F#3"U3U3UU3UOŸÏÿU3Uo¯ï€¸±TS++K¸ÿRK° P[°ˆ°%S°ˆ°@QZ°ˆ°UZ[X±ŽY…BK°2SX°0YK°dSX° ±BYss++^stu+++++t^s+++^st+++++++++++++++++++++++^N¶u¶?šÿìÿìÿìþÿò¶ü”ÿ»þÿàþ©ÿì_Z^WR^a[Y`RVÄRRp$$$$Pv‹þ~—Ãð!Up‡£Á+nÒcÈðhÑ CiœÁ­í K Š Ä ÿ 2 ´ ç  D b ¦ Ú $ a ¼  b † º é@y¦Ùü;d|žÿTß3uMy¸ô cœÝ0µE~®@„·e  Ï+‚ëFmñœì'QYäü3?zÍï7js¥Ê:Pe{Øéú .@©ºËÜîÿ  ! 3 ¡ ² Ã Ô å ÷!'!—!¨!¹!Ê!Ü!í"2"ž"¯"¿"Ï"ß"ð##˜#¤#´#Ä#Ô#å#ö$$$*$•$¥$µ$Å$Õ$å$ö%K%µ%Å%Õ%å%ö&&[&l&}&&ž&®&º'<'M']'n'~'' '±'Á'Ò'Þ'æ(S(d(t(…(•(¦(·(Ã(Ï(à(ð)))")2)C)T)`)p))’)ë*C*T*e*v*‡*˜*©*´*¿*Ð*ç*ó*ÿ++!+-+8+s+„+•+ +¬+½+È+Ô+à,,P,a,q,},ˆ,™,©,´,û-G-X-h-y-‰-›-¬..š.«.».Ç.Ó.ä.õ///'/7/C/O/`/p/{/‡/˜/£/à070H0X0i0y0Š0š0¬0½0Ï0à0ì1H1Y1j1{1‹11®1¾1Ï1à1ñ22*2z33±3Â3Ó3ä3ô3ÿ4 494g44©4Æ4ý5,5j55¿5ÿ666*6;6M6^6p6|66—6Ÿ6¾6Æ6Î6Ö6Þ7?7G7O7}7…77É7Ñ7ö7þ8=8E8M8½8Å99o99“9£9³9Ã9Ô9æ:I:¸:ó;\;¹<">s>Â? ?A?|?ß@?@”@üAAA/A?APAbA±AÂBBB$B6B>B¡BøC8CICZCŠC’CÝCåCíD7D?DŒDíE"E3EgE£E«E³E»EÃEËEÓEÛF#F+F3FdFŸFÏG GTG¢GåH8HžHïH÷IXI»IÛJ#J+JyJÙK KKOK†KÎLL L2L:LBLhLpLÑLÙM MHMyM´NNRN–NæOEOO PPPiPqPyP‹P“PõQOQWQgQwQ§QÎQõRRR'R8RJR\RmR~R•R¬R´RÎRïSS3STSŠS¿SäT"T„T©T¹UUU]UeUˆU¬U¸UÕV VWVÄW4W·X(XŒYYYYaY³YÊYáYøZZsZªZÐ[[/[[[Ä[ö\i\Ä\Ö\è]]+]7]a]ˆ]ª]Ì]î^$^g^ª^ó__z_Ë_Ë_Ë_Ë_Ë_Ë_Ë_Ë_Ë_Ë_Ë_Ë_Ë_ËaahayabbGb¶bÇbØbäbðcc8cvc†c–cúdUd¢dùee ee9ePeaere‚e’ffhfÅg!gˆgîhuªvvkvÍw,wžwÚxxnx»yypy|yˆyÌzzSz›zè{8{v{³{ö|=|||¾}}h}õ~|~ˆ~”~Å~÷~ÿ4z¿€€M€Š€È\¼‚‚O‚‡‚ýƒgƒå„Y„a„r„‚„Û….…y…À† †S†™†ã‡+‡v‡Èˆ ˆ(ˆ9ˆIˆ[ˆlˆtˆ|ˆˆˆð‰@‰R‰c‰u‰†‰˜‰ª‰øŠOŠ`ŠpŠ‚Š“Š¥Š¶Š¾ŠÆŠØŠéŠû‹ ‹‹-‹?‹P‹b‹s‹…‹–‹Â‹îŒŒŒiŒÂk¸ŽŽGŽOŽ±ŠôU­‘‘Z‘§‘÷’L’—’Ö““u“}“Ó”$”0”<”M”^”p”‚”””¦”¸”ʔܔî•••)•;•M•_•q•ƒ•••§•¼•Ð•Ü•è•ù– ––+–=–O–a–s–…–—–©–»–Жä–õ————*—6—G—X—j—|—Ž— —²—Ä—Ö—è—ý˜˜"˜2˜C˜S˜d˜u˜†˜–˜¢˜®˜º˜Æ˜×˜è˜ù™ ™™*™;™L™]™m™y™…™‘™™®™¿™Ð™á™íššMš€šÃ››Q›‰›Ðœ$œRœxœžœÆ+sמžežmž•žŸŸŸ…Ÿ‘ŸŸÿ   0 @ U f w ˆ š « ¼ Í Ø é õ¡¡¡ ¡(¡:¡B¡J¡[¡gÁ ¶@  /3/3993310!!7!!ÁIü·hyý‡¶úJhæ¤ÿìF¶ )@   QY ?+?9/933310#3432#"=wPRRPy=ú˜bbb…¦N¶@  ?3Í2993310#!#!=!É!=!¶ýðýð7ô¶£@_     !  ! RY RY? O  Ï ?O   /3?399//]]33+3333+339939939939223910!!#!#!5!!5!3!3!!!ÇL/þÀVZXþ˜VXVþå+Lþ×7V[YmXVXüÄkNþ• þrOþ=Ãþ=ÃOŽPÆþ:Æþ:PþrŽ¤ÿ‰ß '.{@' %+!( 0/$++NY%  MY¸ÿÀ³H¸ÿÀ@ H,MY ++ //9////3+3+++33+339333910#5&&'53.546753&'4&'66ßƯQ\Ù@KÑY‘Œ@½ QÅš!±Õ n~‰zý¸r~wy¸…¨ìè)g$2ü,XxV|©À¾ ?Z> þBœzUo(þ) |¿Vn&ÅxqÿéË  ,0K@'0-./!'  !'-/21**0/0/$?3?3??9/39/3933333310324&#"#"&5463232#"#"&54632#ÓZ`Ác^`ZÝ–…—Œ‹˜wZ`ÁÁ`ZÝ”ˆ–“‹‰˜þüüÕ`+º»u¸¹¹¸âëñÜßêñüܹ¹rq·ºâëóÚáèð'úJ¶{ÿì‡Í +7Q@-2 ,) 98$%/  5LY !LY?+?+?99993333310467'&&546326673#'#"&2676654&#"{“ÉKB@¿¡›µŒ·Ä=V `?’ ‡Á\«mÑïÇ€Õgþˆy7º(PpŸ||jrƒsŠÂlRGˆJ¨¢i¯kþ7Hªtö´þôÅZS,ÎtWgåHevO¢RO†kU”_^ut…¦¶·?Í9310#!=!¶ýðRþ¼ð¶ @   ?/99331073#&R›’q”ž0o“š1 ή¶þ3ÿþþlªÆ=þ¼Û¶ @   ?/993310#'3Û›’o0ž”q“š1þùþ:¨”ã͵¯þ1h¢ü@ ?Ä910%'%7w%•þu÷|¿´}òþz‘'þkhƒ'þ¬G{þ…GT'ƒh•oú#® 8@#  RY/?_¯¿ß /]3+3939910!!#!5!3q²þNRþP°RüRþP°R²Dþø3îµ//9910%#7' KcAM!îþ÷Øã\7R@ SY/+99105!\ÛRR¢ÿìD°@  QY?+93107432#"¢PRRPNbbb¢¶@ ??993310#¢ýßh ¶úJ¶sÿìÍ (@  MY MY?+?+993310#"3232#"ëîåîçìçòüÀ²µ½­­½½ªßþþŽ}v~pþƒþþ¬þ»PIDPþ°Çª¶ @    ?3?9933310!#47'3ªb  þÛ9V)‘œåG)qË2@  MYNY?+?+993310!!5>54&#"'632!üm…¤„>¬‰·§6·ß¿Û“Ãþ‰X–ª´¤Zƒ¤…EšÌ³‘þñÇþ^ÿìË(Q@+#  *)NY  &&MY& MY ?+?+9/_^]+99333910!"'532654&##532654&#"'6632Ó«°¸þéþúߦTÑ\ÝÞãÜž ¶Õ­Œm´p1Uð{ÊÜ^ˆº´˜ÍáSc,2³£‘œ`­”z“=JCGS¿+u¾ @@!  MY?33?9/+993333310##!533!7#uü^ýÕyüþ¦gýüuþ‹uCü ¢.Í%—ýÿì¶:@ MYNY MY?+?+9/+933102#"&'532654&#"'!!6ê þèömÄBl¨_Àèâ‚Ž<:Àýž-œoâÆáú+(g7+Ë­£º''`ýüƒÿì#Í&N@*# (' OY  OYMY?+?+9/_^]+9933310$32&#"36632#"2654&#"ƒ›É^NIg÷þí LÄmÍçóÎÞþÿߤ¶´›f¯hc©o…¼Xþœþ¬bdêÎàþýSûο¨¼Z•NoÍxm¶+@NY?+9?93310!!5!NZüŲý¤V`Iú“yÿìÏ$1W@/ /( ",32",,"OY, ,, %MY MY ?+?+9/_^]+9393333102#"&5467&&546632654&'"6654&FºãžÀœýÕÝ즮¡„j¿ò»¨¤Èบe«?wŒ£Ž©Ͼ¢p¬IO¼†µØÊÁƒÆFL©viŸVû™Š˜¡Š|›UG¬‹‹yFkW:?˜kxŒoÿì Í(N@*% *)!OYp MY OY?+?+9/_^]+9933310#"'532##"&5432"326654&& —þßÍhX+y ÷ IÊnËãùÇØuþ#ž¼®¢e¯g]§Jþàþ|ºVeV`gàÎÜ—þÜcÕ¹®´Z•MuÌs¢ÿìD-9@"  QY / O o   QY?+/_^]+9399107432#"432#"&¢PRRPPR/#".Nbbbßbb5..LþøD-/@  QY_  Ÿ ¿ Ï ß  /]+//9310%#67432#"&/ KcABPR/#".îþ÷Øa)lÝbb5..o #Á @?_/]Æ93105#üL´üÉ7  =Ú_þkþoÝ#Ç?@) RYï RY/o¯¿ß/]+Æ_^]]+9105!5!o´üL´uRRþhRRo #Á @?_/]Æ93105o7üÉ´üLjc•_þ&=þ`9ÿìË'A@!$  )(& PY&"QY&?+?+9/93933310546776654&#"'6632432#"%Ke[H>§ˆOŠP%n•O·Ò$A\8@EsPRRPy%{œYO=xN–#'P0 ŬDfWQ/6YbaþÕbbbqÿ;¦¬5@T@-<;6 ". (.BA >+990 @ €  2%+2?3/39/]3339/39933333310#"&'##"&543232654$#"!267# $3232&#"¦µ›Yo +¢l”¢ñŠ”FQgƒžþÛ¼æþ¡½N3]¿ˆËÓþ£þzÙú×K³ûÓnwÿOr•°Õäþìl]deÁ®Ê)þ0hié»Â$Çþ”ìþ¾þ¡$4cP‘e™â²þµþŸZ#Íͼ<@     LY?3?9/+99333310!#3#!&'ý®ÌqLA@sý Ç# ýü¼úD`>n`NÏ‘¶Q@+   !LY LYLY?+?+9/_^]+99333310! #!!2654&#!! !Ï‘þ›•¯¥þôöþ@fBλÓÑþÙX–þT¶¸º©©—ÊÚ+‰’’„ýuý‰J-ÿì¸Ë&@LY JY ?+?+9310 !27# 4$32&?þíþÄ*¸š‘ÙþÌþž©=ÒÖ©) oþ þÎþÇþ¦/Z3ŽeßT¹P\PÏ%¶(@  LYLY?+?+993310!!! !!3 %þ~þŠþ¢‹^moþÁþËþóòéþþ‡¶þ’þ:=úþÏî¶ E@%   JY JY JY?+?+9/_^]+933310!!!!!!!îüáýG’ýn¹¶^ý×^ýÏð¶ <@!  JY? JY??+9/_^]+93310!#!!!!5f!ýE”ýl¶^ý”_ÿì)Í:@ KY LY LY?+?+9/+93310!! 4$32&# !27!Ôþ÷þ¦þ·UÝï¾)¾Ìþßþ­B8ÊþMáýeZ‡fßY¼X\Xþ›þÑþ¶þ³9Ïò¶ 7@  JY/ ?3?39/]+99333310!#!#3!3ògüªffVgÏý1¶ýw‰Z¶ 7@   LY LY?+3?+3933310!!57'5!þFªªºªªB AAúöÿHþ5¶ @  JY"?+?93310"'5323!\;NGòfþXÀúJþϦ¶ 5@     ?3?399333310!##373¦}ýÏÃff¢=‚ý©¬ý¨¶ý¢Vý–Ïî¶@KY?+?9931033!Ïf¹¶úª`϶>@     ?33?39933933333310!##333#47#Rýßbžšg ýÝF|‚û¸¶úúúJTt|ú¼Ïö¶.@  ?3?39999333310!###33&53ögüž bfa cèvüL¶ú𴢺ÿìœÍ (@  KY KY?+?+993310! ! ! ! œþ¤þÎþÏþ¤_02ZûTþéþúþûþåÝþ¤þk•^]‘þmþ£þÆþ©T=<Qþ¬Ï?¶ 4@  LY LY??+9/+9933310!##! 32654&##?þàþøâff üöÉ÷ÜÐÚòÔâý¤¶üþ£·©£þ¤œÍ9@  KYJY?+Æ3?+9333310## ! ! ! œüßM¦þæ!þÏþ¤_02ZûTþéþúþûþåÝþÚþ6þ¤J•^]‘þmþ£þÆþ©T=<Qþ¬Ï“¶ R@.   LY?O  LY?+?39/_^]+393333310#! #%!2654&##5f\›žzþ‡þ•¹ÌÈâò}ýƒ¶ÉÊ“Ê,ýf}X¥¡§˜oÿìöË$4@ %& LYJY?+?+9993310# '532654&&'&&54$32&#"öþóßþôžõ´ÓFž™à«Êε%¶¦¢À;†£«¬Oy·Ö;fC¥†SmZ4M³•¤ÏNXL–QhS:;o '¶%@ KY?+3?9310!#!5!!Lgþ%þ%V``¾ÿì¶%@  LY?+?3993310!"533265þÜþûþþãgêÖÑæ¶üNüþäÿ®üNÓëçͼž¶ *@ ??3993333103#367/oýÝZýßmpT;¶úJ¶üáqKž3ð¶D@"    ?3?3393993333333310!#&'#363663\Tþ¿(;þÛVþnkNúq%3 ) gh‹YWâûí¶üR9aUO(ˆwü°lH¢,N¶ 5@    ?3?3999333310!##33NuþPþHqìþAs‹‘mþ;ªýVú¼ýŽrýF9¶,@ ??3993339103#3¬nþiþu– üýË-‰RJ¶ 8@  KYKY?+9?+993310!!5!5!!JüXüϺü¦qL `Lúö®þ¼Z¶@  ?3/3993310!!!!ZþT¬þ¶Jþ¼ú^ùâ¶@ ??993310##gýÞ¶úJ¶3þ¼ß¶@  ?3/3993310!!5!!3Jþ¶¬þTå=^ùX19Á'@?Í2993333103#XÑDÌdþuþr1üpüéÿüþöNÿH@ SY/+3310!5!Nü®RþöR‰Ù! @  €/Í99310#&&'53E`¹!Ž‘FÙO¹/0¼Lbÿì“R$Q@, "&% IY    HYFY?+?+?9/_^]+99333310!'##"&54$7754&#"'632%2655JR­v ² ûÏ~Œ—¢%³¯³±þ'®É¾åÃ}¬iW¤‘Ÿ°H›žTVTºÅý-FDZk y€fq¶ÿìL!>@   #"  FYHY?+?+??99993333102#"&'##3366"3265äçóÜtº6 >c>¯yÀ¦­·²´TþáþìþñþÚ`X¤þyXJUb\ZÜýöÖùæ×wÿì…T&@ FYFY?+?+9310"32&#"327héþøîhÈÎι”h&-1X/÷èÜù5\3wÿì >@   !   FYHY?+?+??999933331023&53#'##""!26554&Dv¬DbA|èáîìá²³g¸¬©TVh~y‡ù즺 *Zúîþ2ÖöüÝwÿìîTG@'    HY HYFY?+?+9/_^]+933310"32!3267"!4&míþ÷ÙÀÞüñÍ¿]l\œ{¾ ¤$9þôæPàì+Z(ÏýÕÕ=@  HY HY?+33?+?9399310!##5754632&#"!JÿcÊÊ“§ZZPOtaéüé:%TÈ»V‰še-þT)3?€@G :4$.*$A@'2! 7IY` )2GY)'=IY')IY),IY?+?+?+9/+9/_^]+339993333310#"'332!"&5467&&547&&54632! 4&## 32654&#"áZÑ°J;>O]¾±¼þéþþÍá‹w1;‹_jÏ°k;ýìM¬†–²þÕS™€ˆ‘•†‚•?Ep†ÃT/40Œ¬»žp”M2mS'§l£Åû àbX¹~‹Šƒ‹‹•¶3@    FY ?3??+999333310!4&#"#33663 ¬Š‘õcc=ºŠrÁ¤•ÅÝý¨þ‹bXþsý9¨)Í %@ `  ???Í]933310!#3432#"ccq?##??.`2.-4ÿžþ)Í 4@  @FY?+??Í_^]9333310"'53253432#"%P7E<—c?##?þV° úY`2.-4¶ß 8@       ?3??993333103##3+xþTÑwþc²ccÝbþ0ý‘%¢þ}üôþÕ¶@ ??9310!#3cc¶fT"H@$ "  "$#   FY?3+3?33?9993333910!4&#"##"#33663 36632|€§ eü«œcR-¦dI5³r²²ÉŸ’¸ÅýƒçÇÛý¨?•QYÁ]d¾Ïý9¶T1@    FY  ?3??+99933310!4&#"#336! ¬Š‘õcTjrÁ¤•ÅÝý¨?•ªþsý9wÿì9T (@  FY FY?+?+993310#"&53232654&#"9þþãÚtáàÿü¦Å´´ÅÇ´´Ã!þöþÕŠ© )þÓþúàûûàáø÷¶þLTA@!  ! FY HY?+???+999933333310"'##33632'265!"‡ûscTpöÜçóÔ§·þ¦¾²«¼TJXþb+›°þßþìþôþÙXøßßÑì ÿÚwþ T>@  !   FYHY?+?+??9999333310"32373#47#'2654&#"9ÖììÜìuTbvùÆ©ªº°·³ -®™ùÕžz~¾XÚ õÚøðåé¶öT,@   FY?+??99933102&#"#3366bEODI‹²cT C˜T_ì´ý¨?ÄxaTÿìXT#4@ %$ FYFY?+?+9993310#"'532654&'.54632&#"XÞÌÚ€¤¶¡§…˜£„C͸°ž% ‰…œy°“†C’CkRkYRp6;UkMzŽBZBXNUf?5UlÿìyF;@    HYHY?+?+333/939910%27#"&5#5773!!Õ^FH^‰¡¡23?þÁXDPš¥¾:-öþùVýP}xªÿì?0@     FY?+??39993331032653#'#!  Š‘·bTjþñþ?ý@¤•ÄÝXûÁ–ªÆ¬? (@    ?2?39333310!33673¤þ\f8)+fþ\?ýŽjˆráûÁª?L@'     ?3?33939393333333310!&'##33673363î$-òbþÉj®=;àZÕHH¦dþÙ×JJ‘ý+?ýŠênêM—ýkëLApûÁ7Å? 3@     ?3?399933331033##Áþ…rDAmþ‹sþªþ¨m/þ6ÊýðýÑåþþ¬?2@   FY?+?3/393333103363#"'532>7fæi*_æfþ;PkL9F:C3N?S ?ýžþçb\ûšl6V0eÛ!RZ? 8@  HYHY?+9?+993310!!5!5!!Züø…ýª×ýw‹?¨X?üX=þ¼‹¶7@   ?3/39/3993993310"&54'5665%…wÃ¥æzlhŠ|XbaYfe[–œQÍPbc^+ZjhþÏ‚€{üþX@ ??93103#ü\\÷íHþ¼–¶7@    ?3/39/39939933104675&&54&'52#5665NYaaY{‹®ºmyæ¥Ãy'{€ƒ1gkZ›–þ¢daPÍþ¯›—[egoh#=,@ €oŸ@ H/+]3Í2ÄÄ9910"56323267#"'&N1v8l}=le~^8k>0qItš|é=;^n,:=@`1@H9¦þ‰HT )@" QY?+?9/9333103#432#"&×=wPR/#".ÇûÂibb5..ÓÿìÍË_@;  MY ° À Ð  MY 0`p€??9/]q+39/_^]3+939910%&5475332&#"327###ZºÍͺRƒ†g»ËÉ´ƒˆn R¾"ëè+!®¦7T3õìáù:\8ÌN1ÉO@*     OYMYNY?+9?+9/3+39399310!!5665#534632&#"!œFN)ün{ÓÓÄ·¯›#Š‰›¤ÿt 0`T²‡R)ÌÞDVB¢¬þÓR ž'T@%  )(@ H ¸ÿÀ@ H  "oß/]3Ô29Æ+2Æ+293310'#"''7&547'763272654&#"ßZ‹;‰n–™kŠ;‹ZZ‹;Šg›i‰;‹Zþi†½¾…†¾½Ó—i<Ž]]ŽP@-5*8<1 %@?<5-! IY !'IY!?+?+99933333310467&&54632&&#"#"&'532654&&'&&76654&&'‘eXVNË®¯¡#[‡M†3x€ÀºVVâÆ\žV¶–¢ª2Èe?”°RX@™ Qc-S‹&/nQu…@P"YK6E>+@‰f­e*lR‡‘%_Nc[7AB.I‰qANH?)r@>PJ2pPLÃ@  /3Í29933104632#"%4632#"P @@?} @@?m.(VVV.(VVdÿìDË%5N@/.&76àð   ï ÿ   "2*"?3?399//]3]3933310"327#"&54632&4$32#"$732$54$#"Ž¡•’Trfj»ËÞºwl%bü‡È^ÊÈ^ÊÂþ¢ÐÏþ¢Ã]±0²²/²«þ͵°þϲD½ªº²+X-æØÐù4S-þ—È^ÊÈþ¢ÊÅþ¦ÐÏZƲþѲ±0²®.¸±þÌN!DÇ!7@ #" ?3Ô]Ä39/39333310'#"&5467754&#"'632%32655Tv_p ¡_LDWm!uräþdF=ZiXtz-HTbZdg+MK1I8×þ=´6>d\@=R}-¨ -@    _/]3Ä29333310%R5>þþ>þËh6=þþ=þʉ+þ•þ–+‡‰+þ•þ–+‡oü3@ RY/?_¯¿ß /]+Ä99310#!5Rü³üþœRÿÿ\7RdÿìDË%5c@6  .& 76  "2*"?3?399//]3]39/33933333331032654#####324$32#"$732$54$#"Åp[hÅn›MHíyÒ¨eÓžüÈ^ÊÈ^ÊÂþ¢ÐÏþ¢Ã]±0²²/²«þ͵°þϲÛ]Y¬§Oy"þwhþ˜p|þÄÈ^ÊÈþ¢ÊÅþ¦ÐÏZƲþѲ±0²®.¸±þÌÿúf@ SY/+3310!5!ûô R‹uáË #@ ?  ?3Ä]29933104632#"&732654&#"‹­~~­­~‚©ZzWV{xYZw „§§„„§¦…[~|]\}€ÿÿo#®'+ýW5JuË%@   ?33?393310!576654&#"'632!uýÀò}^]Mlm1w—|Œ6Sþõ¿JNíyMGSRAgo/TW]þü)9Ë#?@% %$O_o ! !?3?39/]]3993310#"'532654&##532654&#"'632hXIº±Ÿxˆ‚swwwƒ‡ij^P€v/‚£‘ìNk-¦‚bWSNTWMCQNF^x‰Ù! @   € /Í993106673#‰I$­hFéO¹04¬W¶þ??@     FY?+???39399933331032653#'##"&'#ŠÂ·bT2Èuc‰3c?ý@¤•ÄÝXûÁ–M]79\Nþb+qþüR-@ JY/+/9/393310####"&563!Rdäd@RØËÚèþüºùF3úûþÿÿ¢oD3ƒ+þ‰'@    /?39/393310#"'532654'73‰‡yD>NRÁ]`B¨þÝde X 84^®u%LJº¶ @    ?2?99933103#47'^\b Ï/¶ü”#c†zMF!žÇ %@  ?3Ä]2993310#"&54632324&#"ž šœ‘ŽþÑÑdmmdu¡³¬¨¢°®¤þøƒH}#¨ )@   _/]3Ä/293310'7'7#þË>þþ>5þ—þË=þþ=5þw+jk+þyþw+jk+þyÿÿ;p¶&{ï'?<ßý· ³?55ÿÿ {¶&{¿'ôtý·²?5ÿÿ)×Ë&u'×<Fý· ³+?55Jþu%T(?@ #*)!!&QY! PY#?+?+9/939333103277#"&54667>55432#"&9OaZI>¤‹}l@%o•N¸Ñ(M…@E/PR/#".Ç%}ŸUO=wO|˜.O0 ƪFl`o5[aa+bb5..ÿÿÍs&$CÿÈR³&+5ÿÿÍs&$voR³&+5ÿÿÍs&$KR³&+5ÿÿÍ&$RR³&+5ÿÿÍ&$jR ´&+55ÿÿÍ&$Pš ³?55ÿþø¶m@;   JY   LY JYJY?+?+3?9/+9/_^]+93333993310!!!#!!!!!!#øý3þ%ãomý™@ýÀgû²dýü¶^ý×^ýøÿÿþ¸Ë&&zÿÿÏîs&(Cÿ±R³ &+5ÿÿÏîs&(vFR³&+5ÿÿÏîs&(KR³&+5ÿÿÏî&(jR ´&+55ÿÿ4s&,Cþ«R³ &+5ÿÿZ_s&,vÿWR³&+5ÿÿ[s&,KþêR³&+5ÿÿ:6&,jþêR ´&+55/%¶ [@6 JY?_oŸ¿  LY LY?+?+9/_^]3+39399310!!#53! !!!!3 %þ~þŠþ¢  ‹^moþÁþËþó–þjòéþþ‡¦^²þ’þ:=ý¨^ý´ÿÿÏö&1RuR³&+5ÿÿÿìœs&2CmR³&+5ÿÿÿìœs&2v%R³!&+5ÿÿÿìœs&2KÁR³%&+5ÿÿÿìœ&2R R³"&+5ÿÿÿìœ&2jÁR ´(&+55w¤ @  _  ß  /]910'7H™:þh–:þiþj9•þi9 ˜:þiþh9˜þh9˜—:ÿìœì#U@1  %$!  !KY KY?+?+3399933910!"''7&!27'3 &# œþ¤þÎìŸVJZ¼_0è lHo¿o‹ý…ÍûËã…ÉþûþåÝþ¤þkxx;Èq]‘y˜<™Ïþ•;«ûójT=þÈ« fþ¬ÿÿ¾ÿìs&8C9R³&+5ÿÿ¾ÿìs&8vðR³&+5ÿÿ¾ÿìs&8K‘R³&+5ÿÿ¾ÿì&8j‘R ´"&+55ÿÿ9s&<v)R³&+5Ï?¶ @@!  LY  LY/  ??9/]+9/+99333310!##3! 32654&##?þàþøâff üöÉ÷ÜÐÚò Ôâþ¬¶þøüþ£·©£¶ÿìD4A@" & -. .65&2.2)HY2HY?+?+?999333310#"&'532654&'&&54676654&#"#4632Á‹Q;JAj[-°ž_Ÿ/A§EryNn`AJJAŒ„‘¢cϽ¼Ã‹o@I',0B-KckCœ«%k&0mjSzKWxV9QEL‰Ty—þlç’¥É̺Ïöÿÿ¶É&QRÿ³&+5ÿÿwÿì9!&RCƳ&+5ÿÿwÿì9!&Rvj³"&+5ÿÿwÿì9!&RK ³&&+5ÿÿwÿì9É&RRí³#&+5ÿÿwÿì9Ã&Rj ´)&+55o#– \@=RYÐP  RY@/?_¯¿ß /]333/]+/_^]q+9399105!432#"&432#"&o´ýÕPR/#".PR/#".ªRR‰cc4..ýtbb5..wÿÝ9h#U@1  %$! FY !FY?+3?+399933910#"''7&5327&#"4'3269þþã­vVH]yá³z`Jhpü¦Nb”´ÃòHýá^´Å!þöþÕbq:x™ù )h|7‰“ôÈzÁZ÷â¾wýBRûÿÿªÿì!&XC§³&+5ÿÿªÿì!&Xvf³&+5ÿÿªÿì!&XK³ &+5ÿÿªÿìÃ&Xj ´#&+55ÿÿþ¬!&\và³"&+5¶þL >@"! FYHY?+?+??9999333310632#"'##3265!"rþÜçóÒûsccs§·þ¤Á­«–¾þßþìþôþÙ¼TJXþbþy÷ü®øßßÒùÿÚÿÿþ¬Ã&\j† ´)&+55ÿÿ͇&$M1R³&+5ÿÿbÿì“5&DMí³(&+5ÿÿÍ!&$NR³&+5ÿÿbÿì“Ï&DNÞ³%&+5ÿÿþBá¼&$QƒbþBÀR)4j@< ..'2 !'65@P '#.IY #'#HY#*FY?+?+?9/_^]+99/_^]393333310327#"&54767'##"&54$7754&#"'632%2655j1!(@Tc(&YR­v ² ûÏ~Œ—¢%³¯³±HGþ¶®É¾åÃ}øn T_WFECGŸiW¤‘Ÿ°H›žTVTºÅý-?qöDZk y€fqÿÿÿì¸s&&vR³ &+5ÿÿwÿì…!&Fv3³&+5ÿÿÿì¸s&&K®R³$&+5ÿÿwÿì…!&FK÷³#&+5ÿÿÿì¸&&OR³&+5ÿÿwÿì…Í&FOX³&+5ÿÿÿì¸s&&LªR³&+5ÿÿwÿì…!&FL÷³&+5ÿÿÏ%s&'LPR³&+5ÿÿwÿì;&G8Ùÿÿ/%¶’wÿì¨'b@8 $)( IY FY  !HY?+?_^]+??9/3+39993391023&55!5!533##'##""!26554&Dv¬Dþ'ÙbœœA|èáîìá²³g¸¬©TVh~ykRÊÊRû¦º *Zúîþ2ÖöüÝÿÿÏî‡&(MR³&+5ÿÿwÿìî5&HM³&+5ÿÿÏî!&(N R³ &+5ÿÿwÿìîÏ&HNû³&+5ÿÿÏî&(Om5³&+5ÿÿwÿìîÍ&HON³$&+5ÿÿÏþBî¶&(QPÿÿwþgîT&HQN%ÿÿÏîs&(LR³&+5ÿÿwÿìî!&HLñ³&+5ÿÿÿì)s&*KÕR³(&+5ÿÿ-þ!&JK»³M&+5ÿÿÿì)!&*NÕR³&+5ÿÿ-þÏ&JN·³@&+5ÿÿÿì)&*O?R³#&+5ÿÿ-þÍ&JO³H&+5ÿÿþ;)Í&*9ÿÿ-þ!&J:?³D&+5ÿÿÏòs&+K‘R³&+5ÿÿ¶ª&KK‰³"&+5Á¶`@4    JYJY/ ?3?39/]+9/33+3393399103!33##!##5!ÏfVgÏÏgüªfÏ‹üª¨þòþò^û¶Ïý1J^þ…þãY@2     IY  FY ?]+?3?9/3+393933910!4&#"##5353!!3663 ¬Š‘ųc››cÙþ'=ºŠr¢¤•ÄÞýÇøRÊÊRò‹bXþsýXÿÿÿç¡&,RþÌR³&+5ÿÿÿ•OÉ&óRþz³&+5ÿÿ$O‡&,MþÿR³&+5ÿÿÿÔÿ5&óMþ¯³&+5ÿÿ$M!&,NþíR³ &+5ÿÿÿÔýÏ&óNþ³&+5ÿÿZþB¶&,Qfÿÿ'þBFÍ&LQèÿÿZ&,OFR³&+5¶?@ ??9310!#3cc?ÿÿZþ¤¶&,-oÿÿ¨þøÍ&LMÏÿÿÿHþ$s&-Kþ³R³&+5ÿÿÿžþ !&7Kþ›³&+5ÿÿÏþ;¦¶&.9ÿÿ¶þ;ß&N9)¶ß? 7@       ?3?3993333103##3+xþTÑwþc²ccÝbþ0ý‘%¢þ}?þÉþÕÿÿÏîs&/vÿYR³&+5ÿÿˆ¬&Ovþÿ‹³ &+5ÿÿÏþ;î¶&/9Bÿÿaþ;(&O9þÖÿÿÏî·&/8ÿ£² ?5ÿÿ¶H&O8æÿÿÏî¶&/Oýkÿÿ¶&OOãý8î¶ 9@   @ KY?+?9/Í99399103'73%!ω)²fD/þ¹'VJp+ýÍLæýú`Ý =@$   ?_¯¿ ??9/]qÍ99399107#'73™+Äc-®c1gFƒý1VHs"ÿÿÏös&1váR³&+5ÿÿ¶!&Qv`³&+5ÿÿÏþ;ö¶&19Ëÿÿ¶þ;T&Q9PÿÿÏös&1L“R³&+5ÿÿ¶!&QL³&+5ÿÿZ¶&QLäÏþö¶<@   JY"?+?33?3999333310!!"'5325##33&53öþª];NHñüž bfa cþX èvüL¶ú𴢺¶þT>@ FYFY?+?+??999333310"'53254&#"#336632O9E<˜‘˜½­cT6ºpÉÂ}þV°¢¤•ÇÛý¨?•WSÆÇüf†“ÿÿÿ윇&2MÕR³&+5ÿÿwÿì95&RM³&+5ÿÿÿìœ!&2NÃR³&+5ÿÿwÿì9Ï&RN ³&+5ÿÿÿìœs&2SR ´)&+55ÿÿwÿì9!&RST ´*&+55ÿð²Ç^@4 ! JY  JY JY KY KY?+?+?+?+9/_^]+9333310!!# !2!!!!!27&# ²ý LdþÏþ¤]2Niëýqhý˜ü\mA>nþúþæ_[^ý×^ýòþ±þÈþÅþ®wÿìT ,3g@7'0'1! '54 0HY00 00 -* *FY $$FY?3+3?3+39/_^]+99933339910"&'#"&532!2!326732654&#"%"!4&žœÝ7;Æ™Útá—È9n!ÀÞýŲ]l\œúãÅ´®¶º¬´Ã¢›®¤‡ƒ€ŠŠ© )Œ‹þôæPææ+Z(5àûõæàù÷ùнÕÿÿÏ“s&5vbR³ &+5ÿÿ¶ö!&Uvʳ&+5ÿÿÏþ;“¶&59ÿÿmþ;öT&U9þâÿÿÏ“s&5LR³&+5ÿÿ£ö!&ULÿx³&+5ÿÿoÿìös&6v?R³.&+5ÿÿTÿìX!&VvÖ³-&+5ÿÿoÿìös&6KÿíR³2&+5ÿÿTÿìX!&VK™³1&+5ÿÿoþöË&6zFÿÿTþXT&Vzìÿÿoÿìös&6LÿêR³(&+5ÿÿTÿìX!&VL†³'&+5ÿÿ þ;'¶&79ÿÿþ;yF&W9ÿ|ÿÿ 's&7LÿÌR³ &+5ÿÿÿì¦&W8D '¶?@!  JY  KY ?+3?9/3+3939910!!#!5!!5!!Lbþžgþšfþ%þ%_ýFº_=``ÿìyFR@-  HY @  HYHY?+?+3Í39/3+3939103#5773!!!!327#"&5#)‘¡¡23?þÁ5þËX^^FH^‰‘°9:-öþùVþÇVþß}xPš¥/ÿÿ¾ÿì&8RqR³&+5ÿÿªÿìÉ&XRñ³&+5ÿÿ¾ÿì‡&8M¦R³&+5ÿÿªÿì5&XM#³&+5ÿÿ¾ÿì!&8N“R³&+5ÿÿªÿìÏ&XN³&+5ÿÿ¾ÿìÕ&8P“R ´&+55ÿÿªÿìƒ&XP ´&+55ÿÿ¾ÿìs&8SÙR ´#&+55ÿÿªÿì!&XSX ´$&+55ÿÿ¾þB¶&8QªþB/?#M@*  " "%$@P # #FY?+?3?393/_^]3933331032653327#"&54767'#!"&5 Š‘·bHGj1!(@Tc('Njþñº¹?ý@¤•ÄÝXûÁ?qHn T_WFEE<’ªÆÇÆÿÿ3ðs&:K?R³)&+5ÿÿª!&ZK ³)&+5ÿÿ9s&<KÿÐR³&+5ÿÿþ¬!&\Kˆ³&&+5ÿÿ9&<jÿÐR ´&+55ÿÿRJs&=vXR³&+5ÿÿRZ!&]vó³&+5ÿÿRJ&=O\R³&+5ÿÿRZÍ&]Oø³&+5ÿÿRJs&=L R³ &+5ÿÿRZ!&]L›³ &+5¶¤ !@ HY?+?93310!#4632&#"c•¥ZZPOtaœË¸V‰š¾þòËD@$ MYMY MY?+?+9/3+39399105754632&#"!!#"'5325/Ï™¤ReYGsfþ玈U7NB°V;%’ɺV‡œ¢Xûü›£ZÙÿôת%.}@J(*   *.  0 /.@H. # JY  O(_(o(( ?3Ä]9////]+_^]33Æ+333393333310#!#&&54632&'32654&#"7673#DRD)sÈý—Ñn5DTxabx1Ï$(чL=>LN<2@ IY    HYFY?+?+?9/_^]+9Þ2Ä_^]2Ä]9/9333333310!'##"&54$7754&#"'632%26556673##"&5463232654&#"JR­v ² ûÏ~Œ—¢%³¯³±þ'®É¾åÃ}‹0k!Š#›DD#xaaxxaaxþL>>KN;‹)bD®FzclqFéC²CxÀejr]+Ùq! (@    €/Í299333310#&'53673qªHbL¦FrklqF¼{€·^qr]%ãP5@  H/+39910!!%+ýÕ5R7Ù`Ï @   €/2Ì2993310"'332673JýR]XX]PÙöWKKWö² 3Í ¶ /Í9310432#"²@""@m`2.-4sÛ%ƒ  @   À/3Ì2993310#"&5463232654&#"%xaaxxaaxþžK>>KN;>K°atta^uv]BKKB@KL?þB^&@    `p//]393310327#"&54673¢j1!(@TcPHZHGøn T_WFŠ8?qÛÕÉ&@    €/2Í2ÄÄ993310"&'&&#"#663232673 $N> = -<I jT0P*"@.>LjÛ%5(EWo2",IStzÙ˜!#@   €/3Í2933106673#%6673#HUˆ‡wFRHUˆ‡wFé!r¥Êm!r¥ÊmÙìs @   € /Í993106673#8wZ4:éKÚeMäX5h´1@  €/3Ì9/33933310673##432#"%432#"K(ug2:Ù@??@´@??@}¤“4ºGVVVVVVVÿÿÍ &$Tþ:ÿ—²?5ÿÿ¢oD3ƒÿÿÿØH &(ZTýÆÿ—²?5ÿÿÿØL &+ZTýÆÿ—²?5ÿÿÿØÆ ',²TýÆÿ—²?5ÿÿÿØÿì¨ &2 TýÆÿ—²?5ÿÿÿØ) '<ðTýÆÿ—² ?5ÿÿÿØõ &vTýÆÿ—ÿÿÿÎÿìP´&†Uþ™ µ&&+555ÿÿͼ$ÿÿÏ‘¶%Ïð¶@JY?+?99310!#!!5f!ýE¶^ÿÿ}¶(ÿÿÏî¶(ÿÿRJ¶=ÿÿÏò¶+ÿìœÍH@*  JY?_o  KY KY?+?+9/_^]+93310!!%! ! ! ! Á™ýgÛþ¤þÎþÏþ¤_02ZûTþéþúþûþå_#þ¤þk•^]‘þmþ£þÆþ©T=<Qþ¬ÿÿZ¶,ÿÿϦ¶.ͼ *@ ?3?993333103#3#&'qqT1HsþL%¼úD`@"&% #HY?+3?93933333105!#654&&'&&54>7!¶ÍÿþÝ:„„™:2?`r4vjѸ3\…¯Îiþý¾VKìþ©þä›qO!:VC<~V›g17,&мd¸¯¯¼Ä¶þT7@      FY?+???9399333104&#"#336632¬‘˜½­cT6ºpÉÂþ­¤•ÇÛý¨?•WSÆÇûMwÿì+ I@'   HY/ HY HY?+?+9/_^]+99333310# 3  !"!ìéþ3ïäÏþ-aý# _°¯ Û ¶þqþm ˆ—ú´ýLþ·þÄH=¦ÿìP?@  HY ?+?99310327#"&5]jA@R%˜‡?üú†oT  £ÿÿ¶ß?úÿôÿì!"?@ "$#  IY IY?+?+?9333939310#'.#"5632327#"&''# Ý7#2B0,:?3DXD/‘$04C¬` YþÙD¥kS* K.k„û++ J@Iém_ÖýRÿÿ¶þ?wÿþÇ? (@   ?3?2399333310333#f"8_Üïf?üó›?qvþ þàwþos/\@0!'  , $'10..IY..%#'$%$HY%?+3?9/+9939333339910#"#654&&'&&54675&&5467##5!#"!3)–ÈìA„¤®}q`r5ujϺ ‘ysª E³Xž›þúŒ|– ÁŸ]wK#&faw—c2:*&Æ¡Ï* $Žoƒ¿+ VO^£fþÿÿwÿì9TRÿì¬?7@    HYHY?+?+33?93310%27#"&5!##57!#=*%-[gýëbÝ¥îÝD Ttqüé:Vüö›°þ5T;@   FYHY?+?+?999933310#"&'##32%"32654&5ùòT§AbäßÝåþ5³¥D•aþ«#þéþà55^»þ×# þäÂÝêþ‹==ëôèïwþo…T 5@ "! #FY?+?939333310#6654&'.532&&# ßFž‹¡„%3`7;v”©M öŠ‚E†*þj`"h_,SJGJˆ2AFzÇ…:1Xwÿì? 7@    HY FY?+?+39339310#"5!!#3265'#"1ÿâÞû+Àþ®ü®Â³±ÄµOöðùþßù#VÈþáÑëèÊ)ÈîÿìP?,@HY HY ?+?+39310!327#"&5!57PþRmxKG9o™›þ×¢?Vý[ƒTª¡²:¦ÿì=?+@  HY?+?399333310"&3324&'3ZÛÙb¥µ½º!bóúSý¢ÉÔ܈tçþÂþÖwþöT#J@&  %$FY  HY?3+3?+??9333993310$7!24&#">}ÿþúÈPfJÎÐ¥¹„ñ¢®‹qXZ€ÅiþØ! "÷8ŠÜ{Ýöªfþçõ´þù” þ(0Ìê‹ýT Þÿìþ N"H@)   $#IY IY?+?+??9329391023327#"&&'#&&#"56(8,(ÅXoþjÁ624$*&%;:QC8ªþbpÝä4#%.N:`þ™ýþ(†X& L1i¬ý-:3C:G¦þ?G@$   FY ?3+3??3?9333993310654&'3#$3àç$`?þãþòbþÿþõbÜÎú8ê~Ýšâþ÷þêþÁþ&Ú  ýäÝï Èwÿìh?)O@'#$$' ' '+* # FY?3+3?39/993333333910"&'##"4733265332654'3 q€# 'ƒi¨º:AfB7†|krcun|€7Bg?;¶g_g_¡ ˆšþ÷–Ûå•Dþ¼ˆšèØ™›„þó¤þþþäÿÿÿìPÃ&†jþ³ ´&+55ÿÿ¦ÿì=Ã&’j ´&&+55ÿÿwÿì9s&RT³"&+5ÿÿ¦ÿì=s&’T³&+5ÿÿwÿìhs&–T¢³3&+5ÿÿÏî&(jR ´&+55 ÿìì¶D@% JYKYKY?+?+3?9/+933310"'5326554&#!#!5!!!2 ^0:Tmv‹žþggþ°»ýü¶¾·¬d… ’züðV``þ°· ·ÅÿÿÏðs&avZR³&+5ÿì¸ËB@$ JY LY JY?+?+9/_^]+93310 !!!27# 4$32&?ÿþÇüô,¸š‘ÙþÌþž©=ÒÖ©) oþÎþð^þÉþ²/Z3ŽeßT¹P\PÿÿoÿìöË6ÿÿZ¶,ÿÿ:6&,jþêR ´&+55ÿÿÿHþ5¶-ÿéá¶#O@*%$#LYLYKY JY ?+?+?+9/+39333310#!! #"'5326!3232654&##áüåþÅþnGRMvb>7=0DND\>NÃúùýJ¾ÊÀ¼Ü°¨ÍÛVþýÿþþo\f 3Êý{¼ýå¡­¡ŽÏ#¶V@/    JYÀÐ   LY?+??39/_^]]3+39333331032#!!#3!332654&##mÂùûüåþÄý/ffÑg¾ÉÀ¼Û°1¼ÍÌÜÓý-¶ý{…ú¤Ÿ¯¡Ž ì¶;@   JY KY?+3?39/+933310!2#4&#!#!5!!Á½¬ix–þLgþ°Õýâoª½ýø‘qüðV``ÿÿÏ“s&´v R³&+5ÿÿ ÿì´D&½6!R³&+5Ïþç¶ 0@  "KY?3+??3933310!!#!3!3çþ%bþ%fLfþq¶úªVÿÿͼ$ÏR¶ K@*   LYÀ Ð     KY LY?+?+9/_^]]+9333102#!!!!2654&#!Züüùèþ^5ý1+žÀ×þé1¿ÎÊÚ¶`ýÛý)Ÿ«¥ŽÿÿÏ‘¶%ÿÿÏð¶aþü¶ E@$   " KY  KY?+33?+?393333310#!#3!3#!übû×ci”à n–þþR̃þqþÑ>úªöþÅý(ãÿÿÏî¶(=¶L@(      ?33?3393933333993210333###qý°LfLý®r‡ýœfý›‡éÍý<Äý<Äý:ýåýåýRÿìË%N@* !'&KY ##JY#JY?+?+9/_^]+9933910!"'532654&##532654&#"'6!2éþÑLþåþþò¥_Ø`ÈçáàÙáÔʹ•oºl:ÊÍí`þâBGþãÉáVh.2­œ˜œ` “}–?MPšÄÏö¶.@    ?3?29999333310333#47##Ïb`gc üf¶üDfðúJ¶¢¼úìÿÿÏöD&²6“R³&+5Ï“¶ 6@     ?3?393393333310!##33“‹ý-ff¿‡ý=éý¶ý<Äý<ÿ餶/@ KY JY ?+?+?93310!#! #"'5326!¤gýî)\?EbKC2=4Was9ÏVþ­ý þþ};\ØÌÊÿÿ϶0ÿÿÏò¶+ÿÿÿìœÍ2ÿÿÏç¶nÿÿÏ?¶3ÿÿÿì¸Ë&ÿÿ '¶7 ÿì´¶9@      KY?+?39393393310"'5326673373wIV`HgX?ýºy¿#¤rþ+-Rd†g%1m€LüªEJ=¨ûüc§xDÿÿoÿìªËsÿÿN¶;Ïþƒ¶ 2@  "KY?+3??3933310%3#!3!3çœbû®fLf`þ/q¶úªV¶¶8@   KY??39/+999933310!##"&53!2673fþûÈÌØgE`À¥f{gµº3ýÉþö#;ãÏ=¶ 1@  KY?+3?33933310!!3!3!3=ù’fžfžf¶úªVúªVÏþÙ¶;@    " KY?+33??33933331033!3!33#Ïfžfžfœb¶úªVúªVúªþ/q Ó¶ K@*   LYÀÐ KY LY?+?+9/_^]]+933310!!5!!2#%!2654&#!Zþ°·üüùèþÏ žÀ×þôV`ý{¿ÎÊÚZŸ«¥ŽÏ¶¶K@*  LYÀÐ    LY ?+??39/_^]]+9333310!#3!2#!3!2654&#!¶ffûûýøêþif!Ì·¾Ùþó¶ý{¿ÎÊÚ¶ú¤¦¤£ÏT¶ @@# LYÀÐ   LY?+?9/_^]]+9933310!2#!3!2654&#!5'üüøéþ\f-žÀ×þç1¿ÎËÙ¶ú¤Ÿ«¥ŽFÿìqËB@$  JY  LY JY ?+?+9/_^]+93310"'63 #"'53 !5!²P•X)¤ÌDq¦þÇÍÅ6üúþÏo#+\Nþ€þ³ïþœ¿3^3R3^,Ïÿì¸ÍO@+      JY    KYKY?+?+??9/_^]+93333310! !#3!! 32#"¸þ´þÚþÛþ´þbff L%KûŠ úú þ÷ùøþòÝþ¤þkTý1¶ýw8hþmþ£þÇþ¨U<;Rþ¬ã¶ R@.  LY?O  LY?+?39/_^]+393333310#&&5!!##"3!!þy{›™¨\fòÝÇĽ}ýƒ‘Ê™¤úJ}Ý™ª ¢ÿÿbÿì“RD{ÿì#%A@! ""'&" FYFY?+?39/+93933310%6$736632#"2654&#"{Œcxþ×_‡™ kÊkÈÔôÝà÷ß«µ¡œtÙQYªÄc#1V8'þØþÿmþþîýþå^þüäÖËÏ‘€³þò‚¶?Z@1  ! GY  GY  GY ?+?+9/_^]q+993333910#!!24!!! 4&#!!26øfsƒuÏÇþ5ͺ»JþÍþžp%ˆˆþšZ˜„9guyq©?†ýÈþNÓ_QþŒ^¶5?@HY?+?99310!#!5ýäcéü?)þ-? E@$    " FY  GY?+33?+?393333310#!#36!3#!-büÀbHˆ” ‘ôþ®îþqþÏ¿ø*ü…ýãþ˜ÿÿwÿìîTHL?L@(        ?33?339393333333331033###3wdÓyþ)üþdþúþ+yÓ?ýðýðýÑ'ýÙ'ýÙ+ýðDÿì7T&P@,%! %('%&&%HY&& && HY FY?+?+9/_^]+9933910 54&#"'632#"&'532654&##5ƒ'ˆ~PŠO%®¤²¸ÂynÝÄj¯9g–U”¥žž—jËaf%#RN”ƒ½4‹l—®)"c1#}tqlV¶? ,@   ?33?33993333103#7#…„_ý{?üîÍßûÁ Òü!?ÿÿ¶ò&Ò6³ &+5¶¢? 6@   ?3?3933933333103##3{þ …ýþee?ýòýÏ'ýÙ?ýðÿö¦?/@ FY FY?+?+?93310!#!#"'532!¦bþW‰m'#q‹$<ãþuþaÃZݶ°?>@  ?33?3939933333310%73##&&'#3°>9‰^1þÒXþÓ!Zƒ:%j¯&ûÁÇ?„üüü.f;ü5?üàa¶-? =@"  HY/?_o   ?3?39/]+99333310!3#!#²bbýNc?þ#ÝûÁ ýô?ÿÿwÿì9TR¶?%@ GY?+?3993310!#!#!cccýc?ûÁáÿÿ¶þLTSÿÿwÿì…TF)h?%@ HY?+3?9310!#!5!hþ–bþ?éüéVÿÿþ¬?\wþåK@(   !  FY FY?3+3?3+3??9333910#&54734&'66åþñõbôþìøböûúÙÇÍÓžÖÆÈÔ!ûþØþ(Ø(ÿû&Àþ@þÚûÕõ°óÓÑõüPúÿÿ7Å?[¶þ–? 2@    " GY?+3??3933310#!3!33–cüƒc‰b’þq?üáü¤î?8@   FY  ??39/+99993331032673##"&5†‹b²`ccdÁp§«?þ”ŠzFMÝûÁMB®¤x¶? 1@   GY?+3?33933310%!3!3!3šcú›cc^áûÁ?üá¶þ¬?;@   " GY ?+33??339333310%!33#!3!3šc‘búlcc^áüþ1q?üá)´? O@.   GYÀÐà  HY  GY?+?+9/_^]]+933310! #!!5!!2654&#Õ`ÖÇþ\þ¶¬R•†¥uþÓ›­éVýØþG|rja¶? O@.  GYÀÐà  GY?+??39/_^]]+9333310! #!3!2654&##3ZÖÈþbcK˜†¥´bbuþÓ›­?ýØþGvvlaýé?¶? D@'  GYÀÐà  GY?+?9/_^]]+9933310! #!3!2654&#ÖÈþ=cpŽ—†¥uþÓ›­?ýØþGxtlaDÿìwTD@&   HY    FYFY?+?+9/_^]+93310"&'53267!5!&&#"'6632f\ž(Äêý”hͳj 8¨Eô þå\5ùÓXÅË¡:;“0¹Ôqý‹Ú¸.–+ 2XÒ¾XÙó5\ÿÿTÿìXTVÿÿ¨)ÍLÿÿÿëçÃ&ójþ› ´&+55ÿÿÿžþ)ÍMÿö? V@0 "!GY  FYGY FY ?+?+?+9/_^]+9333310!2!!!#"'532!!2654&&#^͸þ\þ þÇWŒo% rŠ&ôš‘8u…mšþ¼ãþvþ^ÁZÎýÏþPswJU'¶h?T@-     GY    GY ?+??39/_^]3+3933399310!2#!!#3!!2654&&#Ç'ĶÑÈþ•ýµccKcŽ“8uz?þ.Ž›¡£ýò?þ.ÒýÏþPm{KW&ÿÿéÿÿ¶¢!&Ôv³&+5ÿÿþ¬ò&\6ˆ³&+5¶þ? 0@   "GY ?3+??3933310!!3!3!#7þccþc?üáûÁþÏðã'@ JY?+?Æ9933103!#cýEf¶-þuú¨¶¶5‰'@ HY?+?Æ993310!#!35ýäc`éü?Jÿÿ3ðs&:CüR³&+5ÿÿª!&ZCX³&+5ÿÿ3ðs&:v¦R³%&+5ÿÿª!&Zv ³%&+5ÿÿ3ð&:j?R ´,&+55ÿÿªÃ&Zj¢ ´,&+55ÿÿ9s&<Cÿ~R³ &+5ÿÿþ¬!&\Cÿ,³&+5R®R@ SY/+99105!R\RRR®R@ SY/+99105!R\RRÿÿR®RÿÿÿüþlNÿÓ'B‹Bÿv±¸ÿÀ³%&H¸ÿÀ³H++5Á ¶@  ?Í99310'673) c+AE Áp[eþÈXÁ ¶@  ?Æ99310#67 KcA@¶þ÷Ø`#rÿÿDþù3î'û83±¸ÿÀ³H¸ÿÀ³H¸ÿÀ³H¸ÿÀ³ H¸ÿÀ³ H+++++5Á ¶@  ?Í99310#&'7ž EA(c# ¶WþÈfT|ÁJ¶"@   ?3Í293310'673!'673f "b*BBþN c+AE Áx[bþÓfp[eþÈXÁJ¶"@   ?3Æ293310#67!#67 KcA@² $b(BB¶þ÷Ø`#r€þöWb-fÿÿDþùqî 'û85²¸ÿÀ³H¸ÿÀ³H¸ÿÀ³H¸ÿÀ³ H¸ÿÀ³ H+++++55{s B@'   TY@??9/]+993910%#53%sþ™uþ®RugûÍ3p¡þ_{si@C    TY   TY@   ??99//]+9_^]+993910%%#553%% gþ™uþ®Rþ®Rugþ™ÍpþspE%pþcpþÛç7  @ ?ï/]Í93104632#"&çQIIQRHHRìY[^VU`^ÿÿ¢ÿì°&'éÓqÿéªË  ,0:Fa@36;1A!'0-./  !'-/;AHG8D**0/0/4>$?333?3??9/39/33393333333310324&#"#"&5463232#"#"&54632#32#"#"&54632ÓZ`Ác^`ZÝ–…—Œ‹˜wZ`ÁÁ`ZÝ”ˆ–“‹‰˜þüüÕ`+-Z`ÁÁ`ZÝ”‡˜“Œ‰˜º»u¸¹¹¸âëñÜßêñüܹ¹rq·ºâëóÚáèð'úJ¶ü¹¹rq·ºâëñÜáèðÿÿ…¦¶ ÿÿ…¦N¶R}Ũ@ _/]Ä9310R5>þþ>þˉ+þ•þ–+‡H}º¨@ _/]Ä9310'7ºþË=þþ=5þw+jk+þyÿÿ¤ÿìð¶&ªþ´=¶@ ??333210#=üÕ^+¶úJ¶q-˜Ç.@      ?3Í]2?399333104&#"#33632=UUl\ZK Fø-ž]Qn|þžZeúþ`h¶V@0  OYNY?   NY ?+?9/_^]+9/3+393910!!##53!!!!ƒuþ‹fµµ÷ýoký•}RþÕ+R9^ýž^N1É&m@> $ &('OY$@ H@OY  MY  NY ?+9?+9/3+3Î+2+3939310!!!!56655#535#5354632&#"!œ›þeFN)ün{ÓÓÓÓÄ·¯›#Š‰›×RRt 0`T²‡TR×R®ÌÞDVB¢¬²Rªÿ쓶&j@8 " (' @ MYMY&MYMY?+?+?9/+9/+33Í933339910%27#"5#57733#!##3 32654&##':20Sã  '=êêFþ‘ýÕ-fÃûý¨:áÑÄÒVB Rý;+ÃÓVþ jVÐþ@ý®¶üôªº¬ JÿìXÍ*@P "  (,+ ! OY!@ H!@ OY ?¯Ïïÿ %%MY%MY?+?+9/_^]]q3+3Î+2+393333310"!!!!327#"#53&57#5332&#®ä)öþÁþE블‹Q‹Gäþé*´¬¬¸' ÚX’K'„uûïRhARÙóA^" R&KfR2"(VHÿøÝÁ -1H@& 1./0& +.032)1 010#?3?3??9/39/393333310#"&5463232654&#""&54632&#"327#ÝŽŒ›¡ŒŒ™þga_fe`ceýí ¬»Ÿd]ULyv}dUV°üÕ^+N ¶·Ÿ¢´·Ÿ|‚„z|‚‚J´ ŸºX‚|ƒz T%¢úJ¶sÿîmË&O@)$  ('$   $$  /3/39///]3999993993310%273#"&556746324&#"66Z«N›†h^j\}st‚ƽXÍQGID˜Hå’­¥¤+T&ú—™Œ¼þãVþÓ†|\ij`sþ1MâϦ¶&*p@>" (),+ '%LY LY ''(LY'?+?3?39/_^]+Ä_^]+99933333310!###33&53#"&5463232654&#"5!¸hüÝ bf#b‡œž‹Š™þda^ec`Å+ÙètüL¶úöèhºü¬¦ªª¦¤²´¢{}y|‚ü VV å¶L@'    ?3333Ä]2222339333333310##5!###33#7#9VÙ ÛXÝR}Ýà}VãåƒNNý}aÉþhÑý¢^ý/ŽÏý£ÿÿRáÍvfÿÝ‹H9@  ! /??3/299//]3933310"&546632!3267&&#"yñ…Šô•˜ó‡üÅ1¦Rƒ·QHbÙ“2£X­z#“«ÿŒŽþý¥þœ5Fi)›|‹5Buþéÿÿÿìw¶'@úý³'{Ê ´ ?555ÿÿ ÿìËË'@Ný³'…u÷ ´ ?555ÿÿ5ÿ캶&=ñ'y@=ý³ ´+?555ÿÿZÿ즶'@)ý³' ? ´ ?555wÿìÍ&L@' $('  FYFYFY?+?+9/+999333310"&54632654&#"563 '2&&#"Ï¥³‰â‘Í`’›=„1€€…šþÿ¢Ÿï,'Œ_v¹o€Ͷ¯6žâKEìå!c3ýÛþöþ3å\L{þö‹œ}¶ 5@  KY?+?999933331073!! Pû—05þ|yþy;{úƒ9#™ûÖÏþ¶%@ KY?+?3993310!#!¨üf?þTø¬´øLVþº¶ E@$   JY JY?+9?+99393331055!!!V˜ýxütýwÙþFÊ_E^üÃüE^oª#ü)@RY/?_¯¿ß /]+99105!o´ªRR%ÿò¨,@  //39/332933310##533bnþç¶ú^Xý{œ #/B@%! ' -10-** $$?/]223Ä]22399331026632#"&'#"&546"32654&!"3267&& [‘A?^¦§~^?B‘Z¦§ØPs77sPXhiýOWjjWJs=l~tš|¬:?^o*9}`qH9þ=;^n,:=@`qH9o²#øg@B  RYï    RY / o ¯ ¿ ß  /]+993Æ_^]]+9939910'!5!!5!!!!‹L{þÉ^™þ I}:þ šúÝþÕ%RFR1'þöRþºRÿÿo#Á&+ýW ³?55ÿÿo#Á&!+ýW ³?55w-à 5@    ?/99333333103# wÂ1Ãþ=1þ‰þ‰wßäýý!ßmý“ýšÿÿ&ILfÿÿ&IOfÙò @   €/2Ì2993310"&'332673N•œ Xjonk XÙ…”n[^kþçÿžþ? @  FY?+?93310"'53253%P7E<—cþV° úœÍb @   €?Í993106673#œ6 pM55Ý-½M<®O‹þ;Rÿƒ @  €/Í993106673#‹2 qQ)6þL6¶KR«=˜Ù^! @   €/Í99310#56673^5pS*5:Ê3M°=19Ë  @   !?3?399331032654&#"#"&5!2“[jh]]hj[ì‘”š)•¾·¶¿»¶¶½æãáèÉàJ‘¼ D@#    ??9/]3339993399310##5!533#547‘Zþc—`Ûþè;ññ<EýÍÝ„d /þvD9}¶-@  !?3?39/39333102#"&'532654&#"'!!6D‘¨®˜Aˆ*x}kwuqJX3Ûþ{8b{„› ^Bg`Ua'›Xþö+9‡Ï.@     !?3?9/39933310#"&54736322654&#"‡§€Ž§úþ#ÂÐ#YŠw•þÙXmd[\{tjƒ®¹ŸÓOP9±‡q—þ§z_[feKm}=J}¶ @ ?3?93310!5!¤lþ-@þ•JXCü×39}Ë#/6@-'!*10*! $ !?3?2993333102#"&5467&&54632654&''"6654&Xy‘¬dcŸˆˆ›YWVA•KiY]bUl]OÀKYI]VPZË|fˆF&xLo‰qKz)/[Beý`GUSI;X) #`MA6N!Q8?M%9É$2@ ""&% !?3?39/39933310#"'53267##"&54632%"32654&ÏÓL56M”§ %zC‚”¢ƒ[MþÃ[h]a_wTþæþÿZµ¸4=–‡ Yª¯o^[ldFf„TþÁî #'+/37;?CGS[kt|‰Þ@[p`zglvvkXHTN $%()DE01<=@A   #-.478;HN`gk„‹Š‚}ZQVKuOlll\vkt…\}KkQ\pkk¸ÿÀ@5 HkO\\ %&)*12=>ABEF\k,-  !4589 //39399/]/+]ÄÄÄ3339/q33339393933333310!#%5!#533!5353!5!!5!5!#3#35!#35!35!#35#3#3#"&546323254#"%32##32654&##32654#"'53253T/ÀÎ0mùoÀÃmýIûáþò·mmmmûÂü0ooÀwú¨ooooþmmûŸ‡‡‡~ˆþs‡‡‡‡á¬mp.,;0m^Ï{B.$*/;J1%Z^4+V}i¾0oÁÁoþÐÁù/ÂmmÂþÑmmmmþooú¨ú;mm¦Jooooü/yýhI‘œœ‘’›š“ÅÅÄaCS1D D8QYb" "ãš+%Jþú fV’þr_cTþÁª*8@ % ,+(""//9///339333310 54676654&#"63232654&#"þ¬üTüVë,AgI»¥OºGR Z?>1HT;GFBIHCHEüVüW©û/2A1R~X‡š8*²P:/5K6DpJ;þí?HI>@IHÿÿÿžþ !&7Lþ›³&+5ÿÿÁ ¶ ÿìš+,5f@6-*3$  $+76-0+!',,+FY,,'IY''0FY'FY?+?+9/+9/+99933333310#"&547654&#"'632! 4'$$546323'&#"þüò³º-#'7>IPX‘þ´þš«’»ô(Žø ¿ˆlw/^A'þ‰þm¯¯>xw%71K_]4jkOþ®84Òäþ½þÐZZüne§PÃ6@ JY?+??9339393107632&#"#32ŒŒfC*IwTiþu–q@b ZWíþÈÉýá-‰ÿìò?,V@-''&  &.-&&HY+""FY?3+3?+3399/933333910"&'##"&547!57!!4'!32655332#j‰(%„r«±SbþÒ¨6þõQG±IASý¬}ƒmrbykübnkeåߎ¨:Vþü¦ÝçÄ›„þÛþì¹±˜„Ý݆–ÿÿÏu&0vT³&+5ÿÿ¶f!&Pv¼³,&+5ÿÿýÙͼ&$[ÿÿbýÙ“R&D[´ÿÿþýÿìàÍ&2D\þO ³?55{ýÙ-ÿ @   /3Ä2993310#"&5463232654&#"-xaaxxaaxþžK>>KN;>Kþ®atta^uv]BKKB@KL®h¦¾&@   À/ÌÆÄ93310673#%467#"&¸W$sj14þögf$( .6³„C°BxTf7&D%Fÿÿö&I'IfLÍÿÿæ&I'IfOÍÿì D@" "!  @ KY KY?+?+Î9993339910! ! 6653! ! œþ¤þÎþÏþ¤_0JªQOh skkûTþéþúþûþåÝþ¤þk•^]‘掊“ª#¶þñþÆþ©T=<Qþ¬wÿì¸ç!D@! #"  @ FY FY?+?+Î999933239910#"&532667332654&#"9þþãÚtáÛHGd f`Rü¦Å´´ÅÇ´´Ã!þöþÕŠ© )“ˆ†¢&‰Óàûûàáø÷¾ÿì#@@  @ LY  LY ?+?39/+Î9933323106653!"533265YSi “‚þÜþûþþãgêÖÑæ¶ÏŒŽ§¯ýqüþäÿ®üNÓëçͼªÿì#òM@& ! @ IY FY?+??39/+Î9993332331032653>53#'##"&5 ‘˜½®bBM!e @waT4·vÉÂ?ý@¤•ÆÛXz Brn{†\ü–RXÄÉÆÿÿüŒÙþ !Cûÿÿý<Ùþ»!vû³ÿÿüQÛÿ ÉRû6ý¸þd ² /Ì210#'6654&#"5632þd¨ P YQCN0-47lyáŒ$y²8,00N [ýjþ¼ýìÿ} ±/Í10432#"ýj@##@ã`2.-4ÿÿÏîs&(Cÿ±R³ &+5ÿÿÏös&²CLR³&+5ÿÿwÿìî!&HC¥³&+5ÿÿ¶!&ÒCȳ &+5ÿìBÍ5T@+ 3%%+76("(/(/KY("KY"?3+3?3+39/9339333910%273324&#"'6632#"&'##"32&&#"¢¥gfn³ÄÚSšg?_/+DsGÔéþò÷oNL›oúþòøÙItA+H\/k¡VåLPúþRiAÁ–"^$þƒþ¨þ‘þc+55+›qT#^$”þãÃþ¼þš¸?G@%   ?3?339393333333310#33663363#ò%¯gþyhÑ'a"Q“¦fÑ”²°^Æ×eAR&þ«?ý¿jþÒM¥Ìý¿þZ²éLþ‘þ Ùò[@2  LYLY@ LY?+?9/_^]q+9/3+3939310!3!!!2#!!!2654&#!Pfáþüÿìþiþ°¶!ÍÀÄÞþô×=þÃTþ®ÃÊÇ݃ûÕ¨¤ž“b'`@7  GYÀÐà    IY GY ?+?3+39/_^]]+Æ939310!!! #!#5353!2654&#dŽþrÖÇþ=ããbqŽ—Š§?Qþ‡þÓ›­îQèüðþGxtlaÏÿì ËX@0 ! JY LY JY?+?+??9/_^]3+393333310 !!!27# !#3!!2&‘ÿþÇüó+¸š‘ÚþÐþŸþbff u*Ö©) oþÎþð^þËþ°/Z3†]ý1¶ýw4jP\P¶ÿì‡T"Z@2  $# HY     FY FY?+?+??9/_^]3+393333310"!#3!632&&#"!!327híÿþ ccd Ù=¡46Š5²ÏHý´й”}-“ýð?þ'èXÔÀXÕó5\¼ O@-    JY_    ?33?9/]+3993333310####3#!&&'wÃb¿þÜos1bsý'–RX"²ýN²ýN¼úDÆÔb4X ô? C@$    IY   ?3?339/+393333310#####!'#1ÃeÑbŽÎgÅo>t(/?ûÁôþ ôþ ?þzQ„Ïã¼c@5     JY   ?3?Æ9/3+3399333339992210####!#3!3#!&'H·b²þÏo3þ%ff1brý3}y" !Ïý1Ïý1Ïý1¶ýwúD-%Ue3W¶h?e@=      HYP` À ?3?3?9/]3+339333333310#####!#3!!'#¦Âd݃bÞfÝþ½ccfÅa#r/?ûÁýìýìýð?þ'Ùþ'`Pƒs¶!m@; !!#"! LY 0  JY?+99?339/_^]3+3993339333310#&&####"#>75!ìþIyŸh\bi“-’#g"m|R “h‹/h¡xþJÏü°¨¶VýßFŠþÖþ¾ã”pýç/mhþÉžH!V^ýò Ï? m@< "! HY  PHY?+99?339/_^]33+393339333310#&&####"#>75!;þª]}Y6i…,}u%c"w}+‡i0Z`þ¨)ýM[?Sþ‹8k…þ¸XsTýáTqþ¦H|r;uSVþ„Ïq¶$'~@E%&#"''!#)( !JY'!!!!$#&$$&JY$?+9?39/_^]33+3393333393333910#&&####"#667!#3!5!éþJ~¡g,Œi“,¡#g"u{N“h‹B5þff%þBÎü±¬¶VýÑDŒ”þ7ãfý'Ù-i`þÉ^†,ý'¶ý)V^ýå¶Z?#&r@=$%"!&& "('  HY& #"%##%HY#?+9?39/33+33933333933339102#&&####"#667!#3!5!Çþd…Y3h…*t{+b+|t)‡f6*þŠccvþ˜)ýNZ?Sþ|5i‚þ¸XmKýðKkþ¦H>e%ýð?þ'†SVþ„RþhËIŽ@RG6<',$ '3870 f' c`kjjil`Vÿÿ{¶uÿÿ¦þ?•ÿìœÍ M@+JY?_o  KY  KY?+?+9/_^]+99333310! !  !"!œþ¤þÎþÏþ¤_02ZýrûÃúþê9 þéÝþ¤þk•^]‘þmü@.þÕþ½þÍþâ 1wÿì9T M@+HY?O  FY  FY?+?+9/_^]+99333310#"&532267!"!&&9þþãÚtáàÿþ®ÅýÆ­¥ÂîÅ!þöþÕŠ© )þÓýí×Óñ´×ÁÄÔ Ã.@  LY?+??999333210"#367>32&º1>;3þž^ýãmfU$,Q°@P_J0**h4{”ûÛ¶ü8êy¤îÀ’@ZþT,@ HY ?2?+?99333210!3367>32&#"¤þ\fI%N}$EL;-D'þð?ý#»S‚ëtm|6XavüÛÿÿ s&€v¨R ´"&+55ÿÿþ!&v5 ´"&+55þ Í 0S@,0 ! !)210+ KY KY &+LY&?+?+?+?399933339310! ! 32#"%33663#"'5326677 þÈþñþìþÐ8.ûäïæèñðåèñƒf©® W gþ5RlN9F:C3M>)7Ýþ¢þmŒg\’þpþ þÃþ¬OB@Mþ²#þ>þ5P#óÇûŽv8V/ak–ÿÿwþ-T&R\ÿ¨Ù (P@+ !!& &*)JY$!& &KY ?+3333?33+339333910#"'$%6326326'#"'ÙþÊþêKIþèþÊ9IK6ûöçOOêóôç 6#OäùÝþÁþrJJA>EEþtþÀþãþ­PNOL*&Pþµwÿ¬bš'P@+!%  )(FY#!% %FY ?+3333?33+339333910#"'&5476326326654&'#"'bÙÂJD¾ÝØÁLMÃÖü} ‘GJ”Ÿ •FC•ž!îþÞHF(êí#LLþÚêÄòHHôÁÁòBBñÿìB-2CY|@G 93OP0##P)7>3Y [ZYDDAOO O OO6KT7666& -&-KY & KY ?3+3?399+3Æ_^]2Ä29/^]33/39333310%26732#"'6632#"&'##"32&&#"5654.54632%#"''&&#"#546323¢^—JT¡_Äضœ?_/+DsGÔéþò÷oNL›oúþòøÙItA+H\/¤¼ã‡fg$( .6 pCTC%8?Zif2`‚usL<=?:fD&N"^$þƒþ¨þ‘þc+55+›qT#^$þ´þØþºþœ•Sg8&D$FD1 :Khs4/wÿìªø+=R†@N3,HI' !',08IR TSR>>;HHM0///ð/ /DMM@ HM   HY# FY*?3+3?3+399Ä+_^]2Æ^]q29/33/39333310%#"4632&#"32732654&#"'632#"56654.54632%#"'&&#"#546323 byÖäW¥n{R!RK…Œ´¦mjnn¦°‚zNRR{h›SæÔ€gf9F$( .6 q~–E#8?Zif2`‚us%9´‡-V+÷êìéCCéìéø+V-†þþ³þôþßÀTf77#%FD19:K hs4/ÿìB Cq@>&A3- &39 ED-606 @ H  6@=6=KY#60KY)0?3+3?3+3Þ22Í+239/9339393310#'##'##'5273324&#"'6632#"&'##"32&&#"{P 6Ê8 7Ë5 PZ¥gfn³ÄÚSšg?_/+DsGÔéþò÷oNL›oúþòøÙItA+H\/k¡Vå¬uuuu¬ùHPúþRiAÁ–"^$þƒþ¨þ‘þc+55+›qT#^$”þãÃþ¼þš¸¤ )l@;  ))( $%  %+*) @ H  $ )?3?33Þ22Í+239993333333999910#'##'##'5#33663363#œP 5Ë7 7Ë5 PŠ%¯gþyhÑ'a"Q“¦fÑ”²°^Æ×e¤¬uuuu¬üjAR&þ«?ý¿jþÒM¥Ìý¿þZ²éLþ‘þ Ùþ¸Ë/@  LY KY ?+?+?93310 !27## 4$32&?þíþÄ:E:g!þ®þ–©=ÒÖ©) oþ þÎþÄþ« ý¾Ø†mßT¹P\Pwþ…T+@  FY GY?+?+?9310%27##"32&#"{LGd+ùþñîhÈÎÕHý¸Õ-1X/÷èßôsdD@*       /Í99339910'%7%7%ôÅRÅþÑ)/íþÍ+1ÃPÅ5-þÏé1'\þª-V²J´—µI´N-þ°²J´þi´JÛš˜  @   /333993310463!6632#!#"&Û11¹%'((,7þH&&((ð1#3)%1.$3+$åÏÉ$@  @ H /Ì+23/3993102676632#54&#"##=zp9f6dkZ?8&I~q L-qj K:71åß²5@  À/Ì93104632&&å6/ '$fg¶9F$D&8gì߸5@  À/Ì93105654.54632¸ff~$( .6¶Sg8&D$F)þÁÁ‘ (6DR_mä@8 7D=>S_YZ(!" )6/0`mfgERKL "(06>DLRZ_gmon)"0¸ÿÀ@ H03,,%3mZSf¸ÿÀ@ HfjVcc\jE>7L¸ÿÀ@ HLO:HHAO3jOOj3 @ H ¸ÿÀµ H /3Í+2/3Í+29///333Í+2333Ì+2333Í+29333333333333333310&&#"#632&&#"#6632&&#"#6632!&&#"#6632&&#"#6632!&&#"#6632&&#"#632!&&#"#6632oL3=AK Å]qOL3=AKdg\sôL3>ALeg\sû/L3>ALeg\s1L3>ALeg\sû/L3>ALeg\sðK3>AK Æ\sù¾E;>ALeg\sÏ930<Âe]ùò930    IY GYà?¯   GY ?+?9/_^]q]+9/_^]3+3939310!!! #!#533!2654&#`þ ÖÈþ=››cpŽ—Š§ Rý»þÓ›­ºRüþGxtlaÏ?¶]@2      LY  LY ?+?9/+9999999333910'###! 327'76654&##?pkyEˆe”âff üöÍXuFƒRPÐÚò€½7¨5¼!ý¤¶üþ¤3¹'Žr©£¶þLT'f@7% )(!  !FYHY?+?+??9999999993333910"'##33632''27'76!"‡ûscTpöÜç¬yF{ZyXFE{þ¦¾²«¼TJXþb+›°þßþìþÁ’¨5¬1X"·3¶{ßÑì ÿÚ/ð¶ D@%  JY?   JY ?+?9/_^]3+3939910!!##53!!5·þIf  !ýE^ýZ¦^²^5? H@)   HY  O _   HY ?+?9/_^]3+3939910!!!##53!5ýänþ’c¤¤éþgVþúVïÏþœ¶G@'  LY JY JY ?+?+?9/_^]+933310!632#"'532!"#ý1slË%˜þõ÷rƒÁÒþÛþøl_f¶^ý´žþÚÅþÀþ¦1e8.$ýP¶¶þ Õ??@" FYHY FY ?+?+?9/+933310!632#"'532654&#"#!FýÓ]eøηŠWpu†“ÐÌbVcéþyþÖþæþ÷þÚ:dDøßñ÷#þ?þL¶\@2     " JY?+??3?339393333333333103333####qý°LfLý®#^c3ýœfý›‡éÍý<Äý<Äý:ýnþ1qåýåýþd?\@2       " GY ?+??3?33939333333333310333####3wdÓyþ)¦nb5þdþúþ+yÓ?ýðýðþ/þ1q'ýÙ'ýÙ+ýðÿÿRþBË&±TÿÿDþB7T&ÑðÏþ߶E@&      "JY?+???3993333310%3###373`bTýÏÃff¢=‚ý©^þ1q¬ý¨¶ý¢Vý–¶þ¾?F@$      "GY?+???393393333331033###3{þ²tb?ýþee?ýòþ-þ1q'ýÙ?ýðϦ¶C@$     ?3?3993333333310!###3733¦}þV¢ff¢Vç‚ý©¼þ{°ý¨¶ý¢cþõþý–¶¢?E@&       ?3?399333333331033##'#3œV{þs°…þÕVeeº<ß(þTÂþ/BØ4‰ýÙ?ýð1¦¶O@,   JY ?3?39/3+3993933103533#73###1žfúú¢=‚ý©g}ýÏÃfžú¼¼^þ"¢Vý–ü´¬ý¨œßP@-     HY  ?3??9/3+399393310353!!33###›cþ+xþTÑwþc²c›LÈÈVþþÕbþ0ý‘%¢þ}ö '¶>@"     KY?+?3?99333310!##!5!73'}ýÏÃfþº¬¢>ýª¬ý¨V`ý¢Vý–)T? A@!      HY ?+?3?933933333103##!5!¶{þ …ýþeþÁ¤?ýòýÏ'ýÙéVýðÏþh¶L@)     JY     "JY?+???39/_^]+93333310%3##!#3!3òvb{üªffVg^þ1qÏý1¶ýw‰¶þ¤?R@/    HY?O  " GY ?+???39/_^]+93333310!33##!#²bwbwýNc?þ#Ýüþ1q ýô?Ï7¶ G@&   JY     KY ?+?3?9/_^]+9333310!#!#3!!7þ»güªffV¬VúªÏý1¶ýw‰¶m? M@,   HY?O    HY?+?3?9/_^]+9333310!!!#!#²¢þÀbýNc?þ#ÝVü ýô?Ïþò¶K@)  LY   KYJY?+?+?39/_^]+9333310!#!#!632#"'532#" güüfÑqn•þðö‘r†}À×þêút_Vúª¶ýVŸþÚÄþ¿þ§1e8-&¶þ …?C@$ FYGY FY?+?+?39/+9333310632#"'53265!"#!#!Ý]QúÀ³ŠWrk„‹þd[Ibýžc'bþÜþàþõþÜ:dD÷àèýøáü?ÿ¬¾Í+5m@;3 &,1&&763#.  ) JY @).KY)) ))KY KY?+?+9/_^]+Ì+999993339910327#"&'#"$5!2&# !267&5432#"6œ†YkJ7*aa‘;d˜ÄþלF)‚OKoþ&_it½£­¸kús…à„Ž¦¹þ¹XD\=+(¹SÝi`ýiþÉþ° b0´õþ÷ù ÛÇþ¢ÁHwÿË–T 6m@ &,&&,487$ "/ )) FY)¸ÿÀ@ H)) 2HY @FY"FY?+?+Ì+9/++9999933399106654&#""'#"&&532&#"327&54632327®OKN`IUª}~rV‘ÚvêÔR@E<¢°_µ€N1¬‚€†jaX(>-,ðz¬A3¼~‹ü»L+þ  3[ùê‹Ôršü²ÆÀ´„ÛEXÿÿþB¸Ë&&#ÿÿwþB…T&Fu þ'¶ 4@  " KYJY?+?+3?93310%3##!5!!Lwc{þ%þ%^þ1qV``)þh? 4@  " HY GY?+?+3?93310!3##!5!hþ–wcvþ?éüuþ1qéVÿÿ9¶<þ¬? /@   ??3?339393310#33673bþ\f8)+fþì?ýŽjˆrá9¶J@(    JY  ??39/3+3993339103!!#!5!53¬nþ;þÅiþÃ=þu– üC_þm“_;‰þ¬?@@"   HY?33+3??39393310!!!#!5!336733þËbþË5þ\f8)+fVþj–V?ýŽjˆráþu¶F@'      "JY?+???3993333310%3###33ec9þPþHqìþAs‹‘mþ;^þ1qªýVú¼ýŽrýF7þî?F@'     " GY?+???3993333310#333##üþ¨mŠþ…rDAmþ‹Lmc9åþ/þ6Êýðþ/þ1q þ{¶@@"  " KY  KY?+3?+3??933310%3#!!5!!!3ßœbû®þC1ýòLf`þ/qV``û V)þR?@@"    "  HY GY ?+3?+3??933310!!33#!!5!^þw‰c‘büƒþ¶5éüuáüþ1qéV¶þ¶H@%   KY "JY?+??39/+999333310%3###"&53!2673wb{þûÈÌØgE`À¥f^þ1q{gµº3ýÉþö#;ã¤þd?H@%   FY " GY?+??39/+999333310326733###"&5†‹b²`cvbwdÁp§«?þ”ŠzFMÝüþ1qMB®¤x¶¶m@?  `p€ °À  KY ??39/+999/9/_^]]933339910!###"&53!336673f®²VÌØgEVI•‚f{Hþº?µº3ýÉþörþ’$/ã¤î?a@5   `p  FY ??39/+9/_^]999/933339910333673##5#"&5†‹VŽŽccŒV#§«?þ”Šz7þÏtÝûÁlüò®¤xϦ¶-@  KY ?3?9/+99333103$32#4&#"#Ïf»Í×g¦ŸFymf3f¶ý…o¼»ýÍ7Š‰%ý¶?-@   FY  ?3?9/+9933310!4&#"#36632ž†‹]µbccdÁp§«mŠzDPþ#?ýüMC®¤þ‡=ÿìåÍ&`@6$#('##JY#?#_#o## ## KY KY?+?+9/_^]3+3Ä9333331047336$3 !!267# &&"!=dNR £µ ûË+^¯r³àþºþ§†íþðÇàB-29B?Ñ?­þŽþ—BþÅþ×%`Cf^qJþÆþÛ*55ÿì T%Z@0#"  '&""HY "" ""HYFY?+?+9/_^]3+3Ä93333310"&&5473632!3267"!4&ëþ÷~vd‘úÅÀÞüñÍ¿]l\œ{ ¼Ÿ¤ vaA-28áþôæPàì+Z(Õ½½Õ=þåÍ!(l@=&%*)%%JY%?%_%o%% %% " "KY KY?+3?+?9/_^]3+3Ä93333331047336$3 !!267##$&&"!=dNR £µ ûË+^¯r³àcýцíþðÇàB-29B?Ñ?­þŽþ—BþÅþ×%`Cþ£a4ŒqJþÆþÛ*55þ T!(f@7%&! *) %%HY%% %%!""HY!!FY!?+3?+?9/_^]3+3Ä933333310#&'&&5473632!3267#"!4&c½Ò~vd‘úÅÀÞüñÍ¿]l\œ` ¼Ÿ¤þeévaA-28áþôæPàì+Z(Õ½½ÕÿÿZ¶,ÿÿ=P&°6Ñ^³&+5ÿÿLò&Ð6Z³&+5ÏþͶK@'   KY JY?+??39/+33393333310!#3363 #"'532!"5ffÕýJ6.BRþðÿ‡r†sÊÖþÛþæ[¶ý)×ýL þÁþËþ½þ©1e8* )¶þ ü?H@%  HYFY?+??39/+3393333310!#33 #"'532654&#"cc{þ "b¶z~[/gFŽ˜ëã\P?ýðþþëþð±ûƒ:d(ñæáêþ=¶A@$JY"KY JY ?+?+??+9333310%3##! #"'5326!¤™“uƒ{ýî)\?EbKC2=4Was9Ï^þ1qVþ­ý þþ};\ØÌÊþ??A@$ GY"FY FY ?+?+??+9333310%3##!#"'532!¦™“uƒvþW‰m'#q‹$<^þ1qãþuþaÃZÝÏþò¶E@% JY  JY?+??39/_^]+9333310%!"&'532!#3!3òöþüLvH†zÐÍüªffVg“þµþ¸^3">ý/¶ýy‡¶þ-?G@' HY  FY?+??39/_^]+9333310!3#"'53265!#²b¢´~Wal„xýNc?þ%Ûûäþòþÿ6b=ÙÛëýò?Ïþ‹¶Q@,     JY     "JY?+???39/_^]+933333310%3##!#3!3ò™“uƒ{üªffVg^þ1qÏý1¶ýw‰¶þÇ?W@2    HY?O  " GY ?+???39/_^]+933333310!33##!#²bš”u„wýNc?þ!ßüþ1q ýö?¶þ¶H@%   KY "JY?+??39/+999333310!##3#"&53!2673{bwþûÈÌØgE`À¥fþÏgµº3ýÉþö#;ã¤þî?H@%  FY  " GY ?+??39/+99933331032673##3#"&5†‹b²`cwcwdÁp§«?þ”ŠzFMÝûÁþϦMB®¤xÏþ²¶O@*     " JY?+??3?3993333333310!##3333##47#Rýßbžš™“uƒ{ ýÝF|‚û¸¶úúú¨þ1qTt|ú¼¶þJ?S@+    " GY ?+??3?393993333333310%733###&&'#3°>9‰š”tƒs1þÒXþÓ!Zƒ:%j¯&üþ1qÇ?„üüü.f;ü5?üàaÿÿZ¶,ÿÿÍD&$6R³&+5ÿÿbÿì“ò&D6Ô³%&+5ÿÿÍ&$jR ´&+55ÿÿbÿì“Ã&DjÊ ´5&+55ÿÿÿþø¶ˆÿÿbÿìLT¨ÿÿÏîD&(6R³ &+5ÿÿwÿìîò&H6õ³&+5ÿì!Í=@   JY KY KY ?+?+9/+933310"5663 # 5!2!½ã€¹gIY–þäÁþíþä5"þ ãü:çjId+þyþ“àþ¬¹sl=búâAþÙþÉwÿìîT=@     HY FYHY?+?+9/+9333102#"55!&&#"566267!øí vØŒ¿ÞËÀY“jZ—¾ý`£TþÜþù¬þùŠ æPßî*Z'ûðÐÁº×ÿÿÿì!&áj˜R ´+&+55ÿÿwÿìîÃ&âjæ ´-&+55ÿÿ=&°jÑR ´"&+55ÿÿLÃ&ÐjZ ´"&+55ÿÿRÿì&±jÿæR ´6&+55ÿÿDÿì7Ã&Ñjÿr ´7&+55Rÿì¶J@'KYKY KY?+?+99/+9933310 !"'532654&##5!5!º6þäþ÷øŸÆØÎâôå˜5ýr/ÖÃÏÛSm`ª›—¡V7``þj?V@0 FY? HY FY?+?+99/_^]+9933310#"'532654&##5!5!?#|áŽÑZ¨ZµÒÝè|ûý{ ´Ú×”áwDf+$ع¬®P=XIÿÿÏö‡&²M¨R³&+5ÿÿ¶5&ÒM-³&+5ÿÿÏö&²j“R ´ &+55ÿÿ¶Ã&Òj ´&+55ÿÿÿìœ&2jÁR ´(&+55ÿÿwÿì9Ã&Rj ´)&+55ÿÿÿìœÍ~ÿÿwÿì9Tÿÿÿìœ&~jÁR ´*&+55ÿÿwÿì9Ã&j ´+&+55ÿÿFÿìq&ÇjÿùR ´+&+55ÿÿDÿìwÃ&çj† ´+&+55ÿÿ ÿì´‡&½M-R³&+5ÿÿþ¬5&\M³&+5ÿÿ ÿì´&½jR ´(&+55ÿÿþ¬Ã&\j† ´)&+55ÿÿ ÿì´s&½SmR ´)&+55ÿÿþ¬!&\SÒ ´*&+55ÿÿ¶&ÁjTR ´"&+55ÿÿ¤îÃ&ájû ´$&+55Ïþð¶ /@   "JY JY ?+?+?93310!!3##Ï!ýEccf¶^ûþ1q¶þ5? /@   "HY GY ?+?+?93310!!3##¶ýäbbc?Vüuþ1qÿÿ϶&ÅjðR ´(&+55ÿÿ¶Ã&åj– ´'&+55/þð¶]@4 JY? JYJY JY "?+?+?+9/_^]3+39399310!!3#"'53255##53!!5·þIw\Z9*-'c{  !ýE^ý¸ôhs\|–¦^²^þ5?_@7HYO_HYGY GY "?+?+?+9/_^]3+3933310!!!3#"'53255##53!5ýänþ’v\Z;'-'bw¤¤éþgVþdôhs\|–úVïþ‰¶N@, JY JY"?+?+??3993333310%3#"'53255##33w\Z;'-'bNþPþHqìþAs‹‘mþ;^ôhs\|–ªýVú¼ýŽrýF7þî?N@,GY GY "?+?+??3993333310333#"'53255##Áþ…rDAmþ‹Lm\[;'-'b9þªþ¨m/þ6Êýðþ/ôhs\|–åþN¶I@)    LY ?3?39/33+339333310!33!!##!“+þos‹‘mþf/þµÛuþPþHqÝþ¶?wýŽrý‰ZýªýVå7Å?O@.   IY/?_o ?3?39/]33+339333310!33!!##!{#þ¨rDAmþ®)þËysþªþ¨msþÑ`ßþ6Êþ!Rýòåþoô¶ :@  LY   LY?+?9/_^]+99333103!"&5463!!"3!gþ\éøüû'þèÙ¿·Ì-¶úJÙËοZ¤¤¦ÿÿwÿì Gqÿì!¶"X@- ""$##LY # LY?2+3?9/_^]+9/993339310"&54$!33!2653#"'# 3265#Ïã!¾ftwg³¥ì^yRÅþL«¡ŽŸÒÃÒÞ…ûÅþÑ–“Ûþ¸Ë¶¶éþ²œ¥ž†wÿì?+Q@)(#-, FY %%HY?3+3?+?9939/9339931023&5332653#"'##""!26554&Dp 7czˆm€b°¨ùBmóáîìá²³g¦ŸšT^`~y‡ûŠ±©“žGþ³½Æßß *Zúîþ2ÞîòçRÿì/Ë+]@2!") "-,!!&KY? , JY&KY&?+?+9/_^]+99/9393310#532654&#"'663232653#"&'&&²ÂÂÇͪˆg²p9pÔ~ÂÜœ‘«– v†ywf°¦¿± ÊÇ`Ÿ”~•=OPRHħ´%¯£¯ˆ’•Ýþ¼ÇÃÒ¬šPÿì`T+S@+") "-, %HY, HY%HY%?+?+9/+99/9393310#532654&#"'6632323#"&&'&&…p”‚x{%P›X¥¸c`qi 7Z]ìbª¤t‹M„Vhc]jHR#+”‡[{vrbp01Gþ³½ÆB‹o_Rþ`Ë"Y@1  $#KY?  " JY  JY ?+?+?9/_^]+993339103##4&##532654&#"'6!2Ûš•«’wb{áäÎáÔʹ•p»k9ÊÍí`³ #¦›þÈþ1q“›™` “}–@LPšÆVþ¢T O@*   "! HY  " HY GY?+?+?9/+99333910 54&#"'6323##4&##5ƒ'ˆ~PŠO%®¤²¸Âzawcvœž“jËaf%#RN”ƒ½4€nÛþ1q?mhVÿé´¶"C@#" "$#KY JYKY?+?+?+9/933310!#"'53266!323#"&5îþE$NRucB7=23D0FS.wz†úf»¥º¬VþþØþþÒv\?qHWûɧŒ)Ûþ¸ËÆËÿìÙ?C@#  FY HY FY?+?+?+9/933310!2653# !#"'532!‡ob­¥þžþžWo!s‹&qþÓšOþ³¼Ç‘fþpþb¿ZÒÏÿì)¶I@'JY  JY ?+??399//_^]+9333310323#"&5!#3!3Éy‡úf·©¸¯üÓff-gu™’ æþ¸ËÉÈRý1¶ýw‰¶ÿì`?O@-  HY?O   HY?+??399//_^]+9333310!332653#"&55!#“bþv|b¯¥°°ýmc?þ#Ýý6þÏ—’Oþ³½ÆÆËýô?ÿìhË:@KY LY LY?+?+9/+93310!! 4$32&&# !2!bþÜþÙþÇþµRÞfáU'PÉ`þÞþ°( óèþfÝXþ±þ¶aåTµ*$^#-þ¤þÊþÉþ¢"wÿìT:@HY FY FY?+?+9/+93310!# 4$32&#"3 !¤ÝôïþüþÝ ºÏ£ –ºêþüèÙþ…#Döý'­‰DXB÷ääõ‡ ÿ쬶9@   KYJY?+?+39/933105!!323#"&5 !þ!}ðf´¢»¶V``ü)¡”+Ûþ»ÈÅÌÙ)ÿìF?9@   HY HY ?+?+39/93310!!23# !5!^þ–ïc­¥þþ˜5éý–þÅ1Gþ³¼Ç‘lVsÿì5Ë&N@*#   ('$KY  JYJY?+?+9/_^]+99339104663 &#"33#"327! $54675&&žrÒ„¾3µçšÂýܦÄéùÜÐî°—þùþúþêÉ´¦¬Tl­^oZkš…˜`©Ÿ—žVeOÑÄ’Ç ®ÿÿ^ÿìTT‚þ¶ D@&  "! JY KY JYJY"?+?+?+?+933310! #"'5326!3#"'53255#=ýî)\?EbKC2=4Was9Ïw\[8*-'b{Vþ­ý þþ};\ØÌÊú¨ôhs\|–þ?C@%  GY FY  FYGY"?+/+?+?+933310!#"'532!3#"'53255#DþW‰m'#q‹$:/("4T^þde€C€YY€D]qkQƒ "'%HH‡~]SS]ˆ}üuÙþÝ"=@ " "¸ÿÀ@ H" "/?À/3Ì]9///+]3Ä3310".#"#66323273#&'#567þ)'G@:PI\N'E?:KL _še€C€YY€D]=(/(ar'/'enO‡~]SS]ˆ}ü‰Ùþ²Á #@ @ HÀ/2Ì+99//]310"'3326736673#ýœýR]XX]PþÊ"32}%p+DÙöWKKWö*L]5y%ü‰Ùþ²Á #@   @ HÀ /3Ì+99//]310#&&'53"'332673ýÑD*r$}3&.5ýR]XX]PÝ%{3^9<þëöWKKWöü‰Ùþ²/@`p /?À/3Ì]299//]3]10#'6654#"5632"'332673þ+F >?b''"8P^ýR]XX]P}k+Z #&?HJþöWKKWöüuÙþÝ ";@!  p    / ?  À/2Ì]9///3]33]3/10"'332673".#"#663232673ýœýR]XX]Pk'G@:PI\N'E?:-* L _ÙöWKKWöZ(/(ar'/'F9en;þBZ&@  ` p  //]3933104&'3#"'532øGI[—fV8+"0køHq?vŽWcT 1þJ^@  "/3?39931073#"'53255#Ów\[8*-'b^ôhs\|–1þJ^@  "/3?39931073#"'53255#Ów\[8*-'b^ôhs\|–?#¶ @    ?3?9933310!#47'3#b  þÛ:ŽV)‘œåG)wÿìs (@  MY 'MY?+?+993310#"323 4&#"øßØõøÛÛöüÄ·²j¸´±¶1þìþÏ1-þÒþìïüëóõô3^ @    &?3?9933310!#47'3c 'Qá5’RÑ„©%CœH3²s<@  MY'NY?+9?+9393310!!5>54&#"'632!²ü‰™~7œ…¼¢5µóªÉ{·þ”ÝX+stHl|†Fš­•v¹‹þë*þ•Ìt(Q@+#  *)NY  &&MY&' MY %?+?+9/_^]+99333910!"'532654&##532654&#"'6632Ÿ«°¸þéþúߦTÑ\ÝÞãÜž ¶Õ­Œm´p1Uð{Ê܈º´˜ÍáSc,2³£‘œ`­”z“=JCGS¿þ¨`^ <@ MY &$??39/3+3993333310%##!533!7#`ü^ýÕxüþ¦dýü%þƒ}Cöü‘*Ò,ý/‚þ•_:@ MYNY& MY%?+?+9/+933102#"&'532654&#"'!!6 ê þèömÄBl¨_Àèâ‚Ž<:Àýž-œâÆáú+(g7+Ë­£º''`ýüÿÿƒÿì#Í/þ©á_(@NY&$??+393310!5!ZüŲý¤þ©V`Iú“ÿÿ{ÿìÏsþ•v(I@(% *)!OY p MY' OY%?+?+9/_^]9+933310#"'532##"&5432"326654&&—þßÍhX+y ÷ IÊnËãùÇØuþ#ž¼®¢e¯g]§óþàþ|ºVeV`gàÎÜ—þÜcÕ¹®´Z•MuÌsÿÿ;&IIf\ÝZÁ!2Q@*+..-2"*)&&' '*-43(.*"'0+$(?333Ô]2Ä222Ä293333333310#"'53254&'&&54632&#"##33#7#5•{‹>ch´;qpU†hzWP^EV;n^K" ÝR}Ýß}Vãª\qN!y;:('YONe!L!6/28)$4Fþþ`ÈþhÑý¢^ý/Ïý¤ÿÿ þ'¶&7z%ÿÿþyF&WzÅwþ T)G@&' *+FY  $FY HY?+?+99??3+933331047##"32373#"'53265%2654&#"ªvûÖììÜìuTôÌÝœ¦Ù ¸þ‘Æ©ªº°·³v6¾ -®™û­ÖþþFkXÈ´[Ú õÚøðåéÿÿwþ !&‘Kù³7&+5ÿÿwþ Ï&‘Nõ³*&+5ÿÿwþ Í&‘OP³2&+5ÿÿwþ !&‘:}³.&+5Ï5¶¶??91033Ïf¶úJÿÿÿÁ@s&–Cþ8R³&+5ÿÿ¿>s&–vÿ6R³ &+5ÿÿÿà&s&–KþµR³&+5ÿÿ&–jþµR ´&+55ÿÿÿ²l&–Rþ—R³&+5ÿÿÿï‡&–MþÊR³&+5ÿÿÿî!&–Nþ·R³&+5ÿÿAþB`¶&–QÿÿÂC&–OR³ &+5ÿÿÏþ9¶&–-ÿÿÿØ‹ &–VTýÆÿ—²?5ÿÿÏ5¶–ÿÿ&–jþµR ´&+55ÿÿÏ5¶–ÿÿ&–jþµR ´&+55ÿÿÏ5¶–ÿÿÏ5¶–ÿÿ…Õá&–fqR³&+5ÿÿÀþ¼B¶&–gV¶2I€6$$ÿq7)9):)<Dÿ®Fÿ…Gÿ…Hÿ…JÿÃPÿÃQÿÃRÿ…SÿÃTÿ…UÿÃVÿÃXÿÂÿqƒÿq„ÿq…ÿq†ÿq‡ÿqŸ¢ÿ…£ÿ®¤ÿ®¥ÿ®¦ÿ®§ÿ®¨ÿ®©ÿ…ªÿ…«ÿ…¬ÿ…­ÿ…´ÿ…µÿ…¶ÿ…·ÿ…¸ÿ…ºÿ…»ÿüÿýÿþÿÃÂÿqÃÿ®ÄÿqÅÿ®ÆÿqÇÿ®Éÿ…Ëÿ…Íÿ…Ïÿ…Ñÿ…Óÿ…Õÿ…×ÿ…Ùÿ…Ûÿ…Ýÿ…ßÿÃáÿÃãÿÃåÿÃúÿÃÿÃÿà ÿÃÿ…ÿ…ÿ…ÿ…ÿÃÿÃÿÃ!ÿÃ$)&)+ÿÃ-ÿÃ/ÿÃ1ÿÃ3ÿÃ5ÿÃ6)8:CÿqDÿ®Fÿ®Hÿ…JÿÃVÿq_ÿqbÿqiÿqyÿ®zÿ×{ÿ×~ÿ®ÿÂÿ׃ÿׄÿׇÿ׉ÿ׌ÿ®ŽÿÃÿ®ÿ®“ÿ®™ÿ®¤ÿ…ªÿq®ÿ…µÿ…Êÿ×ÎÿqÏÿ…ÕÿqØÿ…Ûÿ…Þÿ…êÿ…íÿ…îÿÃòÿqú)ü)þ)WÿÃXÿqYÿ®`ÿ…bÿÃjÿ…rÿqsÿq}ÿìÿ……ÿ…‡ÿ…‰ÿ…ÿ…²ÿ…´ÿ…Îÿ…ÏÿqÙÿqÚÿ×ÛÿqÜÿ×ÝÿqÞÿ×àÿ…âÿ×äÿ×ðÿ…òÿ…ôÿ… ÿq ÿ… ÿq ÿ…ÿ…ÿqÿ…ÿ…ÿ…ÿqÿqÿ®ÿq ÿ®!ÿq"ÿ®#ÿq%ÿq&ÿ®'ÿq(ÿ®)ÿq*ÿ®+ÿq,ÿ®-ÿq.ÿ®/ÿq0ÿ®1ÿq2ÿ®3ÿq4ÿ®6ÿ…8ÿ…:ÿ…<ÿ…@ÿ…Bÿ…Dÿ…Jÿ…Lÿ…Nÿ…Rÿ…Tÿ…Vÿ…Xÿ…Zÿ…\ÿ…^ÿ…`ÿ…bÿÃdÿÃfÿÃhÿÃjÿÃlÿÃnÿÃoqs) $ÿq 7) 9) :) < Dÿ® Fÿ… Gÿ… Hÿ… Jÿà Pÿà Qÿà Rÿ… Sÿà Tÿ… Uÿà Vÿà Xÿà ‚ÿq ƒÿq „ÿq …ÿq †ÿq ‡ÿq Ÿ ¢ÿ… £ÿ® ¤ÿ® ¥ÿ® ¦ÿ® §ÿ® ¨ÿ® ©ÿ… ªÿ… «ÿ… ¬ÿ… ­ÿ… ´ÿ… µÿ… ¶ÿ… ·ÿ… ¸ÿ… ºÿ… »ÿà ¼ÿà ½ÿà ¾ÿà Âÿq Ãÿ® Äÿq Åÿ® Æÿq Çÿ® Éÿ… Ëÿ… Íÿ… Ïÿ… Ñÿ… Óÿ… Õÿ… ×ÿ… Ùÿ… Ûÿ… Ýÿ… ßÿà áÿà ãÿà åÿà úÿà ÿà ÿà  ÿà ÿ… ÿ… ÿ… ÿ… ÿà ÿà ÿà !ÿà $) &) +ÿà -ÿà /ÿà 1ÿà 3ÿà 5ÿà 6) 8 : Cÿq Dÿ® Fÿ® Hÿ… Jÿà Vÿq _ÿq bÿq iÿq yÿ® zÿ× {ÿ× ~ÿ® ÿà ‚ÿ× ƒÿ× „ÿ× ‡ÿ× ‰ÿ× Œÿ® Žÿà ÿ® ÿ® “ÿ® ™ÿ® ¤ÿ… ªÿq ®ÿ… µÿ… Êÿ× Îÿq Ïÿ… Õÿq Øÿ… Ûÿ… Þÿ… êÿ… íÿ… îÿà òÿq ú) ü) þ)  Wÿà Xÿq Yÿ® `ÿ… bÿà jÿ… rÿq sÿq }ÿì ÿ… …ÿ… ‡ÿ… ‰ÿ… ÿ… ²ÿ… ´ÿ… Îÿ… Ïÿq Ùÿq Úÿ× Ûÿq Üÿ× Ýÿq Þÿ× àÿ… âÿ× äÿ× ðÿ… òÿ… ôÿ…  ÿq  ÿ…  ÿq  ÿ… ÿ… ÿq ÿ… ÿ… ÿ… ÿq ÿq ÿ® ÿq  ÿ® !ÿq "ÿ® #ÿq %ÿq &ÿ® 'ÿq (ÿ® )ÿq *ÿ® +ÿq ,ÿ® -ÿq .ÿ® /ÿq 0ÿ® 1ÿq 2ÿ® 3ÿq 4ÿ® 6ÿ… 8ÿ… :ÿ… <ÿ… @ÿ… Bÿ… Dÿ… Jÿ… Lÿ… Nÿ… Rÿ… Tÿ… Vÿ… Xÿ… Zÿ… \ÿ… ^ÿ… `ÿ… bÿà dÿà fÿà hÿà jÿà lÿà nÿà o q s ) -¸&ÿš*ÿš2ÿš4ÿš7ÿq8ÿ×9ÿ…:ÿ…<ÿ…‰ÿš”ÿš•ÿš–ÿš—ÿš˜ÿššÿš›ÿלÿ×ÿמÿןÿ…ÈÿšÊÿšÌÿšÎÿšÞÿšàÿšâÿšäÿšÿšÿšÿšÿš$ÿq&ÿq*ÿ×,ÿ×.ÿ×0ÿ×2ÿ×4ÿ×6ÿ…8ÿ…:ÿ…Gÿšfÿ®mÿ®qÿqrÿ…sÿšuÿ…xÿ……ÿ×ÿqŸÿš¦ÿq¸ÿš»ÿš¼ÿq¾ÿ®Áÿ\ÄÿqÜÿšáÿ…äÿšúÿ…üÿ…þÿ…ÿ…Tÿ…_ÿšaÿ×lÿš|ÿ\~ÿš€ÿ…‚ÿ…„ÿš†ÿšˆÿšŠÿšŒÿš©ÿqªÿš±ÿš³ÿšµÿq¶ÿš·ÿ…¹ÿ…½ÿq¾ÿš¿ÿ\Àÿ…Áÿ\Âÿ…Åÿ…Çÿ…Ôÿ\Õÿ…ïÿšñÿšóÿšýÿ\þÿ… ÿ…ÿšÿ…ÿšÿšÿqÿšIÿšKÿšMÿšOÿšQÿšSÿšUÿšWÿšYÿš[ÿš]ÿš_ÿšaÿ×cÿ×eÿ×gÿ×iÿ×kÿ×mÿ×oÿ…qÿ…sÿ…ÿq7ÿ®$ÿ®&ÿ®qÿ®ÿ®¦ÿ®¼ÿ®Äÿ®Üÿ×äÿשÿ®ªÿ×µÿ®¶ÿ×½ÿ®¾ÿ×ÿ®ÿ×ÿ®&ÿš*ÿš2ÿš4ÿš7ÿq8ÿ×9ÿ…:ÿ…<ÿ…‰ÿš”ÿš•ÿš–ÿš—ÿš˜ÿššÿš›ÿלÿ×ÿמÿןÿ…ÈÿšÊÿšÌÿšÎÿšÞÿšàÿšâÿšäÿšÿšÿšÿšÿš$ÿq&ÿq*ÿ×,ÿ×.ÿ×0ÿ×2ÿ×4ÿ×6ÿ…8ÿ…:ÿ…Gÿšfÿ®mÿ®qÿqrÿ…sÿšuÿ…xÿ……ÿ×ÿqŸÿš¦ÿq¸ÿš»ÿš¼ÿq¾ÿ®Áÿ\ÄÿqÜÿšáÿ…äÿšúÿ…üÿ…þÿ…ÿ…Tÿ…_ÿšaÿ×lÿš|ÿ\~ÿš€ÿ…‚ÿ…„ÿš†ÿšˆÿšŠÿšŒÿš©ÿqªÿš±ÿš³ÿšµÿq¶ÿš·ÿ…¹ÿ…½ÿq¾ÿš¿ÿ\Àÿ…Áÿ\Âÿ…Åÿ…Çÿ…Ôÿ\Õÿ…ïÿšñÿšóÿšýÿ\þÿ… ÿ…ÿšÿ…ÿšÿšÿqÿšIÿšKÿšMÿšOÿšQÿšSÿšUÿšWÿšYÿš[ÿš]ÿš_ÿšaÿ×cÿ×eÿ×gÿ×iÿ×kÿ×mÿ×oÿ…qÿ…sÿ…ÿq$ÿq$ ÿq$&ÿ×$*ÿ×$- $2ÿ×$4ÿ×$7ÿq$9ÿ®$:ÿ®$<ÿ…$‰ÿ×$”ÿ×$•ÿ×$–ÿ×$—ÿ×$˜ÿ×$šÿ×$Ÿÿ…$Èÿ×$Êÿ×$Ìÿ×$Îÿ×$Þÿ×$àÿ×$âÿ×$äÿ×$ÿ×$ÿ×$ÿ×$ÿ×$$ÿq$&ÿq$6ÿ®$8ÿ…$:ÿ…$Gÿ×$úÿ®$üÿ®$þÿ®$ÿ…$ÿq$ ÿq$_ÿ×$Iÿ×$Kÿ×$Mÿ×$Oÿ×$Qÿ×$Sÿ×$Uÿ×$Wÿ×$Yÿ×$[ÿ×$]ÿ×$_ÿ×$oÿ…$qÿ…$sÿ…$ÿq%ÿ®%ÿ®%$ÿ×%7ÿÃ%9ÿì%:ÿì%;ÿ×%<ÿì%=ÿì%‚ÿ×%ƒÿ×%„ÿ×%…ÿ×%†ÿ×%‡ÿ×%Ÿÿì%Âÿ×%Äÿ×%Æÿ×%$ÿÃ%&ÿÃ%6ÿì%8ÿì%:ÿì%;ÿì%=ÿì%?ÿì%Cÿ×% ÿì%úÿì%üÿì%þÿì%ÿì%ÿ®% ÿ®%Xÿ×%ÿ×%ÿ×%!ÿ×%#ÿ×%%ÿ×%'ÿ×%)ÿ×%+ÿ×%-ÿ×%/ÿ×%1ÿ×%3ÿ×%oÿì%qÿì%sÿì%ÿÃ&&ÿ×&*ÿ×&2ÿ×&4ÿ×&‰ÿ×&”ÿ×&•ÿ×&–ÿ×&—ÿ×&˜ÿ×&šÿ×&Èÿ×&Êÿ×&Ìÿ×&Îÿ×&Þÿ×&àÿ×&âÿ×&äÿ×&ÿ×&ÿ×&ÿ×&ÿ×&Gÿ×&_ÿ×&Iÿ×&Kÿ×&Mÿ×&Oÿ×&Qÿ×&Sÿ×&Uÿ×&Wÿ×&Yÿ×&[ÿ×&]ÿ×&_ÿ×'ÿ®'ÿ®'$ÿ×'7ÿÃ'9ÿì':ÿì';ÿ×'<ÿì'=ÿì'‚ÿ×'ƒÿ×'„ÿ×'…ÿ×'†ÿ×'‡ÿ×'Ÿÿì'Âÿ×'Äÿ×'Æÿ×'$ÿÃ'&ÿÃ'6ÿì'8ÿì':ÿì';ÿì'=ÿì'?ÿì'Cÿ×' ÿì'úÿì'üÿì'þÿì'ÿì'ÿ®' ÿ®'Xÿ×'ÿ×'ÿ×'!ÿ×'#ÿ×'%ÿ×''ÿ×')ÿ×'+ÿ×'-ÿ×'/ÿ×'1ÿ×'3ÿ×'oÿì'qÿì'sÿì'ÿÃ(-{)ÿ…)ÿ…)"))$ÿ×)‚ÿ×)ƒÿ×)„ÿ×)…ÿ×)†ÿ×)‡ÿ×)Âÿ×)Äÿ×)Æÿ×)Cÿ×)ÿ…) ÿ…)Xÿ×)ÿ×)ÿ×)!ÿ×)#ÿ×)%ÿ×)'ÿ×))ÿ×)+ÿ×)-ÿ×)/ÿ×)1ÿ×)3ÿ×.&ÿ×.*ÿ×.2ÿ×.4ÿ×.‰ÿ×.”ÿ×.•ÿ×.–ÿ×.—ÿ×.˜ÿ×.šÿ×.Èÿ×.Êÿ×.Ìÿ×.Îÿ×.Þÿ×.àÿ×.âÿ×.äÿ×.ÿ×.ÿ×.ÿ×.ÿ×.Gÿ×._ÿ×.Iÿ×.Kÿ×.Mÿ×.Oÿ×.Qÿ×.Sÿ×.Uÿ×.Wÿ×.Yÿ×.[ÿ×.]ÿ×._ÿ×/ÿ\/ ÿ\/&ÿ×/*ÿ×/2ÿ×/4ÿ×/7ÿ×/8ÿì/9ÿ×/:ÿ×/<ÿÃ/‰ÿ×/”ÿ×/•ÿ×/–ÿ×/—ÿ×/˜ÿ×/šÿ×/›ÿì/œÿì/ÿì/žÿì/ŸÿÃ/Èÿ×/Êÿ×/Ìÿ×/Îÿ×/Þÿ×/àÿ×/âÿ×/äÿ×/ÿ×/ÿ×/ÿ×/ÿ×/$ÿ×/&ÿ×/*ÿì/,ÿì/.ÿì/0ÿì/2ÿì/4ÿì/6ÿ×/8ÿÃ/:ÿÃ/Gÿ×/úÿ×/üÿ×/þÿ×/ÿÃ/ÿ\/ ÿ\/_ÿ×/aÿì/Iÿ×/Kÿ×/Mÿ×/Oÿ×/Qÿ×/Sÿ×/Uÿ×/Wÿ×/Yÿ×/[ÿ×/]ÿ×/_ÿ×/aÿì/cÿì/eÿì/gÿì/iÿì/kÿì/mÿì/oÿÃ/qÿÃ/sÿÃ/ÿ×2ÿ®2ÿ®2$ÿ×27ÿÃ29ÿì2:ÿì2;ÿ×2<ÿì2=ÿì2‚ÿ×2ƒÿ×2„ÿ×2…ÿ×2†ÿ×2‡ÿ×2Ÿÿì2Âÿ×2Äÿ×2Æÿ×2$ÿÃ2&ÿÃ26ÿì28ÿì2:ÿì2;ÿì2=ÿì2?ÿì2Cÿ×2 ÿì2úÿì2üÿì2þÿì2ÿì2ÿ®2 ÿ®2Xÿ×2ÿ×2ÿ×2!ÿ×2#ÿ×2%ÿ×2'ÿ×2)ÿ×2+ÿ×2-ÿ×2/ÿ×21ÿ×23ÿ×2oÿì2qÿì2sÿì2ÿÃ3þö3þö3$ÿš3;ÿ×3=ÿì3‚ÿš3ƒÿš3„ÿš3…ÿš3†ÿš3‡ÿš3Âÿš3Äÿš3Æÿš3;ÿì3=ÿì3?ÿì3Cÿš3þö3 þö3Xÿš3ÿš3ÿš3!ÿš3#ÿš3%ÿš3'ÿš3)ÿš3+ÿš3-ÿš3/ÿš31ÿš33ÿš4ÿ®4ÿ®4$ÿ×47ÿÃ49ÿì4:ÿì4;ÿ×4<ÿì4=ÿì4‚ÿ×4ƒÿ×4„ÿ×4…ÿ×4†ÿ×4‡ÿ×4Ÿÿì4Âÿ×4Äÿ×4Æÿ×4$ÿÃ4&ÿÃ46ÿì48ÿì4:ÿì4;ÿì4=ÿì4?ÿì4Cÿ×4 ÿì4úÿì4üÿì4þÿì4ÿì4ÿ®4 ÿ®4Xÿ×4ÿ×4ÿ×4!ÿ×4#ÿ×4%ÿ×4'ÿ×4)ÿ×4+ÿ×4-ÿ×4/ÿ×41ÿ×43ÿ×4oÿì4qÿì4sÿì4ÿÃ7ÿ…7ÿ®7ÿ…7")7$ÿq7&ÿ×7*ÿ×72ÿ×74ÿ×77)7Dÿ\7Fÿq7Gÿq7Hÿq7Jÿq7Pÿš7Qÿš7Rÿq7Sÿš7Tÿq7Uÿš7Vÿ…7Xÿš7Yÿ×7Zÿ×7[ÿ×7\ÿ×7]ÿ®7‚ÿq7ƒÿq7„ÿq7…ÿq7†ÿq7‡ÿq7‰ÿ×7”ÿ×7•ÿ×7–ÿ×7—ÿ×7˜ÿ×7šÿ×7¢ÿq7£ÿ\7¤ÿ\7¥ÿ\7¦ÿ\7§ÿ\7¨ÿ\7©ÿq7ªÿq7«ÿq7¬ÿq7­ÿq7´ÿq7µÿq7¶ÿq7·ÿq7¸ÿq7ºÿq7»ÿš7¼ÿš7½ÿš7¾ÿš7¿ÿ×7Âÿq7Ãÿ\7Äÿq7Åÿ\7Æÿq7Çÿ\7Èÿ×7Éÿq7Êÿ×7Ëÿq7Ìÿ×7Íÿq7Îÿ×7Ïÿq7Ñÿq7Óÿq7Õÿq7×ÿq7Ùÿq7Ûÿq7Ýÿq7Þÿ×7ßÿq7àÿ×7áÿq7âÿ×7ãÿq7äÿ×7åÿq7úÿš7ÿš7ÿš7 ÿš7ÿ×7ÿq7ÿ×7ÿq7ÿ×7ÿq7ÿ×7ÿq7ÿš7ÿš7ÿ…7!ÿ…7$)7&)7+ÿš7-ÿš7/ÿš71ÿš73ÿš75ÿš77ÿ×7<ÿ®7>ÿ®7@ÿ®7Cÿq7Dÿ\7Fÿ\7Gÿ×7Hÿq7Jÿ…7ûÿ×7ýÿ×7ÿ®7ÿ®7ÿ®7ÿ…7 ÿ…7Wÿš7Xÿq7Yÿ\7_ÿ×7`ÿq7bÿš7ÿq7ÿ\7ÿq7 ÿ\7!ÿq7"ÿ\7#ÿq7%ÿq7&ÿ\7'ÿq7(ÿ\7)ÿq7*ÿ\7+ÿq7,ÿ\7-ÿq7.ÿ\7/ÿq70ÿ\71ÿq72ÿ\73ÿq74ÿ\76ÿq78ÿq7:ÿq7<ÿq7@ÿq7Bÿq7Dÿq7Iÿ×7Jÿq7Kÿ×7Lÿq7Mÿ×7Nÿq7Oÿ×7Qÿ×7Rÿq7Sÿ×7Tÿq7Uÿ×7Vÿq7Wÿ×7Xÿq7Yÿ×7Zÿq7[ÿ×7\ÿq7]ÿ×7^ÿq7_ÿ×7`ÿq7bÿš7dÿš7fÿš7hÿš7jÿš7lÿš7nÿš7pÿ×7)8ÿ×8ÿ×8$ÿì8‚ÿì8ƒÿì8„ÿì8…ÿì8†ÿì8‡ÿì8Âÿì8Äÿì8Æÿì8Cÿì8ÿ×8 ÿ×8Xÿì8ÿì8ÿì8!ÿì8#ÿì8%ÿì8'ÿì8)ÿì8+ÿì8-ÿì8/ÿì81ÿì83ÿì9ÿš9ÿš9")9$ÿ®9&ÿì9*ÿì92ÿì94ÿì9Dÿ×9Fÿ×9Gÿ×9Hÿ×9Jÿì9Pÿì9Qÿì9Rÿ×9Sÿì9Tÿ×9Uÿì9Vÿì9Xÿì9‚ÿ®9ƒÿ®9„ÿ®9…ÿ®9†ÿ®9‡ÿ®9‰ÿì9”ÿì9•ÿì9–ÿì9—ÿì9˜ÿì9šÿì9¢ÿ×9£ÿ×9¤ÿ×9¥ÿ×9¦ÿ×9§ÿ×9¨ÿ×9©ÿ×9ªÿ×9«ÿ×9¬ÿ×9­ÿ×9´ÿ×9µÿ×9¶ÿ×9·ÿ×9¸ÿ×9ºÿ×9»ÿì9¼ÿì9½ÿì9¾ÿì9Âÿ®9Ãÿ×9Äÿ®9Åÿ×9Æÿ®9Çÿ×9Èÿì9Éÿ×9Êÿì9Ëÿ×9Ìÿì9Íÿ×9Îÿì9Ïÿ×9Ñÿ×9Óÿ×9Õÿ×9×ÿ×9Ùÿ×9Ûÿ×9Ýÿ×9Þÿì9ßÿì9àÿì9áÿì9âÿì9ãÿì9äÿì9åÿì9úÿì9ÿì9ÿì9 ÿì9ÿì9ÿ×9ÿì9ÿ×9ÿì9ÿ×9ÿì9ÿ×9ÿì9ÿì9ÿì9!ÿì9+ÿì9-ÿì9/ÿì91ÿì93ÿì95ÿì9Cÿ®9Dÿ×9Fÿ×9Gÿì9Hÿ×9Jÿì9ÿš9 ÿš9Wÿì9Xÿ®9Yÿ×9_ÿì9`ÿ×9bÿì9ÿ®9ÿ×9ÿ®9 ÿ×9!ÿ®9"ÿ×9#ÿ®9%ÿ®9&ÿ×9'ÿ®9(ÿ×9)ÿ®9*ÿ×9+ÿ®9,ÿ×9-ÿ®9.ÿ×9/ÿ®90ÿ×91ÿ®92ÿ×93ÿ®94ÿ×96ÿ×98ÿ×9:ÿ×9<ÿ×9@ÿ×9Bÿ×9Dÿ×9Iÿì9Jÿ×9Kÿì9Lÿ×9Mÿì9Nÿ×9Oÿì9Qÿì9Rÿ×9Sÿì9Tÿ×9Uÿì9Vÿ×9Wÿì9Xÿ×9Yÿì9Zÿ×9[ÿì9\ÿ×9]ÿì9^ÿ×9_ÿì9`ÿ×9bÿì9dÿì9fÿì9hÿì9jÿì9lÿì9nÿì:ÿš:ÿš:"):$ÿ®:&ÿì:*ÿì:2ÿì:4ÿì:Dÿ×:Fÿ×:Gÿ×:Hÿ×:Jÿì:Pÿì:Qÿì:Rÿ×:Sÿì:Tÿ×:Uÿì:Vÿì:Xÿì:‚ÿ®:ƒÿ®:„ÿ®:…ÿ®:†ÿ®:‡ÿ®:‰ÿì:”ÿì:•ÿì:–ÿì:—ÿì:˜ÿì:šÿì:¢ÿ×:£ÿ×:¤ÿ×:¥ÿ×:¦ÿ×:§ÿ×:¨ÿ×:©ÿ×:ªÿ×:«ÿ×:¬ÿ×:­ÿ×:´ÿ×:µÿ×:¶ÿ×:·ÿ×:¸ÿ×:ºÿ×:»ÿì:¼ÿì:½ÿì:¾ÿì:Âÿ®:Ãÿ×:Äÿ®:Åÿ×:Æÿ®:Çÿ×:Èÿì:Éÿ×:Êÿì:Ëÿ×:Ìÿì:Íÿ×:Îÿì:Ïÿ×:Ñÿ×:Óÿ×:Õÿ×:×ÿ×:Ùÿ×:Ûÿ×:Ýÿ×:Þÿì:ßÿì:àÿì:áÿì:âÿì:ãÿì:äÿì:åÿì:úÿì:ÿì:ÿì: ÿì:ÿì:ÿ×:ÿì:ÿ×:ÿì:ÿ×:ÿì:ÿ×:ÿì:ÿì:ÿì:!ÿì:+ÿì:-ÿì:/ÿì:1ÿì:3ÿì:5ÿì:Cÿ®:Dÿ×:Fÿ×:Gÿì:Hÿ×:Jÿì:ÿš: ÿš:Wÿì:Xÿ®:Yÿ×:_ÿì:`ÿ×:bÿì:ÿ®:ÿ×:ÿ®: ÿ×:!ÿ®:"ÿ×:#ÿ®:%ÿ®:&ÿ×:'ÿ®:(ÿ×:)ÿ®:*ÿ×:+ÿ®:,ÿ×:-ÿ®:.ÿ×:/ÿ®:0ÿ×:1ÿ®:2ÿ×:3ÿ®:4ÿ×:6ÿ×:8ÿ×::ÿ×:<ÿ×:@ÿ×:Bÿ×:Dÿ×:Iÿì:Jÿ×:Kÿì:Lÿ×:Mÿì:Nÿ×:Oÿì:Qÿì:Rÿ×:Sÿì:Tÿ×:Uÿì:Vÿ×:Wÿì:Xÿ×:Yÿì:Zÿ×:[ÿì:\ÿ×:]ÿì:^ÿ×:_ÿì:`ÿ×:bÿì:dÿì:fÿì:hÿì:jÿì:lÿì:nÿì;&ÿ×;*ÿ×;2ÿ×;4ÿ×;‰ÿ×;”ÿ×;•ÿ×;–ÿ×;—ÿ×;˜ÿ×;šÿ×;Èÿ×;Êÿ×;Ìÿ×;Îÿ×;Þÿ×;àÿ×;âÿ×;äÿ×;ÿ×;ÿ×;ÿ×;ÿ×;Gÿ×;_ÿ×;Iÿ×;Kÿ×;Mÿ×;Oÿ×;Qÿ×;Sÿ×;Uÿ×;Wÿ×;Yÿ×;[ÿ×;]ÿ×;_ÿ×<ÿ…<ÿ…<")<$ÿ…<&ÿ×<*ÿ×<2ÿ×<4ÿ×<Dÿš<Fÿš<Gÿš<Hÿš<Jÿ×<PÿÃ<QÿÃ<Rÿš<SÿÃ<Tÿš<UÿÃ<Vÿ®<XÿÃ<]ÿ×<‚ÿ…<ƒÿ…<„ÿ…<…ÿ…<†ÿ…<‡ÿ…<‰ÿ×<”ÿ×<•ÿ×<–ÿ×<—ÿ×<˜ÿ×<šÿ×<¢ÿš<£ÿš<¤ÿš<¥ÿš<¦ÿš<§ÿš<¨ÿš<©ÿš<ªÿš<«ÿš<¬ÿš<­ÿš<´ÿš<µÿš<¶ÿš<·ÿš<¸ÿš<ºÿš<»ÿÃ<¼ÿÃ<½ÿÃ<¾ÿÃ<Âÿ…<Ãÿš<Äÿ…<Åÿš<Æÿ…<Çÿš<Èÿ×<Éÿš<Êÿ×<Ëÿš<Ìÿ×<Íÿš<Îÿ×<Ïÿš<Ñÿš<Óÿš<Õÿš<×ÿš<Ùÿš<Ûÿš<Ýÿš<Þÿ×<ßÿ×<àÿ×<áÿ×<âÿ×<ãÿ×<äÿ×<åÿ×<úÿÃ<ÿÃ<ÿÃ< ÿÃ<ÿ×<ÿš<ÿ×<ÿš<ÿ×<ÿš<ÿ×<ÿš<ÿÃ<ÿÃ<ÿ®<!ÿ®<+ÿÃ<-ÿÃ</ÿÃ<1ÿÃ<3ÿÃ<5ÿÃ<<ÿ×<>ÿ×<@ÿ×<Cÿ…<Dÿš<Fÿš<Gÿ×<Hÿš<Jÿ®<ÿ…< ÿ…<WÿÃ<Xÿ…<Yÿš<_ÿ×<`ÿš<bÿÃ<ÿ…<ÿš<ÿ…< ÿš<!ÿ…<"ÿš<#ÿ…<%ÿ…<&ÿš<'ÿ…<(ÿš<)ÿ…<*ÿš<+ÿ…<,ÿš<-ÿ…<.ÿš</ÿ…<0ÿš<1ÿ…<2ÿš<3ÿ…<4ÿš<6ÿš<8ÿš<:ÿš<<ÿš<@ÿš<Bÿš<Dÿš<Iÿ×<Jÿš<Kÿ×<Lÿš<Mÿ×<Nÿš<Oÿ×<Qÿ×<Rÿš<Sÿ×<Tÿš<Uÿ×<Vÿš<Wÿ×<Xÿš<Yÿ×<Zÿš<[ÿ×<\ÿš<]ÿ×<^ÿš<_ÿ×<`ÿš<bÿÃ<dÿÃ<fÿÃ<hÿÃ<jÿÃ<lÿÃ<nÿÃ=&ÿì=*ÿì=2ÿì=4ÿì=‰ÿì=”ÿì=•ÿì=–ÿì=—ÿì=˜ÿì=šÿì=Èÿì=Êÿì=Ìÿì=Îÿì=Þÿì=àÿì=âÿì=äÿì=ÿì=ÿì=ÿì=ÿì=Gÿì=_ÿì=Iÿì=Kÿì=Mÿì=Oÿì=Qÿì=Sÿì=Uÿì=Wÿì=Yÿì=[ÿì=]ÿì=_ÿì>-¸DÿìD ÿìDÿìD ÿìEÿìE ÿìEYÿ×EZÿ×E[ÿ×E\ÿ×E]ÿìE¿ÿ×E7ÿ×E<ÿìE>ÿìE@ÿìEûÿ×Eýÿ×EÿìE ÿìEpÿ×F)F )F)F )HÿìH ÿìHYÿ×HZÿ×H[ÿ×H\ÿ×H]ÿìH¿ÿ×H7ÿ×H<ÿìH>ÿìH@ÿìHûÿ×Hýÿ×HÿìH ÿìHpÿ×I{I {I{I {KÿìK ÿìKÿìK ÿìNFÿ×NGÿ×NHÿ×NRÿ×NTÿ×N¢ÿ×N©ÿ×Nªÿ×N«ÿ×N¬ÿ×N­ÿ×N´ÿ×Nµÿ×N¶ÿ×N·ÿ×N¸ÿ×Nºÿ×NÉÿ×NËÿ×NÍÿ×NÏÿ×NÑÿ×NÓÿ×NÕÿ×N×ÿ×NÙÿ×NÛÿ×NÝÿ×Nÿ×Nÿ×Nÿ×Nÿ×NHÿ×N`ÿ×N6ÿ×N8ÿ×N:ÿ×N<ÿ×N@ÿ×NBÿ×NDÿ×NJÿ×NLÿ×NNÿ×NRÿ×NTÿ×NVÿ×NXÿ×NZÿ×N\ÿ×N^ÿ×N`ÿ×PÿìP ÿìPÿìP ÿìQÿìQ ÿìQÿìQ ÿìRÿìR ÿìRYÿ×RZÿ×R[ÿ×R\ÿ×R]ÿìR¿ÿ×R7ÿ×R<ÿìR>ÿìR@ÿìRûÿ×Rýÿ×RÿìR ÿìRpÿ×SÿìS ÿìSYÿ×SZÿ×S[ÿ×S\ÿ×S]ÿìS¿ÿ×S7ÿ×S<ÿìS>ÿìS@ÿìSûÿ×Sýÿ×SÿìS ÿìSpÿ×URU RUDÿ×UFÿ×UGÿ×UHÿ×UJÿìURÿ×UTÿ×U¢ÿ×U£ÿ×U¤ÿ×U¥ÿ×U¦ÿ×U§ÿ×U¨ÿ×U©ÿ×Uªÿ×U«ÿ×U¬ÿ×U­ÿ×U´ÿ×Uµÿ×U¶ÿ×U·ÿ×U¸ÿ×Uºÿ×UÃÿ×UÅÿ×UÇÿ×UÉÿ×UËÿ×UÍÿ×UÏÿ×UÑÿ×UÓÿ×UÕÿ×U×ÿ×UÙÿ×UÛÿ×UÝÿ×UßÿìUáÿìUãÿìUåÿìUÿ×Uÿ×Uÿ×Uÿ×UDÿ×UFÿ×UHÿ×URU RUYÿ×U`ÿ×Uÿ×U ÿ×U"ÿ×U&ÿ×U(ÿ×U*ÿ×U,ÿ×U.ÿ×U0ÿ×U2ÿ×U4ÿ×U6ÿ×U8ÿ×U:ÿ×U<ÿ×U@ÿ×UBÿ×UDÿ×UJÿ×ULÿ×UNÿ×URÿ×UTÿ×UVÿ×UXÿ×UZÿ×U\ÿ×U^ÿ×U`ÿ×W)W )W)W )YRY RYÿ®Yÿ®Y")YRYÿ®Y RY ÿ®ZRZ RZÿ®Zÿ®Z")ZRZÿ®Z RZ ÿ®[Fÿ×[Gÿ×[Hÿ×[Rÿ×[Tÿ×[¢ÿ×[©ÿ×[ªÿ×[«ÿ×[¬ÿ×[­ÿ×[´ÿ×[µÿ×[¶ÿ×[·ÿ×[¸ÿ×[ºÿ×[Éÿ×[Ëÿ×[Íÿ×[Ïÿ×[Ñÿ×[Óÿ×[Õÿ×[×ÿ×[Ùÿ×[Ûÿ×[Ýÿ×[ÿ×[ÿ×[ÿ×[ÿ×[Hÿ×[`ÿ×[6ÿ×[8ÿ×[:ÿ×[<ÿ×[@ÿ×[Bÿ×[Dÿ×[Jÿ×[Lÿ×[Nÿ×[Rÿ×[Tÿ×[Vÿ×[Xÿ×[Zÿ×[\ÿ×[^ÿ×[`ÿ×\R\ R\ÿ®\ÿ®\")\R\ÿ®\ R\ ÿ®^-¸‚ÿq‚ ÿq‚&ÿׂ*ÿׂ- ‚2ÿׂ4ÿׂ7ÿq‚9ÿ®‚:ÿ®‚<ÿ…‚‰ÿׂ”ÿׂ•ÿׂ–ÿׂ—ÿׂ˜ÿׂšÿׂŸÿ…‚ÈÿׂÊÿׂÌÿׂÎÿׂÞÿׂàÿׂâÿׂäÿׂÿׂÿׂÿׂÿׂ$ÿq‚&ÿq‚6ÿ®‚8ÿ…‚:ÿ…‚Gÿׂúÿ®‚üÿ®‚þÿ®‚ÿ…‚ÿq‚ ÿq‚_ÿׂIÿׂKÿׂMÿׂOÿׂQÿׂSÿׂUÿׂWÿׂYÿׂ[ÿׂ]ÿׂ_ÿׂoÿ…‚qÿ…‚sÿ…‚ÿqƒÿqƒ ÿqƒ&ÿ׃*ÿ׃- ƒ2ÿ׃4ÿ׃7ÿqƒ9ÿ®ƒ:ÿ®ƒ<ÿ…ƒ‰ÿ׃”ÿ׃•ÿ׃–ÿ׃—ÿ׃˜ÿ׃šÿ׃Ÿÿ…ƒÈÿ׃Êÿ׃Ìÿ׃Îÿ׃Þÿ׃àÿ׃âÿ׃äÿ׃ÿ׃ÿ׃ÿ׃ÿ׃$ÿqƒ&ÿqƒ6ÿ®ƒ8ÿ…ƒ:ÿ…ƒGÿ׃úÿ®ƒüÿ®ƒþÿ®ƒÿ…ƒÿqƒ ÿqƒ_ÿ׃Iÿ׃Kÿ׃Mÿ׃Oÿ׃Qÿ׃Sÿ׃Uÿ׃Wÿ׃Yÿ׃[ÿ׃]ÿ׃_ÿ׃oÿ…ƒqÿ…ƒsÿ…ƒÿq„ÿq„ ÿq„&ÿׄ*ÿׄ- „2ÿׄ4ÿׄ7ÿq„9ÿ®„:ÿ®„<ÿ…„‰ÿׄ”ÿׄ•ÿׄ–ÿׄ—ÿׄ˜ÿׄšÿׄŸÿ…„ÈÿׄÊÿׄÌÿׄÎÿׄÞÿׄàÿׄâÿׄäÿׄÿׄÿׄÿׄÿׄ$ÿq„&ÿq„6ÿ®„8ÿ…„:ÿ…„Gÿׄúÿ®„üÿ®„þÿ®„ÿ…„ÿq„ ÿq„_ÿׄIÿׄKÿׄMÿׄOÿׄQÿׄSÿׄUÿׄWÿׄYÿׄ[ÿׄ]ÿׄ_ÿׄoÿ…„qÿ…„sÿ…„ÿq…ÿq… ÿq…&ÿ×…*ÿ×…- …2ÿ×…4ÿ×…7ÿq…9ÿ®…:ÿ®…<ÿ……‰ÿ×…”ÿ×…•ÿ×…–ÿ×…—ÿ×…˜ÿ×…šÿ×…Ÿÿ……Èÿ×…Êÿ×…Ìÿ×…Îÿ×…Þÿ×…àÿ×…âÿ×…äÿ×…ÿ×…ÿ×…ÿ×…ÿ×…$ÿq…&ÿq…6ÿ®…8ÿ……:ÿ……Gÿ×…úÿ®…üÿ®…þÿ®…ÿ……ÿq… ÿq…_ÿ×…Iÿ×…Kÿ×…Mÿ×…Oÿ×…Qÿ×…Sÿ×…Uÿ×…Wÿ×…Yÿ×…[ÿ×…]ÿ×…_ÿ×…oÿ……qÿ……sÿ……ÿq†ÿq† ÿq†&ÿ׆*ÿ׆- †2ÿ׆4ÿ׆7ÿq†9ÿ®†:ÿ®†<ÿ…†‰ÿ׆”ÿ׆•ÿ׆–ÿ׆—ÿ׆˜ÿ׆šÿ׆Ÿÿ…†Èÿ׆Êÿ׆Ìÿ׆Îÿ׆Þÿ׆àÿ׆âÿ׆äÿ׆ÿ׆ÿ׆ÿ׆ÿ׆$ÿq†&ÿq†6ÿ®†8ÿ…†:ÿ…†Gÿ׆úÿ®†üÿ®†þÿ®†ÿ…†ÿq† ÿq†_ÿ׆Iÿ׆Kÿ׆Mÿ׆Oÿ׆Qÿ׆Sÿ׆Uÿ׆Wÿ׆Yÿ׆[ÿ׆]ÿ׆_ÿ׆oÿ…†qÿ…†sÿ…†ÿq‡ÿq‡ ÿq‡&ÿׇ*ÿׇ- ‡2ÿׇ4ÿׇ7ÿq‡9ÿ®‡:ÿ®‡<ÿ…‡‰ÿׇ”ÿׇ•ÿׇ–ÿׇ—ÿׇ˜ÿׇšÿׇŸÿ…‡ÈÿׇÊÿׇÌÿׇÎÿׇÞÿׇàÿׇâÿׇäÿׇÿׇÿׇÿׇÿׇ$ÿq‡&ÿq‡6ÿ®‡8ÿ…‡:ÿ…‡Gÿׇúÿ®‡üÿ®‡þÿ®‡ÿ…‡ÿq‡ ÿq‡_ÿׇIÿׇKÿׇMÿׇOÿׇQÿׇSÿׇUÿׇWÿׇYÿׇ[ÿׇ]ÿׇ_ÿׇoÿ…‡qÿ…‡sÿ…‡ÿqˆ-{‰&ÿ׉*ÿ׉2ÿ׉4ÿ׉‰ÿ׉”ÿ׉•ÿ׉–ÿ׉—ÿ׉˜ÿ׉šÿ׉Èÿ׉Êÿ׉Ìÿ׉Îÿ׉Þÿ׉àÿ׉âÿ׉äÿ׉ÿ׉ÿ׉ÿ׉ÿ׉Gÿ׉_ÿ׉Iÿ׉Kÿ׉Mÿ׉Oÿ׉Qÿ׉Sÿ׉Uÿ׉Wÿ׉Yÿ׉[ÿ׉]ÿ׉_ÿ׊-{‹-{Œ-{-{’ÿ®’ÿ®’$ÿ×’7ÿÃ’9ÿì’:ÿì’;ÿ×’<ÿì’=ÿì’‚ÿ×’ƒÿ×’„ÿ×’…ÿ×’†ÿ×’‡ÿ×’Ÿÿì’Âÿ×’Äÿ×’Æÿ×’$ÿÃ’&ÿÃ’6ÿì’8ÿì’:ÿì’;ÿì’=ÿì’?ÿì’Cÿ×’ ÿì’úÿì’üÿì’þÿì’ÿì’ÿ®’ ÿ®’Xÿ×’ÿ×’ÿ×’!ÿ×’#ÿ×’%ÿ×’'ÿ×’)ÿ×’+ÿ×’-ÿ×’/ÿ×’1ÿ×’3ÿ×’oÿì’qÿì’sÿì’ÿÔÿ®”ÿ®”$ÿ×”7ÿÔ9ÿì”:ÿì”;ÿ×”<ÿì”=ÿ씂ÿ×”ƒÿ×”„ÿ×”…ÿ×”†ÿ×”‡ÿ×”Ÿÿì”Âÿ×”Äÿ×”Æÿ×”$ÿÔ&ÿÔ6ÿì”8ÿì”:ÿì”;ÿì”=ÿì”?ÿì”Cÿ×” ÿì”úÿì”üÿì”þÿì”ÿì”ÿ®” ÿ®”Xÿ×”ÿ×”ÿ×”!ÿ×”#ÿ×”%ÿ×”'ÿ×”)ÿ×”+ÿ×”-ÿ×”/ÿ×”1ÿ×”3ÿ×”oÿì”qÿì”sÿì”ÿÕÿ®•ÿ®•$ÿו7ÿÕ9ÿì•:ÿì•;ÿו<ÿì•=ÿì•‚ÿוƒÿו„ÿו…ÿו†ÿו‡ÿוŸÿì•ÂÿוÄÿוÆÿו$ÿÕ&ÿÕ6ÿì•8ÿì•:ÿì•;ÿì•=ÿì•?ÿì•Cÿו ÿì•úÿì•üÿì•þÿì•ÿì•ÿ®• ÿ®•Xÿוÿוÿו!ÿו#ÿו%ÿו'ÿו)ÿו+ÿו-ÿו/ÿו1ÿו3ÿוoÿì•qÿì•sÿì•ÿÖÿ®–ÿ®–$ÿ×–7ÿÖ9ÿì–:ÿì–;ÿ×–<ÿì–=ÿì–‚ÿ×–ƒÿ×–„ÿ×–…ÿ×–†ÿ×–‡ÿ×–Ÿÿì–Âÿ×–Äÿ×–Æÿ×–$ÿÖ&ÿÖ6ÿì–8ÿì–:ÿì–;ÿì–=ÿì–?ÿì–Cÿ×– ÿì–úÿì–üÿì–þÿì–ÿì–ÿ®– ÿ®–Xÿ×–ÿ×–ÿ×–!ÿ×–#ÿ×–%ÿ×–'ÿ×–)ÿ×–+ÿ×–-ÿ×–/ÿ×–1ÿ×–3ÿ×–oÿì–qÿì–sÿì–ÿ×ÿ®—ÿ®—$ÿ×—7ÿ×9ÿì—:ÿì—;ÿ×—<ÿì—=ÿì—‚ÿ×—ƒÿ×—„ÿ×—…ÿ×—†ÿ×—‡ÿ×—Ÿÿì—Âÿ×—Äÿ×—Æÿ×—$ÿ×&ÿ×6ÿì—8ÿì—:ÿì—;ÿì—=ÿì—?ÿì—Cÿ×— ÿì—úÿì—üÿì—þÿì—ÿì—ÿ®— ÿ®—Xÿ×—ÿ×—ÿ×—!ÿ×—#ÿ×—%ÿ×—'ÿ×—)ÿ×—+ÿ×—-ÿ×—/ÿ×—1ÿ×—3ÿ×—oÿì—qÿì—sÿì—ÿØÿ®˜ÿ®˜$ÿט7ÿØ9ÿì˜:ÿì˜;ÿט<ÿì˜=ÿ옂ÿטƒÿט„ÿט…ÿט†ÿט‡ÿטŸÿì˜ÂÿטÄÿטÆÿט$ÿØ&ÿØ6ÿì˜8ÿì˜:ÿì˜;ÿì˜=ÿì˜?ÿì˜Cÿט ÿì˜úÿì˜üÿì˜þÿì˜ÿì˜ÿ®˜ ÿ®˜Xÿטÿטÿט!ÿט#ÿט%ÿט'ÿט)ÿט+ÿט-ÿט/ÿט1ÿט3ÿטoÿì˜qÿì˜sÿì˜ÿÚÿ®šÿ®š$ÿך7ÿÚ9ÿìš:ÿìš;ÿך<ÿìš=ÿìš‚ÿךƒÿך„ÿך…ÿך†ÿך‡ÿךŸÿìšÂÿךÄÿךÆÿך$ÿÚ&ÿÚ6ÿìš8ÿìš:ÿìš;ÿìš=ÿìš?ÿìšCÿך ÿìšúÿìšüÿìšþÿìšÿìšÿ®š ÿ®šXÿךÿךÿך!ÿך#ÿך%ÿך'ÿך)ÿך+ÿך-ÿך/ÿך1ÿך3ÿךoÿìšqÿìšsÿìšÿÛÿ×›ÿ×›$ÿ웂ÿ웃ÿ웄ÿì›…ÿ웆ÿ웇ÿì›Âÿì›Äÿì›Æÿì›Cÿì›ÿ×› ÿ×›Xÿì›ÿì›ÿì›!ÿì›#ÿì›%ÿì›'ÿì›)ÿì›+ÿì›-ÿì›/ÿì›1ÿì›3ÿìœÿלÿל$ÿ윂ÿ윃ÿ위ÿ윅ÿ윆ÿ윇ÿìœÂÿìœÄÿìœÆÿìœCÿìœÿל ÿלXÿìœÿìœÿìœ!ÿìœ#ÿìœ%ÿìœ'ÿìœ)ÿìœ+ÿìœ-ÿìœ/ÿìœ1ÿìœ3ÿìÿ×ÿ×$ÿì‚ÿìƒÿì„ÿì…ÿì†ÿì‡ÿìÂÿìÄÿìÆÿìCÿìÿ× ÿ×Xÿìÿìÿì!ÿì#ÿì%ÿì'ÿì)ÿì+ÿì-ÿì/ÿì1ÿì3ÿìžÿמÿמ$ÿìž‚ÿ잃ÿìž„ÿìž…ÿ잆ÿ잇ÿìžÂÿìžÄÿìžÆÿìžCÿìžÿמ ÿמXÿìžÿìžÿìž!ÿìž#ÿìž%ÿìž'ÿìž)ÿìž+ÿìž-ÿìž/ÿìž1ÿìž3ÿìŸÿ…Ÿÿ…Ÿ")Ÿ$ÿ…Ÿ&ÿן*ÿן2ÿן4ÿןDÿšŸFÿšŸGÿšŸHÿšŸJÿןPÿßQÿßRÿšŸSÿßTÿšŸUÿßVÿ®ŸXÿß]ÿן‚ÿ…Ÿƒÿ…Ÿ„ÿ…Ÿ…ÿ…Ÿ†ÿ…Ÿ‡ÿ…Ÿ‰ÿן”ÿן•ÿן–ÿן—ÿן˜ÿןšÿן¢ÿšŸ£ÿšŸ¤ÿšŸ¥ÿšŸ¦ÿšŸ§ÿšŸ¨ÿšŸ©ÿšŸªÿšŸ«ÿšŸ¬ÿšŸ­ÿšŸ´ÿšŸµÿšŸ¶ÿšŸ·ÿšŸ¸ÿšŸºÿšŸ»ÿß¼ÿß½ÿß¾ÿßÂÿ…ŸÃÿšŸÄÿ…ŸÅÿšŸÆÿ…ŸÇÿšŸÈÿןÉÿšŸÊÿןËÿšŸÌÿןÍÿšŸÎÿןÏÿšŸÑÿšŸÓÿšŸÕÿšŸ×ÿšŸÙÿšŸÛÿšŸÝÿšŸÞÿןßÿןàÿןáÿןâÿןãÿןäÿןåÿןúÿßÿßÿß ÿßÿןÿšŸÿןÿšŸÿןÿšŸÿןÿšŸÿßÿßÿ®Ÿ!ÿ®Ÿ+ÿß-ÿß/ÿß1ÿß3ÿß5ÿß<ÿן>ÿן@ÿןCÿ…ŸDÿšŸFÿšŸGÿןHÿšŸJÿ®Ÿÿ…Ÿ ÿ…ŸWÿßXÿ…ŸYÿšŸ_ÿן`ÿšŸbÿßÿ…ŸÿšŸÿ…Ÿ ÿšŸ!ÿ…Ÿ"ÿšŸ#ÿ…Ÿ%ÿ…Ÿ&ÿšŸ'ÿ…Ÿ(ÿšŸ)ÿ…Ÿ*ÿšŸ+ÿ…Ÿ,ÿšŸ-ÿ…Ÿ.ÿšŸ/ÿ…Ÿ0ÿšŸ1ÿ…Ÿ2ÿšŸ3ÿ…Ÿ4ÿšŸ6ÿšŸ8ÿšŸ:ÿšŸ<ÿšŸ@ÿšŸBÿšŸDÿšŸIÿןJÿšŸKÿןLÿšŸMÿןNÿšŸOÿןQÿןRÿšŸSÿןTÿšŸUÿןVÿšŸWÿןXÿšŸYÿןZÿšŸ[ÿן\ÿšŸ]ÿן^ÿšŸ_ÿן`ÿšŸbÿßdÿßfÿßhÿßjÿßlÿßnÿàþö þö $ÿš ;ÿ× =ÿì ‚ÿš ƒÿš „ÿš …ÿš †ÿš ‡ÿš Âÿš Äÿš Æÿš ;ÿì =ÿì ?ÿì Cÿš þö  þö Xÿš ÿš ÿš !ÿš #ÿš %ÿš 'ÿš )ÿš +ÿš -ÿš /ÿš 1ÿš 3ÿš¢ÿì¢ ÿì¢ÿì¢ ÿì£ÿì£ ÿì£ÿì£ ÿì¤ÿì¤ ÿì¤ÿì¤ ÿì¥ÿì¥ ÿì¥ÿì¥ ÿì¦ÿì¦ ÿì¦ÿì¦ ÿì§ÿì§ ÿì§ÿì§ ÿìªÿìª ÿìªYÿתZÿת[ÿת\ÿת]ÿ쪿ÿת7ÿת<ÿìª>ÿìª@ÿìªûÿתýÿתÿìª ÿìªpÿ׫ÿì« ÿì«Yÿ׫Zÿ׫[ÿ׫\ÿ׫]ÿì«¿ÿ׫7ÿ׫<ÿì«>ÿì«@ÿì«ûÿ׫ýÿ׫ÿì« ÿì«pÿ׬ÿì¬ ÿì¬Yÿ׬Zÿ׬[ÿ׬\ÿ׬]ÿ쬿ÿ׬7ÿ׬<ÿì¬>ÿì¬@ÿì¬ûÿ׬ýÿ׬ÿì¬ ÿì¬pÿ×­ÿì­ ÿì­Yÿ×­Zÿ×­[ÿ×­\ÿ×­]ÿì­¿ÿ×­7ÿ×­<ÿì­>ÿì­@ÿì­ûÿ×­ýÿ×­ÿì­ ÿì­pÿײÿì² ÿì²YÿײZÿײ[ÿײ\ÿײ]ÿ첿ÿײ7ÿײ<ÿì²>ÿì²@ÿì²ûÿײýÿײÿì² ÿì²pÿ×´ÿì´ ÿì´Yÿ×´Zÿ×´[ÿ×´\ÿ×´]ÿì´¿ÿ×´7ÿ×´<ÿì´>ÿì´@ÿì´ûÿ×´ýÿ×´ÿì´ ÿì´pÿ×µÿìµ ÿìµYÿ×µZÿ×µ[ÿ×µ\ÿ×µ]ÿ쵿ÿ×µ7ÿ×µ<ÿìµ>ÿìµ@ÿìµûÿ×µýÿ×µÿìµ ÿìµpÿ׶ÿì¶ ÿì¶Yÿ׶Zÿ׶[ÿ׶\ÿ׶]ÿ춿ÿ׶7ÿ׶<ÿì¶>ÿì¶@ÿì¶ûÿ׶ýÿ׶ÿì¶ ÿì¶pÿ׸ÿ׸ ÿ׸ÿ׸ ÿ׺ÿìº ÿìºYÿ׺Zÿ׺[ÿ׺\ÿ׺]ÿ캿ÿ׺7ÿ׺<ÿìº>ÿìº@ÿìºûÿ׺ýÿ׺ÿìº ÿìºpÿ׿R¿ R¿ÿ®¿ÿ®¿")¿R¿ÿ®¿ R¿ ÿ®ÀÿìÀ ÿìÀYÿ×ÀZÿ×À[ÿ×À\ÿ×À]ÿìÀ¿ÿ×À7ÿ×À<ÿìÀ>ÿìÀ@ÿìÀûÿ×Àýÿ×ÀÿìÀ ÿìÀpÿ×ÁRÁ RÁÿ®Áÿ®Á")ÁRÁÿ®Á RÁ ÿ®Âÿq ÿqÂ&ÿ×Â*ÿ×Â- Â2ÿ×Â4ÿ×Â7ÿqÂ9ÿ®Â:ÿ®Â<ÿ…‰ÿ×”ÿוÿ×–ÿ×—ÿטÿךÿןÿ…ÂÈÿ×ÂÊÿ×ÂÌÿ×ÂÎÿ×ÂÞÿ×Âàÿ×Ââÿ×Âäÿ×Âÿ×Âÿ×Âÿ×Âÿ×Â$ÿqÂ&ÿqÂ6ÿ®Â8ÿ…Â:ÿ…ÂGÿ×Âúÿ®Âüÿ®Âþÿ®Âÿ…Âÿq ÿqÂ_ÿ×ÂIÿ×ÂKÿ×ÂMÿ×ÂOÿ×ÂQÿ×ÂSÿ×ÂUÿ×ÂWÿ×ÂYÿ×Â[ÿ×Â]ÿ×Â_ÿ×Âoÿ…Âqÿ…Âsÿ…ÂÿqÃÿìà ÿìÃÿìà ÿìÄÿqÄ ÿqÄ&ÿ×Ä*ÿ×Ä- Ä2ÿ×Ä4ÿ×Ä7ÿqÄ9ÿ®Ä:ÿ®Ä<ÿ…ĉÿ×Ä”ÿ×Ä•ÿ×Ä–ÿ×Ä—ÿ×Ęÿ×Äšÿ×ÄŸÿ…ÄÈÿ×ÄÊÿ×ÄÌÿ×ÄÎÿ×ÄÞÿ×Äàÿ×Äâÿ×Ääÿ×Äÿ×Äÿ×Äÿ×Äÿ×Ä$ÿqÄ&ÿqÄ6ÿ®Ä8ÿ…Ä:ÿ…ÄGÿ×Äúÿ®Äüÿ®Äþÿ®Äÿ…ÄÿqÄ ÿqÄ_ÿ×ÄIÿ×ÄKÿ×ÄMÿ×ÄOÿ×ÄQÿ×ÄSÿ×ÄUÿ×ÄWÿ×ÄYÿ×Ä[ÿ×Ä]ÿ×Ä_ÿ×Äoÿ…Äqÿ…Äsÿ…ÄÿqÅÿìÅ ÿìÅÿìÅ ÿìÆÿqÆ ÿqÆ&ÿ×Æ*ÿ×Æ- Æ2ÿ×Æ4ÿ×Æ7ÿqÆ9ÿ®Æ:ÿ®Æ<ÿ…Ɖÿ×Æ”ÿ×Æ•ÿ×Æ–ÿ×Æ—ÿ×Ƙÿ×Æšÿ×ÆŸÿ…ÆÈÿ×ÆÊÿ×ÆÌÿ×ÆÎÿ×ÆÞÿ×Æàÿ×Æâÿ×Æäÿ×Æÿ×Æÿ×Æÿ×Æÿ×Æ$ÿqÆ&ÿqÆ6ÿ®Æ8ÿ…Æ:ÿ…ÆGÿ×Æúÿ®Æüÿ®Æþÿ®Æÿ…ÆÿqÆ ÿqÆ_ÿ×ÆIÿ×ÆKÿ×ÆMÿ×ÆOÿ×ÆQÿ×ÆSÿ×ÆUÿ×ÆWÿ×ÆYÿ×Æ[ÿ×Æ]ÿ×Æ_ÿ×Æoÿ…Æqÿ…Æsÿ…ÆÿqÇÿìÇ ÿìÇÿìÇ ÿìÈ&ÿ×È*ÿ×È2ÿ×È4ÿ×ȉÿ×È”ÿ×È•ÿ×È–ÿ×È—ÿ×Șÿ×Èšÿ×ÈÈÿ×ÈÊÿ×ÈÌÿ×ÈÎÿ×ÈÞÿ×Èàÿ×Èâÿ×Èäÿ×Èÿ×Èÿ×Èÿ×Èÿ×ÈGÿ×È_ÿ×ÈIÿ×ÈKÿ×ÈMÿ×ÈOÿ×ÈQÿ×ÈSÿ×ÈUÿ×ÈWÿ×ÈYÿ×È[ÿ×È]ÿ×È_ÿ×Ê&ÿ×Ê*ÿ×Ê2ÿ×Ê4ÿ×ʉÿ×Ê”ÿ×Ê•ÿ×Ê–ÿ×Ê—ÿ×ʘÿ×Êšÿ×ÊÈÿ×ÊÊÿ×ÊÌÿ×ÊÎÿ×ÊÞÿ×Êàÿ×Êâÿ×Êäÿ×Êÿ×Êÿ×Êÿ×Êÿ×ÊGÿ×Ê_ÿ×ÊIÿ×ÊKÿ×ÊMÿ×ÊOÿ×ÊQÿ×ÊSÿ×ÊUÿ×ÊWÿ×ÊYÿ×Ê[ÿ×Ê]ÿ×Ê_ÿ×Ì&ÿ×Ì*ÿ×Ì2ÿ×Ì4ÿ×̉ÿ×Ì”ÿ×Ì•ÿ×Ì–ÿ×Ì—ÿ×̘ÿ×Ìšÿ×ÌÈÿ×ÌÊÿ×ÌÌÿ×ÌÎÿ×ÌÞÿ×Ìàÿ×Ìâÿ×Ìäÿ×Ìÿ×Ìÿ×Ìÿ×Ìÿ×ÌGÿ×Ì_ÿ×ÌIÿ×ÌKÿ×ÌMÿ×ÌOÿ×ÌQÿ×ÌSÿ×ÌUÿ×ÌWÿ×ÌYÿ×Ì[ÿ×Ì]ÿ×Ì_ÿ×Î&ÿ×Î*ÿ×Î2ÿ×Î4ÿ×Ήÿ×Δÿ×Εÿ×Ζÿ×Ηÿ×Θÿ×Κÿ×ÎÈÿ×ÎÊÿ×ÎÌÿ×ÎÎÿ×ÎÞÿ×Îàÿ×Îâÿ×Îäÿ×Îÿ×Îÿ×Îÿ×Îÿ×ÎGÿ×Î_ÿ×ÎIÿ×ÎKÿ×ÎMÿ×ÎOÿ×ÎQÿ×ÎSÿ×ÎUÿ×ÎWÿ×ÎYÿ×Î[ÿ×Î]ÿ×Î_ÿ×Ðÿ®Ðÿ®Ð$ÿ×Ð7ÿÃÐ9ÿìÐ:ÿìÐ;ÿ×Ð<ÿìÐ=ÿìЂÿ×Ѓÿ×Єÿ×Ð…ÿ×Іÿ×Їÿ×ПÿìÐÂÿ×ÐÄÿ×ÐÆÿ×Ð$ÿÃÐ&ÿÃÐ6ÿìÐ8ÿìÐ:ÿìÐ;ÿìÐ=ÿìÐ?ÿìÐCÿ×РÿìÐúÿìÐüÿìÐþÿìÐÿìÐÿ®Ð ÿ®ÐXÿ×Ðÿ×Ðÿ×Ð!ÿ×Ð#ÿ×Ð%ÿ×Ð'ÿ×Ð)ÿ×Ð+ÿ×Ð-ÿ×Ð/ÿ×Ð1ÿ×Ð3ÿ×ÐoÿìÐqÿìÐsÿìÐÿÃÑRÑ RÑ Ñ"¤Ñ@ÑE=ÑK=ÑN=ÑO=Ñ`Ñç=Ñé{ÑRÑ RÒÿ®Òÿ®Ò$ÿ×Ò7ÿÃÒ9ÿìÒ:ÿìÒ;ÿ×Ò<ÿìÒ=ÿìÒ‚ÿ×Òƒÿ×Ò„ÿ×Ò…ÿ×Ò†ÿ×Ò‡ÿ×ÒŸÿìÒÂÿ×ÒÄÿ×ÒÆÿ×Ò$ÿÃÒ&ÿÃÒ6ÿìÒ8ÿìÒ:ÿìÒ;ÿìÒ=ÿìÒ?ÿìÒCÿ×Ò ÿìÒúÿìÒüÿìÒþÿìÒÿìÒÿ®Ò ÿ®ÒXÿ×Òÿ×Òÿ×Ò!ÿ×Ò#ÿ×Ò%ÿ×Ò'ÿ×Ò)ÿ×Ò+ÿ×Ò-ÿ×Ò/ÿ×Ò1ÿ×Ò3ÿ×ÒoÿìÒqÿìÒsÿìÒÿÃÔ-{ÕÿìÕ ÿìÕYÿ×ÕZÿ×Õ[ÿ×Õ\ÿ×Õ]ÿìÕ¿ÿ×Õ7ÿ×Õ<ÿìÕ>ÿìÕ@ÿìÕûÿ×Õýÿ×ÕÿìÕ ÿìÕpÿ×Ö-{×ÿì× ÿì×Yÿ××Zÿ××[ÿ××\ÿ××]ÿì׿ÿ××7ÿ××<ÿì×>ÿì×@ÿì×ûÿ××ýÿ××ÿì× ÿì×pÿ×Ø-{ÙÿìÙ ÿìÙYÿ×ÙZÿ×Ù[ÿ×Ù\ÿ×Ù]ÿìÙ¿ÿ×Ù7ÿ×Ù<ÿìÙ>ÿìÙ@ÿìÙûÿ×Ùýÿ×ÙÿìÙ ÿìÙpÿ×Ú-{ÛÿìÛ ÿìÛYÿ×ÛZÿ×Û[ÿ×Û\ÿ×Û]ÿìÛ¿ÿ×Û7ÿ×Û<ÿìÛ>ÿìÛ@ÿìÛûÿ×Ûýÿ×ÛÿìÛ ÿìÛpÿ×Ü-{ÝÿìÝ ÿìÝYÿ×ÝZÿ×Ý[ÿ×Ý\ÿ×Ý]ÿìÝ¿ÿ×Ý7ÿ×Ý<ÿìÝ>ÿìÝ@ÿìÝûÿ×Ýýÿ×ÝÿìÝ ÿìÝpÿ×çÿìç ÿìçÿìç ÿìø&ÿ×ø*ÿ×ø2ÿ×ø4ÿ×ø‰ÿ×ø”ÿ×ø•ÿ×ø–ÿ×ø—ÿ×ø˜ÿ×øšÿ×øÈÿ×øÊÿ×øÌÿ×øÎÿ×øÞÿ×øàÿ×øâÿ×øäÿ×øÿ×øÿ×øÿ×øÿ×øGÿ×ø_ÿ×øIÿ×øKÿ×øMÿ×øOÿ×øQÿ×øSÿ×øUÿ×øWÿ×øYÿ×ø[ÿ×ø]ÿ×ø_ÿ×ùFÿ×ùGÿ×ùHÿ×ùRÿ×ùTÿ×ù¢ÿ×ù©ÿ×ùªÿ×ù«ÿ×ù¬ÿ×ù­ÿ×ù´ÿ×ùµÿ×ù¶ÿ×ù·ÿ×ù¸ÿ×ùºÿ×ùÉÿ×ùËÿ×ùÍÿ×ùÏÿ×ùÑÿ×ùÓÿ×ùÕÿ×ù×ÿ×ùÙÿ×ùÛÿ×ùÝÿ×ùÿ×ùÿ×ùÿ×ùÿ×ùHÿ×ù`ÿ×ù6ÿ×ù8ÿ×ù:ÿ×ù<ÿ×ù@ÿ×ùBÿ×ùDÿ×ùJÿ×ùLÿ×ùNÿ×ùRÿ×ùTÿ×ùVÿ×ùXÿ×ùZÿ×ù\ÿ×ù^ÿ×ù`ÿ×úFÿ×úGÿ×úHÿ×úRÿ×úTÿ×ú¢ÿ×ú©ÿ×úªÿ×ú«ÿ×ú¬ÿ×ú­ÿ×ú´ÿ×úµÿ×ú¶ÿ×ú·ÿ×ú¸ÿ×úºÿ×úÉÿ×úËÿ×úÍÿ×úÏÿ×úÑÿ×úÓÿ×úÕÿ×ú×ÿ×úÙÿ×úÛÿ×úÝÿ×úÿ×úÿ×úÿ×úÿ×úHÿ×ú`ÿ×ú6ÿ×ú8ÿ×ú:ÿ×ú<ÿ×ú@ÿ×úBÿ×úDÿ×úJÿ×úLÿ×úNÿ×úRÿ×úTÿ×úVÿ×úXÿ×úZÿ×ú\ÿ×ú^ÿ×ú`ÿ×ûÿ\û ÿ\û&ÿ×û*ÿ×û2ÿ×û4ÿ×û7ÿ×û8ÿìû9ÿ×û:ÿ×û<ÿÃû‰ÿ×û”ÿ×û•ÿ×û–ÿ×û—ÿ×û˜ÿ×ûšÿ×û›ÿìûœÿìûÿìûžÿìûŸÿÃûÈÿ×ûÊÿ×ûÌÿ×ûÎÿ×ûÞÿ×ûàÿ×ûâÿ×ûäÿ×ûÿ×ûÿ×ûÿ×ûÿ×û$ÿ×û&ÿ×û*ÿìû,ÿìû.ÿìû0ÿìû2ÿìû4ÿìû6ÿ×û8ÿÃû:ÿÃûGÿ×ûúÿ×ûüÿ×ûþÿ×ûÿÃûÿ\û ÿ\û_ÿ×ûaÿìûIÿ×ûKÿ×ûMÿ×ûOÿ×ûQÿ×ûSÿ×ûUÿ×ûWÿ×ûYÿ×û[ÿ×û]ÿ×û_ÿ×ûaÿìûcÿìûeÿìûgÿìûiÿìûkÿìûmÿìûoÿÃûqÿÃûsÿÃûÿ×ýÿ\ý ÿ\ý&ÿ×ý*ÿ×ý2ÿ×ý4ÿ×ý7ÿ×ý8ÿìý9ÿ×ý:ÿ×ý<ÿÃý‰ÿ×ý”ÿ×ý•ÿ×ý–ÿ×ý—ÿ×ý˜ÿ×ýšÿ×ý›ÿìýœÿìýÿìýžÿìýŸÿÃýÈÿ×ýÊÿ×ýÌÿ×ýÎÿ×ýÞÿ×ýàÿ×ýâÿ×ýäÿ×ýÿ×ýÿ×ýÿ×ýÿ×ý$ÿ×ý&ÿ×ý*ÿìý,ÿìý.ÿìý0ÿìý2ÿìý4ÿìý6ÿ×ý8ÿÃý:ÿÃýGÿ×ýúÿ×ýüÿ×ýþÿ×ýÿÃýÿ\ý ÿ\ý_ÿ×ýaÿìýIÿ×ýKÿ×ýMÿ×ýOÿ×ýQÿ×ýSÿ×ýUÿ×ýWÿ×ýYÿ×ý[ÿ×ý]ÿ×ý_ÿ×ýaÿìýcÿìýeÿìýgÿìýiÿìýkÿìýmÿìýoÿÃýqÿÃýsÿÃýÿ×ÿÿ\ÿ ÿ\ÿ&ÿ×ÿ*ÿ×ÿ2ÿ×ÿ4ÿ×ÿ7ÿ×ÿ8ÿìÿ9ÿ×ÿ:ÿ×ÿ<ÿÃÿ‰ÿ×ÿ”ÿ×ÿ•ÿ×ÿ–ÿ×ÿ—ÿ×ÿ˜ÿ×ÿšÿ×ÿ›ÿìÿœÿìÿÿìÿžÿìÿŸÿÃÿÈÿ×ÿÊÿ×ÿÌÿ×ÿÎÿ×ÿÞÿ×ÿàÿ×ÿâÿ×ÿäÿ×ÿÿ×ÿÿ×ÿÿ×ÿÿ×ÿ$ÿ×ÿ&ÿ×ÿ*ÿìÿ,ÿìÿ.ÿìÿ0ÿìÿ2ÿìÿ4ÿìÿ6ÿ×ÿ8ÿÃÿ:ÿÃÿGÿ×ÿúÿ×ÿüÿ×ÿþÿ×ÿÿÃÿÿ\ÿ ÿ\ÿ_ÿ×ÿaÿìÿIÿ×ÿKÿ×ÿMÿ×ÿOÿ×ÿQÿ×ÿSÿ×ÿUÿ×ÿWÿ×ÿYÿ×ÿ[ÿ×ÿ]ÿ×ÿ_ÿ×ÿaÿìÿcÿìÿeÿìÿgÿìÿiÿìÿkÿìÿmÿìÿoÿÃÿqÿÃÿsÿÃÿÿ×R R "@E=K=N=O=`ç=éR Rÿ\ ÿ\&ÿ×*ÿ×2ÿ×4ÿ×7ÿ×8ÿì9ÿ×:ÿ×<ÿÉÿ×”ÿוÿ×–ÿ×—ÿטÿךÿ×›ÿìœÿìÿìžÿìŸÿÃÈÿ×Êÿ×Ìÿ×Îÿ×Þÿ×àÿ×âÿ×äÿ×ÿ×ÿ×ÿ×ÿ×$ÿ×&ÿ×*ÿì,ÿì.ÿì0ÿì2ÿì4ÿì6ÿ×8ÿÃ:ÿÃGÿ×úÿ×üÿ×þÿ×ÿÃÿ\ ÿ\_ÿ×aÿìIÿ×Kÿ×Mÿ×Oÿ×Qÿ×Sÿ×Uÿ×Wÿ×Yÿ×[ÿ×]ÿ×_ÿ×aÿìcÿìeÿìgÿìiÿìkÿìmÿìoÿÃqÿÃsÿÃÿ×ÿ\ ÿ\&ÿ×*ÿ×2ÿ×4ÿ×7ÿ×8ÿì9ÿ×:ÿ×<ÿÉÿ×”ÿוÿ×–ÿ×—ÿטÿךÿ×›ÿìœÿìÿìžÿìŸÿÃÈÿ×Êÿ×Ìÿ×Îÿ×Þÿ×àÿ×âÿ×äÿ×ÿ×ÿ×ÿ×ÿ×$ÿ×&ÿ×*ÿì,ÿì.ÿì0ÿì2ÿì4ÿì6ÿ×8ÿÃ:ÿÃGÿ×úÿ×üÿ×þÿ×ÿÃÿ\ ÿ\_ÿ×aÿìIÿ×Kÿ×Mÿ×Oÿ×Qÿ×Sÿ×Uÿ×Wÿ×Yÿ×[ÿ×]ÿ×_ÿ×aÿìcÿìeÿìgÿìiÿìkÿìmÿìoÿÃqÿÃsÿÃÿ×ÿì ÿìÿì ÿìÿ®ÿ®$ÿ×7ÿÃ9ÿì:ÿì;ÿ×<ÿì=ÿì‚ÿ׃ÿׄÿ×…ÿ׆ÿׇÿןÿìÂÿ×Äÿ×Æÿ×$ÿÃ&ÿÃ6ÿì8ÿì:ÿì;ÿì=ÿì?ÿìCÿ× ÿìúÿìüÿìþÿìÿìÿ® ÿ®Xÿ×ÿ×ÿ×!ÿ×#ÿ×%ÿ×'ÿ×)ÿ×+ÿ×-ÿ×/ÿ×1ÿ×3ÿ×oÿìqÿìsÿìÿÃÿ®ÿ®$ÿ×7ÿÃ9ÿì:ÿì;ÿ×<ÿì=ÿì‚ÿ׃ÿׄÿ×…ÿ׆ÿׇÿןÿìÂÿ×Äÿ×Æÿ×$ÿÃ&ÿÃ6ÿì8ÿì:ÿì;ÿì=ÿì?ÿìCÿ× ÿìúÿìüÿìþÿìÿìÿ® ÿ®Xÿ×ÿ×ÿ×!ÿ×#ÿ×%ÿ×'ÿ×)ÿ×+ÿ×-ÿ×/ÿ×1ÿ×3ÿ×oÿìqÿìsÿìÿÃÿ®ÿ®$ÿ×7ÿÃ9ÿì:ÿì;ÿ×<ÿì=ÿì‚ÿ׃ÿׄÿ×…ÿ׆ÿׇÿןÿìÂÿ×Äÿ×Æÿ×$ÿÃ&ÿÃ6ÿì8ÿì:ÿì;ÿì=ÿì?ÿìCÿ× ÿìúÿìüÿìþÿìÿìÿ® ÿ®Xÿ×ÿ×ÿ×!ÿ×#ÿ×%ÿ×'ÿ×)ÿ×+ÿ×-ÿ×/ÿ×1ÿ×3ÿ×oÿìqÿìsÿìÿÃ-{R RDÿ×Fÿ×Gÿ×Hÿ×JÿìRÿ×Tÿ×¢ÿ×£ÿפÿ×¥ÿצÿקÿרÿשÿתÿ׫ÿ׬ÿ×­ÿ×´ÿ×µÿ׶ÿ×·ÿ׸ÿ׺ÿ×Ãÿ×Åÿ×Çÿ×Éÿ×Ëÿ×Íÿ×Ïÿ×Ñÿ×Óÿ×Õÿ××ÿ×Ùÿ×Ûÿ×Ýÿ×ßÿìáÿìãÿìåÿìÿ×ÿ×ÿ×ÿ×Dÿ×Fÿ×Hÿ×R RYÿ×`ÿ×ÿ× ÿ×"ÿ×&ÿ×(ÿ×*ÿ×,ÿ×.ÿ×0ÿ×2ÿ×4ÿ×6ÿ×8ÿ×:ÿ×<ÿ×@ÿ×Bÿ×Dÿ×Jÿ×Lÿ×Nÿ×Rÿ×Tÿ×Vÿ×Xÿ×Zÿ×\ÿ×^ÿ×`ÿ×R RDÿ×Fÿ×Gÿ×Hÿ×JÿìRÿ×Tÿ×¢ÿ×£ÿפÿ×¥ÿצÿקÿרÿשÿתÿ׫ÿ׬ÿ×­ÿ×´ÿ×µÿ׶ÿ×·ÿ׸ÿ׺ÿ×Ãÿ×Åÿ×Çÿ×Éÿ×Ëÿ×Íÿ×Ïÿ×Ñÿ×Óÿ×Õÿ××ÿ×Ùÿ×Ûÿ×Ýÿ×ßÿìáÿìãÿìåÿìÿ×ÿ×ÿ×ÿ×Dÿ×Fÿ×Hÿ×R RYÿ×`ÿ×ÿ× ÿ×"ÿ×&ÿ×(ÿ×*ÿ×,ÿ×.ÿ×0ÿ×2ÿ×4ÿ×6ÿ×8ÿ×:ÿ×<ÿ×@ÿ×Bÿ×Dÿ×Jÿ×Lÿ×Nÿ×Rÿ×Tÿ×Vÿ×Xÿ×Zÿ×\ÿ×^ÿ×`ÿ×R RDÿ×Fÿ×Gÿ×Hÿ×JÿìRÿ×Tÿ×¢ÿ×£ÿפÿ×¥ÿצÿקÿרÿשÿתÿ׫ÿ׬ÿ×­ÿ×´ÿ×µÿ׶ÿ×·ÿ׸ÿ׺ÿ×Ãÿ×Åÿ×Çÿ×Éÿ×Ëÿ×Íÿ×Ïÿ×Ñÿ×Óÿ×Õÿ××ÿ×Ùÿ×Ûÿ×Ýÿ×ßÿìáÿìãÿìåÿìÿ×ÿ×ÿ×ÿ×Dÿ×Fÿ×Hÿ×R RYÿ×`ÿ×ÿ× ÿ×"ÿ×&ÿ×(ÿ×*ÿ×,ÿ×.ÿ×0ÿ×2ÿ×4ÿ×6ÿ×8ÿ×:ÿ×<ÿ×@ÿ×Bÿ×Dÿ×Jÿ×Lÿ×Nÿ×Rÿ×Tÿ×Vÿ×Xÿ×Zÿ×\ÿ×^ÿ×`ÿ×$ÿ…$ÿ®$ÿ…$")$$ÿq$&ÿ×$*ÿ×$2ÿ×$4ÿ×$7)$Dÿ\$Fÿq$Gÿq$Hÿq$Jÿq$Pÿš$Qÿš$Rÿq$Sÿš$Tÿq$Uÿš$Vÿ…$Xÿš$Yÿ×$Zÿ×$[ÿ×$\ÿ×$]ÿ®$‚ÿq$ƒÿq$„ÿq$…ÿq$†ÿq$‡ÿq$‰ÿ×$”ÿ×$•ÿ×$–ÿ×$—ÿ×$˜ÿ×$šÿ×$¢ÿq$£ÿ\$¤ÿ\$¥ÿ\$¦ÿ\$§ÿ\$¨ÿ\$©ÿq$ªÿq$«ÿq$¬ÿq$­ÿq$´ÿq$µÿq$¶ÿq$·ÿq$¸ÿq$ºÿq$»ÿš$¼ÿš$½ÿš$¾ÿš$¿ÿ×$Âÿq$Ãÿ\$Äÿq$Åÿ\$Æÿq$Çÿ\$Èÿ×$Éÿq$Êÿ×$Ëÿq$Ìÿ×$Íÿq$Îÿ×$Ïÿq$Ñÿq$Óÿq$Õÿq$×ÿq$Ùÿq$Ûÿq$Ýÿq$Þÿ×$ßÿq$àÿ×$áÿq$âÿ×$ãÿq$äÿ×$åÿq$úÿš$ÿš$ÿš$ ÿš$ÿ×$ÿq$ÿ×$ÿq$ÿ×$ÿq$ÿ×$ÿq$ÿš$ÿš$ÿ…$!ÿ…$$)$&)$+ÿš$-ÿš$/ÿš$1ÿš$3ÿš$5ÿš$7ÿ×$<ÿ®$>ÿ®$@ÿ®$Cÿq$Dÿ\$Fÿ\$Gÿ×$Hÿq$Jÿ…$ûÿ×$ýÿ×$ÿ®$ÿ®$ÿ®$ÿ…$ ÿ…$Wÿš$Xÿq$Yÿ\$_ÿ×$`ÿq$bÿš$ÿq$ÿ\$ÿq$ ÿ\$!ÿq$"ÿ\$#ÿq$%ÿq$&ÿ\$'ÿq$(ÿ\$)ÿq$*ÿ\$+ÿq$,ÿ\$-ÿq$.ÿ\$/ÿq$0ÿ\$1ÿq$2ÿ\$3ÿq$4ÿ\$6ÿq$8ÿq$:ÿq$<ÿq$@ÿq$Bÿq$Dÿq$Iÿ×$Jÿq$Kÿ×$Lÿq$Mÿ×$Nÿq$Oÿ×$Qÿ×$Rÿq$Sÿ×$Tÿq$Uÿ×$Vÿq$Wÿ×$Xÿq$Yÿ×$Zÿq$[ÿ×$\ÿq$]ÿ×$^ÿq$_ÿ×$`ÿq$bÿš$dÿš$fÿš$hÿš$jÿš$lÿš$nÿš$pÿ×$)%)% )%)% )&ÿ…&ÿ®&ÿ…&")&$ÿq&&ÿ×&*ÿ×&2ÿ×&4ÿ×&7)&Dÿ\&Fÿq&Gÿq&Hÿq&Jÿq&Pÿš&Qÿš&Rÿq&Sÿš&Tÿq&Uÿš&Vÿ…&Xÿš&Yÿ×&Zÿ×&[ÿ×&\ÿ×&]ÿ®&‚ÿq&ƒÿq&„ÿq&…ÿq&†ÿq&‡ÿq&‰ÿ×&”ÿ×&•ÿ×&–ÿ×&—ÿ×&˜ÿ×&šÿ×&¢ÿq&£ÿ\&¤ÿ\&¥ÿ\&¦ÿ\&§ÿ\&¨ÿ\&©ÿq&ªÿq&«ÿq&¬ÿq&­ÿq&´ÿq&µÿq&¶ÿq&·ÿq&¸ÿq&ºÿq&»ÿš&¼ÿš&½ÿš&¾ÿš&¿ÿ×&Âÿq&Ãÿ\&Äÿq&Åÿ\&Æÿq&Çÿ\&Èÿ×&Éÿq&Êÿ×&Ëÿq&Ìÿ×&Íÿq&Îÿ×&Ïÿq&Ñÿq&Óÿq&Õÿq&×ÿq&Ùÿq&Ûÿq&Ýÿq&Þÿ×&ßÿq&àÿ×&áÿq&âÿ×&ãÿq&äÿ×&åÿq&úÿš&ÿš&ÿš& ÿš&ÿ×&ÿq&ÿ×&ÿq&ÿ×&ÿq&ÿ×&ÿq&ÿš&ÿš&ÿ…&!ÿ…&$)&&)&+ÿš&-ÿš&/ÿš&1ÿš&3ÿš&5ÿš&7ÿ×&<ÿ®&>ÿ®&@ÿ®&Cÿq&Dÿ\&Fÿ\&Gÿ×&Hÿq&Jÿ…&ûÿ×&ýÿ×&ÿ®&ÿ®&ÿ®&ÿ…& ÿ…&Wÿš&Xÿq&Yÿ\&_ÿ×&`ÿq&bÿš&ÿq&ÿ\&ÿq& ÿ\&!ÿq&"ÿ\&#ÿq&%ÿq&&ÿ\&'ÿq&(ÿ\&)ÿq&*ÿ\&+ÿq&,ÿ\&-ÿq&.ÿ\&/ÿq&0ÿ\&1ÿq&2ÿ\&3ÿq&4ÿ\&6ÿq&8ÿq&:ÿq&<ÿq&@ÿq&Bÿq&Dÿq&Iÿ×&Jÿq&Kÿ×&Lÿq&Mÿ×&Nÿq&Oÿ×&Qÿ×&Rÿq&Sÿ×&Tÿq&Uÿ×&Vÿq&Wÿ×&Xÿq&Yÿ×&Zÿq&[ÿ×&\ÿq&]ÿ×&^ÿq&_ÿ×&`ÿq&bÿš&dÿš&fÿš&hÿš&jÿš&lÿš&nÿš&pÿ×&)')' )')' )(ÿ…(ÿ®(ÿ…(")($ÿq(&ÿ×(*ÿ×(2ÿ×(4ÿ×(7)(Dÿ\(Fÿq(Gÿq(Hÿq(Jÿq(Pÿš(Qÿš(Rÿq(Sÿš(Tÿq(Uÿš(Vÿ…(Xÿš(Yÿ×(Zÿ×([ÿ×(\ÿ×(]ÿ®(‚ÿq(ƒÿq(„ÿq(…ÿq(†ÿq(‡ÿq(‰ÿ×(”ÿ×(•ÿ×(–ÿ×(—ÿ×(˜ÿ×(šÿ×(¢ÿq(£ÿ\(¤ÿ\(¥ÿ\(¦ÿ\(§ÿ\(¨ÿ\(©ÿq(ªÿq(«ÿq(¬ÿq(­ÿq(´ÿq(µÿq(¶ÿq(·ÿq(¸ÿq(ºÿq(»ÿš(¼ÿš(½ÿš(¾ÿš(¿ÿ×(Âÿq(Ãÿ\(Äÿq(Åÿ\(Æÿq(Çÿ\(Èÿ×(Éÿq(Êÿ×(Ëÿq(Ìÿ×(Íÿq(Îÿ×(Ïÿq(Ñÿq(Óÿq(Õÿq(×ÿq(Ùÿq(Ûÿq(Ýÿq(Þÿ×(ßÿq(àÿ×(áÿq(âÿ×(ãÿq(äÿ×(åÿq(úÿš(ÿš(ÿš( ÿš(ÿ×(ÿq(ÿ×(ÿq(ÿ×(ÿq(ÿ×(ÿq(ÿš(ÿš(ÿ…(!ÿ…($)(&)(+ÿš(-ÿš(/ÿš(1ÿš(3ÿš(5ÿš(7ÿ×(<ÿ®(>ÿ®(@ÿ®(Cÿq(Dÿ\(Fÿ\(Gÿ×(Hÿq(Jÿ…(ûÿ×(ýÿ×(ÿ®(ÿ®(ÿ®(ÿ…( ÿ…(Wÿš(Xÿq(Yÿ\(_ÿ×(`ÿq(bÿš(ÿq(ÿ\(ÿq( ÿ\(!ÿq("ÿ\(#ÿq(%ÿq(&ÿ\('ÿq((ÿ\()ÿq(*ÿ\(+ÿq(,ÿ\(-ÿq(.ÿ\(/ÿq(0ÿ\(1ÿq(2ÿ\(3ÿq(4ÿ\(6ÿq(8ÿq(:ÿq(<ÿq(@ÿq(Bÿq(Dÿq(Iÿ×(Jÿq(Kÿ×(Lÿq(Mÿ×(Nÿq(Oÿ×(Qÿ×(Rÿq(Sÿ×(Tÿq(Uÿ×(Vÿq(Wÿ×(Xÿq(Yÿ×(Zÿq([ÿ×(\ÿq(]ÿ×(^ÿq(_ÿ×(`ÿq(bÿš(dÿš(fÿš(hÿš(jÿš(lÿš(nÿš(pÿ×()*ÿ×*ÿ×*$ÿì*‚ÿì*ƒÿì*„ÿì*…ÿì*†ÿì*‡ÿì*Âÿì*Äÿì*Æÿì*Cÿì*ÿ×* ÿ×*Xÿì*ÿì*ÿì*!ÿì*#ÿì*%ÿì*'ÿì*)ÿì*+ÿì*-ÿì*/ÿì*1ÿì*3ÿì,ÿ×,ÿ×,$ÿì,‚ÿì,ƒÿì,„ÿì,…ÿì,†ÿì,‡ÿì,Âÿì,Äÿì,Æÿì,Cÿì,ÿ×, ÿ×,Xÿì,ÿì,ÿì,!ÿì,#ÿì,%ÿì,'ÿì,)ÿì,+ÿì,-ÿì,/ÿì,1ÿì,3ÿì.ÿ×.ÿ×.$ÿì.‚ÿì.ƒÿì.„ÿì.…ÿì.†ÿì.‡ÿì.Âÿì.Äÿì.Æÿì.Cÿì.ÿ×. ÿ×.Xÿì.ÿì.ÿì.!ÿì.#ÿì.%ÿì.'ÿì.)ÿì.+ÿì.-ÿì./ÿì.1ÿì.3ÿì0ÿ×0ÿ×0$ÿì0‚ÿì0ƒÿì0„ÿì0…ÿì0†ÿì0‡ÿì0Âÿì0Äÿì0Æÿì0Cÿì0ÿ×0 ÿ×0Xÿì0ÿì0ÿì0!ÿì0#ÿì0%ÿì0'ÿì0)ÿì0+ÿì0-ÿì0/ÿì01ÿì03ÿì2ÿ×2ÿ×2$ÿì2‚ÿì2ƒÿì2„ÿì2…ÿì2†ÿì2‡ÿì2Âÿì2Äÿì2Æÿì2Cÿì2ÿ×2 ÿ×2Xÿì2ÿì2ÿì2!ÿì2#ÿì2%ÿì2'ÿì2)ÿì2+ÿì2-ÿì2/ÿì21ÿì23ÿì4ÿ×4ÿ×4$ÿì4‚ÿì4ƒÿì4„ÿì4…ÿì4†ÿì4‡ÿì4Âÿì4Äÿì4Æÿì4Cÿì4ÿ×4 ÿ×4Xÿì4ÿì4ÿì4!ÿì4#ÿì4%ÿì4'ÿì4)ÿì4+ÿì4-ÿì4/ÿì41ÿì43ÿì6ÿš6ÿš6")6$ÿ®6&ÿì6*ÿì62ÿì64ÿì6Dÿ×6Fÿ×6Gÿ×6Hÿ×6Jÿì6Pÿì6Qÿì6Rÿ×6Sÿì6Tÿ×6Uÿì6Vÿì6Xÿì6‚ÿ®6ƒÿ®6„ÿ®6…ÿ®6†ÿ®6‡ÿ®6‰ÿì6”ÿì6•ÿì6–ÿì6—ÿì6˜ÿì6šÿì6¢ÿ×6£ÿ×6¤ÿ×6¥ÿ×6¦ÿ×6§ÿ×6¨ÿ×6©ÿ×6ªÿ×6«ÿ×6¬ÿ×6­ÿ×6´ÿ×6µÿ×6¶ÿ×6·ÿ×6¸ÿ×6ºÿ×6»ÿì6¼ÿì6½ÿì6¾ÿì6Âÿ®6Ãÿ×6Äÿ®6Åÿ×6Æÿ®6Çÿ×6Èÿì6Éÿ×6Êÿì6Ëÿ×6Ìÿì6Íÿ×6Îÿì6Ïÿ×6Ñÿ×6Óÿ×6Õÿ×6×ÿ×6Ùÿ×6Ûÿ×6Ýÿ×6Þÿì6ßÿì6àÿì6áÿì6âÿì6ãÿì6äÿì6åÿì6úÿì6ÿì6ÿì6 ÿì6ÿì6ÿ×6ÿì6ÿ×6ÿì6ÿ×6ÿì6ÿ×6ÿì6ÿì6ÿì6!ÿì6+ÿì6-ÿì6/ÿì61ÿì63ÿì65ÿì6Cÿ®6Dÿ×6Fÿ×6Gÿì6Hÿ×6Jÿì6ÿš6 ÿš6Wÿì6Xÿ®6Yÿ×6_ÿì6`ÿ×6bÿì6ÿ®6ÿ×6ÿ®6 ÿ×6!ÿ®6"ÿ×6#ÿ®6%ÿ®6&ÿ×6'ÿ®6(ÿ×6)ÿ®6*ÿ×6+ÿ®6,ÿ×6-ÿ®6.ÿ×6/ÿ®60ÿ×61ÿ®62ÿ×63ÿ®64ÿ×66ÿ×68ÿ×6:ÿ×6<ÿ×6@ÿ×6Bÿ×6Dÿ×6Iÿì6Jÿ×6Kÿì6Lÿ×6Mÿì6Nÿ×6Oÿì6Qÿì6Rÿ×6Sÿì6Tÿ×6Uÿì6Vÿ×6Wÿì6Xÿ×6Yÿì6Zÿ×6[ÿì6\ÿ×6]ÿì6^ÿ×6_ÿì6`ÿ×6bÿì6dÿì6fÿì6hÿì6jÿì6lÿì6nÿì7R7 R7ÿ®7ÿ®7")7R7ÿ®7 R7 ÿ®8ÿ…8ÿ…8")8$ÿ…8&ÿ×8*ÿ×82ÿ×84ÿ×8Dÿš8Fÿš8Gÿš8Hÿš8Jÿ×8PÿÃ8QÿÃ8Rÿš8SÿÃ8Tÿš8UÿÃ8Vÿ®8XÿÃ8]ÿ×8‚ÿ…8ƒÿ…8„ÿ…8…ÿ…8†ÿ…8‡ÿ…8‰ÿ×8”ÿ×8•ÿ×8–ÿ×8—ÿ×8˜ÿ×8šÿ×8¢ÿš8£ÿš8¤ÿš8¥ÿš8¦ÿš8§ÿš8¨ÿš8©ÿš8ªÿš8«ÿš8¬ÿš8­ÿš8´ÿš8µÿš8¶ÿš8·ÿš8¸ÿš8ºÿš8»ÿÃ8¼ÿÃ8½ÿÃ8¾ÿÃ8Âÿ…8Ãÿš8Äÿ…8Åÿš8Æÿ…8Çÿš8Èÿ×8Éÿš8Êÿ×8Ëÿš8Ìÿ×8Íÿš8Îÿ×8Ïÿš8Ñÿš8Óÿš8Õÿš8×ÿš8Ùÿš8Ûÿš8Ýÿš8Þÿ×8ßÿ×8àÿ×8áÿ×8âÿ×8ãÿ×8äÿ×8åÿ×8úÿÃ8ÿÃ8ÿÃ8 ÿÃ8ÿ×8ÿš8ÿ×8ÿš8ÿ×8ÿš8ÿ×8ÿš8ÿÃ8ÿÃ8ÿ®8!ÿ®8+ÿÃ8-ÿÃ8/ÿÃ81ÿÃ83ÿÃ85ÿÃ8<ÿ×8>ÿ×8@ÿ×8Cÿ…8Dÿš8Fÿš8Gÿ×8Hÿš8Jÿ®8ÿ…8 ÿ…8WÿÃ8Xÿ…8Yÿš8_ÿ×8`ÿš8bÿÃ8ÿ…8ÿš8ÿ…8 ÿš8!ÿ…8"ÿš8#ÿ…8%ÿ…8&ÿš8'ÿ…8(ÿš8)ÿ…8*ÿš8+ÿ…8,ÿš8-ÿ…8.ÿš8/ÿ…80ÿš81ÿ…82ÿš83ÿ…84ÿš86ÿš88ÿš8:ÿš8<ÿš8@ÿš8Bÿš8Dÿš8Iÿ×8Jÿš8Kÿ×8Lÿš8Mÿ×8Nÿš8Oÿ×8Qÿ×8Rÿš8Sÿ×8Tÿš8Uÿ×8Vÿš8Wÿ×8Xÿš8Yÿ×8Zÿš8[ÿ×8\ÿš8]ÿ×8^ÿš8_ÿ×8`ÿš8bÿÃ8dÿÃ8fÿÃ8hÿÃ8jÿÃ8lÿÃ8nÿÃ9R9 R9ÿ®9ÿ®9")9R9ÿ®9 R9 ÿ®:ÿ…:ÿ…:"):$ÿ…:&ÿ×:*ÿ×:2ÿ×:4ÿ×:Dÿš:Fÿš:Gÿš:Hÿš:Jÿ×:PÿÃ:QÿÃ:Rÿš:SÿÃ:Tÿš:UÿÃ:Vÿ®:XÿÃ:]ÿ×:‚ÿ…:ƒÿ…:„ÿ…:…ÿ…:†ÿ…:‡ÿ…:‰ÿ×:”ÿ×:•ÿ×:–ÿ×:—ÿ×:˜ÿ×:šÿ×:¢ÿš:£ÿš:¤ÿš:¥ÿš:¦ÿš:§ÿš:¨ÿš:©ÿš:ªÿš:«ÿš:¬ÿš:­ÿš:´ÿš:µÿš:¶ÿš:·ÿš:¸ÿš:ºÿš:»ÿÃ:¼ÿÃ:½ÿÃ:¾ÿÃ:Âÿ…:Ãÿš:Äÿ…:Åÿš:Æÿ…:Çÿš:Èÿ×:Éÿš:Êÿ×:Ëÿš:Ìÿ×:Íÿš:Îÿ×:Ïÿš:Ñÿš:Óÿš:Õÿš:×ÿš:Ùÿš:Ûÿš:Ýÿš:Þÿ×:ßÿ×:àÿ×:áÿ×:âÿ×:ãÿ×:äÿ×:åÿ×:úÿÃ:ÿÃ:ÿÃ: ÿÃ:ÿ×:ÿš:ÿ×:ÿš:ÿ×:ÿš:ÿ×:ÿš:ÿÃ:ÿÃ:ÿ®:!ÿ®:+ÿÃ:-ÿÃ:/ÿÃ:1ÿÃ:3ÿÃ:5ÿÃ:<ÿ×:>ÿ×:@ÿ×:Cÿ…:Dÿš:Fÿš:Gÿ×:Hÿš:Jÿ®:ÿ…: ÿ…:WÿÃ:Xÿ…:Yÿš:_ÿ×:`ÿš:bÿÃ:ÿ…:ÿš:ÿ…: ÿš:!ÿ…:"ÿš:#ÿ…:%ÿ…:&ÿš:'ÿ…:(ÿš:)ÿ…:*ÿš:+ÿ…:,ÿš:-ÿ…:.ÿš:/ÿ…:0ÿš:1ÿ…:2ÿš:3ÿ…:4ÿš:6ÿš:8ÿš::ÿš:<ÿš:@ÿš:Bÿš:Dÿš:Iÿ×:Jÿš:Kÿ×:Lÿš:Mÿ×:Nÿš:Oÿ×:Qÿ×:Rÿš:Sÿ×:Tÿš:Uÿ×:Vÿš:Wÿ×:Xÿš:Yÿ×:Zÿš:[ÿ×:\ÿš:]ÿ×:^ÿš:_ÿ×:`ÿš:bÿÃ:dÿÃ:fÿÃ:hÿÃ:jÿÃ:lÿÃ:nÿÃ;&ÿì;*ÿì;2ÿì;4ÿì;‰ÿì;”ÿì;•ÿì;–ÿì;—ÿì;˜ÿì;šÿì;Èÿì;Êÿì;Ìÿì;Îÿì;Þÿì;àÿì;âÿì;äÿì;ÿì;ÿì;ÿì;ÿì;Gÿì;_ÿì;Iÿì;Kÿì;Mÿì;Oÿì;Qÿì;Sÿì;Uÿì;Wÿì;Yÿì;[ÿì;]ÿì;_ÿì=&ÿì=*ÿì=2ÿì=4ÿì=‰ÿì=”ÿì=•ÿì=–ÿì=—ÿì=˜ÿì=šÿì=Èÿì=Êÿì=Ìÿì=Îÿì=Þÿì=àÿì=âÿì=äÿì=ÿì=ÿì=ÿì=ÿì=Gÿì=_ÿì=Iÿì=Kÿì=Mÿì=Oÿì=Qÿì=Sÿì=Uÿì=Wÿì=Yÿì=[ÿì=]ÿì=_ÿì?&ÿì?*ÿì?2ÿì?4ÿì?‰ÿì?”ÿì?•ÿì?–ÿì?—ÿì?˜ÿì?šÿì?Èÿì?Êÿì?Ìÿì?Îÿì?Þÿì?àÿì?âÿì?äÿì?ÿì?ÿì?ÿì?ÿì?Gÿì?_ÿì?Iÿì?Kÿì?Mÿì?Oÿì?Qÿì?Sÿì?Uÿì?Wÿì?Yÿì?[ÿì?]ÿì?_ÿìCÿqC ÿqC&ÿ×C*ÿ×C- C2ÿ×C4ÿ×C7ÿqC9ÿ®C:ÿ®C<ÿ…C‰ÿ×C”ÿ×C•ÿ×C–ÿ×C—ÿ×C˜ÿ×Cšÿ×CŸÿ…CÈÿ×CÊÿ×CÌÿ×CÎÿ×CÞÿ×Càÿ×Câÿ×Cäÿ×Cÿ×Cÿ×Cÿ×Cÿ×C$ÿqC&ÿqC6ÿ®C8ÿ…C:ÿ…CGÿ×Cúÿ®Cüÿ®Cþÿ®Cÿ…CÿqC ÿqC_ÿ×CIÿ×CKÿ×CMÿ×COÿ×CQÿ×CSÿ×CUÿ×CWÿ×CYÿ×C[ÿ×C]ÿ×C_ÿ×Coÿ…Cqÿ…Csÿ…CÿqDÿìD ÿìDÿìD ÿìE-{Gÿ®Gÿ®G$ÿ×G7ÿÃG9ÿìG:ÿìG;ÿ×G<ÿìG=ÿìG‚ÿ×Gƒÿ×G„ÿ×G…ÿ×G†ÿ×G‡ÿ×GŸÿìGÂÿ×GÄÿ×GÆÿ×G$ÿÃG&ÿÃG6ÿìG8ÿìG:ÿìG;ÿìG=ÿìG?ÿìGCÿ×G ÿìGúÿìGüÿìGþÿìGÿìGÿ®G ÿ®GXÿ×Gÿ×Gÿ×G!ÿ×G#ÿ×G%ÿ×G'ÿ×G)ÿ×G+ÿ×G-ÿ×G/ÿ×G1ÿ×G3ÿ×GoÿìGqÿìGsÿìGÿÃVÿqV ÿqVfÿ×Vmÿ×VqÿqVrÿ…Vsÿ×Vuÿ®Vxÿ…VÿqV ÿqVTÿ…[ÿ®[ÿ®[Vÿ×[_ÿ×[bÿ×[dÿì[iÿ×[pÿì[qÿÃ[rÿì[tÿ×[uÿì[xÿì[ˆÿì[ÿ®[ ÿ®[Tÿì\ÿ…\ÿ…\Vÿ…\_ÿ…\bÿ…\fÿ×\iÿ…\mÿ×\sÿÃ\vÿì\yÿš\zÿ®\{ÿÃ\|ÿÃ\}ÿÃ\~ÿš\ÿÃ\‚ÿ®\„ÿÃ\†ÿÃ\‡ÿÃ\‰ÿÃ\Œÿš\Žÿš\ÿš\ÿš\’ÿÃ\“ÿš\•ÿÃ\–ÿÃ\˜ÿÃ\™ÿš\šÿÃ\›ÿÃ\ÿ…\ ÿ…\!ÿì]qÿ×]rÿì]xÿì]Tÿì^ÿ×^ ÿ×^ÿ×^ ÿ×_ÿq_ ÿq_fÿ×_mÿ×_qÿq_rÿ…_sÿ×_uÿ®_xÿ…_ÿq_ ÿq_Tÿ…`ÿ®`ÿ®`Vÿ×`_ÿ×`bÿ×`iÿ×`tÿ×`ÿ®` ÿ®aÿ…aÿ®aÿ…aVÿ\a_ÿ\abÿ\afÿÃaiÿ\amÿÃasÿšavÿÃayÿqazÿša{ÿša|ÿ®a}ÿša~ÿqa€ÿ×aÿÃa‚ÿša„ÿša†ÿ®a‡ÿša‰ÿšaŠÿ×aŒÿqaŽÿšaÿqaÿqa’ÿša“ÿqa”ÿ×a•ÿša–ÿša˜ÿša™ÿqašÿša›ÿšaÿ®aÿ®aÿ®aÿ…a ÿ…a!ÿÃaSÿ×bÿqb ÿqbfÿ×bmÿ×bqÿqbrÿ…bsÿ×buÿ®bxÿ…bÿqb ÿqbTÿ…dfÿìdmÿìdsÿÃfÿ®fÿ®fVÿ×f_ÿ×fbÿ×fdÿìfiÿ×fpÿìfqÿÃfrÿìftÿ×fuÿìfxÿìfˆÿìfÿ®f ÿ®fTÿìhfÿ×hmÿ×hsÿÃhÿìh‘ÿìiÿqi ÿqifÿ×imÿ×iqÿqirÿ…isÿ×iuÿ®ixÿ…iÿqi ÿqiTÿ…mÿ®mÿ®mVÿ×m_ÿ×mbÿ×mdÿìmiÿ×mpÿìmqÿÃmrÿìmtÿ×muÿìmxÿìmˆÿìmÿ®m ÿ®mTÿìoþöoþöoVÿšo_ÿšobÿšodÿìoiÿšotÿ×oˆÿ×oþöo þöqÿ…qÿ®qÿ…qVÿ\q_ÿ\qbÿ\qfÿÃqiÿ\qmÿÃqsÿšqvÿÃqyÿqqzÿšq{ÿšq|ÿ®q}ÿšq~ÿqq€ÿ×qÿÃq‚ÿšq„ÿšq†ÿ®q‡ÿšq‰ÿšqŠÿ×qŒÿqqŽÿšqÿqqÿqq’ÿšq“ÿqq”ÿ×q•ÿšq–ÿšq˜ÿšq™ÿqqšÿšq›ÿšqÿ®qÿ®qÿ®qÿ…q ÿ…q!ÿÃqSÿ×rÿ…rÿ…rVÿ…r_ÿ…rbÿ…rfÿ×riÿ…rmÿ×rsÿÃrvÿìryÿšrzÿ®r{ÿÃr|ÿÃr}ÿÃr~ÿšrÿÃr‚ÿ®r„ÿÃr†ÿÃr‡ÿÃr‰ÿÃrŒÿšrŽÿšrÿšrÿšr’ÿÃr“ÿšr•ÿÃr–ÿÃr˜ÿÃr™ÿšršÿÃr›ÿÃrÿ…r ÿ…r!ÿìsÿšsÿšsVÿ×s_ÿ×sbÿ×sdÿÃsiÿ×spÿìsqÿ®srÿÃstÿìsxÿÃsˆÿìsÿšs ÿšsTÿÃtfÿ×tmÿ×tsÿÃtÿìt‘ÿìuÿ…uÿ…uVÿ®u_ÿ®ubÿ®ufÿìuiÿ®umÿìuÿ…u ÿ…vqÿ×vrÿìvxÿìvTÿìxÿ…xÿ…xVÿ…x_ÿ…xbÿ…xfÿ×xiÿ…xmÿ×xsÿÃxvÿìxyÿšxzÿ®x{ÿÃx|ÿÃx}ÿÃx~ÿšxÿÃx‚ÿ®x„ÿÃx†ÿÃx‡ÿÃx‰ÿÃxŒÿšxŽÿšxÿšxÿšx’ÿÃx“ÿšx•ÿÃx–ÿÃx˜ÿÃx™ÿšxšÿÃx›ÿÃxÿ…x ÿ…x!ÿìyˆ){ÿì{ ÿì{ÿì{ ÿì|ÿ®| ÿ®|ÿì|‘ÿì|ÿ®| ÿ®~ˆ)€ÿ®€ÿ®€ˆÿì€ÿ®€ ÿ®ƒÿšƒyÿ׃~ÿ׃ÿ׃Œÿ׃ÿ׃ÿ׃ÿ׃‘ÿ׃“ÿ׃™ÿ׃ÿšƒÿšƒÿš„ÿì„ ÿì„ÿì„ ÿì…ÿ×…ÿ×…ÿ×… ÿ׆ÿ®† ÿ®†ÿ솑ÿì†ÿ®† ÿ®‡yÿׇ~ÿׇŒÿׇÿׇÿׇ“ÿׇ™ÿ׈ÿ…ˆ ÿ…ˆyÿìˆ~ÿ숀ÿ׈Šÿ׈Œÿìˆÿ׈ÿìˆÿ숑ÿ׈“ÿ숙ÿìˆÿ…ˆ ÿ…Šÿ®Šÿ®ŠˆÿìŠÿ®Š ÿ®ŒÿìŒ ÿ쌀ÿ׌Šÿ׌ÿìŒ ÿìŽÿìŽ ÿ쎀ÿ׎Šÿ׎ÿìŽ ÿìÿìÿìÿì ÿì“ÿì“ ÿì“€ÿדŠÿדÿì“ ÿì”ÿÔÿ×”ÿÔyÿ×”~ÿ×”ÿ×”Œÿ×”ÿ×”ÿ×”“ÿ×”™ÿ×”ÿ×”ÿ×”ÿ×”ÿÔ ÿ×ÿ×— ÿ×—ÿ×— ÿ×™ÿì™ ÿ와ÿ×™Šÿ×™ÿì™ ÿìÿ® ÿ®ÿ…¦ÿ…¨ÿ×¼ÿš½ÿ×ÁÿšÄÿ…Üÿ×Ýÿ×áÿ×äÿ×öÿ×ÿ® ÿ®nÿ®|ÿš€ÿ®‚ÿ®—ÿ®›ÿ®§ÿ®©ÿ…ªÿ×µÿš¶ÿ×·ÿš¸ÿ×¹ÿšºÿ×½ÿ…¾ÿ׿ÿšÀÿ×ÁÿšÂÿ×ÔÿšÕÿ×÷ÿ×øÿ×ùÿ×úÿ×ûÿ×üÿ×ýÿšþÿ×ÿ® ÿšÿÃÿšÿÃÿ…ÿמÿ…žÿ®žÿ…žŸÿמ¤ÿšžªÿqž®ÿšžµÿšž¸ÿמ»ÿמ¼)ž¾ÿ®žÌÿšžÍÿšžÎÿ…žÏÿqžÐÿמÑÿמÒÿšžÓÿšžÔÿšžÕÿ…žÖÿšž×ÿšžØÿqžÙÿšžÚÿšžÛÿqžÜÿ®žÝÿ®žÞÿqžßÿמàÿšžáÿšžâÿšžãÿšžäÿ®žåÿšžæÿšžçÿמèÿšžéÿÞêÿqžìÿšžíÿqžîÿ…žòÿ…žóÿšžõÿšžöÿ®ž÷ÿšžùÿšžÿ®žÿ®žÿ®žÿ…ž ÿ…žjÿqžkÿšžlÿמmÿמqÿšžrÿqžsÿ…žuÿšžwÿšžyÿšž}ÿšž~ÿמÿqžÿמƒÿמ„ÿמ…ÿqž†ÿמ‡ÿqžˆÿמ‰ÿqžŠÿמ‹ÿמŒÿמÿqž–ÿšžšÿšžžÿšž ÿמ¢ÿמ¤ÿšž¦ÿšžªÿ®ž¬ÿšž®ÿšž°ÿšž±ÿמ²ÿqž³ÿמ´ÿqžµ)ž¶ÿ®ž¸ÿ®žºÿ®ž¼ÿמ¾ÿ®žÀÿšžÂÿšžÄÿšžÅÿšžÆÿqžÇÿšžÈÿqžËÿמÍÿšžÎÿšžÏÿ…žÑÿšžÓÿšžÕÿšž×ÿšžÙÿqžÛÿqžÝÿqžàÿqžæÿמèÿמêÿÞìÿšžîÿšžïÿמðÿqžñÿמòÿqžóÿמôÿqžöÿמøÿ®žúÿ®žüÿ®žþÿšžÿšžÿšžÿמÿמ ÿqž ÿqž ÿqž ÿqžÿšžÿšžÿšžÿ…žÿšžÿמÿqžÿ®žÿqžÿšžÿ…ŸŸÿן¸ÿן»ÿן¾ÿןáÿןlÿן~ÿן„ÿן†ÿןˆÿןŠÿןŒÿן±ÿן³ÿןÀÿןÂÿןÅÿןÇÿןÕÿןïÿןñÿןóÿןþÿן ÿן ÿןÿןÿןÿ× ÿ× ÿפÿ®¤ ÿ®¤ÿ…¤¦ÿ…¤¨ÿפ¼ÿš¤½ÿפÁÿš¤Äÿ…¤ÜÿפÝÿפáÿפäÿפöÿפÿ®¤ ÿ®¤nÿ®¤|ÿš¤€ÿ®¤‚ÿ®¤—ÿ®¤›ÿ®¤§ÿ®¤©ÿ…¤ªÿפµÿš¤¶ÿפ·ÿš¤¸ÿפ¹ÿš¤ºÿפ½ÿ…¤¾ÿפ¿ÿš¤ÀÿפÁÿš¤ÂÿפÔÿš¤Õÿפ÷ÿפøÿפùÿפúÿפûÿפüÿפýÿš¤þÿפÿ®¤ ÿš¤ÿäÿš¤ÿäÿ…¤ÿ×¥ÿ®¥ ÿ®¥ÿ…¥¦ÿ…¥¨ÿ×¥¼ÿš¥½ÿ×¥Áÿš¥Äÿ…¥Üÿ×¥Ýÿ×¥áÿ×¥äÿ×¥öÿ×¥ÿ®¥ ÿ®¥nÿ®¥|ÿš¥€ÿ®¥‚ÿ®¥—ÿ®¥›ÿ®¥§ÿ®¥©ÿ…¥ªÿ×¥µÿš¥¶ÿ×¥·ÿš¥¸ÿ×¥¹ÿš¥ºÿ×¥½ÿ…¥¾ÿ×¥¿ÿš¥Àÿ×¥Áÿš¥Âÿ×¥Ôÿš¥Õÿ×¥÷ÿ×¥øÿ×¥ùÿ×¥úÿ×¥ûÿ×¥üÿ×¥ýÿš¥þÿ×¥ÿ®¥ ÿš¥ÿÃ¥ÿš¥ÿÃ¥ÿ…¥ÿצÿ®¦ ÿ®¦ÿ…¦¦ÿ…¦¨ÿצ¼ÿš¦½ÿצÁÿš¦Äÿ…¦ÜÿצÝÿצáÿצäÿצöÿצÿ®¦ ÿ®¦nÿ®¦|ÿš¦€ÿ®¦‚ÿ®¦—ÿ®¦›ÿ®¦§ÿ®¦©ÿ…¦ªÿצµÿš¦¶ÿצ·ÿš¦¸ÿצ¹ÿš¦ºÿצ½ÿ…¦¾ÿצ¿ÿš¦ÀÿצÁÿš¦ÂÿצÔÿš¦Õÿצ÷ÿצøÿצùÿצúÿצûÿצüÿצýÿš¦þÿצÿ®¦ ÿš¦ÿæÿš¦ÿæÿ…¦ÿקŸÿק¸ÿק»ÿק¾ÿקÁÿקáÿקlÿק|ÿק~ÿק„ÿק†ÿקˆÿקŠÿקŒÿק±ÿק³ÿק¿ÿקÀÿקÁÿקÂÿקÅÿš§Çÿš§ÔÿקÕÿקïÿקñÿקóÿקýÿקþÿק ÿק ÿקÿקÿקÿקÿì¨ÿ…¨ÿ…¨Ÿÿ쨤ÿš¨ªÿq¨®ÿš¨µÿš¨¸ÿ쨻ÿ쨾ÿèÉÿì¨Îÿ®¨ÏÿרÕÿ®¨ØÿרÛÿרÞÿרáÿרêÿרëf¨íÿרîÿì¨òÿ®¨ôf¨ÿ…¨ ÿ…¨jÿרlÿì¨rÿq¨sÿ®¨~ÿì¨ÿר„ÿ쨅ÿר†ÿ쨇ÿרˆÿ쨉ÿרŠÿ쨌ÿì¨ÿר˜f¨¨f¨±ÿ쨲ÿר³ÿ쨴ÿרÀÿרÂÿרÅÿרÆÿèÇÿרÈÿèÎÿš¨Ïÿ®¨ÕÿרÙÿq¨Ûÿq¨Ýÿq¨àÿרïÿì¨ðÿרñÿì¨òÿרóÿì¨ôÿרþÿר ÿq¨ ÿר ÿq¨ ÿרÿš¨ÿ®¨ÿì¨ÿרÿרÿš¨ÿ®ªÿqª ÿqªÿšª¦ÿšª¼ÿqª¾ÿתÁÿšªÄÿšªÜÿתáÿתäÿתÿqª ÿqªnÿת|ÿšª€ÿ®ª‚ÿ®ª—ÿת›ÿת§ÿת©ÿšªªÿתµÿqª¶ÿת·ÿ…ª¹ÿ…ª½ÿšª¾ÿת¿ÿšªÀÿתÁÿšªÂÿתÅÿšªÇÿšªÔÿšªÕÿתáÿתãÿתýÿšªþÿתÿת ÿqªÿתÿqªÿתÿšªÿ׫ÿ׫ ÿ׫ªÿì«Áÿ׫ÿ׫ ÿ׫rÿì«|ÿ׫¿ÿ׫Áÿ׫Åÿ׫Çÿ׫Ôÿ׫Ùÿì«Ûÿì«Ýÿì«ýÿ׬ÿ®¬ÿ®¬ÿ®¬ ÿ®¬€ÿ쬂ÿ쬷ÿ쬹ÿì¬ ÿ׬ÿ×­ÿ…­ÿ®­ÿ…­Ÿÿ×­¤ÿš­ªÿq­®ÿš­µÿš­¸ÿ×­»ÿ×­¼)­¾ÿ®­Ìÿš­Íÿš­Îÿ…­Ïÿq­Ðÿ×­Ñÿ×­Òÿš­Óÿš­Ôÿš­Õÿ…­Öÿš­×ÿš­Øÿq­Ùÿš­Úÿš­Ûÿq­Üÿ®­Ýÿ®­Þÿq­ßÿ×­àÿš­áÿš­âÿš­ãÿš­äÿ®­åÿš­æÿš­çÿ×­èÿš­éÿíêÿq­ìÿš­íÿq­îÿ…­òÿ…­óÿš­õÿš­öÿ®­÷ÿš­ùÿš­ÿ®­ÿ®­ÿ®­ÿ…­ ÿ…­jÿq­kÿš­lÿ×­mÿ×­qÿš­rÿq­sÿ…­uÿš­wÿš­yÿš­}ÿš­~ÿ×­ÿq­ÿ×­ƒÿ×­„ÿ×­…ÿq­†ÿ×­‡ÿq­ˆÿ×­‰ÿq­Šÿ×­‹ÿ×­Œÿ×­ÿq­–ÿš­šÿš­žÿš­ ÿ×­¢ÿ×­¤ÿš­¦ÿš­ªÿ®­¬ÿš­®ÿš­°ÿš­±ÿ×­²ÿq­³ÿ×­´ÿq­µ)­¶ÿ®­¸ÿ®­ºÿ®­¼ÿ×­¾ÿ®­Àÿš­Âÿš­Äÿš­Åÿš­Æÿq­Çÿš­Èÿq­Ëÿ×­Íÿš­Îÿš­Ïÿ…­Ñÿš­Óÿš­Õÿš­×ÿš­Ùÿq­Ûÿq­Ýÿq­àÿq­æÿ×­èÿ×­êÿíìÿš­îÿš­ïÿ×­ðÿq­ñÿ×­òÿq­óÿ×­ôÿq­öÿ×­øÿ®­úÿ®­üÿ®­þÿš­ÿš­ÿš­ÿ×­ÿ×­ ÿq­ ÿq­ ÿq­ ÿq­ÿš­ÿš­ÿš­ÿ…­ÿš­ÿ×­ÿq­ÿ®­ÿq­ÿš­ÿ…®£á®ê)®ÿ×®ÿ×°Ÿÿ×°¸ÿ×°»ÿ×°¾ÿ×°Áÿ×°áÿ×°lÿ×°|ÿ×°~ÿ×°„ÿ×°†ÿ×°ˆÿ×°Šÿ×°Œÿ×°±ÿ×°³ÿ×°¿ÿ×°Àÿ×°Áÿ×°Âÿ×°Åÿš°Çÿš°Ôÿ×°Õÿ×°ïÿ×°ñÿ×°óÿ×°ýÿ×°þÿ×° ÿ×° ÿ×°ÿ×°ÿ×°ÿ×°ÿì±ÿ®±ÿ®±ÿ®± ÿ®±€ÿ챂ÿì±·ÿì±¹ÿì± ÿ×±ÿ×´Ÿÿ×´¸ÿ×´»ÿ×´¾ÿ×´Áÿ×´áÿ×´lÿ×´|ÿ×´~ÿ×´„ÿ×´†ÿ×´ˆÿ×´Šÿ×´Œÿ×´±ÿ×´³ÿ×´¿ÿ×´Àÿ×´Áÿ×´Âÿ×´Åÿš´Çÿš´Ôÿ×´Õÿ×´ïÿ×´ñÿ×´óÿ×´ýÿ×´þÿ×´ ÿ×´ ÿ×´ÿ×´ÿ×´ÿ×´ÿì¸ÿ®¸ÿ®¸ÿ츤ÿ׸¦ÿ츨ÿ׸ªÿ׸®ÿ׸°ÿ׸±ÿ층ÿ׸¼ÿø½ÿ׸¿ÿ׸Áÿ׸Äÿì¸Çÿì¸Îÿì¸Õÿì¸òÿì¸ÿ®¸ ÿ®¸rÿ׸sÿì¸zÿì¸|ÿ׸€ÿ츂ÿ츟ÿ׸¡ÿ츩ÿ층ÿø·ÿ츹ÿ츻ÿ׸½ÿ츿ÿ׸Áÿ׸Êÿ׸Îÿ׸Ïÿì¸Ôÿ׸Ùÿ׸Ûÿ׸Ýÿ׸åÿ׸çÿì¸õÿì¸÷ÿ׸ùÿ׸ûÿ׸ýÿ׸ÿ׸ÿ׸ ÿ׸ÿ׸ÿ׸ÿì¸ÿì¸ÿ׸ÿìºþöºþöº¤ÿ…ºªÿšº®ÿ…º°ÿ׺µÿ…º¿ÿ׺ÎÿšºÕÿšºòÿšºþöº þöºrÿšºsÿšºvÿ캟ÿ׺»ÿ׺Êÿ׺Îÿ…ºÏÿšºÙÿšºÛÿšºÝÿšºåÿ׺ÿ׺ÿ׺ ÿ®º ÿ®ºÿ…ºÿšºÿ…ºÿš»Ÿÿ×»¸ÿ×»»ÿ×»¾ÿ×»áÿ×»lÿ×»~ÿ×»„ÿ×»†ÿ×»ˆÿ×»Šÿ×»Œÿ×»±ÿ×»³ÿ×»Àÿ×»Âÿ×»Åÿ×»Çÿ×»Õÿ×»ïÿ×»ñÿ×»óÿ×»þÿ×» ÿ×» ÿ×»ÿ×»ÿ×»ÿ×¼ÿ…¼ÿ®¼ÿ…¼Ÿÿ×¼¤ÿš¼ªÿq¼®ÿš¼µÿš¼¸ÿ×¼»ÿ×¼¼)¼¾ÿ®¼Ìÿš¼Íÿš¼Îÿ…¼Ïÿq¼Ðÿ×¼Ñÿ×¼Òÿš¼Óÿš¼Ôÿš¼Õÿ…¼Öÿš¼×ÿš¼Øÿq¼Ùÿš¼Úÿš¼Ûÿq¼Üÿ®¼Ýÿ®¼Þÿq¼ßÿ×¼àÿš¼áÿš¼âÿš¼ãÿš¼äÿ®¼åÿš¼æÿš¼çÿ×¼èÿš¼éÿüêÿq¼ìÿš¼íÿq¼îÿ…¼òÿ…¼óÿš¼õÿš¼öÿ®¼÷ÿš¼ùÿš¼ÿ®¼ÿ®¼ÿ®¼ÿ…¼ ÿ…¼jÿq¼kÿš¼lÿ×¼mÿ×¼qÿš¼rÿq¼sÿ…¼uÿš¼wÿš¼yÿš¼}ÿš¼~ÿ×¼ÿq¼ÿ×¼ƒÿ×¼„ÿ×¼…ÿq¼†ÿ×¼‡ÿq¼ˆÿ×¼‰ÿq¼Šÿ×¼‹ÿ×¼Œÿ×¼ÿq¼–ÿš¼šÿš¼žÿš¼ ÿ×¼¢ÿ×¼¤ÿš¼¦ÿš¼ªÿ®¼¬ÿš¼®ÿš¼°ÿš¼±ÿ×¼²ÿq¼³ÿ×¼´ÿq¼µ)¼¶ÿ®¼¸ÿ®¼ºÿ®¼¼ÿ×¼¾ÿ®¼Àÿš¼Âÿš¼Äÿš¼Åÿš¼Æÿq¼Çÿš¼Èÿq¼Ëÿ×¼Íÿš¼Îÿš¼Ïÿ…¼Ñÿš¼Óÿš¼Õÿš¼×ÿš¼Ùÿq¼Ûÿq¼Ýÿq¼àÿq¼æÿ×¼èÿ×¼êÿüìÿš¼îÿš¼ïÿ×¼ðÿq¼ñÿ×¼òÿq¼óÿ×¼ôÿq¼öÿ×¼øÿ®¼úÿ®¼üÿ®¼þÿš¼ÿš¼ÿš¼ÿ×¼ÿ×¼ ÿq¼ ÿq¼ ÿq¼ ÿq¼ÿš¼ÿš¼ÿš¼ÿ…¼ÿš¼ÿ×¼ÿq¼ÿ®¼ÿq¼ÿš¼ÿ…½ÿ…½ÿ…½Ÿÿ콤ÿš½ªÿq½®ÿš½µÿš½¸ÿì½»ÿì½¾ÿýÉÿì½Îÿ®½Ïÿ×½Õÿ®½Øÿ×½Ûÿ×½Þÿ×½áÿ×½êÿ×½ëf½íÿ×½îÿì½òÿ®½ôf½ÿ…½ ÿ…½jÿ×½lÿì½rÿq½sÿ®½~ÿì½ÿ×½„ÿì½…ÿ×½†ÿ콇ÿ×½ˆÿ콉ÿ×½Šÿ콌ÿì½ÿ×½˜f½¨f½±ÿì½²ÿ×½³ÿì½´ÿ×½Àÿ×½Âÿ×½Åÿ×½ÆÿýÇÿ×½ÈÿýÎÿš½Ïÿ®½Õÿ×½Ùÿq½Ûÿq½Ýÿq½àÿ×½ïÿì½ðÿ×½ñÿì½òÿ×½óÿì½ôÿ×½þÿ×½ ÿq½ ÿ×½ ÿq½ ÿ×½ÿš½ÿ®½ÿì½ÿ×½ÿ×½ÿš½ÿ®¾ÿ®¾ÿ®¾ÿ×¾¤ÿ×¾¦ÿ×¾¨ÿþªÿ×¾®ÿ×¾°ÿ×¾±ÿ×¾µÿ×¾¼ÿþ½ÿþ¿ÿ×¾Äÿ×¾Çÿ×¾Îÿì¾Õÿì¾òÿì¾ÿ®¾ ÿ®¾rÿ×¾sÿì¾zÿ×¾€ÿ쾂ÿ쾟ÿ×¾¡ÿ×¾©ÿ×¾µÿþ·ÿþ¹ÿþ»ÿ×¾½ÿ×¾Êÿ×¾Îÿ×¾Ïÿì¾Ùÿ×¾Ûÿ×¾Ýÿ×¾åÿ×¾çÿ×¾õÿ×¾÷ÿþùÿþûÿþÿ×¾ÿ×¾ ÿ×¾ÿ×¾ÿ×¾ÿì¾ÿ×¾ÿ×¾ÿì¿Ÿÿ׿¸ÿ׿»ÿ׿¾ÿ׿Áÿ׿áÿ׿lÿ׿|ÿ׿~ÿ׿„ÿ׿†ÿ׿ˆÿ׿Šÿ׿Œÿ׿±ÿ׿³ÿ׿¿ÿ׿Àÿ׿Áÿ׿Âÿ׿Åÿš¿Çÿš¿Ôÿ׿Õÿ׿ïÿ׿ñÿ׿óÿ׿ýÿ׿þÿ׿ ÿ׿ ÿ׿ÿ׿ÿ׿ÿ׿ÿìÀ£áÀê)Àÿ×Àÿ×ãáÃê)Ãÿ×Ãÿ×Äÿ®Ä ÿ®Äÿ…Ħÿ…Ĩÿ×ļÿšÄ½ÿ×ÄÁÿšÄÄÿ…ÄÜÿ×ÄÝÿ×Äáÿ×Ääÿ×Äöÿ×Äÿ®Ä ÿ®Änÿ®Ä|ÿšÄ€ÿ®Ä‚ÿ®Ä—ÿ®Ä›ÿ®Ä§ÿ®Ä©ÿ…Īÿ×ĵÿšÄ¶ÿ×Ä·ÿšÄ¸ÿ×ĹÿšÄºÿ׼ÿ…ľÿ×Ä¿ÿšÄÀÿ×ÄÁÿšÄÂÿ×ÄÔÿšÄÕÿ×Ä÷ÿ×Äøÿ×Äùÿ×Äúÿ×Äûÿ×Äüÿ×ÄýÿšÄþÿ×Äÿ®Ä ÿšÄÿÃÄÿšÄÿÃÄÿ…Äÿ×Æÿ®Æ ÿ®Æÿ…Ʀÿ…ƨÿ×ƼÿšÆ½ÿ×ÆÁÿšÆÄÿ…ÆÜÿ×ÆÝÿ×Æáÿ×Æäÿ×Æöÿ×Æÿ®Æ ÿ®Ænÿ®Æ|ÿšÆ€ÿ®Æ‚ÿ®Æ—ÿ®Æ›ÿ®Æ§ÿ®Æ©ÿ…ƪÿ×ƵÿšÆ¶ÿ×Æ·ÿšÆ¸ÿ×ƹÿšÆºÿ×ƽÿ…ƾÿ×Æ¿ÿšÆÀÿ×ÆÁÿšÆÂÿ×ÆÔÿšÆÕÿ×Æ÷ÿ×Æøÿ×Æùÿ×Æúÿ×Æûÿ×Æüÿ×ÆýÿšÆþÿ×Æÿ®Æ ÿšÆÿÃÆÿšÆÿÃÆÿ…Æÿ×Çÿ®Çÿ®ÇÿìǤÿ×ǦÿìǨÿ×Ǫÿ×Ç®ÿ×Ç°ÿ×DZÿìǵÿ×ǼÿÃǽÿ×Ç¿ÿ×ÇÁÿ×ÇÄÿìÇÇÿìÇÎÿìÇÕÿìÇòÿìÇÿ®Ç ÿ®Çrÿ×ÇsÿìÇzÿìÇ|ÿ×Ç€ÿìÇ‚ÿìÇŸÿ×Ç¡ÿìÇ©ÿìǵÿÃÇ·ÿìǹÿìÇ»ÿ×ǽÿìÇ¿ÿ×ÇÁÿ×ÇÊÿ×ÇÎÿ×ÇÏÿìÇÔÿ×ÇÙÿ×ÇÛÿ×ÇÝÿ×Çåÿ×ÇçÿìÇõÿìÇ÷ÿ×Çùÿ×Çûÿ×Çýÿ×Çÿ×Çÿ×Ç ÿ×Çÿ×Çÿ×ÇÿìÇÿìÇÿ×ÇÿìÈÿ®Èÿ®ÈÿìȤÿ×ȦÿìȨÿ×Ȫÿ×È®ÿ×È°ÿ×ȱÿìȵÿ×ȼÿÃȽÿ×È¿ÿ×ÈÁÿ×ÈÄÿìÈÇÿìÈÎÿìÈÕÿìÈòÿìÈÿ®È ÿ®Èrÿ×ÈsÿìÈzÿìÈ|ÿ×È€ÿìÈ‚ÿìÈŸÿ×È¡ÿìÈ©ÿìȵÿÃÈ·ÿìȹÿìÈ»ÿ×ȽÿìÈ¿ÿ×ÈÁÿ×ÈÊÿ×ÈÎÿ×ÈÏÿìÈÔÿ×ÈÙÿ×ÈÛÿ×ÈÝÿ×Èåÿ×ÈçÿìÈõÿìÈ÷ÿ×Èùÿ×Èûÿ×Èýÿ×Èÿ×Èÿ×È ÿ×Èÿ×Èÿ×ÈÿìÈÿìÈÿ×ÈÿìÊÿìÊ ÿìÊÿìÊ ÿìÌé)ÍÿšÍÿ×ÍÿšÍÎÿÃÍÏÿìÍÕÿÃÍØÿìÍÛÿìÍÞÿìÍêÿìÍíÿìÍòÿÃÍÿ×Íÿ×Íÿ×ÍÿšÍ ÿšÍjÿìÍsÿÃÍÿìÍ…ÿì͇ÿì͉ÿìÍÿìͲÿìÍ´ÿìÍÏÿÃÍàÿìÍðÿìÍòÿìÍôÿìÍ ÿìÍ ÿìÍÿÃÍÿìÍÿìÍÿÃÎÿìÎ ÿìÎÿìÎ ÿìÏÿìÏ ÿìÏÿìÏ ÿìÐÏÿ×ÐØÿ×ÐÛÿ×ÐÞÿ×Ðáÿ×Ðêÿ×Ðíÿ×Ðjÿ×Ðÿ×Ð…ÿ×Їÿ×Љÿ×Ðÿ×вÿ×дÿ×ÐÀÿ×ÐÂÿ×ÐÆÿ×ÐÈÿ×ÐÕÿ×Ðàÿ×Ððÿ×Ðòÿ×Ðôÿ×Ðþÿ×Ð ÿ×Ð ÿ×Ðÿ×Ðÿ×Ñé)ÔÏÿ×ÔØÿ×ÔÛÿ×ÔÞÿ×Ôáÿ×Ôêÿ×Ôíÿ×Ôjÿ×Ôÿ×Ô…ÿ×Ô‡ÿ×Ô‰ÿ×Ôÿ×Ô²ÿ×Ô´ÿ×ÔÀÿ×ÔÂÿ×ÔÆÿ×ÔÈÿ×ÔÕÿ×Ôàÿ×Ôðÿ×Ôòÿ×Ôôÿ×Ôþÿ×Ô ÿ×Ô ÿ×Ôÿ×Ôÿ×ØÿìØ ÿìØÐÿ×ØÜÿìØÝÿìØßÿ×ØáÿìØäÿìØöÿìØÿìØ ÿìØ ÿ×تÿìضÿìؼÿ×ؾÿìØÀÿìØÂÿìØËÿ×ØÕÿìØæÿ×ØøÿìØúÿìØüÿìØþÿìØÿ×Øÿ×ØÿìØÿìØÿìÚÿìÚ ÿìÚÐÿ×ÚÜÿìÚÝÿìÚßÿ×ÚáÿìÚäÿìÚöÿìÚÿìÚ ÿìÚ ÿ×ÚªÿìÚ¶ÿìÚ¼ÿ×Ú¾ÿìÚÀÿìÚÂÿìÚËÿ×ÚÕÿìÚæÿ×ÚøÿìÚúÿìÚüÿìÚþÿìÚÿ×Úÿ×ÚÿìÚÿìÚÿìÜÿšÜÿ×ÜÿšÜÎÿÃÜÏÿìÜÕÿÃÜØÿìÜÛÿìÜÞÿìÜêÿìÜíÿìÜòÿÃÜÿ×Üÿ×Üÿ×ÜÿšÜ ÿšÜjÿìÜsÿÃÜÿìÜ…ÿì܇ÿì܉ÿìÜÿìܲÿìÜ´ÿìÜÏÿÃÜàÿìÜðÿìÜòÿìÜôÿìÜ ÿìÜ ÿìÜÿÃÜÿìÜÿìÜÿÃÝÿ®Ýÿ®ÝÎÿ×ÝÕÿ×Ýòÿ×Ýÿ®Ý ÿ®Ýsÿ×ÝÏÿ×Ýÿ×Ýÿ×ÞÿìÞ ÿìÞÐÿ×ÞÜÿìÞÝÿìÞßÿ×ÞáÿìÞäÿìÞöÿìÞÿìÞ ÿìÞ ÿ×ÞªÿìÞ¶ÿìÞ¼ÿ×Þ¾ÿìÞÀÿìÞÂÿìÞËÿ×ÞÕÿìÞæÿ×ÞøÿìÞúÿìÞüÿìÞþÿìÞÿ×Þÿ×ÞÿìÞÿìÞÿìßÏÿ×ßØÿ×ßÛÿ×ßÞÿ×ßáÿ×ßêÿ×ßíÿ×ßjÿ×ßÿ×ß…ÿ×߇ÿ×߉ÿ×ßÿ×ß²ÿ×ß´ÿ×ßÀÿ×ßÂÿ×ßÆÿ×ßÈÿ×ßÕÿ×ßàÿ×ßðÿ×ßòÿ×ßôÿ×ßþÿ×ß ÿ×ß ÿ×ßÿ×ßÿ×àÿìà ÿìàÿìà ÿìãÿìã ÿìãÿìã ÿìäÿ…ä ÿ…äÐÿ×äÜÿšäÝÿÃäßÿ×äáÿ®ääÿšäöÿÃäÿ…ä ÿ…ämÿ×äÿ×äƒÿ×ä‹ÿ×ä ÿ×äªÿšä¶ÿšä¸ÿÃäºÿÃä¼ÿ×ä¾ÿšäÀÿ®äÂÿ®äÆÿ×äÈÿ×äËÿ×äÕÿ®äæÿ×äêÿ×äøÿÃäúÿÃäüÿÃäþÿ®äÿ×äÿ×äÿšäÿšäÿšæÿ…æ ÿ…æÐÿ×æÜÿšæÝÿÃæßÿ×æáÿ®æäÿšæöÿÃæÿ…æ ÿ…æmÿ×æÿ×æƒÿ×æ‹ÿ×æ ÿ×æªÿšæ¶ÿšæ¸ÿÃæºÿÃæ¼ÿ×æ¾ÿšæÀÿ®æÂÿ®æÆÿ×æÈÿ×æËÿ×æÕÿ®ææÿ×æêÿ×æøÿÃæúÿÃæüÿÃæþÿ®æÿ×æÿ×æÿšæÿšæÿšçÿìç ÿìçÐÿ×çÜÿìçÝÿìçßÿ×çáÿìçäÿìçöÿìçÿìç ÿìç ÿ×çªÿìç¶ÿìç¼ÿ×ç¾ÿìçÀÿìçÂÿìçËÿ×çÕÿìçæÿ×çøÿìçúÿìçüÿìçþÿìçÿ×çÿ×çÿìçÿìçÿìèÿìè ÿìèÐÿ×èÜÿìèÝÿìèßÿ×èáÿìèäÿìèöÿìèÿìè ÿìè ÿ×èªÿìè¶ÿìè¼ÿ×è¾ÿìèÀÿìèÂÿìèËÿ×èÕÿìèæÿ×èøÿìèúÿìèüÿìèþÿìèÿ×èÿ×èÿìèÿìèÿìêÿìê ÿìêÿìê ÿìëÿìë ÿìëÿìë ÿìëÿ×ëÿ×ìÿšìÿ×ìÿšìÎÿÃìÏÿììÕÿÃìØÿììÛÿììÞÿììêÿììíÿììòÿÃìÿ×ìÿ×ìÿ×ìÿšì ÿšìjÿììsÿÃìÿìì…ÿìì‡ÿìì‰ÿììÿìì²ÿìì´ÿììÏÿÃìàÿììðÿììòÿììôÿìì ÿìì ÿììÿÃìÿììÿììÿÃòÿ…ò ÿ…òÐÿ×òÜÿšòÝÿÃòßÿ×òáÿ®òäÿšòöÿÃòÿ…ò ÿ…òmÿ×òÿ×òƒÿ×ò‹ÿ×ò ÿ×òªÿšò¶ÿšò¸ÿÃòºÿÃò¼ÿ×ò¾ÿšòÀÿ®òÂÿ®òÆÿ×òÈÿ×òËÿ×òÕÿ®òæÿ×òêÿ×òøÿÃòúÿÃòüÿÃòþÿ®òÿ×òÿ×òÿšòÿšòÿšóÿ…ó ÿ…óÐÿ×óÜÿšóÝÿÃóßÿ×óáÿ®óäÿšóöÿÃóÿ…ó ÿ…ómÿ×óÿ×óƒÿ×ó‹ÿ×ó ÿ×óªÿšó¶ÿšó¸ÿÃóºÿÃó¼ÿ×ó¾ÿšóÀÿ®óÂÿ®óÆÿ×óÈÿ×óËÿ×óÕÿ®óæÿ×óêÿ×óøÿÃóúÿÃóüÿÃóþÿ®óÿ×óÿ×óÿšóÿšóÿšôÿìô ÿìôÿìô ÿìôÿ×ôÿ×õÏÿ×õØÿ×õÛÿ×õÞÿ×õáÿ×õêÿ×õíÿ×õjÿ×õÿ×õ…ÿ×õ‡ÿ×õ‰ÿ×õÿ×õ²ÿ×õ´ÿ×õÀÿ×õÂÿ×õÆÿ×õÈÿ×õÕÿ×õàÿ×õðÿ×õòÿ×õôÿ×õþÿ×õ ÿ×õ ÿ×õÿ×õÿ×öÿ®öÿ®öÎÿ×öÕÿ×öòÿ×öÿ®ö ÿ®ösÿ×öÏÿ×öÿ×öÿ×øÿ…øÿ®øÿ…øŸÿ×ø¤ÿšøªÿqø®ÿšøµÿšø¸ÿ×ø»ÿ×ø¼)ø¾ÿ®øÌÿšøÍÿšøÎÿ…øÏÿqøÐÿ×øÑÿ×øÒÿšøÓÿšøÔÿšøÕÿ…øÖÿšø×ÿšøØÿqøÙÿšøÚÿšøÛÿqøÜÿ®øÝÿ®øÞÿqøßÿ×øàÿšøáÿšøâÿšøãÿšøäÿ®øåÿšøæÿšøçÿ×øèÿšøéÿÃøêÿqøìÿšøíÿqøîÿ…øòÿ…øóÿšøõÿšøöÿ®ø÷ÿšøùÿšøÿ®øÿ®øÿ®øÿ…ø ÿ…øjÿqøkÿšølÿ×ømÿ×øqÿšørÿqøsÿ…øuÿšøwÿšøyÿšø}ÿšø~ÿ×øÿqøÿ×øƒÿ×ø„ÿ×ø…ÿqø†ÿ×ø‡ÿqøˆÿ×ø‰ÿqøŠÿ×ø‹ÿ×øŒÿ×øÿqø–ÿšøšÿšøžÿšø ÿ×ø¢ÿ×ø¤ÿšø¦ÿšøªÿ®ø¬ÿšø®ÿšø°ÿšø±ÿ×ø²ÿqø³ÿ×ø´ÿqøµ)ø¶ÿ®ø¸ÿ®øºÿ®ø¼ÿ×ø¾ÿ®øÀÿšøÂÿšøÄÿšøÅÿšøÆÿqøÇÿšøÈÿqøËÿ×øÍÿšøÎÿšøÏÿ…øÑÿšøÓÿšøÕÿšø×ÿšøÙÿqøÛÿqøÝÿqøàÿqøæÿ×øèÿ×øêÿÃøìÿšøîÿšøïÿ×øðÿqøñÿ×øòÿqøóÿ×øôÿqøöÿ×øøÿ®øúÿ®øüÿ®øþÿšøÿšøÿšøÿ×øÿ×ø ÿqø ÿqø ÿqø ÿqøÿšøÿšøÿšøÿ…øÿšøÿ×øÿqøÿ®øÿqøÿšøÿ…ùÿšùÿ×ùÿšùÎÿÃùÏÿìùÕÿÃùØÿìùÛÿìùÞÿìùêÿìùíÿìùòÿÃùÿ×ùÿ×ùÿ×ùÿšù ÿšùjÿìùsÿÃùÿìù…ÿìù‡ÿìù‰ÿìùÿìù²ÿìù´ÿìùÏÿÃùàÿìùðÿìùòÿìùôÿìù ÿìù ÿìùÿÃùÿìùÿìùÿÃúÿšúÿšú")ú$ÿ®ú&ÿìú*ÿìú2ÿìú4ÿìúDÿ×úFÿ×úGÿ×úHÿ×úJÿìúPÿìúQÿìúRÿ×úSÿìúTÿ×úUÿìúVÿìúXÿìú‚ÿ®úƒÿ®ú„ÿ®ú…ÿ®ú†ÿ®ú‡ÿ®ú‰ÿìú”ÿìú•ÿìú–ÿìú—ÿìú˜ÿìúšÿìú¢ÿ×ú£ÿ×ú¤ÿ×ú¥ÿ×ú¦ÿ×ú§ÿ×ú¨ÿ×ú©ÿ×úªÿ×ú«ÿ×ú¬ÿ×ú­ÿ×ú´ÿ×úµÿ×ú¶ÿ×ú·ÿ×ú¸ÿ×úºÿ×ú»ÿìú¼ÿìú½ÿìú¾ÿìúÂÿ®úÃÿ×úÄÿ®úÅÿ×úÆÿ®úÇÿ×úÈÿìúÉÿ×úÊÿìúËÿ×úÌÿìúÍÿ×úÎÿìúÏÿ×úÑÿ×úÓÿ×úÕÿ×ú×ÿ×úÙÿ×úÛÿ×úÝÿ×úÞÿìúßÿìúàÿìúáÿìúâÿìúãÿìúäÿìúåÿìúúÿìúÿìúÿìú ÿìúÿìúÿ×úÿìúÿ×úÿìúÿ×úÿìúÿ×úÿìúÿìúÿìú!ÿìú+ÿìú-ÿìú/ÿìú1ÿìú3ÿìú5ÿìúCÿ®úDÿ×úFÿ×úGÿìúHÿ×úJÿìúÿšú ÿšúWÿìúXÿ®úYÿ×ú_ÿìú`ÿ×úbÿìúÿ®úÿ×úÿ®ú ÿ×ú!ÿ®ú"ÿ×ú#ÿ®ú%ÿ®ú&ÿ×ú'ÿ®ú(ÿ×ú)ÿ®ú*ÿ×ú+ÿ®ú,ÿ×ú-ÿ®ú.ÿ×ú/ÿ®ú0ÿ×ú1ÿ®ú2ÿ×ú3ÿ®ú4ÿ×ú6ÿ×ú8ÿ×ú:ÿ×ú<ÿ×ú@ÿ×úBÿ×úDÿ×úIÿìúJÿ×úKÿìúLÿ×úMÿìúNÿ×úOÿìúQÿìúRÿ×úSÿìúTÿ×úUÿìúVÿ×úWÿìúXÿ×úYÿìúZÿ×ú[ÿìú\ÿ×ú]ÿìú^ÿ×ú_ÿìú`ÿ×úbÿìúdÿìúfÿìúhÿìújÿìúlÿìúnÿìûRû Rûÿ®ûÿ®û")ûRûÿ®û Rû ÿ®üÿšüÿšü")ü$ÿ®ü&ÿìü*ÿìü2ÿìü4ÿìüDÿ×üFÿ×üGÿ×üHÿ×üJÿìüPÿìüQÿìüRÿ×üSÿìüTÿ×üUÿìüVÿìüXÿìü‚ÿ®üƒÿ®ü„ÿ®ü…ÿ®ü†ÿ®ü‡ÿ®ü‰ÿìü”ÿìü•ÿìü–ÿìü—ÿìü˜ÿìüšÿìü¢ÿ×ü£ÿ×ü¤ÿ×ü¥ÿ×ü¦ÿ×ü§ÿ×ü¨ÿ×ü©ÿ×üªÿ×ü«ÿ×ü¬ÿ×ü­ÿ×ü´ÿ×üµÿ×ü¶ÿ×ü·ÿ×ü¸ÿ×üºÿ×ü»ÿìü¼ÿìü½ÿìü¾ÿìüÂÿ®üÃÿ×üÄÿ®üÅÿ×üÆÿ®üÇÿ×üÈÿìüÉÿ×üÊÿìüËÿ×üÌÿìüÍÿ×üÎÿìüÏÿ×üÑÿ×üÓÿ×üÕÿ×ü×ÿ×üÙÿ×üÛÿ×üÝÿ×üÞÿìüßÿìüàÿìüáÿìüâÿìüãÿìüäÿìüåÿìüúÿìüÿìüÿìü ÿìüÿìüÿ×üÿìüÿ×üÿìüÿ×üÿìüÿ×üÿìüÿìüÿìü!ÿìü+ÿìü-ÿìü/ÿìü1ÿìü3ÿìü5ÿìüCÿ®üDÿ×üFÿ×üGÿìüHÿ×üJÿìüÿšü ÿšüWÿìüXÿ®üYÿ×ü_ÿìü`ÿ×übÿìüÿ®üÿ×üÿ®ü ÿ×ü!ÿ®ü"ÿ×ü#ÿ®ü%ÿ®ü&ÿ×ü'ÿ®ü(ÿ×ü)ÿ®ü*ÿ×ü+ÿ®ü,ÿ×ü-ÿ®ü.ÿ×ü/ÿ®ü0ÿ×ü1ÿ®ü2ÿ×ü3ÿ®ü4ÿ×ü6ÿ×ü8ÿ×ü:ÿ×ü<ÿ×ü@ÿ×üBÿ×üDÿ×üIÿìüJÿ×üKÿìüLÿ×üMÿìüNÿ×üOÿìüQÿìüRÿ×üSÿìüTÿ×üUÿìüVÿ×üWÿìüXÿ×üYÿìüZÿ×ü[ÿìü\ÿ×ü]ÿìü^ÿ×ü_ÿìü`ÿ×übÿìüdÿìüfÿìühÿìüjÿìülÿìünÿìýRý Rýÿ®ýÿ®ý")ýRýÿ®ý Rý ÿ®þÿšþÿšþ")þ$ÿ®þ&ÿìþ*ÿìþ2ÿìþ4ÿìþDÿ×þFÿ×þGÿ×þHÿ×þJÿìþPÿìþQÿìþRÿ×þSÿìþTÿ×þUÿìþVÿìþXÿìþ‚ÿ®þƒÿ®þ„ÿ®þ…ÿ®þ†ÿ®þ‡ÿ®þ‰ÿìþ”ÿìþ•ÿìþ–ÿìþ—ÿìþ˜ÿìþšÿìþ¢ÿ×þ£ÿ×þ¤ÿ×þ¥ÿ×þ¦ÿ×þ§ÿ×þ¨ÿ×þ©ÿ×þªÿ×þ«ÿ×þ¬ÿ×þ­ÿ×þ´ÿ×þµÿ×þ¶ÿ×þ·ÿ×þ¸ÿ×þºÿ×þ»ÿìþ¼ÿìþ½ÿìþ¾ÿìþÂÿ®þÃÿ×þÄÿ®þÅÿ×þÆÿ®þÇÿ×þÈÿìþÉÿ×þÊÿìþËÿ×þÌÿìþÍÿ×þÎÿìþÏÿ×þÑÿ×þÓÿ×þÕÿ×þ×ÿ×þÙÿ×þÛÿ×þÝÿ×þÞÿìþßÿìþàÿìþáÿìþâÿìþãÿìþäÿìþåÿìþúÿìþÿìþÿìþ ÿìþÿìþÿ×þÿìþÿ×þÿìþÿ×þÿìþÿ×þÿìþÿìþÿìþ!ÿìþ+ÿìþ-ÿìþ/ÿìþ1ÿìþ3ÿìþ5ÿìþCÿ®þDÿ×þFÿ×þGÿìþHÿ×þJÿìþÿšþ ÿšþWÿìþXÿ®þYÿ×þ_ÿìþ`ÿ×þbÿìþÿ®þÿ×þÿ®þ ÿ×þ!ÿ®þ"ÿ×þ#ÿ®þ%ÿ®þ&ÿ×þ'ÿ®þ(ÿ×þ)ÿ®þ*ÿ×þ+ÿ®þ,ÿ×þ-ÿ®þ.ÿ×þ/ÿ®þ0ÿ×þ1ÿ®þ2ÿ×þ3ÿ®þ4ÿ×þ6ÿ×þ8ÿ×þ:ÿ×þ<ÿ×þ@ÿ×þBÿ×þDÿ×þIÿìþJÿ×þKÿìþLÿ×þMÿìþNÿ×þOÿìþQÿìþRÿ×þSÿìþTÿ×þUÿìþVÿ×þWÿìþXÿ×þYÿìþZÿ×þ[ÿìþ\ÿ×þ]ÿìþ^ÿ×þ_ÿìþ`ÿ×þbÿìþdÿìþfÿìþhÿìþjÿìþlÿìþnÿìÿRÿ Rÿÿ®ÿÿ®ÿ")ÿRÿÿ®ÿ Rÿ ÿ®ÿ…ÿ…")$ÿ…&ÿ×*ÿ×2ÿ×4ÿ×DÿšFÿšGÿšHÿšJÿ×PÿÃQÿÃRÿšSÿÃTÿšUÿÃVÿ®XÿÃ]ÿׂÿ…ƒÿ…„ÿ……ÿ…†ÿ…‡ÿ…‰ÿ×”ÿוÿ×–ÿ×—ÿטÿךÿ×¢ÿš£ÿš¤ÿš¥ÿš¦ÿš§ÿš¨ÿš©ÿšªÿš«ÿš¬ÿš­ÿš´ÿšµÿš¶ÿš·ÿš¸ÿšºÿš»ÿüÿýÿþÿÃÂÿ…ÃÿšÄÿ…ÅÿšÆÿ…ÇÿšÈÿ×ÉÿšÊÿ×ËÿšÌÿ×ÍÿšÎÿ×ÏÿšÑÿšÓÿšÕÿš×ÿšÙÿšÛÿšÝÿšÞÿ×ßÿ×àÿ×áÿ×âÿ×ãÿ×äÿ×åÿ×úÿÃÿÃÿà ÿÃÿ×ÿšÿ×ÿšÿ×ÿšÿ×ÿšÿÃÿÃÿ®!ÿ®+ÿÃ-ÿÃ/ÿÃ1ÿÃ3ÿÃ5ÿÃ<ÿ×>ÿ×@ÿ×Cÿ…DÿšFÿšGÿ×HÿšJÿ®ÿ… ÿ…WÿÃXÿ…Yÿš_ÿ×`ÿšbÿÃÿ…ÿšÿ… ÿš!ÿ…"ÿš#ÿ…%ÿ…&ÿš'ÿ…(ÿš)ÿ…*ÿš+ÿ…,ÿš-ÿ….ÿš/ÿ…0ÿš1ÿ…2ÿš3ÿ…4ÿš6ÿš8ÿš:ÿš<ÿš@ÿšBÿšDÿšIÿ×JÿšKÿ×LÿšMÿ×NÿšOÿ×Qÿ×RÿšSÿ×TÿšUÿ×VÿšWÿ×XÿšYÿ×Zÿš[ÿ×\ÿš]ÿ×^ÿš_ÿ×`ÿšbÿÃdÿÃfÿÃhÿÃjÿÃlÿÃnÿÃR Rÿ®ÿ®")Rÿ® R ÿ®7ÿ®$ÿ®&ÿ®qÿ®ÿ®¦ÿ®¼ÿ®Äÿ®Üÿ×äÿשÿ®ªÿ×µÿ®¶ÿ×½ÿ®¾ÿ×ÿ®ÿ×ÿ®7ÿ®$ÿ®&ÿ®qÿ®ÿ®¦ÿ®¼ÿ®Äÿ®Üÿ×äÿשÿ®ªÿ×µÿ®¶ÿ×½ÿ®¾ÿ×ÿ®ÿ×ÿ®7ÿ®$ÿ®&ÿ®qÿ®ÿ®¦ÿ®¼ÿ®Äÿ®Üÿ×äÿשÿ®ªÿ×µÿ®¶ÿ×½ÿ®¾ÿ×ÿ®ÿ×ÿ®$ÿq7)9):)<Dÿ®Fÿ…Gÿ…Hÿ…JÿÃPÿÃQÿÃRÿ…SÿÃTÿ…UÿÃVÿÃXÿÂÿqƒÿq„ÿq…ÿq†ÿq‡ÿqŸ¢ÿ…£ÿ®¤ÿ®¥ÿ®¦ÿ®§ÿ®¨ÿ®©ÿ…ªÿ…«ÿ…¬ÿ…­ÿ…´ÿ…µÿ…¶ÿ…·ÿ…¸ÿ…ºÿ…»ÿüÿýÿþÿÃÂÿqÃÿ®ÄÿqÅÿ®ÆÿqÇÿ®Éÿ…Ëÿ…Íÿ…Ïÿ…Ñÿ…Óÿ…Õÿ…×ÿ…Ùÿ…Ûÿ…Ýÿ…ßÿÃáÿÃãÿÃåÿÃúÿÃÿÃÿà ÿÃÿ…ÿ…ÿ…ÿ…ÿÃÿÃÿÃ!ÿÃ$)&)+ÿÃ-ÿÃ/ÿÃ1ÿÃ3ÿÃ5ÿÃ6)8:CÿqDÿ®Fÿ®Hÿ…JÿÃVÿq_ÿqbÿqiÿqyÿ®zÿ×{ÿ×~ÿ®ÿÂÿ׃ÿׄÿׇÿ׉ÿ׌ÿ®ŽÿÃÿ®ÿ®“ÿ®™ÿ®¤ÿ…ªÿq®ÿ…µÿ…Êÿ×ÎÿqÏÿ…ÕÿqØÿ…Ûÿ…Þÿ…êÿ…íÿ…îÿÃòÿqú)ü)þ)WÿÃXÿqYÿ®`ÿ…bÿÃjÿ…rÿqsÿq}ÿìÿ……ÿ…‡ÿ…‰ÿ…ÿ…²ÿ…´ÿ…Îÿ…ÏÿqÙÿqÚÿ×ÛÿqÜÿ×ÝÿqÞÿ×àÿ…âÿ×äÿ×ðÿ…òÿ…ôÿ… ÿq ÿ… ÿq ÿ…ÿ…ÿqÿ…ÿ…ÿ…ÿqÿqÿ®ÿq ÿ®!ÿq"ÿ®#ÿq%ÿq&ÿ®'ÿq(ÿ®)ÿq*ÿ®+ÿq,ÿ®-ÿq.ÿ®/ÿq0ÿ®1ÿq2ÿ®3ÿq4ÿ®6ÿ…8ÿ…:ÿ…<ÿ…@ÿ…Bÿ…Dÿ…Jÿ…Lÿ…Nÿ…Rÿ…Tÿ…Vÿ…Xÿ…Zÿ…\ÿ…^ÿ…`ÿ…bÿÃdÿÃfÿÃhÿÃjÿÃlÿÃnÿÃoqs)$ÿq7)9):)<Dÿ®Fÿ…Gÿ…Hÿ…JÿÃPÿÃQÿÃRÿ…SÿÃTÿ…UÿÃVÿÃXÿÂÿqƒÿq„ÿq…ÿq†ÿq‡ÿqŸ¢ÿ…£ÿ®¤ÿ®¥ÿ®¦ÿ®§ÿ®¨ÿ®©ÿ…ªÿ…«ÿ…¬ÿ…­ÿ…´ÿ…µÿ…¶ÿ…·ÿ…¸ÿ…ºÿ…»ÿüÿýÿþÿÃÂÿqÃÿ®ÄÿqÅÿ®ÆÿqÇÿ®Éÿ…Ëÿ…Íÿ…Ïÿ…Ñÿ…Óÿ…Õÿ…×ÿ…Ùÿ…Ûÿ…Ýÿ…ßÿÃáÿÃãÿÃåÿÃúÿÃÿÃÿà ÿÃÿ…ÿ…ÿ…ÿ…ÿÃÿÃÿÃ!ÿÃ$)&)+ÿÃ-ÿÃ/ÿÃ1ÿÃ3ÿÃ5ÿÃ6)8:CÿqDÿ®Fÿ®Hÿ…JÿÃVÿq_ÿqbÿqiÿqyÿ®zÿ×{ÿ×~ÿ®ÿÂÿ׃ÿׄÿׇÿ׉ÿ׌ÿ®ŽÿÃÿ®ÿ®“ÿ®™ÿ®¤ÿ…ªÿq®ÿ…µÿ…Êÿ×ÎÿqÏÿ…ÕÿqØÿ…Ûÿ…Þÿ…êÿ…íÿ…îÿÃòÿqú)ü)þ)WÿÃXÿqYÿ®`ÿ…bÿÃjÿ…rÿqsÿq}ÿìÿ……ÿ…‡ÿ…‰ÿ…ÿ…²ÿ…´ÿ…Îÿ…ÏÿqÙÿqÚÿ×ÛÿqÜÿ×ÝÿqÞÿ×àÿ…âÿ×äÿ×ðÿ…òÿ…ôÿ… ÿq ÿ… ÿq ÿ…ÿ…ÿqÿ…ÿ…ÿ…ÿqÿqÿ®ÿq ÿ®!ÿq"ÿ®#ÿq%ÿq&ÿ®'ÿq(ÿ®)ÿq*ÿ®+ÿq,ÿ®-ÿq.ÿ®/ÿq0ÿ®1ÿq2ÿ®3ÿq4ÿ®6ÿ…8ÿ…:ÿ…<ÿ…@ÿ…Bÿ…Dÿ…Jÿ…Lÿ…Nÿ…Rÿ…Tÿ…Vÿ…Xÿ…Zÿ…\ÿ…^ÿ…`ÿ…bÿÃdÿÃfÿÃhÿÃjÿÃlÿÃnÿÃoqs)&ÿš*ÿš2ÿš4ÿš7ÿq8ÿ×9ÿ…:ÿ…<ÿ…‰ÿš”ÿš•ÿš–ÿš—ÿš˜ÿššÿš›ÿלÿ×ÿמÿןÿ…ÈÿšÊÿšÌÿšÎÿšÞÿšàÿšâÿšäÿšÿšÿšÿšÿš$ÿq&ÿq*ÿ×,ÿ×.ÿ×0ÿ×2ÿ×4ÿ×6ÿ…8ÿ…:ÿ…Gÿšfÿ®mÿ®qÿqrÿ…sÿšuÿ…xÿ……ÿ×ÿqŸÿš¦ÿq¸ÿš»ÿš¼ÿq¾ÿ®Áÿ\ÄÿqÜÿšáÿ…äÿšúÿ…üÿ…þÿ…ÿ…Tÿ…_ÿšaÿ×lÿš|ÿ\~ÿš€ÿ…‚ÿ…„ÿš†ÿšˆÿšŠÿšŒÿš©ÿqªÿš±ÿš³ÿšµÿq¶ÿš·ÿ…¹ÿ…½ÿq¾ÿš¿ÿ\Àÿ…Áÿ\Âÿ…Åÿ…Çÿ…Ôÿ\Õÿ…ïÿšñÿšóÿšýÿ\þÿ… ÿ…ÿšÿ…ÿšÿšÿqÿšIÿšKÿšMÿšOÿšQÿšSÿšUÿšWÿšYÿš[ÿš]ÿš_ÿšaÿ×cÿ×eÿ×gÿ×iÿ×kÿ×mÿ×oÿ…qÿ…sÿ…ÿq $ÿq 7) 9) :) < Dÿ® Fÿ… Gÿ… Hÿ… Jÿà Pÿà Qÿà Rÿ… Sÿà Tÿ… Uÿà Vÿà Xÿà ‚ÿq ƒÿq „ÿq …ÿq †ÿq ‡ÿq Ÿ ¢ÿ… £ÿ® ¤ÿ® ¥ÿ® ¦ÿ® §ÿ® ¨ÿ® ©ÿ… ªÿ… «ÿ… ¬ÿ… ­ÿ… ´ÿ… µÿ… ¶ÿ… ·ÿ… ¸ÿ… ºÿ… »ÿà ¼ÿà ½ÿà ¾ÿà Âÿq Ãÿ® Äÿq Åÿ® Æÿq Çÿ® Éÿ… Ëÿ… Íÿ… Ïÿ… Ñÿ… Óÿ… Õÿ… ×ÿ… Ùÿ… Ûÿ… Ýÿ… ßÿà áÿà ãÿà åÿà úÿà ÿà ÿà  ÿà ÿ… ÿ… ÿ… ÿ… ÿà ÿà ÿà !ÿà $) &) +ÿà -ÿà /ÿà 1ÿà 3ÿà 5ÿà 6) 8 : Cÿq Dÿ® Fÿ® Hÿ… Jÿà Vÿq _ÿq bÿq iÿq yÿ® zÿ× {ÿ× ~ÿ® ÿà ‚ÿ× ƒÿ× „ÿ× ‡ÿ× ‰ÿ× Œÿ® Žÿà ÿ® ÿ® “ÿ® ™ÿ® ¤ÿ… ªÿq ®ÿ… µÿ… Êÿ× Îÿq Ïÿ… Õÿq Øÿ… Ûÿ… Þÿ… êÿ… íÿ… îÿà òÿq ú) ü) þ)  Wÿà Xÿq Yÿ® `ÿ… bÿà jÿ… rÿq sÿq }ÿì ÿ… …ÿ… ‡ÿ… ‰ÿ… ÿ… ²ÿ… ´ÿ… Îÿ… Ïÿq Ùÿq Úÿ× Ûÿq Üÿ× Ýÿq Þÿ× àÿ… âÿ× äÿ× ðÿ… òÿ… ôÿ…  ÿq  ÿ…  ÿq  ÿ… ÿ… ÿq ÿ… ÿ… ÿ… ÿq ÿq ÿ® ÿq  ÿ® !ÿq "ÿ® #ÿq %ÿq &ÿ® 'ÿq (ÿ® )ÿq *ÿ® +ÿq ,ÿ® -ÿq .ÿ® /ÿq 0ÿ® 1ÿq 2ÿ® 3ÿq 4ÿ® 6ÿ… 8ÿ… :ÿ… <ÿ… @ÿ… Bÿ… Dÿ… Jÿ… Lÿ… Nÿ… Rÿ… Tÿ… Vÿ… Xÿ… Zÿ… \ÿ… ^ÿ… `ÿ… bÿà dÿà fÿà hÿà jÿà lÿà nÿà o q s ) &ÿš *ÿš 2ÿš 4ÿš 7ÿq 8ÿ× 9ÿ… :ÿ… <ÿ… ‰ÿš ”ÿš •ÿš –ÿš —ÿš ˜ÿš šÿš ›ÿ× œÿ× ÿ× žÿ× Ÿÿ… Èÿš Êÿš Ìÿš Îÿš Þÿš àÿš âÿš äÿš ÿš ÿš ÿš ÿš $ÿq &ÿq *ÿ× ,ÿ× .ÿ× 0ÿ× 2ÿ× 4ÿ× 6ÿ… 8ÿ… :ÿ… Gÿš fÿ® mÿ® qÿq rÿ… sÿš uÿ… xÿ… …ÿ× ÿq Ÿÿš ¦ÿq ¸ÿš »ÿš ¼ÿq ¾ÿ® Áÿ\ Äÿq Üÿš áÿ… äÿš úÿ… üÿ… þÿ… ÿ… Tÿ… _ÿš aÿ× lÿš |ÿ\ ~ÿš €ÿ… ‚ÿ… „ÿš †ÿš ˆÿš Šÿš Œÿš ©ÿq ªÿš ±ÿš ³ÿš µÿq ¶ÿš ·ÿ… ¹ÿ… ½ÿq ¾ÿš ¿ÿ\ Àÿ… Áÿ\ Âÿ… Åÿ… Çÿ… Ôÿ\ Õÿ… ïÿš ñÿš óÿš ýÿ\ þÿ…  ÿ… ÿš ÿ… ÿš ÿš ÿq ÿš Iÿš Kÿš Mÿš Oÿš Qÿš Sÿš Uÿš Wÿš Yÿš [ÿš ]ÿš _ÿš aÿ× cÿ× eÿ× gÿ× iÿ× kÿ× mÿ× oÿ… qÿ… sÿ… ÿq!qÿ×!rÿì!xÿì!TÿìSÿÃSÿÃSÿÃS ÿÃTÿ…Tÿ…TVÿ…T_ÿ…Tbÿ…Tfÿ×Tiÿ…Tmÿ×TsÿÃTvÿìTyÿšTzÿ®T{ÿÃT|ÿÃT}ÿÃT~ÿšTÿÃT‚ÿ®T„ÿÃT†ÿÃT‡ÿÃT‰ÿÃTŒÿšTŽÿšTÿšTÿšT’ÿÃT“ÿšT•ÿÃT–ÿÃT˜ÿÃT™ÿšTšÿÃT›ÿÃTÿ…T ÿ…T!ÿìXÿqX ÿqX&ÿ×X*ÿ×X- X2ÿ×X4ÿ×X7ÿqX9ÿ®X:ÿ®X<ÿ…X‰ÿ×X”ÿ×X•ÿ×X–ÿ×X—ÿ×X˜ÿ×Xšÿ×XŸÿ…XÈÿ×XÊÿ×XÌÿ×XÎÿ×XÞÿ×Xàÿ×Xâÿ×Xäÿ×Xÿ×Xÿ×Xÿ×Xÿ×X$ÿqX&ÿqX6ÿ®X8ÿ…X:ÿ…XGÿ×Xúÿ®Xüÿ®Xþÿ®Xÿ…XÿqX ÿqX_ÿ×XIÿ×XKÿ×XMÿ×XOÿ×XQÿ×XSÿ×XUÿ×XWÿ×XYÿ×X[ÿ×X]ÿ×X_ÿ×Xoÿ…Xqÿ…Xsÿ…XÿqYÿìY ÿìYÿìY ÿìZÿ®Zÿ®ZVÿ×Z_ÿ×Zbÿ×ZdÿìZiÿ×ZpÿìZqÿÃZrÿìZtÿ×ZuÿìZxÿìZˆÿìZÿ®Z ÿ®ZTÿì`IR`WR`Yf`Zf`[f`\f`¿f`%R`'R`7f`ûf`ýf`4R`5R`]R`^R`pf`R`RbIfbWfbYfbZfb[fb\fb¿fb%fb'fb7fbûfbýfb4fb5fb]fb^fbpfbfbfjÿìj ÿìjÿìj ÿìlÿ®lÿ®lÿìl¤ÿ×l¦ÿìl¨ÿ×lªÿ×l®ÿ×l°ÿ×l±ÿìlµÿ×l¼ÿÃl½ÿ×l¿ÿ×lÁÿ×lÄÿìlÇÿìlÎÿìlÕÿìlòÿìlÿ®l ÿ®lrÿ×lsÿìlzÿìl|ÿ×l€ÿìl‚ÿìlŸÿ×l¡ÿìl©ÿìlµÿÃl·ÿìl¹ÿìl»ÿ×l½ÿìl¿ÿ×lÁÿ×lÊÿ×lÎÿ×lÏÿìlÔÿ×lÙÿ×lÛÿ×lÝÿ×låÿ×lçÿìlõÿìl÷ÿ×lùÿ×lûÿ×lýÿ×lÿ×lÿ×l ÿ×lÿ×lÿ×lÿìlÿìlÿ×lÿìmÿ®mÿ®mÎÿ×mÕÿ×mòÿ×mÿ®m ÿ®msÿ×mÏÿ×mÿ×mÿ×nÿ®n ÿ®nÿ×n¦ÿ×n¼ÿ®nÁÿ®nÄÿ×nÜÿ×näÿ×nÿ®n ÿ®n|ÿ®n€ÿÃn‚ÿÃn©ÿ×nªÿ×nµÿ®n¶ÿ×n·ÿÃn¹ÿÃn½ÿ×n¾ÿ×n¿ÿ®nÁÿ®nÔÿ®nýÿ®n ÿšnÿšnÿ×nÿ×oÿ…o ÿ…oÐÿ×oÜÿšoÝÿÃoßÿ×oáÿ®oäÿšoöÿÃoÿ…o ÿ…omÿ×oÿ×oƒÿ×o‹ÿ×o ÿ×oªÿšo¶ÿšo¸ÿÃoºÿÃo¼ÿ×o¾ÿšoÀÿ®oÂÿ®oÆÿ×oÈÿ×oËÿ×oÕÿ®oæÿ×oêÿ×oøÿÃoúÿÃoüÿÃoþÿ®oÿ×oÿ×oÿšoÿšoÿšpŸÿ×p¸ÿ×p»ÿ×p¾ÿ×páÿ×plÿ×p~ÿ×p„ÿ×p†ÿ×pˆÿ×pŠÿ×pŒÿ×p±ÿ×p³ÿ×pÀÿ×pÂÿ×pÅÿ×pÇÿ×pÕÿ×pïÿ×pñÿ×póÿ×pþÿ×p ÿ×p ÿ×pÿ×pÿ×pÿ×rÿqr ÿqrÿšr¦ÿšr¼ÿqr¾ÿ×rÁÿšrÄÿšrÜÿ×ráÿ×räÿ×rÿqr ÿqrnÿ×r|ÿšr€ÿ®r‚ÿ®r—ÿ×r›ÿ×r§ÿ×r©ÿšrªÿ×rµÿqr¶ÿ×r·ÿ…r¹ÿ…r½ÿšr¾ÿ×r¿ÿšrÀÿ×rÁÿšrÂÿ×rÅÿšrÇÿšrÔÿšrÕÿ×ráÿ×rãÿ×rýÿšrþÿ×rÿ×r ÿqrÿ×rÿqrÿ×rÿšrÿ×sÿqs ÿqsÏÿ×sØÿ×sÛÿ×sÜÿšsÝÿÃsÞÿ×sáÿÃsäÿšsêÿ×síÿ×söÿÃsÿqs ÿqsjÿ×smÿ×s}ÿìsÿ×sÿ×sƒÿ×s…ÿ×s‡ÿ×s‰ÿ×s‹ÿ×sÿ×sªÿšs²ÿ×s´ÿ×s¶ÿšs¸ÿ×sºÿ×s¾ÿšsÀÿÃsÂÿÃsÆÿ×sÈÿ×sÕÿÃsàÿ×sðÿ×sòÿ×sôÿ×søÿÃsúÿÃsüÿÃsþÿÃs ÿ×s ÿ×sÿ…sÿ…sÿ×sÿšsÿ×tÿqt ÿqtÿšt¦ÿšt¼ÿqt¾ÿ×tÁÿštÄÿštÜÿ×táÿ×täÿ×tÿqt ÿqtnÿ×t|ÿšt€ÿ®t‚ÿ®t—ÿ×t›ÿ×t§ÿ×t©ÿštªÿ×tµÿqt¶ÿ×t·ÿ…t¹ÿ…t½ÿšt¾ÿ×t¿ÿštÀÿ×tÁÿštÂÿ×tÅÿštÇÿštÔÿštÕÿ×táÿ×tãÿ×týÿštþÿ×tÿ×t ÿqtÿ×tÿqtÿ×tÿštÿ×uÿqu ÿquÏÿ×uØÿ×uÛÿ×uÜÿšuÝÿÃuÞÿ×uáÿÃuäÿšuêÿ×uíÿ×uöÿÃuÿqu ÿqujÿ×umÿ×u}ÿìuÿ×uÿ×uƒÿ×u…ÿ×u‡ÿ×u‰ÿ×u‹ÿ×uÿ×uªÿšu²ÿ×u´ÿ×u¶ÿšu¸ÿ×uºÿ×u¾ÿšuÀÿÃuÂÿÃuÆÿ×uÈÿ×uÕÿÃuàÿ×uðÿ×uòÿ×uôÿ×uøÿÃuúÿÃuüÿÃuþÿÃu ÿ×u ÿ×uÿ…uÿ…uÿ×uÿšuÿ×v ÿìvÿìx ÿìxÿìzÿ®zÿ®zÿ®z ÿ®z€ÿìz‚ÿìz·ÿìz¹ÿìz ÿ×zÿ×|ÿq|ÿq|¤ÿÃ|ªÿ®|®ÿÃ|µÿÃ|Îÿ×|Õÿ×|òÿ×|ÿq| ÿq|rÿ®|sÿ×|ÎÿÃ|Ïÿ×|Ùÿ®|Ûÿ®|Ýÿ®| ÿ®| ÿ®|ÿÃ|ÿ×|ÿÃ|ÿ×}ÿì} ÿì}Ðÿ×}Üÿì}Ýÿì}ßÿ×}áÿì}äÿì}öÿì}ÿì} ÿì} ÿ×}ªÿì}¶ÿì}¼ÿ×}¾ÿì}Àÿì}Âÿì}Ëÿ×}Õÿì}æÿ×}øÿì}úÿì}üÿì}þÿì}ÿ×}ÿ×}ÿì}ÿì}ÿì~ÿ®~ÿ®~ÿì~¤ÿ×~¦ÿì~¨ÿ×~ªÿ×~®ÿ×~°ÿ×~±ÿì~µÿ×~¼ÿÃ~½ÿ×~¿ÿ×~Áÿ×~Äÿì~Çÿì~Îÿì~Õÿì~òÿì~ÿ®~ ÿ®~rÿ×~sÿì~zÿì~|ÿ×~€ÿì~‚ÿì~Ÿÿ×~¡ÿì~©ÿì~µÿÃ~·ÿì~¹ÿì~»ÿ×~½ÿì~¿ÿ×~Áÿ×~Êÿ×~Îÿ×~Ïÿì~Ôÿ×~Ùÿ×~Ûÿ×~Ýÿ×~åÿ×~çÿì~õÿì~÷ÿ×~ùÿ×~ûÿ×~ýÿ×~ÿ×~ÿ×~ ÿ×~ÿ×~ÿ×~ÿì~ÿì~ÿ×~ÿìÿì ÿìÐÿ×ÜÿìÝÿìßÿ×áÿìäÿìöÿìÿì ÿì ÿתÿì¶ÿì¼ÿ×¾ÿìÀÿìÂÿìËÿ×Õÿìæÿ×øÿìúÿìüÿìþÿìÿ×ÿ×ÿìÿìÿì€ÿ…€ÿ…€Ÿÿ쀤ÿš€ªÿq€®ÿš€µÿš€¸ÿ쀻ÿ쀾ÿÀÉÿì€Îÿ®€Ïÿ×€Õÿ®€Øÿ×€Ûÿ×€Þÿ×€áÿ×€êÿ×€ëf€íÿ×€îÿì€òÿ®€ôf€ÿ…€ ÿ…€jÿ×€lÿì€rÿq€sÿ®€~ÿì€ÿ×€„ÿ쀅ÿ×€†ÿ쀇ÿ×€ˆÿ쀉ÿ×€Šÿ쀌ÿì€ÿ×€˜f€¨f€±ÿ쀲ÿ×€³ÿ쀴ÿ×€Àÿ×€Âÿ×€Åÿ×€ÆÿÀÇÿ×€ÈÿÀÎÿš€Ïÿ®€Õÿ×€Ùÿq€Ûÿq€Ýÿq€àÿ×€ïÿì€ðÿ×€ñÿì€òÿ×€óÿì€ôÿ×€þÿ×€ ÿq€ ÿ×€ ÿq€ ÿ×€ÿš€ÿ®€ÿì€ÿ×€ÿ×€ÿš€ÿ®ÿ®ÿ®Îÿ×Õÿ×òÿ×ÿ® ÿ®sÿ×Ïÿ×ÿ×ÿׂÿ…‚ÿ…‚Ÿÿ삤ÿš‚ªÿq‚®ÿš‚µÿš‚¸ÿì‚»ÿ삾ÿÂÉÿì‚Îÿ®‚ÏÿׂÕÿ®‚ØÿׂÛÿׂÞÿׂáÿׂêÿׂëf‚íÿׂîÿì‚òÿ®‚ôf‚ÿ…‚ ÿ…‚jÿׂlÿì‚rÿq‚sÿ®‚~ÿì‚ÿׂ„ÿì‚…ÿׂ†ÿ삇ÿׂˆÿ삉ÿׂŠÿì‚Œÿì‚ÿׂ˜f‚¨f‚±ÿ삲ÿׂ³ÿì‚´ÿׂÀÿׂÂÿׂÅÿׂÆÿÂÇÿׂÈÿÂÎÿš‚Ïÿ®‚ÕÿׂÙÿq‚Ûÿq‚Ýÿq‚àÿׂïÿì‚ðÿׂñÿì‚òÿׂóÿì‚ôÿׂþÿׂ ÿq‚ ÿׂ ÿq‚ ÿׂÿš‚ÿ®‚ÿì‚ÿׂÿׂÿš‚ÿ®ƒÿ®ƒÿ®ƒÎÿ׃Õÿ׃òÿ׃ÿ®ƒ ÿ®ƒsÿ׃Ïÿ׃ÿ׃ÿׄÿ®„ÿ®„ÎÿׄÕÿׄòÿׄÿ®„ ÿ®„sÿׄÏÿׄÿׄÿ×…ÿ®…ÿ®…Îÿ×…Õÿ×…òÿ×…ÿ®… ÿ®…sÿ×…Ïÿ×…ÿ×…ÿ׆ÿ®†ÿ®†ÿ솤ÿ׆¦ÿ솨ÿ׆ªÿ׆®ÿ׆°ÿ׆±ÿ솵ÿ׆¼ÿƽÿ׆¿ÿ׆Áÿ׆Äÿì†Çÿì†Îÿì†Õÿì†òÿì†ÿ®† ÿ®†rÿ׆sÿì†zÿì†|ÿ׆€ÿ솂ÿ솟ÿ׆¡ÿ솩ÿ솵ÿÆ·ÿ솹ÿ솻ÿ׆½ÿ솿ÿ׆Áÿ׆Êÿ׆Îÿ׆Ïÿì†Ôÿ׆Ùÿ׆Ûÿ׆Ýÿ׆åÿ׆çÿì†õÿì†÷ÿ׆ùÿ׆ûÿ׆ýÿ׆ÿ׆ÿ׆ ÿ׆ÿ׆ÿ׆ÿì†ÿì†ÿ׆ÿì‡ÿì‡ ÿì‡ÐÿׇÜÿì‡Ýÿì‡ßÿׇáÿì‡äÿì‡öÿì‡ÿì‡ ÿ쇠ÿׇªÿ쇶ÿ쇼ÿׇ¾ÿì‡Àÿì‡Âÿì‡ËÿׇÕÿì‡æÿׇøÿì‡úÿì‡üÿì‡þÿì‡ÿׇÿׇÿì‡ÿì‡ÿìˆÿ®ˆÿ®ˆÿ숤ÿ׈¦ÿ숨ÿ׈ªÿ׈®ÿ׈°ÿ׈±ÿ숵ÿ׈¼ÿȽÿ׈¿ÿ׈Áÿ׈ÄÿìˆÇÿìˆÎÿìˆÕÿìˆòÿìˆÿ®ˆ ÿ®ˆrÿ׈sÿìˆzÿìˆ|ÿ׈€ÿ숂ÿ숟ÿ׈¡ÿ숩ÿ숵ÿÈ·ÿ숹ÿ숻ÿ׈½ÿ숿ÿ׈Áÿ׈Êÿ׈Îÿ׈ÏÿìˆÔÿ׈Ùÿ׈Ûÿ׈Ýÿ׈åÿ׈çÿìˆõÿìˆ÷ÿ׈ùÿ׈ûÿ׈ýÿ׈ÿ׈ÿ׈ ÿ׈ÿ׈ÿ׈ÿìˆÿìˆÿ׈ÿì‰ÿì‰ ÿì‰Ðÿ׉Üÿì‰Ýÿì‰ßÿ׉áÿì‰äÿì‰öÿì‰ÿì‰ ÿ쉠ÿ׉ªÿ쉶ÿ쉼ÿ׉¾ÿì‰Àÿì‰Âÿì‰Ëÿ׉Õÿì‰æÿ׉øÿì‰úÿì‰üÿì‰þÿì‰ÿ׉ÿ׉ÿì‰ÿì‰ÿìŠÿ®Šÿ®Šÿ스ÿ׊¦ÿ슨ÿ׊ªÿ׊®ÿ׊°ÿ׊±ÿ습ÿ׊¼ÿʽÿ׊¿ÿ׊Áÿ׊ÄÿìŠÇÿìŠÎÿìŠÕÿìŠòÿìŠÿ®Š ÿ®Šrÿ׊sÿìŠzÿìŠ|ÿ׊€ÿ슂ÿ슟ÿ׊¡ÿ슩ÿ습ÿÊ·ÿ승ÿ슻ÿ׊½ÿ슿ÿ׊Áÿ׊Êÿ׊Îÿ׊ÏÿìŠÔÿ׊Ùÿ׊Ûÿ׊Ýÿ׊åÿ׊çÿìŠõÿìŠ÷ÿ׊ùÿ׊ûÿ׊ýÿ׊ÿ׊ÿ׊ ÿ׊ÿ׊ÿ׊ÿìŠÿìŠÿ׊ÿì‹ÿ®‹ÿ®‹Îÿ׋Õÿ׋òÿ׋ÿ®‹ ÿ®‹sÿ׋Ïÿ׋ÿ׋ÿ׌Ÿÿ׌¸ÿ׌»ÿ׌¾ÿ׌áÿ׌lÿ׌~ÿ׌„ÿ׌†ÿ׌ˆÿ׌Šÿ׌Œÿ׌±ÿ׌³ÿ׌Àÿ׌Âÿ׌Åÿ׌Çÿ׌Õÿ׌ïÿ׌ñÿ׌óÿ׌þÿ׌ ÿ׌ ÿ׌ÿ׌ÿ׌ÿו£á•ê)•ÿוÿ×–ÿì– ÿì–ÿì– ÿì—ÿ®— ÿ®—ÿ×—¦ÿ×—¼ÿ®—Áÿ®—Äÿ×—Üÿ×—äÿ×—ÿ®— ÿ®—|ÿ®—€ÿׂÿשÿ×—ªÿ×—µÿ®—¶ÿ×—·ÿ×¹ÿ×½ÿ×—¾ÿ×—¿ÿ®—Áÿ®—Ôÿ®—ýÿ®— ÿš—ÿš—ÿ×—ÿטÿ…˜ ÿ…˜ÐÿטÜÿš˜ÝÿØßÿטáÿ®˜äÿš˜öÿØÿ…˜ ÿ…˜mÿטÿטƒÿט‹ÿט ÿטªÿš˜¶ÿš˜¸ÿغÿؼÿט¾ÿš˜Àÿ®˜Âÿ®˜ÆÿטÈÿטËÿטÕÿ®˜æÿטêÿטøÿØúÿØüÿØþÿ®˜ÿטÿטÿš˜ÿš˜ÿš™þö™þö™¤ÿ…™ªÿš™®ÿ…™°ÿ×™µÿ…™¿ÿ×™Îÿš™Õÿš™òÿš™þö™ þö™rÿš™sÿš™vÿ왟ÿ×™»ÿ×™Êÿ×™Îÿ…™Ïÿš™Ùÿš™Ûÿš™Ýÿš™åÿ×™ÿ×™ÿ×™ ÿ®™ ÿ®™ÿ…™ÿš™ÿ…™ÿššÿìš ÿìšÐÿךÜÿìšÝÿìšßÿךáÿìšäÿìšöÿìšÿìš ÿìš ÿךªÿ욶ÿìš¼ÿך¾ÿìšÀÿìšÂÿìšËÿךÕÿìšæÿךøÿìšúÿìšüÿìšþÿìšÿךÿךÿìšÿìšÿì›ÿš›ÿ×›ÿš›)›Ÿÿ×›¤ÿ®›¦)›ªÿ…›®ÿ®›µÿ®›¸ÿ×›»ÿ×›¼)›¾ÿÛÄ)›ÌÿÛÍÿÛÎÿš›Ïÿ®›Ðÿ×›Ñÿ×›ÒÿÛÓÿÛÔÿÛÕÿš›ÖÿÛ×ÿÛØÿ®›ÙÿÛÚÿÛÛÿ®›Þÿ®›ßÿ×›àÿÛáÿš›âÿÛãÿÛåÿÛæÿÛçÿ×›èÿÛêÿ®›ë)›ìÿÛíÿ®›îÿÛòÿš›óÿÛô)›õÿÛ÷ÿÛùÿÛÿ×›ÿ×›ÿ×›ÿš› ÿš›jÿ®›kÿÛlÿ×›qÿÛrÿ…›sÿš›uÿÛwÿ×›yÿÛ}ÿÛ~ÿ×›ÿ®›„ÿ×›…ÿ®›†ÿ×›‡ÿ®›ˆÿ×›‰ÿ®›Šÿ×›Œÿ×›ÿ®›–ÿÛ˜)›šÿÛžÿÛ ÿ×›¢ÿ×›¤ÿÛ¦ÿÛ¨)›©)›¬ÿÛ®ÿÛ°ÿÛ±ÿ×›²ÿ®›³ÿ×›´ÿ®›µ)›¼ÿ×›½)›Àÿš›Âÿš›ÄÿÛÅÿ×›ÆÿÛÇÿ×›ÈÿÛËÿ×›ÍÿÛÎÿ®›Ïÿš›ÑÿÛÓÿÛÕÿš›×ÿÛÙÿ…›Ûÿ…›Ýÿ…›àÿ®›æÿ×›èÿ×›ìÿÛîÿÛïÿ×›ðÿ®›ñÿ×›òÿ®›óÿ×›ôÿ®›öÿ×›þÿš›ÿÛÿÛÿ×›ÿ×› ÿš› ÿ®› ÿš› ÿ®›ÿ×›ÿ×›ÿ®›ÿš›ÿÛÿ×›ÿ®›)›ÿ®›ÿ®›ÿšœÿÃœÿÃœÎÿÃœÏÿלÕÿÃœØÿלÛÿלÞÿלêÿלíÿלòÿÃœÿÃœ ÿÃœjÿלsÿÃœÿל…ÿל‡ÿל‰ÿלÿל²ÿל´ÿלÏÿÃœàÿלðÿלòÿלôÿל ÿל ÿלÿÃœÿלÿלÿÃÿà ÿÃÿãf¦ÿüÿÃÁÿ®ÄÿÃÜÿ×áÿ×äÿ×ÿà ÿÃ|ÿ®€ÿÂÿéÿêÿ×µÿöÿ×·ÿ×¹ÿ×½ÿþÿ׿ÿ®Àÿ×Áÿ®Âÿ×Ôÿ®Õÿ×ýÿ®þÿ× ÿ×ÿÃÿ×ÿÃÿÃÿמÿÞ ÿÞÿÞ ÿÞÿמÿןŸÿן£áŸ¸ÿן»ÿן¾ÿßÜÿןáÿ®Ÿäÿןlÿן{=Ÿ}ÿìŸ~ÿן„ÿן†ÿןˆÿןŠÿןŒÿןªÿן±ÿן³ÿן¶ÿן¾ÿןÀÿ®ŸÂÿ®ŸÅÿßÆÿןÇÿßÈÿןÕÿ®Ÿïÿןñÿןóÿןþÿ®Ÿÿןÿןÿןÿ× Ïÿì Øÿì Ûÿì Þÿì áÿì êÿì íÿì jÿì ÿì …ÿì ‡ÿì ‰ÿì ÿì ²ÿì ´ÿì Àÿì Âÿì Õÿì àÿì ðÿì òÿì ôÿì þÿì  ÿì  ÿì ÿ× ÿ× ÿì ÿì¡ÿ®¡ÿ®¡ÿ®¡ ÿ®¡€ÿì¡‚ÿì¡·ÿ졹ÿì¡ ÿסÿ×¢é)£Ÿÿ×££á£¸ÿ×£»ÿ×£¾ÿãÜÿ×£áÿ®£äÿ×£lÿ×£{=£}ÿì£~ÿ×£„ÿ×£†ÿ×£ˆÿ×£Šÿ×£Œÿ×£ªÿ×£±ÿ×£³ÿ×£¶ÿ×£¾ÿ×£Àÿ®£Âÿ®£ÅÿãÆÿ×£ÇÿãÈÿ×£Õÿ®£ïÿ×£ñÿ×£óÿ×£þÿ®£ÿ×£ÿ×£ÿ×£ÿפÏÿì¤Øÿì¤Ûÿì¤Þÿì¤áÿì¤êÿì¤íÿì¤jÿì¤ÿ줅ÿ줇ÿ줉ÿì¤ÿ줲ÿ줴ÿì¤Àÿì¤Âÿì¤Õÿì¤àÿì¤ðÿì¤òÿì¤ôÿì¤þÿì¤ ÿì¤ ÿì¤ÿפÿפÿì¤ÿ쥟ÿ×¥¸ÿ×¥»ÿ×¥¾ÿ×¥Áÿ×¥áÿ×¥lÿ×¥|ÿ×¥~ÿ×¥„ÿ×¥†ÿ×¥ˆÿ×¥Šÿ×¥Œÿ×¥±ÿ×¥³ÿ×¥¿ÿ×¥Àÿ×¥Áÿ×¥Âÿ×¥Åÿš¥Çÿš¥Ôÿ×¥Õÿ×¥ïÿ×¥ñÿ×¥óÿ×¥ýÿ×¥þÿ×¥ ÿ×¥ ÿ×¥ÿ×¥ÿ×¥ÿ×¥ÿì¦ÏÿצØÿצÛÿצÞÿצáÿצêÿצíÿצjÿצÿצ…ÿצ‡ÿצ‰ÿצÿצ²ÿצ´ÿצÀÿצÂÿצÆÿצÈÿצÕÿצàÿצðÿצòÿצôÿצþÿצ ÿצ ÿצÿצÿקŸÿק¸ÿק»ÿק¾ÿקÁÿקáÿקlÿק|ÿק~ÿק„ÿק†ÿקˆÿקŠÿקŒÿק±ÿק³ÿק¿ÿקÀÿקÁÿקÂÿקÅÿš§Çÿš§ÔÿקÕÿקïÿקñÿקóÿקýÿקþÿק ÿק ÿקÿקÿקÿקÿì¨ÏÿרØÿרÛÿרÞÿרáÿרêÿרíÿרjÿרÿר…ÿר‡ÿר‰ÿרÿר²ÿר´ÿרÀÿרÂÿרÆÿרÈÿרÕÿרàÿרðÿרòÿרôÿרþÿר ÿר ÿרÿרÿשŸÿש¸ÿש»ÿש¾ÿשÁÿשáÿשlÿש|ÿש~ÿש„ÿש†ÿשˆÿשŠÿשŒÿש±ÿש³ÿש¿ÿשÀÿשÁÿשÂÿשÅÿš©Çÿš©ÔÿשÕÿשïÿשñÿשóÿשýÿשþÿש ÿש ÿשÿשÿשÿשÿìªÏÿתØÿתÛÿתÞÿתáÿתêÿתíÿתjÿתÿת…ÿת‡ÿת‰ÿתÿת²ÿת´ÿתÀÿתÂÿתÆÿתÈÿתÕÿתàÿתðÿתòÿתôÿתþÿת ÿת ÿתÿתÿ׫£á«ê)«ÿ׫ÿ׬ÿì¬ ÿì¬ÿì¬ ÿì­ÿš­ÿ×­ÿš­)­Ÿÿ×­¤ÿ®­¦)­ªÿ…­®ÿ®­µÿ®­¸ÿ×­»ÿ×­¼)­¾ÿíÄ)­ÌÿíÍÿíÎÿš­Ïÿ®­Ðÿ×­Ñÿ×­ÒÿíÓÿíÔÿíÕÿš­Öÿí×ÿíØÿ®­ÙÿíÚÿíÛÿ®­Þÿ®­ßÿ×­àÿíáÿš­âÿíãÿíåÿíæÿíçÿ×­èÿíêÿ®­ë)­ìÿííÿ®­îÿíòÿš­óÿíô)­õÿí÷ÿíùÿíÿ×­ÿ×­ÿ×­ÿš­ ÿš­jÿ®­kÿílÿ×­qÿírÿ…­sÿš­uÿíwÿ×­yÿí}ÿí~ÿ×­ÿ®­„ÿ×­…ÿ®­†ÿ×­‡ÿ®­ˆÿ×­‰ÿ®­Šÿ×­Œÿ×­ÿ®­–ÿí˜)­šÿížÿí ÿ×­¢ÿ×­¤ÿí¦ÿí¨)­©)­¬ÿí®ÿí°ÿí±ÿ×­²ÿ®­³ÿ×­´ÿ®­µ)­¼ÿ×­½)­Àÿš­Âÿš­ÄÿíÅÿ×­ÆÿíÇÿ×­ÈÿíËÿ×­ÍÿíÎÿ®­Ïÿš­ÑÿíÓÿíÕÿš­×ÿíÙÿ…­Ûÿ…­Ýÿ…­àÿ®­æÿ×­èÿ×­ìÿíîÿíïÿ×­ðÿ®­ñÿ×­òÿ®­óÿ×­ôÿ®­öÿ×­þÿš­ÿíÿíÿ×­ÿ×­ ÿš­ ÿ®­ ÿš­ ÿ®­ÿ×­ÿ×­ÿ®­ÿš­ÿíÿ×­ÿ®­)­ÿ®­ÿ®­ÿš®ÿš®ÿ×®ÿš®ÎÿîÏÿì®ÕÿîØÿì®Ûÿì®Þÿì®êÿì®íÿì®òÿîÿ×®ÿ×®ÿ×®ÿš® ÿš®jÿì®sÿîÿì®…ÿ쮇ÿ쮉ÿì®ÿ쮲ÿì®´ÿì®Ïÿîàÿì®ðÿì®òÿì®ôÿì® ÿì® ÿì®ÿîÿì®ÿì®ÿïÿ\¯ ÿ\¯ÿš¯£f¯¦ÿš¯¼ÿH¯Áÿ…¯Äÿš¯Üÿ®¯áÿׯäÿ®¯ÿ\¯ ÿ\¯|ÿ…¯€ÿq¯‚ÿq¯©ÿš¯ªÿ®¯µÿH¯¶ÿ®¯·ÿš¯¹ÿš¯½ÿš¯¾ÿ®¯¿ÿ…¯ÀÿׯÁÿ…¯ÂÿׯÅÿïÆÿׯÇÿïÈÿׯÔÿ…¯Õÿׯýÿ…¯þÿׯ ÿH¯ÿ®¯ÿH¯ÿ®¯ÿš¯ÿ®°ÿq° ÿq°Üÿš°áÿ×°äÿš°ÿq° ÿq°mÿ×°ÿ×°ƒÿ×°‹ÿ×°ªÿš°¶ÿš°¸ÿ×°ºÿ×°¾ÿš°Àÿ×°Âÿ×°Æÿ×°Èÿ×°Õÿ×°þÿ×°ÿq°ÿq°ÿš±ÿ×±¦ÿ×±¼ÿñÄÿ×±€ÿ챂ÿ챩ÿ×±µÿñ·ÿì±¹ÿì±½ÿ×± ÿ×±ÿ×±ÿײÿì² ÿì²ÐÿײÜÿì²Ýÿì²ßÿײáÿì²äÿì²öÿì²ÿì² ÿì² ÿײªÿ첶ÿì²¼ÿײ¾ÿì²Àÿì²Âÿì²ËÿײÕÿì²æÿײøÿì²úÿì²üÿì²þÿì²ÿײÿײÿì²ÿì²ÿ쳟ÿ׳¸ÿ׳»ÿ׳¾ÿ׳áÿ׳lÿ׳~ÿ׳„ÿ׳†ÿ׳ˆÿ׳Šÿ׳Œÿ׳±ÿ׳³ÿ׳Àÿ׳Âÿ׳Åÿ׳Çÿ׳Õÿ׳ïÿ׳ñÿ׳óÿ׳þÿ׳ ÿ׳ ÿ׳ÿ׳ÿ׳ÿ×µÿ…µÿ®µÿ…µŸÿ×µ¤ÿšµªÿqµ®ÿšµµÿšµ¸ÿ×µ»ÿ×µ¼)µ¾ÿ®µÌÿšµÍÿšµÎÿ…µÏÿqµÐÿ×µÑÿ×µÒÿšµÓÿšµÔÿšµÕÿ…µÖÿšµ×ÿšµØÿqµÙÿšµÚÿšµÛÿqµÜÿ®µÝÿ®µÞÿqµßÿ×µàÿšµáÿšµâÿšµãÿšµäÿ®µåÿšµæÿšµçÿ×µèÿšµéÿõêÿqµìÿšµíÿqµîÿ…µòÿ…µóÿšµõÿšµöÿ®µ÷ÿšµùÿšµÿ®µÿ®µÿ®µÿ…µ ÿ…µjÿqµkÿšµlÿ×µmÿ×µqÿšµrÿqµsÿ…µuÿšµwÿšµyÿšµ}ÿšµ~ÿ×µÿqµÿ×µƒÿ×µ„ÿ×µ…ÿqµ†ÿ×µ‡ÿqµˆÿ×µ‰ÿqµŠÿ×µ‹ÿ×µŒÿ×µÿqµ–ÿšµšÿšµžÿšµ ÿ×µ¢ÿ×µ¤ÿšµ¦ÿšµªÿ®µ¬ÿšµ®ÿšµ°ÿšµ±ÿ×µ²ÿqµ³ÿ×µ´ÿqµµ)µ¶ÿ®µ¸ÿ®µºÿ®µ¼ÿ×µ¾ÿ®µÀÿšµÂÿšµÄÿšµÅÿšµÆÿqµÇÿšµÈÿqµËÿ×µÍÿšµÎÿšµÏÿ…µÑÿšµÓÿšµÕÿšµ×ÿšµÙÿqµÛÿqµÝÿqµàÿqµæÿ×µèÿ×µêÿõìÿšµîÿšµïÿ×µðÿqµñÿ×µòÿqµóÿ×µôÿqµöÿ×µøÿ®µúÿ®µüÿ®µþÿšµÿšµÿšµÿ×µÿ×µ ÿqµ ÿqµ ÿqµ ÿqµÿšµÿšµÿšµÿ…µÿšµÿ×µÿqµÿ®µÿqµÿšµÿ…¶ÿš¶ÿ׶ÿš¶ÎÿöÏÿì¶ÕÿöØÿì¶Ûÿì¶Þÿì¶êÿì¶íÿì¶òÿöÿ׶ÿ׶ÿ׶ÿš¶ ÿš¶jÿì¶sÿöÿ춅ÿ춇ÿ춉ÿì¶ÿ춲ÿ춴ÿì¶Ïÿöàÿì¶ðÿì¶òÿì¶ôÿì¶ ÿì¶ ÿì¶ÿöÿì¶ÿì¶ÿ÷ÿ…·ÿ…·Ÿÿ×·¤ÿ®·ªÿ…·®ÿ®·µÿ®·¸ÿ×·»ÿ×·¾ÿ÷Êÿ®·Ìÿ÷Íÿ÷Îÿš·Ïÿš·Òÿ÷Óÿ÷Ôÿ÷Õÿš·Öÿ÷×ÿ÷Øÿš·Ùÿ÷Úÿ÷Ûÿš·Þÿš·àÿ÷áÿ®·âÿ÷ãÿ÷åÿ÷æÿ÷èÿ÷éÿ×·êÿš·ë)·ìÿ÷íÿš·îÿ®·òÿš·óÿ÷ô)·õÿ÷÷ÿ÷ùÿ÷ÿ…· ÿ…·jÿš·kÿ÷lÿ×·qÿ÷rÿ…·sÿš·uÿ÷wÿ×·yÿ÷}ÿ×·~ÿ×·ÿš·„ÿ×·…ÿš·†ÿ×·‡ÿš·ˆÿ×·‰ÿš·Šÿ×·Œÿ×·ÿš·–ÿ÷˜)·šÿ÷žÿ÷¤ÿ÷¦ÿ÷¨)·¬ÿ÷®ÿ÷°ÿ÷±ÿ×·²ÿš·³ÿ×·´ÿš·Àÿ®·Âÿ®·Äÿ÷Æÿ®·Èÿ®·Íÿ÷Îÿ®·Ïÿš·Ñÿ÷Óÿ÷Õÿ®·×ÿ÷Ùÿ…·Úÿ®·Ûÿ…·Üÿ®·Ýÿ…·Þÿ®·àÿš·áÿì·âÿ®·ãÿì·äÿ®·ìÿ÷îÿ÷ïÿ×·ðÿš·ñÿ×·òÿš·óÿ×·ôÿš·þÿ®·ÿ÷ÿ÷ ÿ®· ÿš· ÿ®· ÿš·ÿ×·ÿ×·ÿ®·ÿš·ÿ÷ÿ×·ÿš·ÿì·ÿš·ÿ®·ÿš¸ÿ®¸ÿ®¸Îÿì¸Õÿì¸òÿì¸ÿ®¸ ÿ®¸sÿì¸Ïÿì¸ÿì¸ÿì¹ÿ…¹ÿ…¹Ÿÿ×¹¤ÿ®¹ªÿ…¹®ÿ®¹µÿ®¹¸ÿ×¹»ÿ×¹¾ÿùÊÿ®¹ÌÿùÍÿùÎÿš¹Ïÿš¹ÒÿùÓÿùÔÿùÕÿš¹Öÿù×ÿùØÿš¹ÙÿùÚÿùÛÿš¹Þÿš¹àÿùáÿ®¹âÿùãÿùåÿùæÿùèÿùéÿ×¹êÿš¹ë)¹ìÿùíÿš¹îÿ®¹òÿš¹óÿùô)¹õÿù÷ÿùùÿùÿ…¹ ÿ…¹jÿš¹kÿùlÿ×¹qÿùrÿ…¹sÿš¹uÿùwÿ×¹yÿù}ÿ×¹~ÿ×¹ÿš¹„ÿ×¹…ÿš¹†ÿ×¹‡ÿš¹ˆÿ×¹‰ÿš¹Šÿ×¹Œÿ×¹ÿš¹–ÿù˜)¹šÿùžÿù¤ÿù¦ÿù¨)¹¬ÿù®ÿù°ÿù±ÿ×¹²ÿš¹³ÿ×¹´ÿš¹Àÿ®¹Âÿ®¹ÄÿùÆÿ®¹Èÿ®¹ÍÿùÎÿ®¹Ïÿš¹ÑÿùÓÿùÕÿ®¹×ÿùÙÿ…¹Úÿ®¹Ûÿ…¹Üÿ®¹Ýÿ…¹Þÿ®¹àÿš¹áÿì¹âÿ®¹ãÿì¹äÿ®¹ìÿùîÿùïÿ×¹ðÿš¹ñÿ×¹òÿš¹óÿ×¹ôÿš¹þÿ®¹ÿùÿù ÿ®¹ ÿš¹ ÿ®¹ ÿš¹ÿ×¹ÿ×¹ÿ®¹ÿš¹ÿùÿ×¹ÿš¹ÿì¹ÿš¹ÿ®¹ÿšºÿ®ºÿ®ºÎÿìºÕÿìºòÿìºÿ®º ÿ®ºsÿìºÏÿìºÿìºÿ컟ÿ×»£á»¸ÿ×»»ÿ×»¾ÿûÜÿ×»áÿ®»äÿ×»lÿ×»{=»}ÿì»~ÿ×»„ÿ×»†ÿ×»ˆÿ×»Šÿ×»Œÿ×»ªÿ×»±ÿ×»³ÿ×»¶ÿ×»¾ÿ×»Àÿ®»Âÿ®»ÅÿûÆÿ×»ÇÿûÈÿ×»Õÿ®»ïÿ×»ñÿ×»óÿ×»þÿ®»ÿ×»ÿ×»ÿ×»ÿ×¼Ïÿì¼Øÿì¼Ûÿì¼Þÿì¼áÿì¼êÿì¼íÿì¼jÿì¼ÿì¼…ÿ켇ÿ켉ÿì¼ÿì¼²ÿì¼´ÿì¼Àÿì¼Âÿì¼Õÿì¼àÿì¼ðÿì¼òÿì¼ôÿì¼þÿì¼ ÿì¼ ÿì¼ÿ×¼ÿ×¼ÿì¼ÿì½£á½ê)½ÿ×½ÿ×¾ÿì¾ ÿì¾ÿì¾ ÿì¿£á¿ê)¿ÿ׿ÿ×ÀÿìÀ ÿìÀÿìÀ ÿìÃÿÃà ÿÃÃÿ×æÿ×üÿ…ÃÁÿ®ÃÄÿ×ÃÜÿ×ÃÝÿìÃáÿìÃäÿ×ÃöÿìÃÿÃà ÿÃÃ|ÿ®Ã€ÿÃÂÿÃéÿ×êÿ×õÿ…öÿ×÷ÿšÃ¹ÿšÃ½ÿ×þÿ×ÿÿ®ÃÀÿìÃÁÿ®ÃÂÿìÃÔÿ®ÃÕÿìÃøÿìÃúÿìÃüÿìÃýÿ®Ãþÿìà ÿ®Ãÿ×Ãÿ®Ãÿ×Ãÿ×Ãÿ×ÄÿšÄ ÿšÄÜÿ×ÄÝÿ×Ääÿ×Äöÿ×ÄÿšÄ ÿšÄªÿ×Ķÿ×ĸÿ×ĺÿ׾ÿ×Äøÿ×Äúÿ×Äüÿ×Äÿ®Äÿ®Äÿ׿ÿ×Å€ÿìÅ‚ÿìŵÿ×Å·ÿìŹÿìÅ ÿìÅÿìÆÿìÆ ÿìÆÿìÆ ÿìǼÿ×Ç€ÿìÇ‚ÿìǵÿ×Ç·ÿìǹÿìÇ ÿìÇÿìÈÿìÈ ÿìÈÿìÈ ÿìÊŸÿ×ʸÿ×Ê»ÿ×ʾÿ×ÊÁÿ×Êáÿ×Êlÿ×Ê|ÿ×Ê~ÿ×Ê„ÿ×ʆÿ×ʈÿ×ÊŠÿ×ÊŒÿ×ʱÿ×ʳÿ×Ê¿ÿ×ÊÀÿ×ÊÁÿ×ÊÂÿ×ÊÅÿšÊÇÿšÊÔÿ×ÊÕÿ×Êïÿ×Êñÿ×Êóÿ×Êýÿ×Êþÿ×Ê ÿ×Ê ÿ×Êÿ×Êÿ×Êÿ×ÊÿìËÏÿ×ËØÿ×ËÛÿ×ËÞÿ×Ëáÿ×Ëêÿ×Ëíÿ×Ëjÿ×Ëÿ×Ë…ÿסÿ×ˉÿ×Ëÿ×˲ÿ×Ë´ÿ×ËÀÿ×ËÂÿ×ËÆÿ×ËÈÿ×ËÕÿ×Ëàÿ×Ëðÿ×Ëòÿ×Ëôÿ×Ëþÿ×Ë ÿ×Ë ÿ×Ëÿ×Ëÿ×ÌÿÃÌ ÿÃÌ£f̼ÿ×̾ÿ×ÌÁÿ®ÌÜÿÃÌáÿ×ÌäÿÃÌÿÃÌ ÿÃÌmÿìÌ|ÿ®Ì€ÿ×ÌÿìÌ‚ÿ×̃ÿìÌ‹ÿì̪ÿÃ̵ÿ×̶ÿÃÌ·ÿ×̸ÿì̹ÿ×̺ÿì̾ÿÃÌ¿ÿ®ÌÀÿ×ÌÁÿ®ÌÂÿ×ÌÅÿÃÌÆÿ×ÌÇÿÃÌÈÿ×ÌÔÿ®ÌÕÿ×Ìýÿ®Ìþÿ×Ì ÿ×ÌÿÃÌÿ×ÌÿÃÌÿÃÍáÿ×ÍÀÿ×ÍÂÿ×ÍÕÿ×Íþÿ×ΣáÎê)Îÿ×Îÿ×ÏÿìÏ ÿìÏÿìÏ ÿìÒ£áÒê)Òÿ×Òÿ×ÓÿìÓ ÿìÓÿìÓ ÿìÖ£áÖê)Öÿ×Öÿ××ÿì× ÿì×ÿì× ÿìÙÿqÙ ÿqÙÿšÙ¦ÿšÙ¼ÿqÙ¾ÿ×ÙÁÿšÙÄÿšÙÜÿ×Ùáÿ×Ùäÿ×ÙÿqÙ ÿqÙnÿ×Ù|ÿšÙ€ÿ®Ù‚ÿ®Ù—ÿ×Ù›ÿ×Ù§ÿ×Ù©ÿšÙªÿ×ÙµÿqÙ¶ÿ×Ù·ÿ…Ù¹ÿ…Ù½ÿšÙ¾ÿ×Ù¿ÿšÙÀÿ×ÙÁÿšÙÂÿ×ÙÅÿšÙÇÿšÙÔÿšÙÕÿ×Ùáÿ×Ùãÿ×ÙýÿšÙþÿ×Ùÿ×Ù ÿqÙÿ×ÙÿqÙÿ×ÙÿšÙÿ×ÚÿìÚ ÿìÚÿìÚ ÿìÛÿqÛ ÿqÛÿšÛ¦ÿšÛ¼ÿqÛ¾ÿ×ÛÁÿšÛÄÿšÛÜÿ×Ûáÿ×Ûäÿ×ÛÿqÛ ÿqÛnÿ×Û|ÿšÛ€ÿ®Û‚ÿ®Û—ÿ×Û›ÿ×Û§ÿ×Û©ÿšÛªÿ×ÛµÿqÛ¶ÿ×Û·ÿ…Û¹ÿ…Û½ÿšÛ¾ÿ×Û¿ÿšÛÀÿ×ÛÁÿšÛÂÿ×ÛÅÿšÛÇÿšÛÔÿšÛÕÿ×Ûáÿ×Ûãÿ×ÛýÿšÛþÿ×Ûÿ×Û ÿqÛÿ×ÛÿqÛÿ×ÛÿšÛÿ×ÜÿìÜ ÿìÜÿìÜ ÿìÞÿìÞ ÿìÞÿìÞ ÿìàÿìà ÿìàÿìà ÿìáÿ®áÿ®áÿìá¤ÿ×á¦ÿìá¨ÿ×áªÿ×á®ÿ×á°ÿ×á±ÿìáµÿ×á¼ÿÃá½ÿ×á¿ÿ×áÁÿ×áÄÿìáÇÿìáÎÿìáÕÿìáòÿìáÿ®á ÿ®árÿ×ásÿìázÿìá|ÿ×á€ÿìá‚ÿìáŸÿ×á¡ÿìá©ÿìáµÿÃá·ÿìá¹ÿìá»ÿ×á½ÿìá¿ÿ×áÁÿ×áÊÿ×áÎÿ×áÏÿìáÔÿ×áÙÿ×áÛÿ×áÝÿ×áåÿ×áçÿìáõÿìá÷ÿ×áùÿ×áûÿ×áýÿ×áÿ×áÿ×á ÿ×áÿ×áÿ×áÿìáÿìáÿ×áÿìâÿìâ ÿìâÐÿ×âÜÿìâÝÿìâßÿ×âáÿìâäÿìâöÿìâÿìâ ÿìâ ÿ×âªÿìâ¶ÿìâ¼ÿ×â¾ÿìâÀÿìâÂÿìâËÿ×âÕÿìâæÿ×âøÿìâúÿìâüÿìâþÿìâÿ×âÿ×âÿìâÿìâÿìãÿ®ãÿ®ãÿìã¤ÿ×ã¦ÿìã¨ÿ×ãªÿ×ã®ÿ×ã°ÿ×ã±ÿìãµÿ×ã¼ÿÃã½ÿ×ã¿ÿ×ãÁÿ×ãÄÿìãÇÿìãÎÿìãÕÿìãòÿìãÿ®ã ÿ®ãrÿ×ãsÿìãzÿìã|ÿ×ã€ÿìã‚ÿìãŸÿ×ã¡ÿìã©ÿìãµÿÃã·ÿìã¹ÿìã»ÿ×ã½ÿìã¿ÿ×ãÁÿ×ãÊÿ×ãÎÿ×ãÏÿìãÔÿ×ãÙÿ×ãÛÿ×ãÝÿ×ãåÿ×ãçÿìãõÿìã÷ÿ×ãùÿ×ãûÿ×ãýÿ×ãÿ×ãÿ×ã ÿ×ãÿ×ãÿ×ãÿìãÿìãÿ×ãÿìäÿìä ÿìäÐÿ×äÜÿìäÝÿìäßÿ×äáÿìääÿìäöÿìäÿìä ÿìä ÿ×äªÿìä¶ÿìä¼ÿ×ä¾ÿìäÀÿìäÂÿìäËÿ×äÕÿìäæÿ×äøÿìäúÿìäüÿìäþÿìäÿ×äÿ×äÿìäÿìäÿìåŸÿ×å¸ÿ×å»ÿ×å¾ÿ×åÁÿ×åáÿ×ålÿ×å|ÿ×å~ÿ×å„ÿ×å†ÿ×åˆÿ×åŠÿ×åŒÿ×å±ÿ×å³ÿ×å¿ÿ×åÀÿ×åÁÿ×åÂÿ×åÅÿšåÇÿšåÔÿ×åÕÿ×åïÿ×åñÿ×åóÿ×åýÿ×åþÿ×å ÿ×å ÿ×åÿ×åÿ×åÿ×åÿìæÏÿ×æØÿ×æÛÿ×æÞÿ×æáÿ×æêÿ×æíÿ×æjÿ×æÿ×æ…ÿ×æ‡ÿ×æ‰ÿ×æÿ×æ²ÿ×æ´ÿ×æÀÿ×æÂÿ×æÆÿ×æÈÿ×æÕÿ×æàÿ×æðÿ×æòÿ×æôÿ×æþÿ×æ ÿ×æ ÿ×æÿ×æÿ×çÿ®çÿ®çÿ®ç ÿ®ç€ÿìç‚ÿìç·ÿìç¹ÿìç ÿ×çÿ×èé)éÿìé ÿìéÿìé ÿìéÿ×éÿ×ïÿ®ïÿ®ïÿìï¤ÿ×ï¦ÿìï¨ÿ×ïªÿ×ï®ÿ×ï°ÿ×ï±ÿìïµÿ×ï¼ÿÃï½ÿ×ï¿ÿ×ïÁÿ×ïÄÿìïÇÿìïÎÿìïÕÿìïòÿìïÿ®ï ÿ®ïrÿ×ïsÿìïzÿìï|ÿ×ï€ÿìï‚ÿìïŸÿ×ï¡ÿìï©ÿìïµÿÃï·ÿìï¹ÿìï»ÿ×ï½ÿìï¿ÿ×ïÁÿ×ïÊÿ×ïÎÿ×ïÏÿìïÔÿ×ïÙÿ×ïÛÿ×ïÝÿ×ïåÿ×ïçÿìïõÿìï÷ÿ×ïùÿ×ïûÿ×ïýÿ×ïÿ×ïÿ×ï ÿ×ïÿ×ïÿ×ïÿìïÿìïÿ×ïÿìðÿìð ÿìðÐÿ×ðÜÿìðÝÿìðßÿ×ðáÿìðäÿìðöÿìðÿìð ÿìð ÿ×ðªÿìð¶ÿìð¼ÿ×ð¾ÿìðÀÿìðÂÿìðËÿ×ðÕÿìðæÿ×ðøÿìðúÿìðüÿìðþÿìðÿ×ðÿ×ðÿìðÿìðÿìñÿ®ñÿ®ñÿìñ¤ÿ×ñ¦ÿìñ¨ÿ×ñªÿ×ñ®ÿ×ñ°ÿ×ñ±ÿìñµÿ×ñ¼ÿÃñ½ÿ×ñ¿ÿ×ñÁÿ×ñÄÿìñÇÿìñÎÿìñÕÿìñòÿìñÿ®ñ ÿ®ñrÿ×ñsÿìñzÿìñ|ÿ×ñ€ÿìñ‚ÿìñŸÿ×ñ¡ÿìñ©ÿìñµÿÃñ·ÿìñ¹ÿìñ»ÿ×ñ½ÿìñ¿ÿ×ñÁÿ×ñÊÿ×ñÎÿ×ñÏÿìñÔÿ×ñÙÿ×ñÛÿ×ñÝÿ×ñåÿ×ñçÿìñõÿìñ÷ÿ×ñùÿ×ñûÿ×ñýÿ×ñÿ×ñÿ×ñ ÿ×ñÿ×ñÿ×ñÿìñÿìñÿ×ñÿìòÿìò ÿìòÐÿ×òÜÿìòÝÿìòßÿ×òáÿìòäÿìòöÿìòÿìò ÿìò ÿ×òªÿìò¶ÿìò¼ÿ×ò¾ÿìòÀÿìòÂÿìòËÿ×òÕÿìòæÿ×òøÿìòúÿìòüÿìòþÿìòÿ×òÿ×òÿìòÿìòÿìóÿ®óÿ®óÿìó¤ÿ×ó¦ÿìó¨ÿ×óªÿ×ó®ÿ×ó°ÿ×ó±ÿìóµÿ×ó¼ÿÃó½ÿ×ó¿ÿ×óÁÿ×óÄÿìóÇÿìóÎÿìóÕÿìóòÿìóÿ®ó ÿ®órÿ×ósÿìózÿìó|ÿ×ó€ÿìó‚ÿìóŸÿ×ó¡ÿìó©ÿìóµÿÃó·ÿìó¹ÿìó»ÿ×ó½ÿìó¿ÿ×óÁÿ×óÊÿ×óÎÿ×óÏÿìóÔÿ×óÙÿ×óÛÿ×óÝÿ×óåÿ×óçÿìóõÿìó÷ÿ×óùÿ×óûÿ×óýÿ×óÿ×óÿ×ó ÿ×óÿ×óÿ×óÿìóÿìóÿ×óÿìôÿìô ÿìôÐÿ×ôÜÿìôÝÿìôßÿ×ôáÿìôäÿìôöÿìôÿìô ÿìô ÿ×ôªÿìô¶ÿìô¼ÿ×ô¾ÿìôÀÿìôÂÿìôËÿ×ôÕÿìôæÿ×ôøÿìôúÿìôüÿìôþÿìôÿ×ôÿ×ôÿìôÿìôÿìõÿ®õÿ®õÿìõ¤ÿ×õ¦ÿìõ¨ÿ×õªÿ×õ®ÿ×õ°ÿ×õ±ÿìõµÿ×õ¼ÿÃõ½ÿ×õ¿ÿ×õÁÿ×õÄÿìõÇÿìõÎÿìõÕÿìõòÿìõÿ®õ ÿ®õrÿ×õsÿìõzÿìõ|ÿ×õ€ÿìõ‚ÿìõŸÿ×õ¡ÿìõ©ÿìõµÿÃõ·ÿìõ¹ÿìõ»ÿ×õ½ÿìõ¿ÿ×õÁÿ×õÊÿ×õÎÿ×õÏÿìõÔÿ×õÙÿ×õÛÿ×õÝÿ×õåÿ×õçÿìõõÿìõ÷ÿ×õùÿ×õûÿ×õýÿ×õÿ×õÿ×õ ÿ×õÿ×õÿ×õÿìõÿìõÿ×õÿìöÿìö ÿìöÐÿ×öÜÿìöÝÿìößÿ×öáÿìöäÿìööÿìöÿìö ÿìö ÿ×öªÿìö¶ÿìö¼ÿ×ö¾ÿìöÀÿìöÂÿìöËÿ×öÕÿìöæÿ×öøÿìöúÿìöüÿìöþÿìöÿ×öÿ×öÿìöÿìöÿì÷ÿ…÷ÿ…÷Ÿÿì÷¤ÿš÷ªÿq÷®ÿš÷µÿš÷¸ÿì÷»ÿì÷¾ÿÃ÷Éÿì÷Îÿ®÷Ïÿ×÷Õÿ®÷Øÿ×÷Ûÿ×÷Þÿ×÷áÿ×÷êÿ×÷ëf÷íÿ×÷îÿì÷òÿ®÷ôf÷ÿ…÷ ÿ…÷jÿ×÷lÿì÷rÿq÷sÿ®÷~ÿì÷ÿ×÷„ÿì÷…ÿ×÷†ÿì÷‡ÿ×÷ˆÿì÷‰ÿ×÷Šÿì÷Œÿì÷ÿ×÷˜f÷¨f÷±ÿì÷²ÿ×÷³ÿì÷´ÿ×÷Àÿ×÷Âÿ×÷Åÿ×÷ÆÿÃ÷Çÿ×÷ÈÿÃ÷Îÿš÷Ïÿ®÷Õÿ×÷Ùÿq÷Ûÿq÷Ýÿq÷àÿ×÷ïÿì÷ðÿ×÷ñÿì÷òÿ×÷óÿì÷ôÿ×÷þÿ×÷ ÿq÷ ÿ×÷ ÿq÷ ÿ×÷ÿš÷ÿ®÷ÿì÷ÿ×÷ÿ×÷ÿš÷ÿ®øÿ®øÿ®øÎÿ×øÕÿ×øòÿ×øÿ®ø ÿ®øsÿ×øÏÿ×øÿ×øÿ×ùÿ…ùÿ…ùŸÿìù¤ÿšùªÿqù®ÿšùµÿšù¸ÿìù»ÿìù¾ÿÃùÉÿìùÎÿ®ùÏÿ×ùÕÿ®ùØÿ×ùÛÿ×ùÞÿ×ùáÿ×ùêÿ×ùëfùíÿ×ùîÿìùòÿ®ùôfùÿ…ù ÿ…ùjÿ×ùlÿìùrÿqùsÿ®ù~ÿìùÿ×ù„ÿìù…ÿ×ù†ÿìù‡ÿ×ùˆÿìù‰ÿ×ùŠÿìùŒÿìùÿ×ù˜fù¨fù±ÿìù²ÿ×ù³ÿìù´ÿ×ùÀÿ×ùÂÿ×ùÅÿ×ùÆÿÃùÇÿ×ùÈÿÃùÎÿšùÏÿ®ùÕÿ×ùÙÿqùÛÿqùÝÿqùàÿ×ùïÿìùðÿ×ùñÿìùòÿ×ùóÿìùôÿ×ùþÿ×ù ÿqù ÿ×ù ÿqù ÿ×ùÿšùÿ®ùÿìùÿ×ùÿ×ùÿšùÿ®úÿ®úÿ®úÎÿ×úÕÿ×úòÿ×úÿ®ú ÿ®úsÿ×úÏÿ×úÿ×úÿ×ûÿ…ûÿ…ûŸÿìû¤ÿšûªÿqû®ÿšûµÿšû¸ÿìû»ÿìû¾ÿÃûÉÿìûÎÿ®ûÏÿ×ûÕÿ®ûØÿ×ûÛÿ×ûÞÿ×ûáÿ×ûêÿ×ûëfûíÿ×ûîÿìûòÿ®ûôfûÿ…û ÿ…ûjÿ×ûlÿìûrÿqûsÿ®û~ÿìûÿ×û„ÿìû…ÿ×û†ÿìû‡ÿ×ûˆÿìû‰ÿ×ûŠÿìûŒÿìûÿ×û˜fû¨fû±ÿìû²ÿ×û³ÿìû´ÿ×ûÀÿ×ûÂÿ×ûÅÿ×ûÆÿÃûÇÿ×ûÈÿÃûÎÿšûÏÿ®ûÕÿ×ûÙÿqûÛÿqûÝÿqûàÿ×ûïÿìûðÿ×ûñÿìûòÿ×ûóÿìûôÿ×ûþÿ×û ÿqû ÿ×û ÿqû ÿ×ûÿšûÿ®ûÿìûÿ×ûÿ×ûÿšûÿ®üÿ®üÿ®üÎÿ×üÕÿ×üòÿ×üÿ®ü ÿ®üsÿ×üÏÿ×üÿ×üÿ×ÿÿ…ÿÿ®ÿÿ…ÿŸÿ×ÿ¤ÿšÿªÿqÿ®ÿšÿµÿšÿ¸ÿ×ÿ»ÿ×ÿ¼)ÿ¾ÿ®ÿÌÿšÿÍÿšÿÎÿ…ÿÏÿqÿÐÿ×ÿÑÿ×ÿÒÿšÿÓÿšÿÔÿšÿÕÿ…ÿÖÿšÿ×ÿšÿØÿqÿÙÿšÿÚÿšÿÛÿqÿÜÿ®ÿÝÿ®ÿÞÿqÿßÿ×ÿàÿšÿáÿšÿâÿšÿãÿšÿäÿ®ÿåÿšÿæÿšÿçÿ×ÿèÿšÿéÿÃÿêÿqÿìÿšÿíÿqÿîÿ…ÿòÿ…ÿóÿšÿõÿšÿöÿ®ÿ÷ÿšÿùÿšÿÿ®ÿÿ®ÿÿ®ÿÿ…ÿ ÿ…ÿjÿqÿkÿšÿlÿ×ÿmÿ×ÿqÿšÿrÿqÿsÿ…ÿuÿšÿwÿšÿyÿšÿ}ÿšÿ~ÿ×ÿÿqÿÿ×ÿƒÿ×ÿ„ÿ×ÿ…ÿqÿ†ÿ×ÿ‡ÿqÿˆÿ×ÿ‰ÿqÿŠÿ×ÿ‹ÿ×ÿŒÿ×ÿÿqÿ–ÿšÿšÿšÿžÿšÿ ÿ×ÿ¢ÿ×ÿ¤ÿšÿ¦ÿšÿªÿ®ÿ¬ÿšÿ®ÿšÿ°ÿšÿ±ÿ×ÿ²ÿqÿ³ÿ×ÿ´ÿqÿµ)ÿ¶ÿ®ÿ¸ÿ®ÿºÿ®ÿ¼ÿ×ÿ¾ÿ®ÿÀÿšÿÂÿšÿÄÿšÿÅÿšÿÆÿqÿÇÿšÿÈÿqÿËÿ×ÿÍÿšÿÎÿšÿÏÿ…ÿÑÿšÿÓÿšÿÕÿšÿ×ÿšÿÙÿqÿÛÿqÿÝÿqÿàÿqÿæÿ×ÿèÿ×ÿêÿÃÿìÿšÿîÿšÿïÿ×ÿðÿqÿñÿ×ÿòÿqÿóÿ×ÿôÿqÿöÿ×ÿøÿ®ÿúÿ®ÿüÿ®ÿþÿšÿÿšÿÿšÿÿ×ÿÿ×ÿ ÿqÿ ÿqÿ ÿqÿ ÿqÿÿšÿÿšÿÿšÿÿ…ÿÿšÿÿ×ÿÿqÿÿ®ÿÿqÿÿšÿÿ…ÿšÿ×ÿšÎÿÃÏÿìÕÿÃØÿìÛÿìÞÿìêÿìíÿìòÿÃÿ×ÿ×ÿ×ÿš ÿšjÿìsÿÃÿì…ÿì‡ÿì‰ÿìÿì²ÿì´ÿìÏÿÃàÿìðÿìòÿìôÿì ÿì ÿìÿÃÿìÿìÿÃÿšÿ×ÿš)Ÿÿפÿ®¦)ªÿ…®ÿ®µÿ®¸ÿ×»ÿ×¼)¾ÿÃÄ)ÌÿÃÍÿÃÎÿšÏÿ®Ðÿ×Ñÿ×ÒÿÃÓÿÃÔÿÃÕÿšÖÿÃ×ÿÃØÿ®ÙÿÃÚÿÃÛÿ®Þÿ®ßÿ×àÿÃáÿšâÿÃãÿÃåÿÃæÿÃçÿ×èÿÃêÿ®ë)ìÿÃíÿ®îÿÃòÿšóÿÃô)õÿÃ÷ÿÃùÿÃÿ×ÿ×ÿ×ÿš ÿšjÿ®kÿÃlÿ×qÿÃrÿ…sÿšuÿÃwÿ×yÿÃ}ÿÃ~ÿ×ÿ®„ÿ×…ÿ®†ÿׇÿ®ˆÿ׉ÿ®Šÿ׌ÿ×ÿ®–ÿØ)šÿÞÿàÿ×¢ÿפÿæÿè)©)¬ÿîÿðÿñÿײÿ®³ÿ×´ÿ®µ)¼ÿ×½)ÀÿšÂÿšÄÿÃÅÿ×ÆÿÃÇÿ×ÈÿÃËÿ×ÍÿÃÎÿ®ÏÿšÑÿÃÓÿÃÕÿš×ÿÃÙÿ…Ûÿ…Ýÿ…àÿ®æÿ×èÿ×ìÿÃîÿÃïÿ×ðÿ®ñÿ×òÿ®óÿ×ôÿ®öÿ×þÿšÿÃÿÃÿ×ÿ× ÿš ÿ® ÿš ÿ®ÿ×ÿ×ÿ®ÿšÿÃÿ×ÿ®)ÿ®ÿ®ÿšÿÃÿÃÎÿÃÏÿ×ÕÿÃØÿ×Ûÿ×Þÿ×êÿ×íÿ×òÿÃÿà ÿÃjÿ×sÿÃÿ×…ÿׇÿ׉ÿ×ÿײÿ×´ÿ×ÏÿÃàÿ×ðÿ×òÿ×ôÿ× ÿ× ÿ×ÿÃÿ×ÿ×ÿßÿ×£á¸ÿ×»ÿ×¾ÿÃÜÿ×áÿ®äÿ×lÿ×{=}ÿì~ÿׄÿ׆ÿ׈ÿ׊ÿ׌ÿתÿ×±ÿ׳ÿ׶ÿ×¾ÿ×Àÿ®Âÿ®ÅÿÃÆÿ×ÇÿÃÈÿ×Õÿ®ïÿ×ñÿ×óÿ×þÿ®ÿ×ÿ×ÿ×ÿ×ÏÿìØÿìÛÿìÞÿìáÿìêÿìíÿìjÿìÿì…ÿì‡ÿì‰ÿìÿì²ÿì´ÿìÀÿìÂÿìÕÿìàÿìðÿìòÿìôÿìþÿì ÿì ÿìÿ×ÿ×ÿìÿìŸÿ׸ÿ×»ÿ×¾ÿ×Áÿ×áÿ×lÿ×|ÿ×~ÿׄÿ׆ÿ׈ÿ׊ÿ׌ÿ×±ÿ׳ÿ׿ÿ×Àÿ×Áÿ×Âÿ×ÅÿšÇÿšÔÿ×Õÿ×ïÿ×ñÿ×óÿ×ýÿ×þÿ× ÿ× ÿ×ÿ×ÿ×ÿ×ÿìÏÿìØÿìÛÿìÞÿìáÿìêÿìíÿìjÿìÿì…ÿì‡ÿì‰ÿìÿì²ÿì´ÿìÀÿìÂÿìÕÿìàÿìðÿìòÿìôÿìþÿì ÿì ÿìÿ×ÿ×ÿìÿì ÿš ÿš ÿ® ¦ÿ® ¨ÿà ªÿà °ÿà ¼ÿq ½ÿà ¿ÿà Áÿà Äÿ® Ðÿ× Üÿà ßÿ× áÿ× äÿà ÿš  ÿš rÿà vÿ× |ÿà €ÿà ‚ÿà Ÿÿà  ÿ× ©ÿ® ªÿà µÿq ¶ÿà ·ÿà ¹ÿà »ÿà ¼ÿ× ½ÿ® ¾ÿà ¿ÿà Àÿ× Áÿà Âÿ× Êÿà Ëÿ× Ôÿà Õÿ× Ùÿà Ûÿà Ýÿà åÿà æÿ× ÷ÿà ùÿà ûÿà ýÿà þÿ× ÿà ÿ× ÿà ÿ×  ÿ× ÿ× ÿ× ÿ× ÿ® ÿà ÿš ÿš Ðÿ× Üÿà Ýÿ× ßÿ× áÿ× äÿà öÿ× ÿš  ÿš  ÿ× ªÿà ¶ÿà ¼ÿ× ¾ÿà Àÿ× Âÿ× Ëÿ× Õÿ× æÿ× øÿ× úÿ× üÿ× þÿ× ÿ× ÿ× ÿš ÿš ÿà ÿš ÿš ÿ® ¦ÿ® ¨ÿà ªÿà °ÿà ¼ÿq ½ÿà ¿ÿà Áÿà Äÿ® Ðÿ× Üÿà ßÿ× áÿ× äÿà ÿš  ÿš rÿà vÿ× |ÿà €ÿà ‚ÿà Ÿÿà  ÿ× ©ÿ® ªÿà µÿq ¶ÿà ·ÿà ¹ÿà »ÿà ¼ÿ× ½ÿ® ¾ÿà ¿ÿà Àÿ× Áÿà Âÿ× Êÿà Ëÿ× Ôÿà Õÿ× Ùÿà Ûÿà Ýÿà åÿà æÿ× ÷ÿà ùÿà ûÿà ýÿà þÿ× ÿà ÿ× ÿà ÿ×  ÿ× ÿ× ÿ× ÿ× ÿ® ÿÃÿš ÿšÐÿ×ÜÿÃÝÿ×ßÿ×áÿ×äÿÃöÿ×ÿš ÿš ÿתÿöÿüÿ×¾ÿÃÀÿ×Âÿ×Ëÿ×Õÿ×æÿ×øÿ×úÿ×üÿ×þÿ×ÿ×ÿ×ÿšÿšÿãáê)ÿ×ÿ×ÿì ÿìÿì ÿìÿš ÿšÿ®¦ÿ®¨ÿêÿðÿüÿq½ÿÿÿÃÁÿÃÄÿ®Ðÿ×ÜÿÃßÿ×áÿ×äÿÃÿš ÿšrÿÃvÿ×|ÿÀÿÂÿßÿàÿשÿ®ªÿõÿq¶ÿ÷ÿùÿûÿüÿ×½ÿ®¾ÿÿÿÃÀÿ×ÁÿÃÂÿ×ÊÿÃËÿ×ÔÿÃÕÿ×ÙÿÃÛÿÃÝÿÃåÿÃæÿ×÷ÿÃùÿÃûÿÃýÿÃþÿ×ÿÃÿ×ÿÃÿ× ÿ×ÿ×ÿ×ÿ×ÿ®ÿÃÿš ÿšÐÿ×ÜÿÃÝÿ×ßÿ×áÿ×äÿÃöÿ×ÿš ÿš ÿתÿöÿüÿ×¾ÿÃÀÿ×Âÿ×Ëÿ×Õÿ×æÿ×øÿ×úÿ×üÿ×þÿ×ÿ×ÿ×ÿšÿšÿÃÿš ÿšÿ®¦ÿ®¨ÿêÿðÿüÿq½ÿÿÿÃÁÿÃÄÿ®Ðÿ×ÜÿÃßÿ×áÿ×äÿÃÿš ÿšrÿÃvÿ×|ÿÀÿÂÿßÿàÿשÿ®ªÿõÿq¶ÿ÷ÿùÿûÿüÿ×½ÿ®¾ÿÿÿÃÀÿ×ÁÿÃÂÿ×ÊÿÃËÿ×ÔÿÃÕÿ×ÙÿÃÛÿÃÝÿÃåÿÃæÿ×÷ÿÃùÿÃûÿÃýÿÃþÿ×ÿÃÿ×ÿÃÿ× ÿ×ÿ×ÿ×ÿ×ÿ®ÿÃÿš ÿšÐÿ×ÜÿÃÝÿ×ßÿ×áÿ×äÿÃöÿ×ÿš ÿš ÿתÿöÿüÿ×¾ÿÃÀÿ×Âÿ×Ëÿ×Õÿ×æÿ×øÿ×úÿ×üÿ×þÿ×ÿ×ÿ×ÿšÿšÿÃÿ®ÿ®ªÿì°ÿ×¼ÿ׿ÿ×ÿ® ÿ®rÿì€ÿì‚ÿìŸÿ×µÿ×·ÿì¹ÿì»ÿ×Êÿ×ÙÿìÛÿìÝÿìåÿ×ÿ×ÿ×ÿ× ÿ×ÐÿìÝÿìßÿìöÿìÿ× ÿ× ÿì¼ÿìËÿìæÿìøÿìúÿìüÿìÿìÿìÿ×ÿ×ÿ® ÿ®ÿæÿêÿ×°ÿ×¼ÿÿÿ×Áÿ×ÄÿÃÜÿ×äÿ×ÿ® ÿ®rÿ×|ÿ×€ÿׂÿןÿשÿêÿ×µÿöÿ×·ÿ×¹ÿ×»ÿ×½ÿþÿ׿ÿ×Áÿ×Êÿ×Ôÿ×Ùÿ×Ûÿ×Ýÿ×åÿ×ýÿ×ÿ×ÿ× ÿ×ÿ×ÿÃÿ×ÿš ÿšÐÿ×ÜÿÃÝÿ×ßÿ×áÿ×äÿÃöÿ×ÿš ÿš ÿתÿöÿüÿ×¾ÿÃÀÿ×Âÿ×Ëÿ×Õÿ×æÿ×øÿ×úÿ×üÿ×þÿ×ÿ×ÿ×ÿšÿšÿÃáÿ×Àÿ×Âÿ×Õÿ×þÿ×£áê)ÿ×ÿ×ÿì ÿìÿì ÿìÿq ÿq&ÿ×*ÿ×- 2ÿ×4ÿ×7ÿq9ÿ®:ÿ®<ÿ…‰ÿ×”ÿוÿ×–ÿ×—ÿטÿךÿןÿ…Èÿ×Êÿ×Ìÿ×Îÿ×Þÿ×àÿ×âÿ×äÿ×ÿ×ÿ×ÿ×ÿ×$ÿq&ÿq6ÿ®8ÿ…:ÿ…Gÿ×úÿ®üÿ®þÿ®ÿ…ÿq ÿq_ÿ×Iÿ×Kÿ×Mÿ×Oÿ×Qÿ×Sÿ×Uÿ×Wÿ×Yÿ×[ÿ×]ÿ×_ÿ×oÿ…qÿ…sÿ…ÿqÿì ÿìÿì ÿìÿq ÿq&ÿ×*ÿ×- 2ÿ×4ÿ×7ÿq9ÿ®:ÿ®<ÿ…‰ÿ×”ÿוÿ×–ÿ×—ÿטÿךÿןÿ…Èÿ×Êÿ×Ìÿ×Îÿ×Þÿ×àÿ×âÿ×äÿ×ÿ×ÿ×ÿ×ÿ×$ÿq&ÿq6ÿ®8ÿ…:ÿ…Gÿ×úÿ®üÿ®þÿ®ÿ…ÿq ÿq_ÿ×Iÿ×Kÿ×Mÿ×Oÿ×Qÿ×Sÿ×Uÿ×Wÿ×Yÿ×[ÿ×]ÿ×_ÿ×oÿ…qÿ…sÿ…ÿq ÿì ÿì ÿì  ÿì!ÿq! ÿq!&ÿ×!*ÿ×!- !2ÿ×!4ÿ×!7ÿq!9ÿ®!:ÿ®!<ÿ…!‰ÿ×!”ÿ×!•ÿ×!–ÿ×!—ÿ×!˜ÿ×!šÿ×!Ÿÿ…!Èÿ×!Êÿ×!Ìÿ×!Îÿ×!Þÿ×!àÿ×!âÿ×!äÿ×!ÿ×!ÿ×!ÿ×!ÿ×!$ÿq!&ÿq!6ÿ®!8ÿ…!:ÿ…!Gÿ×!úÿ®!üÿ®!þÿ®!ÿ…!ÿq! ÿq!_ÿ×!Iÿ×!Kÿ×!Mÿ×!Oÿ×!Qÿ×!Sÿ×!Uÿ×!Wÿ×!Yÿ×![ÿ×!]ÿ×!_ÿ×!oÿ…!qÿ…!sÿ…!ÿq"ÿì" ÿì"ÿì" ÿì#ÿq# ÿq#&ÿ×#*ÿ×#- #2ÿ×#4ÿ×#7ÿq#9ÿ®#:ÿ®#<ÿ…#‰ÿ×#”ÿ×#•ÿ×#–ÿ×#—ÿ×#˜ÿ×#šÿ×#Ÿÿ…#Èÿ×#Êÿ×#Ìÿ×#Îÿ×#Þÿ×#àÿ×#âÿ×#äÿ×#ÿ×#ÿ×#ÿ×#ÿ×#$ÿq#&ÿq#6ÿ®#8ÿ…#:ÿ…#Gÿ×#úÿ®#üÿ®#þÿ®#ÿ…#ÿq# ÿq#_ÿ×#Iÿ×#Kÿ×#Mÿ×#Oÿ×#Qÿ×#Sÿ×#Uÿ×#Wÿ×#Yÿ×#[ÿ×#]ÿ×#_ÿ×#oÿ…#qÿ…#sÿ…#ÿq$ÿì$ ÿì$ÿì$ ÿì%ÿq% ÿq%&ÿ×%*ÿ×%- %2ÿ×%4ÿ×%7ÿq%9ÿ®%:ÿ®%<ÿ…%‰ÿ×%”ÿ×%•ÿ×%–ÿ×%—ÿ×%˜ÿ×%šÿ×%Ÿÿ…%Èÿ×%Êÿ×%Ìÿ×%Îÿ×%Þÿ×%àÿ×%âÿ×%äÿ×%ÿ×%ÿ×%ÿ×%ÿ×%$ÿq%&ÿq%6ÿ®%8ÿ…%:ÿ…%Gÿ×%úÿ®%üÿ®%þÿ®%ÿ…%ÿq% ÿq%_ÿ×%Iÿ×%Kÿ×%Mÿ×%Oÿ×%Qÿ×%Sÿ×%Uÿ×%Wÿ×%Yÿ×%[ÿ×%]ÿ×%_ÿ×%oÿ…%qÿ…%sÿ…%ÿq&ÿì& ÿì&ÿì& ÿì'ÿq' ÿq'&ÿ×'*ÿ×'- '2ÿ×'4ÿ×'7ÿq'9ÿ®':ÿ®'<ÿ…'‰ÿ×'”ÿ×'•ÿ×'–ÿ×'—ÿ×'˜ÿ×'šÿ×'Ÿÿ…'Èÿ×'Êÿ×'Ìÿ×'Îÿ×'Þÿ×'àÿ×'âÿ×'äÿ×'ÿ×'ÿ×'ÿ×'ÿ×'$ÿq'&ÿq'6ÿ®'8ÿ…':ÿ…'Gÿ×'úÿ®'üÿ®'þÿ®'ÿ…'ÿq' ÿq'_ÿ×'Iÿ×'Kÿ×'Mÿ×'Oÿ×'Qÿ×'Sÿ×'Uÿ×'Wÿ×'Yÿ×'[ÿ×']ÿ×'_ÿ×'oÿ…'qÿ…'sÿ…'ÿq(ÿì( ÿì(ÿì( ÿì)ÿq) ÿq)&ÿ×)*ÿ×)- )2ÿ×)4ÿ×)7ÿq)9ÿ®):ÿ®)<ÿ…)‰ÿ×)”ÿ×)•ÿ×)–ÿ×)—ÿ×)˜ÿ×)šÿ×)Ÿÿ…)Èÿ×)Êÿ×)Ìÿ×)Îÿ×)Þÿ×)àÿ×)âÿ×)äÿ×)ÿ×)ÿ×)ÿ×)ÿ×)$ÿq)&ÿq)6ÿ®)8ÿ…):ÿ…)Gÿ×)úÿ®)üÿ®)þÿ®)ÿ…)ÿq) ÿq)_ÿ×)Iÿ×)Kÿ×)Mÿ×)Oÿ×)Qÿ×)Sÿ×)Uÿ×)Wÿ×)Yÿ×)[ÿ×)]ÿ×)_ÿ×)oÿ…)qÿ…)sÿ…)ÿq*ÿì* ÿì*ÿì* ÿì+ÿq+ ÿq+&ÿ×+*ÿ×+- +2ÿ×+4ÿ×+7ÿq+9ÿ®+:ÿ®+<ÿ…+‰ÿ×+”ÿ×+•ÿ×+–ÿ×+—ÿ×+˜ÿ×+šÿ×+Ÿÿ…+Èÿ×+Êÿ×+Ìÿ×+Îÿ×+Þÿ×+àÿ×+âÿ×+äÿ×+ÿ×+ÿ×+ÿ×+ÿ×+$ÿq+&ÿq+6ÿ®+8ÿ…+:ÿ…+Gÿ×+úÿ®+üÿ®+þÿ®+ÿ…+ÿq+ ÿq+_ÿ×+Iÿ×+Kÿ×+Mÿ×+Oÿ×+Qÿ×+Sÿ×+Uÿ×+Wÿ×+Yÿ×+[ÿ×+]ÿ×+_ÿ×+oÿ…+qÿ…+sÿ…+ÿq,ÿì, ÿì,ÿì, ÿì-ÿq- ÿq-&ÿ×-*ÿ×-- -2ÿ×-4ÿ×-7ÿq-9ÿ®-:ÿ®-<ÿ…-‰ÿ×-”ÿ×-•ÿ×-–ÿ×-—ÿ×-˜ÿ×-šÿ×-Ÿÿ…-Èÿ×-Êÿ×-Ìÿ×-Îÿ×-Þÿ×-àÿ×-âÿ×-äÿ×-ÿ×-ÿ×-ÿ×-ÿ×-$ÿq-&ÿq-6ÿ®-8ÿ…-:ÿ…-Gÿ×-úÿ®-üÿ®-þÿ®-ÿ…-ÿq- ÿq-_ÿ×-Iÿ×-Kÿ×-Mÿ×-Oÿ×-Qÿ×-Sÿ×-Uÿ×-Wÿ×-Yÿ×-[ÿ×-]ÿ×-_ÿ×-oÿ…-qÿ…-sÿ…-ÿq.ÿì. ÿì.ÿì. ÿì/ÿq/ ÿq/&ÿ×/*ÿ×/- /2ÿ×/4ÿ×/7ÿq/9ÿ®/:ÿ®/<ÿ…/‰ÿ×/”ÿ×/•ÿ×/–ÿ×/—ÿ×/˜ÿ×/šÿ×/Ÿÿ…/Èÿ×/Êÿ×/Ìÿ×/Îÿ×/Þÿ×/àÿ×/âÿ×/äÿ×/ÿ×/ÿ×/ÿ×/ÿ×/$ÿq/&ÿq/6ÿ®/8ÿ…/:ÿ…/Gÿ×/úÿ®/üÿ®/þÿ®/ÿ…/ÿq/ ÿq/_ÿ×/Iÿ×/Kÿ×/Mÿ×/Oÿ×/Qÿ×/Sÿ×/Uÿ×/Wÿ×/Yÿ×/[ÿ×/]ÿ×/_ÿ×/oÿ…/qÿ…/sÿ…/ÿq0ÿì0 ÿì0ÿì0 ÿì1ÿq1 ÿq1&ÿ×1*ÿ×1- 12ÿ×14ÿ×17ÿq19ÿ®1:ÿ®1<ÿ…1‰ÿ×1”ÿ×1•ÿ×1–ÿ×1—ÿ×1˜ÿ×1šÿ×1Ÿÿ…1Èÿ×1Êÿ×1Ìÿ×1Îÿ×1Þÿ×1àÿ×1âÿ×1äÿ×1ÿ×1ÿ×1ÿ×1ÿ×1$ÿq1&ÿq16ÿ®18ÿ…1:ÿ…1Gÿ×1úÿ®1üÿ®1þÿ®1ÿ…1ÿq1 ÿq1_ÿ×1Iÿ×1Kÿ×1Mÿ×1Oÿ×1Qÿ×1Sÿ×1Uÿ×1Wÿ×1Yÿ×1[ÿ×1]ÿ×1_ÿ×1oÿ…1qÿ…1sÿ…1ÿq2ÿì2 ÿì2ÿì2 ÿì3ÿq3 ÿq3&ÿ×3*ÿ×3- 32ÿ×34ÿ×37ÿq39ÿ®3:ÿ®3<ÿ…3‰ÿ×3”ÿ×3•ÿ×3–ÿ×3—ÿ×3˜ÿ×3šÿ×3Ÿÿ…3Èÿ×3Êÿ×3Ìÿ×3Îÿ×3Þÿ×3àÿ×3âÿ×3äÿ×3ÿ×3ÿ×3ÿ×3ÿ×3$ÿq3&ÿq36ÿ®38ÿ…3:ÿ…3Gÿ×3úÿ®3üÿ®3þÿ®3ÿ…3ÿq3 ÿq3_ÿ×3Iÿ×3Kÿ×3Mÿ×3Oÿ×3Qÿ×3Sÿ×3Uÿ×3Wÿ×3Yÿ×3[ÿ×3]ÿ×3_ÿ×3oÿ…3qÿ…3sÿ…3ÿq4ÿì4 ÿì4ÿì4 ÿì5-{6ÿì6 ÿì6Yÿ×6Zÿ×6[ÿ×6\ÿ×6]ÿì6¿ÿ×67ÿ×6<ÿì6>ÿì6@ÿì6ûÿ×6ýÿ×6ÿì6 ÿì6pÿ×7-{8ÿì8 ÿì8Yÿ×8Zÿ×8[ÿ×8\ÿ×8]ÿì8¿ÿ×87ÿ×8<ÿì8>ÿì8@ÿì8ûÿ×8ýÿ×8ÿì8 ÿì8pÿ×9-{:ÿì: ÿì:Yÿ×:Zÿ×:[ÿ×:\ÿ×:]ÿì:¿ÿ×:7ÿ×:<ÿì:>ÿì:@ÿì:ûÿ×:ýÿ×:ÿì: ÿì:pÿ×;-{<ÿì< ÿì<Yÿ×<Zÿ×<[ÿ×<\ÿ×<]ÿì<¿ÿ×<7ÿ×<<ÿì<>ÿì<@ÿì<ûÿ×<ýÿ×<ÿì< ÿì<pÿ×=-{>ÿì> ÿì>Yÿ×>Zÿ×>[ÿ×>\ÿ×>]ÿì>¿ÿ×>7ÿ×><ÿì>>ÿì>@ÿì>ûÿ×>ýÿ×>ÿì> ÿì>pÿ×?-{@ÿì@ ÿì@Yÿ×@Zÿ×@[ÿ×@\ÿ×@]ÿì@¿ÿ×@7ÿ×@<ÿì@>ÿì@@ÿì@ûÿ×@ýÿ×@ÿì@ ÿì@pÿ×A-{BÿìB ÿìBYÿ×BZÿ×B[ÿ×B\ÿ×B]ÿìB¿ÿ×B7ÿ×B<ÿìB>ÿìB@ÿìBûÿ×Býÿ×BÿìB ÿìBpÿ×C-{DÿìD ÿìDYÿ×DZÿ×D[ÿ×D\ÿ×D]ÿìD¿ÿ×D7ÿ×D<ÿìD>ÿìD@ÿìDûÿ×Dýÿ×DÿìD ÿìDpÿ×Iÿ®Iÿ®I$ÿ×I7ÿÃI9ÿìI:ÿìI;ÿ×I<ÿìI=ÿìI‚ÿ×Iƒÿ×I„ÿ×I…ÿ×I†ÿ×I‡ÿ×IŸÿìIÂÿ×IÄÿ×IÆÿ×I$ÿÃI&ÿÃI6ÿìI8ÿìI:ÿìI;ÿìI=ÿìI?ÿìICÿ×I ÿìIúÿìIüÿìIþÿìIÿìIÿ®I ÿ®IXÿ×Iÿ×Iÿ×I!ÿ×I#ÿ×I%ÿ×I'ÿ×I)ÿ×I+ÿ×I-ÿ×I/ÿ×I1ÿ×I3ÿ×IoÿìIqÿìIsÿìIÿÃJÿìJ ÿìJYÿ×JZÿ×J[ÿ×J\ÿ×J]ÿìJ¿ÿ×J7ÿ×J<ÿìJ>ÿìJ@ÿìJûÿ×Jýÿ×JÿìJ ÿìJpÿ×Kÿ®Kÿ®K$ÿ×K7ÿÃK9ÿìK:ÿìK;ÿ×K<ÿìK=ÿìK‚ÿ×Kƒÿ×K„ÿ×K…ÿ×K†ÿ×K‡ÿ×KŸÿìKÂÿ×KÄÿ×KÆÿ×K$ÿÃK&ÿÃK6ÿìK8ÿìK:ÿìK;ÿìK=ÿìK?ÿìKCÿ×K ÿìKúÿìKüÿìKþÿìKÿìKÿ®K ÿ®KXÿ×Kÿ×Kÿ×K!ÿ×K#ÿ×K%ÿ×K'ÿ×K)ÿ×K+ÿ×K-ÿ×K/ÿ×K1ÿ×K3ÿ×KoÿìKqÿìKsÿìKÿÃLÿìL ÿìLYÿ×LZÿ×L[ÿ×L\ÿ×L]ÿìL¿ÿ×L7ÿ×L<ÿìL>ÿìL@ÿìLûÿ×Lýÿ×LÿìL ÿìLpÿ×Mÿ®Mÿ®M$ÿ×M7ÿÃM9ÿìM:ÿìM;ÿ×M<ÿìM=ÿìM‚ÿ×Mƒÿ×M„ÿ×M…ÿ×M†ÿ×M‡ÿ×MŸÿìMÂÿ×MÄÿ×MÆÿ×M$ÿÃM&ÿÃM6ÿìM8ÿìM:ÿìM;ÿìM=ÿìM?ÿìMCÿ×M ÿìMúÿìMüÿìMþÿìMÿìMÿ®M ÿ®MXÿ×Mÿ×Mÿ×M!ÿ×M#ÿ×M%ÿ×M'ÿ×M)ÿ×M+ÿ×M-ÿ×M/ÿ×M1ÿ×M3ÿ×MoÿìMqÿìMsÿìMÿÃOÿ®Oÿ®O$ÿ×O7ÿÃO9ÿìO:ÿìO;ÿ×O<ÿìO=ÿìO‚ÿ×Oƒÿ×O„ÿ×O…ÿ×O†ÿ×O‡ÿ×OŸÿìOÂÿ×OÄÿ×OÆÿ×O$ÿÃO&ÿÃO6ÿìO8ÿìO:ÿìO;ÿìO=ÿìO?ÿìOCÿ×O ÿìOúÿìOüÿìOþÿìOÿìOÿ®O ÿ®OXÿ×Oÿ×Oÿ×O!ÿ×O#ÿ×O%ÿ×O'ÿ×O)ÿ×O+ÿ×O-ÿ×O/ÿ×O1ÿ×O3ÿ×OoÿìOqÿìOsÿìOÿÃQÿ®Qÿ®Q$ÿ×Q7ÿÃQ9ÿìQ:ÿìQ;ÿ×Q<ÿìQ=ÿìQ‚ÿ×Qƒÿ×Q„ÿ×Q…ÿ×Q†ÿ×Q‡ÿ×QŸÿìQÂÿ×QÄÿ×QÆÿ×Q$ÿÃQ&ÿÃQ6ÿìQ8ÿìQ:ÿìQ;ÿìQ=ÿìQ?ÿìQCÿ×Q ÿìQúÿìQüÿìQþÿìQÿìQÿ®Q ÿ®QXÿ×Qÿ×Qÿ×Q!ÿ×Q#ÿ×Q%ÿ×Q'ÿ×Q)ÿ×Q+ÿ×Q-ÿ×Q/ÿ×Q1ÿ×Q3ÿ×QoÿìQqÿìQsÿìQÿÃSÿ®Sÿ®S$ÿ×S7ÿÃS9ÿìS:ÿìS;ÿ×S<ÿìS=ÿìS‚ÿ×Sƒÿ×S„ÿ×S…ÿ×S†ÿ×S‡ÿ×SŸÿìSÂÿ×SÄÿ×SÆÿ×S$ÿÃS&ÿÃS6ÿìS8ÿìS:ÿìS;ÿìS=ÿìS?ÿìSCÿ×S ÿìSúÿìSüÿìSþÿìSÿìSÿ®S ÿ®SXÿ×Sÿ×Sÿ×S!ÿ×S#ÿ×S%ÿ×S'ÿ×S)ÿ×S+ÿ×S-ÿ×S/ÿ×S1ÿ×S3ÿ×SoÿìSqÿìSsÿìSÿÃUÿ®Uÿ®U$ÿ×U7ÿÃU9ÿìU:ÿìU;ÿ×U<ÿìU=ÿìU‚ÿ×Uƒÿ×U„ÿ×U…ÿ×U†ÿ×U‡ÿ×UŸÿìUÂÿ×UÄÿ×UÆÿ×U$ÿÃU&ÿÃU6ÿìU8ÿìU:ÿìU;ÿìU=ÿìU?ÿìUCÿ×U ÿìUúÿìUüÿìUþÿìUÿìUÿ®U ÿ®UXÿ×Uÿ×Uÿ×U!ÿ×U#ÿ×U%ÿ×U'ÿ×U)ÿ×U+ÿ×U-ÿ×U/ÿ×U1ÿ×U3ÿ×UoÿìUqÿìUsÿìUÿÃXIRXWRXYfXZfX[fX\fX¿fX%RX'RX7fXûfXýfX4RX5RX]RX^RXpfXRXRZIRZWRZYfZZfZ[fZ\fZ¿fZ%RZ'RZ7fZûfZýfZ4RZ5RZ]RZ^RZpfZRZR\IR\WR\Yf\Zf\[f\\f\¿f\%R\'R\7f\ûf\ýf\4R\5R\]R\^R\pf\R\R^IR^WR^Yf^Zf^[f^\f^¿f^%R^'R^7f^ûf^ýf^4R^5R^]R^^R^pf^R^R`IR`WR`Yf`Zf`[f`\f`¿f`%R`'R`7f`ûf`ýf`4R`5R`]R`^R`pf`R`Raÿ×aÿ×a$ÿìa‚ÿìaƒÿìa„ÿìa…ÿìa†ÿìa‡ÿìaÂÿìaÄÿìaÆÿìaCÿìaÿ×a ÿ×aXÿìaÿìaÿìa!ÿìa#ÿìa%ÿìa'ÿìa)ÿìa+ÿìa-ÿìa/ÿìa1ÿìa3ÿìfIffWffYffZff[ff\ff¿ff%ff'ff7ffûffýff4ff5ff]ff^ffpfffffhIfhWfhYfhZfh[fh\fh¿fh%fh'fh7fhûfhýfh4fh5fh]fh^fhpfhfhfjIfjWfjYfjZfj[fj\fj¿fj%fj'fj7fjûfjýfj4fj5fj]fj^fjpfjfjflIflWflYflZfl[fl\fl¿fl%fl'fl7flûflýfl4fl5fl]fl^flpflflfnIfnWfnYfnZfn[fn\fn¿fn%fn'fn7fnûfnýfn4fn5fn]fn^fnpfnfnfoÿ…oÿ…o")o$ÿ…o&ÿ×o*ÿ×o2ÿ×o4ÿ×oDÿšoFÿšoGÿšoHÿšoJÿ×oPÿÃoQÿÃoRÿšoSÿÃoTÿšoUÿÃoVÿ®oXÿÃo]ÿ×o‚ÿ…oƒÿ…o„ÿ…o…ÿ…o†ÿ…o‡ÿ…o‰ÿ×o”ÿ×o•ÿ×o–ÿ×o—ÿ×o˜ÿ×ošÿ×o¢ÿšo£ÿšo¤ÿšo¥ÿšo¦ÿšo§ÿšo¨ÿšo©ÿšoªÿšo«ÿšo¬ÿšo­ÿšo´ÿšoµÿšo¶ÿšo·ÿšo¸ÿšoºÿšo»ÿÃo¼ÿÃo½ÿÃo¾ÿÃoÂÿ…oÃÿšoÄÿ…oÅÿšoÆÿ…oÇÿšoÈÿ×oÉÿšoÊÿ×oËÿšoÌÿ×oÍÿšoÎÿ×oÏÿšoÑÿšoÓÿšoÕÿšo×ÿšoÙÿšoÛÿšoÝÿšoÞÿ×oßÿ×oàÿ×oáÿ×oâÿ×oãÿ×oäÿ×oåÿ×oúÿÃoÿÃoÿÃo ÿÃoÿ×oÿšoÿ×oÿšoÿ×oÿšoÿ×oÿšoÿÃoÿÃoÿ®o!ÿ®o+ÿÃo-ÿÃo/ÿÃo1ÿÃo3ÿÃo5ÿÃo<ÿ×o>ÿ×o@ÿ×oCÿ…oDÿšoFÿšoGÿ×oHÿšoJÿ®oÿ…o ÿ…oWÿÃoXÿ…oYÿšo_ÿ×o`ÿšobÿÃoÿ…oÿšoÿ…o ÿšo!ÿ…o"ÿšo#ÿ…o%ÿ…o&ÿšo'ÿ…o(ÿšo)ÿ…o*ÿšo+ÿ…o,ÿšo-ÿ…o.ÿšo/ÿ…o0ÿšo1ÿ…o2ÿšo3ÿ…o4ÿšo6ÿšo8ÿšo:ÿšo<ÿšo@ÿšoBÿšoDÿšoIÿ×oJÿšoKÿ×oLÿšoMÿ×oNÿšoOÿ×oQÿ×oRÿšoSÿ×oTÿšoUÿ×oVÿšoWÿ×oXÿšoYÿ×oZÿšo[ÿ×o\ÿšo]ÿ×o^ÿšo_ÿ×o`ÿšobÿÃodÿÃofÿÃohÿÃojÿÃolÿÃonÿÃpRp Rpÿ®pÿ®p")pRpÿ®p Rp ÿ®qÿ…qÿ…q")q$ÿ…q&ÿ×q*ÿ×q2ÿ×q4ÿ×qDÿšqFÿšqGÿšqHÿšqJÿ×qPÿÃqQÿÃqRÿšqSÿÃqTÿšqUÿÃqVÿ®qXÿÃq]ÿ×q‚ÿ…qƒÿ…q„ÿ…q…ÿ…q†ÿ…q‡ÿ…q‰ÿ×q”ÿ×q•ÿ×q–ÿ×q—ÿ×q˜ÿ×qšÿ×q¢ÿšq£ÿšq¤ÿšq¥ÿšq¦ÿšq§ÿšq¨ÿšq©ÿšqªÿšq«ÿšq¬ÿšq­ÿšq´ÿšqµÿšq¶ÿšq·ÿšq¸ÿšqºÿšq»ÿÃq¼ÿÃq½ÿÃq¾ÿÃqÂÿ…qÃÿšqÄÿ…qÅÿšqÆÿ…qÇÿšqÈÿ×qÉÿšqÊÿ×qËÿšqÌÿ×qÍÿšqÎÿ×qÏÿšqÑÿšqÓÿšqÕÿšq×ÿšqÙÿšqÛÿšqÝÿšqÞÿ×qßÿ×qàÿ×qáÿ×qâÿ×qãÿ×qäÿ×qåÿ×qúÿÃqÿÃqÿÃq ÿÃqÿ×qÿšqÿ×qÿšqÿ×qÿšqÿ×qÿšqÿÃqÿÃqÿ®q!ÿ®q+ÿÃq-ÿÃq/ÿÃq1ÿÃq3ÿÃq5ÿÃq<ÿ×q>ÿ×q@ÿ×qCÿ…qDÿšqFÿšqGÿ×qHÿšqJÿ®qÿ…q ÿ…qWÿÃqXÿ…qYÿšq_ÿ×q`ÿšqbÿÃqÿ…qÿšqÿ…q ÿšq!ÿ…q"ÿšq#ÿ…q%ÿ…q&ÿšq'ÿ…q(ÿšq)ÿ…q*ÿšq+ÿ…q,ÿšq-ÿ…q.ÿšq/ÿ…q0ÿšq1ÿ…q2ÿšq3ÿ…q4ÿšq6ÿšq8ÿšq:ÿšq<ÿšq@ÿšqBÿšqDÿšqIÿ×qJÿšqKÿ×qLÿšqMÿ×qNÿšqOÿ×qQÿ×qRÿšqSÿ×qTÿšqUÿ×qVÿšqWÿ×qXÿšqYÿ×qZÿšq[ÿ×q\ÿšq]ÿ×q^ÿšq_ÿ×q`ÿšqbÿÃqdÿÃqfÿÃqhÿÃqjÿÃqlÿÃqnÿÃrRr Rrÿ®rÿ®r")rRrÿ®r Rr ÿ®sÿ…sÿ…s")s$ÿ…s&ÿ×s*ÿ×s2ÿ×s4ÿ×sDÿšsFÿšsGÿšsHÿšsJÿ×sPÿÃsQÿÃsRÿšsSÿÃsTÿšsUÿÃsVÿ®sXÿÃs]ÿ×s‚ÿ…sƒÿ…s„ÿ…s…ÿ…s†ÿ…s‡ÿ…s‰ÿ×s”ÿ×s•ÿ×s–ÿ×s—ÿ×s˜ÿ×sšÿ×s¢ÿšs£ÿšs¤ÿšs¥ÿšs¦ÿšs§ÿšs¨ÿšs©ÿšsªÿšs«ÿšs¬ÿšs­ÿšs´ÿšsµÿšs¶ÿšs·ÿšs¸ÿšsºÿšs»ÿÃs¼ÿÃs½ÿÃs¾ÿÃsÂÿ…sÃÿšsÄÿ…sÅÿšsÆÿ…sÇÿšsÈÿ×sÉÿšsÊÿ×sËÿšsÌÿ×sÍÿšsÎÿ×sÏÿšsÑÿšsÓÿšsÕÿšs×ÿšsÙÿšsÛÿšsÝÿšsÞÿ×sßÿ×sàÿ×sáÿ×sâÿ×sãÿ×säÿ×såÿ×súÿÃsÿÃsÿÃs ÿÃsÿ×sÿšsÿ×sÿšsÿ×sÿšsÿ×sÿšsÿÃsÿÃsÿ®s!ÿ®s+ÿÃs-ÿÃs/ÿÃs1ÿÃs3ÿÃs5ÿÃs<ÿ×s>ÿ×s@ÿ×sCÿ…sDÿšsFÿšsGÿ×sHÿšsJÿ®sÿ…s ÿ…sWÿÃsXÿ…sYÿšs_ÿ×s`ÿšsbÿÃsÿ…sÿšsÿ…s ÿšs!ÿ…s"ÿšs#ÿ…s%ÿ…s&ÿšs'ÿ…s(ÿšs)ÿ…s*ÿšs+ÿ…s,ÿšs-ÿ…s.ÿšs/ÿ…s0ÿšs1ÿ…s2ÿšs3ÿ…s4ÿšs6ÿšs8ÿšs:ÿšs<ÿšs@ÿšsBÿšsDÿšsIÿ×sJÿšsKÿ×sLÿšsMÿ×sNÿšsOÿ×sQÿ×sRÿšsSÿ×sTÿšsUÿ×sVÿšsWÿ×sXÿšsYÿ×sZÿšs[ÿ×s\ÿšs]ÿ×s^ÿšs_ÿ×s`ÿšsbÿÃsdÿÃsfÿÃshÿÃsjÿÃslÿÃsnÿÃtRt Rtÿ®tÿ®t")tRtÿ®t Rt ÿ®{ {{ {ÿ…ÿ®ÿ…")$ÿq&ÿ×*ÿ×2ÿ×4ÿ×7)Dÿ\FÿqGÿqHÿqJÿqPÿšQÿšRÿqSÿšTÿqUÿšVÿ…XÿšYÿ×Zÿ×[ÿ×\ÿ×]ÿ®‚ÿqƒÿq„ÿq…ÿq†ÿq‡ÿq‰ÿ×”ÿוÿ×–ÿ×—ÿטÿךÿ×¢ÿq£ÿ\¤ÿ\¥ÿ\¦ÿ\§ÿ\¨ÿ\©ÿqªÿq«ÿq¬ÿq­ÿq´ÿqµÿq¶ÿq·ÿq¸ÿqºÿq»ÿš¼ÿš½ÿš¾ÿš¿ÿ×ÂÿqÃÿ\ÄÿqÅÿ\ÆÿqÇÿ\Èÿ×ÉÿqÊÿ×ËÿqÌÿ×ÍÿqÎÿ×ÏÿqÑÿqÓÿqÕÿq×ÿqÙÿqÛÿqÝÿqÞÿ×ßÿqàÿ×áÿqâÿ×ãÿqäÿ×åÿqúÿšÿšÿš ÿšÿ×ÿqÿ×ÿqÿ×ÿqÿ×ÿqÿšÿšÿ…!ÿ…$)&)+ÿš-ÿš/ÿš1ÿš3ÿš5ÿš7ÿ×<ÿ®>ÿ®@ÿ®CÿqDÿ\Fÿ\Gÿ×HÿqJÿ…ûÿ×ýÿ×ÿ®ÿ®ÿ®ÿ… ÿ…WÿšXÿqYÿ\_ÿ×`ÿqbÿšÿqÿ\ÿq ÿ\!ÿq"ÿ\#ÿq%ÿq&ÿ\'ÿq(ÿ\)ÿq*ÿ\+ÿq,ÿ\-ÿq.ÿ\/ÿq0ÿ\1ÿq2ÿ\3ÿq4ÿ\6ÿq8ÿq:ÿq<ÿq@ÿqBÿqDÿqIÿ×JÿqKÿ×LÿqMÿ×NÿqOÿ×Qÿ×RÿqSÿ×TÿqUÿ×VÿqWÿ×XÿqYÿ×Zÿq[ÿ×\ÿq]ÿ×^ÿq_ÿ×`ÿqbÿšdÿšfÿšhÿšjÿšlÿšnÿšpÿ×)) )) )n99H$O9 sRß ó . .=*k 9C r•  % H3  { “ ¤¯ (S 8{ \³ \ Tk   Digitized data copyright © 2010-2011, Google Corporation.Open Sans LightRegularAscender - Open Sans Light Build 100Version 1.10OpenSans-LightOpen Sans is a trademark of Google and may be registered in certain jurisdictions.Ascender Corporationhttp://www.ascendercorp.com/http://www.ascendercorp.com/typedesigners.htmlLicensed under the Apache License, Version 2.0http://www.apache.org/licenses/LICENSE-2.0Digitized data copyright © 2010-2011, Google Corporation.Open Sans LightRegularAscender - Open Sans Light Build 100Version 1.10OpenSans-LightOpen Sans is a trademark of Google and may be registered in certain jurisdictions.Ascender Corporationhttp://www.ascendercorp.com/http://www.ascendercorp.com/typedesigners.htmlLicensed under the Apache License, Version 2.0http://www.apache.org/licenses/LICENSE-2.0ÿffª      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«.notdefnullnonmarkingreturnspaceexclamquotedbl numbersigndollarpercent ampersand quotesingle parenleft parenrightasteriskpluscommahyphenperiodslashzeroonetwothreefourfivesixseveneightninecolon semicolonlessequalgreaterquestionatABCDEFGHI.altJKLMNOPQRSTUVWXYZ bracketleft backslash bracketright asciicircum underscoregraveabcdefghijklmnopqrstuvwxyz braceleftbar braceright asciitildenonbreakingspace exclamdowncentsterlingcurrencyyen brokenbarsectiondieresis copyright ordfeminine guillemotleft logicalnotuni00AD registered overscoredegree plusminus twosuperior threesuperioracutemu paragraphperiodcenteredcedilla onesuperior ordmasculineguillemotright onequarteronehalf threequarters questiondownAgraveAacute AcircumflexAtilde AdieresisAringAECcedillaEgraveEacute Ecircumflex Edieresis Igrave.alt Iacute.altIcircumflex.alt Idieresis.altEthNtildeOgraveOacute OcircumflexOtilde OdieresismultiplyOslashUgraveUacute Ucircumflex UdieresisYacuteThorn germandblsagraveaacute acircumflexatilde adieresisaringaeccedillaegraveeacute ecircumflex edieresisigraveiacute icircumflex idieresisethntildeograveoacute ocircumflexotilde odieresisdivideoslashugraveuacute ucircumflex udieresisyacutethorn ydieresisAmacronamacronAbreveabreveAogonekaogonekCacutecacute Ccircumflex ccircumflexCdotcdotCcaronccaronDcarondcaronDcroatdcroatEmacronemacronEbreveebreve Edotaccent edotaccentEogonekeogonekEcaronecaron Gcircumflex gcircumflexGbrevegbreveGdotgdot Gcommaaccent gcommaaccent Hcircumflex hcircumflexHbarhbar Itilde.altitilde Imacron.altimacron Ibreve.altibreve Iogonek.altiogonekIdotaccent.altdotlessiIJ.altij Jcircumflex jcircumflex Kcommaaccent kcommaaccent kgreenlandicLacutelacute Lcommaaccent lcommaaccentLcaronlcaronLdotldotLslashlslashNacutenacute Ncommaaccent ncommaaccentNcaronncaron napostropheEngengOmacronomacronObreveobreve Ohungarumlaut ohungarumlautOEoeRacuteracute Rcommaaccent rcommaaccentRcaronrcaronSacutesacute Scircumflex scircumflexScedillascedillaScaronscaron Tcommaaccent tcommaaccentTcarontcaronTbartbarUtildeutildeUmacronumacronUbreveubreveUringuring Uhungarumlaut uhungarumlautUogonekuogonek Wcircumflex wcircumflex Ycircumflex ycircumflex YdieresisZacutezacute Zdotaccent zdotaccentZcaronzcaronlongsflorin Aringacute aringacuteAEacuteaeacute Oslashacute oslashacute Scommaaccent scommaaccent circumflexcaronmacronbreve dotaccentringogonektilde hungarumlauttonos dieresistonos Alphatonos anoteleia EpsilontonosEtatonos Iotatonos.alt Omicrontonos Upsilontonos OmegatonosiotadieresistonosAlphaBetaGammauni0394EpsilonZetaEtaThetaIota.altKappaLambdaMuNuXiOmicronPiRhoSigmaTauUpsilonPhiChiPsiuni03A9Iotadieresis.altUpsilondieresis alphatonos epsilontonosetatonos iotatonosupsilondieresistonosalphabetagammadeltaepsilonzetaetathetaiotakappalambdauni03BCnuxiomicronpirhosigma1sigmatauupsilonphichipsiomega iotadieresisupsilondieresis omicrontonos upsilontonos omegatonos afii10023 afii10051 afii10052 afii10053 afii10054 afii10055.alt afii10056.alt afii10057 afii10058 afii10059 afii10060 afii10061 afii10062 afii10145 afii10017 afii10018 afii10019 afii10020 afii10021 afii10022 afii10024 afii10025 afii10026 afii10027 afii10028 afii10029 afii10030 afii10031 afii10032 afii10033 afii10034 afii10035 afii10036 afii10037 afii10038 afii10039 afii10040 afii10041 afii10042 afii10043 afii10044 afii10045 afii10046 afii10047 afii10048 afii10049 afii10065 afii10066 afii10067 afii10068 afii10069 afii10070 afii10072 afii10073 afii10074 afii10075 afii10076 afii10077 afii10078 afii10079 afii10080 afii10081 afii10082 afii10083 afii10084 afii10085 afii10086 afii10087 afii10088 afii10089 afii10090 afii10091 afii10092 afii10093 afii10094 afii10095 afii10096 afii10097 afii10071 afii10099 afii10100 afii10101 afii10102 afii10103 afii10104 afii10105 afii10106 afii10107 afii10108 afii10109 afii10110 afii10193 afii10050 afii10098WgravewgraveWacutewacute Wdieresis wdieresisYgraveygraveendashemdash afii00208 underscoredbl quoteleft quoterightquotesinglbase quotereversed quotedblleft quotedblright quotedblbasedagger daggerdblbulletellipsis perthousandminutesecond guilsinglleftguilsinglright exclamdblfraction nsuperiorfranc afii08941pesetaEuro afii61248 afii61289 afii61352 trademarkOmega estimated oneeighth threeeighths fiveeighths seveneighths partialdiffDeltaproduct summationminusradicalinfinityintegral approxequalnotequal lessequal greaterequallozengeuniFB01uniFB02 cyrillicbrevedotlessjcaroncommaaccent commaaccentcommaaccentrotate zerosuperior foursuperior fivesuperior sixsuperior sevensuperior eightsuperior ninesuperioruni2000uni2001uni2002uni2003uni2004uni2005uni2006uni2007uni2008uni2009uni200Auni200BuniFEFFuniFFFCuniFFFDuni01F0uni02BCuni03D1uni03D2uni03D6uni1E3Euni1E3Funi1E00uni1E01uni1F4Duni02F3 dasiaoxiauniFB03uniFB04OhornohornUhornuhornuni0300uni0301uni0303hookdotbelowuni0400uni040Duni0450uni045Duni0460uni0461uni0462uni0463uni0464uni0465uni0466uni0467uni0468uni0469uni046Auni046Buni046Cuni046Duni046Euni046Funi0470uni0471uni0472uni0473uni0474uni0475uni0476uni0477uni0478uni0479uni047Auni047Buni047Cuni047Duni047Euni047Funi0480uni0481uni0482uni0483uni0484uni0485uni0486uni0488uni0489uni048Auni048Buni048Cuni048Duni048Euni048Funi0492uni0493uni0494uni0495uni0496uni0497uni0498uni0499uni049Auni049Buni049Cuni049Duni049Euni049Funi04A0uni04A1uni04A2uni04A3uni04A4uni04A5uni04A6uni04A7uni04A8uni04A9uni04AAuni04ABuni04ACuni04ADuni04AEuni04AFuni04B0uni04B1uni04B2uni04B3uni04B4uni04B5uni04B6uni04B7uni04B8uni04B9uni04BAuni04BBuni04BCuni04BDuni04BEuni04BF uni04C0.altuni04C1uni04C2uni04C3uni04C4uni04C5uni04C6uni04C7uni04C8uni04C9uni04CAuni04CBuni04CCuni04CDuni04CE uni04CF.altuni04D0uni04D1uni04D2uni04D3uni04D4uni04D5uni04D6uni04D7uni04D8uni04D9uni04DAuni04DBuni04DCuni04DDuni04DEuni04DFuni04E0uni04E1uni04E2uni04E3uni04E4uni04E5uni04E6uni04E7uni04E8uni04E9uni04EAuni04EBuni04ECuni04EDuni04EEuni04EFuni04F0uni04F1uni04F2uni04F3uni04F4uni04F5uni04F6uni04F7uni04F8uni04F9uni04FAuni04FBuni04FCuni04FDuni04FEuni04FFuni0500uni0501uni0502uni0503uni0504uni0505uni0506uni0507uni0508uni0509uni050Auni050Buni050Cuni050Duni050Euni050Funi0510uni0511uni0512uni0513uni1EA0uni1EA1uni1EA2uni1EA3uni1EA4uni1EA5uni1EA6uni1EA7uni1EA8uni1EA9uni1EAAuni1EABuni1EACuni1EADuni1EAEuni1EAFuni1EB0uni1EB1uni1EB2uni1EB3uni1EB4uni1EB5uni1EB6uni1EB7uni1EB8uni1EB9uni1EBAuni1EBBuni1EBCuni1EBDuni1EBEuni1EBFuni1EC0uni1EC1uni1EC2uni1EC3uni1EC4uni1EC5uni1EC6uni1EC7 uni1EC8.altuni1EC9 uni1ECA.altuni1ECBuni1ECCuni1ECDuni1ECEuni1ECFuni1ED0uni1ED1uni1ED2uni1ED3uni1ED4uni1ED5uni1ED6uni1ED7uni1ED8uni1ED9uni1EDAuni1EDBuni1EDCuni1EDDuni1EDEuni1EDFuni1EE0uni1EE1uni1EE2uni1EE3uni1EE4uni1EE5uni1EE6uni1EE7uni1EE8uni1EE9uni1EEAuni1EEBuni1EECuni1EEDuni1EEEuni1EEFuni1EF0uni1EF1uni1EF4uni1EF5uni1EF6uni1EF7uni1EF8uni1EF9uni20ABuni030Fcircumflexacutecombcircumflexgravecombcircumflexhookcombcircumflextildecombbreveacutecombbrevegravecomb brevehookcombbrevetildecombcyrillichookleftcyrillicbighookUCcyrillicbighookLCone.pnumzero.osone.ostwo.osthree.osfour.osfive.ossix.osseven.oseight.osnine.osffuni2120Tcedillatcedillag.altgcircumflex.alt gbreve.altgdot.altgcommaaccent.altIIgraveIacute Icircumflex IdieresisItildeImacronIbreveIogonek IdotaccentIJ IotatonosIota Iotadieresis afii10055 afii10056uni04C0uni04CFuni1EC8uni1ECA ÿÿ © 46latnMOL ROM ÿÿÿÿÿÿ nälatnMOL (ROM Bÿÿ  ÿÿ  ÿÿ  liga°liga¶liga¼lnumÂlnumÈlnumÎloclÔloclÚonumàonumèonumðpnumøpnumþpnumsalt saltsaltss01"ss01*ss012ss02:ss02@ss02Fss03Lss03Rss03Xtnum^tnumftnumn    &.6>FNV^PzªÆîô2H‘’“”•JJßßááããåå.,Ž‘êìîðòôZgw¡¢ÉØEG–© ƒ„…†‡ˆ‰Š‹Œ ƒ…†‡ˆ‰Š‹Œ„‚‚ ‚ ƒŒ‚ ‚ƒŒ !$%IJ6 "(^IO]ILI5O4LI^V0‚R *†H†÷  ‚C0‚?1 0 +0a +‚7 S0Q0, +‚7¢€<<<Obsolete>>>0!0 +ÐîÕÏ—˜üÙmñ R ‚]0‚z0‚b 8%×úøa¯žôç&µÖZÕ0  *†H†÷ 0S1 0 UUS10U VeriSign, Inc.1+0)U"VeriSign Time Stamping Services CA0 070615000000Z 120614235959Z0\1 0 UUS10U VeriSign, Inc.1402U+VeriSign Time Stamping Services Signer - G20Ÿ0  *†H†÷ 0‰ĵòR¼ˆ†`)J[/K‘k‡‘ó5TX5êÑ6^bMRQ4qÂ{f‰ÈÝ*Äj ö7Ù˜t‘ö’®°µv–ñ©JcEG.k ’NK+ŒîXJ‹Ôä,ø‚ªXÙÍBó-ÀuÞ«ÇŽšlL•ÞÛïgárÂIž`<áâ¾£cxi{­-£Ä0Á04+(0&0$+0†http://ocsp.verisign.com0 Uÿ003U,0*0( & $†"http://crl.verisign.com/tss-ca.crl0U%ÿ 0 +0UÿÀ0U0¤010 UTSA1-20  *†H†÷ ‚PÅKÈ$€ßä $ÂÞ±¡¡¦‚- ƒ7 ‚,°ZaµØþˆÛñ‘‘³V@¦ë’¾89°u6t:˜Oä7º™‰Ê•B°¹Ç WàúÕdB5NÑ3¢ÈMª'Çòá†L8MƒxÆüSàëà‡Ý¤–ž^ ˜â¥¾¿‚…Ã`áß­(ØÇ¥KdÚÇ[½¬9Õ8"¡3‹/Ššë¼!?DA µe$¼HÓD€ë¡ÏÉ´ÏTÇ£€\ùy>]r}ˆž,C¢ÊSÎ}=ö*:¸O”¥m ƒ]ù^Sô³WpÃûõ­• ÞÄ€`É+n†ñëôx'ÑÅî4[^¹I2ò30‚Ä0‚- G¿•ßRFC÷ÛmH 1¤0  *†H†÷ 0‹1 0 UZA10U Western Cape10U Durbanville10 U Thawte10U Thawte Certification10UThawte Timestamping CA0 031204000000Z 131203235959Z0S1 0 UUS10U VeriSign, Inc.1+0)U"VeriSign Time Stamping Services CA0‚"0  *†H†÷ ‚0‚ ‚©Ê²¤ÌÍ ¯ }‰¬‡uð´NñßÁ¿ga½£dÚ»ùÊ3«„0‰X~ŒÛkÝ6ž¿Ñìxòw¦~o<¿“¯ ºhôl”ʽR-«H=õ¶Õ]_Ÿú/k¤÷£š¦ÈáLRã`ì@~¹ Þ?Ǵ߇½_zj1.™¨G Î1s W-Íx43•™¹Þh/ªæ㊌*Ë!‡f½ƒXWou¿<ª&‡]Ê<Ÿ„êTÁ nÄþÅJݹ—"|Û>'ÑxìŸ1Éñæ"ÛijGCš_ ä^õî|ñ}«bõM ÞÐ"V¨•Í®ˆv®îº óäMÙ ûh ®;³‡Á»£Û0Ø04+(0&0$+0†http://ocsp.verisign.com0Uÿ0ÿ0AU:0806 4 2†0http://crl.verisign.com/ThawteTimestampingCA.crl0U% 0 +0Uÿ0$U0¤010U TSA2048-1-530  *†H†÷ JkùêXÂD1‰y™+–¿‚¬ÖLÍ°ŠXnß)£^ÈÊ“çR ïG'/8°äÉ“NšÔ"b÷?7!Op1€ñ‹8‡³èè—þÏU–N$Ò©'Nz®·aAó*ÎçÉÙ^Ý»+…>µµÙáWÿ¾´Å~õÏ žð—þ+Ó;R8'÷?J0‚ü0‚e eR&á².áY)…¬"ç\0  *†H†÷ 0_1 0 UUS10U VeriSign, Inc.1705U .Class 3 Public Primary Certification Authority0 090521000000Z 190520235959Z0¶1 0 UUS10U VeriSign, Inc.10U VeriSign Trust Network1;09U 2Terms of use at https://www.verisign.com/rpa (c)09100.U'VeriSign Class 3 Code Signing 2009-2 CA0‚"0  *†H†÷ ‚0‚ ‚¾g´`ªIoV|fÉ^† Õñ¬§qƒŽ‹‰øˆ‰º-„!•äÑœPLûÒ"½Úò²5;à ûü.Z¿‰|=;%öóX{œôµÆ ¸€Î¾'tag'MjåìaXy£à'°áM4+G D¹Þf$fŠÍOºÅ8ÈTáröfuj¹IhÏ8y ª0¨Û,`Hž×ª©ƒ×8‘09–:|@T¶­à/ƒÜ¨R>³×+ý!¶§\£ ©¦P4.M§ÎÉ^%ÔŒ¼ón|)¼]ü1‡ZÕŒ…gXˆ ¿5ðê+£!çöƒå¨í`x^{`ƒýW ]A cT`ÖC!Û0‚×0Uÿ0ÿ0pU i0g0e `†H†øE0V0(+https://www.verisign.com/cps0*+0https://www.verisign.com/rpa0Uÿ0m+ a0_¡] [0Y0W0U image/gif0!00+åÓ†¬ŽkÃÏ€jÔH,{.0%#http://logo.verisign.com/vslogo.gif0U%0++04+(0&0$+0†http://ocsp.verisign.com01U*0(0& $ "† http://crl.verisign.com/pca3.crl0)U"0 ¤010UClass3CA2048-1-550U—Ðk¨&pÈ¡?”-Ä5›¤¡ò0  *†H†÷ ‹ÀÝ”ØA¢ai°¨xÇ0Æ<~B÷$¶äƒsœ¡âú/ëÀÊDçràP¶U ƒn–’äšQj´71Ü¥-ëŒÇOçM2º…øN¾úgUeðj¾zÊd8xEv1ó†z`³]ö‹fv‚Yáƒå½I¥8VåÞAwX0‚0‚û fãðgyÊmPSoˆƒ0  *†H†÷ 0¶1 0 UUS10U VeriSign, Inc.10U VeriSign Trust Network1;09U 2Terms of use at https://www.verisign.com/rpa (c)09100.U'VeriSign Class 3 Code Signing 2009-2 CA0 100729000000Z 120808235959Z0Ð1 0 UUS10U Massachusetts10 UWoburn10U Monotype Imaging Inc.1>0<U 5Digital ID Class 3 - Microsoft Software Validation v210U Type Operations10UMonotype Imaging Inc.0Ÿ0  *†H†÷ 0‰”D •i|U ÐÛ25ŠL3«^ ¡L×*‡8ט¥@ðI "SOÂC¦Ê‹©VïnH¨9c;$¹˜ÏÊ5}rãGWýyËŠJç@p-5c®€ÏįØû÷Éü‰Øפ Û ò¢ò{ïÍuÁ÷ePd"½}¼­¸KÌXEMÑYLM£‚ƒ0‚0 U00Uÿ€0DU=0;09 7 5†3http://csc3-2009-2-crl.verisign.com/CSC3-2009-2.crl0DU =0;09 `†H†øE0*0(+https://www.verisign.com/rpa0U% 0 +0u+i0g0$+0†http://ocsp.verisign.com0?+0†3http://csc3-2009-2-aia.verisign.com/CSC3-2009-2.cer0U#0€—Ðk¨&pÈ¡?”-Ä5›¤¡ò0 `†H†øB0 +‚70ÿ0  *†H†÷ ‚Næ"‡ßgAâÒî~ΙÖc½ðµ“åjrbáõÒ<8î¨=_ºG‚_[KIô ú“ ÐVD¢ˆóû®÷ 5Þ< ¬D”`E*›þ›oL;±4gp†ÿZ9\Zãl‚«5|eKý˜mµ”Iœˆp¾=±b•´Û´ÔÚèA~þ}¹¤’ënò"ŠÆw6MŠZ S1Ó+(¯RázkµwD½ ­ô]%,ãÍŠ0>KœyʦN® ÂÌ$ Á”‚öñº¶›šØ\<ñê'M<‰o3ŠÓ†ÞéX3u=ë“iâDoNlÏÕ…ÚV¦š¦?ËL!hò`ºáè]9!2í1‚g0‚c0Ë0¶1 0 UUS10U VeriSign, Inc.10U VeriSign Trust Network1;09U 2Terms of use at https://www.verisign.com/rpa (c)09100.U'VeriSign Class 3 Code Signing 2009-2 CAfãðgyÊmPSoˆƒ0 + p0 +‚7 100 *†H†÷  1  +‚70 +‚7 10  +‚70# *†H†÷  1äú8??}ޜˆ,ûØvü0  *†H†÷ €kÄE¥×$^%"S} ŸR; ½5+BŸîGÚƒI¤J¼óôí½Âp5rþ+´üÁÍcU LCäü~××v2à+IôŽÔ´²`ã®ÑÛS÷¼ä|¼Õr>DBöêkéC.$Ÿ¶.=Æ«ÐÝ¿¯D•”Ñ%JÁ¬•ï-+ì@îÃý¡‚0‚{ *†H†÷  1‚l0‚h0g0S1 0 UUS10U VeriSign, Inc.1+0)U"VeriSign Time Stamping Services CA8%×úøa¯žôç&µÖZÕ0 + ]0 *†H†÷  1  *†H†÷ 0 *†H†÷  1 110505165510Z0# *†H†÷  1Ï—~ÌçfâQiè¦Àgõ™}¤¸í0  *†H†÷ €]­Œ¶,X:lâÉ`µÎ®Z4[òöÐ͌ۡT…y?1Ÿ1'%ù', »tðoü›6¡ˆõ÷ÁáL¶è‘¬H"‘!à¬}ØÙñ_°F¹°ŠdBŸ’^3–§ª»:<­Ÿ¢îá?GO²˜Qý”åKnM­?}I3OpenSans-LightItalic.ttf000077500000000000000000006402101321131462300405350ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/web/client/resources/fonts/Open_Sans0DSIGet"y+tGDEF&¯&ôGPOS 77'8GSUB+=·'LÆOS/2 é›¸`cmap)«/h´cvt M—¨ªfpgm~a¶Ð´gasp#&äglyf·Eº%¬~head÷ëú<6hheaÄØt$hmtxP”鱚kernT+ ~D,¶6locaÝ+”úTVmaxpZ¨˜ name¢ìçúdQpost7ïl¸&+prepJ„$šÔ ÷†_<õ ÉcI ÉèLûÓýö ®i ý¨ VûÓþ7 ®³£ªŠ]/\%D,š3š3Ñf àï@ [(1ASC ÿýþ„X Ÿ?¶ ÍÁöPÑø+Rh‘3N“þhÿdqéh¢Ãÿ¦uRåRÿœh‹hbh'h7hhXhªhôhbhsåfåÿËh‰h¨hªª¼}#ÿ‘²f‘ªFf+fÕf^ªVfFÿÛÝþ¼bfªf…m\f¸¬yf¸¬yfü%ÙÁZ°7ɦîËÿyÅÁhÿôÿÇÑÿPF!ÿJoçmfLwfmf fBÿÿ¨wLÛLÛþé°LÛL×HwLdb}ÿß…bðH;hqwmhqyšÿ¸˜ÿ'wÿãÅ;hHÅÿ×höhúhÿühÏh¦hBãfo쨓ƒª\=h}uM¨–\mòhƒRƒmoD“ÿã=×åϤÿRƒþ¾\!ɲ5²G#ÿ‘#ÿ‘#ÿ‘#ÿ‘#ÿ‘#ÿ‘hÿ‹‘ª+f+f+f+fFÿÛFÿÛFÿÛFÿÛHZ\f¸¬¸¬¸¬¸¬¸¬hݸ‹Z°Z°Z°Z°ÅÁyfFþçmfmfmfmfmfmfBfwf f f f fÛLÛLÛLÛLdfwLdbdbdbdbdbh¨d-wmwmwmwm˜ÿ'‹ÿߘÿ'#ÿ‘mf#ÿ‘mf#ÿ‘mf‘ªwf‘ªwf‘ªwf‘ªwfFfmfHZ‹f+f f+f f+f f+f f+f f^ªÿ¨^ªÿ¨^ªÿ¨^ªÿ¨VfwLVfLFÿÛÛBFÿÛÛLFÿÛÛLFÿÛÛÿFÿÛÛL#ÿã¶IÝþ¼Ûþébf°L°LªfÛLªfÛÿ¯ªfÛLªf¢Eš'® \fwL\fwL\fwL‡dfL¸¬db¸¬db¸¬db笸byfðHyfðÿ©yfðHü%;ü%;ü%;ü%;Ù¡hKÙÁhqÙ¤=-Z°wmZ°wmZ°wmZ°wmZ°wmZ°wm¦îqyÅÁ˜ÿ'ÅÁhÿôwÿãhÿôwÿãhÿôwÿãÙþáh#ÿ‘mfhÿ‹Bf¸‹d-ü%;o¼oH oî¸Fž1\ÿyoZoÍ‹‹‹?#ÿ‘åÏJYöY;|ðgÏY/e/y#ÿ‘²fÕfDÿÓ+fhÿôVf¸¬FÿÛbfLÿ…m\f!ÿ^fyfÿéÙÁÅÁ¦œËÿy‹ÑçFÿÛÅÁqfH;L/psqfÿáswHNH;‰uL7{/y°Lÿ“ÿã¨yj;dbRZqÿß–fqhHsú;áÿ)TšTD/ysdbsTD+f ÅÕf‘ªü%FÿÛFÿÛÝþ¼ÿ¬ff!ÅRfyÿé^f#ÿ‘Xf²fÕfÿ\+fÓÿ¨üÿáXfXfRfòÿ¬…mVf¸¬^fyf‘ªÙÁyÿ馜Ëÿyf¨Íqf²fîÁf^f‘éf^ÿÍmf%b)h‘NXf f-ÿÍÿîwmwm¤Hÿš-¸JdbwL‹ÿßwf×H˜ÿ'ábšÿ¸‘mHœ×uòusRm㉠JÿÛ fL‘Nb;ÛLÛLÛþéÕÿš;JL¤H˜ÿ'wm²fºH¦îqy¦îqy¦îqyÅÁ˜ÿ'×B®D®D!ÿ4++Ãÿœ+Íwwÿ‰î´î#øÑEÏ‘“þÑøV%2þ1ݼh?hÿüB=hPJúsyNþ®çô‰¢9^SNS˜=¦DÿÓÝÏøVh¨d%š{é-h‘o‘‰‘¨¤wÿÿ‹jÛþ麺¬º ƒsƒ5ƒZƒ‹ƒšƒmƒsªVy šÍTTÛþé+ ÏÁ¸s…m×H#ÿ‘mf;ÿ§ªÿË‹PÿZÿ¸¬ƒbÑ°mýNýãüÐý¶üÖ+fXf fwmTªHsî²þHÇfLJ‡ÿ‘éÿºof=L#ÿÃßÿž#fNJüÿ¬Bÿ‹ÑTš¸¬dbHÉmhHÉmh V¬¶d¸¬dbTªÃmTªHs‘ªwfߨ–u¾“¾¾®é)¦)–f‘m^fãyf}ÿߤfºV–H7ÿ¨bÿÍüÿáÿî¨fÉHRfVH7fsLÕÁ/RfÓJüfjJÑfZF¸¬¼f‘ªwfÙÁøHÅÁqŃöÿy®ÿ¸{ÁBTáÍdœ¨ÍJœúd}HƒwdƒwdFÿÛÓÿ¨-ÿÍ´f®H-ÿ¬#ÿšVf¸JfÓJ¨ÍJœªmX-FÿÛ#ÿ‘mf#ÿ‘mfhÿ‹`f+f fL^ =L^ =Óÿ¨-ÿÍüÿáÿî Dÿ\XfwmXfwm¸¬db¸¬db¸¬db‘‰ yÿé˜ÿ'yÿé˜ÿ'yÿé˜ÿ'¨ÍHœ²fºHfm²Hº ÿy°ÿ¸Ëÿyšÿ¸h\mf\f{çm¢Z禢üÿ¬ãÿwfšJhª‹bÁXT“H;-ÿ¬#ÿš#ÿ‘mf#ÿ‘mf#ÿ‘mf#ÿ‘mf#ÿ‘mf#ÿ‘mf#ÿ‘mf#ÿ‘mf#ÿ‘mf#ÿ‘mf#ÿ‘mf#ÿ‘mf+f f+f f+f f+f f+f f+f f+f f+f fFÿÛÛLFÿÛÛ¸¬db¸¬db¸¬db¸¬db¸¬db¸¬db¸¬db¸¬ƒb¸¬ƒb¸¬ƒb¸¬ƒb¸¬ƒbZ°wmZ°wmÑ°mÑ°mÑ°mÑ°mÑ°mÅÁ˜ÿ'ÅÁ˜ÿ'ÅÁ˜ÿ'‹ÿôûÓýümýýý!ý!ý!üÝ¢ÿs%%ˆRhb/‡ÿϤÿ‚Fÿ¸åÿèl}ÿõ)Wÿÿƒÿ5)Ùyh7mFmFmFmFmFøføføføføføføføføÿ¨øfåf“møfffffff0 °€0HI~ËÏ'2a’¡°ðÿ7¼ÇÉÝó #ŠŒ¡ªÎÒÖ O_†‘¿Ï?…ÇÊñùM   " & 0 3 : < D p y  ¤ § ¬!!!! !"!&!.!^"""""""+"H"`"e%Êûþÿÿýÿÿ IJ ÌÐ(3b’ ¯ðú7¼ÆÉØó #„ŒŽ£«ÑÖP`ˆ’ÀÐ>€ ÈËòM   & 0 2 9 < D p t  £ § «!!!! !"!&!.!["""""""+"H"`"d%ÊûþÿÿüÿÿÿãÿãÿÂÿÂÿÂÿ°¿²aÿIÿ–þ…þ„þvÿhÿcÿbÿ]gÿDýÏýÍþ‚þýšþ þ þ äXäãzä}ä}ã âBáïáîáíáêáááàáÛáÚáÓáËáÈá™ávátáá á ânàþàûàôàÈà%à"àààààßçßÐßÍÜiOS®ª®Àðàê0L\pr`<–—˜™š›ëœíïžñŸó &'()*+,-./0123456789:;<=>?@AIJ$%TUVWXY¡\]^_`abcdef¢hijklmnopqrstuv£hœžŸ ¤¥£¤¥¦§ijêëìíîïðñòóôõkö÷“”•–—˜™šøù¦ÊËÌÍÎÏÐÑÒÓÔÕÖק¨F©opqrstu45]^@G[ZYXUTSRQPONMLKJIHGFEDCBA@?>=<;:9876510/.-,('&%$#"! , °`E°% Fa#E#aH-, EhD-,E#F`° a °F`°&#HH-,E#F#a° ` °&a° a°&#HH-,E#F`°@a °f`°&#HH-,E#F#a°@` °&a°@a°&#HH-, <<-, E# °ÍD# ¸ZQX# °D#Y °íQX# °MD#Y °&QX# ° D#Y!!-, EhD °` E°FvhŠE`D-,± C#Ce -,± C#C -,°(#p±(>°(#p±(E:± -, E°%Ead°PQXED!!Y-,I°#D-, E°C`D-,°C°Ce -, i°@a°‹ ±,ÀŠŒ¸b`+ d#da\X°aY-,ŠEŠŠ‡°+°)#D°)zä-,Ee°,#DE°+#D-,KRXED!!Y-,KQXED!!Y-,°%# Šõ°`#íì-,°%# Šõ°a#íì-,°%õíì-,°C°RX!!!!!F#F`ŠŠF# FŠ`Ša¸ÿ€b# #Š± ŠpE` °PX°a¸ÿº‹°FŒY°`h:Y-, E°%FRK°Q[X°%F ha°%°%?#!8!Y-, E°%FPX°%F ha°%°%?#!8!Y-,°C°C -,!! d#d‹¸@b-,!°€QX d#d‹¸ b²@/+Y°`-,!°ÀQX d#d‹¸Ub²€/+Y°`-, d#d‹¸@b`#!-,KSXŠ°%Id#Ei°@‹a°€b° aj°#D#°ö!#Š 9/Y-,KSX °%Idi °&°%Id#a°€b° aj°#D°&°öŠ°#D°ö°#D°íŠ°& 9# 9//Y-,E#E`#E`#E`#vh°€b -,°H+-, E°TX°@D E°@aD!!Y-,E±0/E#Ea`°`iD-,KQX°/#p°#B!!Y-,KQX °%EiSXD!!Y!!Y-,E°C°`c°`iD-,°/ED-,E# EŠ`D-,E#E`D-,K#QX¹3ÿà±4 ³34YDD-,°CX°&EŠXdf°`d° `f X!°@Y°aY#XeY°)#D#°)à!!!!!Y-,°CTXKS#KQZX8!!Y!!!!Y-,°CX°%Ed° `f X!°@Y°a#XeY°)#D°%°% XY°%°% F°%#B<°%°%°%°% F°%°`#B< XY°%°%°)à°) EeD°%°%°)à°%°% XY°%°%CH°%°%°%°%°`CH!Y!!!!!!!-,°% F°%#B°%°%EH!!!!-,°% °%°%CH!!!-,E# E °P X#e#Y#h °@PX!°@Y#XeYŠ`D-,KS#KQZX EŠ`D!!Y-,KTX EŠ`D!!Y-,KS#KQZX8!!Y-,°!KTX8!!Y-,°CTX°F+!!!!Y-,°CTX°G+!!!Y-,°CTX°H+!!!!Y-,°CTX°I+!!!Y-, Š#KSŠKQZX#8!!Y-,°%I°SX °@8!Y-,F#F`#Fa#  FŠa¸ÿ€bŠ±@@ŠpE`h:-, Š#IdŠ#SX<!Y-,KRX}zY-,°KKTB-,±B±#ˆQ±@ˆSZX¹ ˆTX²C`BY±$ˆQX¹ @ˆTX²C`B±$ˆTX² C`BKKRX²C`BY¹@€ˆTX²C`BY¹@€c¸ˆTX²C`BY¹@c¸ˆTX²C`BY±&ˆQX¹@c¸ˆTX²@C`BY¹@c¸ˆTX²€C`BYYYYYY±CTX@ @@ @  ±CTX²@º ³  ±€CRX²@¸€± @²@º€ @Y¹@€ˆU¹@c¸ˆUZX³ ³ YYYBBBBB-,Eh#KQX# E d°@PX|YhŠ`YD-,°°%°%°#>°#>± ° #eB° #B°#?°#?± °#eB°#B°-,°€°CP°°CT[X!#° ÉŠíY-,°Y+-,Šå-@° TNdSF<RFdPF3OFÿ!H U UHU?¯MJÿLIÿKFr&4U%3$UÿÿÿJF?IF<3UU3U?¯HFrGFk3U3UU3UOŸÏÿU3Uo¯ï€¸±TS++K¸ÿRK° P[°ˆ°%S°ˆ°@QZ°ˆ°UZ[X±ŽY…BK°2SX° YK°dSX°±BYss++^stu++++++st+++++++++++++st++++++++^N¶u¶Í?šÿìÿìÿìþÿì¶ü”ÿéþ“þJþ ÿãþ¼VZQ^RX^RLV\ÂTdJEb¸%û0Sˆ©ÂÕîA`šì%kÁß:¹ç$BMœÓ6[£Êõ  D ^ ” ½ ý / | º  ' X { À è  0 M a ~ ™ ° É  ` ” Þ%kö3U‹ºÌ"Y’Ý*Z¤á;y¢ÚUg½ññ\© Xvâ €Äù±äI™´ó )Nr©Þô m~ ±ÃÜ ,=N_q‚“¤¶#4EVh’ø +=N…ö&6GXàìü ->O`rÛëû  + < w Õ å õ!!!&!r!„!•!¥!¶!Æ!Ò!Þ!ï!ÿ"" "1"B"S"c"t"…""ñ#####3#D#U#a#m#~#Ž#Ÿ#¯#À#Ð#á#ò#þ$$$0$w$Ì$Ý$î$ÿ%%!%2%>%I%Z%k%w%ƒ%”%¥%°%»%è%ù& &&!&2&B&N&Z&‹&µ&Æ&Ö&â&í&þ'''b'«'¼'Ì'Ý'í'ÿ((h(Ý(î(þ) ))')8)I)Y)j){)‡)“)¤)µ)À)Ë)Ü)ì*!*u*†*–*§*·*È*Ø*ê*û+ ++*+6+G+W+h+x+Š+›+«+¼+Í+Þ+ï,&,q,ê--"-3-D-T-_-j--´-Æ-é..2.T.†.².Ì///!/3/E/W/h/z/‹/ž/¦/®/Ç/Ï/×/ß/ç060>0F0j0r0z0«0³0Ò0Ú111!1v1~1Å22'292I2Y2i2z2Œ2ì3Q3|3Ó4)4t4°55(505„5Œ5°666[6Ÿ6ß7!7X7…7Ø8+8s8Ä8Ö8ç8÷999*9x9‰9Í9Õ9Ý9ï9÷:L:“:Ï:à:ñ;;";^;f;n;­;µ;í<=>J>ˆ>¼??W?•??ô@K@˜@ó@ûAoAÇAÏAßBB@BzB£B«B³B»BÃBËBÓC+C3C~C¹D DtD¾E EKE’EâF7FHF¬F¼FýGG GG'GGáGéGùH HPHqH‘H¢H²HÃHÔHæH÷III/IEIMIZItII¨IÀIëJJ@JpJÀJÙJéKƒK‹K“K°KÌKØKíL"L^LÇM2M–MôNEN£NßNçO&O=OTOkO‚OÐOúPPDPVPvPÓPýQaQ QÉQòRR#R/RSRxR“R¬RÇRÿS6SvSÈSçTBT•T•T•T•T•T•T•T•T•T•T•T•T•T•UªUüV VVVÆW&W7WHWTW`WmW¡WÓWßWëX>XŠXÌYYY'Y0YVYmY~YYŸY¯ZZYZ£Zû[T[§[á\\e\¯]]Z]À^#^À_]_e_m_Æ``K`}``¡`­`¹a0a¨boc$c´ddHd€d¹dÞe e-ePf$f›fìgKg”gìh=h¡hÑiiJi”i×jPj\jhjšjÌk kPk“kÚl l:lnl¢lÔmmQmŸn$n›n§n³nÞoNoVo}oµoìp"pWppåq&qlq¾rrGrƒrêsIsºt#t+tËwþT2,B2+Cy=úƒ8AH5Eø¦¶ ´?3Í210#!#Ç’=PÈ‘=O¶ýðýðRJ¶3@  ?3?39/333339/3333310!7!3!3!!!!#!#!7!!!…wþ×7†Zˆm‡V‡þÒv/þÀ…Z‡þ˜†X†þåkxþ–ŽPÆþ:Æþ:PþrOþ=Ãþ=ÃOŽÿ‰!!(/>@"%,(/  MY" ))MY  //99//3+33+3910#7&&'53.546773&'6654&' Ý»5R3Ož:A±HnnV/Ó§)P)•€#n’m|a2þyŽ£`m1†ŽJdÓ—¸ ðð ^"'5LcC›¿ÀÀ?N= ýþþx'Š/þkkþo%¡þ¤N>}f¨˜¢)˜ · SY/3+310!5!3!!#3þo‘e‘þoe d”þldþpÿ¦þøî±/Í107#67ú" PJO|î\þåh„\Rö-P ´GY/+107!RÉöZZRÿîò° µQY?+1074632#"R2,B2*D78AH5Eÿœ;¶ ³??10#;üÏn/¶úJ¶‹ÿì3Í@ KY KY?+?+10#"&463 "3264&3R—؆°±YŸ×…Tþ †×„}‡‹ÒzwøÉþhþäýº‡‰XâþPëÞÖàÂÇÀbR¶ µ ??Í310!#67'3iá7*CØ4–Z\É$2ˆN'-Ë@ KYLY?+?+910!!7>54&#"'632!üšÁƬQ„ƒ°6´Ö­¿WÄÕþàh’±Ç®]p„I’ª˜nÅâ¾þ®7ÿìË(-@LY && KY& KY ?+?+9/+910#"&'532654&##732654&#"'6632Ô´u‰€çŸ`±A¬¬ÅÕ²žunÑø}§±1TÐr¡·–¢â·‡†Æb) eV³£‘œ`¿£rzƒKCK¥DÅ !@KY ??9/3+3310!#!73!!7#/þøP`PýPqv× þ•OP.B?ýusþs`òüq{¥[KýXÿì3¶/@MYLY KY?+?+9/+33102!"&'532654&#"'!!6F¼ÑþØþýT»AªªÐñªŒ…nBÁpýã•bo̱íþç(kZåÇŒŸ)1“`ýüªÿìVÉ(-@ !KY KYKY?+?+9/+910$32&#"36632#"&26654&#"ªÒIÛ{;VTéþ¿IDÀs¡³xÞ’«½up©[†€Q’p,‘¬ ÷Zþ¤þ¸^bɶœúŒî–uÏ~’?owr¤¶ôƒ¶@ LY?+3?103!7!ôýZüõV`nú¸bÿìBÍ$0#@+ KY %KY?+?+9102#"&5467&&54632654&"6654&᣾¨É‚xt×™²ÓÉÝdXä2Ú¿›Ž¨Ì|‚©StÀ®ͪŠÁLN¹tt¸i¹¡ŸÛNH dŸÔýI½ƒˆ¶Žhªâ¤y[ˆJ>¤|msÿì#É&-@ LYKY MY?+?+9/+910#"'53 ##"&546632%"32>54&#Ëþ¼çrHWiÚ™Œã¢ºwÞ’®»þ‹p«Z‡}S•m,ŽþàýøôZ¢ÀÒ³›üŒçuÐ~‘ Anvu¦´fÿî¤V @ QY QY?+?+104632#"4632#"3+B2*Dž3,A3)DÝ9@H7Dü¤8AH7CÿËþøªV@  QY ?+Ä/Æ10%#674632#"#§IIO|Z3+B2*Dî`þÜ[„\ï9@H7D‰Åµ /33ÍÍ105ün’üß!žJ×gþqþ¢¨Í/Ù@ SYSY/+Æ+105!5!¨‡üy‡uddþXbbª=ŵ /33ÍÍ105ª!üß“ümq^gþ)JþbªÿòsË%)@$$QY$  PY?+3?+9/9107667>54&#"'66324632#"òjhvr;‡s‹¨'U­eŸ·„¥U_3¤2,B1+Dj„•IT{„Kl|eV1:©‘Öw=__`þÑ8AG6E}ÿH˜²9FA@!A6:FY.6 A FYAA.6.)GY.6"GY6?+/+9/3+39/+910#"&5##"&546632326654&&#"!27#"$5$!2"3267&˜pÅqbq6Zp„~æ’z‚T'EBV”W‚ôªëþ…Ô6ÏÕÒÚËþ˨󯽟ýXq·fQIeŸ-NBZ³þߥnYaf’œþ4þÅŒQGQ“ùœò†Ùþyôþàþ¾RZR¥9Ö³ï‘þç?vÕ„\e²¦!ÿ‘Ó¼@ IY?3?9/+310!#3#&'%þþáu6CÉiQ'Eþðýø¼úDd#ò ?†þfž¶!-@IYIYIY?+?+9/+910!2#!!2654&#!!2654&#œ{¾É´¤}þçúþ7ÎÖœ—þðŠ‡VÉÙ´¹¶¨™À¥zÍí+¢w{ýuý‰¯©‘ŽªÿìôË@ IY IY ?+?+10"327#"$32&&ÁÅþ˵ÝÏŒ¤œ üþôÑhÞ±‚-7‹mÑþpñáò3^1"  ¼îDZ"f¶ @ IYIY?+?+10#!! 2$5!#Ûþ‚ÿþ¶61!ü¦âQ¹þ$Îþíoýþ_ѶþÙû˽jçòûfs¶ &@ IYIY IY?+?+9/+10!!!!!!!=ý)6×ýuNý´‡s¶^ý×^ýf`¶ @ IYIY?+?9/+103#!!!!Íg6Äý¤†:ýǶ^ý”_ªÿì=Ë&@IY IY IY?+?+9/+10!# $32&&#"327!X––ÓÂþÿþèÒeÙq´^&nŸX¸þʲåÔ›šuþÑßýVI$ µê&(^. ×þ|ïåö/f\¶ @ IY ?3?39/+10!#!#3!3'd—ý•g6f‹ø‰dÏý1¶ýw‰ÿÛ²¶ @ JY JY?+3?+310!!77'7!þ\¤ž ¤  þê™?  AA úà þ¼þ˜ô¶ · IY"?+?10"&'73273´0P 9PÕ15iþÆ#´þ˜\ñÍú-ª¡f¶ @   ?3?3910!##373Óoþª¾ƒg6fž…¨ŠýE™ý…¶ý-yZýžfN¶·IY?+?1033!f6fþßm¶úª`mw¶@   ?33?3310%3#7####3Ý–þÓe¿Oüô3Þ:Ä`5ÍÍéúJ…qNú¼Dšþðüf¶ûfb¶· ?33?3310!###33673-Výü2½_6P 3¼^•øü‰¶úò°ðn¬ÿì{Ë @ IY IY?+?+10#"$32%"32$54&{¼þÄÏúþòºDÓ÷ýô®þó ÛÒ©žÑÿþ;ß*¯çþ×ËÊþvÜõÿÅ“åðøfy¶ @ IY IY?+?9/+10!##!23265!#yýžÉg6;ÊØüå¿üóþ·ÓNþ ý¦¶¹ý¹ÁѬþ¤{Ë#@IYIY?+?+Æ9910#"$32%"32$54&{Œéž ŽçJúþòºDÓ÷ýô®þó ÛÒ©žÑØþlô-þ¢L*¯çþ×ËÊþvÜõÿÅ“åðøfy¶ (@ IY IY?+?39/+9910#! #%3265!#Pƒg6/®Ï²ÉoÓþÓüÐÚþ·Óyý‡¶þ˜¶òý±8y\¿º %ÿì Ë) @ # JY IY?+?+9910#"&'532654.'&&546632&&#"ƒä›X©W£¹¼×"GoL–wvÔƒc¢W B«O£Áb…šw;“~Åd")m\­’=WFB*L°vv³c#+^(.¥ˆg†BOf|Á¢¶@ IY?+3?10!#!7!!¶f!þPÍþHX^^°ÿìs¶@  IY?+?310# 473!267sÏ:þêìþHºgÁVÃá.϶ü/þòë‘Svpü}Y_þËÁÞÑÉö¶ ¶ ??3310%673#3É3I54&&#"è/;PåR-TΆþç–ûaY±J4fL|È€dPÛÊûÁŽ˜vÅfÃûö|ÐüWO}I¤þ¹¢˜Lÿð"'@ GYFY?+?+??9910"&'##33663 "32654&ôq’7PG_ƒ]Ô}˜úc[²F€f|È€bvkÑýŒ{œ“þ‰ËþžÀ {ØþO“¦D£˜fÿì‰P@  FYGY?+?+10"&54632&#"3267ݮɓú¥†kkoÏv“‡GyGtÝÄÁQ±+Z/šþÞ¯ž«!\9fÿìœ'@ FY GY ?+?+??99102363### 462>54&#"æ1 ƒcþ¶R-­ûþçü[Y³H{k|È€PÛB]ùìþÚvÁbËûö}ÓûT~—¦þÁ¨þÙfÿì}P &@FYFYGY?+?+9/+10"&54632!#327"3 4&Õ­ÂŽù–rˆþ¹þ¾!”‹„Œƒá21WÛĵLÄziµ¾,6¥­I^EçÁCWÿþq'@FY HY GY?+?3+3?+10"'53267#?6632&#"3#ƒ065/X\öÍÍ##£’I]W<`s#øøü!ŽþZj…ŽC ¨˜Pk}¤QûZ¡“ÿ¨þLT*7EH@(*GY*55HY!  ( ;FY5 5 ((BFY(.FY?+?+99//+9+3?+10#"'#"&54%&547&&54663232654&''326654&#"Ló#m»x?PX?RyZ‚ô©ºÓ5N¿GOk½pENý+¢Ëä}œ ŠujX„Ipe]ˆJ?O p:mÃ` !P))/ ép«\ƒìb*Q{O$‹Xoºjúòeb•‚U[ -‹3ptJš\hsV’L @ FY ?3??+910!654&#"#336632ü•W[pŇ$fbL`V,NÙy|ˆ”´\@PZ†ò¥þ#þeÈOq}‚vFpý^Léϵ ??Ä2103#34632#"&®bç`5,&9,#?7BH9B'þéþéÏ @  GY?+?Ä210"'5326734632#"&¦>3/BR] `þô#,&9,#þ\g~íû ¥B7BH9B'Lì @    ?3??9103##3a}þ&)jþøÍP`J`¦FÝbþ+ý–/¼þüôþÕLø ³??103#3ª^N^H^P+%@ ! 'FY?3+3?33?9910!654#"#33663236632#654&#"Ç“šj¼‚#dbçP!PËojrMÐvuƒ˜d•VLñ0m¢}%¶‡ò¦þ%?Òqr†€…{s7\ýN¨x8MUþíáýúL P@ FY  ?3??+910!654&#"#33632ü•W[pŇ$fbçR%¤ü‚‚”´\@PZ†ñ¦þ#?Ýî€xFpý^bÿìT @ FYFY?+?+102#"&546"!2654&‰´Åø¢¸¿’ø•|ÆvÅu’TÙ¿Åþ©´ÛÌ¿N´VþÛ¤þª›-´š¦ÿßþT!&@ GY FY?+???+9910"'##336632"3265òæ1 ˆcPR-[Ñ|‡’û\W®•H{k|Ê~ÛHý‘+þ¹¾Ãþ Ê uÚþÿP}—¨?¦'bþ+3P"'@ FYGY?+?+??99102373### 462>54&#"‹m•7Pþ¹_b@]Ô}þç—úb\´Eg|È€[PtmÐùìÖœ“vÉdÁûö}ÚÿI‚“¦þ¼£˜HDR@   GY?+??9102&#"#33>ÉE6/B^ªˆ dbçPIdqR]€ÿ•þ?Ì^S.ÿì1P& @ FY FY?+?+9910#"'532654&&'&&54632&#"Éα­„JžEŠ’Eb”hÅ¡K§9#ˆ€tŒ"WLr_-'«Kk.2sj*@;8Pƒ^€£#X@jU7BG)?Q\qÿì¶?'@@HY FY ?+?+33Í10!327#"&547#?3¶þå‡~DTeEcl¶¸a77?Qý…cA‹VmhI…_Cýÿmÿð+?@  FY?+??3910326673#7##"&547}˜_[nÃ…!ibçP§ìƒ‡–?ýFj4JWƒóžåûÁÍÝ|w76675&&547654&Lƒu7cd}„X ™‰`T5JylKE6 $HP¶f`)Jü_ MSNamþv‹uV&TOR~iA7L=(,2Vh3=@ RYRY/+/+3310"56323267#"'&&^1v8l}=lf~]6k@ozuš>eé=;^n,::C`qHþ‰°P @ " QY ?+?9/103##"54632>Ëw¬2,B2+CÇûÂ}8AH7DúÿìË(@ MY KY   ??99//+33+10#7&&546773&#"327#B]-„”åŽ$Z&tekn‚Îw•†‰v£××¥¸:À²°'Z/˜þÞ±¤¦<\:ÿü¨Ç-@ MY KYLY?+?+9/3+3102'&#"!!!!7667#7366oª'6l{†­I™þh92Š÷üV]‘#9ÇÆL)äÇNT2•’þ¬RþôáY^T ©˜R^»¸Ï3u(D@$   RY&RY/+Ä+9////////Æ2Æ21047'76327'#"''7&732654&&#"J?i}viƒ=NN=ƒhw~f=JX uu£I„Kr£Óvk@NN>jy‡\>LP>bt¡¢sK‚N¤¦Ý¶@@#MY/  MY  ??39/3+3Ä_^]+333103!!!!#!7!7!7!3H uýÑ þÅ'=þÄ;i@þÕ+)þÓ×d…1üÉL¾Tþß!T¾L7Bþ¦@ ??99//103#3#Bddddý ýÑý fÿþî/<'@*07! FY !'FY!?+?+910467&&546632&#"#"'532654&'&&6654&Ó‹@O\­t£~Š~|\‰p]1ùz`·‚v/žJ•žU|›q\w‰1qƒgvs e¢1mBJyD:P6]M;[=4K_?Åx@…V‡L5c'ib>X4A‚b‡W9OC01\HlìÇÁ  ³ /3Í2104632#"%4632#"D)$6*"7þ¨)$6*"7V1:@0:?1:@0:“ÿìsË%5?@& GYGY     "2GY"*GY"?+?+99//_^]]++10"327#"&54632&4$32#"$732$54$#"°Ž¡•’Urhi»ÊÜ»wl$cü‡È^ÊÈ^ÊÂþ¢ÐÏþ¢Ã]±0²®.¸²þѳ¶þΫD½ªº²+X-èÖÏú4S-þ—È^ÊÈþ¢ÊÅþ¦ÐÏZƲþѲ«3µ²0²¸þÒª+öÍ&@  TY TY?+?Ä2+99102373#7##"&54267654&#"ç7U#B‰H`P^µB‡H9^‡Í:9gýv}‰ql½ý¨—m3H:Uß ={L¤ $@    //3333ÍÍÍÍ1077ª9þÃÕ@þÓ:þÆÑ?þ¤1þ°þ'¢m1þ°þ'¢}¶SY/+Ä10#!5düÝþ dÿÿMö(Pû–ÿìuË%5R@. HYFY  "2GY"*GY"?+?+99//_^]]3+9/+91032654#####324$32#"$732$54$#"öp]fÅn›OFíxÓ¨eÓžüÏZÆÈ^ÊÂþ¢ÐÌþ§Ê\±0²®.¸²þѳ¶þΫÛ]Y¬§Pz þwhþ˜p|þÄÏ^ÃÈþ¢ÊÅþ¦ÐÉYͲþѲ«3µ²0²¸þÒ\u ´IY/+10!7!éýs5Žaò;Ë @ RY RY?+3/+104632#"&732654&#"òª{zª«yz«I[\€[Z‚¦x­­xz««zY€€YZƒƒm @  SY SY /+/+3310!5!3!!#5!þo‘e‘þoeþo‡ub–þjbþpåddRJÉÇ@ NYNY ?+3?+10!76654&#"'632!\ýö)‰[MC_c)lƒIh5v|þö JPv‘Q;LL>Z6Z7j¹fßm9ÁÉ'-@NY %% NY% NY !?+?+9/+910#"&'532654##732654&#"'632ÁajBONŒ[;).|?cxÄTVf…KDdc(mŽdvüU~hHM€FZ(iZ¢OcPDED@VqDÙå! ²€ /Í106673#DB©-‰3ÕVCî3¶JB¹6ÿãþH? @  FY?+???399107326673#7##"&'##3îaWnƒ$hcêN¤ðUl!?aRe˜òRZì§åûÁÍÝA9„˜þÆ+ýF`×þü¸!@@IY?+Í9/9310####"&563!¸dãe@QØÌÚéþüºùF3úûþÿÿÏqo3}ƒÿRþŵ /Ì29/310#"'53254'73Å—Ž. *Æ—nPNŒþß^mOsa ¾‰þJP¶ ¶  ?2?9/103#>7'PºTv "4u'¶ü”9;=9)I;¾'çÇ @ TYTY?+Ä+102#"&5466"326654&ixP”ernS•VFl<œIi:NÇ€tsÆs‡upÃqJ]œYº]¢_S[!{/¤ $@  //33ÍÍ33ÍÍ10%'7'7Ã::Ñ?þý-99Ñ@þ{1P'þ^þ”1P'þ^ÿÿ8¶'<–ý·'P{ý ³?55ÿÿ5k¶'t¢ý·&{¯²?5ÿÿGÉ'<Óý·&uÚ¤ ³?55þmÉF%'@$$QY$  PY#?+3?+9/910327#"&5467>7#"54632fnvr;ƒw§&U«fŸ·ŒUa1¤3,A2*DÍ’QT{„Kj}dV19©…×q=`^_/8AH8Cÿÿÿ‘Ós&$C1R³&+5ÿÿÿ‘=s&$vXR³&+5ÿÿÿ‘ïs&$K1R³&+5ÿÿÿ‘V&$RPR³&+5ÿÿÿ‘ò&$j+R ´!&+55ÿÿÿ‘Ó&$Pÿê˜@?]]q55ÿ‹°¶4@ IYIY IY  IY?+3?99//+++310!!!#!!!!!!#{ý)nþDþ¸ƒ²sýuNý´‡rü ‘œX ýö¶^ý×^ýåÿÿªþôË&&z+ÿÿfss&(C}R³ &+5ÿÿfss&(vJR³&+5ÿÿfss&(KNR³&+5ÿÿfs&(jBR ´&+55ÿÿÿÛ²s&,CÿER³ &+5ÿÿÿÛ>s&,vÿYR³&+5ÿÿÿÛös&,Kÿ8R³&+5ÿÿÿÛý&,jÿ6R ´&+55Z¶ -@IY IY IY?+?+9/3+310#!#73! 2$5!#!!Ûþ‚ÿþ¶œ›’1!ü¦âQ¹þ$Îzþ…}oýþ_Ѥ`²þÙû˽jçòýª`ý¶ÿÿfb&1RçR³&+5ÿÿ¬ÿì{s&2CßR³&+5ÿÿ¬ÿì{s&2vR³%&+5ÿÿ¬ÿì{s&2KÕR³#&+5ÿÿ¬ÿì{&2RöR³&&+5ÿÿ¬ÿì{&2jÃR ´.&+55ÝDþd ¶  /3/399107''þ¶FJMDþ´LDþ³þ¶DÓLEþ·ICþ²þ´CIþ¹C‹ÿ²¨ú",.@!&' ) IY)IY?+?+9910#"''7&5$327"&4&'32${h¹þû¡×…‹B’q¼EÐÛ……F‘-7ýô†Ü\+#:kÝ#üËkºª»þ›ü‡pª@¬•ü±äy¨5·3ÜnwÝþÆ¢i¬4qþU®*ûúdȉÿÿ°ÿìss&8C´R³&+5ÿÿ°ÿìss&8vR³&+5ÿÿ°ÿìss&8K¾R³&+5ÿÿ°ÿìs&8jºR ´&&+55ÿÿÁƒs&<vÿïR³&+5f?¶ @ IY IY ??99//++10!##3323 65!#?þÎþÐÉGg6f9ÕÈÙüæ¾ðþ¶ÓD÷ýþ°¶þö¹ý¹ÅÌþçþ</@3,& 6FY #GYGY?+?+?+910"'53267!2#"'532654&'&&546676654&#"¢I.5>OX1PE‰œYzkED;`TÕ´[-‡>„™?NRJ*Obe=n_˜ þÝ!þZege{qKƒSLa:3K&?_ªÆAm$.Ž|Kl6:iE9\UGF\7FP˜™úŸ˜‰ÿÿfÿì7!&DC+³#&+5ÿÿfÿì7!&Dv³+&+5ÿÿfÿì7#&DKý³)&+5ÿÿfÿì7Å&DR³,&+5ÿÿfÿì7Á&Djÿ ´4&+55ÿÿfÿì7h&DPØ ´%&+55fÿìP,<FD@% @!FY@@ =66FY&- -GY ?3+3?3+3??9/+910"&'#7##"&54632373632!#3267%2>54&#""3 654&ƒ{°'M) ^¾qx|ô˜jx ;B#‹Óp~þÃþÈ'‹”EBP†ü¥C}W(b\{ÈqUwâ;0ðMxiÍþŽ„¼°ÎeÅqdÀºÏ{o³¹3-¡³*^% ZT—¾Ð=vˆ¬þ̺–„´çÁ†ˆGSÿÿfþ‰P&Fzyÿÿfÿì}!&HCñ³"&+5ÿÿfÿìµ!&Hvг*&+5ÿÿfÿìˆ!&HKʳ(&+5ÿÿfÿìÁ&HjÈ ´3&+55ÿÿLÆ!&óCþȳ&+5ÿÿL½!&óvþس &+5ÿÿL‚!&óKþij &+5ÿÿL†Á&ójþ¿ ´&+55fÿìL#.8@ (GY GY?+?39/+9/9910&'7%!"&5463234''26654&&#"É6h; b3 'ÿWYþåþþ±È~ç“k¢(VHþÙ'=vµkF‚[|³`“T54&#"ã4Kþl‘+c+šþòR-­ûþçü[Y³H{k|È€PÛ*YTÈÈTûþÚvÁbËûö}ÓûT~—¦þÁ¨þÙÿÿfs‡&(MmR³&+5ÿÿfÿìŸ5&HMñ³$&+5ÿÿfs&(NPR³&+5ÿÿfÿì²É&HN³$&+5ÿÿfs&(O˜5³&+5ÿÿfÿì}Ï&HOø³)&+5ÿÿfþbs¶&(QLÿÿfþ}P&HQ!ÿÿfss&(LDR³&+5ÿÿfÿì¿!&HL»³-&+5ÿÿªÿì=s&*KÛR³%&+5ÿÿÿ¨þL!&JKijM&+5ÿÿªÿì=&*NÑR³!&+5ÿÿÿ¨þLÉ&JN©³I&+5ÿÿªÿì=!&*OR³&&+5ÿÿÿ¨þLÏ&JO³N&+5ÿÿªþ;=Ë&*9!ÿÿÿ¨þL!&J:9³J&+5ÿÿf\s&+K¾R³&+5ÿÿL ª&KK)‰³#&+5fç¶1@ IY IY    ?3?399//+33+33103##!##733!3!!ÆÅçd—ý•gèÁ¾lýNÿÿÿÛ[&,RÿUR³&+5ÿÿBîÅ&óRþè³&+5ÿÿÿÛ‡&,MÿYR³&+5ÿÿL’5&óMþä³&+5ÿÿÿÛ&,Nÿ(R³&+5ÿÿL¡É&óNþ±³&+5ÿÿÿÛþb²¶&,QšÿÿÿþbéÏ&LQÿÿÿÛ²!&,O‡R³&+5L“? ³??103#3®bç`?ÿÿÿãþ˜:¶&,-FÿÿIþÀÏ&LýM×ÿÿþ¼þ˜Ös&-KÿR³&+5ÿÿþéþq!&7Kþ³³&+5ÿÿfþ;¶&.9}ÿÿLþ;ì&N9-Lì? @    ?3?39103##3a}þ&)jþøÍP`å`AFÝbþ+ý–/¼þ?þÉþÕÿÿfNs&/vÿ[R³&+5ÿÿL4¬&OvÿO‹³ &+5ÿÿfþ;N¶&/9wÿÿÿ¯þ;ø&O9ÿÿÿfý·&/8éÿ£² ?5ÿÿLS&O8?²?5ÿÿfN¶&/OfýxÿÿEF&OùOuý£'N¶ %@  IY?+?99//9103'73%!dq‡'Ç®f +þžgm PNw5ý ªLÕþ` = @  ??99//9107#'73^¶)÷œ^ª%æª^DhHý)˜cH‡ÿÿfbs&1vR³&+5ÿÿL;!&QvV³"&+5ÿÿfþ;b¶&19×ÿÿLþ; P&Q9Vÿÿfbs&1LÅR³&+5ÿÿL !&QLù³%&+5ÿÿ‡‡¶&Q}²?5fþ˜b¶%@   IY"?+??3399//10"&'73267##33673¸%\ :Oq}#þ2½_6P 3¼^þÏ)³þ˜\‚í•øü‰¶úò°ðnú\ĶLþ P"#@FYGY?+?+??910"'53267654&#"#33632A//AR[ºW[pŇ$fbçR%¤ü‚‚»#þ\fb\@PZ†ñ¦þ#?Ýî€xFpü¦¥ÿÿ¬ÿì{‡&2MçR³&+5ÿÿbÿì5&RM³&+5ÿÿ¬ÿì{&2N°R³&+5ÿÿbÿìÉ&RNγ&+5ÿÿ¬ÿì{s&2S'R ´/&+55ÿÿbÿìg!&RS ´.&+55¬ÿì/Ë"4@ IYIYIY  IY IY?+?+??9/+++10!!#"$32!!!!!27&#"úýfi*ûþóÀLׂn°ýuNý´‡rü³D0nO¶þé¦Ú+¶ß^ý×^ý  Åþzåõÿbÿì–T#09;@ 4FY44 1$ $FY **FY?3+3?3+39/+9910"&'#"&546326632!#327"!2654&"3 4& A丿’øÀFárˆþ¹þ½ ”‹…Œüô|ÆvÅu’…ƒà21YŠ„ÛÌ¿N´•Š„—ziµ¾&<¥­I^EþÛ¤þª›-´š¦æÂFTÿÿfys&5v‘R³&+5ÿÿHs!&UvŽ³&+5ÿÿfþ;y¶&59ÿÿÿ©þ;DR&U9þýÿÿfys&5L3R³"&+5ÿÿH|!&ULÿx³&+5ÿÿ%ÿì$s&6v?R³3&+5ÿÿÿìe!&Vv€³0&+5ÿÿ%ÿì s&6KR³1&+5ÿÿÿì1!&VKÿ_³.&+5ÿÿ%þ Ë&6z7ÿÿþ1P&Vzüÿÿ%ÿì s&6LÿÒR³6&+5ÿÿÿìM!&VLÿI³3&+5ÿÿ¡þ;¢¶&79õÿÿKþ;¶?&W9ŸÿÿÁ¢s&7LR³&+5ÿÿqÿì|&W8hÿ²?5¤¢¶(@ JY IY?+3?9/3+310!!7!!!!#!¶DwþPÍþHyLþ¶˜f—þ½#5^^ýËRý/Ñ-ÿì¶?"<@@ ""HY  HYFY?+?+9/3+333Í103#?3!!3#327#"&5477#?¢F¶¸a77þåEùú/=ADTk"bq-¢¨FCýÿQþºRãcG9LV v_OmÙÿÿ°ÿìs&8RîR³&+5ÿÿmÿð-Å&XR'³#&+5ÿÿ°ÿìs‡&8MåR³&+5ÿÿmÿð+5&XM%³&+5ÿÿ°ÿìs&8N´R³&+5ÿÿmÿð+É&XNè³&+5ÿÿ°ÿìsº&8PR ´&+55ÿÿmÿð+h&XPÚ ´&+55ÿÿ°ÿìss&8SüR ´'&+55ÿÿmÿðb!&XS ´,&+55ÿÿ°þbs¶&8Qwÿÿmþb+?&XQ¢ÿÿî;s&:K`R³&&+5ÿÿy®!&ZKq³"&+5ÿÿÁƒs&<KÿâR³&+5ÿÿÿ'þð!&\K€³&+5ÿÿÁƒ&<jÿÚR ´&+55ÿÿÿôÉs&=vXR³&+5ÿÿÿãŠ!&]v¥³&+5ÿÿÿôÉ!&=O‰R³&+5ÿÿÿãÏ&]Oɳ&+5ÿÿÿôÉs&=L5R³&+5ÿÿÿã€!&]Lÿ|³&+5þáþ;@ FY GY?+?+10"'532676632&#"¸1650X\&&¡’(dW=_rþÑ!ŽþZj…©— Pj~úe¡“þJË0@  HY FYGY?+Ä+9/+3310"'53267#?6632&#"3#h065/X\×ÌÍ/#£’I]W<`s/ø÷Þ"þZj…úDߨ˜Pk}ãRûî¥ÿ‘Fô&0O@/IY$  $JY$JY0@ H0  *@ H* ?3/+9/]Æ++Ä+999/+10#!#&&54632&'#4&#"3266673# >;¬iEþþáuÉ%+vY]j‡' !<þüA<6GA<8E°B©-Š:ÎWC¦?fûýøüU5Zpiüc#›»7sþ1@9DD9;BBX3¶JG´6ÿÿfÿì7Ç&D&PÜÎvL¦-@#BB/B?B_BoBB¿BÏB B% %Ï%ß%ï%%/]55/]5ÿÿÿ‹°s&ˆvR³&+5ÿÿfÿì!&¨v…³P&+5ÿÿ‹ÿ²¨s&švéR³6&+5ÿÿ-ÿ¸1!&ºv³1&+5ÿÿ%þ; Ë&69ÿÿþ;1P&V9ļپ!´ €/3Í210#&'#56673¾1F[7Œ76D³&@c+Ù<“9s#8¹:@±:Ù!´€ /3Í21036673#&&'1HZ7Œ75D¯*?_*!=’9s#7¶>J¨9 Ý®5±/É10!!²üþ5XîßðÉ´€ /3Í210#"&55733267ðxitEHVUgÉxre\DF=MF ÑÏ ±/Í104632#"F+'9-#;V8AH:A1ÛÇh @  / ?  /3Ì]210#"&546324&#"326ÇsX]nwZXmNC6 µ#&+555ÿÿÿ‘Ó¼$ÿÿfž¶%f`¶·IY?+?103#!!Íg6Äý¤¶^ÿÿÿÓô¼(ÿÿfs¶(ÿÿÿôɶ=ÿÿf\¶+¬ÿì{Ë&@IYIYIY?+?+9/+10!7%#"$32%"32$54&?ý¨”¼þÄÏúþòºDÓ÷ýô®þó ÛÒ©žÑaavÿþ;ß*¯çþ×ËÊþvÜõÿÅ“åðøÿÿÿÛ²¶,ÿÿf¶.ÿø¶ ¶?3?910#3#&'áCŠýòw>\Ïe‹3”óüT¶úJÙÎŒÿÿmw¶0ÿÿfb¶1ÿîs¶ &@IY IY IY ?+?+9/+10!!!!!7rý@)üÕDüŠ/^å^û^^ÿÿ¬ÿì{Ë2f\¶@ IY?+?310!#!#!'d ý þßg6ÀVúª¶ÿÿfy¶3ÿéq¶ /@ IY IY?+33?+339/310#77!!'7!rþ¯HýîÅPýœ—X{T^ýý^ÿÿÁ¢¶7ÿÿÁƒ¶<œÿìqË#.@#  IY IY  ??99//++9999107.54$773$54&'#11Ëk¥3Ô)d'Úé¨þÎÌ3E#¸¶g«û‹È­é{È‚±˜¿¿çÉ»þá˜éEù£½|ì™®Çÿÿÿy}¶;Ñö¶!@JY ??339/3+310###"&547333332673 `g`ÔâOg7=¬µ Âgà ëû5dei8þÃÇþ9ÇÉÀf‰wþþþåA ™—üiÒöÏþþí÷{Ë$!@IY  IY ?3+333?+10"!7!.54$32!!7$4&o‡Üœ\7ck þ ZTT3½=Íû öÓyýÐ  ØmiÂþéË©n9^^¡È}ã„ÂþÝþçýþJ~^9’»àõÿÿÿÛý&,jÿ6R ´&+55ÿÿÁƒ&<jÿØR ´&+55ÿÿfÿìm&~Tï³;&+5ÿÿ;ÿìp&‚T£³2&+5ÿÿLþ &„T³"&+5ÿÿpÿìz&†÷Tþ­³&+5ÿÿÿì%´&’U{ µ&&+555fÿìmP!1*@+FY""GY?3+3?+?991023673327#"&547## 462>54&&#"q‘45R$R"I L'7…Ž~tV …}_i1']#.”‚„«mQŠ¥BV#of[`uþJ"!@# HY?+33?9104#!7!#6654&'&&ut¹`†þôZ¿âþ÷ƒ.]ofW*FYuZZIw¡ˆãûhSS¬ÈþÖþì‚UrO-)>N5@€VS|92I-;·Lþ P"@   FY?+???9310654&#"#33632‘W[pŇ$fbçR%¤ü‚‚ÿþ \@PZ†ñ¦þ#?Ýî€xFpûr{ÿì=+ "&@ GY  FYFY?+?+9/+10%2! !654&"&54663 שçOýH {þµŠµxþfª¨9r—¿vK8q’½BPp7ÎE¾¸•ý…–…¶ªúâäXSØiþP…þœþ¥ÛpyÿìÝ?· FY?+?10%27#"&5473Z7LTAdk“b™DTsbS{°ý4g=‹ÿÿLì?úÿÿìR!"0@ " FYHY?+?+?9939/10#'&&#"'632327#"&'&'1Lþag›>œ QX'A3Jw{n%* $'1NI /Åk…ý+ÀibR~•û¨?< NV`慠ÿÿÿãþH?wyÛ? µ ?3?210363#ybFÊ!@bDþÎûd?ýÅâȧ=þ§ýíÓ;þ`Ç35@ (22FY22(#*$'('HY(?+33?9/+9910#"#654&'.54675&&5467##7!#"33H¤þøƒjŽz\.LFx¡>G}xQ1ïÖvzɸsWmZ!ƒþò½³Nf±zgˆ2+=U==ˆ=„€0@-=QuV¯î'ˆk†Î/SSk¥euuÿÿbÿìTRZÿì˜?"@ HYHY?+?+33?10%27#"&547!##77!#b+/+=HV™þ-ÕbÕÕ»uÀœ&= R V??[Óüî?QýK.#/ÿßþT"@  FYFY?+?+?9102#"&'#"32654&œ­ÅòšYŽM`cú_U‡ª/\ ~Âx’T×ÁÉþ©°8F˜þB–ªV´×þN›0±š¦fþJ‰P@ #FY?+?910&#"#6654&'&&54632mnlÐu0fvˆ]‘yKYKk¯–ü ƒnË/þç¦^}X.4hSƒAx:=I)@ƪÃH©+hÿì¨?@  HY FY?+?+310#"&54$3!#"326654&'öþøðÀÖšÂÍð#-þéüþ줙w®^%yþÍþ¦öÚÅ(–QFÏþÞþû¼É„þ»SÎNHÿìR?@  HYFY?+?+310%27#"&547!77!!Ù=[o*cl‚þ²¸Dþ¶‡@DVngR|_?Qý…k9AJÿì%?@ FY?+?310"&5473323㢴%iff €|æèg·£i¥ëþ!W.„ˆøû­;þÁT%%@GY" FY?2+3?+??10&&5476632#4&#"66Ë¿Ñšª?•‰£š œtƒ’ þÕÍbaúaWRfœªù‚ðÇ»Ež@ˆþä´ªÂæ•š¾¦âþ¢Áþ-цpxý- ¬-ÿ)þ#J!/@ FY GY?+?+??99991023327#"'#.#"'66ß?J*7ákýÉE @;/'5;±9þw^A ,#&(CJ+Ojþ<üìýôdNRæ×ýC6U7T šþ @  FY ?3+3??3?10$3#&&5473¶íP f•þÕàf^f´ºcfbv…Bûºþ€áÿþyþ.å þäϯ`ŽÊþ:‹]þÛ#aBDÿì?)"@( FY%?2+3?39/910"&547332673324'3#"&'R‚Œˆˆf‡^\V}#H`BTNÃ\x̆X{]¾®À|«Äþ˜·ŠŽˆœLþËZ3TZu(Ç—8Èb×þ™³^T²ÿÿyÿì“Á&†jþÌ ´#&+55ÿÿÿì%Á&’jù ´&&+55ÿÿbÿì&RT÷³$&+5ÿÿÿì%&’Tè³&+5ÿÿDÿì&–T³3&+5ÿÿfs&(jBR ´&+55Åÿòo¶"+@IYIYIY?+?+3?9/+10"'532677654&#!#!7!!!2Û;FE.y} wƒþÓ¤f!þÍRþEj1§£ °bx–Z@EmdüòX^^þ™‡KI¤ÿÿf`s&avTR³&+5ªÿìôË&@IYIY IY?+?+9/+10"!!327#"$32&Áñþ¬E¤ýZßÍŒ¤œ üþôÊg求-qmþÒþø^Uiâñ3^1 ºøDZ@ÿÿ%ÿì Ë6ÿÿÿÛ²¶,ÿÿÿÛý&,jÿ6R ´&+55ÿÿþ¼þ˜ô¶-ÿ¬ÿ鞶$,@IYIYIY IY ?+?+?9/++10#!!#"'53266!32%32654&#žþèûþ–!þ(„ªre60-9Nmc·š=‹è»Èýƒ‡ïÍÝ•–ÑßòX‰þ<þÉ]`XÇ7ýu³Yý‰¸¹†€fì¶)@ IY  IY?+??39/3+310#!!#3!332%32654&#ìþèûþ–—ý\•g6f‹¤‰h‹çºÊýƒˆðÌÞ“˜ÑßòÏý1¶ýw‰ýwµWý‹¸¹„€Åq¶#@IY  IY ?+3?39/+10!654&#!#!7!!! œTw‡þÓ¤f!þÍRþEj1L f{uCshüòX^^þþÚ)Sþ:ÿÿfs&´vR³&+5ÿÿÿéÿì5J&½6R³&+5fþœ\¶ @  " IY ?3+??3103!3!#!œdþßö!fþËþXLdNþI¶úªVúJþœdÿÿÿ‘Ó¼$fD¶ &@ IY IYIY?+?+9/+10#!!!32%32654&#ãþêüþ•6¨ýÁwç»Èýƒ‡ðÌÞ•–ÑÞó¶^ýÓ³Yý‰¸¹†€ÿÿfž¶%ÿÿf`¶aÿ\þœÍ¶ $@" IY  IY?+33?+?310%#!#36!!TbiPü9QeiO²RšþÝ°’þ»˜¹^þ>dþœÂϹÐú¨úþMýk²úÿÿfs¶(ÿ¨–¶@  ?33?33910333###þX}ž“g˜´Œý3²{þRšfžýEø¾ý@Àý>Âý+ýáýãýÿáÿìÛË&-@IY $$JY$ IY ?+?+9/+910#"'53265!#7326654&#"'632Û¶°‚Š‡ï¥Ó²·ÛÌÜþ‹¶²ƒÔh†|¨¬6¾Ø¥¹‘ Ï*¯Œ‚ÍgOuj»§`Zir|wL¤fb¶ ·  ?33?221033#7#œfºO nþËdx#ûæe¶ü’þ¦<úJ9f|úåÿÿfbJ&²6 R³&+5f¶ @  ?3?3910!##33ýÕ—g6fžü×Ùý'¶ý)×ý#ÿ¬ÿéú¶@IY IY?+?+?10#"'53266!#Ï(„ªre60-9Nmc·šyþËe!X‰þ<þÉ]`XÇ7úJXÿÿmw¶0ÿÿf\¶+ÿÿ¬ÿì{Ë2ÿÿf\¶nÿÿfy¶3ÿÿªÿìôË&ÿÿÁ¢¶7ÿéÿì5¶@  IY ?3?+9910"'532673663…]?C_o¸uþÂi L!oÄtý-pßo%Áýu)þê=¾ÏûŒ´¢ÿÿœÿìqËsÿÿÿy}¶;fþœ\¶ @ "  IY?+3??31033#!3!ødþߨbhOûþ6dþßö¶ú¨þ>d¶ú¨Í®¶@ IY ??39/+910!#"&54733273„Û½’¡iffriÃÙ dþËm[‹„@dñþt8\^ZïúJf¶ @ IY?+3?331033!3!3f6dþßX#dþàZ#dþ˶ú¨Xú¨XúJfþœ¶@ " IY?+33??3310%#!3!3!3biPùÛ6dþßX#dþàZ#dþß^þ>d¶ú¨Xú¨Xú¨Ás¶ &@ IY IYIY?+?+9/+10#!!7!32%32654&#sþèûþ–!þª¾‹è»Èýƒ‡ïÍÝ•–ÑßòX^ýu³Yý‰¸¹†€f¶ "@ IY IY?+??39/+10#!332%32654&##3ãþêüþ•6h‹ç»Èýƒ‡ðÌÞ•–f5fÑÞó¶ýu³Yý‰¸¹†€ý/¶f㶠@ IY IY?+?9/+10#!332%32654&#ãþêüþ•6h‹ç»Èýƒ‡ðÌÞ•–ÑÞó¶ýu³Yý‰¸¹†€ÿìNË&@IY IYIY?+?+9/+10%2!7!74&#"'6632#"'5mþ91ýf“ÓÌ€²r£Eú¿þ¸ÚΑ¸HPE`Hïù@^&þ×þíþðþHÛKm\fÿì¬Ë$*@ IY  IYIY?+?+??9/+10#"47!#3!6$32%"32$54&¬°þÀ×úþòþ}•g6f‹(Á ¯÷ýô­þó ÛÑ©žÑõþ?í*`@ý1¶ýwË/¤þ×ËÉþsÚõÿÅ“åðøÿÍm¶ &@ IY  IY ?+?39/+910#&&54$!!##"33Lýþ}ixLþÊf…žÅå䤔Ì{ý…–(¹wÛíúJ{ß·¯…šÿÿfÿì7PDbÿìT*$@"FYFY?+?9/+910476$73632#"&26654&#"b‡Þ]LK ?þÎ{…Å7²Û–§Ü”¬¹st¬[}me¿i ƒ²ðÃ.C V 9)/þßêÚÆ»¼þЕꔊöžž˜t†#/À¸hÿìÙP(-@""FY""FYGY?+?+9/+9102#"&54$32654!"32654&¢”£’†hue¿„ÂÌ’þΡš¡þòq¦ø'ðÕÙpP}w•w\^–UåÕ¹=´ý—I©¯|kºóÈ‚zXgNÿì\P(#@"%FYFY?+?+910>32327#"&54667>54&#"çydY)ˆŽ™¿˜};nk¤¤B¦l’¡G’š”n3b[:¦U* uloœE8N`CW]IZ+‰}R}e<;DN3KK'!fÿì)(-@ #FY GYGY?+?+9/+910#"&54632365#"'66322#"f­Ü“¡”ô“ÙB‘’5}%'4D¹ý¢¡;FÆtÉsϵþzþäŒÈ®¸V½ÑK 'R(þØûE\+ ¯þáœþÙÿÿfÿì}PHÿÍÿì{P;=@ 8FY88: /4/GY4(#(GY#?3+3?3+3??9/3+3103>32&#"327# 47####"'732654&#"563 33^¢‰ÌƒM:9Fq»qv}532Õ`×&$\xhGVn„`%J`]KT|¢wQ[îO½ÔÿÆYZLºÛùÇW-ò?@     ?33?33339/10!#&&'#3663°Å,þC’ÁZçe™Iíuê¢ LüÊÓŒ üd?üâž 7|ûÁJm? @ GY   ?3?39/+10!3#!#“dqheèfnýodé?þ!ßûÁýü?ÿÿbÿìTRÿÿL PQÿÿÿßþTSÿÿfÿì‰PFÿÿH^PPÿÿÿ'þð?\bþ…"-@"GY FY ?3+3?+33??10##&&54$732654&'sšþò´kZi©Â‘´c^ýR‰ÅÒzrŽ×’B'þr¹þÌ þìæ¹(§Õû­¤¼ ‘ƒþúýû„œ¥¶ÿÿÿ¸º?[mþ“+?$!@ $"FY?3+3??3910326673327#&&57##"&547}˜_[nÃ…!ib¤T(dePC6TÏr…‡–?ýFg7JWƒóžåýhBYþM_ SN3qr|w¸²½ý©8€05‚9°ß)ýôˆ‹0dlXKUTÓÅÐþ­­fæâX!%¬¦*T# Jÿì¶T#*@ GYFYFY?+?+??9/+102#"&547!#3!6"32654&H®À𡶷þìodé`d3¹zÁsˆ‰}Áp‹TÓÅËþª¯ØÏ6;ýü?þ!ç VšþÚ¦³£™2±ž¢ÿÛÿøÃ?&.@$$HY$$HY FY?+?+?9/+910"#"'53267667&&54663!#"!3RSiL83AR>! 32"32654&5•Y§¥Ù³œ£ jwžZTn†`  Ka]I*Pi‘kAOzsx߆›wT‰ Æ¡”LOÐþðþÈXZM½×zÆ‹LýÝ„KéweeJÿìÕ?$2@FYGYGY?+??399//++910763 #"&547!#3!3"32654&s8uaTßÁ£­þodé`dãidN‹6q„£L þè¢Äž™býü?þ!ßýÕ xKzsŠzhbÿÿL éÿÿHñ!&Ôv ³&+5ÿÿÿ'þðø&\6ʳ&+5mþ+?(@ FY?+???39/9103#326673#7##"&547ô ZZX;˜_[nÃ…!ibçP§ìƒ‡–Vþj†¥ýFj4JWƒóžåûÁÍÝ|w???3Ä22333?3Ä210##"&54632'"3254&#"&54632"32654&#"&54632'"32654&²ûjo¬d¬opxg«myoìO…QRH‚ŸHý¦d¬opxg«mèìN„SRHTLHPd¬ooxg«mxoìO„QQHTLI¶úJ¶ü®¯þÐœ—”ž0Eþü†ttMÜmly¯þÐœ—”ž0JŒþûŠst‘mlüå¯þÐœ—”ž0Eþýˆtt‘piÿÿþ¦Í¶ ÿÿø¦¶V{ü¤µ /33ÍÍ107Ã9þÂÕ?þ¤1þ°þ'¢%{ˤµ /33ÍÍ107'7^9=Õ@þ{1P'þ^ÿÿ2ÿð¨¶'¬âþ1Û¶ ³??10#ÛûÁk>¶úJ¶¼3Ç@  @ TY?+?Í2910654#"#336632HVTY—þw?‰¶/@LY LY LY?+?99//3+3+10!!!!!!##7 â›ýÍ$ýÛ;5þË?g@¹'^ý°^þå^þÏ1^ÿü¨Ç&T@/ !"!MY ""?"O" ""MYKYLY?+3?+9/3+39/_^]3+3102'&#"!!!!!!76677#737#73766oª'6l{†­+šþh/žþc1‹÷üV_"¾Á1ÇÇ-)äÇNT2•’ÅRçRdßY^T ©–\RçRÏ»¸=ÿîo¶ ,F@$**),',MY,, LY LY!KY!?+?+?9/+9/+339/10!##323265!##3267#"547#?3¦ýžg6‘ÊØýüïþµ)¨òS4A.;E4ÄN`77Nþ ý¦¶¹ý¹ÁÑýðRþ}g=BIVÕN€gCþÿPÿìË&L@)MY " MY""LY"LY?+?+9/3+39/_^]3+310"!!!!327#"55#7367#7332&ߺþßRÉþ4 ºþX²°s‰Ñ踬ª®_^à¦y5fmñâRbwRóâ9^7ÿRetR ZRNú¬º'3@+1! ???3Ì2?3Ä210#"&546632&#"3272#"&54664&#"326¬û¸jHüûq€Yœ]ROHCg‹—QUJêw{N‘au|R‘òOGFf7›ey¶úJ¶ýuz~n½lP¼‡¬'R%ž„vpºi…wn»hóQTV—X®¸sÿîmË&)@$     /3/399//9929910%273#"&556746324&#"66Z«N›†h^j\}st‚ƽXÍQGID˜Hå’­¥¤+T&ú—™Œ¼þãVþÓ†|\ij`sþ1MâND¶ (1@  &  ?333?39/]39/33310!##337!2#"&5464&#"326ßfþJ)+Á`5{¨\A–(zˆZ˜bv†º3UJl‚ZHl?ÝÕüs¶úðúJVV¶’~rÁa‘‚®ãþîYg¬dc±®åº¶ @ ?3333Ä233210##5!###33#7#ÝVÙ ÛXÝR}Ýß}VãåƒNNý}aÉþhÑý¢^ý/ŽÏý£ÿÿ{Ëv‰ÿÝ®H· /3/29/310"&546632!3267&&#"œñ…Šô•˜ó‡üÅ1¦Rƒ·QHbÙ“7žX­z#“«ÿŒŽþý¥þœ5Fi)›|‹7@uþéÿÿ9ÿîZ¶'@‰ý³&{Ä ´ ?555ÿÿSÿîÉ'@Fý³&uæÁ ´ ?555ÿÿSÿî¶'@5ý³&=ù¶ ´ ?555ÿÿ=ÿîP¶'@ý³' ?ê ´ ?555ÿì-Á'@ ! ?3?39/9310#"&546327&#"56632267&#"-–þð°š®ŽæßU˜ 9ƒ-*“9ÀÍý¸qºƒ_Àu·m}¬þíþGôÈ°ª5žÕið#bþòû“’«ú‹þûŒ™ÿÓô¼ @  IY?+?3103!7!ðCÁ ûê*gþ!FJ¼ú†BFÓZÄüe2Ïþ¶@ IY?+?310!#!¨üf?þTø¬´øLVþº¶ @ IY IY?+?+331055!!!V˜ýxütýwÙþFÊ_E^üÃüE^¨ / ´SY/+105!¨‡ dd%ÿò¨·//9/3310##533bnþç¶ú^Xý{œ #/*@**SY $$SY/2+3/3+3991026632#"&'#"&546"32654&!"3267&& [‘A?^¦§~^?B‘Z¦§ØPs77sPXhiýOWjjWJs=e?:^o!'9}apG›=;^n,::C`qHo²#ø/@RY RY    //99//3+33+310'!5!!5!!!!‹L{þÉ^™þ I}:þ šúÝþÕ%RFR1'þöRþºR‰ÿö/Å @ SY /3ÍÍ/+105 5!ün’üß!ü‡žJ×gþqþ¢þ…dd¨ÿö=Å @ SY /33ÍÍ/+1055!ª!üß“üm‡q^gþ)Jþbþðddw-à µ //33103# wÂ1Ãþ=1þ‰þ‰wßäýý!ßmý“ýšÿÿÿþ'L5Iïÿÿÿþ/'O7IïjÙÛø´€/3Ì210#"&5473327Û»–Œƒ RUeçø‰–ta&$-DGÉþéþ? · GY?+?10"'532673¦>3/BR] `þô#þ\g~íû ¥Í ²€ /Í106673#$h` :0ç.É6'Ö6¬þ;¬ÿƒ ± /Í106673#¬"g` ‹=/þV,Ä=(Ó9 Ù ! ² €/Í10#56673 "g`Š?/,Ä=&Ò;s3ÙÉ @ NY NY!?+?+10#"&54632"32654&Ùd«poxg«mçëN„SQHTLI®®þЗ”ž0J‹þýst‘pi5J¢¼ %@NY  ??9/3+33310##7!733#67‘ƒ1R1þyúV}…×=$ fþá/ååLAý»&"~þ·Z7˶(@NY NY!?+?39/9+9102#"'532654&#"'!!6˜p}Á™~SfotŠVRNZ!y–þ³P@`tu³1]B†jMW¨Nþè‹5å¼&-@ NYNYNY!?+?+9/+910&#"3632#"&546322654&#"Ï3B|Ã#U„]pN^nt|ÙˆTþ’]zHE:i=QZÁ¡`whZž\’‰ª"  üÓ”lE[8_MUgšJî¶@ NY?+3?10!7!šãþdü þJPAüÕm;ÑÅ#0#@* $NY NY !?+?+9102#"&5467&&54632654&">54&øbwav?L¥†jƒ~s<2hsUJZoRQ[2@SG+JÅfYOx1(dGpqbb€-/[8f€þ+#fSAL_ORgTþÁî #'+/37;?CGS[kt|‰@N-luuk\‚}}VKvkZQ\…t\84 0%3&1HT;GFBIHCHEüVüW©û/2A1R~X‡š8*²P:/5K6DpJ;þí?HI>@IHÿÿþéþ·!&7Lþ³³&+5ÿÿÁ߶ ÿìD)2?<@&7&HY077,FY,,=FY,!FY?+?+9/+9/3+310#"&5476654&#"76323267#"&54632333654&#"®u®Óz‚’:D%;668K3/+dZ…Þ˜ýû¯‹¤ýmR¦™op`ss©þ—ûz‘…gŒ£BZM:LskDWeÊ…à³¹“·ùî}Rpe|=*@ÖÎÁÃÃ@ IY?+??91066632&#"#3î€ëtf<);išÆ]liwíd…9 X iðþ±®ýî!•sÿìú?--@##  HY *FY?2+3?+339/10"&547!77!##"&'4'!32673326‡‚ˆˆ|þòº¿÷tÂVr^‹ ýQþü³Rt#;a6QF]•Zµ·­W’?QE®v¶þ»ž^T²¿¦þ¹þ¹þ䈜üc&Pbÿÿmwu&0v}T³&+5ÿÿH^!&Pvq³5&+5ÿÿÿ‘ýöÓ¼&$[øÿÿfýö7P&D[%ÿÿÿ§ÿìüË'\þ2ÿËýömÿƒ ±¸ÿÀ@ H @ H /+3Ì+210#"&546324&#"326mta`mm`atYE76E?<7Eþ¾\lj\]jnY9DD9:CC‹Z´Ã ´ ?3Ä210673#'467#"&‰i;‡<9þ†t7<2&*,…˜•!U­1`VŒ#]3 #1:ÿÿÿþ^&ïLuÿÿÿþw&ïO¬ÿì$%@  IY IY?+?+99Æ10#"$326673"32$54&{¼þÄÏúþòºDÓÛBfhi 5ü-ýô®þó ÛÒ©žÑÿþ;ß*¯çlm)ˆqöby<ÊþvÜõÿÅ“åðøbÿìöã"%@ FYFY?+?+99Æ1026673#"&546"!2654&‰ËbWah 4å%ø¢¸¿’ø•|ÆvÅu’T‰#…pð^WpÅþ©´ÛÌ¿N´VþÛ¤þª›-´š¦°ÿì®@   IY ?+?3Æ99106673# 473!267s-ewi #½›:þêìþHºgÁVÃá.϶ӌˆ ±&ýZþòë‘Svpü}Y_þËÁÞÑmÿðwå!#@  !FY??+?3Æ999103266736673#7##"&547}˜_[nÃ…!ibgxh #¾œ¶P§ìƒ‡–?ýFj4JWƒóžå‘Ž¢¸#üªÍÝ|wþó×c=þÀ?ý[ïIàýýq˃³ÞLþýðÌÉþ7²s1@IY IY @IY?+Í99//+3+310#!!7!3!!32%32654&#sþèûþ–öþÆ9DhDšþdLè»Èýƒ‡ïÍÝ•–Ñßò‰^-þÓ^þ¢³Yý‰¸¹†€Hÿì˜'%8@ FY HY GY ?+?3+39/+Æ910!!763 #"&547#7373"32654& þåZ8ubTßÁ£­dãã4d^M‹6r„¡€?Qþ^ þè¢Äž™iÓQèüí vMzs‹ygcfÿì)Ë%1@IY!IY! IY?+?+??9/3+310"!!327#"47!#3!6$32&öìþ§G¦ýZ ßÍ‹¤œ üþôþt•g6f‹‰0Ö7¹±‚-omþÍþó^"r âñ3^1 `Xý1¶ýwÊ.¦DZ@JÿìRP$1@ FY  FYGY?+?+??9/3+310"&547!#3!632&#"!!3267¨´Åþèqdé`d4ȇkkn™æ1ýð‘‰EyH{ÞÃJ3ýö?þê+Z/ÕÇT6E ©!\9ÿ‘-¶ #@  JY ?33?9/+3310!###3##!'&'^œ¦þVm_Eø`}¨LTX^g#$Õý+¶úJÕN$Ÿ•žÑÌYÿºd? !@HY   ?3?339/+310#####!'¨¼bR‰m^s}þËcŒH™#4?ûÁþþþþ?bÿ1^f¶-@ JY   ?3?339/3+33310!###!#3!3##!'&'ø^›¦þVlªþA—g6f‹áF÷`}¨LX7zf#$Õý+Õý+¶ýw‰úJÕN%¦\ÏÑÌYL¸?,@  HY ?3?3?9/3+3310#####!#3!!'ü¼bR‰m^s}þËc1þØm^é^jF+H™#4?ûÁþþþþþþ?þñbÿ1^ÿÃ`¶"0@JY  ""IY?+33?339/33+310#>77!#.####"!=÷Fl”hþìúýömA i4j^¦b bw]=á¢öüüv<ZVýäKŠ›þ3×xm2ýî-mþ+Dÿž?0@HY  HY?+33?339/33+310#>77!#&&'#!bÊ9k“gþþ  þ^b{F6c3{“v_wqs[-»e‡ýƒoif8}EEþƒ DzuþÁ7ŒfýÕ+'XQþ¨}qf`¶%(9@ IY&   ( (IY ?+33?3?9/33+3310!667!#3!7!#.####"!Ã÷)O6þ›g6f…éþîúýömA i4j^¦b bw]=á¢öüüUm#ý¶ýŽZVýäKŠ›þ3×xm2ýî-mþ+DJü?"%9@ GY#   % %HY ?+33?3?9/33+3310!667!#3!7!#&&'##"! Ë#C0þ¶udé`^@þþ  þ^azF5b3{“w^w †˜Bºd‡ýƒo?Týß?þ>}EEþƒ DxwþÁ7ŒfýÕ+Zyþ¨}qÿ¬þ\ÛÃNZ@3A32&#"37632&##"&54667>þ‹¶²ƒÔhˆz_¦O6X³p^!^>K@DC#"&%c5uƒ¶°€šþÙþÚ§€QDK¾M™H^›N´BpŽO—£¼Æd¦!`Zir|C4L32&#"7`gƒ{Ye[·® j8¨EMd*\‰B›JvrEÆ’‚ŒTZ•ŸiX=qJ)vŒ _ ^=L@DC"#!&bJ‚]q”u\gŠVB;^ `/ `TE\="soaY\{kN^".PI @…Eˆ^H' MYÿÿÑö¶uÿÿšþ•¬ÿì{Ë6@ IY]m?  IY IY?+?+9/_^]]+10#"$322!"!74&{k·þû ýþõ·FÔøýFß)3üÜÝþÊ3áÖ½þ–÷…,±ëþ×û¦E)A8öÿ%þ¼þésôôbÿìT 4@FY?O FYFY?+?+9/_^]+102#"&546267!"!654&‰´Åø¢¸¿’ø  Þ(ýF¸—à-¹’TÙ¿Åþ©´ÛÌ¿N´ûîïÓ84þª¼åÁ42š¦ÉHÃ@  JY?+??310%66>32&#"#3ÉWv<_rK++MnKýÝX¶du“/À~t7T hšû‘¶üJä‰hP@  HY ?3?+?10337>32&#"#hel?î5SeD0,<^;þœq?ý!²L,}o9 N cˆüéÿÿÉHs&€vfR ´!&+55ÿÿh!&vœ ´ &+55ÿÿ¬þ ®Ë&2\¾ÿÿdþT'\R¬ÿ¢{0K@##/) /O IY&))IY¸ÿൠH?3++3?+33_^]999910#"&'&54$76632%"'6632665%{©þÞº 9#&9 ¹Â©,à 7#&; ¯¸þ/R¡ø•Š 4"&: ›ëŽþþñþNì''-+&#ìù¢ï%&-/)þå£S ÐþÒÄö)"$++Ï…ÖzW?bÿª“-\@8!,% +;K FY#%$ 4 D     %FY ?+3_^]]3?+3_^]]39999102#"&'&&54676"&'6326654&'¬#3y}ÕE"3†‚}á’C"2q°f¦@Jq¦bLN“)($Èš¹þ¼»H(&Õ§²9ÂCå'%§þë—þ÷;;I¨žk™#7ªÿì2H[}@ PYL>443JY4¸ÿÀ@: H4B@Y YY Y Y;B;JYB@ HB YL 0 % %IY --IY?3+3?3+399ÖÄÄ++Æ_^]_^]Í++Ä910%2654&#"'63 #"'#"&532&#"3267#"&'&&#"#6632376654&'&&54632\ŽË™Z{w;].-w‡OÄþåÍ’€b|9ÁЪ ±†d9Za]³“Qœ–U05‹<Kv?*O/>Q c_0f\KR+þÞpW +8+#38H#u¥ª¯!TDþEþêýêøI+úñéHV@Œþëþ­˜ÍÌ6"&2NR(=7^d("˜Jq> 2  7mÿì`×-CVnµKGT9/T¸ÿà@ HT6/.HY/¸ÿÀ@( H/=@=6HY=@ H=G+""GY ((GY?3+3?3+399ÆÄ++Í++Æ+Ä910%2654&#"'63 #"'#"&54632&#"3267#"&'&&#"#6632376654'.54632J‚®‚UULR+mbšà–obpc˜§ˆÌƒeO7CCP¢xá>p%'l 7n[*O/>Q c_/g\LL0þÞpW (:%+#38H˜s¯s/R9þ²Øþi§55»ÃÂl¸>T6–þ¯šþÕ($R,=8^e(#—Jq= 3   7ªÿìü7EK@'=A=AE HE@;?B**IY0&&IY ?3+3?3+39/9Ö22Í+99//10"'63 #"&'#"&532&#"!2677332654&#'##'##'7¶;].-w‡Ol·ÜŒp’)³j·Æª ±†d9Za]³“QzŽ#5m)Ït»”X{s ËP ÊN -m!TDþE½þbþÃŒd\WiõöéHV@Œþëþ­˜þg–ŸôÉY6Ñ™'pœª¯¤uuuu¤sj°$1@  $ H$! ?223?3399Ö22Í+99//1033363###'##'##'7òbLTEb\ ³ä@b>þó×c=þÀ]r ËP ËM -?ý[ïIàýýq˃³ÞLþýðÌÉþ7°¤tttt¤ªþôË@ IY IY ?+?+?10"327#&5$32&ÁÅþ˵ٽ6}ffÞ÷ÑhÞ±‚-€mÑþpñÝöýÄÚ #ý ¼îDZ@fþ‰P@ FY GY?+?+?10%27#"&54632&#"çXLbd½Ê—ú¡†kkoƒÐs”F$ýªÕÞÇÁT®+Z/›þⲚ¯¨'^Ù@   //910%'%7%7%1'þã´Hµþå'çþå%¶F·)þ椦B¤þÇ);¦@¤“¤D¤5%þŤB¤u¨Hž ³ /Í2310#"&5463!6632R"%::»*+"(yþV$,3++""W“îu®µ€ /33Í2102676632#654#"##7²4yd:uBXi]i,cc¤r?#!LC V$9Qç\ ³ € /Ì9104632&&0&P%+wjc¸,9>' 9%B"n®ç{ ³€/Ì9105654'.5432{jcw+ P&0¸KkB%9  >9)þÁÁ‘ (6DR_m`@0(!%6/,3_YV\mfcjD=:ARKHO %3j\AOOA\j3%  //9//////ÍÍ2ÍÄ2ÍÄ2ÍÄ2ÍÄ2ÍÄ2ÍÄ2ÍÄ210&&#"#632&&#"#6632&&#"#6632!&&#"#6632&&#"#6632!&&#"#6632&&#"#632!&&#"#6632o ³/Æ/Æ10#677&''6673&&'7%'67'&'7%'766&&'57 F$a5sGÈAÝýR Ia4!‚&b'Zü›©E±x+REC{L%E±xbC¾ûWB¿OÝ#B¿OÝ® Ia5uGÈAÜ‚ú¸2Ã4bEÂ<ºY?DnXÞŒ·FÆcÓDnXb'Xý< F$a5fþœbJ"(@ IY  ""€ ?22Ö2Ì2??3+?10333##7##"&5473327œfº)6 nþݤÙrС¸60ûæe}»–…‰ RUeç¶ü’ÅÑú¨þ>d`¶úåJ‰–ng("-DGÉmþ‘+ú-/@-%€+  FY HY"??+?+?39Ö2Ì2103266733##7##"&547#"&5473327}˜_[nÃ…!ibפÉuÏ•§ì„†– »–Œƒ RUfç?ýFj8JSƒóžåüþAoÍÝ|wE‘k6Äý¤{D=ì®þÑ͆_ww©ý“ÙÁ ýH¶^ýº þóóíþ‰¹)h3¢LËÉáHþ'?.@ GYHYFY?+?+?9/+910"'532654&#"#!!632fLXbzºf–…O@mbãøþmR9Lp§`‡êþ%c0Ÿ®š°ýö?Qþz _»ˆÊþ¯ªÿ¨þœ–¶(@ " IY?+?33?339103333####þX}ž“g˜´Œý3{•biP^þRšfžýEø¾ý@Àý>Âý+ý}þ>dáýãýÿÍþ“{P=@@" $ FY($$ & ="2 GY- 9GY?3+3?3+3???9/3+310# 47####"'732654&#"563 333>32&#"327#R þ² ¦m`mžŒÎ‚K<8Gt¼nv~4dÙý'¶ý)×ý#Hþ“ì?"@   "HY?+???391033###3Z’ý¡X{fdQEþyqbábn?ýêþ'þCm%ýÛ?ýôf¶/@/  ?3?399//9]10#37733##ø¨ƒg6fœ¬6V!ŠýEsoþ×CV‡ý…¶ý8“øœÙýžü¬¬þÅHì?6@   ¸ÿÀ@ H ?3?399//+]91033##'#37V+-’þ"1Dß0VDfqbábn¦öËþ[âþH9ß<ýÛ?ýô˜f¶7@! JY o ?3?39/]3+3910!###73733#73Óoþª¾ƒgö¤¤-f/ßß]…¨ŠýE™ý…R××RþVyZýžLì4@  HY  /   ?3??9/]3+39103###7373!!a}þ&)jþøÍP`,`+yþ‡jFÝbþ+ý–/¼þNÄÄNþþÕÁ˜¶ !@  IY ?+?3?9103##!7!öü×3ýÕ˜f!þ¨¾ß×ý#ý'Ùý'X^Rw? !@   HY?+?3?9107!3##R±o=’ý¢“þyqbÑîQýô ýêý×%ýÛîfþœ\¶%@IY " IY?+???39/+10!!#3!33#×ý•g6f‹ø‰dþߨbhOÏý1¶ýw‰ú¨þ>dJþ“m?%@ GY " FY ?+???39/+10!33##!#“dqheײgdT²nýodé?þ!ßüþ?mýü?f˶ $@ IY   IY ?+?3?9/+10!#!#3!!¸þþßd—ý•g6f‹ø‰ÓXú¨Ïý1¶ýw‰Jº? $@GY  HY ?+?3?9/+10!#!#3!!!…fnýodé`dqh²þ¶ýü?þ!ßQfþ=¶0@ IY IYIY?+?+?39/+910!#!#!632#"'532654&#"'d ý þßg6ÀD=ì®þÑ͆_ww©ý“Ù¿>EVúª¶ý\ þóóíþ‰¹)h3¢LËÉá Fþ? 0@GY  GY  FY ?+?+?39/+910632#"'532654&#"#!#hdDCp§`‡ê—hJXbzºf–…?RmhÕýÕdç?þ) _»ˆÊþ¯ª%c0Ÿ®š°ýöãü?¬ÿ®mË.<N@+%/#6, IY ,6IY,, , ,,IY#IY?+?+9/_^]+Ä+999910327#"&'#"$32&#"327&&546326654&#"mh¸t?kG4dHþ“sP92@0"  FY!1,HY1?+?3+3??3?99104&#"#654#"#33663236632327#&&54666úVLñ0mf“šj¼‚#dbçP!PËojrMÐvuƒRT!edP=DZXMUþíáýú¢}%¶‡ò¦þ%?Òqr†€…{s7\þg8aþM_YF6,™xÿÿÁƒ¶<qþå? ¶  ??3910%663#3h >¹fýœf]e²dmfCyû±þ$ÞMý!v„ƒƒ¶)@  JY  ??39/3+39103!!#!7!73î uý‰ !þâRiXþô íd…1ü\-Rþm“R<•þå?%@ HY ?2+3??3931033336633###-ô°dm >¹fý¤ô÷X]Vù?ý!v„CyûÁRþfšÿyþœ}¶"@  IY"??+??3910%###33ÝbiP^þýò`þðjðãwýÕø^þ>d¦ýZþ¸ýŽrý1ýwÿ¸þ“º;"@  HY"??+??3910%###33ffdRTàþwy×õdÏuxþ@ÝPþCmßþ!+þ2Îýêþ+ÁþœH¶'@ "IY IY?+3?+3??10!7!!!33#!qþPÍþHþôö"eþߨbiPûüX^^ûXú¨þ>dTþ“Û?(/@' "&'&HY'FY?3+3?+3??910!326673327#&&57##"&547!7!bþ¹…_[m„$ib¤T(ddOA8NÒu…‡ƒþžîý—c;JW‚ì¦åýhBYþM_ RK8mv|wdœþ“þ?)@ FY "FY?+??39/+910##"&5473327733##6?¡ð€Š:dE Ya£þ0bײfeT²TsÝxuJf þÂXJWêZüþ?mzÍ®¶<@ IY??39/+9999/9/_^]10%#"&5473333673#ÅA’¡iffri OWP© dþËe„™¡CÝ5‹„@dñþt8\^xþŽDïúJmBþÆœþ?6@ FY ??39/+9/9/99910336773#667##"&547PE W_BV@‰Ë)bêf22-ƒº7V5€†:?þÂXJW3þ×  ÆZûÁå饶!þõ{rJf dF¶@IY ?3?9/+910632#654&#"#þƒÔÓ¡hggsh½ßŸe6¶ý”Z‹ƒ>fþão=^]Zý¶Hª?@ FY  ?3?9/+910!654&#"#336632öE Za¦ü/bég12/NÐt€Š@AVJXþêäZ?âè¨on|r*fþÔƒÿìüË&04@"" &IY*&&'IYIY?+?+9/3+39/10!2!#3267#"47"&54733"3 $54&mEÇÑþ1þ ÕÏjÐ|~ÒpóþñXcdeçþŸKƒ ™š;|ªœêã8Gõú(0`1%.U8_PF36:[YþÃþä²·u{dÿìJP-4@(( "-"FY-- FY GY?+?+9/3+39/10"3 4&632!#327#"&547"&54733Dƒá21YýÀ5µrˆþ¹þ¾!”Š…ŒŸ­ÂXc`húçÁFTþXæziµ¾,6¥­I^EÛÄ:5_PF37:^ƒþœüË)3=@$$) )IY-))"*IYIY?+3?+?9/3+39/10!2!#3267#&547"&54733"3 $54&mEÇÑþ1þ ÕÏjÐ|vÄgHhKÔèXcdeçþŸKƒ ™š;|ªœêã8Gõú(0`/%þ°T+ûU8_PF36:[YþÃþä²·u{dþ“JP'0=@""' 'FY+''"(FYGY?+?+?9/3+39/310632!#327#&&547"&54733"3 4&J5µrˆþ¹þ¾!”Š…ƒœ?eD…–Xc`hƒá21YRæziµ¾,6¥­I^Aþ§aѯ:5_PF37:^¨çÁFTÿÿÿÛ²¶,ÿÿÿ¨–J&°6fR³&+5ÿÿÿÍÿì{ø&Ð6L³?&+5fþ¶+@IY IY ?+??39/+9910632#"'532654&#"#33ò(*äù¬þз_ww«þÑÆal‡g6fžðÿíéþ•´)h3?ÈÃÓý{¶ý)×Hýúì?)@HY FY?+??39/+910#"'532654&#"#33Á­³‡è™eNVezºe–=8hbábn=’V×¼Ëþ°©%b/ ®Ÿ­ þ?ýô ÿ¬þœú¶$@"IYIY IY??++?+?10!#"'53266!3##þN(„ªre60-9Nmc·šyþݤÙsÑ X‰þ<þÉ]`XÇ7ú¨þ>dÿšþ‘¼H$@"FYHY GY ??++?+?10&#"#"'532667>323##L&$\xhGVn„`%J`]KT|¢wQ[פÈuϦîO½ÔÿÆYZLºÛùÇWüþAofþ\¶"@ IY  IY?+??39/+10"'532!#3!3¤Œr,œ@ê >{ý•g6f‹ø‰dþèHþÂþ-i" Fý1¶ýw‰úÏþ­þÒJþm?"@ GY   FY?+??39/+10"'53267!#3!3¤fLXb’±.pýodé`dqheð+yµþ%c0»Õýü?þ!ßû”©¼`fþœ\¶%@IY " IY?+???39/+10!#3!33##Zý•g6f‹ø‰dþߤÙsÑ¡Ïý1¶ýw‰ú¨þ>dJþ‘m?%@ GY  "FY?+???39/+10%##!#3!33ÉtϦnýodé`dqheÞTþ=oýü?þ!ßüÍþœ®¶)@IY"IY?+??39/+910#"&54733273##3˜Û½’¡iffriÃÙ dþ˦Hh^¨m[‹„@dñþt8\^ZïúJþœÂœþ‘þ?)@FY " FY ?+??39/+91032773##3767##"&547PE Ya£þ0bê‹Jb\ˆ13¡ð€Š:?þÂXJWêZûÁþ‘Ãå|¾ÝxuJf mþœw¶$@ "IY?+??3?3310%33##7####3Ý–þå¤ÙsÑ ¿Oüô3Þ:Ä`5ÍÍéú¨þ>d…qNú¼Dšþðüf¶û-þ‘ò?$@   "HY?+??3?3310#&&'#36633##u,þC’ÁZçe™IíuÙ£ÈuÏž¢ LüÊÓŒ üd?üâž 7|üþAoÿÿÿÛ²¶,ÿÿÿ‘VJ&$6{R³&+5ÿÿfÿì7ø&D6B³%&+5ÿÿÿ‘ò&$j+R ´!&+55ÿÿfÿì7Á&Djñ ´4&+55ÿÿÿ‹°¶ˆÿÿfÿìP¨ÿÿfsJ&(6‘R³&+5ÿÿfÿìáø&H6³$&+5^ÿì Ë"&@ IY IYIY?+?+9/+10#"&54$!3654&#"566322#  ÖþœÚÇÑÏìÕÏÒäv×sñüìæbKƒþbþeš‹õþE瀞ìá2MôüYa/'þÑû®:±¸vy=ÿìTP &@ GY GYFY?+?+9/+102#"&54$!3654&#"56267# å­Â–õ’rˆGC ”‹ƒ’„à11ýüWPÛŽþ³ºziµ¾%=¥­J^Fûòè¿þòETÿÿ^ÿì &ájR ´5&+55ÿÿ=ÿìTÁ&âjŒ ´3&+55ÿÿÿ¨–&°jR ´$&+55ÿÿÿÍÿì{Á&Ðjå ´N&+55ÿÿÿáÿìÛ&±jÿÚR ´9&+55ÿÿÿîÿìÁ&Ñjÿ> ´<&+55 ÿì9¶&@IYIY IY?+?+9/+10#"&'5326654&##7!7!Õâåˆí dµd·Òƒ»d¾ÍhHýŸç)¹²ˆÚn#,uj^¥k‘ŠX1^Xÿ\þ'?&@FYFY FY?+?+9/+10#"'532665!#7!7!®Ó…öª£x6¤K†ÅkþªKøýé®Ï®œö‡@h#/pÊ7P=XOÿÿfb‡&²MéR³&+5ÿÿmÿð+5&XM%³&+5ÿÿfb&²j´R ´ &+55ÿÿmÿð+Á&Xjñ ´+&+55ÿÿ¬ÿì{&2jÏR ´.&+55ÿÿbÿìÁ&Rjè ´-&+55ÿÿ¬ÿì{Ë~ÿÿbÿìTÿÿ¬ÿì{&~jÏR ´2&+55ÿÿbÿìÁ&jè ´1&+55ÿÿÿìN&ÇjÿõR ´.&+55ÿÿ ÿì'Á&çjÿ< ´3&+55ÿÿÿéÿì5‡&½M\R³&+5ÿÿÿ'þð5&\M£³&+5ÿÿÿéÿì5&½jDR ´'&+55ÿÿÿ'þðÁ&\jÿr ´*&+55ÿÿÿéÿì5s&½ShR ´(&+55ÿÿÿ'þù!&\S© ´+&+55ÿÿÍ®&Áj=R ´(&+55ÿÿœþÁ&áj ´,&+55fþœ`¶ @"IYIY?+?+?103!!3#f6Äý¤þñ¨biP¶^ûþ>dHþ“#? @"HY FY?+?+?10%##!!mgdT®ãøþmÃTþ?m?Qüfÿÿf&ÅjR ´*&+55ÿÿÿì!Á&åj… ´4&+55Hþ°`¶7@JYIYIY IY "?+?+?+9/3+310!!!3#"'53277##73`ý¤Oþ²}Ž8QI0 !T¨’’”¶^ý¦Rý²þüWSXg¬R¸þ°#?7@ HY HY FYGY"?+?+?+9/3+3103#73!!!!3#"'53277Hj›šhøþmVþíZ…5RH0 !TPíQþdPþRúWSXgÿyþ°}¶'@IY IY"?+?+??39910%3#"'53277##33J‘7QH1" Swþýò`þðjðãwýÕ^þüWSXg¦ýZþ¸ýŽrý1ÿ¸þ°º;'@ FYGY"?+?+??39910#333#"'53277#ºþwy×õdÏuxþ@Ù•5RH0 !Tpßþ!+þ2Îýêþ/úWSXgÿy}¶)@  JY ?3?39/3+39910##!7!33!\kþýò9þòþþjðãwþ-Íý3¦ýZÍR—ýŽrýiRÿ¸º;)@ HY  ?3?39/3+39910#!7!33!!#ºþwy²þòãdÏuxþeþßòbßþ!Réþ2ÎþRþ\o¶ @ IYIY?+?9/+104$!33!"&# !3\ ègþÊþÅÈÚ ¼þÿàIÓhÚåúJ¹§¼þôÿÿfÿìœG\ÿì1¶(1@ IY $ $IY ?3+3?9/+9/910#"&'#"&54$!33327# 326671n É–m—{ç¤ÃègÓ qZÞ2mýŸ¼ÿáŒv\‹ZPýë ¯c[¼Á©ãìü(}$Ugö …¯ÂBwKfÿì-.@(FY  GY ?3+3?+?999/1032673# #! 46323632>54&#"šh\t{ G\I%´˜þô¬þüþçüžæ1 ƒcòýüY³H{k|È€fh…—Zþ’´®"þÞvÁbËÛB]ûŒFþì}ÓûT~—¦þÁ¨þÙçÿìË26@'',IY, JY,#IY,?+?+9/+9/9104&##7326654&#"'63232673#"&&547¡­Û²ƒÔh†|¨¬6¾Ø¥¹¶°€ˆqYslkq#Ä–X…H Á…`Zir|wL¤– Ï*—&??Ug|z ý塨DzJ*{¢ÿìüP+6@$$)GY) FY) GY)?+?+9/+9/910%74&##732654&#"'663232673#"&7bs‡Z’¡hX=qJ)SŒV‚„y¶´pw!H\J&©™‚‘åw[U\woN^".P2$‚tq”³xªZþ’¸ª|çþœìË&0@IY$"" JY$IY$?+?+?9/+9104&##7326654&#"'6323##6½¸¶²ƒÔh†|¨¬6¾Ø¥¹¶°„ˆ$¨chP¦@®‘ˆ`Zir|wL¤– Ï*£…6r®þ>d%h¢þ“/P&0@! GY "FYFY?+?+?9/+910%3##7654&##732654&#"'6632}²feT²/ŽTZ’¡hX=qJ)SŒV‚„y¾ Tþ?mÝA$k_\woN^".P2$‚tq”(Á@ÿ¬ÿ鞶&'@#IY #IY#?+?3+39/10%32673#"&547!#"'53266!òm[slkq#Ä–‡žÂþg(„ªre60-9Nmc·š`ÕþQ_|z ý塨’tBŠš‰þ<þÉ]`XÇ7ü€ÿÿìsH,'@((FY(  GY ?3+3?+9/10%32673#"&547&#"#"'532667>32µpw!H\J&©™†}&$\xfIVn„`#J`]KSz¢zQ[‰þ¸Zþ’¸ªŠ|GkJO¸ÙÿÆYZLºÛúÄYýq{fÿì¶,@IYIY?+??39/+9/10!#3!332673#"&546Zý•g6f‹ø‰dÕm[slkq#Ä–‡žÏý1¶ýw‰ü€IQ_|z ý塨’t/aJÿì)?,@GYGY?+??39/+9/10!#3!332673#"&547ýodé`dqheŽ´pw!H\J&©™†ýü?þ!ßýi`J¸Zþ’¸ª‰}Gkªÿì=Ë&@IY IY IY?+?+9/+10!!"$32&&#"32667!TÏ0þÕþùôþðÒeÙq´^&nŸX¸þʲÜÄ—Êvþ—ÉwþÂþØ-  µê&(^. ×þ|ïáúsÜÑbÿìT0@FY  FY FY?+?+9/_^]+10!#"&54$32'&#"3267!fµ3úÏÏß•«P™k)Ax|ˆÙ|¬¢Ÿ¾(þ¶Eþÿâïݽ2­*:T#?“þힵóÉÁÿ쨶%@ IY IY ?+?+39/10%32673#"&547!7!!ün[rlkq#Ä–‡ ÃþPÍþHÀþR^|z ý塨”rBŠš^^üo{Tÿìç?%@HY GY?+?+39/10!7!!32673#"&547¶þžþ¹}´qx G\I&«˜†ŽîQQý¸dD¸‚šZþ’¹©Š|Hj“ÿìhË'-@&IY JYIY?+?+9/+9104632&#"33#"3267#"&54675&PöÄd§S5„«“¹¨’²ÈÞåž•\¢uu´VÁ×Ú¼Ù+¹ç1>Vo·“}‹`¸¯‚’$4c/"¬³â Eÿÿ;ÿìmP‚ÿ¬þ°ú¶!)@IY IY IY IY"?+??++?+10#"'53266!3#"'53277#Ï(„ªre60-9Nmc·šyþÝ7QH1" S¤!X‰þ<þÉ]`XÇ7ú¨þüWSXgXÿšþ°¼H()@&FY&FYGY GY"?+??++?+10%3#"'53277#&#"#"'532667>32ç†6QI0 !T™×&$\xhGVn„`%J`]KT|¢wQ[TúWSXgîO½ÔÿÆYZLºÛùÇWÿÿÿ‘þÇÓ¼&$g›ÿÿfþÇ7P&Dg‘ÿÿÿ‘Ó&$fþR³&+5ÿÿfÿì7&Dfɳ&&+5ÿÿÿ‘ôÑ&$wÙR ´&+55ÿÿfÿìâ&DwÇ ´0&+55ÿÿÿ‘éÏ&$xÙR ´'&+55ÿÿfÿì7}&DxÇ ´:&+55ÿÿÿ‘¾%&$yÙR ´&+55ÿÿfÿì¬Ó&DyÇ ´0&+55ÿÿÿ‘¦i&$zÙR ´&+55ÿÿfÿì”&DzÇ ´0&+55ÿÿÿ‘þÇés&$'K+Rg³&+5ÿÿfþÇ7#&D&Kýg—³)&+5ÿÿÿ‘&${ãR ´&+55ÿÿfÿì7Á&D{Ë ´%&+55ÿÿÿ‘&$|ãR ´&+55ÿÿfÿì7Á&D|Ë ´%&+55ÿÿÿ‘V&$}ãR ´&+55ÿÿfÿì7&D}Ë ´%&+55ÿÿÿ‘i&$~ãR ´&+55ÿÿfÿìi&D~Ë ´%&+55ÿÿÿ‘þÇ#&$'N3Rg³&+5ÿÿfþÇ7É&D&Ng‰³%&+5ÿÿfþÇs¶&(g«ÿÿfþÇ}P&Hg‚ÿÿfsÓ&(fðR³&+5ÿÿfÿì‹&Hfƒ³%&+5ÿÿfs&(RXR³&+5ÿÿfÿìàÅ&HRÚ³+&+5ÿÿfÑ&(wìR ´&+55ÿÿfÿì¢&Hw‡ ´/&+55ÿÿfsÏ&(xðR ´$&+55ÿÿfÿì—}&Hx‡ ´9&+55ÿÿfÑ%&(yìR ´&+55ÿÿfÿìlÓ&Hy‡ ´/&+55ÿÿf½i&(zðR ´&+55ÿÿfÿìT&Hz‡ ´/&+55ÿÿfþÇss&('KFRg«³&+5ÿÿfþÇŽ!&H&KÐg³(&+5ÿÿÿÛÓ&,f R³&+5ÿÿL—&óf³&+5ÿÿÿÛþDz¶&,gwÿÿþÇéÏ&Lg<ÿÿ¬þÇ{Ë&2g|ÿÿbþÇT&Rg­ÿÿ¬ÿì{Ó&2fªR³ &+5ÿÿbÿì&Rf¦³&+5ÿÿ¬ÿì”Ñ&2wyR ´*&+55ÿÿbÿì®&Rw“ ´)&+55ÿÿ¬ÿì{Ï&2xuR ´4&+55ÿÿbÿì}&Rx“ ´3&+55ÿÿ¬ÿì{%&2yuR ´*&+55ÿÿbÿìxÓ&Ry“ ´)&+55ÿÿ¬ÿì{i&2zuR ´*&+55ÿÿbÿì`&Rz“ ´)&+55ÿÿ¬þÇ{s&2'KÍRgx³#&+5ÿÿbþÇ!&R&Kïg­³"&+5ÿÿ¬ÿìs&_vçR³.&+5ÿÿbÿìö!&`v³+&+5ÿÿ¬ÿìs&_CÏR³&&+5ÿÿbÿìö!&`Cï³$&+5ÿÿ¬ÿìÓ&_fªR³(&+5ÿÿbÿìö&`f¦³&&+5ÿÿ¬ÿì&_RåR³/&+5ÿÿbÿìöÅ&`R³#&+5ÿÿ¬þÇ&_gxÿÿbþÇöã&`gÿÿ°þÇs¶&8g$ÿÿmþÇ+?&Xg‘ÿÿ°ÿìsÓ&8fmR³&+5ÿÿmÿð+&Xfó&+5ÿÿ°ÿì®s&avçR³&&+5ÿÿmÿðw!&bv³*&+5ÿÿ°ÿì®s&aCÏR³&+5ÿÿmÿðw!&bC³"&+5ÿÿ°ÿì®Ó&afƒR³ &+5ÿÿmÿðw&bfͳ%&+5ÿÿ°ÿì®&aRÝR³'&+5ÿÿmÿðwÅ&bR³"&+5ÿÿ°þÇ®&ag$ÿÿmþÇwå&bg—ÿÿÁþǃ¶&<g2ÿÿÿ'þð?&\gtÿÿÁƒÓ&<fªR³ &+5ÿÿÿ'þð&\f/³&+5ÿÿÁƒ&<R R³&+5ÿÿÿ'þðÅ&\R—³"&+5ÿÿÿôþÝ&ÓBªûÓÙþ?!´€ /3Í210#&&'53#&&'53üôJ/Š}1sKI/Š}/tÙ/È<‰¦/È<„«ýÙ@@ H€ H € /3Í2Ü++Ì106673#&'#%6673#ý?©1M_9$cZ‰%Û2m76Bò'—9+>7ih8ß%w+9mümÙÿ} !@ @ H€ H€/3Ü++ÍÍ210&&'536673#&'#ý97{rU$u?©1M_9$cZ‰%š"t.;o¨'—9+>7ih8ýÙÿåÓ3@@ H@ H € /3Í2Ì_]+299//+3106673#&'##7654#"5632ý?©1M_9$cZ‰%ã¬?œW1--›ò'—9+>7ih8l!)X L8 :ýÙÿÍ(%@%"¯@ H € /3Í2Ô+]Æ3Ý2Æ106673#&'#"&'&&#"#663232673ý?©1M_9$cZ‰%þ*K)#>(.=LkU2M;2-;Neò'—9+>7ih8k"!4Cel$':Aneý!ßÿ7Á@ @ H € /3Ì2Ü+Ì10#"&55733267'6673#ÝŽzitEHVUgá*o#.>AÉwse\DF=M1 t32q"ý!ßÿ#Á@ @ H€ /3Í2Ü+Í10#"&55733267'&&'53ÝŽzitEHVUgº>wsZ)Éwse\DF=M&t++{#ý!ßÿ# 0³¸ÿð@ H@ H@ H € /3Ì2Ü+Ì+2+9/310#"&557332677#7654#"5632ÝŽzitEHVUg`UC¤["2? ¤Éwse\DF=MÊ8N+^ Q: < üÝßÿž)!@&#@ H € /3Ì2Ô+22Í2210#"&55733267'"&'&&#"#663232673ÝŽzitEHVUg *L(#>(.=LkU2M;2-;NeÉwse\DF=M{"!4Cel$':Aneÿsþbš ² /Ì210254'3#"'7;v T+mh2 þ¬ dPsKfzE þ°B^ ² /Ì210%#"'53277B8RH0 !T1^þüWSXgíþ°?T ² /Ì210%#"'53277?5RH0 !T/TúWSXgãÿÿˆx¶ÿ&hÿìéd @ MY &MY?+?+10#"&54632%"32654&é‰ì›³¾‰ó“¯ÃþŠuÀq’„{¼iŽÁÌþ§°ÜÐÇJ»Ý‰ŸþÚ«¶«£'³¢²/Z µ ??Í310!#67'3/h—4(YÅ3–ZÁßG#?{NÿÏZd@ LY&LY?+?+910!!7>54&#"'6632!ÝüòËŠz8th¢Ÿ;T¹q™­I„‰þkjHcyuEXh‹NHQ”~V•‰_þçÿ‚þ‡df(-@LY && KY&& KY %?+?+9/+910#"&'532654&##732654&#"'6632dÔ´u‰€çŸ`±A¬¬ÅÕ²žunÑø}§±1TÐr¡·1¢â·‡†Æb) eV³£‘œ`¿£rzƒKCK¥ÿ¸þ åZ !@KY $??9/3+3310%!#!73!!7#ÑþøP`OýPnwÕþ–h;(8LýyþŽraçüê “RVý ÿèþ‡ÃQ/@MYLY KY%?+?+9/+33102!"&'532654&#"'!!6Ö¼ÑþØþýT»AªªÐñªŒ…nBÁpýã•b ̱íþç(kZåÇŒŸ)1“`ýüÿÿlÿìÉÂÿõþ™„O@ $LY?+3?10!7! ýZüõþ™V`nú¸ÿÿWÿì7Íõÿÿþƒ¯`&-@ LYKY& MY%?+?+9/+910#"'53 ##"&546632%"32>54&¯Ëþ¼çrHWiÚ™Œã¢ºwÞ’®»þ‹p«Z‡}S•m,ŽŸþàýøôZ¢ÀÒ³›üŒçuÐ~‘ Anvu¦´ÿþ²;8@3GY.#FY*8 HY' ?33+33?3+3?3+310"'53267#?6632&#"!76632&#"3##"'53267!ƒ065/X\öÍÍ##£’I]W<`s#Ý##£’I]W=as#øøü"z065/X\ôþ#ü!ŽþZj…ŽC ¨˜Pk}¤ ¨˜Pm{¤QûZ¥Zj…ŽûZ¡“)Ý+Á$5#@3'-%1*+.+?3?3Ä2Í2223310#"'532654&'.54632&&#"##33#7#ðzoQ]a[\?mQJ_Yk!d)EG7_`L!¶ÝR}Ýß}Vã¨]nR#C859+!3?:OhL ;2.6#&6HöaÉþhÑý¢^ý/ŽÏý£ÿÿyþ¢¶&7z'ÿÿ7þ¶?&WzåFþ7P-.@ 'FYGYFY?+?+?+?9910"&'53267##"&5463237326654&#"fHœ<>£H›µ*FHå{‰Ž•öžä1;Pñ1ë”U³‘H{k|È€eþ'g'0¤¿Eˆž¿·Äk¿ÛÊû†ãÎ2xÕO–£þÀª˜ÿÿFþ7!&‘K³5&+5ÿÿFþ7É&‘Nû³1&+5ÿÿFþ7Ï&‘O7³6&+5ÿÿFþ7!&‘:j³2&+5fþ¶ ³??1033f6bþ˶úJÿÿf s&–CÿR³&+5ÿÿfDs&–vÿ_R³ &+5ÿÿfâs&–Kÿ$R³ &+5ÿÿfß&–jÿR ´&+55ÿÿfF&–Rÿ@R³&+5ÿÿfä‡&–Mÿ6R³&+5ÿÿf&–NÿR³&+5ÿÿÿ¨þbþ¶&–Q/ÿÿfB!&–OqR³ &+5ÿÿfþ˜ì¶&–-øÿÿmš'–œTýâÿ—²?5ÿÿfþ¶–ÿÿfß&–jÿR ´&+55ÿÿfþ¶–ÿÿfß&–jÿR ´&+55ÿÿfþ¶–ÿÿfþ¶–ÿÿfñÓ&–féR³&+5ÿÿ0þÇþ¶&–gZ¶2I€6$$ÿq7)9):)<Dÿ®Fÿ…Gÿ…Hÿ…JÿÃPÿÃQÿÃRÿ…SÿÃTÿ…UÿÃVÿÃXÿÂÿqƒÿq„ÿq…ÿq†ÿq‡ÿqŸ¢ÿ…£ÿ®¤ÿ®¥ÿ®¦ÿ®§ÿ®¨ÿ®©ÿ…ªÿ…«ÿ…¬ÿ…­ÿ…´ÿ…µÿ…¶ÿ…·ÿ…¸ÿ…ºÿ…»ÿüÿýÿþÿÃÂÿqÃÿ®ÄÿqÅÿ®ÆÿqÇÿ®Éÿ…Ëÿ…Íÿ…Ïÿ…Ñÿ…Óÿ…Õÿ…×ÿ…Ùÿ…Ûÿ…Ýÿ…ßÿÃáÿÃãÿÃåÿÃúÿÃÿÃÿà ÿÃÿ…ÿ…ÿ…ÿ…ÿÃÿÃÿÃ!ÿÃ$)&)+ÿÃ-ÿÃ/ÿÃ1ÿÃ3ÿÃ5ÿÃ6)8:CÿqDÿ®Fÿ®Hÿ…JÿÃVÿq_ÿqbÿqiÿqyÿ®zÿ×{ÿ×~ÿ®ÿÂÿ׃ÿׄÿׇÿ׉ÿ׌ÿ®ŽÿÃÿ®ÿ®“ÿ®™ÿ®¤ÿ…ªÿq®ÿ…µÿ…Êÿ×ÎÿqÏÿ…ÕÿqØÿ…Ûÿ…Þÿ…êÿ…íÿ…îÿÃòÿqú)ü)þ)WÿÃXÿqYÿ®`ÿ…bÿÃjÿ…rÿqsÿq}ÿìÿ……ÿ…‡ÿ…‰ÿ…ÿ…²ÿ…´ÿ…Îÿ…ÏÿqÙÿqÚÿ×ÛÿqÜÿ×ÝÿqÞÿ×àÿ…âÿ×äÿ×ðÿ…òÿ…ôÿ… ÿq ÿ… ÿq ÿ…ÿ…ÿqÿ…ÿ…ÿ…ÿqÿqÿ®ÿq ÿ®!ÿq"ÿ®#ÿq%ÿq&ÿ®'ÿq(ÿ®)ÿq*ÿ®+ÿq,ÿ®-ÿq.ÿ®/ÿq0ÿ®1ÿq2ÿ®3ÿq4ÿ®6ÿ…8ÿ…:ÿ…<ÿ…@ÿ…Bÿ…Dÿ…Jÿ…Lÿ…Nÿ…Rÿ…Tÿ…Vÿ…Xÿ…Zÿ…\ÿ…^ÿ…`ÿ…bÿÃdÿÃfÿÃhÿÃjÿÃlÿÃnÿÃoqs) $ÿq 7) 9) :) < Dÿ® Fÿ… Gÿ… Hÿ… Jÿà Pÿà Qÿà Rÿ… Sÿà Tÿ… Uÿà Vÿà Xÿà ‚ÿq ƒÿq „ÿq …ÿq †ÿq ‡ÿq Ÿ ¢ÿ… £ÿ® ¤ÿ® ¥ÿ® ¦ÿ® §ÿ® ¨ÿ® ©ÿ… ªÿ… «ÿ… ¬ÿ… ­ÿ… ´ÿ… µÿ… ¶ÿ… ·ÿ… ¸ÿ… ºÿ… »ÿà ¼ÿà ½ÿà ¾ÿà Âÿq Ãÿ® Äÿq Åÿ® Æÿq Çÿ® Éÿ… Ëÿ… Íÿ… Ïÿ… Ñÿ… Óÿ… Õÿ… ×ÿ… Ùÿ… Ûÿ… Ýÿ… ßÿà áÿà ãÿà åÿà úÿà ÿà ÿà  ÿà ÿ… ÿ… ÿ… ÿ… ÿà ÿà ÿà !ÿà $) &) +ÿà -ÿà /ÿà 1ÿà 3ÿà 5ÿà 6) 8 : Cÿq Dÿ® Fÿ® Hÿ… Jÿà Vÿq _ÿq bÿq iÿq yÿ® zÿ× {ÿ× ~ÿ® ÿà ‚ÿ× ƒÿ× „ÿ× ‡ÿ× ‰ÿ× Œÿ® Žÿà ÿ® ÿ® “ÿ® ™ÿ® ¤ÿ… ªÿq ®ÿ… µÿ… Êÿ× Îÿq Ïÿ… Õÿq Øÿ… Ûÿ… Þÿ… êÿ… íÿ… îÿà òÿq ú) ü) þ)  Wÿà Xÿq Yÿ® `ÿ… bÿà jÿ… rÿq sÿq }ÿì ÿ… …ÿ… ‡ÿ… ‰ÿ… ÿ… ²ÿ… ´ÿ… Îÿ… Ïÿq Ùÿq Úÿ× Ûÿq Üÿ× Ýÿq Þÿ× àÿ… âÿ× äÿ× ðÿ… òÿ… ôÿ…  ÿq  ÿ…  ÿq  ÿ… ÿ… ÿq ÿ… ÿ… ÿ… ÿq ÿq ÿ® ÿq  ÿ® !ÿq "ÿ® #ÿq %ÿq &ÿ® 'ÿq (ÿ® )ÿq *ÿ® +ÿq ,ÿ® -ÿq .ÿ® /ÿq 0ÿ® 1ÿq 2ÿ® 3ÿq 4ÿ® 6ÿ… 8ÿ… :ÿ… <ÿ… @ÿ… Bÿ… Dÿ… Jÿ… Lÿ… Nÿ… Rÿ… Tÿ… Vÿ… Xÿ… Zÿ… \ÿ… ^ÿ… `ÿ… bÿà dÿà fÿà hÿà jÿà lÿà nÿà o q s ) -¸&ÿš*ÿš2ÿš4ÿš7ÿq8ÿ×9ÿ…:ÿ…<ÿ…‰ÿš”ÿš•ÿš–ÿš—ÿš˜ÿššÿš›ÿלÿ×ÿמÿןÿ…ÈÿšÊÿšÌÿšÎÿšÞÿšàÿšâÿšäÿšÿšÿšÿšÿš$ÿq&ÿq*ÿ×,ÿ×.ÿ×0ÿ×2ÿ×4ÿ×6ÿ…8ÿ…:ÿ…Gÿšfÿ®mÿ®qÿqrÿ…sÿšuÿ…xÿ……ÿ×ÿqŸÿš¦ÿq¸ÿš»ÿš¼ÿq¾ÿ®Áÿ\ÄÿqÜÿšáÿ…äÿšúÿ…üÿ…þÿ…ÿ…Tÿ…_ÿšaÿ×lÿš|ÿ\~ÿš€ÿ…‚ÿ…„ÿš†ÿšˆÿšŠÿšŒÿš©ÿqªÿš±ÿš³ÿšµÿq¶ÿš·ÿ…¹ÿ…½ÿq¾ÿš¿ÿ\Àÿ…Áÿ\Âÿ…Åÿ…Çÿ…Ôÿ\Õÿ…ïÿšñÿšóÿšýÿ\þÿ… ÿ…ÿšÿ…ÿšÿšÿqÿšIÿšKÿšMÿšOÿšQÿšSÿšUÿšWÿšYÿš[ÿš]ÿš_ÿšaÿ×cÿ×eÿ×gÿ×iÿ×kÿ×mÿ×oÿ…qÿ…sÿ…ÿq7ÿ®$ÿ®&ÿ®qÿ®ÿ®¦ÿ®¼ÿ®Äÿ®Üÿ×äÿשÿ®ªÿ×µÿ®¶ÿ×½ÿ®¾ÿ×ÿ®ÿ×ÿ®&ÿš*ÿš2ÿš4ÿš7ÿq8ÿ×9ÿ…:ÿ…<ÿ…‰ÿš”ÿš•ÿš–ÿš—ÿš˜ÿššÿš›ÿלÿ×ÿמÿןÿ…ÈÿšÊÿšÌÿšÎÿšÞÿšàÿšâÿšäÿšÿšÿšÿšÿš$ÿq&ÿq*ÿ×,ÿ×.ÿ×0ÿ×2ÿ×4ÿ×6ÿ…8ÿ…:ÿ…Gÿšfÿ®mÿ®qÿqrÿ…sÿšuÿ…xÿ……ÿ×ÿqŸÿš¦ÿq¸ÿš»ÿš¼ÿq¾ÿ®Áÿ\ÄÿqÜÿšáÿ…äÿšúÿ…üÿ…þÿ…ÿ…Tÿ…_ÿšaÿ×lÿš|ÿ\~ÿš€ÿ…‚ÿ…„ÿš†ÿšˆÿšŠÿšŒÿš©ÿqªÿš±ÿš³ÿšµÿq¶ÿš·ÿ…¹ÿ…½ÿq¾ÿš¿ÿ\Àÿ…Áÿ\Âÿ…Åÿ…Çÿ…Ôÿ\Õÿ…ïÿšñÿšóÿšýÿ\þÿ… ÿ…ÿšÿ…ÿšÿšÿqÿšIÿšKÿšMÿšOÿšQÿšSÿšUÿšWÿšYÿš[ÿš]ÿš_ÿšaÿ×cÿ×eÿ×gÿ×iÿ×kÿ×mÿ×oÿ…qÿ…sÿ…ÿq$ÿq$ ÿq$&ÿ×$*ÿ×$- $2ÿ×$4ÿ×$7ÿq$9ÿ®$:ÿ®$<ÿ…$‰ÿ×$”ÿ×$•ÿ×$–ÿ×$—ÿ×$˜ÿ×$šÿ×$Ÿÿ…$Èÿ×$Êÿ×$Ìÿ×$Îÿ×$Þÿ×$àÿ×$âÿ×$äÿ×$ÿ×$ÿ×$ÿ×$ÿ×$$ÿq$&ÿq$6ÿ®$8ÿ…$:ÿ…$Gÿ×$úÿ®$üÿ®$þÿ®$ÿ…$ÿq$ ÿq$_ÿ×$Iÿ×$Kÿ×$Mÿ×$Oÿ×$Qÿ×$Sÿ×$Uÿ×$Wÿ×$Yÿ×$[ÿ×$]ÿ×$_ÿ×$oÿ…$qÿ…$sÿ…$ÿq%ÿ®%ÿ®%$ÿ×%7ÿÃ%9ÿì%:ÿì%;ÿ×%<ÿì%=ÿì%‚ÿ×%ƒÿ×%„ÿ×%…ÿ×%†ÿ×%‡ÿ×%Ÿÿì%Âÿ×%Äÿ×%Æÿ×%$ÿÃ%&ÿÃ%6ÿì%8ÿì%:ÿì%;ÿì%=ÿì%?ÿì%Cÿ×% ÿì%úÿì%üÿì%þÿì%ÿì%ÿ®% ÿ®%Xÿ×%ÿ×%ÿ×%!ÿ×%#ÿ×%%ÿ×%'ÿ×%)ÿ×%+ÿ×%-ÿ×%/ÿ×%1ÿ×%3ÿ×%oÿì%qÿì%sÿì%ÿÃ&&ÿ×&*ÿ×&2ÿ×&4ÿ×&‰ÿ×&”ÿ×&•ÿ×&–ÿ×&—ÿ×&˜ÿ×&šÿ×&Èÿ×&Êÿ×&Ìÿ×&Îÿ×&Þÿ×&àÿ×&âÿ×&äÿ×&ÿ×&ÿ×&ÿ×&ÿ×&Gÿ×&_ÿ×&Iÿ×&Kÿ×&Mÿ×&Oÿ×&Qÿ×&Sÿ×&Uÿ×&Wÿ×&Yÿ×&[ÿ×&]ÿ×&_ÿ×'ÿ®'ÿ®'$ÿ×'7ÿÃ'9ÿì':ÿì';ÿ×'<ÿì'=ÿì'‚ÿ×'ƒÿ×'„ÿ×'…ÿ×'†ÿ×'‡ÿ×'Ÿÿì'Âÿ×'Äÿ×'Æÿ×'$ÿÃ'&ÿÃ'6ÿì'8ÿì':ÿì';ÿì'=ÿì'?ÿì'Cÿ×' ÿì'úÿì'üÿì'þÿì'ÿì'ÿ®' ÿ®'Xÿ×'ÿ×'ÿ×'!ÿ×'#ÿ×'%ÿ×''ÿ×')ÿ×'+ÿ×'-ÿ×'/ÿ×'1ÿ×'3ÿ×'oÿì'qÿì'sÿì'ÿÃ(-{)ÿ…)ÿ…)"))$ÿ×)‚ÿ×)ƒÿ×)„ÿ×)…ÿ×)†ÿ×)‡ÿ×)Âÿ×)Äÿ×)Æÿ×)Cÿ×)ÿ…) ÿ…)Xÿ×)ÿ×)ÿ×)!ÿ×)#ÿ×)%ÿ×)'ÿ×))ÿ×)+ÿ×)-ÿ×)/ÿ×)1ÿ×)3ÿ×.&ÿ×.*ÿ×.2ÿ×.4ÿ×.‰ÿ×.”ÿ×.•ÿ×.–ÿ×.—ÿ×.˜ÿ×.šÿ×.Èÿ×.Êÿ×.Ìÿ×.Îÿ×.Þÿ×.àÿ×.âÿ×.äÿ×.ÿ×.ÿ×.ÿ×.ÿ×.Gÿ×._ÿ×.Iÿ×.Kÿ×.Mÿ×.Oÿ×.Qÿ×.Sÿ×.Uÿ×.Wÿ×.Yÿ×.[ÿ×.]ÿ×._ÿ×/ÿ\/ ÿ\/&ÿ×/*ÿ×/2ÿ×/4ÿ×/7ÿ×/8ÿì/9ÿ×/:ÿ×/<ÿÃ/‰ÿ×/”ÿ×/•ÿ×/–ÿ×/—ÿ×/˜ÿ×/šÿ×/›ÿì/œÿì/ÿì/žÿì/ŸÿÃ/Èÿ×/Êÿ×/Ìÿ×/Îÿ×/Þÿ×/àÿ×/âÿ×/äÿ×/ÿ×/ÿ×/ÿ×/ÿ×/$ÿ×/&ÿ×/*ÿì/,ÿì/.ÿì/0ÿì/2ÿì/4ÿì/6ÿ×/8ÿÃ/:ÿÃ/Gÿ×/úÿ×/üÿ×/þÿ×/ÿÃ/ÿ\/ ÿ\/_ÿ×/aÿì/Iÿ×/Kÿ×/Mÿ×/Oÿ×/Qÿ×/Sÿ×/Uÿ×/Wÿ×/Yÿ×/[ÿ×/]ÿ×/_ÿ×/aÿì/cÿì/eÿì/gÿì/iÿì/kÿì/mÿì/oÿÃ/qÿÃ/sÿÃ/ÿ×2ÿ®2ÿ®2$ÿ×27ÿÃ29ÿì2:ÿì2;ÿ×2<ÿì2=ÿì2‚ÿ×2ƒÿ×2„ÿ×2…ÿ×2†ÿ×2‡ÿ×2Ÿÿì2Âÿ×2Äÿ×2Æÿ×2$ÿÃ2&ÿÃ26ÿì28ÿì2:ÿì2;ÿì2=ÿì2?ÿì2Cÿ×2 ÿì2úÿì2üÿì2þÿì2ÿì2ÿ®2 ÿ®2Xÿ×2ÿ×2ÿ×2!ÿ×2#ÿ×2%ÿ×2'ÿ×2)ÿ×2+ÿ×2-ÿ×2/ÿ×21ÿ×23ÿ×2oÿì2qÿì2sÿì2ÿÃ3þö3þö3$ÿš3;ÿ×3=ÿì3‚ÿš3ƒÿš3„ÿš3…ÿš3†ÿš3‡ÿš3Âÿš3Äÿš3Æÿš3;ÿì3=ÿì3?ÿì3Cÿš3þö3 þö3Xÿš3ÿš3ÿš3!ÿš3#ÿš3%ÿš3'ÿš3)ÿš3+ÿš3-ÿš3/ÿš31ÿš33ÿš4ÿ®4ÿ®4$ÿ×47ÿÃ49ÿì4:ÿì4;ÿ×4<ÿì4=ÿì4‚ÿ×4ƒÿ×4„ÿ×4…ÿ×4†ÿ×4‡ÿ×4Ÿÿì4Âÿ×4Äÿ×4Æÿ×4$ÿÃ4&ÿÃ46ÿì48ÿì4:ÿì4;ÿì4=ÿì4?ÿì4Cÿ×4 ÿì4úÿì4üÿì4þÿì4ÿì4ÿ®4 ÿ®4Xÿ×4ÿ×4ÿ×4!ÿ×4#ÿ×4%ÿ×4'ÿ×4)ÿ×4+ÿ×4-ÿ×4/ÿ×41ÿ×43ÿ×4oÿì4qÿì4sÿì4ÿÃ7ÿ…7ÿ®7ÿ…7")7$ÿq7&ÿ×7*ÿ×72ÿ×74ÿ×77)7Dÿ\7Fÿq7Gÿq7Hÿq7Jÿq7Pÿš7Qÿš7Rÿq7Sÿš7Tÿq7Uÿš7Vÿ…7Xÿš7Yÿ×7Zÿ×7[ÿ×7\ÿ×7]ÿ®7‚ÿq7ƒÿq7„ÿq7…ÿq7†ÿq7‡ÿq7‰ÿ×7”ÿ×7•ÿ×7–ÿ×7—ÿ×7˜ÿ×7šÿ×7¢ÿq7£ÿ\7¤ÿ\7¥ÿ\7¦ÿ\7§ÿ\7¨ÿ\7©ÿq7ªÿq7«ÿq7¬ÿq7­ÿq7´ÿq7µÿq7¶ÿq7·ÿq7¸ÿq7ºÿq7»ÿš7¼ÿš7½ÿš7¾ÿš7¿ÿ×7Âÿq7Ãÿ\7Äÿq7Åÿ\7Æÿq7Çÿ\7Èÿ×7Éÿq7Êÿ×7Ëÿq7Ìÿ×7Íÿq7Îÿ×7Ïÿq7Ñÿq7Óÿq7Õÿq7×ÿq7Ùÿq7Ûÿq7Ýÿq7Þÿ×7ßÿq7àÿ×7áÿq7âÿ×7ãÿq7äÿ×7åÿq7úÿš7ÿš7ÿš7 ÿš7ÿ×7ÿq7ÿ×7ÿq7ÿ×7ÿq7ÿ×7ÿq7ÿš7ÿš7ÿ…7!ÿ…7$)7&)7+ÿš7-ÿš7/ÿš71ÿš73ÿš75ÿš77ÿ×7<ÿ®7>ÿ®7@ÿ®7Cÿq7Dÿ\7Fÿ\7Gÿ×7Hÿq7Jÿ…7ûÿ×7ýÿ×7ÿ®7ÿ®7ÿ®7ÿ…7 ÿ…7Wÿš7Xÿq7Yÿ\7_ÿ×7`ÿq7bÿš7ÿq7ÿ\7ÿq7 ÿ\7!ÿq7"ÿ\7#ÿq7%ÿq7&ÿ\7'ÿq7(ÿ\7)ÿq7*ÿ\7+ÿq7,ÿ\7-ÿq7.ÿ\7/ÿq70ÿ\71ÿq72ÿ\73ÿq74ÿ\76ÿq78ÿq7:ÿq7<ÿq7@ÿq7Bÿq7Dÿq7Iÿ×7Jÿq7Kÿ×7Lÿq7Mÿ×7Nÿq7Oÿ×7Qÿ×7Rÿq7Sÿ×7Tÿq7Uÿ×7Vÿq7Wÿ×7Xÿq7Yÿ×7Zÿq7[ÿ×7\ÿq7]ÿ×7^ÿq7_ÿ×7`ÿq7bÿš7dÿš7fÿš7hÿš7jÿš7lÿš7nÿš7pÿ×7)8ÿ×8ÿ×8$ÿì8‚ÿì8ƒÿì8„ÿì8…ÿì8†ÿì8‡ÿì8Âÿì8Äÿì8Æÿì8Cÿì8ÿ×8 ÿ×8Xÿì8ÿì8ÿì8!ÿì8#ÿì8%ÿì8'ÿì8)ÿì8+ÿì8-ÿì8/ÿì81ÿì83ÿì9ÿš9ÿš9")9$ÿ®9&ÿì9*ÿì92ÿì94ÿì9Dÿ×9Fÿ×9Gÿ×9Hÿ×9Jÿì9Pÿì9Qÿì9Rÿ×9Sÿì9Tÿ×9Uÿì9Vÿì9Xÿì9‚ÿ®9ƒÿ®9„ÿ®9…ÿ®9†ÿ®9‡ÿ®9‰ÿì9”ÿì9•ÿì9–ÿì9—ÿì9˜ÿì9šÿì9¢ÿ×9£ÿ×9¤ÿ×9¥ÿ×9¦ÿ×9§ÿ×9¨ÿ×9©ÿ×9ªÿ×9«ÿ×9¬ÿ×9­ÿ×9´ÿ×9µÿ×9¶ÿ×9·ÿ×9¸ÿ×9ºÿ×9»ÿì9¼ÿì9½ÿì9¾ÿì9Âÿ®9Ãÿ×9Äÿ®9Åÿ×9Æÿ®9Çÿ×9Èÿì9Éÿ×9Êÿì9Ëÿ×9Ìÿì9Íÿ×9Îÿì9Ïÿ×9Ñÿ×9Óÿ×9Õÿ×9×ÿ×9Ùÿ×9Ûÿ×9Ýÿ×9Þÿì9ßÿì9àÿì9áÿì9âÿì9ãÿì9äÿì9åÿì9úÿì9ÿì9ÿì9 ÿì9ÿì9ÿ×9ÿì9ÿ×9ÿì9ÿ×9ÿì9ÿ×9ÿì9ÿì9ÿì9!ÿì9+ÿì9-ÿì9/ÿì91ÿì93ÿì95ÿì9Cÿ®9Dÿ×9Fÿ×9Gÿì9Hÿ×9Jÿì9ÿš9 ÿš9Wÿì9Xÿ®9Yÿ×9_ÿì9`ÿ×9bÿì9ÿ®9ÿ×9ÿ®9 ÿ×9!ÿ®9"ÿ×9#ÿ®9%ÿ®9&ÿ×9'ÿ®9(ÿ×9)ÿ®9*ÿ×9+ÿ®9,ÿ×9-ÿ®9.ÿ×9/ÿ®90ÿ×91ÿ®92ÿ×93ÿ®94ÿ×96ÿ×98ÿ×9:ÿ×9<ÿ×9@ÿ×9Bÿ×9Dÿ×9Iÿì9Jÿ×9Kÿì9Lÿ×9Mÿì9Nÿ×9Oÿì9Qÿì9Rÿ×9Sÿì9Tÿ×9Uÿì9Vÿ×9Wÿì9Xÿ×9Yÿì9Zÿ×9[ÿì9\ÿ×9]ÿì9^ÿ×9_ÿì9`ÿ×9bÿì9dÿì9fÿì9hÿì9jÿì9lÿì9nÿì:ÿš:ÿš:"):$ÿ®:&ÿì:*ÿì:2ÿì:4ÿì:Dÿ×:Fÿ×:Gÿ×:Hÿ×:Jÿì:Pÿì:Qÿì:Rÿ×:Sÿì:Tÿ×:Uÿì:Vÿì:Xÿì:‚ÿ®:ƒÿ®:„ÿ®:…ÿ®:†ÿ®:‡ÿ®:‰ÿì:”ÿì:•ÿì:–ÿì:—ÿì:˜ÿì:šÿì:¢ÿ×:£ÿ×:¤ÿ×:¥ÿ×:¦ÿ×:§ÿ×:¨ÿ×:©ÿ×:ªÿ×:«ÿ×:¬ÿ×:­ÿ×:´ÿ×:µÿ×:¶ÿ×:·ÿ×:¸ÿ×:ºÿ×:»ÿì:¼ÿì:½ÿì:¾ÿì:Âÿ®:Ãÿ×:Äÿ®:Åÿ×:Æÿ®:Çÿ×:Èÿì:Éÿ×:Êÿì:Ëÿ×:Ìÿì:Íÿ×:Îÿì:Ïÿ×:Ñÿ×:Óÿ×:Õÿ×:×ÿ×:Ùÿ×:Ûÿ×:Ýÿ×:Þÿì:ßÿì:àÿì:áÿì:âÿì:ãÿì:äÿì:åÿì:úÿì:ÿì:ÿì: ÿì:ÿì:ÿ×:ÿì:ÿ×:ÿì:ÿ×:ÿì:ÿ×:ÿì:ÿì:ÿì:!ÿì:+ÿì:-ÿì:/ÿì:1ÿì:3ÿì:5ÿì:Cÿ®:Dÿ×:Fÿ×:Gÿì:Hÿ×:Jÿì:ÿš: ÿš:Wÿì:Xÿ®:Yÿ×:_ÿì:`ÿ×:bÿì:ÿ®:ÿ×:ÿ®: ÿ×:!ÿ®:"ÿ×:#ÿ®:%ÿ®:&ÿ×:'ÿ®:(ÿ×:)ÿ®:*ÿ×:+ÿ®:,ÿ×:-ÿ®:.ÿ×:/ÿ®:0ÿ×:1ÿ®:2ÿ×:3ÿ®:4ÿ×:6ÿ×:8ÿ×::ÿ×:<ÿ×:@ÿ×:Bÿ×:Dÿ×:Iÿì:Jÿ×:Kÿì:Lÿ×:Mÿì:Nÿ×:Oÿì:Qÿì:Rÿ×:Sÿì:Tÿ×:Uÿì:Vÿ×:Wÿì:Xÿ×:Yÿì:Zÿ×:[ÿì:\ÿ×:]ÿì:^ÿ×:_ÿì:`ÿ×:bÿì:dÿì:fÿì:hÿì:jÿì:lÿì:nÿì;&ÿ×;*ÿ×;2ÿ×;4ÿ×;‰ÿ×;”ÿ×;•ÿ×;–ÿ×;—ÿ×;˜ÿ×;šÿ×;Èÿ×;Êÿ×;Ìÿ×;Îÿ×;Þÿ×;àÿ×;âÿ×;äÿ×;ÿ×;ÿ×;ÿ×;ÿ×;Gÿ×;_ÿ×;Iÿ×;Kÿ×;Mÿ×;Oÿ×;Qÿ×;Sÿ×;Uÿ×;Wÿ×;Yÿ×;[ÿ×;]ÿ×;_ÿ×<ÿ…<ÿ…<")<$ÿ…<&ÿ×<*ÿ×<2ÿ×<4ÿ×<Dÿš<Fÿš<Gÿš<Hÿš<Jÿ×<PÿÃ<QÿÃ<Rÿš<SÿÃ<Tÿš<UÿÃ<Vÿ®<XÿÃ<]ÿ×<‚ÿ…<ƒÿ…<„ÿ…<…ÿ…<†ÿ…<‡ÿ…<‰ÿ×<”ÿ×<•ÿ×<–ÿ×<—ÿ×<˜ÿ×<šÿ×<¢ÿš<£ÿš<¤ÿš<¥ÿš<¦ÿš<§ÿš<¨ÿš<©ÿš<ªÿš<«ÿš<¬ÿš<­ÿš<´ÿš<µÿš<¶ÿš<·ÿš<¸ÿš<ºÿš<»ÿÃ<¼ÿÃ<½ÿÃ<¾ÿÃ<Âÿ…<Ãÿš<Äÿ…<Åÿš<Æÿ…<Çÿš<Èÿ×<Éÿš<Êÿ×<Ëÿš<Ìÿ×<Íÿš<Îÿ×<Ïÿš<Ñÿš<Óÿš<Õÿš<×ÿš<Ùÿš<Ûÿš<Ýÿš<Þÿ×<ßÿ×<àÿ×<áÿ×<âÿ×<ãÿ×<äÿ×<åÿ×<úÿÃ<ÿÃ<ÿÃ< ÿÃ<ÿ×<ÿš<ÿ×<ÿš<ÿ×<ÿš<ÿ×<ÿš<ÿÃ<ÿÃ<ÿ®<!ÿ®<+ÿÃ<-ÿÃ</ÿÃ<1ÿÃ<3ÿÃ<5ÿÃ<<ÿ×<>ÿ×<@ÿ×<Cÿ…<Dÿš<Fÿš<Gÿ×<Hÿš<Jÿ®<ÿ…< ÿ…<WÿÃ<Xÿ…<Yÿš<_ÿ×<`ÿš<bÿÃ<ÿ…<ÿš<ÿ…< ÿš<!ÿ…<"ÿš<#ÿ…<%ÿ…<&ÿš<'ÿ…<(ÿš<)ÿ…<*ÿš<+ÿ…<,ÿš<-ÿ…<.ÿš</ÿ…<0ÿš<1ÿ…<2ÿš<3ÿ…<4ÿš<6ÿš<8ÿš<:ÿš<<ÿš<@ÿš<Bÿš<Dÿš<Iÿ×<Jÿš<Kÿ×<Lÿš<Mÿ×<Nÿš<Oÿ×<Qÿ×<Rÿš<Sÿ×<Tÿš<Uÿ×<Vÿš<Wÿ×<Xÿš<Yÿ×<Zÿš<[ÿ×<\ÿš<]ÿ×<^ÿš<_ÿ×<`ÿš<bÿÃ<dÿÃ<fÿÃ<hÿÃ<jÿÃ<lÿÃ<nÿÃ=&ÿì=*ÿì=2ÿì=4ÿì=‰ÿì=”ÿì=•ÿì=–ÿì=—ÿì=˜ÿì=šÿì=Èÿì=Êÿì=Ìÿì=Îÿì=Þÿì=àÿì=âÿì=äÿì=ÿì=ÿì=ÿì=ÿì=Gÿì=_ÿì=Iÿì=Kÿì=Mÿì=Oÿì=Qÿì=Sÿì=Uÿì=Wÿì=Yÿì=[ÿì=]ÿì=_ÿì>-¸DÿìD ÿìDÿìD ÿìEÿìE ÿìEYÿ×EZÿ×E[ÿ×E\ÿ×E]ÿìE¿ÿ×E7ÿ×E<ÿìE>ÿìE@ÿìEûÿ×Eýÿ×EÿìE ÿìEpÿ×F)F )F)F )HÿìH ÿìHYÿ×HZÿ×H[ÿ×H\ÿ×H]ÿìH¿ÿ×H7ÿ×H<ÿìH>ÿìH@ÿìHûÿ×Hýÿ×HÿìH ÿìHpÿ×I{I {I{I {KÿìK ÿìKÿìK ÿìNFÿ×NGÿ×NHÿ×NRÿ×NTÿ×N¢ÿ×N©ÿ×Nªÿ×N«ÿ×N¬ÿ×N­ÿ×N´ÿ×Nµÿ×N¶ÿ×N·ÿ×N¸ÿ×Nºÿ×NÉÿ×NËÿ×NÍÿ×NÏÿ×NÑÿ×NÓÿ×NÕÿ×N×ÿ×NÙÿ×NÛÿ×NÝÿ×Nÿ×Nÿ×Nÿ×Nÿ×NHÿ×N`ÿ×N6ÿ×N8ÿ×N:ÿ×N<ÿ×N@ÿ×NBÿ×NDÿ×NJÿ×NLÿ×NNÿ×NRÿ×NTÿ×NVÿ×NXÿ×NZÿ×N\ÿ×N^ÿ×N`ÿ×PÿìP ÿìPÿìP ÿìQÿìQ ÿìQÿìQ ÿìRÿìR ÿìRYÿ×RZÿ×R[ÿ×R\ÿ×R]ÿìR¿ÿ×R7ÿ×R<ÿìR>ÿìR@ÿìRûÿ×Rýÿ×RÿìR ÿìRpÿ×SÿìS ÿìSYÿ×SZÿ×S[ÿ×S\ÿ×S]ÿìS¿ÿ×S7ÿ×S<ÿìS>ÿìS@ÿìSûÿ×Sýÿ×SÿìS ÿìSpÿ×URU RUDÿ×UFÿ×UGÿ×UHÿ×UJÿìURÿ×UTÿ×U¢ÿ×U£ÿ×U¤ÿ×U¥ÿ×U¦ÿ×U§ÿ×U¨ÿ×U©ÿ×Uªÿ×U«ÿ×U¬ÿ×U­ÿ×U´ÿ×Uµÿ×U¶ÿ×U·ÿ×U¸ÿ×Uºÿ×UÃÿ×UÅÿ×UÇÿ×UÉÿ×UËÿ×UÍÿ×UÏÿ×UÑÿ×UÓÿ×UÕÿ×U×ÿ×UÙÿ×UÛÿ×UÝÿ×UßÿìUáÿìUãÿìUåÿìUÿ×Uÿ×Uÿ×Uÿ×UDÿ×UFÿ×UHÿ×URU RUYÿ×U`ÿ×Uÿ×U ÿ×U"ÿ×U&ÿ×U(ÿ×U*ÿ×U,ÿ×U.ÿ×U0ÿ×U2ÿ×U4ÿ×U6ÿ×U8ÿ×U:ÿ×U<ÿ×U@ÿ×UBÿ×UDÿ×UJÿ×ULÿ×UNÿ×URÿ×UTÿ×UVÿ×UXÿ×UZÿ×U\ÿ×U^ÿ×U`ÿ×W)W )W)W )YRY RYÿ®Yÿ®Y")YRYÿ®Y RY ÿ®ZRZ RZÿ®Zÿ®Z")ZRZÿ®Z RZ ÿ®[Fÿ×[Gÿ×[Hÿ×[Rÿ×[Tÿ×[¢ÿ×[©ÿ×[ªÿ×[«ÿ×[¬ÿ×[­ÿ×[´ÿ×[µÿ×[¶ÿ×[·ÿ×[¸ÿ×[ºÿ×[Éÿ×[Ëÿ×[Íÿ×[Ïÿ×[Ñÿ×[Óÿ×[Õÿ×[×ÿ×[Ùÿ×[Ûÿ×[Ýÿ×[ÿ×[ÿ×[ÿ×[ÿ×[Hÿ×[`ÿ×[6ÿ×[8ÿ×[:ÿ×[<ÿ×[@ÿ×[Bÿ×[Dÿ×[Jÿ×[Lÿ×[Nÿ×[Rÿ×[Tÿ×[Vÿ×[Xÿ×[Zÿ×[\ÿ×[^ÿ×[`ÿ×\R\ R\ÿ®\ÿ®\")\R\ÿ®\ R\ ÿ®^-¸‚ÿq‚ ÿq‚&ÿׂ*ÿׂ- ‚2ÿׂ4ÿׂ7ÿq‚9ÿ®‚:ÿ®‚<ÿ…‚‰ÿׂ”ÿׂ•ÿׂ–ÿׂ—ÿׂ˜ÿׂšÿׂŸÿ…‚ÈÿׂÊÿׂÌÿׂÎÿׂÞÿׂàÿׂâÿׂäÿׂÿׂÿׂÿׂÿׂ$ÿq‚&ÿq‚6ÿ®‚8ÿ…‚:ÿ…‚Gÿׂúÿ®‚üÿ®‚þÿ®‚ÿ…‚ÿq‚ ÿq‚_ÿׂIÿׂKÿׂMÿׂOÿׂQÿׂSÿׂUÿׂWÿׂYÿׂ[ÿׂ]ÿׂ_ÿׂoÿ…‚qÿ…‚sÿ…‚ÿqƒÿqƒ ÿqƒ&ÿ׃*ÿ׃- ƒ2ÿ׃4ÿ׃7ÿqƒ9ÿ®ƒ:ÿ®ƒ<ÿ…ƒ‰ÿ׃”ÿ׃•ÿ׃–ÿ׃—ÿ׃˜ÿ׃šÿ׃Ÿÿ…ƒÈÿ׃Êÿ׃Ìÿ׃Îÿ׃Þÿ׃àÿ׃âÿ׃äÿ׃ÿ׃ÿ׃ÿ׃ÿ׃$ÿqƒ&ÿqƒ6ÿ®ƒ8ÿ…ƒ:ÿ…ƒGÿ׃úÿ®ƒüÿ®ƒþÿ®ƒÿ…ƒÿqƒ ÿqƒ_ÿ׃Iÿ׃Kÿ׃Mÿ׃Oÿ׃Qÿ׃Sÿ׃Uÿ׃Wÿ׃Yÿ׃[ÿ׃]ÿ׃_ÿ׃oÿ…ƒqÿ…ƒsÿ…ƒÿq„ÿq„ ÿq„&ÿׄ*ÿׄ- „2ÿׄ4ÿׄ7ÿq„9ÿ®„:ÿ®„<ÿ…„‰ÿׄ”ÿׄ•ÿׄ–ÿׄ—ÿׄ˜ÿׄšÿׄŸÿ…„ÈÿׄÊÿׄÌÿׄÎÿׄÞÿׄàÿׄâÿׄäÿׄÿׄÿׄÿׄÿׄ$ÿq„&ÿq„6ÿ®„8ÿ…„:ÿ…„Gÿׄúÿ®„üÿ®„þÿ®„ÿ…„ÿq„ ÿq„_ÿׄIÿׄKÿׄMÿׄOÿׄQÿׄSÿׄUÿׄWÿׄYÿׄ[ÿׄ]ÿׄ_ÿׄoÿ…„qÿ…„sÿ…„ÿq…ÿq… ÿq…&ÿ×…*ÿ×…- …2ÿ×…4ÿ×…7ÿq…9ÿ®…:ÿ®…<ÿ……‰ÿ×…”ÿ×…•ÿ×…–ÿ×…—ÿ×…˜ÿ×…šÿ×…Ÿÿ……Èÿ×…Êÿ×…Ìÿ×…Îÿ×…Þÿ×…àÿ×…âÿ×…äÿ×…ÿ×…ÿ×…ÿ×…ÿ×…$ÿq…&ÿq…6ÿ®…8ÿ……:ÿ……Gÿ×…úÿ®…üÿ®…þÿ®…ÿ……ÿq… ÿq…_ÿ×…Iÿ×…Kÿ×…Mÿ×…Oÿ×…Qÿ×…Sÿ×…Uÿ×…Wÿ×…Yÿ×…[ÿ×…]ÿ×…_ÿ×…oÿ……qÿ……sÿ……ÿq†ÿq† ÿq†&ÿ׆*ÿ׆- †2ÿ׆4ÿ׆7ÿq†9ÿ®†:ÿ®†<ÿ…†‰ÿ׆”ÿ׆•ÿ׆–ÿ׆—ÿ׆˜ÿ׆šÿ׆Ÿÿ…†Èÿ׆Êÿ׆Ìÿ׆Îÿ׆Þÿ׆àÿ׆âÿ׆äÿ׆ÿ׆ÿ׆ÿ׆ÿ׆$ÿq†&ÿq†6ÿ®†8ÿ…†:ÿ…†Gÿ׆úÿ®†üÿ®†þÿ®†ÿ…†ÿq† ÿq†_ÿ׆Iÿ׆Kÿ׆Mÿ׆Oÿ׆Qÿ׆Sÿ׆Uÿ׆Wÿ׆Yÿ׆[ÿ׆]ÿ׆_ÿ׆oÿ…†qÿ…†sÿ…†ÿq‡ÿq‡ ÿq‡&ÿׇ*ÿׇ- ‡2ÿׇ4ÿׇ7ÿq‡9ÿ®‡:ÿ®‡<ÿ…‡‰ÿׇ”ÿׇ•ÿׇ–ÿׇ—ÿׇ˜ÿׇšÿׇŸÿ…‡ÈÿׇÊÿׇÌÿׇÎÿׇÞÿׇàÿׇâÿׇäÿׇÿׇÿׇÿׇÿׇ$ÿq‡&ÿq‡6ÿ®‡8ÿ…‡:ÿ…‡Gÿׇúÿ®‡üÿ®‡þÿ®‡ÿ…‡ÿq‡ ÿq‡_ÿׇIÿׇKÿׇMÿׇOÿׇQÿׇSÿׇUÿׇWÿׇYÿׇ[ÿׇ]ÿׇ_ÿׇoÿ…‡qÿ…‡sÿ…‡ÿqˆ-{‰&ÿ׉*ÿ׉2ÿ׉4ÿ׉‰ÿ׉”ÿ׉•ÿ׉–ÿ׉—ÿ׉˜ÿ׉šÿ׉Èÿ׉Êÿ׉Ìÿ׉Îÿ׉Þÿ׉àÿ׉âÿ׉äÿ׉ÿ׉ÿ׉ÿ׉ÿ׉Gÿ׉_ÿ׉Iÿ׉Kÿ׉Mÿ׉Oÿ׉Qÿ׉Sÿ׉Uÿ׉Wÿ׉Yÿ׉[ÿ׉]ÿ׉_ÿ׊-{‹-{Œ-{-{’ÿ®’ÿ®’$ÿ×’7ÿÃ’9ÿì’:ÿì’;ÿ×’<ÿì’=ÿì’‚ÿ×’ƒÿ×’„ÿ×’…ÿ×’†ÿ×’‡ÿ×’Ÿÿì’Âÿ×’Äÿ×’Æÿ×’$ÿÃ’&ÿÃ’6ÿì’8ÿì’:ÿì’;ÿì’=ÿì’?ÿì’Cÿ×’ ÿì’úÿì’üÿì’þÿì’ÿì’ÿ®’ ÿ®’Xÿ×’ÿ×’ÿ×’!ÿ×’#ÿ×’%ÿ×’'ÿ×’)ÿ×’+ÿ×’-ÿ×’/ÿ×’1ÿ×’3ÿ×’oÿì’qÿì’sÿì’ÿÔÿ®”ÿ®”$ÿ×”7ÿÔ9ÿì”:ÿì”;ÿ×”<ÿì”=ÿ씂ÿ×”ƒÿ×”„ÿ×”…ÿ×”†ÿ×”‡ÿ×”Ÿÿì”Âÿ×”Äÿ×”Æÿ×”$ÿÔ&ÿÔ6ÿì”8ÿì”:ÿì”;ÿì”=ÿì”?ÿì”Cÿ×” ÿì”úÿì”üÿì”þÿì”ÿì”ÿ®” ÿ®”Xÿ×”ÿ×”ÿ×”!ÿ×”#ÿ×”%ÿ×”'ÿ×”)ÿ×”+ÿ×”-ÿ×”/ÿ×”1ÿ×”3ÿ×”oÿì”qÿì”sÿì”ÿÕÿ®•ÿ®•$ÿו7ÿÕ9ÿì•:ÿì•;ÿו<ÿì•=ÿì•‚ÿוƒÿו„ÿו…ÿו†ÿו‡ÿוŸÿì•ÂÿוÄÿוÆÿו$ÿÕ&ÿÕ6ÿì•8ÿì•:ÿì•;ÿì•=ÿì•?ÿì•Cÿו ÿì•úÿì•üÿì•þÿì•ÿì•ÿ®• ÿ®•Xÿוÿוÿו!ÿו#ÿו%ÿו'ÿו)ÿו+ÿו-ÿו/ÿו1ÿו3ÿוoÿì•qÿì•sÿì•ÿÖÿ®–ÿ®–$ÿ×–7ÿÖ9ÿì–:ÿì–;ÿ×–<ÿì–=ÿì–‚ÿ×–ƒÿ×–„ÿ×–…ÿ×–†ÿ×–‡ÿ×–Ÿÿì–Âÿ×–Äÿ×–Æÿ×–$ÿÖ&ÿÖ6ÿì–8ÿì–:ÿì–;ÿì–=ÿì–?ÿì–Cÿ×– ÿì–úÿì–üÿì–þÿì–ÿì–ÿ®– ÿ®–Xÿ×–ÿ×–ÿ×–!ÿ×–#ÿ×–%ÿ×–'ÿ×–)ÿ×–+ÿ×–-ÿ×–/ÿ×–1ÿ×–3ÿ×–oÿì–qÿì–sÿì–ÿ×ÿ®—ÿ®—$ÿ×—7ÿ×9ÿì—:ÿì—;ÿ×—<ÿì—=ÿì—‚ÿ×—ƒÿ×—„ÿ×—…ÿ×—†ÿ×—‡ÿ×—Ÿÿì—Âÿ×—Äÿ×—Æÿ×—$ÿ×&ÿ×6ÿì—8ÿì—:ÿì—;ÿì—=ÿì—?ÿì—Cÿ×— ÿì—úÿì—üÿì—þÿì—ÿì—ÿ®— ÿ®—Xÿ×—ÿ×—ÿ×—!ÿ×—#ÿ×—%ÿ×—'ÿ×—)ÿ×—+ÿ×—-ÿ×—/ÿ×—1ÿ×—3ÿ×—oÿì—qÿì—sÿì—ÿØÿ®˜ÿ®˜$ÿט7ÿØ9ÿì˜:ÿì˜;ÿט<ÿì˜=ÿ옂ÿטƒÿט„ÿט…ÿט†ÿט‡ÿטŸÿì˜ÂÿטÄÿטÆÿט$ÿØ&ÿØ6ÿì˜8ÿì˜:ÿì˜;ÿì˜=ÿì˜?ÿì˜Cÿט ÿì˜úÿì˜üÿì˜þÿì˜ÿì˜ÿ®˜ ÿ®˜Xÿטÿטÿט!ÿט#ÿט%ÿט'ÿט)ÿט+ÿט-ÿט/ÿט1ÿט3ÿטoÿì˜qÿì˜sÿì˜ÿÚÿ®šÿ®š$ÿך7ÿÚ9ÿìš:ÿìš;ÿך<ÿìš=ÿìš‚ÿךƒÿך„ÿך…ÿך†ÿך‡ÿךŸÿìšÂÿךÄÿךÆÿך$ÿÚ&ÿÚ6ÿìš8ÿìš:ÿìš;ÿìš=ÿìš?ÿìšCÿך ÿìšúÿìšüÿìšþÿìšÿìšÿ®š ÿ®šXÿךÿךÿך!ÿך#ÿך%ÿך'ÿך)ÿך+ÿך-ÿך/ÿך1ÿך3ÿךoÿìšqÿìšsÿìšÿÛÿ×›ÿ×›$ÿ웂ÿ웃ÿ웄ÿì›…ÿ웆ÿ웇ÿì›Âÿì›Äÿì›Æÿì›Cÿì›ÿ×› ÿ×›Xÿì›ÿì›ÿì›!ÿì›#ÿì›%ÿì›'ÿì›)ÿì›+ÿì›-ÿì›/ÿì›1ÿì›3ÿìœÿלÿל$ÿ윂ÿ윃ÿ위ÿ윅ÿ윆ÿ윇ÿìœÂÿìœÄÿìœÆÿìœCÿìœÿל ÿלXÿìœÿìœÿìœ!ÿìœ#ÿìœ%ÿìœ'ÿìœ)ÿìœ+ÿìœ-ÿìœ/ÿìœ1ÿìœ3ÿìÿ×ÿ×$ÿì‚ÿìƒÿì„ÿì…ÿì†ÿì‡ÿìÂÿìÄÿìÆÿìCÿìÿ× ÿ×Xÿìÿìÿì!ÿì#ÿì%ÿì'ÿì)ÿì+ÿì-ÿì/ÿì1ÿì3ÿìžÿמÿמ$ÿìž‚ÿ잃ÿìž„ÿìž…ÿ잆ÿ잇ÿìžÂÿìžÄÿìžÆÿìžCÿìžÿמ ÿמXÿìžÿìžÿìž!ÿìž#ÿìž%ÿìž'ÿìž)ÿìž+ÿìž-ÿìž/ÿìž1ÿìž3ÿìŸÿ…Ÿÿ…Ÿ")Ÿ$ÿ…Ÿ&ÿן*ÿן2ÿן4ÿןDÿšŸFÿšŸGÿšŸHÿšŸJÿןPÿßQÿßRÿšŸSÿßTÿšŸUÿßVÿ®ŸXÿß]ÿן‚ÿ…Ÿƒÿ…Ÿ„ÿ…Ÿ…ÿ…Ÿ†ÿ…Ÿ‡ÿ…Ÿ‰ÿן”ÿן•ÿן–ÿן—ÿן˜ÿןšÿן¢ÿšŸ£ÿšŸ¤ÿšŸ¥ÿšŸ¦ÿšŸ§ÿšŸ¨ÿšŸ©ÿšŸªÿšŸ«ÿšŸ¬ÿšŸ­ÿšŸ´ÿšŸµÿšŸ¶ÿšŸ·ÿšŸ¸ÿšŸºÿšŸ»ÿß¼ÿß½ÿß¾ÿßÂÿ…ŸÃÿšŸÄÿ…ŸÅÿšŸÆÿ…ŸÇÿšŸÈÿןÉÿšŸÊÿןËÿšŸÌÿןÍÿšŸÎÿןÏÿšŸÑÿšŸÓÿšŸÕÿšŸ×ÿšŸÙÿšŸÛÿšŸÝÿšŸÞÿןßÿןàÿןáÿןâÿןãÿןäÿןåÿןúÿßÿßÿß ÿßÿןÿšŸÿןÿšŸÿןÿšŸÿןÿšŸÿßÿßÿ®Ÿ!ÿ®Ÿ+ÿß-ÿß/ÿß1ÿß3ÿß5ÿß<ÿן>ÿן@ÿןCÿ…ŸDÿšŸFÿšŸGÿןHÿšŸJÿ®Ÿÿ…Ÿ ÿ…ŸWÿßXÿ…ŸYÿšŸ_ÿן`ÿšŸbÿßÿ…ŸÿšŸÿ…Ÿ ÿšŸ!ÿ…Ÿ"ÿšŸ#ÿ…Ÿ%ÿ…Ÿ&ÿšŸ'ÿ…Ÿ(ÿšŸ)ÿ…Ÿ*ÿšŸ+ÿ…Ÿ,ÿšŸ-ÿ…Ÿ.ÿšŸ/ÿ…Ÿ0ÿšŸ1ÿ…Ÿ2ÿšŸ3ÿ…Ÿ4ÿšŸ6ÿšŸ8ÿšŸ:ÿšŸ<ÿšŸ@ÿšŸBÿšŸDÿšŸIÿןJÿšŸKÿןLÿšŸMÿןNÿšŸOÿןQÿןRÿšŸSÿןTÿšŸUÿןVÿšŸWÿןXÿšŸYÿןZÿšŸ[ÿן\ÿšŸ]ÿן^ÿšŸ_ÿן`ÿšŸbÿßdÿßfÿßhÿßjÿßlÿßnÿàþö þö $ÿš ;ÿ× =ÿì ‚ÿš ƒÿš „ÿš …ÿš †ÿš ‡ÿš Âÿš Äÿš Æÿš ;ÿì =ÿì ?ÿì Cÿš þö  þö Xÿš ÿš ÿš !ÿš #ÿš %ÿš 'ÿš )ÿš +ÿš -ÿš /ÿš 1ÿš 3ÿš¢ÿì¢ ÿì¢ÿì¢ ÿì£ÿì£ ÿì£ÿì£ ÿì¤ÿì¤ ÿì¤ÿì¤ ÿì¥ÿì¥ ÿì¥ÿì¥ ÿì¦ÿì¦ ÿì¦ÿì¦ ÿì§ÿì§ ÿì§ÿì§ ÿìªÿìª ÿìªYÿתZÿת[ÿת\ÿת]ÿ쪿ÿת7ÿת<ÿìª>ÿìª@ÿìªûÿתýÿתÿìª ÿìªpÿ׫ÿì« ÿì«Yÿ׫Zÿ׫[ÿ׫\ÿ׫]ÿì«¿ÿ׫7ÿ׫<ÿì«>ÿì«@ÿì«ûÿ׫ýÿ׫ÿì« ÿì«pÿ׬ÿì¬ ÿì¬Yÿ׬Zÿ׬[ÿ׬\ÿ׬]ÿ쬿ÿ׬7ÿ׬<ÿì¬>ÿì¬@ÿì¬ûÿ׬ýÿ׬ÿì¬ ÿì¬pÿ×­ÿì­ ÿì­Yÿ×­Zÿ×­[ÿ×­\ÿ×­]ÿì­¿ÿ×­7ÿ×­<ÿì­>ÿì­@ÿì­ûÿ×­ýÿ×­ÿì­ ÿì­pÿײÿì² ÿì²YÿײZÿײ[ÿײ\ÿײ]ÿ첿ÿײ7ÿײ<ÿì²>ÿì²@ÿì²ûÿײýÿײÿì² ÿì²pÿ×´ÿì´ ÿì´Yÿ×´Zÿ×´[ÿ×´\ÿ×´]ÿì´¿ÿ×´7ÿ×´<ÿì´>ÿì´@ÿì´ûÿ×´ýÿ×´ÿì´ ÿì´pÿ×µÿìµ ÿìµYÿ×µZÿ×µ[ÿ×µ\ÿ×µ]ÿ쵿ÿ×µ7ÿ×µ<ÿìµ>ÿìµ@ÿìµûÿ×µýÿ×µÿìµ ÿìµpÿ׶ÿì¶ ÿì¶Yÿ׶Zÿ׶[ÿ׶\ÿ׶]ÿ춿ÿ׶7ÿ׶<ÿì¶>ÿì¶@ÿì¶ûÿ׶ýÿ׶ÿì¶ ÿì¶pÿ׸ÿ׸ ÿ׸ÿ׸ ÿ׺ÿìº ÿìºYÿ׺Zÿ׺[ÿ׺\ÿ׺]ÿ캿ÿ׺7ÿ׺<ÿìº>ÿìº@ÿìºûÿ׺ýÿ׺ÿìº ÿìºpÿ׿R¿ R¿ÿ®¿ÿ®¿")¿R¿ÿ®¿ R¿ ÿ®ÀÿìÀ ÿìÀYÿ×ÀZÿ×À[ÿ×À\ÿ×À]ÿìÀ¿ÿ×À7ÿ×À<ÿìÀ>ÿìÀ@ÿìÀûÿ×Àýÿ×ÀÿìÀ ÿìÀpÿ×ÁRÁ RÁÿ®Áÿ®Á")ÁRÁÿ®Á RÁ ÿ®Âÿq ÿqÂ&ÿ×Â*ÿ×Â- Â2ÿ×Â4ÿ×Â7ÿqÂ9ÿ®Â:ÿ®Â<ÿ…‰ÿ×”ÿוÿ×–ÿ×—ÿטÿךÿןÿ…ÂÈÿ×ÂÊÿ×ÂÌÿ×ÂÎÿ×ÂÞÿ×Âàÿ×Ââÿ×Âäÿ×Âÿ×Âÿ×Âÿ×Âÿ×Â$ÿqÂ&ÿqÂ6ÿ®Â8ÿ…Â:ÿ…ÂGÿ×Âúÿ®Âüÿ®Âþÿ®Âÿ…Âÿq ÿqÂ_ÿ×ÂIÿ×ÂKÿ×ÂMÿ×ÂOÿ×ÂQÿ×ÂSÿ×ÂUÿ×ÂWÿ×ÂYÿ×Â[ÿ×Â]ÿ×Â_ÿ×Âoÿ…Âqÿ…Âsÿ…ÂÿqÃÿìà ÿìÃÿìà ÿìÄÿqÄ ÿqÄ&ÿ×Ä*ÿ×Ä- Ä2ÿ×Ä4ÿ×Ä7ÿqÄ9ÿ®Ä:ÿ®Ä<ÿ…ĉÿ×Ä”ÿ×Ä•ÿ×Ä–ÿ×Ä—ÿ×Ęÿ×Äšÿ×ÄŸÿ…ÄÈÿ×ÄÊÿ×ÄÌÿ×ÄÎÿ×ÄÞÿ×Äàÿ×Äâÿ×Ääÿ×Äÿ×Äÿ×Äÿ×Äÿ×Ä$ÿqÄ&ÿqÄ6ÿ®Ä8ÿ…Ä:ÿ…ÄGÿ×Äúÿ®Äüÿ®Äþÿ®Äÿ…ÄÿqÄ ÿqÄ_ÿ×ÄIÿ×ÄKÿ×ÄMÿ×ÄOÿ×ÄQÿ×ÄSÿ×ÄUÿ×ÄWÿ×ÄYÿ×Ä[ÿ×Ä]ÿ×Ä_ÿ×Äoÿ…Äqÿ…Äsÿ…ÄÿqÅÿìÅ ÿìÅÿìÅ ÿìÆÿqÆ ÿqÆ&ÿ×Æ*ÿ×Æ- Æ2ÿ×Æ4ÿ×Æ7ÿqÆ9ÿ®Æ:ÿ®Æ<ÿ…Ɖÿ×Æ”ÿ×Æ•ÿ×Æ–ÿ×Æ—ÿ×Ƙÿ×Æšÿ×ÆŸÿ…ÆÈÿ×ÆÊÿ×ÆÌÿ×ÆÎÿ×ÆÞÿ×Æàÿ×Æâÿ×Æäÿ×Æÿ×Æÿ×Æÿ×Æÿ×Æ$ÿqÆ&ÿqÆ6ÿ®Æ8ÿ…Æ:ÿ…ÆGÿ×Æúÿ®Æüÿ®Æþÿ®Æÿ…ÆÿqÆ ÿqÆ_ÿ×ÆIÿ×ÆKÿ×ÆMÿ×ÆOÿ×ÆQÿ×ÆSÿ×ÆUÿ×ÆWÿ×ÆYÿ×Æ[ÿ×Æ]ÿ×Æ_ÿ×Æoÿ…Æqÿ…Æsÿ…ÆÿqÇÿìÇ ÿìÇÿìÇ ÿìÈ&ÿ×È*ÿ×È2ÿ×È4ÿ×ȉÿ×È”ÿ×È•ÿ×È–ÿ×È—ÿ×Șÿ×Èšÿ×ÈÈÿ×ÈÊÿ×ÈÌÿ×ÈÎÿ×ÈÞÿ×Èàÿ×Èâÿ×Èäÿ×Èÿ×Èÿ×Èÿ×Èÿ×ÈGÿ×È_ÿ×ÈIÿ×ÈKÿ×ÈMÿ×ÈOÿ×ÈQÿ×ÈSÿ×ÈUÿ×ÈWÿ×ÈYÿ×È[ÿ×È]ÿ×È_ÿ×Ê&ÿ×Ê*ÿ×Ê2ÿ×Ê4ÿ×ʉÿ×Ê”ÿ×Ê•ÿ×Ê–ÿ×Ê—ÿ×ʘÿ×Êšÿ×ÊÈÿ×ÊÊÿ×ÊÌÿ×ÊÎÿ×ÊÞÿ×Êàÿ×Êâÿ×Êäÿ×Êÿ×Êÿ×Êÿ×Êÿ×ÊGÿ×Ê_ÿ×ÊIÿ×ÊKÿ×ÊMÿ×ÊOÿ×ÊQÿ×ÊSÿ×ÊUÿ×ÊWÿ×ÊYÿ×Ê[ÿ×Ê]ÿ×Ê_ÿ×Ì&ÿ×Ì*ÿ×Ì2ÿ×Ì4ÿ×̉ÿ×Ì”ÿ×Ì•ÿ×Ì–ÿ×Ì—ÿ×̘ÿ×Ìšÿ×ÌÈÿ×ÌÊÿ×ÌÌÿ×ÌÎÿ×ÌÞÿ×Ìàÿ×Ìâÿ×Ìäÿ×Ìÿ×Ìÿ×Ìÿ×Ìÿ×ÌGÿ×Ì_ÿ×ÌIÿ×ÌKÿ×ÌMÿ×ÌOÿ×ÌQÿ×ÌSÿ×ÌUÿ×ÌWÿ×ÌYÿ×Ì[ÿ×Ì]ÿ×Ì_ÿ×Î&ÿ×Î*ÿ×Î2ÿ×Î4ÿ×Ήÿ×Δÿ×Εÿ×Ζÿ×Ηÿ×Θÿ×Κÿ×ÎÈÿ×ÎÊÿ×ÎÌÿ×ÎÎÿ×ÎÞÿ×Îàÿ×Îâÿ×Îäÿ×Îÿ×Îÿ×Îÿ×Îÿ×ÎGÿ×Î_ÿ×ÎIÿ×ÎKÿ×ÎMÿ×ÎOÿ×ÎQÿ×ÎSÿ×ÎUÿ×ÎWÿ×ÎYÿ×Î[ÿ×Î]ÿ×Î_ÿ×Ðÿ®Ðÿ®Ð$ÿ×Ð7ÿÃÐ9ÿìÐ:ÿìÐ;ÿ×Ð<ÿìÐ=ÿìЂÿ×Ѓÿ×Єÿ×Ð…ÿ×Іÿ×Їÿ×ПÿìÐÂÿ×ÐÄÿ×ÐÆÿ×Ð$ÿÃÐ&ÿÃÐ6ÿìÐ8ÿìÐ:ÿìÐ;ÿìÐ=ÿìÐ?ÿìÐCÿ×РÿìÐúÿìÐüÿìÐþÿìÐÿìÐÿ®Ð ÿ®ÐXÿ×Ðÿ×Ðÿ×Ð!ÿ×Ð#ÿ×Ð%ÿ×Ð'ÿ×Ð)ÿ×Ð+ÿ×Ð-ÿ×Ð/ÿ×Ð1ÿ×Ð3ÿ×ÐoÿìÐqÿìÐsÿìÐÿÃÑRÑ RÑ Ñ"¤Ñ@ÑE=ÑK=ÑN=ÑO=Ñ`Ñç=Ñé{ÑRÑ RÒÿ®Òÿ®Ò$ÿ×Ò7ÿÃÒ9ÿìÒ:ÿìÒ;ÿ×Ò<ÿìÒ=ÿìÒ‚ÿ×Òƒÿ×Ò„ÿ×Ò…ÿ×Ò†ÿ×Ò‡ÿ×ÒŸÿìÒÂÿ×ÒÄÿ×ÒÆÿ×Ò$ÿÃÒ&ÿÃÒ6ÿìÒ8ÿìÒ:ÿìÒ;ÿìÒ=ÿìÒ?ÿìÒCÿ×Ò ÿìÒúÿìÒüÿìÒþÿìÒÿìÒÿ®Ò ÿ®ÒXÿ×Òÿ×Òÿ×Ò!ÿ×Ò#ÿ×Ò%ÿ×Ò'ÿ×Ò)ÿ×Ò+ÿ×Ò-ÿ×Ò/ÿ×Ò1ÿ×Ò3ÿ×ÒoÿìÒqÿìÒsÿìÒÿÃÔ-{ÕÿìÕ ÿìÕYÿ×ÕZÿ×Õ[ÿ×Õ\ÿ×Õ]ÿìÕ¿ÿ×Õ7ÿ×Õ<ÿìÕ>ÿìÕ@ÿìÕûÿ×Õýÿ×ÕÿìÕ ÿìÕpÿ×Ö-{×ÿì× ÿì×Yÿ××Zÿ××[ÿ××\ÿ××]ÿì׿ÿ××7ÿ××<ÿì×>ÿì×@ÿì×ûÿ××ýÿ××ÿì× ÿì×pÿ×Ø-{ÙÿìÙ ÿìÙYÿ×ÙZÿ×Ù[ÿ×Ù\ÿ×Ù]ÿìÙ¿ÿ×Ù7ÿ×Ù<ÿìÙ>ÿìÙ@ÿìÙûÿ×Ùýÿ×ÙÿìÙ ÿìÙpÿ×Ú-{ÛÿìÛ ÿìÛYÿ×ÛZÿ×Û[ÿ×Û\ÿ×Û]ÿìÛ¿ÿ×Û7ÿ×Û<ÿìÛ>ÿìÛ@ÿìÛûÿ×Ûýÿ×ÛÿìÛ ÿìÛpÿ×Ü-{ÝÿìÝ ÿìÝYÿ×ÝZÿ×Ý[ÿ×Ý\ÿ×Ý]ÿìÝ¿ÿ×Ý7ÿ×Ý<ÿìÝ>ÿìÝ@ÿìÝûÿ×Ýýÿ×ÝÿìÝ ÿìÝpÿ×çÿìç ÿìçÿìç ÿìø&ÿ×ø*ÿ×ø2ÿ×ø4ÿ×ø‰ÿ×ø”ÿ×ø•ÿ×ø–ÿ×ø—ÿ×ø˜ÿ×øšÿ×øÈÿ×øÊÿ×øÌÿ×øÎÿ×øÞÿ×øàÿ×øâÿ×øäÿ×øÿ×øÿ×øÿ×øÿ×øGÿ×ø_ÿ×øIÿ×øKÿ×øMÿ×øOÿ×øQÿ×øSÿ×øUÿ×øWÿ×øYÿ×ø[ÿ×ø]ÿ×ø_ÿ×ùFÿ×ùGÿ×ùHÿ×ùRÿ×ùTÿ×ù¢ÿ×ù©ÿ×ùªÿ×ù«ÿ×ù¬ÿ×ù­ÿ×ù´ÿ×ùµÿ×ù¶ÿ×ù·ÿ×ù¸ÿ×ùºÿ×ùÉÿ×ùËÿ×ùÍÿ×ùÏÿ×ùÑÿ×ùÓÿ×ùÕÿ×ù×ÿ×ùÙÿ×ùÛÿ×ùÝÿ×ùÿ×ùÿ×ùÿ×ùÿ×ùHÿ×ù`ÿ×ù6ÿ×ù8ÿ×ù:ÿ×ù<ÿ×ù@ÿ×ùBÿ×ùDÿ×ùJÿ×ùLÿ×ùNÿ×ùRÿ×ùTÿ×ùVÿ×ùXÿ×ùZÿ×ù\ÿ×ù^ÿ×ù`ÿ×úFÿ×úGÿ×úHÿ×úRÿ×úTÿ×ú¢ÿ×ú©ÿ×úªÿ×ú«ÿ×ú¬ÿ×ú­ÿ×ú´ÿ×úµÿ×ú¶ÿ×ú·ÿ×ú¸ÿ×úºÿ×úÉÿ×úËÿ×úÍÿ×úÏÿ×úÑÿ×úÓÿ×úÕÿ×ú×ÿ×úÙÿ×úÛÿ×úÝÿ×úÿ×úÿ×úÿ×úÿ×úHÿ×ú`ÿ×ú6ÿ×ú8ÿ×ú:ÿ×ú<ÿ×ú@ÿ×úBÿ×úDÿ×úJÿ×úLÿ×úNÿ×úRÿ×úTÿ×úVÿ×úXÿ×úZÿ×ú\ÿ×ú^ÿ×ú`ÿ×ûÿ\û ÿ\û&ÿ×û*ÿ×û2ÿ×û4ÿ×û7ÿ×û8ÿìû9ÿ×û:ÿ×û<ÿÃû‰ÿ×û”ÿ×û•ÿ×û–ÿ×û—ÿ×û˜ÿ×ûšÿ×û›ÿìûœÿìûÿìûžÿìûŸÿÃûÈÿ×ûÊÿ×ûÌÿ×ûÎÿ×ûÞÿ×ûàÿ×ûâÿ×ûäÿ×ûÿ×ûÿ×ûÿ×ûÿ×û$ÿ×û&ÿ×û*ÿìû,ÿìû.ÿìû0ÿìû2ÿìû4ÿìû6ÿ×û8ÿÃû:ÿÃûGÿ×ûúÿ×ûüÿ×ûþÿ×ûÿÃûÿ\û ÿ\û_ÿ×ûaÿìûIÿ×ûKÿ×ûMÿ×ûOÿ×ûQÿ×ûSÿ×ûUÿ×ûWÿ×ûYÿ×û[ÿ×û]ÿ×û_ÿ×ûaÿìûcÿìûeÿìûgÿìûiÿìûkÿìûmÿìûoÿÃûqÿÃûsÿÃûÿ×ýÿ\ý ÿ\ý&ÿ×ý*ÿ×ý2ÿ×ý4ÿ×ý7ÿ×ý8ÿìý9ÿ×ý:ÿ×ý<ÿÃý‰ÿ×ý”ÿ×ý•ÿ×ý–ÿ×ý—ÿ×ý˜ÿ×ýšÿ×ý›ÿìýœÿìýÿìýžÿìýŸÿÃýÈÿ×ýÊÿ×ýÌÿ×ýÎÿ×ýÞÿ×ýàÿ×ýâÿ×ýäÿ×ýÿ×ýÿ×ýÿ×ýÿ×ý$ÿ×ý&ÿ×ý*ÿìý,ÿìý.ÿìý0ÿìý2ÿìý4ÿìý6ÿ×ý8ÿÃý:ÿÃýGÿ×ýúÿ×ýüÿ×ýþÿ×ýÿÃýÿ\ý ÿ\ý_ÿ×ýaÿìýIÿ×ýKÿ×ýMÿ×ýOÿ×ýQÿ×ýSÿ×ýUÿ×ýWÿ×ýYÿ×ý[ÿ×ý]ÿ×ý_ÿ×ýaÿìýcÿìýeÿìýgÿìýiÿìýkÿìýmÿìýoÿÃýqÿÃýsÿÃýÿ×ÿÿ\ÿ ÿ\ÿ&ÿ×ÿ*ÿ×ÿ2ÿ×ÿ4ÿ×ÿ7ÿ×ÿ8ÿìÿ9ÿ×ÿ:ÿ×ÿ<ÿÃÿ‰ÿ×ÿ”ÿ×ÿ•ÿ×ÿ–ÿ×ÿ—ÿ×ÿ˜ÿ×ÿšÿ×ÿ›ÿìÿœÿìÿÿìÿžÿìÿŸÿÃÿÈÿ×ÿÊÿ×ÿÌÿ×ÿÎÿ×ÿÞÿ×ÿàÿ×ÿâÿ×ÿäÿ×ÿÿ×ÿÿ×ÿÿ×ÿÿ×ÿ$ÿ×ÿ&ÿ×ÿ*ÿìÿ,ÿìÿ.ÿìÿ0ÿìÿ2ÿìÿ4ÿìÿ6ÿ×ÿ8ÿÃÿ:ÿÃÿGÿ×ÿúÿ×ÿüÿ×ÿþÿ×ÿÿÃÿÿ\ÿ ÿ\ÿ_ÿ×ÿaÿìÿIÿ×ÿKÿ×ÿMÿ×ÿOÿ×ÿQÿ×ÿSÿ×ÿUÿ×ÿWÿ×ÿYÿ×ÿ[ÿ×ÿ]ÿ×ÿ_ÿ×ÿaÿìÿcÿìÿeÿìÿgÿìÿiÿìÿkÿìÿmÿìÿoÿÃÿqÿÃÿsÿÃÿÿ×R R "@E=K=N=O=`ç=éR Rÿ\ ÿ\&ÿ×*ÿ×2ÿ×4ÿ×7ÿ×8ÿì9ÿ×:ÿ×<ÿÉÿ×”ÿוÿ×–ÿ×—ÿטÿךÿ×›ÿìœÿìÿìžÿìŸÿÃÈÿ×Êÿ×Ìÿ×Îÿ×Þÿ×àÿ×âÿ×äÿ×ÿ×ÿ×ÿ×ÿ×$ÿ×&ÿ×*ÿì,ÿì.ÿì0ÿì2ÿì4ÿì6ÿ×8ÿÃ:ÿÃGÿ×úÿ×üÿ×þÿ×ÿÃÿ\ ÿ\_ÿ×aÿìIÿ×Kÿ×Mÿ×Oÿ×Qÿ×Sÿ×Uÿ×Wÿ×Yÿ×[ÿ×]ÿ×_ÿ×aÿìcÿìeÿìgÿìiÿìkÿìmÿìoÿÃqÿÃsÿÃÿ×ÿ\ ÿ\&ÿ×*ÿ×2ÿ×4ÿ×7ÿ×8ÿì9ÿ×:ÿ×<ÿÉÿ×”ÿוÿ×–ÿ×—ÿטÿךÿ×›ÿìœÿìÿìžÿìŸÿÃÈÿ×Êÿ×Ìÿ×Îÿ×Þÿ×àÿ×âÿ×äÿ×ÿ×ÿ×ÿ×ÿ×$ÿ×&ÿ×*ÿì,ÿì.ÿì0ÿì2ÿì4ÿì6ÿ×8ÿÃ:ÿÃGÿ×úÿ×üÿ×þÿ×ÿÃÿ\ ÿ\_ÿ×aÿìIÿ×Kÿ×Mÿ×Oÿ×Qÿ×Sÿ×Uÿ×Wÿ×Yÿ×[ÿ×]ÿ×_ÿ×aÿìcÿìeÿìgÿìiÿìkÿìmÿìoÿÃqÿÃsÿÃÿ×ÿì ÿìÿì ÿìÿ®ÿ®$ÿ×7ÿÃ9ÿì:ÿì;ÿ×<ÿì=ÿì‚ÿ׃ÿׄÿ×…ÿ׆ÿׇÿןÿìÂÿ×Äÿ×Æÿ×$ÿÃ&ÿÃ6ÿì8ÿì:ÿì;ÿì=ÿì?ÿìCÿ× ÿìúÿìüÿìþÿìÿìÿ® ÿ®Xÿ×ÿ×ÿ×!ÿ×#ÿ×%ÿ×'ÿ×)ÿ×+ÿ×-ÿ×/ÿ×1ÿ×3ÿ×oÿìqÿìsÿìÿÃÿ®ÿ®$ÿ×7ÿÃ9ÿì:ÿì;ÿ×<ÿì=ÿì‚ÿ׃ÿׄÿ×…ÿ׆ÿׇÿןÿìÂÿ×Äÿ×Æÿ×$ÿÃ&ÿÃ6ÿì8ÿì:ÿì;ÿì=ÿì?ÿìCÿ× ÿìúÿìüÿìþÿìÿìÿ® ÿ®Xÿ×ÿ×ÿ×!ÿ×#ÿ×%ÿ×'ÿ×)ÿ×+ÿ×-ÿ×/ÿ×1ÿ×3ÿ×oÿìqÿìsÿìÿÃÿ®ÿ®$ÿ×7ÿÃ9ÿì:ÿì;ÿ×<ÿì=ÿì‚ÿ׃ÿׄÿ×…ÿ׆ÿׇÿןÿìÂÿ×Äÿ×Æÿ×$ÿÃ&ÿÃ6ÿì8ÿì:ÿì;ÿì=ÿì?ÿìCÿ× ÿìúÿìüÿìþÿìÿìÿ® ÿ®Xÿ×ÿ×ÿ×!ÿ×#ÿ×%ÿ×'ÿ×)ÿ×+ÿ×-ÿ×/ÿ×1ÿ×3ÿ×oÿìqÿìsÿìÿÃ-{R RDÿ×Fÿ×Gÿ×Hÿ×JÿìRÿ×Tÿ×¢ÿ×£ÿפÿ×¥ÿצÿקÿרÿשÿתÿ׫ÿ׬ÿ×­ÿ×´ÿ×µÿ׶ÿ×·ÿ׸ÿ׺ÿ×Ãÿ×Åÿ×Çÿ×Éÿ×Ëÿ×Íÿ×Ïÿ×Ñÿ×Óÿ×Õÿ××ÿ×Ùÿ×Ûÿ×Ýÿ×ßÿìáÿìãÿìåÿìÿ×ÿ×ÿ×ÿ×Dÿ×Fÿ×Hÿ×R RYÿ×`ÿ×ÿ× ÿ×"ÿ×&ÿ×(ÿ×*ÿ×,ÿ×.ÿ×0ÿ×2ÿ×4ÿ×6ÿ×8ÿ×:ÿ×<ÿ×@ÿ×Bÿ×Dÿ×Jÿ×Lÿ×Nÿ×Rÿ×Tÿ×Vÿ×Xÿ×Zÿ×\ÿ×^ÿ×`ÿ×R RDÿ×Fÿ×Gÿ×Hÿ×JÿìRÿ×Tÿ×¢ÿ×£ÿפÿ×¥ÿצÿקÿרÿשÿתÿ׫ÿ׬ÿ×­ÿ×´ÿ×µÿ׶ÿ×·ÿ׸ÿ׺ÿ×Ãÿ×Åÿ×Çÿ×Éÿ×Ëÿ×Íÿ×Ïÿ×Ñÿ×Óÿ×Õÿ××ÿ×Ùÿ×Ûÿ×Ýÿ×ßÿìáÿìãÿìåÿìÿ×ÿ×ÿ×ÿ×Dÿ×Fÿ×Hÿ×R RYÿ×`ÿ×ÿ× ÿ×"ÿ×&ÿ×(ÿ×*ÿ×,ÿ×.ÿ×0ÿ×2ÿ×4ÿ×6ÿ×8ÿ×:ÿ×<ÿ×@ÿ×Bÿ×Dÿ×Jÿ×Lÿ×Nÿ×Rÿ×Tÿ×Vÿ×Xÿ×Zÿ×\ÿ×^ÿ×`ÿ×R RDÿ×Fÿ×Gÿ×Hÿ×JÿìRÿ×Tÿ×¢ÿ×£ÿפÿ×¥ÿצÿקÿרÿשÿתÿ׫ÿ׬ÿ×­ÿ×´ÿ×µÿ׶ÿ×·ÿ׸ÿ׺ÿ×Ãÿ×Åÿ×Çÿ×Éÿ×Ëÿ×Íÿ×Ïÿ×Ñÿ×Óÿ×Õÿ××ÿ×Ùÿ×Ûÿ×Ýÿ×ßÿìáÿìãÿìåÿìÿ×ÿ×ÿ×ÿ×Dÿ×Fÿ×Hÿ×R RYÿ×`ÿ×ÿ× ÿ×"ÿ×&ÿ×(ÿ×*ÿ×,ÿ×.ÿ×0ÿ×2ÿ×4ÿ×6ÿ×8ÿ×:ÿ×<ÿ×@ÿ×Bÿ×Dÿ×Jÿ×Lÿ×Nÿ×Rÿ×Tÿ×Vÿ×Xÿ×Zÿ×\ÿ×^ÿ×`ÿ×$ÿ…$ÿ®$ÿ…$")$$ÿq$&ÿ×$*ÿ×$2ÿ×$4ÿ×$7)$Dÿ\$Fÿq$Gÿq$Hÿq$Jÿq$Pÿš$Qÿš$Rÿq$Sÿš$Tÿq$Uÿš$Vÿ…$Xÿš$Yÿ×$Zÿ×$[ÿ×$\ÿ×$]ÿ®$‚ÿq$ƒÿq$„ÿq$…ÿq$†ÿq$‡ÿq$‰ÿ×$”ÿ×$•ÿ×$–ÿ×$—ÿ×$˜ÿ×$šÿ×$¢ÿq$£ÿ\$¤ÿ\$¥ÿ\$¦ÿ\$§ÿ\$¨ÿ\$©ÿq$ªÿq$«ÿq$¬ÿq$­ÿq$´ÿq$µÿq$¶ÿq$·ÿq$¸ÿq$ºÿq$»ÿš$¼ÿš$½ÿš$¾ÿš$¿ÿ×$Âÿq$Ãÿ\$Äÿq$Åÿ\$Æÿq$Çÿ\$Èÿ×$Éÿq$Êÿ×$Ëÿq$Ìÿ×$Íÿq$Îÿ×$Ïÿq$Ñÿq$Óÿq$Õÿq$×ÿq$Ùÿq$Ûÿq$Ýÿq$Þÿ×$ßÿq$àÿ×$áÿq$âÿ×$ãÿq$äÿ×$åÿq$úÿš$ÿš$ÿš$ ÿš$ÿ×$ÿq$ÿ×$ÿq$ÿ×$ÿq$ÿ×$ÿq$ÿš$ÿš$ÿ…$!ÿ…$$)$&)$+ÿš$-ÿš$/ÿš$1ÿš$3ÿš$5ÿš$7ÿ×$<ÿ®$>ÿ®$@ÿ®$Cÿq$Dÿ\$Fÿ\$Gÿ×$Hÿq$Jÿ…$ûÿ×$ýÿ×$ÿ®$ÿ®$ÿ®$ÿ…$ ÿ…$Wÿš$Xÿq$Yÿ\$_ÿ×$`ÿq$bÿš$ÿq$ÿ\$ÿq$ ÿ\$!ÿq$"ÿ\$#ÿq$%ÿq$&ÿ\$'ÿq$(ÿ\$)ÿq$*ÿ\$+ÿq$,ÿ\$-ÿq$.ÿ\$/ÿq$0ÿ\$1ÿq$2ÿ\$3ÿq$4ÿ\$6ÿq$8ÿq$:ÿq$<ÿq$@ÿq$Bÿq$Dÿq$Iÿ×$Jÿq$Kÿ×$Lÿq$Mÿ×$Nÿq$Oÿ×$Qÿ×$Rÿq$Sÿ×$Tÿq$Uÿ×$Vÿq$Wÿ×$Xÿq$Yÿ×$Zÿq$[ÿ×$\ÿq$]ÿ×$^ÿq$_ÿ×$`ÿq$bÿš$dÿš$fÿš$hÿš$jÿš$lÿš$nÿš$pÿ×$)%)% )%)% )&ÿ…&ÿ®&ÿ…&")&$ÿq&&ÿ×&*ÿ×&2ÿ×&4ÿ×&7)&Dÿ\&Fÿq&Gÿq&Hÿq&Jÿq&Pÿš&Qÿš&Rÿq&Sÿš&Tÿq&Uÿš&Vÿ…&Xÿš&Yÿ×&Zÿ×&[ÿ×&\ÿ×&]ÿ®&‚ÿq&ƒÿq&„ÿq&…ÿq&†ÿq&‡ÿq&‰ÿ×&”ÿ×&•ÿ×&–ÿ×&—ÿ×&˜ÿ×&šÿ×&¢ÿq&£ÿ\&¤ÿ\&¥ÿ\&¦ÿ\&§ÿ\&¨ÿ\&©ÿq&ªÿq&«ÿq&¬ÿq&­ÿq&´ÿq&µÿq&¶ÿq&·ÿq&¸ÿq&ºÿq&»ÿš&¼ÿš&½ÿš&¾ÿš&¿ÿ×&Âÿq&Ãÿ\&Äÿq&Åÿ\&Æÿq&Çÿ\&Èÿ×&Éÿq&Êÿ×&Ëÿq&Ìÿ×&Íÿq&Îÿ×&Ïÿq&Ñÿq&Óÿq&Õÿq&×ÿq&Ùÿq&Ûÿq&Ýÿq&Þÿ×&ßÿq&àÿ×&áÿq&âÿ×&ãÿq&äÿ×&åÿq&úÿš&ÿš&ÿš& ÿš&ÿ×&ÿq&ÿ×&ÿq&ÿ×&ÿq&ÿ×&ÿq&ÿš&ÿš&ÿ…&!ÿ…&$)&&)&+ÿš&-ÿš&/ÿš&1ÿš&3ÿš&5ÿš&7ÿ×&<ÿ®&>ÿ®&@ÿ®&Cÿq&Dÿ\&Fÿ\&Gÿ×&Hÿq&Jÿ…&ûÿ×&ýÿ×&ÿ®&ÿ®&ÿ®&ÿ…& ÿ…&Wÿš&Xÿq&Yÿ\&_ÿ×&`ÿq&bÿš&ÿq&ÿ\&ÿq& ÿ\&!ÿq&"ÿ\&#ÿq&%ÿq&&ÿ\&'ÿq&(ÿ\&)ÿq&*ÿ\&+ÿq&,ÿ\&-ÿq&.ÿ\&/ÿq&0ÿ\&1ÿq&2ÿ\&3ÿq&4ÿ\&6ÿq&8ÿq&:ÿq&<ÿq&@ÿq&Bÿq&Dÿq&Iÿ×&Jÿq&Kÿ×&Lÿq&Mÿ×&Nÿq&Oÿ×&Qÿ×&Rÿq&Sÿ×&Tÿq&Uÿ×&Vÿq&Wÿ×&Xÿq&Yÿ×&Zÿq&[ÿ×&\ÿq&]ÿ×&^ÿq&_ÿ×&`ÿq&bÿš&dÿš&fÿš&hÿš&jÿš&lÿš&nÿš&pÿ×&)')' )')' )(ÿ…(ÿ®(ÿ…(")($ÿq(&ÿ×(*ÿ×(2ÿ×(4ÿ×(7)(Dÿ\(Fÿq(Gÿq(Hÿq(Jÿq(Pÿš(Qÿš(Rÿq(Sÿš(Tÿq(Uÿš(Vÿ…(Xÿš(Yÿ×(Zÿ×([ÿ×(\ÿ×(]ÿ®(‚ÿq(ƒÿq(„ÿq(…ÿq(†ÿq(‡ÿq(‰ÿ×(”ÿ×(•ÿ×(–ÿ×(—ÿ×(˜ÿ×(šÿ×(¢ÿq(£ÿ\(¤ÿ\(¥ÿ\(¦ÿ\(§ÿ\(¨ÿ\(©ÿq(ªÿq(«ÿq(¬ÿq(­ÿq(´ÿq(µÿq(¶ÿq(·ÿq(¸ÿq(ºÿq(»ÿš(¼ÿš(½ÿš(¾ÿš(¿ÿ×(Âÿq(Ãÿ\(Äÿq(Åÿ\(Æÿq(Çÿ\(Èÿ×(Éÿq(Êÿ×(Ëÿq(Ìÿ×(Íÿq(Îÿ×(Ïÿq(Ñÿq(Óÿq(Õÿq(×ÿq(Ùÿq(Ûÿq(Ýÿq(Þÿ×(ßÿq(àÿ×(áÿq(âÿ×(ãÿq(äÿ×(åÿq(úÿš(ÿš(ÿš( ÿš(ÿ×(ÿq(ÿ×(ÿq(ÿ×(ÿq(ÿ×(ÿq(ÿš(ÿš(ÿ…(!ÿ…($)(&)(+ÿš(-ÿš(/ÿš(1ÿš(3ÿš(5ÿš(7ÿ×(<ÿ®(>ÿ®(@ÿ®(Cÿq(Dÿ\(Fÿ\(Gÿ×(Hÿq(Jÿ…(ûÿ×(ýÿ×(ÿ®(ÿ®(ÿ®(ÿ…( ÿ…(Wÿš(Xÿq(Yÿ\(_ÿ×(`ÿq(bÿš(ÿq(ÿ\(ÿq( ÿ\(!ÿq("ÿ\(#ÿq(%ÿq(&ÿ\('ÿq((ÿ\()ÿq(*ÿ\(+ÿq(,ÿ\(-ÿq(.ÿ\(/ÿq(0ÿ\(1ÿq(2ÿ\(3ÿq(4ÿ\(6ÿq(8ÿq(:ÿq(<ÿq(@ÿq(Bÿq(Dÿq(Iÿ×(Jÿq(Kÿ×(Lÿq(Mÿ×(Nÿq(Oÿ×(Qÿ×(Rÿq(Sÿ×(Tÿq(Uÿ×(Vÿq(Wÿ×(Xÿq(Yÿ×(Zÿq([ÿ×(\ÿq(]ÿ×(^ÿq(_ÿ×(`ÿq(bÿš(dÿš(fÿš(hÿš(jÿš(lÿš(nÿš(pÿ×()*ÿ×*ÿ×*$ÿì*‚ÿì*ƒÿì*„ÿì*…ÿì*†ÿì*‡ÿì*Âÿì*Äÿì*Æÿì*Cÿì*ÿ×* ÿ×*Xÿì*ÿì*ÿì*!ÿì*#ÿì*%ÿì*'ÿì*)ÿì*+ÿì*-ÿì*/ÿì*1ÿì*3ÿì,ÿ×,ÿ×,$ÿì,‚ÿì,ƒÿì,„ÿì,…ÿì,†ÿì,‡ÿì,Âÿì,Äÿì,Æÿì,Cÿì,ÿ×, ÿ×,Xÿì,ÿì,ÿì,!ÿì,#ÿì,%ÿì,'ÿì,)ÿì,+ÿì,-ÿì,/ÿì,1ÿì,3ÿì.ÿ×.ÿ×.$ÿì.‚ÿì.ƒÿì.„ÿì.…ÿì.†ÿì.‡ÿì.Âÿì.Äÿì.Æÿì.Cÿì.ÿ×. ÿ×.Xÿì.ÿì.ÿì.!ÿì.#ÿì.%ÿì.'ÿì.)ÿì.+ÿì.-ÿì./ÿì.1ÿì.3ÿì0ÿ×0ÿ×0$ÿì0‚ÿì0ƒÿì0„ÿì0…ÿì0†ÿì0‡ÿì0Âÿì0Äÿì0Æÿì0Cÿì0ÿ×0 ÿ×0Xÿì0ÿì0ÿì0!ÿì0#ÿì0%ÿì0'ÿì0)ÿì0+ÿì0-ÿì0/ÿì01ÿì03ÿì2ÿ×2ÿ×2$ÿì2‚ÿì2ƒÿì2„ÿì2…ÿì2†ÿì2‡ÿì2Âÿì2Äÿì2Æÿì2Cÿì2ÿ×2 ÿ×2Xÿì2ÿì2ÿì2!ÿì2#ÿì2%ÿì2'ÿì2)ÿì2+ÿì2-ÿì2/ÿì21ÿì23ÿì4ÿ×4ÿ×4$ÿì4‚ÿì4ƒÿì4„ÿì4…ÿì4†ÿì4‡ÿì4Âÿì4Äÿì4Æÿì4Cÿì4ÿ×4 ÿ×4Xÿì4ÿì4ÿì4!ÿì4#ÿì4%ÿì4'ÿì4)ÿì4+ÿì4-ÿì4/ÿì41ÿì43ÿì6ÿš6ÿš6")6$ÿ®6&ÿì6*ÿì62ÿì64ÿì6Dÿ×6Fÿ×6Gÿ×6Hÿ×6Jÿì6Pÿì6Qÿì6Rÿ×6Sÿì6Tÿ×6Uÿì6Vÿì6Xÿì6‚ÿ®6ƒÿ®6„ÿ®6…ÿ®6†ÿ®6‡ÿ®6‰ÿì6”ÿì6•ÿì6–ÿì6—ÿì6˜ÿì6šÿì6¢ÿ×6£ÿ×6¤ÿ×6¥ÿ×6¦ÿ×6§ÿ×6¨ÿ×6©ÿ×6ªÿ×6«ÿ×6¬ÿ×6­ÿ×6´ÿ×6µÿ×6¶ÿ×6·ÿ×6¸ÿ×6ºÿ×6»ÿì6¼ÿì6½ÿì6¾ÿì6Âÿ®6Ãÿ×6Äÿ®6Åÿ×6Æÿ®6Çÿ×6Èÿì6Éÿ×6Êÿì6Ëÿ×6Ìÿì6Íÿ×6Îÿì6Ïÿ×6Ñÿ×6Óÿ×6Õÿ×6×ÿ×6Ùÿ×6Ûÿ×6Ýÿ×6Þÿì6ßÿì6àÿì6áÿì6âÿì6ãÿì6äÿì6åÿì6úÿì6ÿì6ÿì6 ÿì6ÿì6ÿ×6ÿì6ÿ×6ÿì6ÿ×6ÿì6ÿ×6ÿì6ÿì6ÿì6!ÿì6+ÿì6-ÿì6/ÿì61ÿì63ÿì65ÿì6Cÿ®6Dÿ×6Fÿ×6Gÿì6Hÿ×6Jÿì6ÿš6 ÿš6Wÿì6Xÿ®6Yÿ×6_ÿì6`ÿ×6bÿì6ÿ®6ÿ×6ÿ®6 ÿ×6!ÿ®6"ÿ×6#ÿ®6%ÿ®6&ÿ×6'ÿ®6(ÿ×6)ÿ®6*ÿ×6+ÿ®6,ÿ×6-ÿ®6.ÿ×6/ÿ®60ÿ×61ÿ®62ÿ×63ÿ®64ÿ×66ÿ×68ÿ×6:ÿ×6<ÿ×6@ÿ×6Bÿ×6Dÿ×6Iÿì6Jÿ×6Kÿì6Lÿ×6Mÿì6Nÿ×6Oÿì6Qÿì6Rÿ×6Sÿì6Tÿ×6Uÿì6Vÿ×6Wÿì6Xÿ×6Yÿì6Zÿ×6[ÿì6\ÿ×6]ÿì6^ÿ×6_ÿì6`ÿ×6bÿì6dÿì6fÿì6hÿì6jÿì6lÿì6nÿì7R7 R7ÿ®7ÿ®7")7R7ÿ®7 R7 ÿ®8ÿ…8ÿ…8")8$ÿ…8&ÿ×8*ÿ×82ÿ×84ÿ×8Dÿš8Fÿš8Gÿš8Hÿš8Jÿ×8PÿÃ8QÿÃ8Rÿš8SÿÃ8Tÿš8UÿÃ8Vÿ®8XÿÃ8]ÿ×8‚ÿ…8ƒÿ…8„ÿ…8…ÿ…8†ÿ…8‡ÿ…8‰ÿ×8”ÿ×8•ÿ×8–ÿ×8—ÿ×8˜ÿ×8šÿ×8¢ÿš8£ÿš8¤ÿš8¥ÿš8¦ÿš8§ÿš8¨ÿš8©ÿš8ªÿš8«ÿš8¬ÿš8­ÿš8´ÿš8µÿš8¶ÿš8·ÿš8¸ÿš8ºÿš8»ÿÃ8¼ÿÃ8½ÿÃ8¾ÿÃ8Âÿ…8Ãÿš8Äÿ…8Åÿš8Æÿ…8Çÿš8Èÿ×8Éÿš8Êÿ×8Ëÿš8Ìÿ×8Íÿš8Îÿ×8Ïÿš8Ñÿš8Óÿš8Õÿš8×ÿš8Ùÿš8Ûÿš8Ýÿš8Þÿ×8ßÿ×8àÿ×8áÿ×8âÿ×8ãÿ×8äÿ×8åÿ×8úÿÃ8ÿÃ8ÿÃ8 ÿÃ8ÿ×8ÿš8ÿ×8ÿš8ÿ×8ÿš8ÿ×8ÿš8ÿÃ8ÿÃ8ÿ®8!ÿ®8+ÿÃ8-ÿÃ8/ÿÃ81ÿÃ83ÿÃ85ÿÃ8<ÿ×8>ÿ×8@ÿ×8Cÿ…8Dÿš8Fÿš8Gÿ×8Hÿš8Jÿ®8ÿ…8 ÿ…8WÿÃ8Xÿ…8Yÿš8_ÿ×8`ÿš8bÿÃ8ÿ…8ÿš8ÿ…8 ÿš8!ÿ…8"ÿš8#ÿ…8%ÿ…8&ÿš8'ÿ…8(ÿš8)ÿ…8*ÿš8+ÿ…8,ÿš8-ÿ…8.ÿš8/ÿ…80ÿš81ÿ…82ÿš83ÿ…84ÿš86ÿš88ÿš8:ÿš8<ÿš8@ÿš8Bÿš8Dÿš8Iÿ×8Jÿš8Kÿ×8Lÿš8Mÿ×8Nÿš8Oÿ×8Qÿ×8Rÿš8Sÿ×8Tÿš8Uÿ×8Vÿš8Wÿ×8Xÿš8Yÿ×8Zÿš8[ÿ×8\ÿš8]ÿ×8^ÿš8_ÿ×8`ÿš8bÿÃ8dÿÃ8fÿÃ8hÿÃ8jÿÃ8lÿÃ8nÿÃ9R9 R9ÿ®9ÿ®9")9R9ÿ®9 R9 ÿ®:ÿ…:ÿ…:"):$ÿ…:&ÿ×:*ÿ×:2ÿ×:4ÿ×:Dÿš:Fÿš:Gÿš:Hÿš:Jÿ×:PÿÃ:QÿÃ:Rÿš:SÿÃ:Tÿš:UÿÃ:Vÿ®:XÿÃ:]ÿ×:‚ÿ…:ƒÿ…:„ÿ…:…ÿ…:†ÿ…:‡ÿ…:‰ÿ×:”ÿ×:•ÿ×:–ÿ×:—ÿ×:˜ÿ×:šÿ×:¢ÿš:£ÿš:¤ÿš:¥ÿš:¦ÿš:§ÿš:¨ÿš:©ÿš:ªÿš:«ÿš:¬ÿš:­ÿš:´ÿš:µÿš:¶ÿš:·ÿš:¸ÿš:ºÿš:»ÿÃ:¼ÿÃ:½ÿÃ:¾ÿÃ:Âÿ…:Ãÿš:Äÿ…:Åÿš:Æÿ…:Çÿš:Èÿ×:Éÿš:Êÿ×:Ëÿš:Ìÿ×:Íÿš:Îÿ×:Ïÿš:Ñÿš:Óÿš:Õÿš:×ÿš:Ùÿš:Ûÿš:Ýÿš:Þÿ×:ßÿ×:àÿ×:áÿ×:âÿ×:ãÿ×:äÿ×:åÿ×:úÿÃ:ÿÃ:ÿÃ: ÿÃ:ÿ×:ÿš:ÿ×:ÿš:ÿ×:ÿš:ÿ×:ÿš:ÿÃ:ÿÃ:ÿ®:!ÿ®:+ÿÃ:-ÿÃ:/ÿÃ:1ÿÃ:3ÿÃ:5ÿÃ:<ÿ×:>ÿ×:@ÿ×:Cÿ…:Dÿš:Fÿš:Gÿ×:Hÿš:Jÿ®:ÿ…: ÿ…:WÿÃ:Xÿ…:Yÿš:_ÿ×:`ÿš:bÿÃ:ÿ…:ÿš:ÿ…: ÿš:!ÿ…:"ÿš:#ÿ…:%ÿ…:&ÿš:'ÿ…:(ÿš:)ÿ…:*ÿš:+ÿ…:,ÿš:-ÿ…:.ÿš:/ÿ…:0ÿš:1ÿ…:2ÿš:3ÿ…:4ÿš:6ÿš:8ÿš::ÿš:<ÿš:@ÿš:Bÿš:Dÿš:Iÿ×:Jÿš:Kÿ×:Lÿš:Mÿ×:Nÿš:Oÿ×:Qÿ×:Rÿš:Sÿ×:Tÿš:Uÿ×:Vÿš:Wÿ×:Xÿš:Yÿ×:Zÿš:[ÿ×:\ÿš:]ÿ×:^ÿš:_ÿ×:`ÿš:bÿÃ:dÿÃ:fÿÃ:hÿÃ:jÿÃ:lÿÃ:nÿÃ;&ÿì;*ÿì;2ÿì;4ÿì;‰ÿì;”ÿì;•ÿì;–ÿì;—ÿì;˜ÿì;šÿì;Èÿì;Êÿì;Ìÿì;Îÿì;Þÿì;àÿì;âÿì;äÿì;ÿì;ÿì;ÿì;ÿì;Gÿì;_ÿì;Iÿì;Kÿì;Mÿì;Oÿì;Qÿì;Sÿì;Uÿì;Wÿì;Yÿì;[ÿì;]ÿì;_ÿì=&ÿì=*ÿì=2ÿì=4ÿì=‰ÿì=”ÿì=•ÿì=–ÿì=—ÿì=˜ÿì=šÿì=Èÿì=Êÿì=Ìÿì=Îÿì=Þÿì=àÿì=âÿì=äÿì=ÿì=ÿì=ÿì=ÿì=Gÿì=_ÿì=Iÿì=Kÿì=Mÿì=Oÿì=Qÿì=Sÿì=Uÿì=Wÿì=Yÿì=[ÿì=]ÿì=_ÿì?&ÿì?*ÿì?2ÿì?4ÿì?‰ÿì?”ÿì?•ÿì?–ÿì?—ÿì?˜ÿì?šÿì?Èÿì?Êÿì?Ìÿì?Îÿì?Þÿì?àÿì?âÿì?äÿì?ÿì?ÿì?ÿì?ÿì?Gÿì?_ÿì?Iÿì?Kÿì?Mÿì?Oÿì?Qÿì?Sÿì?Uÿì?Wÿì?Yÿì?[ÿì?]ÿì?_ÿìCÿqC ÿqC&ÿ×C*ÿ×C- C2ÿ×C4ÿ×C7ÿqC9ÿ®C:ÿ®C<ÿ…C‰ÿ×C”ÿ×C•ÿ×C–ÿ×C—ÿ×C˜ÿ×Cšÿ×CŸÿ…CÈÿ×CÊÿ×CÌÿ×CÎÿ×CÞÿ×Càÿ×Câÿ×Cäÿ×Cÿ×Cÿ×Cÿ×Cÿ×C$ÿqC&ÿqC6ÿ®C8ÿ…C:ÿ…CGÿ×Cúÿ®Cüÿ®Cþÿ®Cÿ…CÿqC ÿqC_ÿ×CIÿ×CKÿ×CMÿ×COÿ×CQÿ×CSÿ×CUÿ×CWÿ×CYÿ×C[ÿ×C]ÿ×C_ÿ×Coÿ…Cqÿ…Csÿ…CÿqDÿìD ÿìDÿìD ÿìE-{Gÿ®Gÿ®G$ÿ×G7ÿÃG9ÿìG:ÿìG;ÿ×G<ÿìG=ÿìG‚ÿ×Gƒÿ×G„ÿ×G…ÿ×G†ÿ×G‡ÿ×GŸÿìGÂÿ×GÄÿ×GÆÿ×G$ÿÃG&ÿÃG6ÿìG8ÿìG:ÿìG;ÿìG=ÿìG?ÿìGCÿ×G ÿìGúÿìGüÿìGþÿìGÿìGÿ®G ÿ®GXÿ×Gÿ×Gÿ×G!ÿ×G#ÿ×G%ÿ×G'ÿ×G)ÿ×G+ÿ×G-ÿ×G/ÿ×G1ÿ×G3ÿ×GoÿìGqÿìGsÿìGÿÃVÿqV ÿqVfÿ×Vmÿ×VqÿqVrÿ…Vsÿ×Vuÿ®Vxÿ…VÿqV ÿqVTÿ…[ÿ®[ÿ®[Vÿ×[_ÿ×[bÿ×[dÿì[iÿ×[pÿì[qÿÃ[rÿì[tÿ×[uÿì[xÿì[ˆÿì[ÿ®[ ÿ®[Tÿì\ÿ…\ÿ…\Vÿ…\_ÿ…\bÿ…\fÿ×\iÿ…\mÿ×\sÿÃ\vÿì\yÿš\zÿ®\{ÿÃ\|ÿÃ\}ÿÃ\~ÿš\ÿÃ\‚ÿ®\„ÿÃ\†ÿÃ\‡ÿÃ\‰ÿÃ\Œÿš\Žÿš\ÿš\ÿš\’ÿÃ\“ÿš\•ÿÃ\–ÿÃ\˜ÿÃ\™ÿš\šÿÃ\›ÿÃ\ÿ…\ ÿ…\!ÿì]qÿ×]rÿì]xÿì]Tÿì^ÿ×^ ÿ×^ÿ×^ ÿ×_ÿq_ ÿq_fÿ×_mÿ×_qÿq_rÿ…_sÿ×_uÿ®_xÿ…_ÿq_ ÿq_Tÿ…`ÿ®`ÿ®`Vÿ×`_ÿ×`bÿ×`iÿ×`tÿ×`ÿ®` ÿ®aÿ…aÿ®aÿ…aVÿ\a_ÿ\abÿ\afÿÃaiÿ\amÿÃasÿšavÿÃayÿqazÿša{ÿša|ÿ®a}ÿša~ÿqa€ÿ×aÿÃa‚ÿša„ÿša†ÿ®a‡ÿša‰ÿšaŠÿ×aŒÿqaŽÿšaÿqaÿqa’ÿša“ÿqa”ÿ×a•ÿša–ÿša˜ÿša™ÿqašÿša›ÿšaÿ®aÿ®aÿ®aÿ…a ÿ…a!ÿÃaSÿ×bÿqb ÿqbfÿ×bmÿ×bqÿqbrÿ…bsÿ×buÿ®bxÿ…bÿqb ÿqbTÿ…dfÿìdmÿìdsÿÃfÿ®fÿ®fVÿ×f_ÿ×fbÿ×fdÿìfiÿ×fpÿìfqÿÃfrÿìftÿ×fuÿìfxÿìfˆÿìfÿ®f ÿ®fTÿìhfÿ×hmÿ×hsÿÃhÿìh‘ÿìiÿqi ÿqifÿ×imÿ×iqÿqirÿ…isÿ×iuÿ®ixÿ…iÿqi ÿqiTÿ…mÿ®mÿ®mVÿ×m_ÿ×mbÿ×mdÿìmiÿ×mpÿìmqÿÃmrÿìmtÿ×muÿìmxÿìmˆÿìmÿ®m ÿ®mTÿìoþöoþöoVÿšo_ÿšobÿšodÿìoiÿšotÿ×oˆÿ×oþöo þöqÿ…qÿ®qÿ…qVÿ\q_ÿ\qbÿ\qfÿÃqiÿ\qmÿÃqsÿšqvÿÃqyÿqqzÿšq{ÿšq|ÿ®q}ÿšq~ÿqq€ÿ×qÿÃq‚ÿšq„ÿšq†ÿ®q‡ÿšq‰ÿšqŠÿ×qŒÿqqŽÿšqÿqqÿqq’ÿšq“ÿqq”ÿ×q•ÿšq–ÿšq˜ÿšq™ÿqqšÿšq›ÿšqÿ®qÿ®qÿ®qÿ…q ÿ…q!ÿÃqSÿ×rÿ…rÿ…rVÿ…r_ÿ…rbÿ…rfÿ×riÿ…rmÿ×rsÿÃrvÿìryÿšrzÿ®r{ÿÃr|ÿÃr}ÿÃr~ÿšrÿÃr‚ÿ®r„ÿÃr†ÿÃr‡ÿÃr‰ÿÃrŒÿšrŽÿšrÿšrÿšr’ÿÃr“ÿšr•ÿÃr–ÿÃr˜ÿÃr™ÿšršÿÃr›ÿÃrÿ…r ÿ…r!ÿìsÿšsÿšsVÿ×s_ÿ×sbÿ×sdÿÃsiÿ×spÿìsqÿ®srÿÃstÿìsxÿÃsˆÿìsÿšs ÿšsTÿÃtfÿ×tmÿ×tsÿÃtÿìt‘ÿìuÿ…uÿ…uVÿ®u_ÿ®ubÿ®ufÿìuiÿ®umÿìuÿ…u ÿ…vqÿ×vrÿìvxÿìvTÿìxÿ…xÿ…xVÿ…x_ÿ…xbÿ…xfÿ×xiÿ…xmÿ×xsÿÃxvÿìxyÿšxzÿ®x{ÿÃx|ÿÃx}ÿÃx~ÿšxÿÃx‚ÿ®x„ÿÃx†ÿÃx‡ÿÃx‰ÿÃxŒÿšxŽÿšxÿšxÿšx’ÿÃx“ÿšx•ÿÃx–ÿÃx˜ÿÃx™ÿšxšÿÃx›ÿÃxÿ…x ÿ…x!ÿìyˆ){ÿì{ ÿì{ÿì{ ÿì|ÿ®| ÿ®|ÿì|‘ÿì|ÿ®| ÿ®~ˆ)€ÿ®€ÿ®€ˆÿì€ÿ®€ ÿ®ƒÿšƒyÿ׃~ÿ׃ÿ׃Œÿ׃ÿ׃ÿ׃ÿ׃‘ÿ׃“ÿ׃™ÿ׃ÿšƒÿšƒÿš„ÿì„ ÿì„ÿì„ ÿì…ÿ×…ÿ×…ÿ×… ÿ׆ÿ®† ÿ®†ÿ솑ÿì†ÿ®† ÿ®‡yÿׇ~ÿׇŒÿׇÿׇÿׇ“ÿׇ™ÿ׈ÿ…ˆ ÿ…ˆyÿìˆ~ÿ숀ÿ׈Šÿ׈Œÿìˆÿ׈ÿìˆÿ숑ÿ׈“ÿ숙ÿìˆÿ…ˆ ÿ…Šÿ®Šÿ®ŠˆÿìŠÿ®Š ÿ®ŒÿìŒ ÿ쌀ÿ׌Šÿ׌ÿìŒ ÿìŽÿìŽ ÿ쎀ÿ׎Šÿ׎ÿìŽ ÿìÿìÿìÿì ÿì“ÿì“ ÿì“€ÿדŠÿדÿì“ ÿì”ÿÔÿ×”ÿÔyÿ×”~ÿ×”ÿ×”Œÿ×”ÿ×”ÿ×”“ÿ×”™ÿ×”ÿ×”ÿ×”ÿ×”ÿÔ ÿ×ÿ×— ÿ×—ÿ×— ÿ×™ÿì™ ÿ와ÿ×™Šÿ×™ÿì™ ÿìÿ® ÿ®ÿ…¦ÿ…¨ÿ×¼ÿš½ÿ×ÁÿšÄÿ…Üÿ×Ýÿ×áÿ×äÿ×öÿ×ÿ® ÿ®nÿ®|ÿš€ÿ®‚ÿ®—ÿ®›ÿ®§ÿ®©ÿ…ªÿ×µÿš¶ÿ×·ÿš¸ÿ×¹ÿšºÿ×½ÿ…¾ÿ׿ÿšÀÿ×ÁÿšÂÿ×ÔÿšÕÿ×÷ÿ×øÿ×ùÿ×úÿ×ûÿ×üÿ×ýÿšþÿ×ÿ® ÿšÿÃÿšÿÃÿ…ÿמÿ…žÿ®žÿ…žŸÿמ¤ÿšžªÿqž®ÿšžµÿšž¸ÿמ»ÿמ¼)ž¾ÿ®žÌÿšžÍÿšžÎÿ…žÏÿqžÐÿמÑÿמÒÿšžÓÿšžÔÿšžÕÿ…žÖÿšž×ÿšžØÿqžÙÿšžÚÿšžÛÿqžÜÿ®žÝÿ®žÞÿqžßÿמàÿšžáÿšžâÿšžãÿšžäÿ®žåÿšžæÿšžçÿמèÿšžéÿÞêÿqžìÿšžíÿqžîÿ…žòÿ…žóÿšžõÿšžöÿ®ž÷ÿšžùÿšžÿ®žÿ®žÿ®žÿ…ž ÿ…žjÿqžkÿšžlÿמmÿמqÿšžrÿqžsÿ…žuÿšžwÿšžyÿšž}ÿšž~ÿמÿqžÿמƒÿמ„ÿמ…ÿqž†ÿמ‡ÿqžˆÿמ‰ÿqžŠÿמ‹ÿמŒÿמÿqž–ÿšžšÿšžžÿšž ÿמ¢ÿמ¤ÿšž¦ÿšžªÿ®ž¬ÿšž®ÿšž°ÿšž±ÿמ²ÿqž³ÿמ´ÿqžµ)ž¶ÿ®ž¸ÿ®žºÿ®ž¼ÿמ¾ÿ®žÀÿšžÂÿšžÄÿšžÅÿšžÆÿqžÇÿšžÈÿqžËÿמÍÿšžÎÿšžÏÿ…žÑÿšžÓÿšžÕÿšž×ÿšžÙÿqžÛÿqžÝÿqžàÿqžæÿמèÿמêÿÞìÿšžîÿšžïÿמðÿqžñÿמòÿqžóÿמôÿqžöÿמøÿ®žúÿ®žüÿ®žþÿšžÿšžÿšžÿמÿמ ÿqž ÿqž ÿqž ÿqžÿšžÿšžÿšžÿ…žÿšžÿמÿqžÿ®žÿqžÿšžÿ…ŸŸÿן¸ÿן»ÿן¾ÿןáÿןlÿן~ÿן„ÿן†ÿןˆÿןŠÿןŒÿן±ÿן³ÿןÀÿןÂÿןÅÿןÇÿןÕÿןïÿןñÿןóÿןþÿן ÿן ÿןÿןÿןÿ× ÿ× ÿפÿ®¤ ÿ®¤ÿ…¤¦ÿ…¤¨ÿפ¼ÿš¤½ÿפÁÿš¤Äÿ…¤ÜÿפÝÿפáÿפäÿפöÿפÿ®¤ ÿ®¤nÿ®¤|ÿš¤€ÿ®¤‚ÿ®¤—ÿ®¤›ÿ®¤§ÿ®¤©ÿ…¤ªÿפµÿš¤¶ÿפ·ÿš¤¸ÿפ¹ÿš¤ºÿפ½ÿ…¤¾ÿפ¿ÿš¤ÀÿפÁÿš¤ÂÿפÔÿš¤Õÿפ÷ÿפøÿפùÿפúÿפûÿפüÿפýÿš¤þÿפÿ®¤ ÿš¤ÿäÿš¤ÿäÿ…¤ÿ×¥ÿ®¥ ÿ®¥ÿ…¥¦ÿ…¥¨ÿ×¥¼ÿš¥½ÿ×¥Áÿš¥Äÿ…¥Üÿ×¥Ýÿ×¥áÿ×¥äÿ×¥öÿ×¥ÿ®¥ ÿ®¥nÿ®¥|ÿš¥€ÿ®¥‚ÿ®¥—ÿ®¥›ÿ®¥§ÿ®¥©ÿ…¥ªÿ×¥µÿš¥¶ÿ×¥·ÿš¥¸ÿ×¥¹ÿš¥ºÿ×¥½ÿ…¥¾ÿ×¥¿ÿš¥Àÿ×¥Áÿš¥Âÿ×¥Ôÿš¥Õÿ×¥÷ÿ×¥øÿ×¥ùÿ×¥úÿ×¥ûÿ×¥üÿ×¥ýÿš¥þÿ×¥ÿ®¥ ÿš¥ÿÃ¥ÿš¥ÿÃ¥ÿ…¥ÿצÿ®¦ ÿ®¦ÿ…¦¦ÿ…¦¨ÿצ¼ÿš¦½ÿצÁÿš¦Äÿ…¦ÜÿצÝÿצáÿצäÿצöÿצÿ®¦ ÿ®¦nÿ®¦|ÿš¦€ÿ®¦‚ÿ®¦—ÿ®¦›ÿ®¦§ÿ®¦©ÿ…¦ªÿצµÿš¦¶ÿצ·ÿš¦¸ÿצ¹ÿš¦ºÿצ½ÿ…¦¾ÿצ¿ÿš¦ÀÿצÁÿš¦ÂÿצÔÿš¦Õÿצ÷ÿצøÿצùÿצúÿצûÿצüÿצýÿš¦þÿצÿ®¦ ÿš¦ÿæÿš¦ÿæÿ…¦ÿקŸÿק¸ÿק»ÿק¾ÿקÁÿקáÿקlÿק|ÿק~ÿק„ÿק†ÿקˆÿקŠÿקŒÿק±ÿק³ÿק¿ÿקÀÿקÁÿקÂÿקÅÿš§Çÿš§ÔÿקÕÿקïÿקñÿקóÿקýÿקþÿק ÿק ÿקÿקÿקÿקÿì¨ÿ…¨ÿ…¨Ÿÿ쨤ÿš¨ªÿq¨®ÿš¨µÿš¨¸ÿ쨻ÿ쨾ÿèÉÿì¨Îÿ®¨ÏÿרÕÿ®¨ØÿרÛÿרÞÿרáÿרêÿרëf¨íÿרîÿì¨òÿ®¨ôf¨ÿ…¨ ÿ…¨jÿרlÿì¨rÿq¨sÿ®¨~ÿì¨ÿר„ÿ쨅ÿר†ÿ쨇ÿרˆÿ쨉ÿרŠÿ쨌ÿì¨ÿר˜f¨¨f¨±ÿ쨲ÿר³ÿ쨴ÿרÀÿרÂÿרÅÿרÆÿèÇÿרÈÿèÎÿš¨Ïÿ®¨ÕÿרÙÿq¨Ûÿq¨Ýÿq¨àÿרïÿì¨ðÿרñÿì¨òÿרóÿì¨ôÿרþÿר ÿq¨ ÿר ÿq¨ ÿרÿš¨ÿ®¨ÿì¨ÿרÿרÿš¨ÿ®ªÿqª ÿqªÿšª¦ÿšª¼ÿqª¾ÿתÁÿšªÄÿšªÜÿתáÿתäÿתÿqª ÿqªnÿת|ÿšª€ÿ®ª‚ÿ®ª—ÿת›ÿת§ÿת©ÿšªªÿתµÿqª¶ÿת·ÿ…ª¹ÿ…ª½ÿšª¾ÿת¿ÿšªÀÿתÁÿšªÂÿתÅÿšªÇÿšªÔÿšªÕÿתáÿתãÿתýÿšªþÿתÿת ÿqªÿתÿqªÿתÿšªÿ׫ÿ׫ ÿ׫ªÿì«Áÿ׫ÿ׫ ÿ׫rÿì«|ÿ׫¿ÿ׫Áÿ׫Åÿ׫Çÿ׫Ôÿ׫Ùÿì«Ûÿì«Ýÿì«ýÿ׬ÿ®¬ÿ®¬ÿ®¬ ÿ®¬€ÿ쬂ÿ쬷ÿ쬹ÿì¬ ÿ׬ÿ×­ÿ…­ÿ®­ÿ…­Ÿÿ×­¤ÿš­ªÿq­®ÿš­µÿš­¸ÿ×­»ÿ×­¼)­¾ÿ®­Ìÿš­Íÿš­Îÿ…­Ïÿq­Ðÿ×­Ñÿ×­Òÿš­Óÿš­Ôÿš­Õÿ…­Öÿš­×ÿš­Øÿq­Ùÿš­Úÿš­Ûÿq­Üÿ®­Ýÿ®­Þÿq­ßÿ×­àÿš­áÿš­âÿš­ãÿš­äÿ®­åÿš­æÿš­çÿ×­èÿš­éÿíêÿq­ìÿš­íÿq­îÿ…­òÿ…­óÿš­õÿš­öÿ®­÷ÿš­ùÿš­ÿ®­ÿ®­ÿ®­ÿ…­ ÿ…­jÿq­kÿš­lÿ×­mÿ×­qÿš­rÿq­sÿ…­uÿš­wÿš­yÿš­}ÿš­~ÿ×­ÿq­ÿ×­ƒÿ×­„ÿ×­…ÿq­†ÿ×­‡ÿq­ˆÿ×­‰ÿq­Šÿ×­‹ÿ×­Œÿ×­ÿq­–ÿš­šÿš­žÿš­ ÿ×­¢ÿ×­¤ÿš­¦ÿš­ªÿ®­¬ÿš­®ÿš­°ÿš­±ÿ×­²ÿq­³ÿ×­´ÿq­µ)­¶ÿ®­¸ÿ®­ºÿ®­¼ÿ×­¾ÿ®­Àÿš­Âÿš­Äÿš­Åÿš­Æÿq­Çÿš­Èÿq­Ëÿ×­Íÿš­Îÿš­Ïÿ…­Ñÿš­Óÿš­Õÿš­×ÿš­Ùÿq­Ûÿq­Ýÿq­àÿq­æÿ×­èÿ×­êÿíìÿš­îÿš­ïÿ×­ðÿq­ñÿ×­òÿq­óÿ×­ôÿq­öÿ×­øÿ®­úÿ®­üÿ®­þÿš­ÿš­ÿš­ÿ×­ÿ×­ ÿq­ ÿq­ ÿq­ ÿq­ÿš­ÿš­ÿš­ÿ…­ÿš­ÿ×­ÿq­ÿ®­ÿq­ÿš­ÿ…®£á®ê)®ÿ×®ÿ×°Ÿÿ×°¸ÿ×°»ÿ×°¾ÿ×°Áÿ×°áÿ×°lÿ×°|ÿ×°~ÿ×°„ÿ×°†ÿ×°ˆÿ×°Šÿ×°Œÿ×°±ÿ×°³ÿ×°¿ÿ×°Àÿ×°Áÿ×°Âÿ×°Åÿš°Çÿš°Ôÿ×°Õÿ×°ïÿ×°ñÿ×°óÿ×°ýÿ×°þÿ×° ÿ×° ÿ×°ÿ×°ÿ×°ÿ×°ÿì±ÿ®±ÿ®±ÿ®± ÿ®±€ÿ챂ÿì±·ÿì±¹ÿì± ÿ×±ÿ×´Ÿÿ×´¸ÿ×´»ÿ×´¾ÿ×´Áÿ×´áÿ×´lÿ×´|ÿ×´~ÿ×´„ÿ×´†ÿ×´ˆÿ×´Šÿ×´Œÿ×´±ÿ×´³ÿ×´¿ÿ×´Àÿ×´Áÿ×´Âÿ×´Åÿš´Çÿš´Ôÿ×´Õÿ×´ïÿ×´ñÿ×´óÿ×´ýÿ×´þÿ×´ ÿ×´ ÿ×´ÿ×´ÿ×´ÿ×´ÿì¸ÿ®¸ÿ®¸ÿ츤ÿ׸¦ÿ츨ÿ׸ªÿ׸®ÿ׸°ÿ׸±ÿ층ÿ׸¼ÿø½ÿ׸¿ÿ׸Áÿ׸Äÿì¸Çÿì¸Îÿì¸Õÿì¸òÿì¸ÿ®¸ ÿ®¸rÿ׸sÿì¸zÿì¸|ÿ׸€ÿ츂ÿ츟ÿ׸¡ÿ츩ÿ층ÿø·ÿ츹ÿ츻ÿ׸½ÿ츿ÿ׸Áÿ׸Êÿ׸Îÿ׸Ïÿì¸Ôÿ׸Ùÿ׸Ûÿ׸Ýÿ׸åÿ׸çÿì¸õÿì¸÷ÿ׸ùÿ׸ûÿ׸ýÿ׸ÿ׸ÿ׸ ÿ׸ÿ׸ÿ׸ÿì¸ÿì¸ÿ׸ÿìºþöºþöº¤ÿ…ºªÿšº®ÿ…º°ÿ׺µÿ…º¿ÿ׺ÎÿšºÕÿšºòÿšºþöº þöºrÿšºsÿšºvÿ캟ÿ׺»ÿ׺Êÿ׺Îÿ…ºÏÿšºÙÿšºÛÿšºÝÿšºåÿ׺ÿ׺ÿ׺ ÿ®º ÿ®ºÿ…ºÿšºÿ…ºÿš»Ÿÿ×»¸ÿ×»»ÿ×»¾ÿ×»áÿ×»lÿ×»~ÿ×»„ÿ×»†ÿ×»ˆÿ×»Šÿ×»Œÿ×»±ÿ×»³ÿ×»Àÿ×»Âÿ×»Åÿ×»Çÿ×»Õÿ×»ïÿ×»ñÿ×»óÿ×»þÿ×» ÿ×» ÿ×»ÿ×»ÿ×»ÿ×¼ÿ…¼ÿ®¼ÿ…¼Ÿÿ×¼¤ÿš¼ªÿq¼®ÿš¼µÿš¼¸ÿ×¼»ÿ×¼¼)¼¾ÿ®¼Ìÿš¼Íÿš¼Îÿ…¼Ïÿq¼Ðÿ×¼Ñÿ×¼Òÿš¼Óÿš¼Ôÿš¼Õÿ…¼Öÿš¼×ÿš¼Øÿq¼Ùÿš¼Úÿš¼Ûÿq¼Üÿ®¼Ýÿ®¼Þÿq¼ßÿ×¼àÿš¼áÿš¼âÿš¼ãÿš¼äÿ®¼åÿš¼æÿš¼çÿ×¼èÿš¼éÿüêÿq¼ìÿš¼íÿq¼îÿ…¼òÿ…¼óÿš¼õÿš¼öÿ®¼÷ÿš¼ùÿš¼ÿ®¼ÿ®¼ÿ®¼ÿ…¼ ÿ…¼jÿq¼kÿš¼lÿ×¼mÿ×¼qÿš¼rÿq¼sÿ…¼uÿš¼wÿš¼yÿš¼}ÿš¼~ÿ×¼ÿq¼ÿ×¼ƒÿ×¼„ÿ×¼…ÿq¼†ÿ×¼‡ÿq¼ˆÿ×¼‰ÿq¼Šÿ×¼‹ÿ×¼Œÿ×¼ÿq¼–ÿš¼šÿš¼žÿš¼ ÿ×¼¢ÿ×¼¤ÿš¼¦ÿš¼ªÿ®¼¬ÿš¼®ÿš¼°ÿš¼±ÿ×¼²ÿq¼³ÿ×¼´ÿq¼µ)¼¶ÿ®¼¸ÿ®¼ºÿ®¼¼ÿ×¼¾ÿ®¼Àÿš¼Âÿš¼Äÿš¼Åÿš¼Æÿq¼Çÿš¼Èÿq¼Ëÿ×¼Íÿš¼Îÿš¼Ïÿ…¼Ñÿš¼Óÿš¼Õÿš¼×ÿš¼Ùÿq¼Ûÿq¼Ýÿq¼àÿq¼æÿ×¼èÿ×¼êÿüìÿš¼îÿš¼ïÿ×¼ðÿq¼ñÿ×¼òÿq¼óÿ×¼ôÿq¼öÿ×¼øÿ®¼úÿ®¼üÿ®¼þÿš¼ÿš¼ÿš¼ÿ×¼ÿ×¼ ÿq¼ ÿq¼ ÿq¼ ÿq¼ÿš¼ÿš¼ÿš¼ÿ…¼ÿš¼ÿ×¼ÿq¼ÿ®¼ÿq¼ÿš¼ÿ…½ÿ…½ÿ…½Ÿÿ콤ÿš½ªÿq½®ÿš½µÿš½¸ÿì½»ÿì½¾ÿýÉÿì½Îÿ®½Ïÿ×½Õÿ®½Øÿ×½Ûÿ×½Þÿ×½áÿ×½êÿ×½ëf½íÿ×½îÿì½òÿ®½ôf½ÿ…½ ÿ…½jÿ×½lÿì½rÿq½sÿ®½~ÿì½ÿ×½„ÿì½…ÿ×½†ÿ콇ÿ×½ˆÿ콉ÿ×½Šÿ콌ÿì½ÿ×½˜f½¨f½±ÿì½²ÿ×½³ÿì½´ÿ×½Àÿ×½Âÿ×½Åÿ×½ÆÿýÇÿ×½ÈÿýÎÿš½Ïÿ®½Õÿ×½Ùÿq½Ûÿq½Ýÿq½àÿ×½ïÿì½ðÿ×½ñÿì½òÿ×½óÿì½ôÿ×½þÿ×½ ÿq½ ÿ×½ ÿq½ ÿ×½ÿš½ÿ®½ÿì½ÿ×½ÿ×½ÿš½ÿ®¾ÿ®¾ÿ®¾ÿ×¾¤ÿ×¾¦ÿ×¾¨ÿþªÿ×¾®ÿ×¾°ÿ×¾±ÿ×¾µÿ×¾¼ÿþ½ÿþ¿ÿ×¾Äÿ×¾Çÿ×¾Îÿì¾Õÿì¾òÿì¾ÿ®¾ ÿ®¾rÿ×¾sÿì¾zÿ×¾€ÿ쾂ÿ쾟ÿ×¾¡ÿ×¾©ÿ×¾µÿþ·ÿþ¹ÿþ»ÿ×¾½ÿ×¾Êÿ×¾Îÿ×¾Ïÿì¾Ùÿ×¾Ûÿ×¾Ýÿ×¾åÿ×¾çÿ×¾õÿ×¾÷ÿþùÿþûÿþÿ×¾ÿ×¾ ÿ×¾ÿ×¾ÿ×¾ÿì¾ÿ×¾ÿ×¾ÿì¿Ÿÿ׿¸ÿ׿»ÿ׿¾ÿ׿Áÿ׿áÿ׿lÿ׿|ÿ׿~ÿ׿„ÿ׿†ÿ׿ˆÿ׿Šÿ׿Œÿ׿±ÿ׿³ÿ׿¿ÿ׿Àÿ׿Áÿ׿Âÿ׿Åÿš¿Çÿš¿Ôÿ׿Õÿ׿ïÿ׿ñÿ׿óÿ׿ýÿ׿þÿ׿ ÿ׿ ÿ׿ÿ׿ÿ׿ÿ׿ÿìÀ£áÀê)Àÿ×Àÿ×ãáÃê)Ãÿ×Ãÿ×Äÿ®Ä ÿ®Äÿ…Ħÿ…Ĩÿ×ļÿšÄ½ÿ×ÄÁÿšÄÄÿ…ÄÜÿ×ÄÝÿ×Äáÿ×Ääÿ×Äöÿ×Äÿ®Ä ÿ®Änÿ®Ä|ÿšÄ€ÿ®Ä‚ÿ®Ä—ÿ®Ä›ÿ®Ä§ÿ®Ä©ÿ…Īÿ×ĵÿšÄ¶ÿ×Ä·ÿšÄ¸ÿ×ĹÿšÄºÿ׼ÿ…ľÿ×Ä¿ÿšÄÀÿ×ÄÁÿšÄÂÿ×ÄÔÿšÄÕÿ×Ä÷ÿ×Äøÿ×Äùÿ×Äúÿ×Äûÿ×Äüÿ×ÄýÿšÄþÿ×Äÿ®Ä ÿšÄÿÃÄÿšÄÿÃÄÿ…Äÿ×Æÿ®Æ ÿ®Æÿ…Ʀÿ…ƨÿ×ƼÿšÆ½ÿ×ÆÁÿšÆÄÿ…ÆÜÿ×ÆÝÿ×Æáÿ×Æäÿ×Æöÿ×Æÿ®Æ ÿ®Ænÿ®Æ|ÿšÆ€ÿ®Æ‚ÿ®Æ—ÿ®Æ›ÿ®Æ§ÿ®Æ©ÿ…ƪÿ×ƵÿšÆ¶ÿ×Æ·ÿšÆ¸ÿ×ƹÿšÆºÿ×ƽÿ…ƾÿ×Æ¿ÿšÆÀÿ×ÆÁÿšÆÂÿ×ÆÔÿšÆÕÿ×Æ÷ÿ×Æøÿ×Æùÿ×Æúÿ×Æûÿ×Æüÿ×ÆýÿšÆþÿ×Æÿ®Æ ÿšÆÿÃÆÿšÆÿÃÆÿ…Æÿ×Çÿ®Çÿ®ÇÿìǤÿ×ǦÿìǨÿ×Ǫÿ×Ç®ÿ×Ç°ÿ×DZÿìǵÿ×ǼÿÃǽÿ×Ç¿ÿ×ÇÁÿ×ÇÄÿìÇÇÿìÇÎÿìÇÕÿìÇòÿìÇÿ®Ç ÿ®Çrÿ×ÇsÿìÇzÿìÇ|ÿ×Ç€ÿìÇ‚ÿìÇŸÿ×Ç¡ÿìÇ©ÿìǵÿÃÇ·ÿìǹÿìÇ»ÿ×ǽÿìÇ¿ÿ×ÇÁÿ×ÇÊÿ×ÇÎÿ×ÇÏÿìÇÔÿ×ÇÙÿ×ÇÛÿ×ÇÝÿ×Çåÿ×ÇçÿìÇõÿìÇ÷ÿ×Çùÿ×Çûÿ×Çýÿ×Çÿ×Çÿ×Ç ÿ×Çÿ×Çÿ×ÇÿìÇÿìÇÿ×ÇÿìÈÿ®Èÿ®ÈÿìȤÿ×ȦÿìȨÿ×Ȫÿ×È®ÿ×È°ÿ×ȱÿìȵÿ×ȼÿÃȽÿ×È¿ÿ×ÈÁÿ×ÈÄÿìÈÇÿìÈÎÿìÈÕÿìÈòÿìÈÿ®È ÿ®Èrÿ×ÈsÿìÈzÿìÈ|ÿ×È€ÿìÈ‚ÿìÈŸÿ×È¡ÿìÈ©ÿìȵÿÃÈ·ÿìȹÿìÈ»ÿ×ȽÿìÈ¿ÿ×ÈÁÿ×ÈÊÿ×ÈÎÿ×ÈÏÿìÈÔÿ×ÈÙÿ×ÈÛÿ×ÈÝÿ×Èåÿ×ÈçÿìÈõÿìÈ÷ÿ×Èùÿ×Èûÿ×Èýÿ×Èÿ×Èÿ×È ÿ×Èÿ×Èÿ×ÈÿìÈÿìÈÿ×ÈÿìÊÿìÊ ÿìÊÿìÊ ÿìÌé)ÍÿšÍÿ×ÍÿšÍÎÿÃÍÏÿìÍÕÿÃÍØÿìÍÛÿìÍÞÿìÍêÿìÍíÿìÍòÿÃÍÿ×Íÿ×Íÿ×ÍÿšÍ ÿšÍjÿìÍsÿÃÍÿìÍ…ÿì͇ÿì͉ÿìÍÿìͲÿìÍ´ÿìÍÏÿÃÍàÿìÍðÿìÍòÿìÍôÿìÍ ÿìÍ ÿìÍÿÃÍÿìÍÿìÍÿÃÎÿìÎ ÿìÎÿìÎ ÿìÏÿìÏ ÿìÏÿìÏ ÿìÐÏÿ×ÐØÿ×ÐÛÿ×ÐÞÿ×Ðáÿ×Ðêÿ×Ðíÿ×Ðjÿ×Ðÿ×Ð…ÿ×Їÿ×Љÿ×Ðÿ×вÿ×дÿ×ÐÀÿ×ÐÂÿ×ÐÆÿ×ÐÈÿ×ÐÕÿ×Ðàÿ×Ððÿ×Ðòÿ×Ðôÿ×Ðþÿ×Ð ÿ×Ð ÿ×Ðÿ×Ðÿ×Ñé)ÔÏÿ×ÔØÿ×ÔÛÿ×ÔÞÿ×Ôáÿ×Ôêÿ×Ôíÿ×Ôjÿ×Ôÿ×Ô…ÿ×Ô‡ÿ×Ô‰ÿ×Ôÿ×Ô²ÿ×Ô´ÿ×ÔÀÿ×ÔÂÿ×ÔÆÿ×ÔÈÿ×ÔÕÿ×Ôàÿ×Ôðÿ×Ôòÿ×Ôôÿ×Ôþÿ×Ô ÿ×Ô ÿ×Ôÿ×Ôÿ×ØÿìØ ÿìØÐÿ×ØÜÿìØÝÿìØßÿ×ØáÿìØäÿìØöÿìØÿìØ ÿìØ ÿ×تÿìضÿìؼÿ×ؾÿìØÀÿìØÂÿìØËÿ×ØÕÿìØæÿ×ØøÿìØúÿìØüÿìØþÿìØÿ×Øÿ×ØÿìØÿìØÿìÚÿìÚ ÿìÚÐÿ×ÚÜÿìÚÝÿìÚßÿ×ÚáÿìÚäÿìÚöÿìÚÿìÚ ÿìÚ ÿ×ÚªÿìÚ¶ÿìÚ¼ÿ×Ú¾ÿìÚÀÿìÚÂÿìÚËÿ×ÚÕÿìÚæÿ×ÚøÿìÚúÿìÚüÿìÚþÿìÚÿ×Úÿ×ÚÿìÚÿìÚÿìÜÿšÜÿ×ÜÿšÜÎÿÃÜÏÿìÜÕÿÃÜØÿìÜÛÿìÜÞÿìÜêÿìÜíÿìÜòÿÃÜÿ×Üÿ×Üÿ×ÜÿšÜ ÿšÜjÿìÜsÿÃÜÿìÜ…ÿì܇ÿì܉ÿìÜÿìܲÿìÜ´ÿìÜÏÿÃÜàÿìÜðÿìÜòÿìÜôÿìÜ ÿìÜ ÿìÜÿÃÜÿìÜÿìÜÿÃÝÿ®Ýÿ®ÝÎÿ×ÝÕÿ×Ýòÿ×Ýÿ®Ý ÿ®Ýsÿ×ÝÏÿ×Ýÿ×Ýÿ×ÞÿìÞ ÿìÞÐÿ×ÞÜÿìÞÝÿìÞßÿ×ÞáÿìÞäÿìÞöÿìÞÿìÞ ÿìÞ ÿ×ÞªÿìÞ¶ÿìÞ¼ÿ×Þ¾ÿìÞÀÿìÞÂÿìÞËÿ×ÞÕÿìÞæÿ×ÞøÿìÞúÿìÞüÿìÞþÿìÞÿ×Þÿ×ÞÿìÞÿìÞÿìßÏÿ×ßØÿ×ßÛÿ×ßÞÿ×ßáÿ×ßêÿ×ßíÿ×ßjÿ×ßÿ×ß…ÿ×߇ÿ×߉ÿ×ßÿ×ß²ÿ×ß´ÿ×ßÀÿ×ßÂÿ×ßÆÿ×ßÈÿ×ßÕÿ×ßàÿ×ßðÿ×ßòÿ×ßôÿ×ßþÿ×ß ÿ×ß ÿ×ßÿ×ßÿ×àÿìà ÿìàÿìà ÿìãÿìã ÿìãÿìã ÿìäÿ…ä ÿ…äÐÿ×äÜÿšäÝÿÃäßÿ×äáÿ®ääÿšäöÿÃäÿ…ä ÿ…ämÿ×äÿ×äƒÿ×ä‹ÿ×ä ÿ×äªÿšä¶ÿšä¸ÿÃäºÿÃä¼ÿ×ä¾ÿšäÀÿ®äÂÿ®äÆÿ×äÈÿ×äËÿ×äÕÿ®äæÿ×äêÿ×äøÿÃäúÿÃäüÿÃäþÿ®äÿ×äÿ×äÿšäÿšäÿšæÿ…æ ÿ…æÐÿ×æÜÿšæÝÿÃæßÿ×æáÿ®æäÿšæöÿÃæÿ…æ ÿ…æmÿ×æÿ×æƒÿ×æ‹ÿ×æ ÿ×æªÿšæ¶ÿšæ¸ÿÃæºÿÃæ¼ÿ×æ¾ÿšæÀÿ®æÂÿ®æÆÿ×æÈÿ×æËÿ×æÕÿ®ææÿ×æêÿ×æøÿÃæúÿÃæüÿÃæþÿ®æÿ×æÿ×æÿšæÿšæÿšçÿìç ÿìçÐÿ×çÜÿìçÝÿìçßÿ×çáÿìçäÿìçöÿìçÿìç ÿìç ÿ×çªÿìç¶ÿìç¼ÿ×ç¾ÿìçÀÿìçÂÿìçËÿ×çÕÿìçæÿ×çøÿìçúÿìçüÿìçþÿìçÿ×çÿ×çÿìçÿìçÿìèÿìè ÿìèÐÿ×èÜÿìèÝÿìèßÿ×èáÿìèäÿìèöÿìèÿìè ÿìè ÿ×èªÿìè¶ÿìè¼ÿ×è¾ÿìèÀÿìèÂÿìèËÿ×èÕÿìèæÿ×èøÿìèúÿìèüÿìèþÿìèÿ×èÿ×èÿìèÿìèÿìêÿìê ÿìêÿìê ÿìëÿìë ÿìëÿìë ÿìëÿ×ëÿ×ìÿšìÿ×ìÿšìÎÿÃìÏÿììÕÿÃìØÿììÛÿììÞÿììêÿììíÿììòÿÃìÿ×ìÿ×ìÿ×ìÿšì ÿšìjÿììsÿÃìÿìì…ÿìì‡ÿìì‰ÿììÿìì²ÿìì´ÿììÏÿÃìàÿììðÿììòÿììôÿìì ÿìì ÿììÿÃìÿììÿììÿÃòÿ…ò ÿ…òÐÿ×òÜÿšòÝÿÃòßÿ×òáÿ®òäÿšòöÿÃòÿ…ò ÿ…òmÿ×òÿ×òƒÿ×ò‹ÿ×ò ÿ×òªÿšò¶ÿšò¸ÿÃòºÿÃò¼ÿ×ò¾ÿšòÀÿ®òÂÿ®òÆÿ×òÈÿ×òËÿ×òÕÿ®òæÿ×òêÿ×òøÿÃòúÿÃòüÿÃòþÿ®òÿ×òÿ×òÿšòÿšòÿšóÿ…ó ÿ…óÐÿ×óÜÿšóÝÿÃóßÿ×óáÿ®óäÿšóöÿÃóÿ…ó ÿ…ómÿ×óÿ×óƒÿ×ó‹ÿ×ó ÿ×óªÿšó¶ÿšó¸ÿÃóºÿÃó¼ÿ×ó¾ÿšóÀÿ®óÂÿ®óÆÿ×óÈÿ×óËÿ×óÕÿ®óæÿ×óêÿ×óøÿÃóúÿÃóüÿÃóþÿ®óÿ×óÿ×óÿšóÿšóÿšôÿìô ÿìôÿìô ÿìôÿ×ôÿ×õÏÿ×õØÿ×õÛÿ×õÞÿ×õáÿ×õêÿ×õíÿ×õjÿ×õÿ×õ…ÿ×õ‡ÿ×õ‰ÿ×õÿ×õ²ÿ×õ´ÿ×õÀÿ×õÂÿ×õÆÿ×õÈÿ×õÕÿ×õàÿ×õðÿ×õòÿ×õôÿ×õþÿ×õ ÿ×õ ÿ×õÿ×õÿ×öÿ®öÿ®öÎÿ×öÕÿ×öòÿ×öÿ®ö ÿ®ösÿ×öÏÿ×öÿ×öÿ×øÿ…øÿ®øÿ…øŸÿ×ø¤ÿšøªÿqø®ÿšøµÿšø¸ÿ×ø»ÿ×ø¼)ø¾ÿ®øÌÿšøÍÿšøÎÿ…øÏÿqøÐÿ×øÑÿ×øÒÿšøÓÿšøÔÿšøÕÿ…øÖÿšø×ÿšøØÿqøÙÿšøÚÿšøÛÿqøÜÿ®øÝÿ®øÞÿqøßÿ×øàÿšøáÿšøâÿšøãÿšøäÿ®øåÿšøæÿšøçÿ×øèÿšøéÿÃøêÿqøìÿšøíÿqøîÿ…øòÿ…øóÿšøõÿšøöÿ®ø÷ÿšøùÿšøÿ®øÿ®øÿ®øÿ…ø ÿ…øjÿqøkÿšølÿ×ømÿ×øqÿšørÿqøsÿ…øuÿšøwÿšøyÿšø}ÿšø~ÿ×øÿqøÿ×øƒÿ×ø„ÿ×ø…ÿqø†ÿ×ø‡ÿqøˆÿ×ø‰ÿqøŠÿ×ø‹ÿ×øŒÿ×øÿqø–ÿšøšÿšøžÿšø ÿ×ø¢ÿ×ø¤ÿšø¦ÿšøªÿ®ø¬ÿšø®ÿšø°ÿšø±ÿ×ø²ÿqø³ÿ×ø´ÿqøµ)ø¶ÿ®ø¸ÿ®øºÿ®ø¼ÿ×ø¾ÿ®øÀÿšøÂÿšøÄÿšøÅÿšøÆÿqøÇÿšøÈÿqøËÿ×øÍÿšøÎÿšøÏÿ…øÑÿšøÓÿšøÕÿšø×ÿšøÙÿqøÛÿqøÝÿqøàÿqøæÿ×øèÿ×øêÿÃøìÿšøîÿšøïÿ×øðÿqøñÿ×øòÿqøóÿ×øôÿqøöÿ×øøÿ®øúÿ®øüÿ®øþÿšøÿšøÿšøÿ×øÿ×ø ÿqø ÿqø ÿqø ÿqøÿšøÿšøÿšøÿ…øÿšøÿ×øÿqøÿ®øÿqøÿšøÿ…ùÿšùÿ×ùÿšùÎÿÃùÏÿìùÕÿÃùØÿìùÛÿìùÞÿìùêÿìùíÿìùòÿÃùÿ×ùÿ×ùÿ×ùÿšù ÿšùjÿìùsÿÃùÿìù…ÿìù‡ÿìù‰ÿìùÿìù²ÿìù´ÿìùÏÿÃùàÿìùðÿìùòÿìùôÿìù ÿìù ÿìùÿÃùÿìùÿìùÿÃúÿšúÿšú")ú$ÿ®ú&ÿìú*ÿìú2ÿìú4ÿìúDÿ×úFÿ×úGÿ×úHÿ×úJÿìúPÿìúQÿìúRÿ×úSÿìúTÿ×úUÿìúVÿìúXÿìú‚ÿ®úƒÿ®ú„ÿ®ú…ÿ®ú†ÿ®ú‡ÿ®ú‰ÿìú”ÿìú•ÿìú–ÿìú—ÿìú˜ÿìúšÿìú¢ÿ×ú£ÿ×ú¤ÿ×ú¥ÿ×ú¦ÿ×ú§ÿ×ú¨ÿ×ú©ÿ×úªÿ×ú«ÿ×ú¬ÿ×ú­ÿ×ú´ÿ×úµÿ×ú¶ÿ×ú·ÿ×ú¸ÿ×úºÿ×ú»ÿìú¼ÿìú½ÿìú¾ÿìúÂÿ®úÃÿ×úÄÿ®úÅÿ×úÆÿ®úÇÿ×úÈÿìúÉÿ×úÊÿìúËÿ×úÌÿìúÍÿ×úÎÿìúÏÿ×úÑÿ×úÓÿ×úÕÿ×ú×ÿ×úÙÿ×úÛÿ×úÝÿ×úÞÿìúßÿìúàÿìúáÿìúâÿìúãÿìúäÿìúåÿìúúÿìúÿìúÿìú ÿìúÿìúÿ×úÿìúÿ×úÿìúÿ×úÿìúÿ×úÿìúÿìúÿìú!ÿìú+ÿìú-ÿìú/ÿìú1ÿìú3ÿìú5ÿìúCÿ®úDÿ×úFÿ×úGÿìúHÿ×úJÿìúÿšú ÿšúWÿìúXÿ®úYÿ×ú_ÿìú`ÿ×úbÿìúÿ®úÿ×úÿ®ú ÿ×ú!ÿ®ú"ÿ×ú#ÿ®ú%ÿ®ú&ÿ×ú'ÿ®ú(ÿ×ú)ÿ®ú*ÿ×ú+ÿ®ú,ÿ×ú-ÿ®ú.ÿ×ú/ÿ®ú0ÿ×ú1ÿ®ú2ÿ×ú3ÿ®ú4ÿ×ú6ÿ×ú8ÿ×ú:ÿ×ú<ÿ×ú@ÿ×úBÿ×úDÿ×úIÿìúJÿ×úKÿìúLÿ×úMÿìúNÿ×úOÿìúQÿìúRÿ×úSÿìúTÿ×úUÿìúVÿ×úWÿìúXÿ×úYÿìúZÿ×ú[ÿìú\ÿ×ú]ÿìú^ÿ×ú_ÿìú`ÿ×úbÿìúdÿìúfÿìúhÿìújÿìúlÿìúnÿìûRû Rûÿ®ûÿ®û")ûRûÿ®û Rû ÿ®üÿšüÿšü")ü$ÿ®ü&ÿìü*ÿìü2ÿìü4ÿìüDÿ×üFÿ×üGÿ×üHÿ×üJÿìüPÿìüQÿìüRÿ×üSÿìüTÿ×üUÿìüVÿìüXÿìü‚ÿ®üƒÿ®ü„ÿ®ü…ÿ®ü†ÿ®ü‡ÿ®ü‰ÿìü”ÿìü•ÿìü–ÿìü—ÿìü˜ÿìüšÿìü¢ÿ×ü£ÿ×ü¤ÿ×ü¥ÿ×ü¦ÿ×ü§ÿ×ü¨ÿ×ü©ÿ×üªÿ×ü«ÿ×ü¬ÿ×ü­ÿ×ü´ÿ×üµÿ×ü¶ÿ×ü·ÿ×ü¸ÿ×üºÿ×ü»ÿìü¼ÿìü½ÿìü¾ÿìüÂÿ®üÃÿ×üÄÿ®üÅÿ×üÆÿ®üÇÿ×üÈÿìüÉÿ×üÊÿìüËÿ×üÌÿìüÍÿ×üÎÿìüÏÿ×üÑÿ×üÓÿ×üÕÿ×ü×ÿ×üÙÿ×üÛÿ×üÝÿ×üÞÿìüßÿìüàÿìüáÿìüâÿìüãÿìüäÿìüåÿìüúÿìüÿìüÿìü ÿìüÿìüÿ×üÿìüÿ×üÿìüÿ×üÿìüÿ×üÿìüÿìüÿìü!ÿìü+ÿìü-ÿìü/ÿìü1ÿìü3ÿìü5ÿìüCÿ®üDÿ×üFÿ×üGÿìüHÿ×üJÿìüÿšü ÿšüWÿìüXÿ®üYÿ×ü_ÿìü`ÿ×übÿìüÿ®üÿ×üÿ®ü ÿ×ü!ÿ®ü"ÿ×ü#ÿ®ü%ÿ®ü&ÿ×ü'ÿ®ü(ÿ×ü)ÿ®ü*ÿ×ü+ÿ®ü,ÿ×ü-ÿ®ü.ÿ×ü/ÿ®ü0ÿ×ü1ÿ®ü2ÿ×ü3ÿ®ü4ÿ×ü6ÿ×ü8ÿ×ü:ÿ×ü<ÿ×ü@ÿ×üBÿ×üDÿ×üIÿìüJÿ×üKÿìüLÿ×üMÿìüNÿ×üOÿìüQÿìüRÿ×üSÿìüTÿ×üUÿìüVÿ×üWÿìüXÿ×üYÿìüZÿ×ü[ÿìü\ÿ×ü]ÿìü^ÿ×ü_ÿìü`ÿ×übÿìüdÿìüfÿìühÿìüjÿìülÿìünÿìýRý Rýÿ®ýÿ®ý")ýRýÿ®ý Rý ÿ®þÿšþÿšþ")þ$ÿ®þ&ÿìþ*ÿìþ2ÿìþ4ÿìþDÿ×þFÿ×þGÿ×þHÿ×þJÿìþPÿìþQÿìþRÿ×þSÿìþTÿ×þUÿìþVÿìþXÿìþ‚ÿ®þƒÿ®þ„ÿ®þ…ÿ®þ†ÿ®þ‡ÿ®þ‰ÿìþ”ÿìþ•ÿìþ–ÿìþ—ÿìþ˜ÿìþšÿìþ¢ÿ×þ£ÿ×þ¤ÿ×þ¥ÿ×þ¦ÿ×þ§ÿ×þ¨ÿ×þ©ÿ×þªÿ×þ«ÿ×þ¬ÿ×þ­ÿ×þ´ÿ×þµÿ×þ¶ÿ×þ·ÿ×þ¸ÿ×þºÿ×þ»ÿìþ¼ÿìþ½ÿìþ¾ÿìþÂÿ®þÃÿ×þÄÿ®þÅÿ×þÆÿ®þÇÿ×þÈÿìþÉÿ×þÊÿìþËÿ×þÌÿìþÍÿ×þÎÿìþÏÿ×þÑÿ×þÓÿ×þÕÿ×þ×ÿ×þÙÿ×þÛÿ×þÝÿ×þÞÿìþßÿìþàÿìþáÿìþâÿìþãÿìþäÿìþåÿìþúÿìþÿìþÿìþ ÿìþÿìþÿ×þÿìþÿ×þÿìþÿ×þÿìþÿ×þÿìþÿìþÿìþ!ÿìþ+ÿìþ-ÿìþ/ÿìþ1ÿìþ3ÿìþ5ÿìþCÿ®þDÿ×þFÿ×þGÿìþHÿ×þJÿìþÿšþ ÿšþWÿìþXÿ®þYÿ×þ_ÿìþ`ÿ×þbÿìþÿ®þÿ×þÿ®þ ÿ×þ!ÿ®þ"ÿ×þ#ÿ®þ%ÿ®þ&ÿ×þ'ÿ®þ(ÿ×þ)ÿ®þ*ÿ×þ+ÿ®þ,ÿ×þ-ÿ®þ.ÿ×þ/ÿ®þ0ÿ×þ1ÿ®þ2ÿ×þ3ÿ®þ4ÿ×þ6ÿ×þ8ÿ×þ:ÿ×þ<ÿ×þ@ÿ×þBÿ×þDÿ×þIÿìþJÿ×þKÿìþLÿ×þMÿìþNÿ×þOÿìþQÿìþRÿ×þSÿìþTÿ×þUÿìþVÿ×þWÿìþXÿ×þYÿìþZÿ×þ[ÿìþ\ÿ×þ]ÿìþ^ÿ×þ_ÿìþ`ÿ×þbÿìþdÿìþfÿìþhÿìþjÿìþlÿìþnÿìÿRÿ Rÿÿ®ÿÿ®ÿ")ÿRÿÿ®ÿ Rÿ ÿ®ÿ…ÿ…")$ÿ…&ÿ×*ÿ×2ÿ×4ÿ×DÿšFÿšGÿšHÿšJÿ×PÿÃQÿÃRÿšSÿÃTÿšUÿÃVÿ®XÿÃ]ÿׂÿ…ƒÿ…„ÿ……ÿ…†ÿ…‡ÿ…‰ÿ×”ÿוÿ×–ÿ×—ÿטÿךÿ×¢ÿš£ÿš¤ÿš¥ÿš¦ÿš§ÿš¨ÿš©ÿšªÿš«ÿš¬ÿš­ÿš´ÿšµÿš¶ÿš·ÿš¸ÿšºÿš»ÿüÿýÿþÿÃÂÿ…ÃÿšÄÿ…ÅÿšÆÿ…ÇÿšÈÿ×ÉÿšÊÿ×ËÿšÌÿ×ÍÿšÎÿ×ÏÿšÑÿšÓÿšÕÿš×ÿšÙÿšÛÿšÝÿšÞÿ×ßÿ×àÿ×áÿ×âÿ×ãÿ×äÿ×åÿ×úÿÃÿÃÿà ÿÃÿ×ÿšÿ×ÿšÿ×ÿšÿ×ÿšÿÃÿÃÿ®!ÿ®+ÿÃ-ÿÃ/ÿÃ1ÿÃ3ÿÃ5ÿÃ<ÿ×>ÿ×@ÿ×Cÿ…DÿšFÿšGÿ×HÿšJÿ®ÿ… ÿ…WÿÃXÿ…Yÿš_ÿ×`ÿšbÿÃÿ…ÿšÿ… ÿš!ÿ…"ÿš#ÿ…%ÿ…&ÿš'ÿ…(ÿš)ÿ…*ÿš+ÿ…,ÿš-ÿ….ÿš/ÿ…0ÿš1ÿ…2ÿš3ÿ…4ÿš6ÿš8ÿš:ÿš<ÿš@ÿšBÿšDÿšIÿ×JÿšKÿ×LÿšMÿ×NÿšOÿ×Qÿ×RÿšSÿ×TÿšUÿ×VÿšWÿ×XÿšYÿ×Zÿš[ÿ×\ÿš]ÿ×^ÿš_ÿ×`ÿšbÿÃdÿÃfÿÃhÿÃjÿÃlÿÃnÿÃR Rÿ®ÿ®")Rÿ® R ÿ®7ÿ®$ÿ®&ÿ®qÿ®ÿ®¦ÿ®¼ÿ®Äÿ®Üÿ×äÿשÿ®ªÿ×µÿ®¶ÿ×½ÿ®¾ÿ×ÿ®ÿ×ÿ®7ÿ®$ÿ®&ÿ®qÿ®ÿ®¦ÿ®¼ÿ®Äÿ®Üÿ×äÿשÿ®ªÿ×µÿ®¶ÿ×½ÿ®¾ÿ×ÿ®ÿ×ÿ®7ÿ®$ÿ®&ÿ®qÿ®ÿ®¦ÿ®¼ÿ®Äÿ®Üÿ×äÿשÿ®ªÿ×µÿ®¶ÿ×½ÿ®¾ÿ×ÿ®ÿ×ÿ®$ÿq7)9):)<Dÿ®Fÿ…Gÿ…Hÿ…JÿÃPÿÃQÿÃRÿ…SÿÃTÿ…UÿÃVÿÃXÿÂÿqƒÿq„ÿq…ÿq†ÿq‡ÿqŸ¢ÿ…£ÿ®¤ÿ®¥ÿ®¦ÿ®§ÿ®¨ÿ®©ÿ…ªÿ…«ÿ…¬ÿ…­ÿ…´ÿ…µÿ…¶ÿ…·ÿ…¸ÿ…ºÿ…»ÿüÿýÿþÿÃÂÿqÃÿ®ÄÿqÅÿ®ÆÿqÇÿ®Éÿ…Ëÿ…Íÿ…Ïÿ…Ñÿ…Óÿ…Õÿ…×ÿ…Ùÿ…Ûÿ…Ýÿ…ßÿÃáÿÃãÿÃåÿÃúÿÃÿÃÿà ÿÃÿ…ÿ…ÿ…ÿ…ÿÃÿÃÿÃ!ÿÃ$)&)+ÿÃ-ÿÃ/ÿÃ1ÿÃ3ÿÃ5ÿÃ6)8:CÿqDÿ®Fÿ®Hÿ…JÿÃVÿq_ÿqbÿqiÿqyÿ®zÿ×{ÿ×~ÿ®ÿÂÿ׃ÿׄÿׇÿ׉ÿ׌ÿ®ŽÿÃÿ®ÿ®“ÿ®™ÿ®¤ÿ…ªÿq®ÿ…µÿ…Êÿ×ÎÿqÏÿ…ÕÿqØÿ…Ûÿ…Þÿ…êÿ…íÿ…îÿÃòÿqú)ü)þ)WÿÃXÿqYÿ®`ÿ…bÿÃjÿ…rÿqsÿq}ÿìÿ……ÿ…‡ÿ…‰ÿ…ÿ…²ÿ…´ÿ…Îÿ…ÏÿqÙÿqÚÿ×ÛÿqÜÿ×ÝÿqÞÿ×àÿ…âÿ×äÿ×ðÿ…òÿ…ôÿ… ÿq ÿ… ÿq ÿ…ÿ…ÿqÿ…ÿ…ÿ…ÿqÿqÿ®ÿq ÿ®!ÿq"ÿ®#ÿq%ÿq&ÿ®'ÿq(ÿ®)ÿq*ÿ®+ÿq,ÿ®-ÿq.ÿ®/ÿq0ÿ®1ÿq2ÿ®3ÿq4ÿ®6ÿ…8ÿ…:ÿ…<ÿ…@ÿ…Bÿ…Dÿ…Jÿ…Lÿ…Nÿ…Rÿ…Tÿ…Vÿ…Xÿ…Zÿ…\ÿ…^ÿ…`ÿ…bÿÃdÿÃfÿÃhÿÃjÿÃlÿÃnÿÃoqs)$ÿq7)9):)<Dÿ®Fÿ…Gÿ…Hÿ…JÿÃPÿÃQÿÃRÿ…SÿÃTÿ…UÿÃVÿÃXÿÂÿqƒÿq„ÿq…ÿq†ÿq‡ÿqŸ¢ÿ…£ÿ®¤ÿ®¥ÿ®¦ÿ®§ÿ®¨ÿ®©ÿ…ªÿ…«ÿ…¬ÿ…­ÿ…´ÿ…µÿ…¶ÿ…·ÿ…¸ÿ…ºÿ…»ÿüÿýÿþÿÃÂÿqÃÿ®ÄÿqÅÿ®ÆÿqÇÿ®Éÿ…Ëÿ…Íÿ…Ïÿ…Ñÿ…Óÿ…Õÿ…×ÿ…Ùÿ…Ûÿ…Ýÿ…ßÿÃáÿÃãÿÃåÿÃúÿÃÿÃÿà ÿÃÿ…ÿ…ÿ…ÿ…ÿÃÿÃÿÃ!ÿÃ$)&)+ÿÃ-ÿÃ/ÿÃ1ÿÃ3ÿÃ5ÿÃ6)8:CÿqDÿ®Fÿ®Hÿ…JÿÃVÿq_ÿqbÿqiÿqyÿ®zÿ×{ÿ×~ÿ®ÿÂÿ׃ÿׄÿׇÿ׉ÿ׌ÿ®ŽÿÃÿ®ÿ®“ÿ®™ÿ®¤ÿ…ªÿq®ÿ…µÿ…Êÿ×ÎÿqÏÿ…ÕÿqØÿ…Ûÿ…Þÿ…êÿ…íÿ…îÿÃòÿqú)ü)þ)WÿÃXÿqYÿ®`ÿ…bÿÃjÿ…rÿqsÿq}ÿìÿ……ÿ…‡ÿ…‰ÿ…ÿ…²ÿ…´ÿ…Îÿ…ÏÿqÙÿqÚÿ×ÛÿqÜÿ×ÝÿqÞÿ×àÿ…âÿ×äÿ×ðÿ…òÿ…ôÿ… ÿq ÿ… ÿq ÿ…ÿ…ÿqÿ…ÿ…ÿ…ÿqÿqÿ®ÿq ÿ®!ÿq"ÿ®#ÿq%ÿq&ÿ®'ÿq(ÿ®)ÿq*ÿ®+ÿq,ÿ®-ÿq.ÿ®/ÿq0ÿ®1ÿq2ÿ®3ÿq4ÿ®6ÿ…8ÿ…:ÿ…<ÿ…@ÿ…Bÿ…Dÿ…Jÿ…Lÿ…Nÿ…Rÿ…Tÿ…Vÿ…Xÿ…Zÿ…\ÿ…^ÿ…`ÿ…bÿÃdÿÃfÿÃhÿÃjÿÃlÿÃnÿÃoqs)&ÿš*ÿš2ÿš4ÿš7ÿq8ÿ×9ÿ…:ÿ…<ÿ…‰ÿš”ÿš•ÿš–ÿš—ÿš˜ÿššÿš›ÿלÿ×ÿמÿןÿ…ÈÿšÊÿšÌÿšÎÿšÞÿšàÿšâÿšäÿšÿšÿšÿšÿš$ÿq&ÿq*ÿ×,ÿ×.ÿ×0ÿ×2ÿ×4ÿ×6ÿ…8ÿ…:ÿ…Gÿšfÿ®mÿ®qÿqrÿ…sÿšuÿ…xÿ……ÿ×ÿqŸÿš¦ÿq¸ÿš»ÿš¼ÿq¾ÿ®Áÿ\ÄÿqÜÿšáÿ…äÿšúÿ…üÿ…þÿ…ÿ…Tÿ…_ÿšaÿ×lÿš|ÿ\~ÿš€ÿ…‚ÿ…„ÿš†ÿšˆÿšŠÿšŒÿš©ÿqªÿš±ÿš³ÿšµÿq¶ÿš·ÿ…¹ÿ…½ÿq¾ÿš¿ÿ\Àÿ…Áÿ\Âÿ…Åÿ…Çÿ…Ôÿ\Õÿ…ïÿšñÿšóÿšýÿ\þÿ… ÿ…ÿšÿ…ÿšÿšÿqÿšIÿšKÿšMÿšOÿšQÿšSÿšUÿšWÿšYÿš[ÿš]ÿš_ÿšaÿ×cÿ×eÿ×gÿ×iÿ×kÿ×mÿ×oÿ…qÿ…sÿ…ÿq $ÿq 7) 9) :) < Dÿ® Fÿ… Gÿ… Hÿ… Jÿà Pÿà Qÿà Rÿ… Sÿà Tÿ… Uÿà Vÿà Xÿà ‚ÿq ƒÿq „ÿq …ÿq †ÿq ‡ÿq Ÿ ¢ÿ… £ÿ® ¤ÿ® ¥ÿ® ¦ÿ® §ÿ® ¨ÿ® ©ÿ… ªÿ… «ÿ… ¬ÿ… ­ÿ… ´ÿ… µÿ… ¶ÿ… ·ÿ… ¸ÿ… ºÿ… »ÿà ¼ÿà ½ÿà ¾ÿà Âÿq Ãÿ® Äÿq Åÿ® Æÿq Çÿ® Éÿ… Ëÿ… Íÿ… Ïÿ… Ñÿ… Óÿ… Õÿ… ×ÿ… Ùÿ… Ûÿ… Ýÿ… ßÿà áÿà ãÿà åÿà úÿà ÿà ÿà  ÿà ÿ… ÿ… ÿ… ÿ… ÿà ÿà ÿà !ÿà $) &) +ÿà -ÿà /ÿà 1ÿà 3ÿà 5ÿà 6) 8 : Cÿq Dÿ® Fÿ® Hÿ… Jÿà Vÿq _ÿq bÿq iÿq yÿ® zÿ× {ÿ× ~ÿ® ÿà ‚ÿ× ƒÿ× „ÿ× ‡ÿ× ‰ÿ× Œÿ® Žÿà ÿ® ÿ® “ÿ® ™ÿ® ¤ÿ… ªÿq ®ÿ… µÿ… Êÿ× Îÿq Ïÿ… Õÿq Øÿ… Ûÿ… Þÿ… êÿ… íÿ… îÿà òÿq ú) ü) þ)  Wÿà Xÿq Yÿ® `ÿ… bÿà jÿ… rÿq sÿq }ÿì ÿ… …ÿ… ‡ÿ… ‰ÿ… ÿ… ²ÿ… ´ÿ… Îÿ… Ïÿq Ùÿq Úÿ× Ûÿq Üÿ× Ýÿq Þÿ× àÿ… âÿ× äÿ× ðÿ… òÿ… ôÿ…  ÿq  ÿ…  ÿq  ÿ… ÿ… ÿq ÿ… ÿ… ÿ… ÿq ÿq ÿ® ÿq  ÿ® !ÿq "ÿ® #ÿq %ÿq &ÿ® 'ÿq (ÿ® )ÿq *ÿ® +ÿq ,ÿ® -ÿq .ÿ® /ÿq 0ÿ® 1ÿq 2ÿ® 3ÿq 4ÿ® 6ÿ… 8ÿ… :ÿ… <ÿ… @ÿ… Bÿ… Dÿ… Jÿ… Lÿ… Nÿ… Rÿ… Tÿ… Vÿ… Xÿ… Zÿ… \ÿ… ^ÿ… `ÿ… bÿà dÿà fÿà hÿà jÿà lÿà nÿà o q s ) &ÿš *ÿš 2ÿš 4ÿš 7ÿq 8ÿ× 9ÿ… :ÿ… <ÿ… ‰ÿš ”ÿš •ÿš –ÿš —ÿš ˜ÿš šÿš ›ÿ× œÿ× ÿ× žÿ× Ÿÿ… Èÿš Êÿš Ìÿš Îÿš Þÿš àÿš âÿš äÿš ÿš ÿš ÿš ÿš $ÿq &ÿq *ÿ× ,ÿ× .ÿ× 0ÿ× 2ÿ× 4ÿ× 6ÿ… 8ÿ… :ÿ… Gÿš fÿ® mÿ® qÿq rÿ… sÿš uÿ… xÿ… …ÿ× ÿq Ÿÿš ¦ÿq ¸ÿš »ÿš ¼ÿq ¾ÿ® Áÿ\ Äÿq Üÿš áÿ… äÿš úÿ… üÿ… þÿ… ÿ… Tÿ… _ÿš aÿ× lÿš |ÿ\ ~ÿš €ÿ… ‚ÿ… „ÿš †ÿš ˆÿš Šÿš Œÿš ©ÿq ªÿš ±ÿš ³ÿš µÿq ¶ÿš ·ÿ… ¹ÿ… ½ÿq ¾ÿš ¿ÿ\ Àÿ… Áÿ\ Âÿ… Åÿ… Çÿ… Ôÿ\ Õÿ… ïÿš ñÿš óÿš ýÿ\ þÿ…  ÿ… ÿš ÿ… ÿš ÿš ÿq ÿš Iÿš Kÿš Mÿš Oÿš Qÿš Sÿš Uÿš Wÿš Yÿš [ÿš ]ÿš _ÿš aÿ× cÿ× eÿ× gÿ× iÿ× kÿ× mÿ× oÿ… qÿ… sÿ… ÿq!qÿ×!rÿì!xÿì!TÿìSÿÃSÿÃSÿÃS ÿÃTÿ…Tÿ…TVÿ…T_ÿ…Tbÿ…Tfÿ×Tiÿ…Tmÿ×TsÿÃTvÿìTyÿšTzÿ®T{ÿÃT|ÿÃT}ÿÃT~ÿšTÿÃT‚ÿ®T„ÿÃT†ÿÃT‡ÿÃT‰ÿÃTŒÿšTŽÿšTÿšTÿšT’ÿÃT“ÿšT•ÿÃT–ÿÃT˜ÿÃT™ÿšTšÿÃT›ÿÃTÿ…T ÿ…T!ÿìXÿqX ÿqX&ÿ×X*ÿ×X- X2ÿ×X4ÿ×X7ÿqX9ÿ®X:ÿ®X<ÿ…X‰ÿ×X”ÿ×X•ÿ×X–ÿ×X—ÿ×X˜ÿ×Xšÿ×XŸÿ…XÈÿ×XÊÿ×XÌÿ×XÎÿ×XÞÿ×Xàÿ×Xâÿ×Xäÿ×Xÿ×Xÿ×Xÿ×Xÿ×X$ÿqX&ÿqX6ÿ®X8ÿ…X:ÿ…XGÿ×Xúÿ®Xüÿ®Xþÿ®Xÿ…XÿqX ÿqX_ÿ×XIÿ×XKÿ×XMÿ×XOÿ×XQÿ×XSÿ×XUÿ×XWÿ×XYÿ×X[ÿ×X]ÿ×X_ÿ×Xoÿ…Xqÿ…Xsÿ…XÿqYÿìY ÿìYÿìY ÿìZÿ®Zÿ®ZVÿ×Z_ÿ×Zbÿ×ZdÿìZiÿ×ZpÿìZqÿÃZrÿìZtÿ×ZuÿìZxÿìZˆÿìZÿ®Z ÿ®ZTÿì`IR`WR`Yf`Zf`[f`\f`¿f`%R`'R`7f`ûf`ýf`4R`5R`]R`^R`pf`R`RbIfbWfbYfbZfb[fb\fb¿fb%fb'fb7fbûfbýfb4fb5fb]fb^fbpfbfbfjÿìj ÿìjÿìj ÿìlÿ®lÿ®lÿìl¤ÿ×l¦ÿìl¨ÿ×lªÿ×l®ÿ×l°ÿ×l±ÿìlµÿ×l¼ÿÃl½ÿ×l¿ÿ×lÁÿ×lÄÿìlÇÿìlÎÿìlÕÿìlòÿìlÿ®l ÿ®lrÿ×lsÿìlzÿìl|ÿ×l€ÿìl‚ÿìlŸÿ×l¡ÿìl©ÿìlµÿÃl·ÿìl¹ÿìl»ÿ×l½ÿìl¿ÿ×lÁÿ×lÊÿ×lÎÿ×lÏÿìlÔÿ×lÙÿ×lÛÿ×lÝÿ×låÿ×lçÿìlõÿìl÷ÿ×lùÿ×lûÿ×lýÿ×lÿ×lÿ×l ÿ×lÿ×lÿ×lÿìlÿìlÿ×lÿìmÿ®mÿ®mÎÿ×mÕÿ×mòÿ×mÿ®m ÿ®msÿ×mÏÿ×mÿ×mÿ×nÿ®n ÿ®nÿ×n¦ÿ×n¼ÿ®nÁÿ®nÄÿ×nÜÿ×näÿ×nÿ®n ÿ®n|ÿ®n€ÿÃn‚ÿÃn©ÿ×nªÿ×nµÿ®n¶ÿ×n·ÿÃn¹ÿÃn½ÿ×n¾ÿ×n¿ÿ®nÁÿ®nÔÿ®nýÿ®n ÿšnÿšnÿ×nÿ×oÿ…o ÿ…oÐÿ×oÜÿšoÝÿÃoßÿ×oáÿ®oäÿšoöÿÃoÿ…o ÿ…omÿ×oÿ×oƒÿ×o‹ÿ×o ÿ×oªÿšo¶ÿšo¸ÿÃoºÿÃo¼ÿ×o¾ÿšoÀÿ®oÂÿ®oÆÿ×oÈÿ×oËÿ×oÕÿ®oæÿ×oêÿ×oøÿÃoúÿÃoüÿÃoþÿ®oÿ×oÿ×oÿšoÿšoÿšpŸÿ×p¸ÿ×p»ÿ×p¾ÿ×páÿ×plÿ×p~ÿ×p„ÿ×p†ÿ×pˆÿ×pŠÿ×pŒÿ×p±ÿ×p³ÿ×pÀÿ×pÂÿ×pÅÿ×pÇÿ×pÕÿ×pïÿ×pñÿ×póÿ×pþÿ×p ÿ×p ÿ×pÿ×pÿ×pÿ×rÿqr ÿqrÿšr¦ÿšr¼ÿqr¾ÿ×rÁÿšrÄÿšrÜÿ×ráÿ×räÿ×rÿqr ÿqrnÿ×r|ÿšr€ÿ®r‚ÿ®r—ÿ×r›ÿ×r§ÿ×r©ÿšrªÿ×rµÿqr¶ÿ×r·ÿ…r¹ÿ…r½ÿšr¾ÿ×r¿ÿšrÀÿ×rÁÿšrÂÿ×rÅÿšrÇÿšrÔÿšrÕÿ×ráÿ×rãÿ×rýÿšrþÿ×rÿ×r ÿqrÿ×rÿqrÿ×rÿšrÿ×sÿqs ÿqsÏÿ×sØÿ×sÛÿ×sÜÿšsÝÿÃsÞÿ×sáÿÃsäÿšsêÿ×síÿ×söÿÃsÿqs ÿqsjÿ×smÿ×s}ÿìsÿ×sÿ×sƒÿ×s…ÿ×s‡ÿ×s‰ÿ×s‹ÿ×sÿ×sªÿšs²ÿ×s´ÿ×s¶ÿšs¸ÿ×sºÿ×s¾ÿšsÀÿÃsÂÿÃsÆÿ×sÈÿ×sÕÿÃsàÿ×sðÿ×sòÿ×sôÿ×søÿÃsúÿÃsüÿÃsþÿÃs ÿ×s ÿ×sÿ…sÿ…sÿ×sÿšsÿ×tÿqt ÿqtÿšt¦ÿšt¼ÿqt¾ÿ×tÁÿštÄÿštÜÿ×táÿ×täÿ×tÿqt ÿqtnÿ×t|ÿšt€ÿ®t‚ÿ®t—ÿ×t›ÿ×t§ÿ×t©ÿštªÿ×tµÿqt¶ÿ×t·ÿ…t¹ÿ…t½ÿšt¾ÿ×t¿ÿštÀÿ×tÁÿštÂÿ×tÅÿštÇÿštÔÿštÕÿ×táÿ×tãÿ×týÿštþÿ×tÿ×t ÿqtÿ×tÿqtÿ×tÿštÿ×uÿqu ÿquÏÿ×uØÿ×uÛÿ×uÜÿšuÝÿÃuÞÿ×uáÿÃuäÿšuêÿ×uíÿ×uöÿÃuÿqu ÿqujÿ×umÿ×u}ÿìuÿ×uÿ×uƒÿ×u…ÿ×u‡ÿ×u‰ÿ×u‹ÿ×uÿ×uªÿšu²ÿ×u´ÿ×u¶ÿšu¸ÿ×uºÿ×u¾ÿšuÀÿÃuÂÿÃuÆÿ×uÈÿ×uÕÿÃuàÿ×uðÿ×uòÿ×uôÿ×uøÿÃuúÿÃuüÿÃuþÿÃu ÿ×u ÿ×uÿ…uÿ…uÿ×uÿšuÿ×v ÿìvÿìx ÿìxÿìzÿ®zÿ®zÿ®z ÿ®z€ÿìz‚ÿìz·ÿìz¹ÿìz ÿ×zÿ×|ÿq|ÿq|¤ÿÃ|ªÿ®|®ÿÃ|µÿÃ|Îÿ×|Õÿ×|òÿ×|ÿq| ÿq|rÿ®|sÿ×|ÎÿÃ|Ïÿ×|Ùÿ®|Ûÿ®|Ýÿ®| ÿ®| ÿ®|ÿÃ|ÿ×|ÿÃ|ÿ×}ÿì} ÿì}Ðÿ×}Üÿì}Ýÿì}ßÿ×}áÿì}äÿì}öÿì}ÿì} ÿì} ÿ×}ªÿì}¶ÿì}¼ÿ×}¾ÿì}Àÿì}Âÿì}Ëÿ×}Õÿì}æÿ×}øÿì}úÿì}üÿì}þÿì}ÿ×}ÿ×}ÿì}ÿì}ÿì~ÿ®~ÿ®~ÿì~¤ÿ×~¦ÿì~¨ÿ×~ªÿ×~®ÿ×~°ÿ×~±ÿì~µÿ×~¼ÿÃ~½ÿ×~¿ÿ×~Áÿ×~Äÿì~Çÿì~Îÿì~Õÿì~òÿì~ÿ®~ ÿ®~rÿ×~sÿì~zÿì~|ÿ×~€ÿì~‚ÿì~Ÿÿ×~¡ÿì~©ÿì~µÿÃ~·ÿì~¹ÿì~»ÿ×~½ÿì~¿ÿ×~Áÿ×~Êÿ×~Îÿ×~Ïÿì~Ôÿ×~Ùÿ×~Ûÿ×~Ýÿ×~åÿ×~çÿì~õÿì~÷ÿ×~ùÿ×~ûÿ×~ýÿ×~ÿ×~ÿ×~ ÿ×~ÿ×~ÿ×~ÿì~ÿì~ÿ×~ÿìÿì ÿìÐÿ×ÜÿìÝÿìßÿ×áÿìäÿìöÿìÿì ÿì ÿתÿì¶ÿì¼ÿ×¾ÿìÀÿìÂÿìËÿ×Õÿìæÿ×øÿìúÿìüÿìþÿìÿ×ÿ×ÿìÿìÿì€ÿ…€ÿ…€Ÿÿ쀤ÿš€ªÿq€®ÿš€µÿš€¸ÿ쀻ÿ쀾ÿÀÉÿì€Îÿ®€Ïÿ×€Õÿ®€Øÿ×€Ûÿ×€Þÿ×€áÿ×€êÿ×€ëf€íÿ×€îÿì€òÿ®€ôf€ÿ…€ ÿ…€jÿ×€lÿì€rÿq€sÿ®€~ÿì€ÿ×€„ÿ쀅ÿ×€†ÿ쀇ÿ×€ˆÿ쀉ÿ×€Šÿ쀌ÿì€ÿ×€˜f€¨f€±ÿ쀲ÿ×€³ÿ쀴ÿ×€Àÿ×€Âÿ×€Åÿ×€ÆÿÀÇÿ×€ÈÿÀÎÿš€Ïÿ®€Õÿ×€Ùÿq€Ûÿq€Ýÿq€àÿ×€ïÿì€ðÿ×€ñÿì€òÿ×€óÿì€ôÿ×€þÿ×€ ÿq€ ÿ×€ ÿq€ ÿ×€ÿš€ÿ®€ÿì€ÿ×€ÿ×€ÿš€ÿ®ÿ®ÿ®Îÿ×Õÿ×òÿ×ÿ® ÿ®sÿ×Ïÿ×ÿ×ÿׂÿ…‚ÿ…‚Ÿÿ삤ÿš‚ªÿq‚®ÿš‚µÿš‚¸ÿì‚»ÿ삾ÿÂÉÿì‚Îÿ®‚ÏÿׂÕÿ®‚ØÿׂÛÿׂÞÿׂáÿׂêÿׂëf‚íÿׂîÿì‚òÿ®‚ôf‚ÿ…‚ ÿ…‚jÿׂlÿì‚rÿq‚sÿ®‚~ÿì‚ÿׂ„ÿì‚…ÿׂ†ÿ삇ÿׂˆÿ삉ÿׂŠÿì‚Œÿì‚ÿׂ˜f‚¨f‚±ÿ삲ÿׂ³ÿì‚´ÿׂÀÿׂÂÿׂÅÿׂÆÿÂÇÿׂÈÿÂÎÿš‚Ïÿ®‚ÕÿׂÙÿq‚Ûÿq‚Ýÿq‚àÿׂïÿì‚ðÿׂñÿì‚òÿׂóÿì‚ôÿׂþÿׂ ÿq‚ ÿׂ ÿq‚ ÿׂÿš‚ÿ®‚ÿì‚ÿׂÿׂÿš‚ÿ®ƒÿ®ƒÿ®ƒÎÿ׃Õÿ׃òÿ׃ÿ®ƒ ÿ®ƒsÿ׃Ïÿ׃ÿ׃ÿׄÿ®„ÿ®„ÎÿׄÕÿׄòÿׄÿ®„ ÿ®„sÿׄÏÿׄÿׄÿ×…ÿ®…ÿ®…Îÿ×…Õÿ×…òÿ×…ÿ®… ÿ®…sÿ×…Ïÿ×…ÿ×…ÿ׆ÿ®†ÿ®†ÿ솤ÿ׆¦ÿ솨ÿ׆ªÿ׆®ÿ׆°ÿ׆±ÿ솵ÿ׆¼ÿƽÿ׆¿ÿ׆Áÿ׆Äÿì†Çÿì†Îÿì†Õÿì†òÿì†ÿ®† ÿ®†rÿ׆sÿì†zÿì†|ÿ׆€ÿ솂ÿ솟ÿ׆¡ÿ솩ÿ솵ÿÆ·ÿ솹ÿ솻ÿ׆½ÿ솿ÿ׆Áÿ׆Êÿ׆Îÿ׆Ïÿì†Ôÿ׆Ùÿ׆Ûÿ׆Ýÿ׆åÿ׆çÿì†õÿì†÷ÿ׆ùÿ׆ûÿ׆ýÿ׆ÿ׆ÿ׆ ÿ׆ÿ׆ÿ׆ÿì†ÿì†ÿ׆ÿì‡ÿì‡ ÿì‡ÐÿׇÜÿì‡Ýÿì‡ßÿׇáÿì‡äÿì‡öÿì‡ÿì‡ ÿ쇠ÿׇªÿ쇶ÿ쇼ÿׇ¾ÿì‡Àÿì‡Âÿì‡ËÿׇÕÿì‡æÿׇøÿì‡úÿì‡üÿì‡þÿì‡ÿׇÿׇÿì‡ÿì‡ÿìˆÿ®ˆÿ®ˆÿ숤ÿ׈¦ÿ숨ÿ׈ªÿ׈®ÿ׈°ÿ׈±ÿ숵ÿ׈¼ÿȽÿ׈¿ÿ׈Áÿ׈ÄÿìˆÇÿìˆÎÿìˆÕÿìˆòÿìˆÿ®ˆ ÿ®ˆrÿ׈sÿìˆzÿìˆ|ÿ׈€ÿ숂ÿ숟ÿ׈¡ÿ숩ÿ숵ÿÈ·ÿ숹ÿ숻ÿ׈½ÿ숿ÿ׈Áÿ׈Êÿ׈Îÿ׈ÏÿìˆÔÿ׈Ùÿ׈Ûÿ׈Ýÿ׈åÿ׈çÿìˆõÿìˆ÷ÿ׈ùÿ׈ûÿ׈ýÿ׈ÿ׈ÿ׈ ÿ׈ÿ׈ÿ׈ÿìˆÿìˆÿ׈ÿì‰ÿì‰ ÿì‰Ðÿ׉Üÿì‰Ýÿì‰ßÿ׉áÿì‰äÿì‰öÿì‰ÿì‰ ÿ쉠ÿ׉ªÿ쉶ÿ쉼ÿ׉¾ÿì‰Àÿì‰Âÿì‰Ëÿ׉Õÿì‰æÿ׉øÿì‰úÿì‰üÿì‰þÿì‰ÿ׉ÿ׉ÿì‰ÿì‰ÿìŠÿ®Šÿ®Šÿ스ÿ׊¦ÿ슨ÿ׊ªÿ׊®ÿ׊°ÿ׊±ÿ습ÿ׊¼ÿʽÿ׊¿ÿ׊Áÿ׊ÄÿìŠÇÿìŠÎÿìŠÕÿìŠòÿìŠÿ®Š ÿ®Šrÿ׊sÿìŠzÿìŠ|ÿ׊€ÿ슂ÿ슟ÿ׊¡ÿ슩ÿ습ÿÊ·ÿ승ÿ슻ÿ׊½ÿ슿ÿ׊Áÿ׊Êÿ׊Îÿ׊ÏÿìŠÔÿ׊Ùÿ׊Ûÿ׊Ýÿ׊åÿ׊çÿìŠõÿìŠ÷ÿ׊ùÿ׊ûÿ׊ýÿ׊ÿ׊ÿ׊ ÿ׊ÿ׊ÿ׊ÿìŠÿìŠÿ׊ÿì‹ÿ®‹ÿ®‹Îÿ׋Õÿ׋òÿ׋ÿ®‹ ÿ®‹sÿ׋Ïÿ׋ÿ׋ÿ׌Ÿÿ׌¸ÿ׌»ÿ׌¾ÿ׌áÿ׌lÿ׌~ÿ׌„ÿ׌†ÿ׌ˆÿ׌Šÿ׌Œÿ׌±ÿ׌³ÿ׌Àÿ׌Âÿ׌Åÿ׌Çÿ׌Õÿ׌ïÿ׌ñÿ׌óÿ׌þÿ׌ ÿ׌ ÿ׌ÿ׌ÿ׌ÿו£á•ê)•ÿוÿ×–ÿì– ÿì–ÿì– ÿì—ÿ®— ÿ®—ÿ×—¦ÿ×—¼ÿ®—Áÿ®—Äÿ×—Üÿ×—äÿ×—ÿ®— ÿ®—|ÿ®—€ÿׂÿשÿ×—ªÿ×—µÿ®—¶ÿ×—·ÿ×¹ÿ×½ÿ×—¾ÿ×—¿ÿ®—Áÿ®—Ôÿ®—ýÿ®— ÿš—ÿš—ÿ×—ÿטÿ…˜ ÿ…˜ÐÿטÜÿš˜ÝÿØßÿטáÿ®˜äÿš˜öÿØÿ…˜ ÿ…˜mÿטÿטƒÿט‹ÿט ÿטªÿš˜¶ÿš˜¸ÿغÿؼÿט¾ÿš˜Àÿ®˜Âÿ®˜ÆÿטÈÿטËÿטÕÿ®˜æÿטêÿטøÿØúÿØüÿØþÿ®˜ÿטÿטÿš˜ÿš˜ÿš™þö™þö™¤ÿ…™ªÿš™®ÿ…™°ÿ×™µÿ…™¿ÿ×™Îÿš™Õÿš™òÿš™þö™ þö™rÿš™sÿš™vÿ왟ÿ×™»ÿ×™Êÿ×™Îÿ…™Ïÿš™Ùÿš™Ûÿš™Ýÿš™åÿ×™ÿ×™ÿ×™ ÿ®™ ÿ®™ÿ…™ÿš™ÿ…™ÿššÿìš ÿìšÐÿךÜÿìšÝÿìšßÿךáÿìšäÿìšöÿìšÿìš ÿìš ÿךªÿ욶ÿìš¼ÿך¾ÿìšÀÿìšÂÿìšËÿךÕÿìšæÿךøÿìšúÿìšüÿìšþÿìšÿךÿךÿìšÿìšÿì›ÿš›ÿ×›ÿš›)›Ÿÿ×›¤ÿ®›¦)›ªÿ…›®ÿ®›µÿ®›¸ÿ×›»ÿ×›¼)›¾ÿÛÄ)›ÌÿÛÍÿÛÎÿš›Ïÿ®›Ðÿ×›Ñÿ×›ÒÿÛÓÿÛÔÿÛÕÿš›ÖÿÛ×ÿÛØÿ®›ÙÿÛÚÿÛÛÿ®›Þÿ®›ßÿ×›àÿÛáÿš›âÿÛãÿÛåÿÛæÿÛçÿ×›èÿÛêÿ®›ë)›ìÿÛíÿ®›îÿÛòÿš›óÿÛô)›õÿÛ÷ÿÛùÿÛÿ×›ÿ×›ÿ×›ÿš› ÿš›jÿ®›kÿÛlÿ×›qÿÛrÿ…›sÿš›uÿÛwÿ×›yÿÛ}ÿÛ~ÿ×›ÿ®›„ÿ×›…ÿ®›†ÿ×›‡ÿ®›ˆÿ×›‰ÿ®›Šÿ×›Œÿ×›ÿ®›–ÿÛ˜)›šÿÛžÿÛ ÿ×›¢ÿ×›¤ÿÛ¦ÿÛ¨)›©)›¬ÿÛ®ÿÛ°ÿÛ±ÿ×›²ÿ®›³ÿ×›´ÿ®›µ)›¼ÿ×›½)›Àÿš›Âÿš›ÄÿÛÅÿ×›ÆÿÛÇÿ×›ÈÿÛËÿ×›ÍÿÛÎÿ®›Ïÿš›ÑÿÛÓÿÛÕÿš›×ÿÛÙÿ…›Ûÿ…›Ýÿ…›àÿ®›æÿ×›èÿ×›ìÿÛîÿÛïÿ×›ðÿ®›ñÿ×›òÿ®›óÿ×›ôÿ®›öÿ×›þÿš›ÿÛÿÛÿ×›ÿ×› ÿš› ÿ®› ÿš› ÿ®›ÿ×›ÿ×›ÿ®›ÿš›ÿÛÿ×›ÿ®›)›ÿ®›ÿ®›ÿšœÿÃœÿÃœÎÿÃœÏÿלÕÿÃœØÿלÛÿלÞÿלêÿלíÿלòÿÃœÿÃœ ÿÃœjÿלsÿÃœÿל…ÿל‡ÿל‰ÿלÿל²ÿל´ÿלÏÿÃœàÿלðÿלòÿלôÿל ÿל ÿלÿÃœÿלÿלÿÃÿà ÿÃÿãf¦ÿüÿÃÁÿ®ÄÿÃÜÿ×áÿ×äÿ×ÿà ÿÃ|ÿ®€ÿÂÿéÿêÿ×µÿöÿ×·ÿ×¹ÿ×½ÿþÿ׿ÿ®Àÿ×Áÿ®Âÿ×Ôÿ®Õÿ×ýÿ®þÿ× ÿ×ÿÃÿ×ÿÃÿÃÿמÿÞ ÿÞÿÞ ÿÞÿמÿןŸÿן£áŸ¸ÿן»ÿן¾ÿßÜÿןáÿ®Ÿäÿןlÿן{=Ÿ}ÿìŸ~ÿן„ÿן†ÿןˆÿןŠÿןŒÿןªÿן±ÿן³ÿן¶ÿן¾ÿןÀÿ®ŸÂÿ®ŸÅÿßÆÿןÇÿßÈÿןÕÿ®Ÿïÿןñÿןóÿןþÿ®Ÿÿןÿןÿןÿ× Ïÿì Øÿì Ûÿì Þÿì áÿì êÿì íÿì jÿì ÿì …ÿì ‡ÿì ‰ÿì ÿì ²ÿì ´ÿì Àÿì Âÿì Õÿì àÿì ðÿì òÿì ôÿì þÿì  ÿì  ÿì ÿ× ÿ× ÿì ÿì¡ÿ®¡ÿ®¡ÿ®¡ ÿ®¡€ÿì¡‚ÿì¡·ÿ졹ÿì¡ ÿסÿ×¢é)£Ÿÿ×££á£¸ÿ×£»ÿ×£¾ÿãÜÿ×£áÿ®£äÿ×£lÿ×£{=£}ÿì£~ÿ×£„ÿ×£†ÿ×£ˆÿ×£Šÿ×£Œÿ×£ªÿ×£±ÿ×£³ÿ×£¶ÿ×£¾ÿ×£Àÿ®£Âÿ®£ÅÿãÆÿ×£ÇÿãÈÿ×£Õÿ®£ïÿ×£ñÿ×£óÿ×£þÿ®£ÿ×£ÿ×£ÿ×£ÿפÏÿì¤Øÿì¤Ûÿì¤Þÿì¤áÿì¤êÿì¤íÿì¤jÿì¤ÿ줅ÿ줇ÿ줉ÿì¤ÿ줲ÿ줴ÿì¤Àÿì¤Âÿì¤Õÿì¤àÿì¤ðÿì¤òÿì¤ôÿì¤þÿì¤ ÿì¤ ÿì¤ÿפÿפÿì¤ÿ쥟ÿ×¥¸ÿ×¥»ÿ×¥¾ÿ×¥Áÿ×¥áÿ×¥lÿ×¥|ÿ×¥~ÿ×¥„ÿ×¥†ÿ×¥ˆÿ×¥Šÿ×¥Œÿ×¥±ÿ×¥³ÿ×¥¿ÿ×¥Àÿ×¥Áÿ×¥Âÿ×¥Åÿš¥Çÿš¥Ôÿ×¥Õÿ×¥ïÿ×¥ñÿ×¥óÿ×¥ýÿ×¥þÿ×¥ ÿ×¥ ÿ×¥ÿ×¥ÿ×¥ÿ×¥ÿì¦ÏÿצØÿצÛÿצÞÿצáÿצêÿצíÿצjÿצÿצ…ÿצ‡ÿצ‰ÿצÿצ²ÿצ´ÿצÀÿצÂÿצÆÿצÈÿצÕÿצàÿצðÿצòÿצôÿצþÿצ ÿצ ÿצÿצÿקŸÿק¸ÿק»ÿק¾ÿקÁÿקáÿקlÿק|ÿק~ÿק„ÿק†ÿקˆÿקŠÿקŒÿק±ÿק³ÿק¿ÿקÀÿקÁÿקÂÿקÅÿš§Çÿš§ÔÿקÕÿקïÿקñÿקóÿקýÿקþÿק ÿק ÿקÿקÿקÿקÿì¨ÏÿרØÿרÛÿרÞÿרáÿרêÿרíÿרjÿרÿר…ÿר‡ÿר‰ÿרÿר²ÿר´ÿרÀÿרÂÿרÆÿרÈÿרÕÿרàÿרðÿרòÿרôÿרþÿר ÿר ÿרÿרÿשŸÿש¸ÿש»ÿש¾ÿשÁÿשáÿשlÿש|ÿש~ÿש„ÿש†ÿשˆÿשŠÿשŒÿש±ÿש³ÿש¿ÿשÀÿשÁÿשÂÿשÅÿš©Çÿš©ÔÿשÕÿשïÿשñÿשóÿשýÿשþÿש ÿש ÿשÿשÿשÿשÿìªÏÿתØÿתÛÿתÞÿתáÿתêÿתíÿתjÿתÿת…ÿת‡ÿת‰ÿתÿת²ÿת´ÿתÀÿתÂÿתÆÿתÈÿתÕÿתàÿתðÿתòÿתôÿתþÿת ÿת ÿתÿתÿ׫£á«ê)«ÿ׫ÿ׬ÿì¬ ÿì¬ÿì¬ ÿì­ÿš­ÿ×­ÿš­)­Ÿÿ×­¤ÿ®­¦)­ªÿ…­®ÿ®­µÿ®­¸ÿ×­»ÿ×­¼)­¾ÿíÄ)­ÌÿíÍÿíÎÿš­Ïÿ®­Ðÿ×­Ñÿ×­ÒÿíÓÿíÔÿíÕÿš­Öÿí×ÿíØÿ®­ÙÿíÚÿíÛÿ®­Þÿ®­ßÿ×­àÿíáÿš­âÿíãÿíåÿíæÿíçÿ×­èÿíêÿ®­ë)­ìÿííÿ®­îÿíòÿš­óÿíô)­õÿí÷ÿíùÿíÿ×­ÿ×­ÿ×­ÿš­ ÿš­jÿ®­kÿílÿ×­qÿírÿ…­sÿš­uÿíwÿ×­yÿí}ÿí~ÿ×­ÿ®­„ÿ×­…ÿ®­†ÿ×­‡ÿ®­ˆÿ×­‰ÿ®­Šÿ×­Œÿ×­ÿ®­–ÿí˜)­šÿížÿí ÿ×­¢ÿ×­¤ÿí¦ÿí¨)­©)­¬ÿí®ÿí°ÿí±ÿ×­²ÿ®­³ÿ×­´ÿ®­µ)­¼ÿ×­½)­Àÿš­Âÿš­ÄÿíÅÿ×­ÆÿíÇÿ×­ÈÿíËÿ×­ÍÿíÎÿ®­Ïÿš­ÑÿíÓÿíÕÿš­×ÿíÙÿ…­Ûÿ…­Ýÿ…­àÿ®­æÿ×­èÿ×­ìÿíîÿíïÿ×­ðÿ®­ñÿ×­òÿ®­óÿ×­ôÿ®­öÿ×­þÿš­ÿíÿíÿ×­ÿ×­ ÿš­ ÿ®­ ÿš­ ÿ®­ÿ×­ÿ×­ÿ®­ÿš­ÿíÿ×­ÿ®­)­ÿ®­ÿ®­ÿš®ÿš®ÿ×®ÿš®ÎÿîÏÿì®ÕÿîØÿì®Ûÿì®Þÿì®êÿì®íÿì®òÿîÿ×®ÿ×®ÿ×®ÿš® ÿš®jÿì®sÿîÿì®…ÿ쮇ÿ쮉ÿì®ÿ쮲ÿì®´ÿì®Ïÿîàÿì®ðÿì®òÿì®ôÿì® ÿì® ÿì®ÿîÿì®ÿì®ÿïÿ\¯ ÿ\¯ÿš¯£f¯¦ÿš¯¼ÿH¯Áÿ…¯Äÿš¯Üÿ®¯áÿׯäÿ®¯ÿ\¯ ÿ\¯|ÿ…¯€ÿq¯‚ÿq¯©ÿš¯ªÿ®¯µÿH¯¶ÿ®¯·ÿš¯¹ÿš¯½ÿš¯¾ÿ®¯¿ÿ…¯ÀÿׯÁÿ…¯ÂÿׯÅÿïÆÿׯÇÿïÈÿׯÔÿ…¯Õÿׯýÿ…¯þÿׯ ÿH¯ÿ®¯ÿH¯ÿ®¯ÿš¯ÿ®°ÿq° ÿq°Üÿš°áÿ×°äÿš°ÿq° ÿq°mÿ×°ÿ×°ƒÿ×°‹ÿ×°ªÿš°¶ÿš°¸ÿ×°ºÿ×°¾ÿš°Àÿ×°Âÿ×°Æÿ×°Èÿ×°Õÿ×°þÿ×°ÿq°ÿq°ÿš±ÿ×±¦ÿ×±¼ÿñÄÿ×±€ÿ챂ÿ챩ÿ×±µÿñ·ÿì±¹ÿì±½ÿ×± ÿ×±ÿ×±ÿײÿì² ÿì²ÐÿײÜÿì²Ýÿì²ßÿײáÿì²äÿì²öÿì²ÿì² ÿì² ÿײªÿ첶ÿì²¼ÿײ¾ÿì²Àÿì²Âÿì²ËÿײÕÿì²æÿײøÿì²úÿì²üÿì²þÿì²ÿײÿײÿì²ÿì²ÿ쳟ÿ׳¸ÿ׳»ÿ׳¾ÿ׳áÿ׳lÿ׳~ÿ׳„ÿ׳†ÿ׳ˆÿ׳Šÿ׳Œÿ׳±ÿ׳³ÿ׳Àÿ׳Âÿ׳Åÿ׳Çÿ׳Õÿ׳ïÿ׳ñÿ׳óÿ׳þÿ׳ ÿ׳ ÿ׳ÿ׳ÿ׳ÿ×µÿ…µÿ®µÿ…µŸÿ×µ¤ÿšµªÿqµ®ÿšµµÿšµ¸ÿ×µ»ÿ×µ¼)µ¾ÿ®µÌÿšµÍÿšµÎÿ…µÏÿqµÐÿ×µÑÿ×µÒÿšµÓÿšµÔÿšµÕÿ…µÖÿšµ×ÿšµØÿqµÙÿšµÚÿšµÛÿqµÜÿ®µÝÿ®µÞÿqµßÿ×µàÿšµáÿšµâÿšµãÿšµäÿ®µåÿšµæÿšµçÿ×µèÿšµéÿõêÿqµìÿšµíÿqµîÿ…µòÿ…µóÿšµõÿšµöÿ®µ÷ÿšµùÿšµÿ®µÿ®µÿ®µÿ…µ ÿ…µjÿqµkÿšµlÿ×µmÿ×µqÿšµrÿqµsÿ…µuÿšµwÿšµyÿšµ}ÿšµ~ÿ×µÿqµÿ×µƒÿ×µ„ÿ×µ…ÿqµ†ÿ×µ‡ÿqµˆÿ×µ‰ÿqµŠÿ×µ‹ÿ×µŒÿ×µÿqµ–ÿšµšÿšµžÿšµ ÿ×µ¢ÿ×µ¤ÿšµ¦ÿšµªÿ®µ¬ÿšµ®ÿšµ°ÿšµ±ÿ×µ²ÿqµ³ÿ×µ´ÿqµµ)µ¶ÿ®µ¸ÿ®µºÿ®µ¼ÿ×µ¾ÿ®µÀÿšµÂÿšµÄÿšµÅÿšµÆÿqµÇÿšµÈÿqµËÿ×µÍÿšµÎÿšµÏÿ…µÑÿšµÓÿšµÕÿšµ×ÿšµÙÿqµÛÿqµÝÿqµàÿqµæÿ×µèÿ×µêÿõìÿšµîÿšµïÿ×µðÿqµñÿ×µòÿqµóÿ×µôÿqµöÿ×µøÿ®µúÿ®µüÿ®µþÿšµÿšµÿšµÿ×µÿ×µ ÿqµ ÿqµ ÿqµ ÿqµÿšµÿšµÿšµÿ…µÿšµÿ×µÿqµÿ®µÿqµÿšµÿ…¶ÿš¶ÿ׶ÿš¶ÎÿöÏÿì¶ÕÿöØÿì¶Ûÿì¶Þÿì¶êÿì¶íÿì¶òÿöÿ׶ÿ׶ÿ׶ÿš¶ ÿš¶jÿì¶sÿöÿ춅ÿ춇ÿ춉ÿì¶ÿ춲ÿ춴ÿì¶Ïÿöàÿì¶ðÿì¶òÿì¶ôÿì¶ ÿì¶ ÿì¶ÿöÿì¶ÿì¶ÿ÷ÿ…·ÿ…·Ÿÿ×·¤ÿ®·ªÿ…·®ÿ®·µÿ®·¸ÿ×·»ÿ×·¾ÿ÷Êÿ®·Ìÿ÷Íÿ÷Îÿš·Ïÿš·Òÿ÷Óÿ÷Ôÿ÷Õÿš·Öÿ÷×ÿ÷Øÿš·Ùÿ÷Úÿ÷Ûÿš·Þÿš·àÿ÷áÿ®·âÿ÷ãÿ÷åÿ÷æÿ÷èÿ÷éÿ×·êÿš·ë)·ìÿ÷íÿš·îÿ®·òÿš·óÿ÷ô)·õÿ÷÷ÿ÷ùÿ÷ÿ…· ÿ…·jÿš·kÿ÷lÿ×·qÿ÷rÿ…·sÿš·uÿ÷wÿ×·yÿ÷}ÿ×·~ÿ×·ÿš·„ÿ×·…ÿš·†ÿ×·‡ÿš·ˆÿ×·‰ÿš·Šÿ×·Œÿ×·ÿš·–ÿ÷˜)·šÿ÷žÿ÷¤ÿ÷¦ÿ÷¨)·¬ÿ÷®ÿ÷°ÿ÷±ÿ×·²ÿš·³ÿ×·´ÿš·Àÿ®·Âÿ®·Äÿ÷Æÿ®·Èÿ®·Íÿ÷Îÿ®·Ïÿš·Ñÿ÷Óÿ÷Õÿ®·×ÿ÷Ùÿ…·Úÿ®·Ûÿ…·Üÿ®·Ýÿ…·Þÿ®·àÿš·áÿì·âÿ®·ãÿì·äÿ®·ìÿ÷îÿ÷ïÿ×·ðÿš·ñÿ×·òÿš·óÿ×·ôÿš·þÿ®·ÿ÷ÿ÷ ÿ®· ÿš· ÿ®· ÿš·ÿ×·ÿ×·ÿ®·ÿš·ÿ÷ÿ×·ÿš·ÿì·ÿš·ÿ®·ÿš¸ÿ®¸ÿ®¸Îÿì¸Õÿì¸òÿì¸ÿ®¸ ÿ®¸sÿì¸Ïÿì¸ÿì¸ÿì¹ÿ…¹ÿ…¹Ÿÿ×¹¤ÿ®¹ªÿ…¹®ÿ®¹µÿ®¹¸ÿ×¹»ÿ×¹¾ÿùÊÿ®¹ÌÿùÍÿùÎÿš¹Ïÿš¹ÒÿùÓÿùÔÿùÕÿš¹Öÿù×ÿùØÿš¹ÙÿùÚÿùÛÿš¹Þÿš¹àÿùáÿ®¹âÿùãÿùåÿùæÿùèÿùéÿ×¹êÿš¹ë)¹ìÿùíÿš¹îÿ®¹òÿš¹óÿùô)¹õÿù÷ÿùùÿùÿ…¹ ÿ…¹jÿš¹kÿùlÿ×¹qÿùrÿ…¹sÿš¹uÿùwÿ×¹yÿù}ÿ×¹~ÿ×¹ÿš¹„ÿ×¹…ÿš¹†ÿ×¹‡ÿš¹ˆÿ×¹‰ÿš¹Šÿ×¹Œÿ×¹ÿš¹–ÿù˜)¹šÿùžÿù¤ÿù¦ÿù¨)¹¬ÿù®ÿù°ÿù±ÿ×¹²ÿš¹³ÿ×¹´ÿš¹Àÿ®¹Âÿ®¹ÄÿùÆÿ®¹Èÿ®¹ÍÿùÎÿ®¹Ïÿš¹ÑÿùÓÿùÕÿ®¹×ÿùÙÿ…¹Úÿ®¹Ûÿ…¹Üÿ®¹Ýÿ…¹Þÿ®¹àÿš¹áÿì¹âÿ®¹ãÿì¹äÿ®¹ìÿùîÿùïÿ×¹ðÿš¹ñÿ×¹òÿš¹óÿ×¹ôÿš¹þÿ®¹ÿùÿù ÿ®¹ ÿš¹ ÿ®¹ ÿš¹ÿ×¹ÿ×¹ÿ®¹ÿš¹ÿùÿ×¹ÿš¹ÿì¹ÿš¹ÿ®¹ÿšºÿ®ºÿ®ºÎÿìºÕÿìºòÿìºÿ®º ÿ®ºsÿìºÏÿìºÿìºÿ컟ÿ×»£á»¸ÿ×»»ÿ×»¾ÿûÜÿ×»áÿ®»äÿ×»lÿ×»{=»}ÿì»~ÿ×»„ÿ×»†ÿ×»ˆÿ×»Šÿ×»Œÿ×»ªÿ×»±ÿ×»³ÿ×»¶ÿ×»¾ÿ×»Àÿ®»Âÿ®»ÅÿûÆÿ×»ÇÿûÈÿ×»Õÿ®»ïÿ×»ñÿ×»óÿ×»þÿ®»ÿ×»ÿ×»ÿ×»ÿ×¼Ïÿì¼Øÿì¼Ûÿì¼Þÿì¼áÿì¼êÿì¼íÿì¼jÿì¼ÿì¼…ÿ켇ÿ켉ÿì¼ÿì¼²ÿì¼´ÿì¼Àÿì¼Âÿì¼Õÿì¼àÿì¼ðÿì¼òÿì¼ôÿì¼þÿì¼ ÿì¼ ÿì¼ÿ×¼ÿ×¼ÿì¼ÿì½£á½ê)½ÿ×½ÿ×¾ÿì¾ ÿì¾ÿì¾ ÿì¿£á¿ê)¿ÿ׿ÿ×ÀÿìÀ ÿìÀÿìÀ ÿìÃÿÃà ÿÃÃÿ×æÿ×üÿ…ÃÁÿ®ÃÄÿ×ÃÜÿ×ÃÝÿìÃáÿìÃäÿ×ÃöÿìÃÿÃà ÿÃÃ|ÿ®Ã€ÿÃÂÿÃéÿ×êÿ×õÿ…öÿ×÷ÿšÃ¹ÿšÃ½ÿ×þÿ×ÿÿ®ÃÀÿìÃÁÿ®ÃÂÿìÃÔÿ®ÃÕÿìÃøÿìÃúÿìÃüÿìÃýÿ®Ãþÿìà ÿ®Ãÿ×Ãÿ®Ãÿ×Ãÿ×Ãÿ×ÄÿšÄ ÿšÄÜÿ×ÄÝÿ×Ääÿ×Äöÿ×ÄÿšÄ ÿšÄªÿ×Ķÿ×ĸÿ×ĺÿ׾ÿ×Äøÿ×Äúÿ×Äüÿ×Äÿ®Äÿ®Äÿ׿ÿ×Å€ÿìÅ‚ÿìŵÿ×Å·ÿìŹÿìÅ ÿìÅÿìÆÿìÆ ÿìÆÿìÆ ÿìǼÿ×Ç€ÿìÇ‚ÿìǵÿ×Ç·ÿìǹÿìÇ ÿìÇÿìÈÿìÈ ÿìÈÿìÈ ÿìÊŸÿ×ʸÿ×Ê»ÿ×ʾÿ×ÊÁÿ×Êáÿ×Êlÿ×Ê|ÿ×Ê~ÿ×Ê„ÿ×ʆÿ×ʈÿ×ÊŠÿ×ÊŒÿ×ʱÿ×ʳÿ×Ê¿ÿ×ÊÀÿ×ÊÁÿ×ÊÂÿ×ÊÅÿšÊÇÿšÊÔÿ×ÊÕÿ×Êïÿ×Êñÿ×Êóÿ×Êýÿ×Êþÿ×Ê ÿ×Ê ÿ×Êÿ×Êÿ×Êÿ×ÊÿìËÏÿ×ËØÿ×ËÛÿ×ËÞÿ×Ëáÿ×Ëêÿ×Ëíÿ×Ëjÿ×Ëÿ×Ë…ÿסÿ×ˉÿ×Ëÿ×˲ÿ×Ë´ÿ×ËÀÿ×ËÂÿ×ËÆÿ×ËÈÿ×ËÕÿ×Ëàÿ×Ëðÿ×Ëòÿ×Ëôÿ×Ëþÿ×Ë ÿ×Ë ÿ×Ëÿ×Ëÿ×ÌÿÃÌ ÿÃÌ£f̼ÿ×̾ÿ×ÌÁÿ®ÌÜÿÃÌáÿ×ÌäÿÃÌÿÃÌ ÿÃÌmÿìÌ|ÿ®Ì€ÿ×ÌÿìÌ‚ÿ×̃ÿìÌ‹ÿì̪ÿÃ̵ÿ×̶ÿÃÌ·ÿ×̸ÿì̹ÿ×̺ÿì̾ÿÃÌ¿ÿ®ÌÀÿ×ÌÁÿ®ÌÂÿ×ÌÅÿÃÌÆÿ×ÌÇÿÃÌÈÿ×ÌÔÿ®ÌÕÿ×Ìýÿ®Ìþÿ×Ì ÿ×ÌÿÃÌÿ×ÌÿÃÌÿÃÍáÿ×ÍÀÿ×ÍÂÿ×ÍÕÿ×Íþÿ×ΣáÎê)Îÿ×Îÿ×ÏÿìÏ ÿìÏÿìÏ ÿìÒ£áÒê)Òÿ×Òÿ×ÓÿìÓ ÿìÓÿìÓ ÿìÖ£áÖê)Öÿ×Öÿ××ÿì× ÿì×ÿì× ÿìÙÿqÙ ÿqÙÿšÙ¦ÿšÙ¼ÿqÙ¾ÿ×ÙÁÿšÙÄÿšÙÜÿ×Ùáÿ×Ùäÿ×ÙÿqÙ ÿqÙnÿ×Ù|ÿšÙ€ÿ®Ù‚ÿ®Ù—ÿ×Ù›ÿ×Ù§ÿ×Ù©ÿšÙªÿ×ÙµÿqÙ¶ÿ×Ù·ÿ…Ù¹ÿ…Ù½ÿšÙ¾ÿ×Ù¿ÿšÙÀÿ×ÙÁÿšÙÂÿ×ÙÅÿšÙÇÿšÙÔÿšÙÕÿ×Ùáÿ×Ùãÿ×ÙýÿšÙþÿ×Ùÿ×Ù ÿqÙÿ×ÙÿqÙÿ×ÙÿšÙÿ×ÚÿìÚ ÿìÚÿìÚ ÿìÛÿqÛ ÿqÛÿšÛ¦ÿšÛ¼ÿqÛ¾ÿ×ÛÁÿšÛÄÿšÛÜÿ×Ûáÿ×Ûäÿ×ÛÿqÛ ÿqÛnÿ×Û|ÿšÛ€ÿ®Û‚ÿ®Û—ÿ×Û›ÿ×Û§ÿ×Û©ÿšÛªÿ×ÛµÿqÛ¶ÿ×Û·ÿ…Û¹ÿ…Û½ÿšÛ¾ÿ×Û¿ÿšÛÀÿ×ÛÁÿšÛÂÿ×ÛÅÿšÛÇÿšÛÔÿšÛÕÿ×Ûáÿ×Ûãÿ×ÛýÿšÛþÿ×Ûÿ×Û ÿqÛÿ×ÛÿqÛÿ×ÛÿšÛÿ×ÜÿìÜ ÿìÜÿìÜ ÿìÞÿìÞ ÿìÞÿìÞ ÿìàÿìà ÿìàÿìà ÿìáÿ®áÿ®áÿìá¤ÿ×á¦ÿìá¨ÿ×áªÿ×á®ÿ×á°ÿ×á±ÿìáµÿ×á¼ÿÃá½ÿ×á¿ÿ×áÁÿ×áÄÿìáÇÿìáÎÿìáÕÿìáòÿìáÿ®á ÿ®árÿ×ásÿìázÿìá|ÿ×á€ÿìá‚ÿìáŸÿ×á¡ÿìá©ÿìáµÿÃá·ÿìá¹ÿìá»ÿ×á½ÿìá¿ÿ×áÁÿ×áÊÿ×áÎÿ×áÏÿìáÔÿ×áÙÿ×áÛÿ×áÝÿ×áåÿ×áçÿìáõÿìá÷ÿ×áùÿ×áûÿ×áýÿ×áÿ×áÿ×á ÿ×áÿ×áÿ×áÿìáÿìáÿ×áÿìâÿìâ ÿìâÐÿ×âÜÿìâÝÿìâßÿ×âáÿìâäÿìâöÿìâÿìâ ÿìâ ÿ×âªÿìâ¶ÿìâ¼ÿ×â¾ÿìâÀÿìâÂÿìâËÿ×âÕÿìâæÿ×âøÿìâúÿìâüÿìâþÿìâÿ×âÿ×âÿìâÿìâÿìãÿ®ãÿ®ãÿìã¤ÿ×ã¦ÿìã¨ÿ×ãªÿ×ã®ÿ×ã°ÿ×ã±ÿìãµÿ×ã¼ÿÃã½ÿ×ã¿ÿ×ãÁÿ×ãÄÿìãÇÿìãÎÿìãÕÿìãòÿìãÿ®ã ÿ®ãrÿ×ãsÿìãzÿìã|ÿ×ã€ÿìã‚ÿìãŸÿ×ã¡ÿìã©ÿìãµÿÃã·ÿìã¹ÿìã»ÿ×ã½ÿìã¿ÿ×ãÁÿ×ãÊÿ×ãÎÿ×ãÏÿìãÔÿ×ãÙÿ×ãÛÿ×ãÝÿ×ãåÿ×ãçÿìãõÿìã÷ÿ×ãùÿ×ãûÿ×ãýÿ×ãÿ×ãÿ×ã ÿ×ãÿ×ãÿ×ãÿìãÿìãÿ×ãÿìäÿìä ÿìäÐÿ×äÜÿìäÝÿìäßÿ×äáÿìääÿìäöÿìäÿìä ÿìä ÿ×äªÿìä¶ÿìä¼ÿ×ä¾ÿìäÀÿìäÂÿìäËÿ×äÕÿìäæÿ×äøÿìäúÿìäüÿìäþÿìäÿ×äÿ×äÿìäÿìäÿìåŸÿ×å¸ÿ×å»ÿ×å¾ÿ×åÁÿ×åáÿ×ålÿ×å|ÿ×å~ÿ×å„ÿ×å†ÿ×åˆÿ×åŠÿ×åŒÿ×å±ÿ×å³ÿ×å¿ÿ×åÀÿ×åÁÿ×åÂÿ×åÅÿšåÇÿšåÔÿ×åÕÿ×åïÿ×åñÿ×åóÿ×åýÿ×åþÿ×å ÿ×å ÿ×åÿ×åÿ×åÿ×åÿìæÏÿ×æØÿ×æÛÿ×æÞÿ×æáÿ×æêÿ×æíÿ×æjÿ×æÿ×æ…ÿ×æ‡ÿ×æ‰ÿ×æÿ×æ²ÿ×æ´ÿ×æÀÿ×æÂÿ×æÆÿ×æÈÿ×æÕÿ×æàÿ×æðÿ×æòÿ×æôÿ×æþÿ×æ ÿ×æ ÿ×æÿ×æÿ×çÿ®çÿ®çÿ®ç ÿ®ç€ÿìç‚ÿìç·ÿìç¹ÿìç ÿ×çÿ×èé)éÿìé ÿìéÿìé ÿìéÿ×éÿ×ïÿ®ïÿ®ïÿìï¤ÿ×ï¦ÿìï¨ÿ×ïªÿ×ï®ÿ×ï°ÿ×ï±ÿìïµÿ×ï¼ÿÃï½ÿ×ï¿ÿ×ïÁÿ×ïÄÿìïÇÿìïÎÿìïÕÿìïòÿìïÿ®ï ÿ®ïrÿ×ïsÿìïzÿìï|ÿ×ï€ÿìï‚ÿìïŸÿ×ï¡ÿìï©ÿìïµÿÃï·ÿìï¹ÿìï»ÿ×ï½ÿìï¿ÿ×ïÁÿ×ïÊÿ×ïÎÿ×ïÏÿìïÔÿ×ïÙÿ×ïÛÿ×ïÝÿ×ïåÿ×ïçÿìïõÿìï÷ÿ×ïùÿ×ïûÿ×ïýÿ×ïÿ×ïÿ×ï ÿ×ïÿ×ïÿ×ïÿìïÿìïÿ×ïÿìðÿìð ÿìðÐÿ×ðÜÿìðÝÿìðßÿ×ðáÿìðäÿìðöÿìðÿìð ÿìð ÿ×ðªÿìð¶ÿìð¼ÿ×ð¾ÿìðÀÿìðÂÿìðËÿ×ðÕÿìðæÿ×ðøÿìðúÿìðüÿìðþÿìðÿ×ðÿ×ðÿìðÿìðÿìñÿ®ñÿ®ñÿìñ¤ÿ×ñ¦ÿìñ¨ÿ×ñªÿ×ñ®ÿ×ñ°ÿ×ñ±ÿìñµÿ×ñ¼ÿÃñ½ÿ×ñ¿ÿ×ñÁÿ×ñÄÿìñÇÿìñÎÿìñÕÿìñòÿìñÿ®ñ ÿ®ñrÿ×ñsÿìñzÿìñ|ÿ×ñ€ÿìñ‚ÿìñŸÿ×ñ¡ÿìñ©ÿìñµÿÃñ·ÿìñ¹ÿìñ»ÿ×ñ½ÿìñ¿ÿ×ñÁÿ×ñÊÿ×ñÎÿ×ñÏÿìñÔÿ×ñÙÿ×ñÛÿ×ñÝÿ×ñåÿ×ñçÿìñõÿìñ÷ÿ×ñùÿ×ñûÿ×ñýÿ×ñÿ×ñÿ×ñ ÿ×ñÿ×ñÿ×ñÿìñÿìñÿ×ñÿìòÿìò ÿìòÐÿ×òÜÿìòÝÿìòßÿ×òáÿìòäÿìòöÿìòÿìò ÿìò ÿ×òªÿìò¶ÿìò¼ÿ×ò¾ÿìòÀÿìòÂÿìòËÿ×òÕÿìòæÿ×òøÿìòúÿìòüÿìòþÿìòÿ×òÿ×òÿìòÿìòÿìóÿ®óÿ®óÿìó¤ÿ×ó¦ÿìó¨ÿ×óªÿ×ó®ÿ×ó°ÿ×ó±ÿìóµÿ×ó¼ÿÃó½ÿ×ó¿ÿ×óÁÿ×óÄÿìóÇÿìóÎÿìóÕÿìóòÿìóÿ®ó ÿ®órÿ×ósÿìózÿìó|ÿ×ó€ÿìó‚ÿìóŸÿ×ó¡ÿìó©ÿìóµÿÃó·ÿìó¹ÿìó»ÿ×ó½ÿìó¿ÿ×óÁÿ×óÊÿ×óÎÿ×óÏÿìóÔÿ×óÙÿ×óÛÿ×óÝÿ×óåÿ×óçÿìóõÿìó÷ÿ×óùÿ×óûÿ×óýÿ×óÿ×óÿ×ó ÿ×óÿ×óÿ×óÿìóÿìóÿ×óÿìôÿìô ÿìôÐÿ×ôÜÿìôÝÿìôßÿ×ôáÿìôäÿìôöÿìôÿìô ÿìô ÿ×ôªÿìô¶ÿìô¼ÿ×ô¾ÿìôÀÿìôÂÿìôËÿ×ôÕÿìôæÿ×ôøÿìôúÿìôüÿìôþÿìôÿ×ôÿ×ôÿìôÿìôÿìõÿ®õÿ®õÿìõ¤ÿ×õ¦ÿìõ¨ÿ×õªÿ×õ®ÿ×õ°ÿ×õ±ÿìõµÿ×õ¼ÿÃõ½ÿ×õ¿ÿ×õÁÿ×õÄÿìõÇÿìõÎÿìõÕÿìõòÿìõÿ®õ ÿ®õrÿ×õsÿìõzÿìõ|ÿ×õ€ÿìõ‚ÿìõŸÿ×õ¡ÿìõ©ÿìõµÿÃõ·ÿìõ¹ÿìõ»ÿ×õ½ÿìõ¿ÿ×õÁÿ×õÊÿ×õÎÿ×õÏÿìõÔÿ×õÙÿ×õÛÿ×õÝÿ×õåÿ×õçÿìõõÿìõ÷ÿ×õùÿ×õûÿ×õýÿ×õÿ×õÿ×õ ÿ×õÿ×õÿ×õÿìõÿìõÿ×õÿìöÿìö ÿìöÐÿ×öÜÿìöÝÿìößÿ×öáÿìöäÿìööÿìöÿìö ÿìö ÿ×öªÿìö¶ÿìö¼ÿ×ö¾ÿìöÀÿìöÂÿìöËÿ×öÕÿìöæÿ×öøÿìöúÿìöüÿìöþÿìöÿ×öÿ×öÿìöÿìöÿì÷ÿ…÷ÿ…÷Ÿÿì÷¤ÿš÷ªÿq÷®ÿš÷µÿš÷¸ÿì÷»ÿì÷¾ÿÃ÷Éÿì÷Îÿ®÷Ïÿ×÷Õÿ®÷Øÿ×÷Ûÿ×÷Þÿ×÷áÿ×÷êÿ×÷ëf÷íÿ×÷îÿì÷òÿ®÷ôf÷ÿ…÷ ÿ…÷jÿ×÷lÿì÷rÿq÷sÿ®÷~ÿì÷ÿ×÷„ÿì÷…ÿ×÷†ÿì÷‡ÿ×÷ˆÿì÷‰ÿ×÷Šÿì÷Œÿì÷ÿ×÷˜f÷¨f÷±ÿì÷²ÿ×÷³ÿì÷´ÿ×÷Àÿ×÷Âÿ×÷Åÿ×÷ÆÿÃ÷Çÿ×÷ÈÿÃ÷Îÿš÷Ïÿ®÷Õÿ×÷Ùÿq÷Ûÿq÷Ýÿq÷àÿ×÷ïÿì÷ðÿ×÷ñÿì÷òÿ×÷óÿì÷ôÿ×÷þÿ×÷ ÿq÷ ÿ×÷ ÿq÷ ÿ×÷ÿš÷ÿ®÷ÿì÷ÿ×÷ÿ×÷ÿš÷ÿ®øÿ®øÿ®øÎÿ×øÕÿ×øòÿ×øÿ®ø ÿ®øsÿ×øÏÿ×øÿ×øÿ×ùÿ…ùÿ…ùŸÿìù¤ÿšùªÿqù®ÿšùµÿšù¸ÿìù»ÿìù¾ÿÃùÉÿìùÎÿ®ùÏÿ×ùÕÿ®ùØÿ×ùÛÿ×ùÞÿ×ùáÿ×ùêÿ×ùëfùíÿ×ùîÿìùòÿ®ùôfùÿ…ù ÿ…ùjÿ×ùlÿìùrÿqùsÿ®ù~ÿìùÿ×ù„ÿìù…ÿ×ù†ÿìù‡ÿ×ùˆÿìù‰ÿ×ùŠÿìùŒÿìùÿ×ù˜fù¨fù±ÿìù²ÿ×ù³ÿìù´ÿ×ùÀÿ×ùÂÿ×ùÅÿ×ùÆÿÃùÇÿ×ùÈÿÃùÎÿšùÏÿ®ùÕÿ×ùÙÿqùÛÿqùÝÿqùàÿ×ùïÿìùðÿ×ùñÿìùòÿ×ùóÿìùôÿ×ùþÿ×ù ÿqù ÿ×ù ÿqù ÿ×ùÿšùÿ®ùÿìùÿ×ùÿ×ùÿšùÿ®úÿ®úÿ®úÎÿ×úÕÿ×úòÿ×úÿ®ú ÿ®úsÿ×úÏÿ×úÿ×úÿ×ûÿ…ûÿ…ûŸÿìû¤ÿšûªÿqû®ÿšûµÿšû¸ÿìû»ÿìû¾ÿÃûÉÿìûÎÿ®ûÏÿ×ûÕÿ®ûØÿ×ûÛÿ×ûÞÿ×ûáÿ×ûêÿ×ûëfûíÿ×ûîÿìûòÿ®ûôfûÿ…û ÿ…ûjÿ×ûlÿìûrÿqûsÿ®û~ÿìûÿ×û„ÿìû…ÿ×û†ÿìû‡ÿ×ûˆÿìû‰ÿ×ûŠÿìûŒÿìûÿ×û˜fû¨fû±ÿìû²ÿ×û³ÿìû´ÿ×ûÀÿ×ûÂÿ×ûÅÿ×ûÆÿÃûÇÿ×ûÈÿÃûÎÿšûÏÿ®ûÕÿ×ûÙÿqûÛÿqûÝÿqûàÿ×ûïÿìûðÿ×ûñÿìûòÿ×ûóÿìûôÿ×ûþÿ×û ÿqû ÿ×û ÿqû ÿ×ûÿšûÿ®ûÿìûÿ×ûÿ×ûÿšûÿ®üÿ®üÿ®üÎÿ×üÕÿ×üòÿ×üÿ®ü ÿ®üsÿ×üÏÿ×üÿ×üÿ×ÿÿ…ÿÿ®ÿÿ…ÿŸÿ×ÿ¤ÿšÿªÿqÿ®ÿšÿµÿšÿ¸ÿ×ÿ»ÿ×ÿ¼)ÿ¾ÿ®ÿÌÿšÿÍÿšÿÎÿ…ÿÏÿqÿÐÿ×ÿÑÿ×ÿÒÿšÿÓÿšÿÔÿšÿÕÿ…ÿÖÿšÿ×ÿšÿØÿqÿÙÿšÿÚÿšÿÛÿqÿÜÿ®ÿÝÿ®ÿÞÿqÿßÿ×ÿàÿšÿáÿšÿâÿšÿãÿšÿäÿ®ÿåÿšÿæÿšÿçÿ×ÿèÿšÿéÿÃÿêÿqÿìÿšÿíÿqÿîÿ…ÿòÿ…ÿóÿšÿõÿšÿöÿ®ÿ÷ÿšÿùÿšÿÿ®ÿÿ®ÿÿ®ÿÿ…ÿ ÿ…ÿjÿqÿkÿšÿlÿ×ÿmÿ×ÿqÿšÿrÿqÿsÿ…ÿuÿšÿwÿšÿyÿšÿ}ÿšÿ~ÿ×ÿÿqÿÿ×ÿƒÿ×ÿ„ÿ×ÿ…ÿqÿ†ÿ×ÿ‡ÿqÿˆÿ×ÿ‰ÿqÿŠÿ×ÿ‹ÿ×ÿŒÿ×ÿÿqÿ–ÿšÿšÿšÿžÿšÿ ÿ×ÿ¢ÿ×ÿ¤ÿšÿ¦ÿšÿªÿ®ÿ¬ÿšÿ®ÿšÿ°ÿšÿ±ÿ×ÿ²ÿqÿ³ÿ×ÿ´ÿqÿµ)ÿ¶ÿ®ÿ¸ÿ®ÿºÿ®ÿ¼ÿ×ÿ¾ÿ®ÿÀÿšÿÂÿšÿÄÿšÿÅÿšÿÆÿqÿÇÿšÿÈÿqÿËÿ×ÿÍÿšÿÎÿšÿÏÿ…ÿÑÿšÿÓÿšÿÕÿšÿ×ÿšÿÙÿqÿÛÿqÿÝÿqÿàÿqÿæÿ×ÿèÿ×ÿêÿÃÿìÿšÿîÿšÿïÿ×ÿðÿqÿñÿ×ÿòÿqÿóÿ×ÿôÿqÿöÿ×ÿøÿ®ÿúÿ®ÿüÿ®ÿþÿšÿÿšÿÿšÿÿ×ÿÿ×ÿ ÿqÿ ÿqÿ ÿqÿ ÿqÿÿšÿÿšÿÿšÿÿ…ÿÿšÿÿ×ÿÿqÿÿ®ÿÿqÿÿšÿÿ…ÿšÿ×ÿšÎÿÃÏÿìÕÿÃØÿìÛÿìÞÿìêÿìíÿìòÿÃÿ×ÿ×ÿ×ÿš ÿšjÿìsÿÃÿì…ÿì‡ÿì‰ÿìÿì²ÿì´ÿìÏÿÃàÿìðÿìòÿìôÿì ÿì ÿìÿÃÿìÿìÿÃÿšÿ×ÿš)Ÿÿפÿ®¦)ªÿ…®ÿ®µÿ®¸ÿ×»ÿ×¼)¾ÿÃÄ)ÌÿÃÍÿÃÎÿšÏÿ®Ðÿ×Ñÿ×ÒÿÃÓÿÃÔÿÃÕÿšÖÿÃ×ÿÃØÿ®ÙÿÃÚÿÃÛÿ®Þÿ®ßÿ×àÿÃáÿšâÿÃãÿÃåÿÃæÿÃçÿ×èÿÃêÿ®ë)ìÿÃíÿ®îÿÃòÿšóÿÃô)õÿÃ÷ÿÃùÿÃÿ×ÿ×ÿ×ÿš ÿšjÿ®kÿÃlÿ×qÿÃrÿ…sÿšuÿÃwÿ×yÿÃ}ÿÃ~ÿ×ÿ®„ÿ×…ÿ®†ÿׇÿ®ˆÿ׉ÿ®Šÿ׌ÿ×ÿ®–ÿØ)šÿÞÿàÿ×¢ÿפÿæÿè)©)¬ÿîÿðÿñÿײÿ®³ÿ×´ÿ®µ)¼ÿ×½)ÀÿšÂÿšÄÿÃÅÿ×ÆÿÃÇÿ×ÈÿÃËÿ×ÍÿÃÎÿ®ÏÿšÑÿÃÓÿÃÕÿš×ÿÃÙÿ…Ûÿ…Ýÿ…àÿ®æÿ×èÿ×ìÿÃîÿÃïÿ×ðÿ®ñÿ×òÿ®óÿ×ôÿ®öÿ×þÿšÿÃÿÃÿ×ÿ× ÿš ÿ® ÿš ÿ®ÿ×ÿ×ÿ®ÿšÿÃÿ×ÿ®)ÿ®ÿ®ÿšÿÃÿÃÎÿÃÏÿ×ÕÿÃØÿ×Ûÿ×Þÿ×êÿ×íÿ×òÿÃÿà ÿÃjÿ×sÿÃÿ×…ÿׇÿ׉ÿ×ÿײÿ×´ÿ×ÏÿÃàÿ×ðÿ×òÿ×ôÿ× ÿ× ÿ×ÿÃÿ×ÿ×ÿßÿ×£á¸ÿ×»ÿ×¾ÿÃÜÿ×áÿ®äÿ×lÿ×{=}ÿì~ÿׄÿ׆ÿ׈ÿ׊ÿ׌ÿתÿ×±ÿ׳ÿ׶ÿ×¾ÿ×Àÿ®Âÿ®ÅÿÃÆÿ×ÇÿÃÈÿ×Õÿ®ïÿ×ñÿ×óÿ×þÿ®ÿ×ÿ×ÿ×ÿ×ÏÿìØÿìÛÿìÞÿìáÿìêÿìíÿìjÿìÿì…ÿì‡ÿì‰ÿìÿì²ÿì´ÿìÀÿìÂÿìÕÿìàÿìðÿìòÿìôÿìþÿì ÿì ÿìÿ×ÿ×ÿìÿìŸÿ׸ÿ×»ÿ×¾ÿ×Áÿ×áÿ×lÿ×|ÿ×~ÿׄÿ׆ÿ׈ÿ׊ÿ׌ÿ×±ÿ׳ÿ׿ÿ×Àÿ×Áÿ×Âÿ×ÅÿšÇÿšÔÿ×Õÿ×ïÿ×ñÿ×óÿ×ýÿ×þÿ× ÿ× ÿ×ÿ×ÿ×ÿ×ÿìÏÿìØÿìÛÿìÞÿìáÿìêÿìíÿìjÿìÿì…ÿì‡ÿì‰ÿìÿì²ÿì´ÿìÀÿìÂÿìÕÿìàÿìðÿìòÿìôÿìþÿì ÿì ÿìÿ×ÿ×ÿìÿì ÿš ÿš ÿ® ¦ÿ® ¨ÿà ªÿà °ÿà ¼ÿq ½ÿà ¿ÿà Áÿà Äÿ® Ðÿ× Üÿà ßÿ× áÿ× äÿà ÿš  ÿš rÿà vÿ× |ÿà €ÿà ‚ÿà Ÿÿà  ÿ× ©ÿ® ªÿà µÿq ¶ÿà ·ÿà ¹ÿà »ÿà ¼ÿ× ½ÿ® ¾ÿà ¿ÿà Àÿ× Áÿà Âÿ× Êÿà Ëÿ× Ôÿà Õÿ× Ùÿà Ûÿà Ýÿà åÿà æÿ× ÷ÿà ùÿà ûÿà ýÿà þÿ× ÿà ÿ× ÿà ÿ×  ÿ× ÿ× ÿ× ÿ× ÿ® ÿà ÿš ÿš Ðÿ× Üÿà Ýÿ× ßÿ× áÿ× äÿà öÿ× ÿš  ÿš  ÿ× ªÿà ¶ÿà ¼ÿ× ¾ÿà Àÿ× Âÿ× Ëÿ× Õÿ× æÿ× øÿ× úÿ× üÿ× þÿ× ÿ× ÿ× ÿš ÿš ÿà ÿš ÿš ÿ® ¦ÿ® ¨ÿà ªÿà °ÿà ¼ÿq ½ÿà ¿ÿà Áÿà Äÿ® Ðÿ× Üÿà ßÿ× áÿ× äÿà ÿš  ÿš rÿà vÿ× |ÿà €ÿà ‚ÿà Ÿÿà  ÿ× ©ÿ® ªÿà µÿq ¶ÿà ·ÿà ¹ÿà »ÿà ¼ÿ× ½ÿ® ¾ÿà ¿ÿà Àÿ× Áÿà Âÿ× Êÿà Ëÿ× Ôÿà Õÿ× Ùÿà Ûÿà Ýÿà åÿà æÿ× ÷ÿà ùÿà ûÿà ýÿà þÿ× ÿà ÿ× ÿà ÿ×  ÿ× ÿ× ÿ× ÿ× ÿ® ÿÃÿš ÿšÐÿ×ÜÿÃÝÿ×ßÿ×áÿ×äÿÃöÿ×ÿš ÿš ÿתÿöÿüÿ×¾ÿÃÀÿ×Âÿ×Ëÿ×Õÿ×æÿ×øÿ×úÿ×üÿ×þÿ×ÿ×ÿ×ÿšÿšÿãáê)ÿ×ÿ×ÿì ÿìÿì ÿìÿš ÿšÿ®¦ÿ®¨ÿêÿðÿüÿq½ÿÿÿÃÁÿÃÄÿ®Ðÿ×ÜÿÃßÿ×áÿ×äÿÃÿš ÿšrÿÃvÿ×|ÿÀÿÂÿßÿàÿשÿ®ªÿõÿq¶ÿ÷ÿùÿûÿüÿ×½ÿ®¾ÿÿÿÃÀÿ×ÁÿÃÂÿ×ÊÿÃËÿ×ÔÿÃÕÿ×ÙÿÃÛÿÃÝÿÃåÿÃæÿ×÷ÿÃùÿÃûÿÃýÿÃþÿ×ÿÃÿ×ÿÃÿ× ÿ×ÿ×ÿ×ÿ×ÿ®ÿÃÿš ÿšÐÿ×ÜÿÃÝÿ×ßÿ×áÿ×äÿÃöÿ×ÿš ÿš ÿתÿöÿüÿ×¾ÿÃÀÿ×Âÿ×Ëÿ×Õÿ×æÿ×øÿ×úÿ×üÿ×þÿ×ÿ×ÿ×ÿšÿšÿÃÿš ÿšÿ®¦ÿ®¨ÿêÿðÿüÿq½ÿÿÿÃÁÿÃÄÿ®Ðÿ×ÜÿÃßÿ×áÿ×äÿÃÿš ÿšrÿÃvÿ×|ÿÀÿÂÿßÿàÿשÿ®ªÿõÿq¶ÿ÷ÿùÿûÿüÿ×½ÿ®¾ÿÿÿÃÀÿ×ÁÿÃÂÿ×ÊÿÃËÿ×ÔÿÃÕÿ×ÙÿÃÛÿÃÝÿÃåÿÃæÿ×÷ÿÃùÿÃûÿÃýÿÃþÿ×ÿÃÿ×ÿÃÿ× ÿ×ÿ×ÿ×ÿ×ÿ®ÿÃÿš ÿšÐÿ×ÜÿÃÝÿ×ßÿ×áÿ×äÿÃöÿ×ÿš ÿš ÿתÿöÿüÿ×¾ÿÃÀÿ×Âÿ×Ëÿ×Õÿ×æÿ×øÿ×úÿ×üÿ×þÿ×ÿ×ÿ×ÿšÿšÿÃÿ®ÿ®ªÿì°ÿ×¼ÿ׿ÿ×ÿ® ÿ®rÿì€ÿì‚ÿìŸÿ×µÿ×·ÿì¹ÿì»ÿ×Êÿ×ÙÿìÛÿìÝÿìåÿ×ÿ×ÿ×ÿ× ÿ×ÐÿìÝÿìßÿìöÿìÿ× ÿ× ÿì¼ÿìËÿìæÿìøÿìúÿìüÿìÿìÿìÿ×ÿ×ÿ® ÿ®ÿæÿêÿ×°ÿ×¼ÿÿÿ×Áÿ×ÄÿÃÜÿ×äÿ×ÿ® ÿ®rÿ×|ÿ×€ÿׂÿןÿשÿêÿ×µÿöÿ×·ÿ×¹ÿ×»ÿ×½ÿþÿ׿ÿ×Áÿ×Êÿ×Ôÿ×Ùÿ×Ûÿ×Ýÿ×åÿ×ýÿ×ÿ×ÿ× ÿ×ÿ×ÿÃÿ×ÿš ÿšÐÿ×ÜÿÃÝÿ×ßÿ×áÿ×äÿÃöÿ×ÿš ÿš ÿתÿöÿüÿ×¾ÿÃÀÿ×Âÿ×Ëÿ×Õÿ×æÿ×øÿ×úÿ×üÿ×þÿ×ÿ×ÿ×ÿšÿšÿÃáÿ×Àÿ×Âÿ×Õÿ×þÿ×£áê)ÿ×ÿ×ÿì ÿìÿì ÿìÿq ÿq&ÿ×*ÿ×- 2ÿ×4ÿ×7ÿq9ÿ®:ÿ®<ÿ…‰ÿ×”ÿוÿ×–ÿ×—ÿטÿךÿןÿ…Èÿ×Êÿ×Ìÿ×Îÿ×Þÿ×àÿ×âÿ×äÿ×ÿ×ÿ×ÿ×ÿ×$ÿq&ÿq6ÿ®8ÿ…:ÿ…Gÿ×úÿ®üÿ®þÿ®ÿ…ÿq ÿq_ÿ×Iÿ×Kÿ×Mÿ×Oÿ×Qÿ×Sÿ×Uÿ×Wÿ×Yÿ×[ÿ×]ÿ×_ÿ×oÿ…qÿ…sÿ…ÿqÿì ÿìÿì ÿìÿq ÿq&ÿ×*ÿ×- 2ÿ×4ÿ×7ÿq9ÿ®:ÿ®<ÿ…‰ÿ×”ÿוÿ×–ÿ×—ÿטÿךÿןÿ…Èÿ×Êÿ×Ìÿ×Îÿ×Þÿ×àÿ×âÿ×äÿ×ÿ×ÿ×ÿ×ÿ×$ÿq&ÿq6ÿ®8ÿ…:ÿ…Gÿ×úÿ®üÿ®þÿ®ÿ…ÿq ÿq_ÿ×Iÿ×Kÿ×Mÿ×Oÿ×Qÿ×Sÿ×Uÿ×Wÿ×Yÿ×[ÿ×]ÿ×_ÿ×oÿ…qÿ…sÿ…ÿq ÿì ÿì ÿì  ÿì!ÿq! ÿq!&ÿ×!*ÿ×!- !2ÿ×!4ÿ×!7ÿq!9ÿ®!:ÿ®!<ÿ…!‰ÿ×!”ÿ×!•ÿ×!–ÿ×!—ÿ×!˜ÿ×!šÿ×!Ÿÿ…!Èÿ×!Êÿ×!Ìÿ×!Îÿ×!Þÿ×!àÿ×!âÿ×!äÿ×!ÿ×!ÿ×!ÿ×!ÿ×!$ÿq!&ÿq!6ÿ®!8ÿ…!:ÿ…!Gÿ×!úÿ®!üÿ®!þÿ®!ÿ…!ÿq! ÿq!_ÿ×!Iÿ×!Kÿ×!Mÿ×!Oÿ×!Qÿ×!Sÿ×!Uÿ×!Wÿ×!Yÿ×![ÿ×!]ÿ×!_ÿ×!oÿ…!qÿ…!sÿ…!ÿq"ÿì" ÿì"ÿì" ÿì#ÿq# ÿq#&ÿ×#*ÿ×#- #2ÿ×#4ÿ×#7ÿq#9ÿ®#:ÿ®#<ÿ…#‰ÿ×#”ÿ×#•ÿ×#–ÿ×#—ÿ×#˜ÿ×#šÿ×#Ÿÿ…#Èÿ×#Êÿ×#Ìÿ×#Îÿ×#Þÿ×#àÿ×#âÿ×#äÿ×#ÿ×#ÿ×#ÿ×#ÿ×#$ÿq#&ÿq#6ÿ®#8ÿ…#:ÿ…#Gÿ×#úÿ®#üÿ®#þÿ®#ÿ…#ÿq# ÿq#_ÿ×#Iÿ×#Kÿ×#Mÿ×#Oÿ×#Qÿ×#Sÿ×#Uÿ×#Wÿ×#Yÿ×#[ÿ×#]ÿ×#_ÿ×#oÿ…#qÿ…#sÿ…#ÿq$ÿì$ ÿì$ÿì$ ÿì%ÿq% ÿq%&ÿ×%*ÿ×%- %2ÿ×%4ÿ×%7ÿq%9ÿ®%:ÿ®%<ÿ…%‰ÿ×%”ÿ×%•ÿ×%–ÿ×%—ÿ×%˜ÿ×%šÿ×%Ÿÿ…%Èÿ×%Êÿ×%Ìÿ×%Îÿ×%Þÿ×%àÿ×%âÿ×%äÿ×%ÿ×%ÿ×%ÿ×%ÿ×%$ÿq%&ÿq%6ÿ®%8ÿ…%:ÿ…%Gÿ×%úÿ®%üÿ®%þÿ®%ÿ…%ÿq% ÿq%_ÿ×%Iÿ×%Kÿ×%Mÿ×%Oÿ×%Qÿ×%Sÿ×%Uÿ×%Wÿ×%Yÿ×%[ÿ×%]ÿ×%_ÿ×%oÿ…%qÿ…%sÿ…%ÿq&ÿì& ÿì&ÿì& ÿì'ÿq' ÿq'&ÿ×'*ÿ×'- '2ÿ×'4ÿ×'7ÿq'9ÿ®':ÿ®'<ÿ…'‰ÿ×'”ÿ×'•ÿ×'–ÿ×'—ÿ×'˜ÿ×'šÿ×'Ÿÿ…'Èÿ×'Êÿ×'Ìÿ×'Îÿ×'Þÿ×'àÿ×'âÿ×'äÿ×'ÿ×'ÿ×'ÿ×'ÿ×'$ÿq'&ÿq'6ÿ®'8ÿ…':ÿ…'Gÿ×'úÿ®'üÿ®'þÿ®'ÿ…'ÿq' ÿq'_ÿ×'Iÿ×'Kÿ×'Mÿ×'Oÿ×'Qÿ×'Sÿ×'Uÿ×'Wÿ×'Yÿ×'[ÿ×']ÿ×'_ÿ×'oÿ…'qÿ…'sÿ…'ÿq(ÿì( ÿì(ÿì( ÿì)ÿq) ÿq)&ÿ×)*ÿ×)- )2ÿ×)4ÿ×)7ÿq)9ÿ®):ÿ®)<ÿ…)‰ÿ×)”ÿ×)•ÿ×)–ÿ×)—ÿ×)˜ÿ×)šÿ×)Ÿÿ…)Èÿ×)Êÿ×)Ìÿ×)Îÿ×)Þÿ×)àÿ×)âÿ×)äÿ×)ÿ×)ÿ×)ÿ×)ÿ×)$ÿq)&ÿq)6ÿ®)8ÿ…):ÿ…)Gÿ×)úÿ®)üÿ®)þÿ®)ÿ…)ÿq) ÿq)_ÿ×)Iÿ×)Kÿ×)Mÿ×)Oÿ×)Qÿ×)Sÿ×)Uÿ×)Wÿ×)Yÿ×)[ÿ×)]ÿ×)_ÿ×)oÿ…)qÿ…)sÿ…)ÿq*ÿì* ÿì*ÿì* ÿì+ÿq+ ÿq+&ÿ×+*ÿ×+- +2ÿ×+4ÿ×+7ÿq+9ÿ®+:ÿ®+<ÿ…+‰ÿ×+”ÿ×+•ÿ×+–ÿ×+—ÿ×+˜ÿ×+šÿ×+Ÿÿ…+Èÿ×+Êÿ×+Ìÿ×+Îÿ×+Þÿ×+àÿ×+âÿ×+äÿ×+ÿ×+ÿ×+ÿ×+ÿ×+$ÿq+&ÿq+6ÿ®+8ÿ…+:ÿ…+Gÿ×+úÿ®+üÿ®+þÿ®+ÿ…+ÿq+ ÿq+_ÿ×+Iÿ×+Kÿ×+Mÿ×+Oÿ×+Qÿ×+Sÿ×+Uÿ×+Wÿ×+Yÿ×+[ÿ×+]ÿ×+_ÿ×+oÿ…+qÿ…+sÿ…+ÿq,ÿì, ÿì,ÿì, ÿì-ÿq- ÿq-&ÿ×-*ÿ×-- -2ÿ×-4ÿ×-7ÿq-9ÿ®-:ÿ®-<ÿ…-‰ÿ×-”ÿ×-•ÿ×-–ÿ×-—ÿ×-˜ÿ×-šÿ×-Ÿÿ…-Èÿ×-Êÿ×-Ìÿ×-Îÿ×-Þÿ×-àÿ×-âÿ×-äÿ×-ÿ×-ÿ×-ÿ×-ÿ×-$ÿq-&ÿq-6ÿ®-8ÿ…-:ÿ…-Gÿ×-úÿ®-üÿ®-þÿ®-ÿ…-ÿq- ÿq-_ÿ×-Iÿ×-Kÿ×-Mÿ×-Oÿ×-Qÿ×-Sÿ×-Uÿ×-Wÿ×-Yÿ×-[ÿ×-]ÿ×-_ÿ×-oÿ…-qÿ…-sÿ…-ÿq.ÿì. ÿì.ÿì. ÿì/ÿq/ ÿq/&ÿ×/*ÿ×/- /2ÿ×/4ÿ×/7ÿq/9ÿ®/:ÿ®/<ÿ…/‰ÿ×/”ÿ×/•ÿ×/–ÿ×/—ÿ×/˜ÿ×/šÿ×/Ÿÿ…/Èÿ×/Êÿ×/Ìÿ×/Îÿ×/Þÿ×/àÿ×/âÿ×/äÿ×/ÿ×/ÿ×/ÿ×/ÿ×/$ÿq/&ÿq/6ÿ®/8ÿ…/:ÿ…/Gÿ×/úÿ®/üÿ®/þÿ®/ÿ…/ÿq/ ÿq/_ÿ×/Iÿ×/Kÿ×/Mÿ×/Oÿ×/Qÿ×/Sÿ×/Uÿ×/Wÿ×/Yÿ×/[ÿ×/]ÿ×/_ÿ×/oÿ…/qÿ…/sÿ…/ÿq0ÿì0 ÿì0ÿì0 ÿì1ÿq1 ÿq1&ÿ×1*ÿ×1- 12ÿ×14ÿ×17ÿq19ÿ®1:ÿ®1<ÿ…1‰ÿ×1”ÿ×1•ÿ×1–ÿ×1—ÿ×1˜ÿ×1šÿ×1Ÿÿ…1Èÿ×1Êÿ×1Ìÿ×1Îÿ×1Þÿ×1àÿ×1âÿ×1äÿ×1ÿ×1ÿ×1ÿ×1ÿ×1$ÿq1&ÿq16ÿ®18ÿ…1:ÿ…1Gÿ×1úÿ®1üÿ®1þÿ®1ÿ…1ÿq1 ÿq1_ÿ×1Iÿ×1Kÿ×1Mÿ×1Oÿ×1Qÿ×1Sÿ×1Uÿ×1Wÿ×1Yÿ×1[ÿ×1]ÿ×1_ÿ×1oÿ…1qÿ…1sÿ…1ÿq2ÿì2 ÿì2ÿì2 ÿì3ÿq3 ÿq3&ÿ×3*ÿ×3- 32ÿ×34ÿ×37ÿq39ÿ®3:ÿ®3<ÿ…3‰ÿ×3”ÿ×3•ÿ×3–ÿ×3—ÿ×3˜ÿ×3šÿ×3Ÿÿ…3Èÿ×3Êÿ×3Ìÿ×3Îÿ×3Þÿ×3àÿ×3âÿ×3äÿ×3ÿ×3ÿ×3ÿ×3ÿ×3$ÿq3&ÿq36ÿ®38ÿ…3:ÿ…3Gÿ×3úÿ®3üÿ®3þÿ®3ÿ…3ÿq3 ÿq3_ÿ×3Iÿ×3Kÿ×3Mÿ×3Oÿ×3Qÿ×3Sÿ×3Uÿ×3Wÿ×3Yÿ×3[ÿ×3]ÿ×3_ÿ×3oÿ…3qÿ…3sÿ…3ÿq4ÿì4 ÿì4ÿì4 ÿì5-{6ÿì6 ÿì6Yÿ×6Zÿ×6[ÿ×6\ÿ×6]ÿì6¿ÿ×67ÿ×6<ÿì6>ÿì6@ÿì6ûÿ×6ýÿ×6ÿì6 ÿì6pÿ×7-{8ÿì8 ÿì8Yÿ×8Zÿ×8[ÿ×8\ÿ×8]ÿì8¿ÿ×87ÿ×8<ÿì8>ÿì8@ÿì8ûÿ×8ýÿ×8ÿì8 ÿì8pÿ×9-{:ÿì: ÿì:Yÿ×:Zÿ×:[ÿ×:\ÿ×:]ÿì:¿ÿ×:7ÿ×:<ÿì:>ÿì:@ÿì:ûÿ×:ýÿ×:ÿì: ÿì:pÿ×;-{<ÿì< ÿì<Yÿ×<Zÿ×<[ÿ×<\ÿ×<]ÿì<¿ÿ×<7ÿ×<<ÿì<>ÿì<@ÿì<ûÿ×<ýÿ×<ÿì< ÿì<pÿ×=-{>ÿì> ÿì>Yÿ×>Zÿ×>[ÿ×>\ÿ×>]ÿì>¿ÿ×>7ÿ×><ÿì>>ÿì>@ÿì>ûÿ×>ýÿ×>ÿì> ÿì>pÿ×?-{@ÿì@ ÿì@Yÿ×@Zÿ×@[ÿ×@\ÿ×@]ÿì@¿ÿ×@7ÿ×@<ÿì@>ÿì@@ÿì@ûÿ×@ýÿ×@ÿì@ ÿì@pÿ×A-{BÿìB ÿìBYÿ×BZÿ×B[ÿ×B\ÿ×B]ÿìB¿ÿ×B7ÿ×B<ÿìB>ÿìB@ÿìBûÿ×Býÿ×BÿìB ÿìBpÿ×C-{DÿìD ÿìDYÿ×DZÿ×D[ÿ×D\ÿ×D]ÿìD¿ÿ×D7ÿ×D<ÿìD>ÿìD@ÿìDûÿ×Dýÿ×DÿìD ÿìDpÿ×Iÿ®Iÿ®I$ÿ×I7ÿÃI9ÿìI:ÿìI;ÿ×I<ÿìI=ÿìI‚ÿ×Iƒÿ×I„ÿ×I…ÿ×I†ÿ×I‡ÿ×IŸÿìIÂÿ×IÄÿ×IÆÿ×I$ÿÃI&ÿÃI6ÿìI8ÿìI:ÿìI;ÿìI=ÿìI?ÿìICÿ×I ÿìIúÿìIüÿìIþÿìIÿìIÿ®I ÿ®IXÿ×Iÿ×Iÿ×I!ÿ×I#ÿ×I%ÿ×I'ÿ×I)ÿ×I+ÿ×I-ÿ×I/ÿ×I1ÿ×I3ÿ×IoÿìIqÿìIsÿìIÿÃJÿìJ ÿìJYÿ×JZÿ×J[ÿ×J\ÿ×J]ÿìJ¿ÿ×J7ÿ×J<ÿìJ>ÿìJ@ÿìJûÿ×Jýÿ×JÿìJ ÿìJpÿ×Kÿ®Kÿ®K$ÿ×K7ÿÃK9ÿìK:ÿìK;ÿ×K<ÿìK=ÿìK‚ÿ×Kƒÿ×K„ÿ×K…ÿ×K†ÿ×K‡ÿ×KŸÿìKÂÿ×KÄÿ×KÆÿ×K$ÿÃK&ÿÃK6ÿìK8ÿìK:ÿìK;ÿìK=ÿìK?ÿìKCÿ×K ÿìKúÿìKüÿìKþÿìKÿìKÿ®K ÿ®KXÿ×Kÿ×Kÿ×K!ÿ×K#ÿ×K%ÿ×K'ÿ×K)ÿ×K+ÿ×K-ÿ×K/ÿ×K1ÿ×K3ÿ×KoÿìKqÿìKsÿìKÿÃLÿìL ÿìLYÿ×LZÿ×L[ÿ×L\ÿ×L]ÿìL¿ÿ×L7ÿ×L<ÿìL>ÿìL@ÿìLûÿ×Lýÿ×LÿìL ÿìLpÿ×Mÿ®Mÿ®M$ÿ×M7ÿÃM9ÿìM:ÿìM;ÿ×M<ÿìM=ÿìM‚ÿ×Mƒÿ×M„ÿ×M…ÿ×M†ÿ×M‡ÿ×MŸÿìMÂÿ×MÄÿ×MÆÿ×M$ÿÃM&ÿÃM6ÿìM8ÿìM:ÿìM;ÿìM=ÿìM?ÿìMCÿ×M ÿìMúÿìMüÿìMþÿìMÿìMÿ®M ÿ®MXÿ×Mÿ×Mÿ×M!ÿ×M#ÿ×M%ÿ×M'ÿ×M)ÿ×M+ÿ×M-ÿ×M/ÿ×M1ÿ×M3ÿ×MoÿìMqÿìMsÿìMÿÃOÿ®Oÿ®O$ÿ×O7ÿÃO9ÿìO:ÿìO;ÿ×O<ÿìO=ÿìO‚ÿ×Oƒÿ×O„ÿ×O…ÿ×O†ÿ×O‡ÿ×OŸÿìOÂÿ×OÄÿ×OÆÿ×O$ÿÃO&ÿÃO6ÿìO8ÿìO:ÿìO;ÿìO=ÿìO?ÿìOCÿ×O ÿìOúÿìOüÿìOþÿìOÿìOÿ®O ÿ®OXÿ×Oÿ×Oÿ×O!ÿ×O#ÿ×O%ÿ×O'ÿ×O)ÿ×O+ÿ×O-ÿ×O/ÿ×O1ÿ×O3ÿ×OoÿìOqÿìOsÿìOÿÃQÿ®Qÿ®Q$ÿ×Q7ÿÃQ9ÿìQ:ÿìQ;ÿ×Q<ÿìQ=ÿìQ‚ÿ×Qƒÿ×Q„ÿ×Q…ÿ×Q†ÿ×Q‡ÿ×QŸÿìQÂÿ×QÄÿ×QÆÿ×Q$ÿÃQ&ÿÃQ6ÿìQ8ÿìQ:ÿìQ;ÿìQ=ÿìQ?ÿìQCÿ×Q ÿìQúÿìQüÿìQþÿìQÿìQÿ®Q ÿ®QXÿ×Qÿ×Qÿ×Q!ÿ×Q#ÿ×Q%ÿ×Q'ÿ×Q)ÿ×Q+ÿ×Q-ÿ×Q/ÿ×Q1ÿ×Q3ÿ×QoÿìQqÿìQsÿìQÿÃSÿ®Sÿ®S$ÿ×S7ÿÃS9ÿìS:ÿìS;ÿ×S<ÿìS=ÿìS‚ÿ×Sƒÿ×S„ÿ×S…ÿ×S†ÿ×S‡ÿ×SŸÿìSÂÿ×SÄÿ×SÆÿ×S$ÿÃS&ÿÃS6ÿìS8ÿìS:ÿìS;ÿìS=ÿìS?ÿìSCÿ×S ÿìSúÿìSüÿìSþÿìSÿìSÿ®S ÿ®SXÿ×Sÿ×Sÿ×S!ÿ×S#ÿ×S%ÿ×S'ÿ×S)ÿ×S+ÿ×S-ÿ×S/ÿ×S1ÿ×S3ÿ×SoÿìSqÿìSsÿìSÿÃUÿ®Uÿ®U$ÿ×U7ÿÃU9ÿìU:ÿìU;ÿ×U<ÿìU=ÿìU‚ÿ×Uƒÿ×U„ÿ×U…ÿ×U†ÿ×U‡ÿ×UŸÿìUÂÿ×UÄÿ×UÆÿ×U$ÿÃU&ÿÃU6ÿìU8ÿìU:ÿìU;ÿìU=ÿìU?ÿìUCÿ×U ÿìUúÿìUüÿìUþÿìUÿìUÿ®U ÿ®UXÿ×Uÿ×Uÿ×U!ÿ×U#ÿ×U%ÿ×U'ÿ×U)ÿ×U+ÿ×U-ÿ×U/ÿ×U1ÿ×U3ÿ×UoÿìUqÿìUsÿìUÿÃXIRXWRXYfXZfX[fX\fX¿fX%RX'RX7fXûfXýfX4RX5RX]RX^RXpfXRXRZIRZWRZYfZZfZ[fZ\fZ¿fZ%RZ'RZ7fZûfZýfZ4RZ5RZ]RZ^RZpfZRZR\IR\WR\Yf\Zf\[f\\f\¿f\%R\'R\7f\ûf\ýf\4R\5R\]R\^R\pf\R\R^IR^WR^Yf^Zf^[f^\f^¿f^%R^'R^7f^ûf^ýf^4R^5R^]R^^R^pf^R^R`IR`WR`Yf`Zf`[f`\f`¿f`%R`'R`7f`ûf`ýf`4R`5R`]R`^R`pf`R`Raÿ×aÿ×a$ÿìa‚ÿìaƒÿìa„ÿìa…ÿìa†ÿìa‡ÿìaÂÿìaÄÿìaÆÿìaCÿìaÿ×a ÿ×aXÿìaÿìaÿìa!ÿìa#ÿìa%ÿìa'ÿìa)ÿìa+ÿìa-ÿìa/ÿìa1ÿìa3ÿìfIffWffYffZff[ff\ff¿ff%ff'ff7ffûffýff4ff5ff]ff^ffpfffffhIfhWfhYfhZfh[fh\fh¿fh%fh'fh7fhûfhýfh4fh5fh]fh^fhpfhfhfjIfjWfjYfjZfj[fj\fj¿fj%fj'fj7fjûfjýfj4fj5fj]fj^fjpfjfjflIflWflYflZfl[fl\fl¿fl%fl'fl7flûflýfl4fl5fl]fl^flpflflfnIfnWfnYfnZfn[fn\fn¿fn%fn'fn7fnûfnýfn4fn5fn]fn^fnpfnfnfoÿ…oÿ…o")o$ÿ…o&ÿ×o*ÿ×o2ÿ×o4ÿ×oDÿšoFÿšoGÿšoHÿšoJÿ×oPÿÃoQÿÃoRÿšoSÿÃoTÿšoUÿÃoVÿ®oXÿÃo]ÿ×o‚ÿ…oƒÿ…o„ÿ…o…ÿ…o†ÿ…o‡ÿ…o‰ÿ×o”ÿ×o•ÿ×o–ÿ×o—ÿ×o˜ÿ×ošÿ×o¢ÿšo£ÿšo¤ÿšo¥ÿšo¦ÿšo§ÿšo¨ÿšo©ÿšoªÿšo«ÿšo¬ÿšo­ÿšo´ÿšoµÿšo¶ÿšo·ÿšo¸ÿšoºÿšo»ÿÃo¼ÿÃo½ÿÃo¾ÿÃoÂÿ…oÃÿšoÄÿ…oÅÿšoÆÿ…oÇÿšoÈÿ×oÉÿšoÊÿ×oËÿšoÌÿ×oÍÿšoÎÿ×oÏÿšoÑÿšoÓÿšoÕÿšo×ÿšoÙÿšoÛÿšoÝÿšoÞÿ×oßÿ×oàÿ×oáÿ×oâÿ×oãÿ×oäÿ×oåÿ×oúÿÃoÿÃoÿÃo ÿÃoÿ×oÿšoÿ×oÿšoÿ×oÿšoÿ×oÿšoÿÃoÿÃoÿ®o!ÿ®o+ÿÃo-ÿÃo/ÿÃo1ÿÃo3ÿÃo5ÿÃo<ÿ×o>ÿ×o@ÿ×oCÿ…oDÿšoFÿšoGÿ×oHÿšoJÿ®oÿ…o ÿ…oWÿÃoXÿ…oYÿšo_ÿ×o`ÿšobÿÃoÿ…oÿšoÿ…o ÿšo!ÿ…o"ÿšo#ÿ…o%ÿ…o&ÿšo'ÿ…o(ÿšo)ÿ…o*ÿšo+ÿ…o,ÿšo-ÿ…o.ÿšo/ÿ…o0ÿšo1ÿ…o2ÿšo3ÿ…o4ÿšo6ÿšo8ÿšo:ÿšo<ÿšo@ÿšoBÿšoDÿšoIÿ×oJÿšoKÿ×oLÿšoMÿ×oNÿšoOÿ×oQÿ×oRÿšoSÿ×oTÿšoUÿ×oVÿšoWÿ×oXÿšoYÿ×oZÿšo[ÿ×o\ÿšo]ÿ×o^ÿšo_ÿ×o`ÿšobÿÃodÿÃofÿÃohÿÃojÿÃolÿÃonÿÃpRp Rpÿ®pÿ®p")pRpÿ®p Rp ÿ®qÿ…qÿ…q")q$ÿ…q&ÿ×q*ÿ×q2ÿ×q4ÿ×qDÿšqFÿšqGÿšqHÿšqJÿ×qPÿÃqQÿÃqRÿšqSÿÃqTÿšqUÿÃqVÿ®qXÿÃq]ÿ×q‚ÿ…qƒÿ…q„ÿ…q…ÿ…q†ÿ…q‡ÿ…q‰ÿ×q”ÿ×q•ÿ×q–ÿ×q—ÿ×q˜ÿ×qšÿ×q¢ÿšq£ÿšq¤ÿšq¥ÿšq¦ÿšq§ÿšq¨ÿšq©ÿšqªÿšq«ÿšq¬ÿšq­ÿšq´ÿšqµÿšq¶ÿšq·ÿšq¸ÿšqºÿšq»ÿÃq¼ÿÃq½ÿÃq¾ÿÃqÂÿ…qÃÿšqÄÿ…qÅÿšqÆÿ…qÇÿšqÈÿ×qÉÿšqÊÿ×qËÿšqÌÿ×qÍÿšqÎÿ×qÏÿšqÑÿšqÓÿšqÕÿšq×ÿšqÙÿšqÛÿšqÝÿšqÞÿ×qßÿ×qàÿ×qáÿ×qâÿ×qãÿ×qäÿ×qåÿ×qúÿÃqÿÃqÿÃq ÿÃqÿ×qÿšqÿ×qÿšqÿ×qÿšqÿ×qÿšqÿÃqÿÃqÿ®q!ÿ®q+ÿÃq-ÿÃq/ÿÃq1ÿÃq3ÿÃq5ÿÃq<ÿ×q>ÿ×q@ÿ×qCÿ…qDÿšqFÿšqGÿ×qHÿšqJÿ®qÿ…q ÿ…qWÿÃqXÿ…qYÿšq_ÿ×q`ÿšqbÿÃqÿ…qÿšqÿ…q ÿšq!ÿ…q"ÿšq#ÿ…q%ÿ…q&ÿšq'ÿ…q(ÿšq)ÿ…q*ÿšq+ÿ…q,ÿšq-ÿ…q.ÿšq/ÿ…q0ÿšq1ÿ…q2ÿšq3ÿ…q4ÿšq6ÿšq8ÿšq:ÿšq<ÿšq@ÿšqBÿšqDÿšqIÿ×qJÿšqKÿ×qLÿšqMÿ×qNÿšqOÿ×qQÿ×qRÿšqSÿ×qTÿšqUÿ×qVÿšqWÿ×qXÿšqYÿ×qZÿšq[ÿ×q\ÿšq]ÿ×q^ÿšq_ÿ×q`ÿšqbÿÃqdÿÃqfÿÃqhÿÃqjÿÃqlÿÃqnÿÃrRr Rrÿ®rÿ®r")rRrÿ®r Rr ÿ®sÿ…sÿ…s")s$ÿ…s&ÿ×s*ÿ×s2ÿ×s4ÿ×sDÿšsFÿšsGÿšsHÿšsJÿ×sPÿÃsQÿÃsRÿšsSÿÃsTÿšsUÿÃsVÿ®sXÿÃs]ÿ×s‚ÿ…sƒÿ…s„ÿ…s…ÿ…s†ÿ…s‡ÿ…s‰ÿ×s”ÿ×s•ÿ×s–ÿ×s—ÿ×s˜ÿ×sšÿ×s¢ÿšs£ÿšs¤ÿšs¥ÿšs¦ÿšs§ÿšs¨ÿšs©ÿšsªÿšs«ÿšs¬ÿšs­ÿšs´ÿšsµÿšs¶ÿšs·ÿšs¸ÿšsºÿšs»ÿÃs¼ÿÃs½ÿÃs¾ÿÃsÂÿ…sÃÿšsÄÿ…sÅÿšsÆÿ…sÇÿšsÈÿ×sÉÿšsÊÿ×sËÿšsÌÿ×sÍÿšsÎÿ×sÏÿšsÑÿšsÓÿšsÕÿšs×ÿšsÙÿšsÛÿšsÝÿšsÞÿ×sßÿ×sàÿ×sáÿ×sâÿ×sãÿ×säÿ×såÿ×súÿÃsÿÃsÿÃs ÿÃsÿ×sÿšsÿ×sÿšsÿ×sÿšsÿ×sÿšsÿÃsÿÃsÿ®s!ÿ®s+ÿÃs-ÿÃs/ÿÃs1ÿÃs3ÿÃs5ÿÃs<ÿ×s>ÿ×s@ÿ×sCÿ…sDÿšsFÿšsGÿ×sHÿšsJÿ®sÿ…s ÿ…sWÿÃsXÿ…sYÿšs_ÿ×s`ÿšsbÿÃsÿ…sÿšsÿ…s ÿšs!ÿ…s"ÿšs#ÿ…s%ÿ…s&ÿšs'ÿ…s(ÿšs)ÿ…s*ÿšs+ÿ…s,ÿšs-ÿ…s.ÿšs/ÿ…s0ÿšs1ÿ…s2ÿšs3ÿ…s4ÿšs6ÿšs8ÿšs:ÿšs<ÿšs@ÿšsBÿšsDÿšsIÿ×sJÿšsKÿ×sLÿšsMÿ×sNÿšsOÿ×sQÿ×sRÿšsSÿ×sTÿšsUÿ×sVÿšsWÿ×sXÿšsYÿ×sZÿšs[ÿ×s\ÿšs]ÿ×s^ÿšs_ÿ×s`ÿšsbÿÃsdÿÃsfÿÃshÿÃsjÿÃslÿÃsnÿÃtRt Rtÿ®tÿ®t")tRtÿ®t Rt ÿ®{ {{ {ÿ…ÿ®ÿ…")$ÿq&ÿ×*ÿ×2ÿ×4ÿ×7)Dÿ\FÿqGÿqHÿqJÿqPÿšQÿšRÿqSÿšTÿqUÿšVÿ…XÿšYÿ×Zÿ×[ÿ×\ÿ×]ÿ®‚ÿqƒÿq„ÿq…ÿq†ÿq‡ÿq‰ÿ×”ÿוÿ×–ÿ×—ÿטÿךÿ×¢ÿq£ÿ\¤ÿ\¥ÿ\¦ÿ\§ÿ\¨ÿ\©ÿqªÿq«ÿq¬ÿq­ÿq´ÿqµÿq¶ÿq·ÿq¸ÿqºÿq»ÿš¼ÿš½ÿš¾ÿš¿ÿ×ÂÿqÃÿ\ÄÿqÅÿ\ÆÿqÇÿ\Èÿ×ÉÿqÊÿ×ËÿqÌÿ×ÍÿqÎÿ×ÏÿqÑÿqÓÿqÕÿq×ÿqÙÿqÛÿqÝÿqÞÿ×ßÿqàÿ×áÿqâÿ×ãÿqäÿ×åÿqúÿšÿšÿš ÿšÿ×ÿqÿ×ÿqÿ×ÿqÿ×ÿqÿšÿšÿ…!ÿ…$)&)+ÿš-ÿš/ÿš1ÿš3ÿš5ÿš7ÿ×<ÿ®>ÿ®@ÿ®CÿqDÿ\Fÿ\Gÿ×HÿqJÿ…ûÿ×ýÿ×ÿ®ÿ®ÿ®ÿ… ÿ…WÿšXÿqYÿ\_ÿ×`ÿqbÿšÿqÿ\ÿq ÿ\!ÿq"ÿ\#ÿq%ÿq&ÿ\'ÿq(ÿ\)ÿq*ÿ\+ÿq,ÿ\-ÿq.ÿ\/ÿq0ÿ\1ÿq2ÿ\3ÿq4ÿ\6ÿq8ÿq:ÿq<ÿq@ÿqBÿqDÿqIÿ×JÿqKÿ×LÿqMÿ×NÿqOÿ×Qÿ×RÿqSÿ×TÿqUÿ×VÿqWÿ×XÿqYÿ×Zÿq[ÿ×\ÿq]ÿ×^ÿq_ÿ×`ÿqbÿšdÿšfÿšhÿšjÿšlÿšnÿšpÿ×)) )) )n99H+NY y…R™ë ÿ . .I*w 9 c r¡   1 V= ,S “ (« ¤Ó (w 8Ÿ \× \3 T  gDigitized data copyright © 2010-2011, Google Corporation.Open Sans LightItalicAscender - Open Sans Light Italic Build 100Version 1.10OpenSansLight-ItalicOpen Sans is a trademark of Google and may be registered in certain jurisdictions.Ascender Corporationhttp://www.ascendercorp.com/http://www.ascendercorp.com/typedesigners.htmlLicensed under the Apache License, Version 2.0http://www.apache.org/licenses/LICENSE-2.0Digitized data copyright © 2010-2011, Google Corporation.Open Sans LightItalicAscender - Open Sans Light Italic Build 100Version 1.10OpenSansLight-ItalicOpen Sans is a trademark of Google and may be registered in certain jurisdictions.Ascender Corporationhttp://www.ascendercorp.com/http://www.ascendercorp.com/typedesigners.htmlLicensed under the Apache License, Version 2.0http://www.apache.org/licenses/LICENSE-2.0ÿôÿffª      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«.notdefnullnonmarkingreturnspaceexclamquotedbl numbersigndollarpercent ampersand quotesingle parenleft parenrightasteriskpluscommahyphenperiodslashzeroonetwothreefourfivesixseveneightninecolon semicolonlessequalgreaterquestionatABCDEFGHI.altJKLMNOPQRSTUVWXYZ bracketleft backslash bracketright asciicircum underscoregraveabcdefghijklmnopqrstuvwxyz braceleftbar braceright asciitildenonbreakingspace exclamdowncentsterlingcurrencyyen brokenbarsectiondieresis copyright ordfeminine guillemotleft logicalnotuni00AD registered overscoredegree plusminus twosuperior threesuperioracutemu paragraphperiodcenteredcedilla onesuperior ordmasculineguillemotright onequarteronehalf threequarters questiondownAgraveAacute AcircumflexAtilde AdieresisAringAECcedillaEgraveEacute Ecircumflex Edieresis Igrave.alt Iacute.altIcircumflex.alt Idieresis.altEthNtildeOgraveOacute OcircumflexOtilde OdieresismultiplyOslashUgraveUacute Ucircumflex UdieresisYacuteThorn germandblsagraveaacute acircumflexatilde adieresisaringaeccedillaegraveeacute ecircumflex edieresisigraveiacute icircumflex idieresisethntildeograveoacute ocircumflexotilde odieresisdivideoslashugraveuacute ucircumflex udieresisyacutethorn ydieresisAmacronamacronAbreveabreveAogonekaogonekCacutecacute Ccircumflex ccircumflexCdotcdotCcaronccaronDcarondcaronDcroatdcroatEmacronemacronEbreveebreve Edotaccent edotaccentEogonekeogonekEcaronecaron Gcircumflex gcircumflexGbrevegbreveGdotgdot Gcommaaccent gcommaaccent Hcircumflex hcircumflexHbarhbar Itilde.altitilde Imacron.altimacron Ibreve.altibreve Iogonek.altiogonekIdotaccent.altdotlessiIJ.altij Jcircumflex jcircumflex Kcommaaccent kcommaaccent kgreenlandicLacutelacute Lcommaaccent lcommaaccentLcaronlcaronLdotldotLslashlslashNacutenacute Ncommaaccent ncommaaccentNcaronncaron napostropheEngengOmacronomacronObreveobreve Ohungarumlaut ohungarumlautOEoeRacuteracute Rcommaaccent rcommaaccentRcaronrcaronSacutesacute Scircumflex scircumflexScedillascedillaScaronscaron Tcommaaccent tcommaaccentTcarontcaronTbartbarUtildeutildeUmacronumacronUbreveubreveUringuring Uhungarumlaut uhungarumlautUogonekuogonek Wcircumflex wcircumflex Ycircumflex ycircumflex YdieresisZacutezacute Zdotaccent zdotaccentZcaronzcaronlongsflorin Aringacute aringacuteAEacuteaeacute Oslashacute oslashacute Scommaaccent scommaaccent circumflexcaronmacronbreve dotaccentringogonektilde hungarumlauttonos dieresistonos Alphatonos anoteleia EpsilontonosEtatonos Iotatonos.alt Omicrontonos Upsilontonos OmegatonosiotadieresistonosAlphaBetaGammauni0394EpsilonZetaEtaThetaIota.altKappaLambdaMuNuXiOmicronPiRhoSigmaTauUpsilonPhiChiPsiuni03A9Iotadieresis.altUpsilondieresis alphatonos epsilontonosetatonos iotatonosupsilondieresistonosalphabetagammadeltaepsilonzetaetathetaiotakappalambdauni03BCnuxiomicronpirhosigma1sigmatauupsilonphichipsiomega iotadieresisupsilondieresis omicrontonos upsilontonos omegatonos afii10023 afii10051 afii10052 afii10053 afii10054 afii10055.alt afii10056.alt afii10057 afii10058 afii10059 afii10060 afii10061 afii10062 afii10145 afii10017 afii10018 afii10019 afii10020 afii10021 afii10022 afii10024 afii10025 afii10026 afii10027 afii10028 afii10029 afii10030 afii10031 afii10032 afii10033 afii10034 afii10035 afii10036 afii10037 afii10038 afii10039 afii10040 afii10041 afii10042 afii10043 afii10044 afii10045 afii10046 afii10047 afii10048 afii10049 afii10065 afii10066 afii10067 afii10068 afii10069 afii10070 afii10072 afii10073 afii10074 afii10075 afii10076 afii10077 afii10078 afii10079 afii10080 afii10081 afii10082 afii10083 afii10084 afii10085 afii10086 afii10087 afii10088 afii10089 afii10090 afii10091 afii10092 afii10093 afii10094 afii10095 afii10096 afii10097 afii10071 afii10099 afii10100 afii10101 afii10102 afii10103 afii10104 afii10105 afii10106 afii10107 afii10108 afii10109 afii10110 afii10193 afii10050 afii10098WgravewgraveWacutewacute Wdieresis wdieresisYgraveygraveendashemdash afii00208 underscoredbl quoteleft quoterightquotesinglbase quotereversed quotedblleft quotedblright quotedblbasedagger daggerdblbulletellipsis perthousandminutesecond guilsinglleftguilsinglright exclamdblfraction nsuperiorfranc afii08941pesetaEuro afii61248 afii61289 afii61352 trademarkOmega estimated oneeighth threeeighths fiveeighths seveneighths partialdiffDeltaproduct summationminusradicalinfinityintegral approxequalnotequal lessequal greaterequallozengeuniFB01uniFB02 cyrillicbrevedotlessjcaroncommaaccent commaaccentcommaaccentrotate zerosuperior foursuperior fivesuperior sixsuperior sevensuperior eightsuperior ninesuperioruni2000uni2001uni2002uni2003uni2004uni2005uni2006uni2007uni2008uni2009uni200Auni200BuniFEFFuniFFFCuniFFFDuni01F0uni02BCuni03D1uni03D2uni03D6uni1E3Euni1E3Funi1E00uni1E01uni1F4Duni02F3 dasiaoxiauniFB03uniFB04OhornohornUhornuhornuni0300uni0301uni0303hookdotbelowuni0400uni040Duni0450uni045Duni0460uni0461uni0462uni0463uni0464uni0465uni0466uni0467uni0468uni0469uni046Auni046Buni046Cuni046Duni046Euni046Funi0470uni0471uni0472uni0473uni0474uni0475uni0476uni0477uni0478uni0479uni047Auni047Buni047Cuni047Duni047Euni047Funi0480uni0481uni0482uni0483uni0484uni0485uni0486uni0488uni0489uni048Auni048Buni048Cuni048Duni048Euni048Funi0492uni0493uni0494uni0495uni0496uni0497uni0498uni0499uni049Auni049Buni049Cuni049Duni049Euni049Funi04A0uni04A1uni04A2uni04A3uni04A4uni04A5uni04A6uni04A7uni04A8uni04A9uni04AAuni04ABuni04ACuni04ADuni04AEuni04AFuni04B0uni04B1uni04B2uni04B3uni04B4uni04B5uni04B6uni04B7uni04B8uni04B9uni04BAuni04BBuni04BCuni04BDuni04BEuni04BF uni04C0.altuni04C1uni04C2uni04C3uni04C4uni04C5uni04C6uni04C7uni04C8uni04C9uni04CAuni04CBuni04CCuni04CDuni04CE uni04CF.altuni04D0uni04D1uni04D2uni04D3uni04D4uni04D5uni04D6uni04D7uni04D8uni04D9uni04DAuni04DBuni04DCuni04DDuni04DEuni04DFuni04E0uni04E1uni04E2uni04E3uni04E4uni04E5uni04E6uni04E7uni04E8uni04E9uni04EAuni04EBuni04ECuni04EDuni04EEuni04EFuni04F0uni04F1uni04F2uni04F3uni04F4uni04F5uni04F6uni04F7uni04F8uni04F9uni04FAuni04FBuni04FCuni04FDuni04FEuni04FFuni0500uni0501uni0502uni0503uni0504uni0505uni0506uni0507uni0508uni0509uni050Auni050Buni050Cuni050Duni050Euni050Funi0510uni0511uni0512uni0513uni1EA0uni1EA1uni1EA2uni1EA3uni1EA4uni1EA5uni1EA6uni1EA7uni1EA8uni1EA9uni1EAAuni1EABuni1EACuni1EADuni1EAEuni1EAFuni1EB0uni1EB1uni1EB2uni1EB3uni1EB4uni1EB5uni1EB6uni1EB7uni1EB8uni1EB9uni1EBAuni1EBBuni1EBCuni1EBDuni1EBEuni1EBFuni1EC0uni1EC1uni1EC2uni1EC3uni1EC4uni1EC5uni1EC6uni1EC7 uni1EC8.altuni1EC9 uni1ECA.altuni1ECBuni1ECCuni1ECDuni1ECEuni1ECFuni1ED0uni1ED1uni1ED2uni1ED3uni1ED4uni1ED5uni1ED6uni1ED7uni1ED8uni1ED9uni1EDAuni1EDBuni1EDCuni1EDDuni1EDEuni1EDFuni1EE0uni1EE1uni1EE2uni1EE3uni1EE4uni1EE5uni1EE6uni1EE7uni1EE8uni1EE9uni1EEAuni1EEBuni1EECuni1EEDuni1EEEuni1EEFuni1EF0uni1EF1uni1EF4uni1EF5uni1EF6uni1EF7uni1EF8uni1EF9uni20ABuni030Fcircumflexacutecombcircumflexgravecombcircumflexhookcombcircumflextildecombbreveacutecombbrevegravecomb brevehookcombbrevetildecombcyrillichookleftcyrillicbighookUCcyrillicbighookLCone.pnumzero.osone.ostwo.osthree.osfour.osfive.ossix.osseven.oseight.osnine.osffuni2120Tcedillatcedillag.altgcircumflex.alt gbreve.altgdot.altgcommaaccent.altIIgraveIacute Icircumflex IdieresisItildeImacronIbreveIogonek IdotaccentIJ IotatonosIota Iotadieresis afii10055 afii10056uni04C0uni04CFuni1EC8uni1ECA ÿÿ © 46latnMOL ROM ÿÿÿÿÿÿ nälatnMOL (ROM Bÿÿ  ÿÿ  ÿÿ  liga°liga¶liga¼lnumÂlnumÈlnumÎloclÔloclÚonumàonumèonumðpnumøpnumþpnumsalt saltsaltss01"ss01*ss012ss02:ss02@ss02Fss03Lss03Rss03Xtnum^tnumftnumn    &.6>FNV^PzªÆîô2H‘’“”•JJßßááããåå.,Ž‘êìîðòôZgw¡¢ÉØEG–© ƒ„…†‡ˆ‰Š‹Œ ƒ…†‡ˆ‰Š‹Œ„‚‚ ‚ ƒŒ‚ ‚ƒŒ !$%IJ6 "(^IO]ILI5O4LI^V0‚R *†H†÷  ‚C0‚?1 0 +0a +‚7 S0Q0, +‚7¢€<<<Obsolete>>>0!0 +´é –ÐûέX[;ôÙ&õ*åë ‚]0‚z0‚b 8%×úøa¯žôç&µÖZÕ0  *†H†÷ 0S1 0 UUS10U VeriSign, Inc.1+0)U"VeriSign Time Stamping Services CA0 070615000000Z 120614235959Z0\1 0 UUS10U VeriSign, Inc.1402U+VeriSign Time Stamping Services Signer - G20Ÿ0  *†H†÷ 0‰ĵòR¼ˆ†`)J[/K‘k‡‘ó5TX5êÑ6^bMRQ4qÂ{f‰ÈÝ*Äj ö7Ù˜t‘ö’®°µv–ñ©JcEG.k ’NK+ŒîXJ‹Ôä,ø‚ªXÙÍBó-ÀuÞ«ÇŽšlL•ÞÛïgárÂIž`<áâ¾£cxi{­-£Ä0Á04+(0&0$+0†http://ocsp.verisign.com0 Uÿ003U,0*0( & $†"http://crl.verisign.com/tss-ca.crl0U%ÿ 0 +0UÿÀ0U0¤010 UTSA1-20  *†H†÷ ‚PÅKÈ$€ßä $ÂÞ±¡¡¦‚- ƒ7 ‚,°ZaµØþˆÛñ‘‘³V@¦ë’¾89°u6t:˜Oä7º™‰Ê•B°¹Ç WàúÕdB5NÑ3¢ÈMª'Çòá†L8MƒxÆüSàëà‡Ý¤–ž^ ˜â¥¾¿‚…Ã`áß­(ØÇ¥KdÚÇ[½¬9Õ8"¡3‹/Ššë¼!?DA µe$¼HÓD€ë¡ÏÉ´ÏTÇ£€\ùy>]r}ˆž,C¢ÊSÎ}=ö*:¸O”¥m ƒ]ù^Sô³WpÃûõ­• ÞÄ€`É+n†ñëôx'ÑÅî4[^¹I2ò30‚Ä0‚- G¿•ßRFC÷ÛmH 1¤0  *†H†÷ 0‹1 0 UZA10U Western Cape10U Durbanville10 U Thawte10U Thawte Certification10UThawte Timestamping CA0 031204000000Z 131203235959Z0S1 0 UUS10U VeriSign, Inc.1+0)U"VeriSign Time Stamping Services CA0‚"0  *†H†÷ ‚0‚ ‚©Ê²¤ÌÍ ¯ }‰¬‡uð´NñßÁ¿ga½£dÚ»ùÊ3«„0‰X~ŒÛkÝ6ž¿Ñìxòw¦~o<¿“¯ ºhôl”ʽR-«H=õ¶Õ]_Ÿú/k¤÷£š¦ÈáLRã`ì@~¹ Þ?Ǵ߇½_zj1.™¨G Î1s W-Íx43•™¹Þh/ªæ㊌*Ë!‡f½ƒXWou¿<ª&‡]Ê<Ÿ„êTÁ nÄþÅJݹ—"|Û>'ÑxìŸ1Éñæ"ÛijGCš_ ä^õî|ñ}«bõM ÞÐ"V¨•Í®ˆv®îº óäMÙ ûh ®;³‡Á»£Û0Ø04+(0&0$+0†http://ocsp.verisign.com0Uÿ0ÿ0AU:0806 4 2†0http://crl.verisign.com/ThawteTimestampingCA.crl0U% 0 +0Uÿ0$U0¤010U TSA2048-1-530  *†H†÷ JkùêXÂD1‰y™+–¿‚¬ÖLÍ°ŠXnß)£^ÈÊ“çR ïG'/8°äÉ“NšÔ"b÷?7!Op1€ñ‹8‡³èè—þÏU–N$Ò©'Nz®·aAó*ÎçÉÙ^Ý»+…>µµÙáWÿ¾´Å~õÏ žð—þ+Ó;R8'÷?J0‚ü0‚e eR&á².áY)…¬"ç\0  *†H†÷ 0_1 0 UUS10U VeriSign, Inc.1705U .Class 3 Public Primary Certification Authority0 090521000000Z 190520235959Z0¶1 0 UUS10U VeriSign, Inc.10U VeriSign Trust Network1;09U 2Terms of use at https://www.verisign.com/rpa (c)09100.U'VeriSign Class 3 Code Signing 2009-2 CA0‚"0  *†H†÷ ‚0‚ ‚¾g´`ªIoV|fÉ^† Õñ¬§qƒŽ‹‰øˆ‰º-„!•äÑœPLûÒ"½Úò²5;à ûü.Z¿‰|=;%öóX{œôµÆ ¸€Î¾'tag'MjåìaXy£à'°áM4+G D¹Þf$fŠÍOºÅ8ÈTáröfuj¹IhÏ8y ª0¨Û,`Hž×ª©ƒ×8‘09–:|@T¶­à/ƒÜ¨R>³×+ý!¶§\£ ©¦P4.M§ÎÉ^%ÔŒ¼ón|)¼]ü1‡ZÕŒ…gXˆ ¿5ðê+£!çöƒå¨í`x^{`ƒýW ]A cT`ÖC!Û0‚×0Uÿ0ÿ0pU i0g0e `†H†øE0V0(+https://www.verisign.com/cps0*+0https://www.verisign.com/rpa0Uÿ0m+ a0_¡] [0Y0W0U image/gif0!00+åÓ†¬ŽkÃÏ€jÔH,{.0%#http://logo.verisign.com/vslogo.gif0U%0++04+(0&0$+0†http://ocsp.verisign.com01U*0(0& $ "† http://crl.verisign.com/pca3.crl0)U"0 ¤010UClass3CA2048-1-550U—Ðk¨&pÈ¡?”-Ä5›¤¡ò0  *†H†÷ ‹ÀÝ”ØA¢ai°¨xÇ0Æ<~B÷$¶äƒsœ¡âú/ëÀÊDçràP¶U ƒn–’äšQj´71Ü¥-ëŒÇOçM2º…øN¾úgUeðj¾zÊd8xEv1ó†z`³]ö‹fv‚Yáƒå½I¥8VåÞAwX0‚0‚û fãðgyÊmPSoˆƒ0  *†H†÷ 0¶1 0 UUS10U VeriSign, Inc.10U VeriSign Trust Network1;09U 2Terms of use at https://www.verisign.com/rpa (c)09100.U'VeriSign Class 3 Code Signing 2009-2 CA0 100729000000Z 120808235959Z0Ð1 0 UUS10U Massachusetts10 UWoburn10U Monotype Imaging Inc.1>0<U 5Digital ID Class 3 - Microsoft Software Validation v210U Type Operations10UMonotype Imaging Inc.0Ÿ0  *†H†÷ 0‰”D •i|U ÐÛ25ŠL3«^ ¡L×*‡8ט¥@ðI "SOÂC¦Ê‹©VïnH¨9c;$¹˜ÏÊ5}rãGWýyËŠJç@p-5c®€ÏįØû÷Éü‰Øפ Û ò¢ò{ïÍuÁ÷ePd"½}¼­¸KÌXEMÑYLM£‚ƒ0‚0 U00Uÿ€0DU=0;09 7 5†3http://csc3-2009-2-crl.verisign.com/CSC3-2009-2.crl0DU =0;09 `†H†øE0*0(+https://www.verisign.com/rpa0U% 0 +0u+i0g0$+0†http://ocsp.verisign.com0?+0†3http://csc3-2009-2-aia.verisign.com/CSC3-2009-2.cer0U#0€—Ðk¨&pÈ¡?”-Ä5›¤¡ò0 `†H†øB0 +‚70ÿ0  *†H†÷ ‚Næ"‡ßgAâÒî~ΙÖc½ðµ“åjrbáõÒ<8î¨=_ºG‚_[KIô ú“ ÐVD¢ˆóû®÷ 5Þ< ¬D”`E*›þ›oL;±4gp†ÿZ9\Zãl‚«5|eKý˜mµ”Iœˆp¾=±b•´Û´ÔÚèA~þ}¹¤’ënò"ŠÆw6MŠZ S1Ó+(¯RázkµwD½ ­ô]%,ãÍŠ0>KœyʦN® ÂÌ$ Á”‚öñº¶›šØ\<ñê'M<‰o3ŠÓ†ÞéX3u=ë“iâDoNlÏÕ…ÚV¦š¦?ËL!hò`ºáè]9!2í1‚g0‚c0Ë0¶1 0 UUS10U VeriSign, Inc.10U VeriSign Trust Network1;09U 2Terms of use at https://www.verisign.com/rpa (c)09100.U'VeriSign Class 3 Code Signing 2009-2 CAfãðgyÊmPSoˆƒ0 + p0 +‚7 100 *†H†÷  1  +‚70 +‚7 10  +‚70# *†H†÷  1ùÿý\ Ü Öv¼éÒîÖ\ÀšT0  *†H†÷ €s .Á5Ò°ìõNP® MÑ/é©>Ñ'˜³Yh‰Þ°=š n­ÔãWAmzŒv±¦‰†(´"¤Ãä½–ÍK¼ë6,`Ž'¤¬à…\œK?¶÷ìn}鯕^ÖFÖ€äcÔ£hòDýÊiÍžðzQn 3“SBí£†0‚|¡‚0‚{ *†H†÷  1‚l0‚h0g0S1 0 UUS10U VeriSign, Inc.1+0)U"VeriSign Time Stamping Services CA8%×úøa¯žôç&µÖZÕ0 + ]0 *†H†÷  1  *†H†÷ 0 *†H†÷  1 110505165510Z0# *†H†÷  1~”š-X `žÒŽÛ…dþÕ0  *†H†÷ €C›þ†…·æ¿N¥÷E„Nj㦈²¢z …C| rSR·—P¼fýEžá«’׋–AÄËjz d¥£ËÌ5ø5e«‚ûý+KXÕŸh›¶ñ£<ÊîŒÿDÐ<ùÌ‚Ûè6ï‡o[x1¤“‰5üïɽTªÅ]‹h}j‚e:¨€ã‡OpenSans-Regular.ttf000077500000000000000000006504201321131462300377450ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/web/client/resources/fonts/Open_Sans0DSIGžD;œtGDEF&¯7|GPOS 777œ8GSUB+=·7ÔÆOS/2¡>žÉ¸`cmap)«/h´cvt M¤¢fpgm~a¶Ð´gasp#7lglyft8™K%Œ/´head÷vâ¦<6hhea Ì st$hmtxè5<ÝškernT+ ~U@¶6loca)Üñ4VmaxpC ˜ names°ˆ… xÇpostCïl@&+prepC·–¤„ š!Çõ__<õ É51‹ÉèLLûšýÕ ¢b ý¨ ¬ûšþ{ ¢£ªŠV/\ø¶š3š3Ñfñ àï@ [(1ASC@ ÿýþ„X ŸH¶ ÍÁ#˜5…+3“ƒ–h×qÅ…^R^=jV“hö?“T!˜ð“f“¼“d“^“+“…“u“^“h“j!˜!?“h“w“ho1y/É }ÕÉsÉ!ÉÓ}çɪT#ÿ`éÉ'É9ÉÉ;}ÑÉ;}òÉdjmÓºÃhž{‘R¢¦ð¢3V1–ÿüž‰s^ç°Ïsçs}s¶b'é°¢ÿ‘3°°q°é°Õsç°çsD°ÑjÓé¤91'¾R=hîH“h#˜“¾“?“{“hî!{ž5¨dÕFúR“h“T¨dÿúm“hÇ1Ç!ž‰ô°=q!˜Ñ%ÇLBúP=K=.=o3üÿþ }sÉsÉsÉsɪ<ªTªÿÿª<Ç/É;};};};};}“…;}ÓºÓºÓºÓº{ãÉú°s^s^s^s^s^s^Ý^Ïs}s}s}s}sÿÚ©ÿ³ÿìÅqé°ÕsÕsÕsÕsÕs“hÕsé¤é¤é¤é¤ç°s^s^s^ }Ïs }Ïs }Ïs }ÏsÕÉçsÇ/çssÉ}ssÉ}ssÉ}ssÉ}ssÉ}sÓ}b'Ó}b'Ó}b'Ó}b'çÉé°çéªÿâÿª*ÿÚªÿ̪T5ªT°ÍT ¢#ÿ`ÿ‘éÉ3°%°'É£'ÉY'É°'Ƀ°/ÿüÉé°Éé°Éé°sÉé°;}Õs;}Õs;}Õsb}‰qòÉD°òÉD`òÉD‚djÑjdjÑjdjÑjdjÑjmÓmÓmÓÓºé¤Óºé¤Óºé¤Óºé¤Óºé¤Óºé¤h9{{‘R¾R‘R¾R‘R¾R°žÃs^üÿþÝ^;}ÕsdjÑj¼ ¼ ²-¼%¢žo“%¼žçžüž!˜òÿÔ}ÿÔ˜ÿäÿä…ÿÔÿä¶ÿé/É)É“'sÉ‘RçÉ;}ªTéÉÓ9ÉÉmH;}ÕÉÑɉJm{bjž^mBPª<{ãsÍZé°¶¨ߤãs° ¤qÍZÝsé°¼s¶¨%°Fÿòô°VÍqÕs3Õ¦ÛsçsÉߤ¾s^ÿì¤/s¶ ߤÕsߤ/ssÉß)É}djªTª<#ÿ`o ÉßåÉøÕÉçÉ/É)ÉwsÉÁ¦JËËåÉ¢9ÉçÉ;}ÕÉÑÉ }møbjžåɪBÉDÉÓÉ%É =fÉ3s^Åw°m°“)}sãÝD°°'°‘á°°Õsø°ç°Ïs¼)¸q1'°Ýœ°-°))°¼°ð9¦°q%}sém°ðsÑj¢ÿìÿ‘²°é'°ø°7Ém°h9h9h9{RRRJÿü\\ö?\ÍÍ={{¤F˜ ždÅ…%…oRoP㘠þy'm“b“Dš¸?˜)w'É5%BPôf=G= =G=j¦f“'éÉ L“hd%¤w “b“h“h“hªo¼¼žÛÿ‘‰qÇ'ÇÇ;Ç)Ç9Ç3Ç#ªVy!šÍTTÿ‘\ú …¸9Éq°s^Rþߪu3˜uu=}ßs%ºR¤üSý üýý;sÉË}s°…fZÉã°mƒ ^É!°Å# ËÉÅ°¨?Ý^m¤=}Õs  ¬}}s}Bsþ}wsß^}çsßjuËžøžßžáé)¦))É%°ç/¼ãÉç°7/m#É3°=¦JÝDJÉ\°éÉD°é/#ƒì)øÉ/°Éã°‰Éì°;}s }Ïsm¼){{ôV'×¼)‰ªßœªÍœÉ®°´=F3´=F3ªTÁãƒÉd°¦“ÑÉî°öÉ9°ªÝœ;Éã°ªTs^s^üÿþÝ^sÉ}s×uyf×uyfÁã¦JÝDªJéË°Ë°;}Õs=}Õs=}Õs =ð9øøøªÝœ7Ém°ÓÉ)°7/møR'ž1'çƒçs1ƒ+s;NjPN/PÙÏÉN° }s®-)ªoÍZš‘s^s^s^s-s^s^s^s^s^s^s^s^sÉ}ssÉ}ssÉ}ssÉ}ss]}JsÉ}ssÉ}ssÉ}sªT{ªT;}Õs;}Õs;}Õs;}Õa;}Õs;}Õs;}Õs=}ßs=}ßs=}ßs=}ßs=}ßsÓºé¤Óºé¤%ºR¤%ºR¤%ºR¤%ºR¤%ºR¤{{{çsûåüqûšüqühüyüyüyüh¤1¤¤-4‰sô-)“^“…“u“^“h“jmZ\mÓçqçqçqçqçq;É;;³;ÿÇ;;ÿ«;ÿó;ÿç;V;»^Éåÿä;ÉÉÉÉ™¸ °€0HI~ËÏ'2a’¡°ðÿ7¼ÇÉÝó #ŠŒ¡ªÎÒÖ O_†‘¿Ï?…ÇÊñùM   " & 0 3 : < D p y  ¤ § ¬!!!! !"!&!.!^"""""""+"H"`"e%Êûþÿÿýÿÿ IJ ÌÐ(3b’ ¯ðú7¼ÆÉØó #„ŒŽ£«ÑÖP`ˆ’ÀÐ>€ ÈËòM   & 0 2 9 < D p t  £ § «!!!! !"!&!.!["""""""+"H"`"d%ÊûþÿÿüÿÿÿãÿãÿÂÿÂÿÂÿ°¿²aÿIÿ–þ…þ„þvÿhÿcÿbÿ]gÿDýÏýÍþ‚þýšþ þ þ äXäãzä}ä}ã âBáïáîáíáêáááàáÛáÚáÓáËáÈá™ávátáá á ânàþàûàôàÈà%à"àààààßçßÐßÍÜiOS®ª®Àðàê0L\pr`<–—˜™š›ëœíïžñŸó &'()*+,-./0123456789:;<=>?@AIJ$%TUVWXY¡\]^_`abcdef¢hijklmnopqrstuv£hœžŸ ¤¥£¤¥¦§ijêëìíîïðñòóôõkö÷“”•–—˜™šøù¦ÊËÌÍÎÏÐÑÒÓÔÕÖק¨F©opqrstu45]^@G[ZYXUTSRQPONMLKJIHGFEDCBA@?>=<;:9876510/.-,('&%$#"! , °`E°% Fa#E#aH-, EhD-,E#F`° a °F`°&#HH-,E#F#a° ` °&a° a°&#HH-,E#F`°@a °f`°&#HH-,E#F#a°@` °&a°@a°&#HH-, <<-, E# °ÍD# ¸ZQX# °D#Y °íQX# °MD#Y °&QX# ° D#Y!!-, EhD °` E°FvhŠE`D-,± C#Ce -,± C#C -,°(#p±(>°(#p±(E:± -, E°%Ead°PQXED!!Y-,I°#D-, E°C`D-,°C°Ce -, i°@a°‹ ±,ÀŠŒ¸b`+ d#da\X°aY-,ŠEŠŠ‡°+°)#D°)zä-,Ee°,#DE°+#D-,KRXED!!Y-,KQXED!!Y-,°%# Šõ°`#íì-,°%# Šõ°a#íì-,°%õíì-,°C°RX!!!!!F#F`ŠŠF# FŠ`Ša¸ÿ€b# #Š± ŠpE` °PX°a¸ÿº‹°FŒY°`h:Y-, E°%FRK°Q[X°%F ha°%°%?#!8!Y-, E°%FPX°%F ha°%°%?#!8!Y-,°C°C -,!! d#d‹¸@b-,!°€QX d#d‹¸ b²@/+Y°`-,!°ÀQX d#d‹¸Ub²€/+Y°`-, d#d‹¸@b`#!-,KSXŠ°%Id#Ei°@‹a°€b° aj°#D#°ö!#Š 9/Y-,KSX °%Idi °&°%Id#a°€b° aj°#D°&°öŠ°#D°ö°#D°íŠ°& 9# 9//Y-,E#E`#E`#E`#vh°€b -,°H+-, E°TX°@D E°@aD!!Y-,E±0/E#Ea`°`iD-,KQX°/#p°#B!!Y-,KQX °%EiSXD!!Y!!Y-,E°C°`c°`iD-,°/ED-,E# EŠ`D-,E#E`D-,K#QX¹3ÿà±4 ³34YDD-,°CX°&EŠXdf°`d° `f X!°@Y°aY#XeY°)#D#°)à!!!!!Y-,°CTXKS#KQZX8!!Y!!!!Y-,°CX°%Ed° `f X!°@Y°a#XeY°)#D°%°% XY°%°% F°%#B<°%°%°%°% F°%°`#B< XY°%°%°)à°) EeD°%°%°)à°%°% XY°%°%CH°%°%°%°%°`CH!Y!!!!!!!-,°% F°%#B°%°%EH!!!!-,°% °%°%CH!!!-,E# E °P X#e#Y#h °@PX!°@Y#XeYŠ`D-,KS#KQZX EŠ`D!!Y-,KTX EŠ`D!!Y-,KS#KQZX8!!Y-,°!KTX8!!Y-,°CTX°F+!!!!Y-,°CTX°G+!!!Y-,°CTX°H+!!!!Y-,°CTX°I+!!!Y-, Š#KSŠKQZX#8!!Y-,°%I°SX °@8!Y-,F#F`#Fa#  FŠa¸ÿ€bŠ±@@ŠpE`h:-, Š#IdŠ#SX<!Y-,KRX}zY-,°KKTB-,±B±#ˆQ±@ˆSZX¹ ˆTX²C`BY±$ˆQX¹ @ˆTX²C`B±$ˆTX² C`BKKRX²C`BY¹@€ˆTX²C`BY¹@€c¸ˆTX²C`BY¹@c¸ˆTX²C`BY±&ˆQX¹@c¸ˆTX²@C`BY¹@c¸ˆTX²€C`BYYYYYY±CTX@ @@ @  ±CTX²@º ³  ±€CRX²@¸€± @²@º€ @Y¹@€ˆU¹@c¸ˆUZX³ ³ YYYBBBBB-,Eh#KQX# E d°@PX|YhŠ`YD-,°°%°%°#>°#>± ° #eB° #B°#?°#?± °#eB°#B°-,°€°CP°°CT[X!#° ÉŠíY-,°Y+-,Šå-@™ !H U UHU?¯MK&LK3KF%&4U%3$UÿÿÿJI3IF%3UU3U?¯GFëF#3"U3U3UU3UOÏÿU3Uo¯ï€¸±TS++K¸ÿRK° P[°ˆ°%S°ˆ°@QZ°ˆ°UZ[X±ŽY…BK°2SX° YK°dSX°±BYss++^stu+++++t+st+++++++++++++st+++^N¶u¶ÍH‘ÿìÿìÿìþÿì¶ü”ÿíþ…ÿêþ©ÿìþ¼‹Ý˜Ž™ˆŠQwÿ{ìjƒ®ÙA_t–¯ñ[¹ûF£Å4‘ÇûDd»A€Û  U Š ¸  9 l ” à á  V œ Ù , y Ì ð $ K ¿ æ6Or“©È$y´T”(f”Ò'¹úO£Ö(h¥ÌG€¬îK……¶S¡õ•ËG”Ïíõ•ÍÙc‚ÁñEl¥Ýó{Œ®¿ÑÝ+7HYj|ž¯Á*;L]n€®  * ; L ^ o ±!!(!8!H!X!i!z"""!"1"A"R"c"t"…"—"ÿ###/#?#O#`#¦$ $$,$<$M$]$´$Å$Ö$æ$÷%%%%0%@%Q%a%r%ƒ%”%¤%µ%Æ%Î&:&K&[&l&|&&ž&ª&¶&Ç&×&è&ø' ''*';'G'W'h'y'É("(3(D(U(f(w(ˆ(“(ž(¯(Æ(Ò(Þ(ï)) ))L)])n)y)…)–)¦)²)¾)ø*-*>*N*Z*e*v*†*—*Þ+'+8+H+Y+i+{+Œ+ï,i,z,Š,•,¡,²,Ã,Ô,ä,õ----.->-I-T-e-u-²...%.6.F.W.g.y.Š.œ.­.¹.Å.Ö.ç.ø///+/;/L/]/n/~/¥/ø0w11'181I1Y1d1o1˜1Á1×1ÿ22T2{2´2æ33N3_3g3x3Š3œ3­3¿3Ð3ã3ë3ó444"4*424‹4“4›4Á4É4Ñ55525:5q5y55è5ð6<66¢6´6Ä6Ô6ä6õ77k7Ð88g8Å99L9¦9Ò9Ú:,:4:_:Ê:Ò;;\;¨;í<%<]<º==_=¹=Ë=Ü=ì=ü> >>o>€>Ê>Ò>Ú>ì>ô?S?¦?å?ö@@7@?@†@Ž@–@ß@çA,A‰AÁAÒBBVcV—V®VÒW2WbWãX,X>XPX}X‰X•X¼XãYY!Y@YuY·YüZMZnZÓ['['['['['['['['['['['['['['\q\Ì\Ý\å]l]§^ ^^-^9^E^W^Œ^Ã^Ó^ã_@_—_à`1`:`C`L`z`™`ª`»`Ë`ÛaNa™aíb;b›bþc?c€cÖd,ddôeieàfŒg0g8g@ggöh/hghyh‹ii i€iójk;kÑl:l}l¿mm3m`m†m¬noooßp1p‚p×qCq{q´rrUr¨rûsssPsŒsÍttXt¬tæuu]u¢uÝvvsvÆwBw¹wÅwÑxx4x‹P‹b‹t‹‰‹‹¯‹Á‹Ó‹å‹÷Œ ŒŒ-ŒBŒVŒbŒnŒŒŒ¡Œ±ŒÃŒÕŒçŒù /AVj{Œ˜¤°¼ÍÞðŽŽŽ&Ž8ŽJŽ\ŽnŽƒŽ—Ž¨Ž¸ŽÉŽÙŽêŽû (4@L]n °ÁÒãóÿ #4EVfr¦á‘‘j‘‘ú’2’{’Í’õ““;“D“ƒ“­“î”N”“”Þ”æ• ••n•z•ö–––q––‘–¢–²–Ç–Ø–é–ú— ——.—?—J—[—g—y——“—›—­—µ—½—ΗÚÁ ¶·/2/3/3/310!!7!!ÁIü·hyý‡¶úJhæ˜ÿ㉶+@   OY ??+9/933310#3432#"&Fi3Ïáx:?@94D“#ú´ˆFB@G?…¦°¶@  ?3Í2993310#!#?(i)+)h)¶ýðýð3ö¶™@U     !  ! NY NYO O   /3?399//]]33+3333+339939939939223910!!#!#!5!!5!3!3!!!ÕBþÍT‰TþÑRˆPþúDþë+R‹R1T†Tüå/Bþуþ¬þR®þR®T´þL´þLþ¬Tƒÿ‰  &-f@5'%* ! ./%  MY$*LY*+MY*//99//92+33+33+3933333333310#5"&'53&&546753&'4&'6 Ì·pÒCSÙYͥ˧¸«4•šœJªY€ÙýÝZocfÁˆ±èß#œ%/¸A¬ˆƒ¨¶´Eƒ; þN2_{eHY,þ{L\)ƒ]hÿì-Ë !-1E@$ ("".( 023 + + +010%?3?3??99//33933331032#"#"&5463232654&#"#"&54632#òJS¤¤SJÊ™”Œ›•’‘œ¦JTTPPTTJË™”Ž™•’ŽŸþþüÕ“+ªªTR¨ªäéîßãæîüÛ«©§­«¥¥«ãéîÞãæë úJ¶qÿìÓÍ 5Q@0#*+.+-#& 673 IY3'-0/&** / JY ?+?9/99?+93333106654&#"27%467.546326673#'#"&žHWegVYo›ñŸþKo\,›þ¹‹´U=$į¢ºˆ—8C¨D‰+å¹vô–×í“E}XKSMa`ûš¨DYfAu‰ú‚Èf_bj9–¨§•kµ]þy>§cþâ”þݲj\Ô…¦?¶·?Í9310#?(i)¶ýðRþ¼!¶ @   '??99331073#&R›’¢‘”‹ “š1 ήÁþ2ôðþ6½ªÆ=þ¼ ¶ @    '??993310#654'3 ›’ ‹”‘¢“š1þùþ:¨¼ËðôÎÁ¯þ1V0@    ?Ä29333910%'%7‘+Žþƒø¬° °òþ‡‡+þuo¶þº^jþ–^F¶o‹hã)à (@  PY/]3+3933310!!#!5!3œþd‹þfš‹ŠþVªŠ¬?þømîµ /Í9910%#67^b5}A îdþ÷rh2\TÙ?qµ/399105!TëÙ˜˜˜ÿã‰ò @  OY ?+931074632#"&˜=9:AB93CjCEECAF?Û¶·??9910#Ûýߦ!¶úJ¶fÿì-Í (@  KY KY?+?+993310#"3232#"-ïöìöîôî÷üá–¤¦••¦¤–Ýþ…þŠr~rþ~þ’þÁþÝ';;%þ߼˶ $@    ??9/9993310!#47'3Ë¢4ÔXƒŒ‚t.¬r+d%Ë+@ KYLY?+?+93310!!5>54&#"'632!%ü?°p8Ž~[£dXÊîÎêœÖþÀðƒ²˜Su‰+8% =1*"% BC55FY;GY "***GY*(?GY(.GY?+?+?+99//99++993333310#"'332!"&5467&&5467&&5463232654&##"3254#"1Ë,ÜÀ1+jJZ²¿þÜþè×é€t*9@EUkØÆVEþ–ŒÑÉn˜Çq~Z‚tóöu~Hi#qG¡À8U-+–¶¿ ’d’P59UlK†›H‡DJA,>85Gÿì¨F4@  GY@FY?+?Í+393310%267# #5773!!,Ri*þÂF`>þÂ^u  OŒPEêþý{cj¤ÿì9H4@   FY ??+?393993331032653#'##"&5Lz‚¬Ÿ¦‰ 3µtÈÇHý9†„¼Õ@û¸“QV¾ÑÍH @   ??399910!3363 þ`²ìP u̲þ`HýväD5M0û¸#H,@    ?3?339933339910!&'##3366733663/É4(ÏÀþÕ®jo 1É´Ä8#¿¬þу;ѯ_ýHþcþPK9µ5uý‹¬u$–Üû¸'H "@  ?3?39991033##¸þƒ½! »þƒ‘¼þÍþʼ1þ\¤ýéýϼþDþH$@  FY ?2?+991033663#"'53277²ðO Sæ²þ)F»ˆLJ7D«I=HýÖ_3÷|û ¹›… ÀœRmH +@ GYGY?+?+93310!!5!5!!müåVýÏçý²]qVüº=þ¼Á¶,@  '??933333310%&&54ᘡ463Ûuq¾Ð~x‚tضæßß f\Œªš/hY\`2›¬‹ÁþÙ×' '×îþ{@ ??93103#î÷üHþ¼Ë¶,@ '??933333310&54'52"5665467 ßã¸Óv‚z~;otnq?'×'Á‹®™þÎa[YhþÑ™«Œ\f)rxhP)T$@ PYPY/+Ä/Ä+9910"56323267#"&'&&R56dDqYBb/6€6fŽH~HKZÉC6—m&@9–n! ˜þ‹‰^+@  OY "??+9/9333103##"&54632Ûi3Ïáy<@      ??99//333393333310%#5&5%53&#"327Ëi“…ËÁŒ‡KŽ11…m¬¢Ÿ§Žð6ÈÎ úü>¬¤!Œ3ÓÙÔË;?DÉH@&   NY LYKY?+?+9/3+393333102&#"!!!!5655#5346ª¾ª=š{}¦þZAJûûÍÆÆàÉT…M|ŒþÙÝdˆ,š/ôß<²Í{ ' @ "()%/33/399331047'76327'#"''7&732654&#"¸J‡^‡h‚f‰_†JJƒ\‰f†d‡\…Jttž rtÓzkŒ\…II…\Šqvƒg‡\…GI…\ˆk|p Ÿqr¢¤q¶V@.        ??399//]9223333933333103!!!!#!5!5!5!3H{®þ`þÃ=þäþÄ<þÄþe²ß×üþªþô ªîþ{$@ ??99//9333103#3#îüøþ ü÷{ÿø–1=C@&2*8 #>?;6-! !'GY! GY ?+?+99333310467&&54632&&#"#"'532654&&'.7654&'‹VNJTÏÅ^Ÿa5b‡Ltt{šº–RJ™êÔÚ€NÂR†0lsŽ†B’„§1‰“¹DU)V‰%(oUy‹'ƒ';@54&#"'632!ý¤ìYR!P?4bEBƒ˜„“Y“®¸JhæVaL6DE&2Xo‚pP—Š¥!9É#9@" $%]mL ! !?3?39/]]]39310#"'53254##532654&#"'6632sRD°¸¨˜t“{ÓçuwgcPCBp8E?Œ^ˆçPg/¢€8{D¢‘kOD=D+#Z-6w‰Ù! ¶  € /Í99106673#‰0o Ê,®@oò>°AA¾4°þDH5@  FY  ??+??399333331032653#'##"'##3Vþ«Ÿ¦ˆ oå–X ¦¦}þú½Ô@û¸“§\T þÀ4qþü`'@ /3?39/93310####"&563!`rÕs>TØËÚè-þü°ùP3úûþ˜L‰Z @   OY/+93104632#"&˜>8:AB93CÓBEEBAF?%þ´$@ /Ì29/393310#"'532654&'73´™–3--;OQOmXn7´þßaj j(6+5²s'LJᶠ@  ?2?9/9933103#47'R…6‡C¶ü”C[Z-_`B¾Ç %@  ?3Ä]2993310#"&5463232654&#"¾«–’©¨—˜¥ýþ[hi\\ig\o¤·º¡£µ¶¢zzzz{vvPu¨¾ #@   /3/393310'7'7¨þ¨uþáuXþuþ¨uþáuX þiG_^EþiþiG_^EþiÿÿKѶ'ƒ&{ÿ<ý· ³?55ÿÿ.Û¶'?&{âtNý·²?5ÿÿ!É&uù'ß<mý· ³+?553þwT^(A@"##)* && OY& IY#?+?+9/_^]9333103267#"&54>76655#"&54632NKay=„zP–b;ÅƾØ#@Y6eA´y;>B73F¬3z”TjKM8dq&0‡`ºªFiYR/Xt]+‡EB@G@ÿÿs&$CÿÂR³&+5ÿÿs&$v…R³&+5ÿÿs&$K#R³&+5ÿÿ/&$RR³&+5ÿÿ%&$j7R ´$&+55ÿÿ&$P9ÿþ¶N@,   IYIY IY  IY?+??99//+++33933310!!!#!!!!!!#ýýþã°ºÉý¼ýãDûT¾vÑþ/¶—þ)–ýæÒµÿÿ}þÏË&&zÿÿÉøs&(Cÿ·R³ &+5ÿÿÉøs&(v?R³&+5ÿÿÉøs&(KÿûR³&+5ÿÿÉø%&(jR ´!&+55ÿÿ<Vs&,Cþ³R³ &+5ÿÿTss&,vÿaR³&+5ÿÿÿÿ¡s&,KþóR³&+5ÿÿ<o%&,jÿR ´!&+55/H¶ W@2 IY?¯Ïß  JY JY?+?+9/_^]3+39333310!!#53! !#!!3 Hþwþþ{šš²Q|µýÇç{þ…¾béþ–þ‰–—þ‰þ¤@ýü–þ ÿÿÉ?/&1R“R³&+5ÿÿ}ÿì¾s&2CyR³&+5ÿÿ}ÿì¾s&2v R³!&+5ÿÿ}ÿì¾s&2K´R³&&+5ÿÿ}ÿì¾/&2RšR³!&+5ÿÿ}ÿì¾%&2jÕR ´-&+55… ˜ @    /993310'7¬`þ ^`þžþ¤e^þ da˜cþžþ c_þ¡c``eþ}ÿþö#N@,  $%! !IY IY?Æ+?Æ9+99933910!"''7&!27'32&#"¾þþÄë”exl²`DÑaxjÀ´ný`s°óøü'ej¨óýÝþ¡þndOšÆme‰^‡P”Êþ•šüLR2*þúš¯IþÍÿÿºÿìs&8CFR³&+5ÿÿºÿìs&8vÏR³&+5ÿÿºÿìs&8K}R³ &+5ÿÿºÿì%&8j˜R ´'&+55ÿÿ{s&<v1R³&+5Éy¶ 6@  JY JY ??99//++99333310!##33 32654&##yþÑþḪª×üú¨âʾÊÌãîþÁ¶ÿÏýꤕŠ°ÿìœ0A@")*# *12*..&FY.*FY?+??+9/9333310#"'53254&'&&54676654&# #4632X8GNŒf³¼k?œH×Sn`EGK@ˆþì¦ÜÞÎáò‡sFC! *93_e «Eš'/¶KkFR{T?j59Z5PUßûL²²»ÿÿ^ÿìÍ!&DCŽ³&&+5ÿÿ^ÿìÍ!&Dv+³.&+5ÿÿ^ÿìÍ!&DKس3&+5ÿÿ^ÿìÍÝ&DR½³.&+5ÿÿ^ÿìÍÓ&Djâ ´:&+55ÿÿ^ÿìÍ…&DP÷ ´(&+55^ÿìs\)4;a@3*$08090 <=-'-FY11GY8$'"'5FY?3+3?39/993+3+39333399310467754&#"'66326632!!267# '#"&732655"!4&^øþ¸tw£4JÇb‚¥)5«nÀèýC:[TV•eþß}Qņ£¹®kX‘¨žº¤½y‹ €/¡³D{T)5W_X`þõÞkþu#'”&!éjª—_Y©šcm2¦žœ¨ÿÿsþ‹\&FzFÿÿsÿì!&HCµ³&+5ÿÿsÿì!&HvN³$&+5ÿÿsÿì!&HK÷³)&+5ÿÿsÿìÓ&Hj ´0&+55ÿÿÿÚc!&óCþQ³&+5ÿÿ©2!&óvÿ ³ &+5ÿÿÿ³U!&óKþ§³&+5ÿÿÿìÓ&ójþ· ´&+55qÿìb!&J@+!  '( FY  $FY?+?39/99+933310#"54327&''7&'774&# 326bþû÷ÞþéÜâd9ÍþñIé\^EœfîLϘ¥¨´œþ¯¯¢¯¡3þçþÒ âæyÖ¿›l…>1uIKŠkwþrþ蓪þ˜§·Éÿÿ°DÝ&QR³&+5ÿÿsÿìb!&RCÔ³&+5ÿÿsÿìb!&RvV³"&+5ÿÿsÿìb!&RK³'&+5ÿÿsÿìbÝ&RRñ³"&+5ÿÿsÿìbÓ&Rj ´.&+55hü)¨3@  PY/+3/33/39333105!4632#"&4632#"&hÁý®;64:;34=;64:;34=ŠŠþè<=?:9@?ô<=?:9@?sÿ¼b‡#K@)  $%! FY !FY?Æ+?Æ9+999339910#"''7&327&#"4'326bþòîšpTr^ îštTuaü½5ÑKr£¦—3þ/Gq£©%þôþÓEuNƒ˜ +LwL…˜ù«f†5ÖÔ¤dý}3Ûÿÿ¤ÿì9!&XCij&+5ÿÿ¤ÿì9!&Xvq³&+5ÿÿ¤ÿì9!&XK³#&+5ÿÿ¤ÿì9Ó&Xj! ´*&+55ÿÿþ!&\v³&+5°þu">@ $#   FY FY?+?+99??993333106632#"'##3%"3 4&XBªj×ðñÖÞz ¦¦H¨˜šª/”´YOþÔþõþôþÓ¡"M?þ5þ.4Z¸É)çÇ°×ÑÿÿþÓ&\jµ ´+&+55ÿÿ´&$M?R³&+5ÿÿ^ÿìÍb&DMõ³(&+5ÿÿ7&$N+R³&+5ÿÿ^ÿìÍå&DNä³%&+5ÿÿþB¼&$Q ÿÿ^þBZ&DQÿÿ}ÿìÏs&&vR³ &+5ÿÿsÿì‹!&FvD³ &+5ÿÿ}ÿìÏs&&K¬R³%&+5ÿÿsÿì‹!&FKÔ³%&+5ÿÿ}ÿìÏ1&&OR³ &+5ÿÿsÿì‹ß&FOP³ &+5ÿÿ}ÿìÏs&&LÁR³"&+5ÿÿsÿì¡!&FLó³"&+5ÿÿÉXs&'LXR³&+5ÿÿsÿì&G8 ²#?5ÿÿ/H¶’sÿìÓ'd@7%()GY/    "FY FY?+?+99?9/_^]3+3?933333310%##"323&55!5!533##%26554&#"š så×ïðÖßw þ@À¦œœ‡þžª™›ª’›š“§&,¢SI…¸¸û%w¹Î#éÇãÏÒÖÿÿÉø´&(MR³&+5ÿÿsÿìb&HM ³&+5ÿÿÉø7&(NR³ &+5ÿÿsÿìå&HNû³&+5ÿÿÉø&(Oo5³&+5ÿÿsÿìß&HOT³$&+5ÿÿÉþBø¶&(Qsÿÿsþa\&HQfÿÿÉøs&(LR³&+5ÿÿsÿì!&HLû³&&+5ÿÿ}ÿì=s&*KéR³*&+5ÿÿ'þ1!&JKʳP&+5ÿÿ}ÿì=7&*NR³&+5ÿÿ'þ1å&JNγB&+5ÿÿ}ÿì=1&*OdR³%&+5ÿÿ'þ1ß&JO³K&+5ÿÿ}þ;=Ë&*9'ÿÿ'þ1!&J:D³F&+5ÿÿÉs&+K–R³&+5ÿÿ°Dª&KK‰³%&+5ç¶T@,   IY JY ?3?399//33+33+9333333331053!533##!##55!ɪªÈȪüþªÉuüþ¾øøøøûÏ°ýP1þŠééDY@2   FY GY   /    ?3?9///]3+3+3933333310!4&#"##5353!!36632žz‚®ž¦œœ¦Áþ? 1µtÉÉž†„ºÕýçÛººÄT8O[¿Òý\ÿÿÿâÊ/&,RþÚR³&+5ÿÿÿxÝ&óRþˆ³ &+5ÿÿ*‚´&,MþýR³&+5ÿÿÿÚ2b&óMþ­³&+5ÿÿŠ7&,NþùR³ &+5ÿÿÿÌ8å&óNþ§³&+5ÿÿTþBV¶&,Qhÿÿ5þBß&LQÿÿTV1&,OPR³&+5°VH@ ??9310!#3V¦¦HÿÿTþ¶&,-¨ÿÿ¢þlß&LMÿÿÿ`þes&-Kþ·R³&+5ÿÿÿ‘þO!&7Kþ¡³&+5ÿÿÉþ;é¶&.9‰ÿÿ°þ;&N9+°F /@   ?3?399333103##3/Ïþb»Éþ—‡²² FþýœøqþyFþå¦qÿÿÉøs&/vÿcR³&+5ÿÿ£,¬&Ovÿ‹³ &+5ÿÿÉþ;ø¶&/91ÿÿYþ;W&O9þèÿÿÉø·&/8ÿ£² ?5ÿÿ° &O8+²?5ÿÿÉø¶&/Oýgÿÿ°¨&OOBý8ø¶ =@!     IY?+?99//99333103'73%!ÉiC¬ª)Cþ”…ü;reýF®yÓþ<šÿü' 7@      ??99//9339333107#'73V‰HѦnF´¦`^pý?THqw ÿÿÉ?s&1vR³&+5ÿÿ°D!&Qvy³&+5ÿÿÉþ;?¶&19Íÿÿ°þ;D\&Q9VÿÿÉ?s&1L¦R³&+5ÿÿ°D!&QL³ &+5ÿÿ˶'Q‡è²?5Éþ?¶8@  IY"?+??3999333310"'53265##33&53Éb6GSijüÀÀŸÁþ‘zoËþøžüÛ¶ûN•à=úXÃÌ°þD\8@ FYFY?+??9?+933310"'53254&#"#336632%V7<>Œz‚¬ ¦‡ 4´nËÇŒþ‡¬y†„ºÖýÁH–RX¿Òüšªÿÿ}ÿì¾´&2MÇR³&+5ÿÿsÿìbb&RM³&+5ÿÿ}ÿì¾7&2NÁR³&+5ÿÿsÿìbå&RN³&+5ÿÿ}ÿì¾s&2SR ´+&+55ÿÿsÿìb!&RSZ ´,&+55}ÿìçÍS@.  !IY IY  IY IYIY?+?+?+?+9/+933310!!# !2!!!!!"327&çýf\þ¹þŸ\@fZý³'ýÙMüDùþÿ÷pWW‰jh†—þ)–ýæþÏþÙþ×þÍ!uqÿìZ*1U@-%/%23+( (FY.FY .. ""FY?3+3?39/99++393399310 '#"326632!!26732654&#"%"!4&–þÛ}>щßþôëƒÍ>:À~Éîý'J^¡WX˜û!˜§£™›¥¦•G‘  „ëtw1 ,wrpyþ÷âiþw#'”' 9ÓÛÕÑÝÕØؤžž¤ÿÿÉÏs&5vyR³&+5ÿÿ°'!&Uvܳ&+5ÿÿÉþ;϶&59}ÿÿ`þ;'\&U9þïÿÿÉÏs&5LR³!&+5ÿÿ‚'!&ULÿv³&+5ÿÿjÿìs&6vPR³.&+5ÿÿjÿìs!&Vvê³.&+5ÿÿjÿìs&6KÿêR³3&+5ÿÿjÿìs!&VK—³3&+5ÿÿjþË&6z'ÿÿjþs\&VzÕÿÿjÿìs&6LÿäR³0&+5ÿÿjÿìs!&VL™³0&+5ÿÿþ;Z¶&79ÿÿþ;¨F&W9‚ÿÿZs&7LÿÜR³&+5ÿÿÿì×&W8b²?5Z¶?@!   JY IY?+3?9/3+3933310!5!!!!#!5áþ1Hþ16þʪþÇ/ð——þý^¢ÿì¨FL@)  GY GY @FY?+?Í9/3+3+39333310%27# 5#53#5773!!!!U< j*þÈF`>þÂ-þÓu\þPEêþÿôÝÿÿºÿì/&8RoR³&+5ÿÿ¤ÿì9Ý&XR÷³&+5ÿÿºÿì´&8M‘R³&+5ÿÿ¤ÿì9b&XM³&+5ÿÿºÿì7&8N‹R³&+5ÿÿ¤ÿì9å&XN³&+5ÿÿºÿì×&8PœR ´&+55ÿÿ¤ÿì9…&XP# ´&+55ÿÿºÿìs&8SáR ´%&+55ÿÿ¤ÿì9!&XSh ´(&+55ÿÿºþB¶&8Q!ÿÿ¤þBeH&XQôÿÿLs&:KTR³(&+5ÿÿ#!&ZKÁ³+&+5ÿÿ{s&<KÿàR³&+5ÿÿþ!&\K­³$&+5ÿÿ{%&<jÿñR ´&+55ÿÿR?s&=vBR³&+5ÿÿRm!&]vè³&+5ÿÿR?1&=ODR³&+5ÿÿRmß&]Oß³&+5ÿÿR?s&=LÿíR³&+5ÿÿRm!&]L†³&+5°Û @  FY??+39310!#!2&#"V¦g`d+WIaYœƒ%…{zÃþË D@$  !" FY FYFY?+?+9/3+3933310"'53265#5754632&#"!!HE@F=_MÞÞ¢¶Uxfy‰çÙ¶! @   € /3Í29106673#%6673#ç$nº%«:ae1eº%«:`ò0ºE?Ä0D±:?Ä0üÙs ¶ € /Í99106673#ü5 ¸m1döHãRJíLƒ´ +@  !"   /3Ì99//393310673#'4632#"&%4632#"&A½!y3På4&)17#&4´4&)17#&4…©†C³=4.4.21124.4.211ÿÿ &$Tþ ÿ—²?5ÿÿ˜L‰ZyÿÿÿÔu &(}TýØÿ—²?5ÿÿÿÔµ '+–TýØÿ—²?5ÿÿÿäD ',îTýèÿ—²?5ÿÿÿäÿì &2DTýèÿ—²?5ÿÿÿÔ… '< TýØÿ—² ?5ÿÿÿä3 &v?Týèÿ—²#?5ÿÿÿéÿì“´&†UþÎ µ.&+555ÿÿ¼$ÿÿɾ¶%Éø¶@IY??+99310!#øý{ª¶™úã¶ÿÿ'm¶(ÿÿÉø¶(ÿÿR?¶=ÿÿɶ+}ÿì¾Í?@   IY IY IY?+?+9/+99339910!!%! ! 32#"ãuý‹ÛþþÄþ½þ¡`D;bûsúôóø÷òõû3•?þ¡þn‹he‰þpþ þØþÌ0,*.þÎÿÿTV¶,ÿÿÉé¶.Ó¶ @   ?3?99910!#&'#3Ó¶þ¶W!Gþ¸¶± üZ‹Éü^¶ÿÿÉq¶0ÿÿÉ?¶1H%¶ 4@  IY  IY IY?+?+9/+910!!!!!5ÃçýR‹üu´ü#H–—ûy˜˜ÿÿ}ÿì¾Í2É ¶#@ IY?3?+993310!#!#! ªýªCúá¶ÿÿÉh¶3J\¶ 5@   IY IY?+?+3933310355!!'!Jáþ+Ëý\`ÌþTo+™ýßýš˜ÿÿZ¶7ÿÿ{¶<jÿìøË"+P@)' +,- **JY"$$JY??99//3+3+339333333310332###5#"$54663332654&+"33Û¬F«û…•þý°)¬-°þþ’‡ü«C¬Éßι:¬9¶ÑÞÊË´ˆøŸ¦þý‚áá„¡žø‹üEÛùÒÔ·ÅÙÿÿ–¶;mò¶>@  IY ??339/3+393333310!##"&&5333332653##ƒª-°ÿ®ÏÔªÓÏ°þý¯-¾z÷¤ãþ!¼ÉdüœÆ»ãþ¥÷{PôÍ9@    !IY  IY?3+333?+93310"!5!&5! !!5654!îú­´ý¶l— b:;bž—ký¶·©ù5þÿýáþ³„…˜v^Ë6`þ¥þÇÏþ¦x˜…†NÞüÿÿ<o%&,jÿR ´!&+55ÿÿ{%&<jÿïR ´&+55ÿÿsÿìÇs&~T³4&+5ÿÿZÿì‡s&‚Tȳ/&+5ÿÿ°þDs&„T;³&+5ÿÿ¨ÿì“s&†Tþij&+5ÿÿ¤ÿìq´&’U; µ4&+555sÿìÇ\ *G@$ '"+,'(( FY FY$ ?3+3?+993?9333310%26554&# "323673327#"&'#P©–˜©þÑ“…Öîôáy¡6 )T!.AQY ;§wÃÚåÇþPÔÔ‹) )TT\8BötþIr wQVVQ°þ¨)L@('"*+#"FY## FY FY?+?+99//+?93333102#"&'#46"32654&##532654&“ÜùþÇyþøîm O¦ýäž]¡V«­¾±p\›¢œзþÚ3*þ‘Ñá&ýã4áöŒ¬¥ü‰1%–¤Ž“‰{… þH!@ ??39/3910#4733>3´@+þ?¬ð^)+ê¬þk05þ`&r<ý¸ëgŽmûÓ|þÜqÿì`*;@ % +,"(FY FY?+?+9933310&&54632&&#"#"$544&'326!Œt¤g½~HpŸQUak§Ò±þðìãþðâa{ﲓ¢®¨NŸc‚˜-?‡>,OBGo[sñ¤ëþøøÒ±þs€·J5Ù «ºZÿì‡\%M@+# &'%%FY%% %% !FY FY ?+?+9/_^]+993310# 3267#"&54675&&54632&&#"!Ë”þÉ“’T¦d‰ÝÒñn‚bkàÀa¥d?^‚Oú=ÃZb'/”K©”bƒ) \…ž!-…*¢¬sþo  0@!"#FY?+33?9333105!#654&'&&54>7!°ð×þàŠ;}¬•ˆ¦}o˼;pÉò(þñ‡´þ½þߦbvI%m[•¤¡k8=$ÛÂrÐÃåÚ°þD\/@   FY  ???9?+99333104&#"#336632žz‚¬ ¦‡3¸qÆÈþ±†„ºÖýÁH–QY¿ÒûIsÿìJ+ I@'FY¿  FY  FY?+?+9/_^]+99333310#"322!"!Jôúðùõôôúþ¤œýy–§¡– … ˜ þjþv“—ˆþkûá13þÐþÌ)þáþç¨ÿì“H@ FY ?+?993103267#"&5NIW%ei2 ‘Hüúhe  ¨© ÿÿ°FúÿòÿìF!"3@$#FY FY ??+93?+3910#'.#"5632327#"&'&'#Ù:2C1:9D?[yX6k*#!0=JSœT Xþ7¢UF$ …<‚˜ü 13 yLS´ð`tÑý¶ÿÿ°þDHwH@  ?2?9993103363#¬ÛS±Ÿ¦ÏáºHý²Cî>¯½Qþ•þáqþo 1I@'- (%2300GY00&)%&%FY&#??+39/+99333310#"#6654&'&&54675&5467##5!#"33V²°Õ2_‡TŽ‡6Cœ5BsÈÇž€Ù‹¦€sDº3‚৯ªò²ŽPb=$nZA•cG“47="È°ŒÒ' @Ùuž2 ƒP_slÿÿsÿìb\RÿìôH6@    FY FY?+??+3393310%27#"5!##57!#}&0+TÛþ#¦ÝLÕ3uƒýÑüFºJDŽýŽ§þ÷ÂÑŶºÐÿç“H,@ FY FY ?+?+39310!3267#"&5!57“þPÍ/b#o0µªþ×”HŽý–ß }ªªJD¤ÿìqH%@  FY?+?3993310"&332654&'3sç覞™§¡"¦$þþú Xý°ÀÃîû‚àˆÖŒþÂþÔsþL\"A@#   #$FY  FY??3+3??+93333310$746324&#"66ƒþüþôσYQh¦•´Úˆø¥y|fIN³ÆþÚ #(ýZuà|þu#l»¾þÛú²þûþ&'¹Ûxrý’ìÿìþPN 9@!"! FYFY?+??+?9391023327#"&'#&&#"56²6N>,‘>´þT¾0R?--<;s;–þ–²Ь&F+%1N+[pþaüüþzJvŸƒýhD¼cP ¤þ‡=@ FY ??3+3?3?933333106654&'3#$3Z¼Ë%¦?þãþð¤þøþö¦´¸úiçÌxë¨þðôþìþÎþ&Ú "ýÛÃÚ ™sÿì¼H'=@ & ()& FY#?2+3?39/99339310"54733265332654'3#"'#ô¶Ë7D¬D9xk^i¡j]kx7E¬A9˶ÜD A(þœ™œÿÁØ}7þÉ€ŒØÁ—’þùüþÖ¶¶ÿÿ ÿì“Ó&†jþÔ ´%&+55ÿÿ¤ÿìqÓ&’j9 ´+&+55ÿÿsÿìbs&RT!³"&+5ÿÿ¤ÿìqs&’T'³&+5ÿÿsÿì¼s&–Tɳ1&+5ÿÿÉø%&(j'R ´!&+55ÿìB¶F@& IYIYIY?+??+39/+933310"'5326554&#!#!5!!!2Ï`67[ehƒŒþƒªþ°·þCŒÍÝÄ–|pƒ€qý——þ^¿²¾ÓÿÿÉøs&avZR³&+5}ÿìãÍ8@ IYIY IY?+?+9/+93310"!!327# !2&BâþóÓý)  ù¢É¡âþ´þ¢yNí²G©3úñ–þîþã7•9„m_‘X”RÿÿjÿìË6ÿÿTV¶,ÿÿ<o%&,jÿR ´!&+55ÿÿÿ`þh¶-ÿé#¶#G@& $%#IY IY JY JY?+?+?+9/+933310!!!#"'532>!3 32654&###þíþüþ¹þ“9TP‹kE@2?0A+7DA¦z:ýL…Æ·ÀÜfªÎÜþHýöûy>gú¾âýýM‹ŒŠ|ÉT¶J@&   IY  JY?+??39/3+3933333310!!!#3!33 32654&##Tþðþûþ·ý}ªªƒ¬y9ýN…ĹÁÛfªÎÜ°ýP¶ý’nýýM‹Œ‰}B¶:@  IY IY  ?3?9/++3933310!2#4&#!#!5!! ÍÙª}Œþ}ªþ°öþ}¼µýôö~qý——ÿÿÉås&´v¢R³&+5ÿÿÿìø^&½6DR³&+5Éþƒ ¶ 0@  IY"??3+?3933310!!#!3!3 þ/°þ>ªïªþƒ}¶úäÿÿ¼$É}¶ =@   IY IYJY?+?+9/+933310!!!!3232654&##}þýþûþT^ýLãÁòtüöï¾­°ÛϪÚж—þ'Y®þT‚•Žxÿÿɾ¶%ÿÿÉø¶aþƒJ¶ C@$    IY " IY?+33?3?+93333310#!#3!3!!J¢ü¢qšÛ ‘¹þþ³Ήþƒ}þƒæ3úäƒòýYêÿÿÉø¶(¼¶<@    ?33?33933333933310333###VýÁ¾9¤:¾ýÀRÄýº¤ý»ÇðÆý<Äý<Äý<ýåýåýJÿì5Ë(C@$# )*JY &&JY& JY ?+?+9/+993310!"'532654&##532654&#"'6632·¡·½þÎþéÿ£`ßgÆËáßÚÑÍᢉn²uTeû‡áÿ`´´‘ÍåOž.2–†Š“„k€2JrKMÅËR¶4@   ?2?3993399333310333#47##ËŸ4º  ü˺¶üÓá¶ÄúJ%ÉÝû5ÿÿËR^&²6áR³&+5Éå¶ -@  ?3?399393310!##33åÎý\ªª“Ãýyåý¶ý<Äý:ÿçÙ¶-@ IY JY??+?+93310!#!'"'53266!Ùªþ%=]˜~J;6;5O=]8ðþ!þE®W×Y¸ÿÿÉq¶0ÿÿɶ+ÿÿ}ÿì¾Í2ÿÿÉ ¶nÿÿÉh¶3ÿÿ}ÿìÏË&ÿÿZ¶7ÿìø¶*@    IY?+?3993910"'5326733673%oT]`n…BýǼ° g´þ-T‡©¦+e‹AüÁ1/T5û껪OÿÿjÿìøËsÿÿ–¶;Éþƒ¸¶ 2@  IY"??+3?3933310%3#!3!3 ¬¡û²ª漢ýé}¶úäªÇ¶-@ IY ??39/+9933310!##"&5332673Ǫ•ÆjÏߪa±©ª\5'¾³EýÏyt7ÊÉy¶ 1@  IY?+3?33933310!!3!3!3yùPªXªX¬¶úäúäÉþƒ¶;@  "  IY?+33?33?933331033!3!33#ɪG¬Hª¬¢¶úäúäúäýé}¶ =@  IY IY JY?+?+9/+933310#!!5!3 32654&##þýùþGþ°úôüõüµ©¯ËàªÎÜ—ýÍþ‹Œˆ~É ¶ ?@  IY JY?+?39/+?9333310333 #%32654&###3ɪïþýùþö÷µª³ÈÛ—ªª¶ýÍÏÎÜ‘Œ‰{ýR¶Éº¶ 2@ IY JY?+?9/+9933310#!3! ! 4&#!ºþñûþª# ü¹+l»ÎþòªË߶ýÓþ ‡=ÿì‰Ë:@ IY  IY IY?+?+9/+93310"'632!"'53 !5!&Ó¬¢H¬ìÙ9¢þ”þªãœS¬cý1Íþñ3LT°þºÝþˆþl9•"!˜åÉÿìçÍG@&     IY IY  IY?+??9/+?+93333310! !#3!! 32#"çþ«þÐþÓþ« þžªªdQ3Vû îçêíëèéðÝþžþqoUýP¶ý’7Nþoþ¡þØþÌ2**.þÏ3N¶ =@   JY  JY  ?3?+9/9+933310#&&54$!!##"!3{þÉš¡’’ªã·¾{Ýbýž3ÏžÄÓúJbÁ~ŽþÝÿÿ^ÿìÍZDwÿìT!";@ $# FY FY??+9/9+39333107$736632#" !"wÔæÚþ¥•‘‘ >ÄkÊâþúêçþúü1þëLu ¦‘h“2=&’:"!öÔT`þúèþÿþßb×…s?h7þùþí°LHI@&   !FY FY  FY ?+?+9/+99333310#!! 4&#!! 4&#!!26){oŒáØþᘃ‡œþÓ1{}þÇš~5ko ~o™¦HýYQþ—šPCþËL°DH@FY??+99310!#!Dþ¦”ºüFH)þ…hH C@$    GY " FY?+33?3?+93333310#!#36!3!#h¡ý V†˜+þÃö ‘lþ…{þ… ¶êüG6Þþ9‘ÿÿsÿì\HßF<@        ?33?3393333393331033###3¤™Ŷþ6ñÀþ™þ¿ðþ7¶ÃFýíýíýÍ+ýÕ+ýÕ3ýíDÿì\"M@+  !#$"!"!FY"" "" FY FY ?+?+9/_^]+993310 54#"'632#"'532654!#57üM~f;ªÉ½ÚÍ~tõØí·»“þɘ¬¢*‡L›†¸9%‰g˜©G˜Vc]¿°bH 4@      ????999933333103#77#LQÏ›ý°ÏHýI¶9¦û¸ž„‚ü\Hÿÿ°b &Ò6=³&+5° H -@    ?3?3993933103##3/¶þ'Âþ ¦¦HýïýÉ+ýÕHýëÿòáH-@ FY GY??+?+93310!#!#"'532!á¨þ·`™v6 sˆ#ºþœþ^ {æï°/F5@  ??3?399399333310%773##&'#3é+)Ó“:þå‹þå5”Ë+ ]vÓûº‰:™ýJ¸†KüwFýIn°bH 9@  FY/?   ?3?39/]+99333310!3#!#Vf¦¦ýš¦Hþ5Ëû¸îþHÿÿsÿìb\R°HH#@ FY?3?+993310!#!#!V¦˜¨ý¶Hû¸¸ÿÿ°þu\Sÿÿsÿì‹\F)“H$@ FY??+39310!#!5!“þœ¦þ jºüFºŽÿÿþH\qþFL@'     FY FY??3+3?3+3?9333333310#&5473%66Fþåþ¤øþàÿžûûÙ°À¹·{þ“¾¯%ùþÙþ$Ü.ôù&¼þDþÔðÀÚTÏÈ'ü®Úÿÿ'H[°þ…ÝH 2@    FY"??+3?3933310#!3!33ݦüy¦F¦›þ…{HüG¹üGœ-H-@  FY  ??39/+993331032673##"&5BÛ[¦i¦¦i³q¤ºHþpÀ8CÕû¸ðH;¬“œ°oH 1@   FY?+3?33933310%!3!3!3áæ¨úA¦å¦¹û¸HüG¹°þ‡ F;@    FY "??+33?339333310%!33#!3!3á榨úN¦å¦·üIýøyFüI·)H =@   FY FY FY?+?+9/+933310!2#!!5!4&#!! -9à×ßÜþ%þ¢L|þÍ9ƒš›¦¨ºŽüü]Sþ—°yH ?@   FY FY?+?39/+?9333310!2#!3#3! 54&#V+ÑÉÕÏþ9¦#¦¦ûÝz“ƒ›š¥©Hû¸Hý¬þ—¹\T°LH 2@  FY FY?+?9/+9933310! #!3!2654&#VR¤ÛÓþ¦@„Œ”ƒþË¢¬Hý¬þ—\][U9ÿì}\D@&   FY    FYFY?+?+9/_^]+93310"'53267!5!&&#"'663 V§v<Œ[®½ ýÕ)©¡g—/7¤P þß9“$º¹¬ 6Œ#þÛþìþóþÖ°ÿì3\Q@-     FY FY     FY?+??9/_^]+?+93333310#"'!#3!663232654&#"3þÿàÕúþᦦ!üÏÜüî’¡ž•’¡¡’%þóþÔ ÷þHþ5äûþÏþúÓÛÕÙÒØØ%ÁH =@    FY FY ?3?+9/9+9333103#&&5463!#!!!!"çÂ;‡Êµè¦þëþö þÓòÏ¡z–¬û¸¶N¾rÿÿsÿìÓ&Hj ´0&+55þD'f@:%%()! FYGY/ !!FY?+??9///_^]3+3+3933333310"'53254&#"##5353!!36632/O4:7z‚­¨œœ¦‘þo 1µtÉɉþ‰ªR†„¼ÓýçÛººÄT8O[¿Òü¶œªÿÿ°D!&Ívñ³&+5sÿìª\D@& FY  FYFY?+?+9/_^]+93310"32&#"!!327yøþòûRž91m¤ª)ýÕ ª§Œ—t#* 3£©¾µ;“9ÿÿjÿìs\Vÿÿ¢fßLÿÿÿìÓ&ójþ· ´&+55ÿÿÿ‘þfßMÿòBHL@) FY  FY GY FY?+?+?+9/+933331032!!!#"'532!4&##3 °ôÓËþKþeþþ(µ«8 sˆ#Pì}žç탛šþ²ºýúþ> {æïüü[Uþ—°¤FJ@&    FY  FY?+??39/3+3933333310!2!!!#3!3 54&#ÙËþNþ`þ ¬¬ú¦ð€™Fþ;™šþ²îþFþ7Éý®þ—¹\TÿÿDéÿÿ° !&Ôv3³&+5ÿÿþ &\6·³&+5°þ‡FF 2@   " FY?+3?3?933310!!3!3!#/þ¦J¦þ¦FüI·ûºþ‡Éã#@ IY??Æ+9933103!#f¢ýkª¶-þ:ú㶰D‰'@ GY??+Æ993310!#!3Dþ¦î¦Çü9HAÿÿLs&:CR³&+5ÿÿ#!&ZCs³&+5ÿÿLs&:v°R³#&+5ÿÿ#!&Zv³&&+5ÿÿL%&:jdR ´/&+55ÿÿ#Ó&ZjÏ ´2&+55ÿÿ{s&<Cÿ”R³ &+5ÿÿþ!&\Cÿa³&+5RÙ®qµ/399105!R\Ù˜˜RÙ®qµ/399105!R\Ù˜˜ÿÿRÙ®qÿüþ1NÿÓ@  /3/3333210!5!5!5!Nü®Rü®Rþ1‹Œ‹ÁD¶¶ ?Í9910'673% b8{B%ÁZ yþ÷ÁD¶¶ ?Æ9910#75b5zF ¶dþ÷rØÿÿ?þømîÁF¶¶ ?Í9910#&'7ß%B{-m¶ûú^eÁ´¶@   ?3Í2910'63!'673–8z{; ý× b8{B%Á×sþßaZ yþ÷Á´¶@  ?3Æ2910#7!#675b5zF '`8}B ¶dþ÷rØ[þözd4]ÿÿþù´î û8 ·@ H¸ÿÀ³ H¸ÿÀ³ H+++55{‰ C@!     ?.333?9/333933333310%#53%‰þ 1Ä1þ´L1Ä1`çûúª¡þ_{šu@:          ??99//9922333333333393333333333333310%%#553%%9aþŸ1Æ1þ¦Z++þ¦Z1Æ1aþŸ+ç¨þ…{¨+¨|þ„¨þå¤ô^ã ¶ /Í93104632#"&¤qlitsjkrìy~|{wƒÿÿ˜ÿã®ò&'%dÿì ;Ë $/;F[@0 0B6<+%%+<B GH33(? "99-D D D?3??99//3333?33393333331032#"#"&5!2%#32654&#"#"&5!232654&#"#"&5!2ìS]´´]Sí¡œ•£8˜¥iüÕ”+ S][YY[]Sí¢›”£7–§û8Q][YY[]Q뢛•£8–§ªªTR¨ªæçîßÉðÛúJ¶ü«©§­«¥¥«ææïÝÉìÝ«©§­«¥¥«ææîÞÉìÿÿ…¦?¶ ÿÿ…¦°¶Ru¾@ //993310RVwþß!wþª'—Eþ¢þ¡G—Pu¾@ //993310'7þ¨uþáuX þiG_^Eþiÿÿ˜ÿãJ¶&Áþy¶·??3310#üy‡¶úJ¶m!ÃÇ&@    ?Í2?399333104&#"#3363 LNPr[t` K‘!¤TGizþ¤™XeúþTb#¶K@(  NYLY LY ??+99//+3+39333310!!##53!!!!¸4þ̦°°ý•Dý¼‹þö +—ýé—DHÉ%p@@ "  &'NY  ! NY !!!?!O! !!LYKY?+?+99//_^]3+33+39333333102&#"!!!!!!5655#535#53546°Éž<˜“z~¤þ\¤þ\AJûüÎÈÈÈÈàÉPƒG‡º¦!dˆ,š0ó#¦Ï²ÍšÿìѶ!*`@7"&   +,"KYNY  *KYMY?+??+9/////++933333310%267#"&5#57733#!##! 32654&##N"V bÝÝ4þ‘þëþö@¥þý¡4ȹ¬·Ru}ˆŠÏPE¿ÓþGMR—ãêýÁ¶Óýî‘¢‘Ž?ÿì‰Ë&q@? $ '( NYNY/ ""LY"LY?+?+99//_^]3+33+3933333310 !!!!327#"#53'57#5332&þÁOþýôÏþA%˪œ™’«íþß.¦˜˜¤'$íÉ¥G¦5þm9@-´ÅB–A *,P$a‹Vÿø Á+E@$% *  *,-# '  ??99//33?3?39333310##"&546323254#"%"&54632&#"327üÕ”+©”‹ª§”ªþ²°°²ýʦ¶¼«hX!QPàÜbZN¶úJ¶û˜Ÿ·¹ž¸ºœîîëÛ±¡¨³#gîë!e%wÿìœË$=@#  %&#     /3/399//99333310%273#"&5556746324#"$}®_™Ž– ``Nr–‡u‡Î¯R®C>oÕ¦²µ©ó#q&òŠŸ¡Š¹þÐJþåh{+ÂVlþK‰Éö'+_@1  "+(,-% ((()JY(?3?3?+99//9933933333310!###33&53#"&5463232654&#"5!Ç»ýL—ª˜ü¡“‹¢¡“‹¢þ"Q][OO[\RVËþàlüÁ¶û:õŠGü·£¸» £µ»rvussppý ‡‡%å…¶O@'    ?Ä229/33333333393333310##5!###33#7#q{ÑÓXÉw»ÄË´Óågjjý™/þRÑýÑ/ý/¤‰ýÓÿÿPôÍvfÿÝ‹H4@  ! /?/2/39/]93933310"&546632!3267&&#"yñ…Šô•˜ó‡üÅ1¦Rƒ·QHbÙ“2£X­z#“«ÿŒŽþý¥þœ5Fi)›|‹5BuþéÿÿGÿìó¶'\&{û@`ý³ ´?555ÿÿ ÿìÉ'¢'@uý³uÿ ´?555ÿÿGÿì¶'œ&= @qý³ ´,?555ÿÿjÿì¶'F'@mý³?1 ´?555fÿì5Ç(A@"&)* "GY FYFY?+?+9/9+933310#"&546327!"56632267&&#"5§þì­¬»ˆè—a’+þæ>0/›JÒØý¢_¦x€Pe¥ee¦þúþ5éÉÀ©3¡]KZ•,!Ÿ%þìûÆ–al„ú€v‚'m¶ (@    IY??+999331073!!&'ϦÑûº!=(þüÑþþDhNú°fôáyüþùÊÉþ!¶#@ IY?3?+993310!#!wüüªXþ øó¦øZLþݶ 1@   IY IY?+?+933331055!!!Lwý™@ü°Cý¤ªþkœ3l—üüü˜h)@ PY/+99105!hÁŠŠ%ÿò¼˜@   //9/933310##5!3oþé´!뉇ýT½w“- !-3@ +% ./" ( /333/3993393310#"&'#"&54632632267&&#""32654&-§€]™A<™Xƒ¨¨ƒµz|¹…¢ü}Bm62mHLda¡Bm73nGLdeσ¹jthq­Ž†³Ûׯþ»[da]iWSjy\ba^kTUi þø@   /2/393102&#"#"'5325}O,1>°¥£J;=:¶‰óúá°»‡ójb‡-/p@@(10'PY/ *@*$PY*@PY/ @ PY /]Ä+Í_^]+ÄÞÄ+Í_^]+Ä993310"56323267#"&'&&"56323267#"&'&&P69l”CpXM[-5€6e™CoXI[19€5j–EtRE_173dšEvOTU@9–n%!B9—m%–D5•m "B7–n !"h¦)F@&  PY  PY/3Ä+3/_^]Æ3+393310!5!!5!!!!!'}þëTþ-‡}mþª×ýéƒ}Á‰‰9æ‰þð‰þå7ÿÿh)Ù&+ýt ³?55ÿÿh)Ù&!+ýt ³?55o=à @  //999933103# oÂHÄþh{Œ›ƒ"&SYNX) hæ )9¢Ç#6@! %$ !?3?39/]93933310632&#"36632#"&2654&#")ÛÛJ14S– qU}”¦™­DQcXVUpjÃÿr™¦+;”~¤Òc]cO[Z;Y|9J¶@  ??39310!5!¢^þ9Vþ Jøt^üò39“Ç"-?@" &+ ./ )))) !#?2?39/]39993333102#"&5467&&54632654&''"654&d|—”°¥Š’ŸIUJ95TVZT]QHF¬DKDQŒNÇvh‚LJžq‰€tEt..]Df~ýfarTþÁî #'+/37;?CGS[kt|‰ø@‡A@=<10 TNXHvkp`zg…†ED)(%$ †;g`87/k4,H# N Š‹ *BZQ†\t\)AF>duulE=‚}VKkvk&2%1 BA>\=l 12k \lkkl\-, 9854! /333333333/3333333339///9999993333Ä2Ä2339333ÄÄ233933333333333333333333333310!#%5!#533!5353!5!!5!5!#3#35!#35!35!#35#3#3#"&546323254#"%32##32654&##32654#"'53253T/ÀÎ0mùoÀÃmýIûáþò·mmmmûÂü0ooÀwú¨ooooþmmûŸ‡‡‡~ˆþs‡‡‡‡á¬mp.,=.m^Ï{B.$*/;J1%Z^4+V}i¾0oÁÁoþÐÁù/ÂmmÂþÑmmmmþooú¨ú;mm¦Jooooü/yýhI‘œœ‘’›š“ÅÅÄaCS1BD5QYb" "ãš+%Jþú fV’þr_cTþÁª*.@ % +,(""//9///33910 54676654&#"63232654&#"þ¬üTüVë,AgI»¥OºGR Z?>1HT;GFBIHCHEüVüW©û/2A1R~X‡š8*²P:/5K6DpJ;þí?HI>@IHÿÿÿ‘þW!&7Lþ©³&+5ÿÿÁD¶ ÿìß+-6f@9 4%.+-% 78GY!.!GY+... ..((1FY(FY?+?+99//_^]3+3+933333310! 47654&#"'6323 4'&$&546323%&#"Vþàþýþw$ 6!S_X]éwßþÉ ¶¨Ð*þÇ·{]aN.AþŸþnX9{z/# v']]#ƒ„:Ïp?,i¼ƒ£þÍþ×Ó_Kš{Ã(@ JY?+??993106632&#"#39zM\:0((;V|e¬þ#ºÍ#7l0‡8¡üìUýã/‡ÿìwH)L@'!!' *+ FY$FY?2+3?+339/99339310"&54!57!##"'#32655332654')ºÇ‡þãŽ×úuȹÝDDþÏ?Blu]l¢k]umoçððJDŽüûð綶΄þþg®¨}¼¼z’©­þïÿÿÉqu&0vœT³&+5ÿÿ°Ë!&Pvͳ-&+5ÿÿýÕ¼&$[5ÿÿ^ýÕÍZ&D[ÇÿÿþßÿìÒÍ&2\þG ³?55uýÕ5ÿƒ @   /3Ì2993310#"&546324&#"3265}fexxee~nB33B<95@þ®axubbuva9<<98==˜hÏÅ@    /ÄÜÆ9310673#%47#"&°F½)w1Nþèíy%]7C‡µzN¬9v£=H)5JDÿÿÓ'I°&ILmÿÿÃ'I°&IOm}ÿìd!<@ "#  IY IY?+?Æ+999333310! ! >5332#"¼þþÆþ½þ¡aCE³2:¶ƒh`ûuúôóöõòóýÝþžþq‰jh†× Cfi›­'°þþþÖþÎ1+'1þÑsÿìð"<@ #$  FY FY?+?Æ+999333310#"&532>5332654&#"bþòî“ä| îÙ‰3:´yfGü½ž­¯Ÿ¯­œ%þôþÓŠ­ +Acnœ¯&Š¹ÓÛÛÓÒØغÿì{3@   IY?+?Æ39999333310>53! 533265:Fµ!¬•þáþøþôþÔªÌƸÁ¶Æ>pn¶¸ýþþþêý®üF·ÄÁ¼¸¤ÿì–òD@"    FY??+?3Æ939933333310326536653#'##"&5Lz‚¬Ÿ¦RJ² °‰ 4µoËÈFý;†„¼Õ>y €šº¿ü¬“RU¾ÑËÿÿüSÙýÜ!CúÊÿÿý Ùþ–!vû„ÿÿüÙÿÝRûý¸þs@   /Ì23339310#'6654&#"563 þs¦ i VNCI> &E׌"q°2++)d ý;þ þÿ} µ /Í33104632#"&ý;;*(::(*;ò9669777ÿÿÉøs&(CÿØR³ &+5ÿÿËRs&²ChR³&+5ÿÿsÿì!&HC·³&+5ÿÿ°b!&ÒCܳ&+5…ÿì‘É1E@$"*'/ '23IY((,%%IY ?3+3?39/9+3933310"'632#"&'## 32&&#"327332¤<^-E~–äþåÿl¬SP©kÿþåÿä™|F-]<“¥Ï»‹fªfŽ»Î¥/)’Pþˆþ­þþa-32.›wSxP’)þ×þöþÓþ²LÉþ7LK0 (H(@   ??339?910#33663363#&' ³Õþ¬ö .JŽ¬² - ­™¦ÃÛ¶}!É3þ„HýI]½5£$Õüÿ,¸³Rþ–þåZ\üL@( IYIYJY?+?99//+3+393333310!3!!3 !!!32654&##?¬¢þ^É1þ÷þûþhþÁëÕÀµºÚ¶úþæ”þàþdÐÚfü+‰Šzœ'G@&    FYFY  FY ?+?3Æ9/++393333310!!! #!#5353! 54&#¨Xþ¨?µßÜþ!ëë¦1‡œHŒþÅþͦ¨¼ŒßüÍþ—¹\TÉÿì!Ë J@) !"IYIY IY?+??9/3+3?+933310"!!327# !#3!%2&&ãþü¿ý= ÷šÂ˜ÞþÁþ¥þ¢ªªdq0Õ¶Hd3úñ–þïþâ7•9pTýP¶ý’3N\’0&°ÿìœ\!Y@2   "# FY  FY    FY?+??9/_^]3+3?+93333310"'!#3!6$32&#"!!3267wëþô þᦦ! ßQš62Še£§ýæ ©¤=wbn øþHþ3ëö 3¤ª¼µ%“9m¶ 4@   IY  ?33?9/9+39310####3#!'&'˜”œ•þß²hžg·ý\LR8@ªýVªýV¶úJ?Ïdb¤ yH 5@   FY  ?33?9/9+39310#####!&&'#¨ѬÏq—sͬÑ!+8" Hû¸éþéþHþ-lŠj\É^¶F@%    IY    ?333?39/93+33933310####!#3!3#!&'…š“þãº"þ_ªªážf¼ýf>v #°ýP°ýP°ýP¶ý’núJH5V/Ch°HM@+    FY/? ?333??9/]93+33933310#####!#3!#!FΪÐq˜nѬÑþߦ¦^Åh Y Hû¸îþîþîþHþ3Ís"_Ù®¶"K@( !$#!!IYJY"?33?9/33+3+99933310#.####"#>75!)þZvšd2…®‰#DeYª[cA ‡¹ˆ/c•vþe¾ý {¶…þH‹¤þ;Éo`&ýB¾'_oþ7ÅŸŽIï…™þ9 H #N@*!"%$" "FYGY# ?33?9/33+33+99933310#.####"#>75!‹þ®WoI1›¬…":TL ™ KR8'‡ªƒ0InWþ± ý´%Hiþ 0PiþqPWGýö @^þ®P=iO2`iŒþÁÉŶ$'a@5!&#'%'"# )(#$&$&IY!IY'!!$?333??9/33+33+99933333310#.####"#67!#3!5!=þ]x™e-ˆ¨ŠFi_¬^dB!‡²‡78þRªª×þhÁý {¶…þHœþ;Éhc(ýD¼(_lþ7¾¸:ýP¶ý’é…™þ7°ºH$'g@:!&#'%'"# )(#$&$&FY!FY'/!?!!!$?333??9/]33+33+99933333310#.####"#67!#3!5!1þ®XoI0›¬…":VJ š KT7&‡ªƒ/%þͦ¦5þ°!ý´%Hiþž1NiþrPVFýø?\þ®Px(þHþ5biŒþÇ?þN5ÑK„@M!?FF ?7C<*-( LMIJYI941../. .*@CJY<**$JY* IY IY# IY "?+?+Æ+?+39/+9Ý_^]9Ä2?+933310327632&#"#"&5467665!#532654&#"'67&''536632&#"ðWYaxxF›GP Diii³¸Ùè̵þ@ÚÑÍᢉj»nV¨¾9u1{\ƒ\ƒ@20+,o0²Á¿ªºËþåþ抆‰72'¦3}…~ Š “„k€7ErrBy4;ˆsVq RG½Œ¸²ÐÕ 7þ{NFƒ@N)6 . >2@<) GHD>AGYAA/A A>&FY#FY3232FY!#& >>8FY> ",GY?+??3+9///+9++Ô_^]Ä+99333102&#"32772&&##"&5467$54&##53 54#"'67&'5366ø3-)/g-zŒÓøòá]m0KYVz¯}'T7³‚\Ÿ¾´NœŸ”w7üJX;|~\g{KŒX†Np O>Šk¸9GÊ”¨*,1+'wpt}¾aZ¬¢"$‡7ub4‰nUÿÿmò¶uÿÿ¤þ‡•}ÿì¾Í G@%IY  IY  IY?+?+9/_^]+99333310! ! 2!"!&¾þþÄþ½þ¡`D;býaå÷ ü+ ùèàûÓôÝþ¡þn‹he‰þpüD þõþî´þþÿþsÿìb\ I@'FY  FY  FY?+?+9/_^]+99333310#"&532267!"!&&bþòî“ä| îæþž¤ ýi   œž “¡%þôþÓŠ­ +þÎýM¸¿º½X­§¨¬Hà @JY ??9?+3910"#367>32&á;N9þ¸Åýî´RH# F¢;TnY*O87gµûå¶üVÇß¿˜A=R@ GY ??9?+3910!336>32&#"–þj®ádR`%G[T-&/:øHý›þôdv 5z{4 T\üßÿÿHs&€v×R ´!&+55ÿÿ=!&vd ´"&+55}þ ¢Í .D@& !.'/0%*JY%  IY IY?+?+?393?+93310! ! 32#"%33663#"'532677Tþ¹þÜþ×þ½C,#EûÝßÙÚÝÜØÚáo°öN Sä°þ+E¼ˆLJ7B^u#=Ýþ þo‹hfˆþpþ þ×þÍ1+)/þÒAý‹Ïf,ûƒû ¶ž… gYœÿÿsþ{\&R\u}ÿ‡-(Q@* & "" )*$"& &IY IY?33+33?33+339333333310#"'$%6326632654'#"'þÑþøw|þôþÑ+|y -û!ʽI6n½Êʽnq½ÊÝþÒþs,oo)Š61…,ll,þsþÕôþÏ)0&V)1ôô/'XV'þÓsÿ“Ï´-P@*  +%#  ./(%++FY  FY ?33+33?33+33933333310#"&'&54766326632665%#"&'ÏàÌ @89= ËåàÐ>98@ ÊâüP}‰ <5g†|þü =35< ‰}%éþß%6-+8$&åé $8*+9&þÜá±Ò*"JÒ¯`>* ,Ñ}ÿì;ETU@.C7++&FKPH< 7 UV R@H:"@:@IY(:4IY.4?3+3?3+3ÖÜÔÍ29/393310#".#"#54632326732#"'632!"&'# 32&&#"5654.5432¢TŽxf+/<}tp:pw…Ný(X«=7«]¼Ò¥“<_+FyšäþàþýhªLK§nþüþãäšyF+^<”¥Ò€íx$\8CÇy$+$43gn$,$øºB?9HN- (+’Rþˆþ­þŒþb(0-+uUvR’+þÙþôþÑþ´h¢=H)5IDsÿì*?N\@3((,"@E JB6 OP2:?--6LB @ FYFY% FY?3+3?39++3ÞÜÔ23Í293310"'#"32&#"!273 4&#"'6632#".#"#5463235654.5432+”^\áúϺ>w(9YGtm1{p>oC-nsGY9(w>»Î÷QTxe+k}sp:qvƒNþðîw$\8CAA#( ‹3ÖÖþ^P*&¢ÖÖ3‹ þ×þêþõþÚ¥x$*$fdo%+%Ý¡>H(8JD^ÿì @_@40$96>6) $AB-'-IY77!' @ H  @';3!3IY!?3+3?3Þ22Í+239/9+3933310#'##'##'5"'632!"&'## 32&&#"3267332‹P 2º1!1¼/!PC<]-F|™äÿþâþýt¬L N¬pþüþãå–~F-]<“¥Ò¾A‚3ªf‘¼Ô¥¬gggg¬þ+)’Pþˆþ­þ‹þc001/ rUvP’)þ×þöþÑþ´&&Éþ7LJ1 (¤ *?@$$ +,( @ H  #??33Þ22Í+239?910#'##'##'5#33663363#&¶R2¼11¼2P¬'ªÕþ¬ö') #º¬² - ­™¦ÃÛ¶}!¤¬gggg¬ü%_þ–HýIo«#QˆÕüÿ,¸³Rþ–þåZ\}þãË-@  IY IY  ??+?+93310"!27## 4$32&Hõþà o9ªþµþŸ¯HØíªG«3þÀþèþÚþÔýtØ„màV¸T’Nsþ¢\/@  FYFY?+?+?93310"32&#"3267#uþþüûO¤01Žh±«««5P9¦+"3ÍÝÜÈýnØjÿüu/@!    ?Í9910'%7%7%¶y¶þáB!ÍþßC!¹v¸!DþáÌA9þÃCB¦s¨d¦u¨=CþÀ¦s¦þž¨sË‘¬´@   /332993310#"&5463!6632#‡*03)*6Á+/3-,6ð-2255).0138(øåÛ×@  € /Ì233991027632#54#"##5x–•Qot}j+fyŽTb;:odf$+$yß×Í5@  /Ì93104632&ßC8\$wî¸8EL6(J@á×Ï5@   /Ì93105654.5432Ïîw$\8C¸¡@J(6LE)þÁÁ‘ (6DR_m€@I_(DZ"> R6mL0gno:HHAOED>LVcc\jf_Zm,,%3/"(6OLjm3663mjLO  /3/39////////333333333333333333910&&#"#632&&#"#6632&&#"#6632!&&#"#6632&&#"#6632!&&#"#6632&&#"#632!&&#"#6632o4@%% >:),25 ?@;+.6/'$3 //9910#67'66737&'&&'57667'67'&'7&&'7 F$a5; Ia4#GÈAÝûhB¿OݦC¾CE±xüꛩE±x+REC{Lj'ZC‚&#B¿OݘGÈAÜ‚þ Ia5; F$a5ª'XDnXü•Y?DnXÞŒ·FÆcüéE¨—þf=ÿì?Í 'Q@*$%()IY$ IY !IY ?+?+99//3+3933333310473337! !3267# "&"!&=‘q"M)(ûÜ÷eÊrÝ‚þÆþ£Ž›¯ÑðnˇI62þ•²þõù û3þ‡ÝZ!(X@/  !&! )*!" FY%  "FYFY?+?+99//3+3??93333310&'$54733376632!3267#"!4&Õ¿Óþöj"ú·Ïñý ¬­eŸbŽ¥¦D†—=Œ àÝE2/;g#Êàþ÷âiÆà *”Aþ™H¤ž¥ÿÿTV¶,ÿÿ¼`&°6T³&+5ÿÿß &Ð6¤³&+5Éþ¶B@% IYIY JY ??39/9++?+933310"#337 !"&'53254$^Œ_ªª‰Íý…ObþÙþõR|Fz˜»Èþë{ý¤¶ý<ÄýTþ»þÏþÆþ¤˜1 ñèý°þ !HB@%  FYGYFY??39/9++?+933310!#33#"'532654&#"T¤¤ã·þ7ünÌ…ˆ_.lG‡˜»¾R\Hýúþþäþõ±ü„<‘&ÙÈÓÏþƒ‘¶9@IY JY IY"??+?+?+933310%3##!'"'53266!ٸŜªþ%=]˜~J;6;5O=]8šýé}ðþ!þE®W×Y¸þ‡F9@ FY GY FY"??+?+?+933310%3##!#"'532!ß°¬}¦þµ^˜v:q‰"ýøy¸þ˜þdÀ ÙöÉþ¶=@   IY IY?+??39/+9333310%!"&'53 !#3!3þæþûRzM{‡Œüþªªª–þÂþ¨–1÷#ýP¶ý’n°þ bHG@'   FY    FY?+??39/_^]+9333310"'53265!#3!3Ó„]of}výœ¦¦d¨Ïþ :•=ÆϽþHþ5ËûëþôþãÉþƒ×¶D@$    IY   IY"??+??39/+933333310%3##!#3!3¸‘Åžªüþªªªšýé}°ýP¶ý’n°þ‡FD@$    FY  FY "??+??39/+933333310!33##!#Vf¦°¬}¦ýš¦Fþ7ÉüIýøyîþFªþƒÇ¶=@    IY "IY?+??39/+9333310!##3#"&5332673Ǫ¢¢•ÆjÏߪa±©ªþƒÂ5'¾³EýÏyt7Êœþ…-H=@   FY  " FY ?+??39/+933331032673##3#"&5BÛ[¦i¦•¦•i³q¤ºHþpÀ8CÕû¸þ… aH;¬“œÉþƒ)¶H@%   IY" ?3?3??+9933933333310!##!333##47#PþÑÑþ¸Çžªþ À/ü^¶ûJ¶úäýé}®„Üúò°þ‡ßF?@     FY "??3+??39939333310%7733###&'#3é+)Ó°¬}“:þå‹þå5”Ë)- ]vÓüIýøy‰:™ýJ¸†KüwFý-nÿÿTV¶,ÿÿ^&$69R³&+5ÿÿ^ÿìÍ &D6è³%&+5ÿÿ%&$j=R ´$&+55ÿÿ^ÿìÍÓ&Djó ´:&+55ÿÿÿþ¶ˆÿÿ^ÿìs\¨ÿÿÉø^&(6R³ &+5ÿÿsÿì &H6 ³&+5uÿìXÍ=@  IY  IY IY?+?+9/+933310"5663 ! 5!27!˜ãâsÒ†Koþ¦þËý¬/þùÃÒùü‡Ì5Lž& þqþ›þ¢þqëF ûN ÷þøüfÿì\;@    FY FYFY?+?+9/+9333102#"55!&&#"566267!úõþýÚÐóô³¦b¥_Y¢š…š ýÃ\þÔþûþøþÉ áiÌ»!)“("ü¥œ¤ÿÿuÿìX%&áj“R ´/&+55ÿÿfÿìÓ&âjê ´1&+55ÿÿ¼%&°jR ´'&+55ÿÿßÓ&Ðj¢ ´'&+55ÿÿJÿì5%&±jÿóR ´>&+55ÿÿDÿìÓ&Ñj” ´8&+55Jÿì7¶@@#IYJY JY?+?9/++3933310! '532654&##5!5!ü$þÍþêþÿ£`ÞjÇÊáߌîýN‡? ÓÁÎèOž.2™†ŠÞ™‹þ¦H@@# FYGY FY?+?9/++3933310#"'532654&##5!5!¬•æþØïꊷȡÅÖÊyÅý‰8ÏrʈÞþîFšV¾ ¤ªrþŽ{ÿÿËR´&²M´R³&+5ÿÿ°bb&ÒM1³&+5ÿÿËR%&²j¾R ´%&+55ÿÿ°bÓ&Òj= ´#&+55ÿÿ}ÿì¾%&2jÑR ´-&+55ÿÿsÿìbÓ&Rj ´.&+55ÿÿ}ÿì¾Í~ÿÿsÿìb\ÿÿ}ÿì¾%&~jÑR ´/&+55ÿÿsÿìbÓ&j ´0&+55ÿÿ=ÿì‰%&ÇjÿíR ´0&+55ÿÿ9ÿì}Ó&çjŽ ´0&+55ÿÿÿìø´&½M/R³&+5ÿÿþb&\M­³&+5ÿÿÿìø%&½j;R ´,&+55ÿÿþÓ&\j· ´+&+55ÿÿÿìøs&½SR ´*&+55ÿÿþ!&\S ´)&+55ÿÿªÇ%&ÁjjR ´)&+55ÿÿœ-Ó&áj ´(&+55Éþƒ¶ -@   IY "IY?+??+93310!!3##É?ýk¡¡ª¶™û}ýé}°þ‡BF -@   FY "FY?+??+93310!!3##°’þ–¦–FŒüÕýøyÿÿÉ %&ÅjR ´-&+55ÿÿ°yÓ&åjÅ ´,&+55ÿÿ/þu¶&›€“ÿÿþuBH&œuÿÿþuɶ&;€Xÿÿ'þu4H&[Ö¶;@"     IY  ?3?39/993+3910!33!!##!3þw¼kl·þp<þº½Áþwþp¶¿þºTbý»Eýž˜ýDƒý}¼'H;@"     GY  ?3?39/993+3910!33!!##!uþ´½! »þ²þâh¼þÍþʼfþèwÑþ\¤þ/þ ¼þDöƒ7¶ 4@ IYJY??+9/+99333104$!33! $#"33ƒ$ ƪþcþõþô ºÞ¶ËÙ¤ÔÎpúJÕÛ|Ž„ÿÿsÿì7Gƒÿìw¶#F@$ ##$%IY JY?2+3?99//9+93339310"&54$!3332653#"&'#"!265Nâé*"‘ªædyªÏ¸vŸ3q)—ÔÂ!ÑÐÙÞpû·ì{næþ®ÎRZªÀ‹–þôwpsÿì‡".Q@), &&/0 *FY##FY ?3+3?+9/99?933339310%2653#"&'##"323&&53!26554&# þvk¨È½ž+K¹ÐèçÏjŸ? ¦mý¹¢’”¢þâ‹w„ˆ9þ½ÈÅ[qq[)  /MUp¾ûŒ ‰¹Î#çÉþNÖÒNÿìË*K@(("" +,JY  %%IY% JY?+?+99//+9933310#532654&#"'663232653#"&'&&®ÉÁÀÕš€g±gT]ö‚Öõ²œbl|wp¨Ò½ÊÐͬ“„l7ErHPħ·3þÑ–y‡Íþ)ÆÇÑÈ–‘PÿìÅ\%K@( $$ &'!FYFYFY?+?+99//+9933310%23# &&##53 54#"'6632Bݦ»Äþ†”Œo!òK‡M9U£h¸ÓÀc{ w 9þ½ÊÃMcX¬¢$"‡($›†¸9zjÓNþƒÑË#J@(#! #$%JY##IY#!" JY?+??+9/+99333104&##532654&#"'66323##ƒåâÙÑÍᤇiÃiTaþ„Üý½£¸Ã¬¢¬œ…‹“„k€:BrJNħŒ·³”þþýé}Pþ‡ZJ@(  FYFY" FY?+??+9/+99333104!#53 54&#"'6323##ÕþË–u9…w™–=¡Ë¿ÕË~p¦•-ǬRPF‡Jš‡¶9 %‰fœýøyÿé!¶#:@## $%IY  JY ?3+3?+9/93310!#"'53266!32653#"&5 þH+LS‚dE@2?1@,8J7ïospq¨Í¼ÄÈðþ®þDÒf>hé®ûωyy‡Íþ)ÁÌÌÅÿì)F:@FYGY ?3+3?+9/93310323#"&5!#"'532!ÏhwÕ¦»¾¼ËþÅ^˜v:q‰"qƒ‰ƒ ;þ½ÊÃÄË=þ˜þdÀ ÙöÉÿì^¶C@#  IY IY ?+??399//+9333331032653#"&5!#3!3önspq¦È¿ÃÈý'ªªÙª…‰yy‡Íþ)¿ÎËÆ3ýP¶ý’n°ÿì¨HM@*  FY   FY?+??399//_^]+93333310!3323#"&55!#VP¦jwÕ¦»ÀºÍý°¦Hþ5Ëý=‰… 9þ½ÊÃÆÉsþH}ÿìšË:@IY IY IY?+?+9/+93310!! 4$32&&# 3 !f4þÌþÉþ»þ“³UêxíSBZÖWþõþÞ ÷´þðVþ¡þ±‘`åTµ1'”&.þÅþãþãþÃ×sÿì°\:@ FY FY FY?+?+9/+93310!! !2&#"3265!²þýþþîþ×C!Ô¯;¨¦ÍåÌÅ©¯þª?Cýð'+PƒJÞÒÏß ÿìô¶9@  IYIY?+3?+9/933105!!323#"&5<þ/wrè¨Ó½ÆÍ™™üh‰{Ïþ)ÀÍÎà)ÿì‡F6@ FY  FY ?+?9/+393310!323#"&5!5!þ¦mvצ½ÀÀÉþ¨XºýɉƒAþ½ÊÃËÄ?ŒoÿìXË&G@& $## '(#JYJY JY?+?+9/+99333104$3 &&#"33#"327! $54675&&œáÑ^iµeŒŸÑÈÙÕÞèÊ·éǯþûþôþÛϼª´\©ÆxD4{r€“ŽŠŽ\žMÜÅ—À²ÿÿZÿì‡\‚ÿÿþuk¶&µ€úÿÿþusH&Õÿÿþ ¼&$géÿÿ^þ ÍZ&Dgyÿÿá&$füR³&+5ÿÿ^ÿìÍ&Df¦³)&+5ÿÿÑ&$wåR ´&+55ÿÿ^ÿìA&Dw“ ´+&+55ÿÿÑ&$xÝR ´&+55ÿÿ-ÿìÍ&Dx“ ´+&+55ÿÿJ&$yÙR ´&+55ÿÿ^ÿìø&Dyœ ´+&+55ÿÿb&$zåR ´-&+55ÿÿ^ÿìÍ&Dz‘ ´C&+55ÿÿþ s&$'géK+R³)&+5ÿÿ^þ Í!&D'gyKÔ³>&+5ÿÿ&${ìR ´&+55ÿÿ^ÿìÍÁ&D{š ´-&+55ÿÿ&$|éR ´&+55ÿÿ^ÿìÍÁ&D|˜ ´-&+55ÿÿX&$}éR ´!&+55ÿÿ^ÿìÍ&D}  ´7&+55ÿÿ^&$~ãR ´'&+55ÿÿ^ÿìÍ &D~˜ ´=&+55ÿÿþ I&$'N-dgé³&+5ÿÿ^þ Íå&D&NØgy³%&+5ÿÿÉþ ø¶&(gÁÿÿsþ \&Hg¸ÿÿÉøá&(fÑR³&+5ÿÿsÿì&Hfɳ&+5ÿÿÉø/&(RÿäR³&+5ÿÿsÿìÝ&HRг$&+5ÿÿÉoÑ&(wÁR ´&+55ÿÿsÿì\&Hw® ´!&+55ÿÿ]øÑ&(xÃR ´&+55ÿÿJÿì&Hx° ´!&+55ÿÿÉ9J&(y¾R ´&+55ÿÿsÿìø&Hy¢ ´!&+55ÿÿÉøb&(z¸R ´*&+55ÿÿsÿì&Hz¢ ´9&+55ÿÿÉþ øs&('g¾KR³%&+5ÿÿsþ !&H'g°Kñ³4&+5ÿÿTVá&,fÉR³&+5ÿÿ{æ&ófs³&+5ÿÿTþ V¶&,g´ÿÿþ fß&Lgbÿÿ}þ ¾Í&2gÿÿsþ b\&RgÉÿÿ}ÿì¾á&2fR³&+5ÿÿsÿìb&RfÙ³&+5ÿÿ}ÿì¾Ñ&2w}R ´&+55ÿÿsÿìu&RwÇ ´&+55ÿÿ}ÿì¾Ñ&2x}R ´&+55ÿÿaÿìb&RxÇ ´&+55ÿÿ}ÿì¾J&2y{R ´&+55ÿÿsÿìbø&RyÇ ´&+55ÿÿ}ÿì¾b&2zyR ´6&+55ÿÿsÿìb&RzÅ ´7&+55ÿÿ}þ ¾s&2'gKÁR³1&+5ÿÿsþ b!&R'gÍK³2&+5ÿÿ}ÿìds&_v+R³+&+5ÿÿsÿì!&`vm³+&+5ÿÿ}ÿìds&_C‡R³#&+5ÿÿsÿì!&`CÔ³$&+5ÿÿ}ÿìdá&_fR³&&+5ÿÿsÿì&`fÙ³'&+5ÿÿ}ÿìd/&_R R³+&+5ÿÿsÿìÝ&`Rõ³#&+5ÿÿ}þ d&_g{ÿÿsþ ð&`gÉÿÿºþ ¶&8gJÿÿ¤þ 9H&Xg¸ÿÿºÿìá&8fTR³&+5ÿÿ¤ÿì9&XfÕ³&+5ÿÿºÿì{s&avîR³%&+5ÿÿ¤ÿì–!&bvy³&&+5ÿÿºÿì{s&aCZR³&+5ÿÿ¤ÿì–!&bC»³&+5ÿÿºÿì{á&af`R³ &+5ÿÿ¤ÿì–&bfÛ³"&+5ÿÿºÿì{/&aRR³%&+5ÿÿ¤ÿì–Ý&bRÿ³&+5ÿÿºþ {&agLÿÿ¤þ –ò&bg²ÿÿþ {¶&<gœÿÿþH&\gžÿýÿÿ{á&<fªR³ &+5ÿÿþ&\fj³&+5ÿÿ{/&<RÿÂR³&+5ÿÿþÝ&\RŠ³&+5ÿÿsþÅÓ&ÓB´ûåÙþ´! @  € /3Í2339910#&&'53#&&'53þ´`4±%ºc1þœ`8®%»c1Ù*Ê?=®D,È?=®DüqÙÿ® (@   À/3Ì99//9339910#&'#57673'673#þÓ^pcra^5p4°B—PI6¬Sx`ÙK[eA<{M^¦Â[pn`ûšÙþ× *@   À/3Ì99//9339910#&'#57673%#&'53þ×^arji^5p4°B—ýî_xT¬4KÙAe`F<{M^¦¬^plaüqÙÿ{ø 4@!   À/3Ì299//93339310#&'#57673#'6654&#"5632þÓ^pcra^5p4°B—¨P 9?9+.7ÃÙK[eA<{M^¦{gQƒ &%PühÙþç%:@ '"  " "À/Ì9///3Ä339339910".#"#663232673#&'#57673þ-%GC?(*[ eK%IC>(* Z c^^arji^5p4°B—5%12jq$11hsþ¤Ae`F<{M^¦üyÙþÇÁ$@ @ €/3Ý2ÔÍ339910673# 332673ý^P1¬Vw`>þìf LjbVi •ôher]þüH9A@xŒüyÙþÇÁ$@ @ €/3Ý2ÔÍ339910#&'53 332673ýÑ^wV¬4K5þìf LjbVi •Ý]rlaþåH9A@xŒüyÙþÇ.@  €/Í239/Ä2339310#'6654&#"5632 332673þ1R 9B9,%$>À•þìf LjbVi •yd)Z %%NýÓH9A@xŒühÙþç $0@" & @ !€/Ý2ÖÄ3Í39/3329910".#"#663232673 332673þ-%GC?(*[ dL%IC>(* Z cÝþìf LjbVi •3$02hq$11grþ¦H9A@xŒ1þBm@   /Ì293104'3#"'5326ß‹{žfcA2 6%3îg‡x„[gl 0þuqš @  /Ì299310%#"'5325qä8<)=^šþßþüŒd0þuq @  /Ì299310%#"'5325qä8<)=^þêþüŒd%ÿÿ4C¶ÿxsÿìs (@  KY &MY?+?+993310#"3232654&#"÷ÞÙöùÚØùý›Žžžš/þõþÈ55þËþñÐèêÎÌìé-7^ &@   ??99//993310!#47'37¡C>–Z‹1ïŒC0pr#)×s,@ KY&LY?+3?+9310!!5>54&#"'632!×üR‘q,‹wXœ\ZÀòÆÚ‚ºþ¹¾…/whSAWg=Jm¨¨–s»€ç^þ•t'G@&" ()KY %%KY%& KY %?+?+9/+9933310!"&'53 !#532654&#"'6632î°ªþÞþõtÁ[_×`{þ^’«È“~`ªmTZë‚Õ쌲´’Ñá#,ž/1) —†kz4FpGQÃþ¨f^ B@!  MY $??9/933+393333310%##!533!47#fÙ¨ý2¾¸Ùþ† )Dþ9þs}ÆüD\ÚÞV\ýž…þ•_:@KYLY KY%?+?+9/+933102#"'53265!"'!!6-ç þßþ÷‚FÐe°Ãþ‰^ V7×ý·%s&åÇãþþO -3¦27¬™þIÿÿuÿì/Ë^þ©+_@LY$??+9310!5!^üãÍýªþ©™…úÏÿÿhÿì)Ëjþ•%t%A@"" &'MY KY&MY%?+?+9/9+933310!"'532##"&5432"326654&&%ýhtDPfðõ 7¶rÂäÿЕßxþœ“[™XR“ïü¦)3SWèÐä™þÛ0¸¤¥J€Fi²fÿÿÄ'I¶I\ݪÁ"3Z@.,00.*&&( (.54+1$-/-)/##( ())?3/3Í2/3993339933333310#"'53254&&'&&54632&#"##33#7#H•|‘Jjw”6UxQŽn}\"dSÿ®7@ÿ®7Cÿq7Dÿ\7Fÿ\7Gÿ×7Hÿq7Jÿ…7ûÿ×7ýÿ×7ÿ®7ÿ®7ÿ®7ÿ…7 ÿ…7Wÿš7Xÿq7Yÿ\7_ÿ×7`ÿq7bÿš7ÿq7ÿ\7ÿq7 ÿ\7!ÿq7"ÿ\7#ÿq7%ÿq7&ÿ\7'ÿq7(ÿ\7)ÿq7*ÿ\7+ÿq7,ÿ\7-ÿq7.ÿ\7/ÿq70ÿ\71ÿq72ÿ\73ÿq74ÿ\76ÿq78ÿq7:ÿq7<ÿq7@ÿq7Bÿq7Dÿq7Iÿ×7Jÿq7Kÿ×7Lÿq7Mÿ×7Nÿq7Oÿ×7Qÿ×7Rÿq7Sÿ×7Tÿq7Uÿ×7Vÿq7Wÿ×7Xÿq7Yÿ×7Zÿq7[ÿ×7\ÿq7]ÿ×7^ÿq7_ÿ×7`ÿq7bÿš7dÿš7fÿš7hÿš7jÿš7lÿš7nÿš7pÿ×7)8ÿ×8ÿ×8$ÿì8‚ÿì8ƒÿì8„ÿì8…ÿì8†ÿì8‡ÿì8Âÿì8Äÿì8Æÿì8Cÿì8ÿ×8 ÿ×8Xÿì8ÿì8ÿì8!ÿì8#ÿì8%ÿì8'ÿì8)ÿì8+ÿì8-ÿì8/ÿì81ÿì83ÿì9ÿš9ÿš9")9$ÿ®9&ÿì9*ÿì92ÿì94ÿì9Dÿ×9Fÿ×9Gÿ×9Hÿ×9Jÿì9Pÿì9Qÿì9Rÿ×9Sÿì9Tÿ×9Uÿì9Vÿì9Xÿì9‚ÿ®9ƒÿ®9„ÿ®9…ÿ®9†ÿ®9‡ÿ®9‰ÿì9”ÿì9•ÿì9–ÿì9—ÿì9˜ÿì9šÿì9¢ÿ×9£ÿ×9¤ÿ×9¥ÿ×9¦ÿ×9§ÿ×9¨ÿ×9©ÿ×9ªÿ×9«ÿ×9¬ÿ×9­ÿ×9´ÿ×9µÿ×9¶ÿ×9·ÿ×9¸ÿ×9ºÿ×9»ÿì9¼ÿì9½ÿì9¾ÿì9Âÿ®9Ãÿ×9Äÿ®9Åÿ×9Æÿ®9Çÿ×9Èÿì9Éÿ×9Êÿì9Ëÿ×9Ìÿì9Íÿ×9Îÿì9Ïÿ×9Ñÿ×9Óÿ×9Õÿ×9×ÿ×9Ùÿ×9Ûÿ×9Ýÿ×9Þÿì9ßÿì9àÿì9áÿì9âÿì9ãÿì9äÿì9åÿì9úÿì9ÿì9ÿì9 ÿì9ÿì9ÿ×9ÿì9ÿ×9ÿì9ÿ×9ÿì9ÿ×9ÿì9ÿì9ÿì9!ÿì9+ÿì9-ÿì9/ÿì91ÿì93ÿì95ÿì9Cÿ®9Dÿ×9Fÿ×9Gÿì9Hÿ×9Jÿì9ÿš9 ÿš9Wÿì9Xÿ®9Yÿ×9_ÿì9`ÿ×9bÿì9ÿ®9ÿ×9ÿ®9 ÿ×9!ÿ®9"ÿ×9#ÿ®9%ÿ®9&ÿ×9'ÿ®9(ÿ×9)ÿ®9*ÿ×9+ÿ®9,ÿ×9-ÿ®9.ÿ×9/ÿ®90ÿ×91ÿ®92ÿ×93ÿ®94ÿ×96ÿ×98ÿ×9:ÿ×9<ÿ×9@ÿ×9Bÿ×9Dÿ×9Iÿì9Jÿ×9Kÿì9Lÿ×9Mÿì9Nÿ×9Oÿì9Qÿì9Rÿ×9Sÿì9Tÿ×9Uÿì9Vÿ×9Wÿì9Xÿ×9Yÿì9Zÿ×9[ÿì9\ÿ×9]ÿì9^ÿ×9_ÿì9`ÿ×9bÿì9dÿì9fÿì9hÿì9jÿì9lÿì9nÿì:ÿš:ÿš:"):$ÿ®:&ÿì:*ÿì:2ÿì:4ÿì:Dÿ×:Fÿ×:Gÿ×:Hÿ×:Jÿì:Pÿì:Qÿì:Rÿ×:Sÿì:Tÿ×:Uÿì:Vÿì:Xÿì:‚ÿ®:ƒÿ®:„ÿ®:…ÿ®:†ÿ®:‡ÿ®:‰ÿì:”ÿì:•ÿì:–ÿì:—ÿì:˜ÿì:šÿì:¢ÿ×:£ÿ×:¤ÿ×:¥ÿ×:¦ÿ×:§ÿ×:¨ÿ×:©ÿ×:ªÿ×:«ÿ×:¬ÿ×:­ÿ×:´ÿ×:µÿ×:¶ÿ×:·ÿ×:¸ÿ×:ºÿ×:»ÿì:¼ÿì:½ÿì:¾ÿì:Âÿ®:Ãÿ×:Äÿ®:Åÿ×:Æÿ®:Çÿ×:Èÿì:Éÿ×:Êÿì:Ëÿ×:Ìÿì:Íÿ×:Îÿì:Ïÿ×:Ñÿ×:Óÿ×:Õÿ×:×ÿ×:Ùÿ×:Ûÿ×:Ýÿ×:Þÿì:ßÿì:àÿì:áÿì:âÿì:ãÿì:äÿì:åÿì:úÿì:ÿì:ÿì: ÿì:ÿì:ÿ×:ÿì:ÿ×:ÿì:ÿ×:ÿì:ÿ×:ÿì:ÿì:ÿì:!ÿì:+ÿì:-ÿì:/ÿì:1ÿì:3ÿì:5ÿì:Cÿ®:Dÿ×:Fÿ×:Gÿì:Hÿ×:Jÿì:ÿš: ÿš:Wÿì:Xÿ®:Yÿ×:_ÿì:`ÿ×:bÿì:ÿ®:ÿ×:ÿ®: ÿ×:!ÿ®:"ÿ×:#ÿ®:%ÿ®:&ÿ×:'ÿ®:(ÿ×:)ÿ®:*ÿ×:+ÿ®:,ÿ×:-ÿ®:.ÿ×:/ÿ®:0ÿ×:1ÿ®:2ÿ×:3ÿ®:4ÿ×:6ÿ×:8ÿ×::ÿ×:<ÿ×:@ÿ×:Bÿ×:Dÿ×:Iÿì:Jÿ×:Kÿì:Lÿ×:Mÿì:Nÿ×:Oÿì:Qÿì:Rÿ×:Sÿì:Tÿ×:Uÿì:Vÿ×:Wÿì:Xÿ×:Yÿì:Zÿ×:[ÿì:\ÿ×:]ÿì:^ÿ×:_ÿì:`ÿ×:bÿì:dÿì:fÿì:hÿì:jÿì:lÿì:nÿì;&ÿ×;*ÿ×;2ÿ×;4ÿ×;‰ÿ×;”ÿ×;•ÿ×;–ÿ×;—ÿ×;˜ÿ×;šÿ×;Èÿ×;Êÿ×;Ìÿ×;Îÿ×;Þÿ×;àÿ×;âÿ×;äÿ×;ÿ×;ÿ×;ÿ×;ÿ×;Gÿ×;_ÿ×;Iÿ×;Kÿ×;Mÿ×;Oÿ×;Qÿ×;Sÿ×;Uÿ×;Wÿ×;Yÿ×;[ÿ×;]ÿ×;_ÿ×<ÿ…<ÿ…<")<$ÿ…<&ÿ×<*ÿ×<2ÿ×<4ÿ×<Dÿš<Fÿš<Gÿš<Hÿš<Jÿ×<PÿÃ<QÿÃ<Rÿš<SÿÃ<Tÿš<UÿÃ<Vÿ®<XÿÃ<]ÿ×<‚ÿ…<ƒÿ…<„ÿ…<…ÿ…<†ÿ…<‡ÿ…<‰ÿ×<”ÿ×<•ÿ×<–ÿ×<—ÿ×<˜ÿ×<šÿ×<¢ÿš<£ÿš<¤ÿš<¥ÿš<¦ÿš<§ÿš<¨ÿš<©ÿš<ªÿš<«ÿš<¬ÿš<­ÿš<´ÿš<µÿš<¶ÿš<·ÿš<¸ÿš<ºÿš<»ÿÃ<¼ÿÃ<½ÿÃ<¾ÿÃ<Âÿ…<Ãÿš<Äÿ…<Åÿš<Æÿ…<Çÿš<Èÿ×<Éÿš<Êÿ×<Ëÿš<Ìÿ×<Íÿš<Îÿ×<Ïÿš<Ñÿš<Óÿš<Õÿš<×ÿš<Ùÿš<Ûÿš<Ýÿš<Þÿ×<ßÿ×<àÿ×<áÿ×<âÿ×<ãÿ×<äÿ×<åÿ×<úÿÃ<ÿÃ<ÿÃ< ÿÃ<ÿ×<ÿš<ÿ×<ÿš<ÿ×<ÿš<ÿ×<ÿš<ÿÃ<ÿÃ<ÿ®<!ÿ®<+ÿÃ<-ÿÃ</ÿÃ<1ÿÃ<3ÿÃ<5ÿÃ<<ÿ×<>ÿ×<@ÿ×<Cÿ…<Dÿš<Fÿš<Gÿ×<Hÿš<Jÿ®<ÿ…< ÿ…<WÿÃ<Xÿ…<Yÿš<_ÿ×<`ÿš<bÿÃ<ÿ…<ÿš<ÿ…< ÿš<!ÿ…<"ÿš<#ÿ…<%ÿ…<&ÿš<'ÿ…<(ÿš<)ÿ…<*ÿš<+ÿ…<,ÿš<-ÿ…<.ÿš</ÿ…<0ÿš<1ÿ…<2ÿš<3ÿ…<4ÿš<6ÿš<8ÿš<:ÿš<<ÿš<@ÿš<Bÿš<Dÿš<Iÿ×<Jÿš<Kÿ×<Lÿš<Mÿ×<Nÿš<Oÿ×<Qÿ×<Rÿš<Sÿ×<Tÿš<Uÿ×<Vÿš<Wÿ×<Xÿš<Yÿ×<Zÿš<[ÿ×<\ÿš<]ÿ×<^ÿš<_ÿ×<`ÿš<bÿÃ<dÿÃ<fÿÃ<hÿÃ<jÿÃ<lÿÃ<nÿÃ=&ÿì=*ÿì=2ÿì=4ÿì=‰ÿì=”ÿì=•ÿì=–ÿì=—ÿì=˜ÿì=šÿì=Èÿì=Êÿì=Ìÿì=Îÿì=Þÿì=àÿì=âÿì=äÿì=ÿì=ÿì=ÿì=ÿì=Gÿì=_ÿì=Iÿì=Kÿì=Mÿì=Oÿì=Qÿì=Sÿì=Uÿì=Wÿì=Yÿì=[ÿì=]ÿì=_ÿì>-¸DÿìD ÿìDÿìD ÿìEÿìE ÿìEYÿ×EZÿ×E[ÿ×E\ÿ×E]ÿìE¿ÿ×E7ÿ×E<ÿìE>ÿìE@ÿìEûÿ×Eýÿ×EÿìE ÿìEpÿ×F)F )F)F )HÿìH ÿìHYÿ×HZÿ×H[ÿ×H\ÿ×H]ÿìH¿ÿ×H7ÿ×H<ÿìH>ÿìH@ÿìHûÿ×Hýÿ×HÿìH ÿìHpÿ×I{I {I{I {KÿìK ÿìKÿìK ÿìNFÿ×NGÿ×NHÿ×NRÿ×NTÿ×N¢ÿ×N©ÿ×Nªÿ×N«ÿ×N¬ÿ×N­ÿ×N´ÿ×Nµÿ×N¶ÿ×N·ÿ×N¸ÿ×Nºÿ×NÉÿ×NËÿ×NÍÿ×NÏÿ×NÑÿ×NÓÿ×NÕÿ×N×ÿ×NÙÿ×NÛÿ×NÝÿ×Nÿ×Nÿ×Nÿ×Nÿ×NHÿ×N`ÿ×N6ÿ×N8ÿ×N:ÿ×N<ÿ×N@ÿ×NBÿ×NDÿ×NJÿ×NLÿ×NNÿ×NRÿ×NTÿ×NVÿ×NXÿ×NZÿ×N\ÿ×N^ÿ×N`ÿ×PÿìP ÿìPÿìP ÿìQÿìQ ÿìQÿìQ ÿìRÿìR ÿìRYÿ×RZÿ×R[ÿ×R\ÿ×R]ÿìR¿ÿ×R7ÿ×R<ÿìR>ÿìR@ÿìRûÿ×Rýÿ×RÿìR ÿìRpÿ×SÿìS ÿìSYÿ×SZÿ×S[ÿ×S\ÿ×S]ÿìS¿ÿ×S7ÿ×S<ÿìS>ÿìS@ÿìSûÿ×Sýÿ×SÿìS ÿìSpÿ×URU RUDÿ×UFÿ×UGÿ×UHÿ×UJÿìURÿ×UTÿ×U¢ÿ×U£ÿ×U¤ÿ×U¥ÿ×U¦ÿ×U§ÿ×U¨ÿ×U©ÿ×Uªÿ×U«ÿ×U¬ÿ×U­ÿ×U´ÿ×Uµÿ×U¶ÿ×U·ÿ×U¸ÿ×Uºÿ×UÃÿ×UÅÿ×UÇÿ×UÉÿ×UËÿ×UÍÿ×UÏÿ×UÑÿ×UÓÿ×UÕÿ×U×ÿ×UÙÿ×UÛÿ×UÝÿ×UßÿìUáÿìUãÿìUåÿìUÿ×Uÿ×Uÿ×Uÿ×UDÿ×UFÿ×UHÿ×URU RUYÿ×U`ÿ×Uÿ×U ÿ×U"ÿ×U&ÿ×U(ÿ×U*ÿ×U,ÿ×U.ÿ×U0ÿ×U2ÿ×U4ÿ×U6ÿ×U8ÿ×U:ÿ×U<ÿ×U@ÿ×UBÿ×UDÿ×UJÿ×ULÿ×UNÿ×URÿ×UTÿ×UVÿ×UXÿ×UZÿ×U\ÿ×U^ÿ×U`ÿ×W)W )W)W )YRY RYÿ®Yÿ®Y")YRYÿ®Y RY ÿ®ZRZ RZÿ®Zÿ®Z")ZRZÿ®Z RZ ÿ®[Fÿ×[Gÿ×[Hÿ×[Rÿ×[Tÿ×[¢ÿ×[©ÿ×[ªÿ×[«ÿ×[¬ÿ×[­ÿ×[´ÿ×[µÿ×[¶ÿ×[·ÿ×[¸ÿ×[ºÿ×[Éÿ×[Ëÿ×[Íÿ×[Ïÿ×[Ñÿ×[Óÿ×[Õÿ×[×ÿ×[Ùÿ×[Ûÿ×[Ýÿ×[ÿ×[ÿ×[ÿ×[ÿ×[Hÿ×[`ÿ×[6ÿ×[8ÿ×[:ÿ×[<ÿ×[@ÿ×[Bÿ×[Dÿ×[Jÿ×[Lÿ×[Nÿ×[Rÿ×[Tÿ×[Vÿ×[Xÿ×[Zÿ×[\ÿ×[^ÿ×[`ÿ×\R\ R\ÿ®\ÿ®\")\R\ÿ®\ R\ ÿ®^-¸‚ÿq‚ ÿq‚&ÿׂ*ÿׂ- ‚2ÿׂ4ÿׂ7ÿq‚9ÿ®‚:ÿ®‚<ÿ…‚‰ÿׂ”ÿׂ•ÿׂ–ÿׂ—ÿׂ˜ÿׂšÿׂŸÿ…‚ÈÿׂÊÿׂÌÿׂÎÿׂÞÿׂàÿׂâÿׂäÿׂÿׂÿׂÿׂÿׂ$ÿq‚&ÿq‚6ÿ®‚8ÿ…‚:ÿ…‚Gÿׂúÿ®‚üÿ®‚þÿ®‚ÿ…‚ÿq‚ ÿq‚_ÿׂIÿׂKÿׂMÿׂOÿׂQÿׂSÿׂUÿׂWÿׂYÿׂ[ÿׂ]ÿׂ_ÿׂoÿ…‚qÿ…‚sÿ…‚ÿqƒÿqƒ ÿqƒ&ÿ׃*ÿ׃- ƒ2ÿ׃4ÿ׃7ÿqƒ9ÿ®ƒ:ÿ®ƒ<ÿ…ƒ‰ÿ׃”ÿ׃•ÿ׃–ÿ׃—ÿ׃˜ÿ׃šÿ׃Ÿÿ…ƒÈÿ׃Êÿ׃Ìÿ׃Îÿ׃Þÿ׃àÿ׃âÿ׃äÿ׃ÿ׃ÿ׃ÿ׃ÿ׃$ÿqƒ&ÿqƒ6ÿ®ƒ8ÿ…ƒ:ÿ…ƒGÿ׃úÿ®ƒüÿ®ƒþÿ®ƒÿ…ƒÿqƒ ÿqƒ_ÿ׃Iÿ׃Kÿ׃Mÿ׃Oÿ׃Qÿ׃Sÿ׃Uÿ׃Wÿ׃Yÿ׃[ÿ׃]ÿ׃_ÿ׃oÿ…ƒqÿ…ƒsÿ…ƒÿq„ÿq„ ÿq„&ÿׄ*ÿׄ- „2ÿׄ4ÿׄ7ÿq„9ÿ®„:ÿ®„<ÿ…„‰ÿׄ”ÿׄ•ÿׄ–ÿׄ—ÿׄ˜ÿׄšÿׄŸÿ…„ÈÿׄÊÿׄÌÿׄÎÿׄÞÿׄàÿׄâÿׄäÿׄÿׄÿׄÿׄÿׄ$ÿq„&ÿq„6ÿ®„8ÿ…„:ÿ…„Gÿׄúÿ®„üÿ®„þÿ®„ÿ…„ÿq„ ÿq„_ÿׄIÿׄKÿׄMÿׄOÿׄQÿׄSÿׄUÿׄWÿׄYÿׄ[ÿׄ]ÿׄ_ÿׄoÿ…„qÿ…„sÿ…„ÿq…ÿq… ÿq…&ÿ×…*ÿ×…- …2ÿ×…4ÿ×…7ÿq…9ÿ®…:ÿ®…<ÿ……‰ÿ×…”ÿ×…•ÿ×…–ÿ×…—ÿ×…˜ÿ×…šÿ×…Ÿÿ……Èÿ×…Êÿ×…Ìÿ×…Îÿ×…Þÿ×…àÿ×…âÿ×…äÿ×…ÿ×…ÿ×…ÿ×…ÿ×…$ÿq…&ÿq…6ÿ®…8ÿ……:ÿ……Gÿ×…úÿ®…üÿ®…þÿ®…ÿ……ÿq… ÿq…_ÿ×…Iÿ×…Kÿ×…Mÿ×…Oÿ×…Qÿ×…Sÿ×…Uÿ×…Wÿ×…Yÿ×…[ÿ×…]ÿ×…_ÿ×…oÿ……qÿ……sÿ……ÿq†ÿq† ÿq†&ÿ׆*ÿ׆- †2ÿ׆4ÿ׆7ÿq†9ÿ®†:ÿ®†<ÿ…†‰ÿ׆”ÿ׆•ÿ׆–ÿ׆—ÿ׆˜ÿ׆šÿ׆Ÿÿ…†Èÿ׆Êÿ׆Ìÿ׆Îÿ׆Þÿ׆àÿ׆âÿ׆äÿ׆ÿ׆ÿ׆ÿ׆ÿ׆$ÿq†&ÿq†6ÿ®†8ÿ…†:ÿ…†Gÿ׆úÿ®†üÿ®†þÿ®†ÿ…†ÿq† ÿq†_ÿ׆Iÿ׆Kÿ׆Mÿ׆Oÿ׆Qÿ׆Sÿ׆Uÿ׆Wÿ׆Yÿ׆[ÿ׆]ÿ׆_ÿ׆oÿ…†qÿ…†sÿ…†ÿq‡ÿq‡ ÿq‡&ÿׇ*ÿׇ- ‡2ÿׇ4ÿׇ7ÿq‡9ÿ®‡:ÿ®‡<ÿ…‡‰ÿׇ”ÿׇ•ÿׇ–ÿׇ—ÿׇ˜ÿׇšÿׇŸÿ…‡ÈÿׇÊÿׇÌÿׇÎÿׇÞÿׇàÿׇâÿׇäÿׇÿׇÿׇÿׇÿׇ$ÿq‡&ÿq‡6ÿ®‡8ÿ…‡:ÿ…‡Gÿׇúÿ®‡üÿ®‡þÿ®‡ÿ…‡ÿq‡ ÿq‡_ÿׇIÿׇKÿׇMÿׇOÿׇQÿׇSÿׇUÿׇWÿׇYÿׇ[ÿׇ]ÿׇ_ÿׇoÿ…‡qÿ…‡sÿ…‡ÿqˆ-{‰&ÿ׉*ÿ׉2ÿ׉4ÿ׉‰ÿ׉”ÿ׉•ÿ׉–ÿ׉—ÿ׉˜ÿ׉šÿ׉Èÿ׉Êÿ׉Ìÿ׉Îÿ׉Þÿ׉àÿ׉âÿ׉äÿ׉ÿ׉ÿ׉ÿ׉ÿ׉Gÿ׉_ÿ׉Iÿ׉Kÿ׉Mÿ׉Oÿ׉Qÿ׉Sÿ׉Uÿ׉Wÿ׉Yÿ׉[ÿ׉]ÿ׉_ÿ׊-{‹-{Œ-{-{’ÿ®’ÿ®’$ÿ×’7ÿÃ’9ÿì’:ÿì’;ÿ×’<ÿì’=ÿì’‚ÿ×’ƒÿ×’„ÿ×’…ÿ×’†ÿ×’‡ÿ×’Ÿÿì’Âÿ×’Äÿ×’Æÿ×’$ÿÃ’&ÿÃ’6ÿì’8ÿì’:ÿì’;ÿì’=ÿì’?ÿì’Cÿ×’ ÿì’úÿì’üÿì’þÿì’ÿì’ÿ®’ ÿ®’Xÿ×’ÿ×’ÿ×’!ÿ×’#ÿ×’%ÿ×’'ÿ×’)ÿ×’+ÿ×’-ÿ×’/ÿ×’1ÿ×’3ÿ×’oÿì’qÿì’sÿì’ÿÔÿ®”ÿ®”$ÿ×”7ÿÔ9ÿì”:ÿì”;ÿ×”<ÿì”=ÿ씂ÿ×”ƒÿ×”„ÿ×”…ÿ×”†ÿ×”‡ÿ×”Ÿÿì”Âÿ×”Äÿ×”Æÿ×”$ÿÔ&ÿÔ6ÿì”8ÿì”:ÿì”;ÿì”=ÿì”?ÿì”Cÿ×” ÿì”úÿì”üÿì”þÿì”ÿì”ÿ®” ÿ®”Xÿ×”ÿ×”ÿ×”!ÿ×”#ÿ×”%ÿ×”'ÿ×”)ÿ×”+ÿ×”-ÿ×”/ÿ×”1ÿ×”3ÿ×”oÿì”qÿì”sÿì”ÿÕÿ®•ÿ®•$ÿו7ÿÕ9ÿì•:ÿì•;ÿו<ÿì•=ÿì•‚ÿוƒÿו„ÿו…ÿו†ÿו‡ÿוŸÿì•ÂÿוÄÿוÆÿו$ÿÕ&ÿÕ6ÿì•8ÿì•:ÿì•;ÿì•=ÿì•?ÿì•Cÿו ÿì•úÿì•üÿì•þÿì•ÿì•ÿ®• ÿ®•Xÿוÿוÿו!ÿו#ÿו%ÿו'ÿו)ÿו+ÿו-ÿו/ÿו1ÿו3ÿוoÿì•qÿì•sÿì•ÿÖÿ®–ÿ®–$ÿ×–7ÿÖ9ÿì–:ÿì–;ÿ×–<ÿì–=ÿì–‚ÿ×–ƒÿ×–„ÿ×–…ÿ×–†ÿ×–‡ÿ×–Ÿÿì–Âÿ×–Äÿ×–Æÿ×–$ÿÖ&ÿÖ6ÿì–8ÿì–:ÿì–;ÿì–=ÿì–?ÿì–Cÿ×– ÿì–úÿì–üÿì–þÿì–ÿì–ÿ®– ÿ®–Xÿ×–ÿ×–ÿ×–!ÿ×–#ÿ×–%ÿ×–'ÿ×–)ÿ×–+ÿ×–-ÿ×–/ÿ×–1ÿ×–3ÿ×–oÿì–qÿì–sÿì–ÿ×ÿ®—ÿ®—$ÿ×—7ÿ×9ÿì—:ÿì—;ÿ×—<ÿì—=ÿì—‚ÿ×—ƒÿ×—„ÿ×—…ÿ×—†ÿ×—‡ÿ×—Ÿÿì—Âÿ×—Äÿ×—Æÿ×—$ÿ×&ÿ×6ÿì—8ÿì—:ÿì—;ÿì—=ÿì—?ÿì—Cÿ×— ÿì—úÿì—üÿì—þÿì—ÿì—ÿ®— ÿ®—Xÿ×—ÿ×—ÿ×—!ÿ×—#ÿ×—%ÿ×—'ÿ×—)ÿ×—+ÿ×—-ÿ×—/ÿ×—1ÿ×—3ÿ×—oÿì—qÿì—sÿì—ÿØÿ®˜ÿ®˜$ÿט7ÿØ9ÿì˜:ÿì˜;ÿט<ÿì˜=ÿ옂ÿטƒÿט„ÿט…ÿט†ÿט‡ÿטŸÿì˜ÂÿטÄÿטÆÿט$ÿØ&ÿØ6ÿì˜8ÿì˜:ÿì˜;ÿì˜=ÿì˜?ÿì˜Cÿט ÿì˜úÿì˜üÿì˜þÿì˜ÿì˜ÿ®˜ ÿ®˜Xÿטÿטÿט!ÿט#ÿט%ÿט'ÿט)ÿט+ÿט-ÿט/ÿט1ÿט3ÿטoÿì˜qÿì˜sÿì˜ÿÚÿ®šÿ®š$ÿך7ÿÚ9ÿìš:ÿìš;ÿך<ÿìš=ÿìš‚ÿךƒÿך„ÿך…ÿך†ÿך‡ÿךŸÿìšÂÿךÄÿךÆÿך$ÿÚ&ÿÚ6ÿìš8ÿìš:ÿìš;ÿìš=ÿìš?ÿìšCÿך ÿìšúÿìšüÿìšþÿìšÿìšÿ®š ÿ®šXÿךÿךÿך!ÿך#ÿך%ÿך'ÿך)ÿך+ÿך-ÿך/ÿך1ÿך3ÿךoÿìšqÿìšsÿìšÿÛÿ×›ÿ×›$ÿ웂ÿ웃ÿ웄ÿì›…ÿ웆ÿ웇ÿì›Âÿì›Äÿì›Æÿì›Cÿì›ÿ×› ÿ×›Xÿì›ÿì›ÿì›!ÿì›#ÿì›%ÿì›'ÿì›)ÿì›+ÿì›-ÿì›/ÿì›1ÿì›3ÿìœÿלÿל$ÿ윂ÿ윃ÿ위ÿ윅ÿ윆ÿ윇ÿìœÂÿìœÄÿìœÆÿìœCÿìœÿל ÿלXÿìœÿìœÿìœ!ÿìœ#ÿìœ%ÿìœ'ÿìœ)ÿìœ+ÿìœ-ÿìœ/ÿìœ1ÿìœ3ÿìÿ×ÿ×$ÿì‚ÿìƒÿì„ÿì…ÿì†ÿì‡ÿìÂÿìÄÿìÆÿìCÿìÿ× ÿ×Xÿìÿìÿì!ÿì#ÿì%ÿì'ÿì)ÿì+ÿì-ÿì/ÿì1ÿì3ÿìžÿמÿמ$ÿìž‚ÿ잃ÿìž„ÿìž…ÿ잆ÿ잇ÿìžÂÿìžÄÿìžÆÿìžCÿìžÿמ ÿמXÿìžÿìžÿìž!ÿìž#ÿìž%ÿìž'ÿìž)ÿìž+ÿìž-ÿìž/ÿìž1ÿìž3ÿìŸÿ…Ÿÿ…Ÿ")Ÿ$ÿ…Ÿ&ÿן*ÿן2ÿן4ÿןDÿšŸFÿšŸGÿšŸHÿšŸJÿןPÿßQÿßRÿšŸSÿßTÿšŸUÿßVÿ®ŸXÿß]ÿן‚ÿ…Ÿƒÿ…Ÿ„ÿ…Ÿ…ÿ…Ÿ†ÿ…Ÿ‡ÿ…Ÿ‰ÿן”ÿן•ÿן–ÿן—ÿן˜ÿןšÿן¢ÿšŸ£ÿšŸ¤ÿšŸ¥ÿšŸ¦ÿšŸ§ÿšŸ¨ÿšŸ©ÿšŸªÿšŸ«ÿšŸ¬ÿšŸ­ÿšŸ´ÿšŸµÿšŸ¶ÿšŸ·ÿšŸ¸ÿšŸºÿšŸ»ÿß¼ÿß½ÿß¾ÿßÂÿ…ŸÃÿšŸÄÿ…ŸÅÿšŸÆÿ…ŸÇÿšŸÈÿןÉÿšŸÊÿןËÿšŸÌÿןÍÿšŸÎÿןÏÿšŸÑÿšŸÓÿšŸÕÿšŸ×ÿšŸÙÿšŸÛÿšŸÝÿšŸÞÿןßÿןàÿןáÿןâÿןãÿןäÿןåÿןúÿßÿßÿß ÿßÿןÿšŸÿןÿšŸÿןÿšŸÿןÿšŸÿßÿßÿ®Ÿ!ÿ®Ÿ+ÿß-ÿß/ÿß1ÿß3ÿß5ÿß<ÿן>ÿן@ÿןCÿ…ŸDÿšŸFÿšŸGÿןHÿšŸJÿ®Ÿÿ…Ÿ ÿ…ŸWÿßXÿ…ŸYÿšŸ_ÿן`ÿšŸbÿßÿ…ŸÿšŸÿ…Ÿ ÿšŸ!ÿ…Ÿ"ÿšŸ#ÿ…Ÿ%ÿ…Ÿ&ÿšŸ'ÿ…Ÿ(ÿšŸ)ÿ…Ÿ*ÿšŸ+ÿ…Ÿ,ÿšŸ-ÿ…Ÿ.ÿšŸ/ÿ…Ÿ0ÿšŸ1ÿ…Ÿ2ÿšŸ3ÿ…Ÿ4ÿšŸ6ÿšŸ8ÿšŸ:ÿšŸ<ÿšŸ@ÿšŸBÿšŸDÿšŸIÿןJÿšŸKÿןLÿšŸMÿןNÿšŸOÿןQÿןRÿšŸSÿןTÿšŸUÿןVÿšŸWÿןXÿšŸYÿןZÿšŸ[ÿן\ÿšŸ]ÿן^ÿšŸ_ÿן`ÿšŸbÿßdÿßfÿßhÿßjÿßlÿßnÿàþö þö $ÿš ;ÿ× =ÿì ‚ÿš ƒÿš „ÿš …ÿš †ÿš ‡ÿš Âÿš Äÿš Æÿš ;ÿì =ÿì ?ÿì Cÿš þö  þö Xÿš ÿš ÿš !ÿš #ÿš %ÿš 'ÿš )ÿš +ÿš -ÿš /ÿš 1ÿš 3ÿš¢ÿì¢ ÿì¢ÿì¢ ÿì£ÿì£ ÿì£ÿì£ ÿì¤ÿì¤ ÿì¤ÿì¤ ÿì¥ÿì¥ ÿì¥ÿì¥ ÿì¦ÿì¦ ÿì¦ÿì¦ ÿì§ÿì§ ÿì§ÿì§ ÿìªÿìª ÿìªYÿתZÿת[ÿת\ÿת]ÿ쪿ÿת7ÿת<ÿìª>ÿìª@ÿìªûÿתýÿתÿìª ÿìªpÿ׫ÿì« ÿì«Yÿ׫Zÿ׫[ÿ׫\ÿ׫]ÿì«¿ÿ׫7ÿ׫<ÿì«>ÿì«@ÿì«ûÿ׫ýÿ׫ÿì« ÿì«pÿ׬ÿì¬ ÿì¬Yÿ׬Zÿ׬[ÿ׬\ÿ׬]ÿ쬿ÿ׬7ÿ׬<ÿì¬>ÿì¬@ÿì¬ûÿ׬ýÿ׬ÿì¬ ÿì¬pÿ×­ÿì­ ÿì­Yÿ×­Zÿ×­[ÿ×­\ÿ×­]ÿì­¿ÿ×­7ÿ×­<ÿì­>ÿì­@ÿì­ûÿ×­ýÿ×­ÿì­ ÿì­pÿײÿì² ÿì²YÿײZÿײ[ÿײ\ÿײ]ÿ첿ÿײ7ÿײ<ÿì²>ÿì²@ÿì²ûÿײýÿײÿì² ÿì²pÿ×´ÿì´ ÿì´Yÿ×´Zÿ×´[ÿ×´\ÿ×´]ÿì´¿ÿ×´7ÿ×´<ÿì´>ÿì´@ÿì´ûÿ×´ýÿ×´ÿì´ ÿì´pÿ×µÿìµ ÿìµYÿ×µZÿ×µ[ÿ×µ\ÿ×µ]ÿ쵿ÿ×µ7ÿ×µ<ÿìµ>ÿìµ@ÿìµûÿ×µýÿ×µÿìµ ÿìµpÿ׶ÿì¶ ÿì¶Yÿ׶Zÿ׶[ÿ׶\ÿ׶]ÿ춿ÿ׶7ÿ׶<ÿì¶>ÿì¶@ÿì¶ûÿ׶ýÿ׶ÿì¶ ÿì¶pÿ׸ÿ׸ ÿ׸ÿ׸ ÿ׺ÿìº ÿìºYÿ׺Zÿ׺[ÿ׺\ÿ׺]ÿ캿ÿ׺7ÿ׺<ÿìº>ÿìº@ÿìºûÿ׺ýÿ׺ÿìº ÿìºpÿ׿R¿ R¿ÿ®¿ÿ®¿")¿R¿ÿ®¿ R¿ ÿ®ÀÿìÀ ÿìÀYÿ×ÀZÿ×À[ÿ×À\ÿ×À]ÿìÀ¿ÿ×À7ÿ×À<ÿìÀ>ÿìÀ@ÿìÀûÿ×Àýÿ×ÀÿìÀ ÿìÀpÿ×ÁRÁ RÁÿ®Áÿ®Á")ÁRÁÿ®Á RÁ ÿ®Âÿq ÿqÂ&ÿ×Â*ÿ×Â- Â2ÿ×Â4ÿ×Â7ÿqÂ9ÿ®Â:ÿ®Â<ÿ…‰ÿ×”ÿוÿ×–ÿ×—ÿטÿךÿןÿ…ÂÈÿ×ÂÊÿ×ÂÌÿ×ÂÎÿ×ÂÞÿ×Âàÿ×Ââÿ×Âäÿ×Âÿ×Âÿ×Âÿ×Âÿ×Â$ÿqÂ&ÿqÂ6ÿ®Â8ÿ…Â:ÿ…ÂGÿ×Âúÿ®Âüÿ®Âþÿ®Âÿ…Âÿq ÿqÂ_ÿ×ÂIÿ×ÂKÿ×ÂMÿ×ÂOÿ×ÂQÿ×ÂSÿ×ÂUÿ×ÂWÿ×ÂYÿ×Â[ÿ×Â]ÿ×Â_ÿ×Âoÿ…Âqÿ…Âsÿ…ÂÿqÃÿìà ÿìÃÿìà ÿìÄÿqÄ ÿqÄ&ÿ×Ä*ÿ×Ä- Ä2ÿ×Ä4ÿ×Ä7ÿqÄ9ÿ®Ä:ÿ®Ä<ÿ…ĉÿ×Ä”ÿ×Ä•ÿ×Ä–ÿ×Ä—ÿ×Ęÿ×Äšÿ×ÄŸÿ…ÄÈÿ×ÄÊÿ×ÄÌÿ×ÄÎÿ×ÄÞÿ×Äàÿ×Äâÿ×Ääÿ×Äÿ×Äÿ×Äÿ×Äÿ×Ä$ÿqÄ&ÿqÄ6ÿ®Ä8ÿ…Ä:ÿ…ÄGÿ×Äúÿ®Äüÿ®Äþÿ®Äÿ…ÄÿqÄ ÿqÄ_ÿ×ÄIÿ×ÄKÿ×ÄMÿ×ÄOÿ×ÄQÿ×ÄSÿ×ÄUÿ×ÄWÿ×ÄYÿ×Ä[ÿ×Ä]ÿ×Ä_ÿ×Äoÿ…Äqÿ…Äsÿ…ÄÿqÅÿìÅ ÿìÅÿìÅ ÿìÆÿqÆ ÿqÆ&ÿ×Æ*ÿ×Æ- Æ2ÿ×Æ4ÿ×Æ7ÿqÆ9ÿ®Æ:ÿ®Æ<ÿ…Ɖÿ×Æ”ÿ×Æ•ÿ×Æ–ÿ×Æ—ÿ×Ƙÿ×Æšÿ×ÆŸÿ…ÆÈÿ×ÆÊÿ×ÆÌÿ×ÆÎÿ×ÆÞÿ×Æàÿ×Æâÿ×Æäÿ×Æÿ×Æÿ×Æÿ×Æÿ×Æ$ÿqÆ&ÿqÆ6ÿ®Æ8ÿ…Æ:ÿ…ÆGÿ×Æúÿ®Æüÿ®Æþÿ®Æÿ…ÆÿqÆ ÿqÆ_ÿ×ÆIÿ×ÆKÿ×ÆMÿ×ÆOÿ×ÆQÿ×ÆSÿ×ÆUÿ×ÆWÿ×ÆYÿ×Æ[ÿ×Æ]ÿ×Æ_ÿ×Æoÿ…Æqÿ…Æsÿ…ÆÿqÇÿìÇ ÿìÇÿìÇ ÿìÈ&ÿ×È*ÿ×È2ÿ×È4ÿ×ȉÿ×È”ÿ×È•ÿ×È–ÿ×È—ÿ×Șÿ×Èšÿ×ÈÈÿ×ÈÊÿ×ÈÌÿ×ÈÎÿ×ÈÞÿ×Èàÿ×Èâÿ×Èäÿ×Èÿ×Èÿ×Èÿ×Èÿ×ÈGÿ×È_ÿ×ÈIÿ×ÈKÿ×ÈMÿ×ÈOÿ×ÈQÿ×ÈSÿ×ÈUÿ×ÈWÿ×ÈYÿ×È[ÿ×È]ÿ×È_ÿ×Ê&ÿ×Ê*ÿ×Ê2ÿ×Ê4ÿ×ʉÿ×Ê”ÿ×Ê•ÿ×Ê–ÿ×Ê—ÿ×ʘÿ×Êšÿ×ÊÈÿ×ÊÊÿ×ÊÌÿ×ÊÎÿ×ÊÞÿ×Êàÿ×Êâÿ×Êäÿ×Êÿ×Êÿ×Êÿ×Êÿ×ÊGÿ×Ê_ÿ×ÊIÿ×ÊKÿ×ÊMÿ×ÊOÿ×ÊQÿ×ÊSÿ×ÊUÿ×ÊWÿ×ÊYÿ×Ê[ÿ×Ê]ÿ×Ê_ÿ×Ì&ÿ×Ì*ÿ×Ì2ÿ×Ì4ÿ×̉ÿ×Ì”ÿ×Ì•ÿ×Ì–ÿ×Ì—ÿ×̘ÿ×Ìšÿ×ÌÈÿ×ÌÊÿ×ÌÌÿ×ÌÎÿ×ÌÞÿ×Ìàÿ×Ìâÿ×Ìäÿ×Ìÿ×Ìÿ×Ìÿ×Ìÿ×ÌGÿ×Ì_ÿ×ÌIÿ×ÌKÿ×ÌMÿ×ÌOÿ×ÌQÿ×ÌSÿ×ÌUÿ×ÌWÿ×ÌYÿ×Ì[ÿ×Ì]ÿ×Ì_ÿ×Î&ÿ×Î*ÿ×Î2ÿ×Î4ÿ×Ήÿ×Δÿ×Εÿ×Ζÿ×Ηÿ×Θÿ×Κÿ×ÎÈÿ×ÎÊÿ×ÎÌÿ×ÎÎÿ×ÎÞÿ×Îàÿ×Îâÿ×Îäÿ×Îÿ×Îÿ×Îÿ×Îÿ×ÎGÿ×Î_ÿ×ÎIÿ×ÎKÿ×ÎMÿ×ÎOÿ×ÎQÿ×ÎSÿ×ÎUÿ×ÎWÿ×ÎYÿ×Î[ÿ×Î]ÿ×Î_ÿ×Ðÿ®Ðÿ®Ð$ÿ×Ð7ÿÃÐ9ÿìÐ:ÿìÐ;ÿ×Ð<ÿìÐ=ÿìЂÿ×Ѓÿ×Єÿ×Ð…ÿ×Іÿ×Їÿ×ПÿìÐÂÿ×ÐÄÿ×ÐÆÿ×Ð$ÿÃÐ&ÿÃÐ6ÿìÐ8ÿìÐ:ÿìÐ;ÿìÐ=ÿìÐ?ÿìÐCÿ×РÿìÐúÿìÐüÿìÐþÿìÐÿìÐÿ®Ð ÿ®ÐXÿ×Ðÿ×Ðÿ×Ð!ÿ×Ð#ÿ×Ð%ÿ×Ð'ÿ×Ð)ÿ×Ð+ÿ×Ð-ÿ×Ð/ÿ×Ð1ÿ×Ð3ÿ×ÐoÿìÐqÿìÐsÿìÐÿÃÑRÑ RÑ Ñ"¤Ñ@ÑE=ÑK=ÑN=ÑO=Ñ`Ñç=Ñé{ÑRÑ RÒÿ®Òÿ®Ò$ÿ×Ò7ÿÃÒ9ÿìÒ:ÿìÒ;ÿ×Ò<ÿìÒ=ÿìÒ‚ÿ×Òƒÿ×Ò„ÿ×Ò…ÿ×Ò†ÿ×Ò‡ÿ×ÒŸÿìÒÂÿ×ÒÄÿ×ÒÆÿ×Ò$ÿÃÒ&ÿÃÒ6ÿìÒ8ÿìÒ:ÿìÒ;ÿìÒ=ÿìÒ?ÿìÒCÿ×Ò ÿìÒúÿìÒüÿìÒþÿìÒÿìÒÿ®Ò ÿ®ÒXÿ×Òÿ×Òÿ×Ò!ÿ×Ò#ÿ×Ò%ÿ×Ò'ÿ×Ò)ÿ×Ò+ÿ×Ò-ÿ×Ò/ÿ×Ò1ÿ×Ò3ÿ×ÒoÿìÒqÿìÒsÿìÒÿÃÔ-{ÕÿìÕ ÿìÕYÿ×ÕZÿ×Õ[ÿ×Õ\ÿ×Õ]ÿìÕ¿ÿ×Õ7ÿ×Õ<ÿìÕ>ÿìÕ@ÿìÕûÿ×Õýÿ×ÕÿìÕ ÿìÕpÿ×Ö-{×ÿì× ÿì×Yÿ××Zÿ××[ÿ××\ÿ××]ÿì׿ÿ××7ÿ××<ÿì×>ÿì×@ÿì×ûÿ××ýÿ××ÿì× ÿì×pÿ×Ø-{ÙÿìÙ ÿìÙYÿ×ÙZÿ×Ù[ÿ×Ù\ÿ×Ù]ÿìÙ¿ÿ×Ù7ÿ×Ù<ÿìÙ>ÿìÙ@ÿìÙûÿ×Ùýÿ×ÙÿìÙ ÿìÙpÿ×Ú-{ÛÿìÛ ÿìÛYÿ×ÛZÿ×Û[ÿ×Û\ÿ×Û]ÿìÛ¿ÿ×Û7ÿ×Û<ÿìÛ>ÿìÛ@ÿìÛûÿ×Ûýÿ×ÛÿìÛ ÿìÛpÿ×Ü-{ÝÿìÝ ÿìÝYÿ×ÝZÿ×Ý[ÿ×Ý\ÿ×Ý]ÿìÝ¿ÿ×Ý7ÿ×Ý<ÿìÝ>ÿìÝ@ÿìÝûÿ×Ýýÿ×ÝÿìÝ ÿìÝpÿ×çÿìç ÿìçÿìç ÿìø&ÿ×ø*ÿ×ø2ÿ×ø4ÿ×ø‰ÿ×ø”ÿ×ø•ÿ×ø–ÿ×ø—ÿ×ø˜ÿ×øšÿ×øÈÿ×øÊÿ×øÌÿ×øÎÿ×øÞÿ×øàÿ×øâÿ×øäÿ×øÿ×øÿ×øÿ×øÿ×øGÿ×ø_ÿ×øIÿ×øKÿ×øMÿ×øOÿ×øQÿ×øSÿ×øUÿ×øWÿ×øYÿ×ø[ÿ×ø]ÿ×ø_ÿ×ùFÿ×ùGÿ×ùHÿ×ùRÿ×ùTÿ×ù¢ÿ×ù©ÿ×ùªÿ×ù«ÿ×ù¬ÿ×ù­ÿ×ù´ÿ×ùµÿ×ù¶ÿ×ù·ÿ×ù¸ÿ×ùºÿ×ùÉÿ×ùËÿ×ùÍÿ×ùÏÿ×ùÑÿ×ùÓÿ×ùÕÿ×ù×ÿ×ùÙÿ×ùÛÿ×ùÝÿ×ùÿ×ùÿ×ùÿ×ùÿ×ùHÿ×ù`ÿ×ù6ÿ×ù8ÿ×ù:ÿ×ù<ÿ×ù@ÿ×ùBÿ×ùDÿ×ùJÿ×ùLÿ×ùNÿ×ùRÿ×ùTÿ×ùVÿ×ùXÿ×ùZÿ×ù\ÿ×ù^ÿ×ù`ÿ×úFÿ×úGÿ×úHÿ×úRÿ×úTÿ×ú¢ÿ×ú©ÿ×úªÿ×ú«ÿ×ú¬ÿ×ú­ÿ×ú´ÿ×úµÿ×ú¶ÿ×ú·ÿ×ú¸ÿ×úºÿ×úÉÿ×úËÿ×úÍÿ×úÏÿ×úÑÿ×úÓÿ×úÕÿ×ú×ÿ×úÙÿ×úÛÿ×úÝÿ×úÿ×úÿ×úÿ×úÿ×úHÿ×ú`ÿ×ú6ÿ×ú8ÿ×ú:ÿ×ú<ÿ×ú@ÿ×úBÿ×úDÿ×úJÿ×úLÿ×úNÿ×úRÿ×úTÿ×úVÿ×úXÿ×úZÿ×ú\ÿ×ú^ÿ×ú`ÿ×ûÿ\û ÿ\û&ÿ×û*ÿ×û2ÿ×û4ÿ×û7ÿ×û8ÿìû9ÿ×û:ÿ×û<ÿÃû‰ÿ×û”ÿ×û•ÿ×û–ÿ×û—ÿ×û˜ÿ×ûšÿ×û›ÿìûœÿìûÿìûžÿìûŸÿÃûÈÿ×ûÊÿ×ûÌÿ×ûÎÿ×ûÞÿ×ûàÿ×ûâÿ×ûäÿ×ûÿ×ûÿ×ûÿ×ûÿ×û$ÿ×û&ÿ×û*ÿìû,ÿìû.ÿìû0ÿìû2ÿìû4ÿìû6ÿ×û8ÿÃû:ÿÃûGÿ×ûúÿ×ûüÿ×ûþÿ×ûÿÃûÿ\û ÿ\û_ÿ×ûaÿìûIÿ×ûKÿ×ûMÿ×ûOÿ×ûQÿ×ûSÿ×ûUÿ×ûWÿ×ûYÿ×û[ÿ×û]ÿ×û_ÿ×ûaÿìûcÿìûeÿìûgÿìûiÿìûkÿìûmÿìûoÿÃûqÿÃûsÿÃûÿ×ýÿ\ý ÿ\ý&ÿ×ý*ÿ×ý2ÿ×ý4ÿ×ý7ÿ×ý8ÿìý9ÿ×ý:ÿ×ý<ÿÃý‰ÿ×ý”ÿ×ý•ÿ×ý–ÿ×ý—ÿ×ý˜ÿ×ýšÿ×ý›ÿìýœÿìýÿìýžÿìýŸÿÃýÈÿ×ýÊÿ×ýÌÿ×ýÎÿ×ýÞÿ×ýàÿ×ýâÿ×ýäÿ×ýÿ×ýÿ×ýÿ×ýÿ×ý$ÿ×ý&ÿ×ý*ÿìý,ÿìý.ÿìý0ÿìý2ÿìý4ÿìý6ÿ×ý8ÿÃý:ÿÃýGÿ×ýúÿ×ýüÿ×ýþÿ×ýÿÃýÿ\ý ÿ\ý_ÿ×ýaÿìýIÿ×ýKÿ×ýMÿ×ýOÿ×ýQÿ×ýSÿ×ýUÿ×ýWÿ×ýYÿ×ý[ÿ×ý]ÿ×ý_ÿ×ýaÿìýcÿìýeÿìýgÿìýiÿìýkÿìýmÿìýoÿÃýqÿÃýsÿÃýÿ×ÿÿ\ÿ ÿ\ÿ&ÿ×ÿ*ÿ×ÿ2ÿ×ÿ4ÿ×ÿ7ÿ×ÿ8ÿìÿ9ÿ×ÿ:ÿ×ÿ<ÿÃÿ‰ÿ×ÿ”ÿ×ÿ•ÿ×ÿ–ÿ×ÿ—ÿ×ÿ˜ÿ×ÿšÿ×ÿ›ÿìÿœÿìÿÿìÿžÿìÿŸÿÃÿÈÿ×ÿÊÿ×ÿÌÿ×ÿÎÿ×ÿÞÿ×ÿàÿ×ÿâÿ×ÿäÿ×ÿÿ×ÿÿ×ÿÿ×ÿÿ×ÿ$ÿ×ÿ&ÿ×ÿ*ÿìÿ,ÿìÿ.ÿìÿ0ÿìÿ2ÿìÿ4ÿìÿ6ÿ×ÿ8ÿÃÿ:ÿÃÿGÿ×ÿúÿ×ÿüÿ×ÿþÿ×ÿÿÃÿÿ\ÿ ÿ\ÿ_ÿ×ÿaÿìÿIÿ×ÿKÿ×ÿMÿ×ÿOÿ×ÿQÿ×ÿSÿ×ÿUÿ×ÿWÿ×ÿYÿ×ÿ[ÿ×ÿ]ÿ×ÿ_ÿ×ÿaÿìÿcÿìÿeÿìÿgÿìÿiÿìÿkÿìÿmÿìÿoÿÃÿqÿÃÿsÿÃÿÿ×R R "@E=K=N=O=`ç=éR Rÿ\ ÿ\&ÿ×*ÿ×2ÿ×4ÿ×7ÿ×8ÿì9ÿ×:ÿ×<ÿÉÿ×”ÿוÿ×–ÿ×—ÿטÿךÿ×›ÿìœÿìÿìžÿìŸÿÃÈÿ×Êÿ×Ìÿ×Îÿ×Þÿ×àÿ×âÿ×äÿ×ÿ×ÿ×ÿ×ÿ×$ÿ×&ÿ×*ÿì,ÿì.ÿì0ÿì2ÿì4ÿì6ÿ×8ÿÃ:ÿÃGÿ×úÿ×üÿ×þÿ×ÿÃÿ\ ÿ\_ÿ×aÿìIÿ×Kÿ×Mÿ×Oÿ×Qÿ×Sÿ×Uÿ×Wÿ×Yÿ×[ÿ×]ÿ×_ÿ×aÿìcÿìeÿìgÿìiÿìkÿìmÿìoÿÃqÿÃsÿÃÿ×ÿ\ ÿ\&ÿ×*ÿ×2ÿ×4ÿ×7ÿ×8ÿì9ÿ×:ÿ×<ÿÉÿ×”ÿוÿ×–ÿ×—ÿטÿךÿ×›ÿìœÿìÿìžÿìŸÿÃÈÿ×Êÿ×Ìÿ×Îÿ×Þÿ×àÿ×âÿ×äÿ×ÿ×ÿ×ÿ×ÿ×$ÿ×&ÿ×*ÿì,ÿì.ÿì0ÿì2ÿì4ÿì6ÿ×8ÿÃ:ÿÃGÿ×úÿ×üÿ×þÿ×ÿÃÿ\ ÿ\_ÿ×aÿìIÿ×Kÿ×Mÿ×Oÿ×Qÿ×Sÿ×Uÿ×Wÿ×Yÿ×[ÿ×]ÿ×_ÿ×aÿìcÿìeÿìgÿìiÿìkÿìmÿìoÿÃqÿÃsÿÃÿ×ÿì ÿìÿì ÿìÿ®ÿ®$ÿ×7ÿÃ9ÿì:ÿì;ÿ×<ÿì=ÿì‚ÿ׃ÿׄÿ×…ÿ׆ÿׇÿןÿìÂÿ×Äÿ×Æÿ×$ÿÃ&ÿÃ6ÿì8ÿì:ÿì;ÿì=ÿì?ÿìCÿ× ÿìúÿìüÿìþÿìÿìÿ® ÿ®Xÿ×ÿ×ÿ×!ÿ×#ÿ×%ÿ×'ÿ×)ÿ×+ÿ×-ÿ×/ÿ×1ÿ×3ÿ×oÿìqÿìsÿìÿÃÿ®ÿ®$ÿ×7ÿÃ9ÿì:ÿì;ÿ×<ÿì=ÿì‚ÿ׃ÿׄÿ×…ÿ׆ÿׇÿןÿìÂÿ×Äÿ×Æÿ×$ÿÃ&ÿÃ6ÿì8ÿì:ÿì;ÿì=ÿì?ÿìCÿ× ÿìúÿìüÿìþÿìÿìÿ® ÿ®Xÿ×ÿ×ÿ×!ÿ×#ÿ×%ÿ×'ÿ×)ÿ×+ÿ×-ÿ×/ÿ×1ÿ×3ÿ×oÿìqÿìsÿìÿÃÿ®ÿ®$ÿ×7ÿÃ9ÿì:ÿì;ÿ×<ÿì=ÿì‚ÿ׃ÿׄÿ×…ÿ׆ÿׇÿןÿìÂÿ×Äÿ×Æÿ×$ÿÃ&ÿÃ6ÿì8ÿì:ÿì;ÿì=ÿì?ÿìCÿ× ÿìúÿìüÿìþÿìÿìÿ® ÿ®Xÿ×ÿ×ÿ×!ÿ×#ÿ×%ÿ×'ÿ×)ÿ×+ÿ×-ÿ×/ÿ×1ÿ×3ÿ×oÿìqÿìsÿìÿÃ-{R RDÿ×Fÿ×Gÿ×Hÿ×JÿìRÿ×Tÿ×¢ÿ×£ÿפÿ×¥ÿצÿקÿרÿשÿתÿ׫ÿ׬ÿ×­ÿ×´ÿ×µÿ׶ÿ×·ÿ׸ÿ׺ÿ×Ãÿ×Åÿ×Çÿ×Éÿ×Ëÿ×Íÿ×Ïÿ×Ñÿ×Óÿ×Õÿ××ÿ×Ùÿ×Ûÿ×Ýÿ×ßÿìáÿìãÿìåÿìÿ×ÿ×ÿ×ÿ×Dÿ×Fÿ×Hÿ×R RYÿ×`ÿ×ÿ× ÿ×"ÿ×&ÿ×(ÿ×*ÿ×,ÿ×.ÿ×0ÿ×2ÿ×4ÿ×6ÿ×8ÿ×:ÿ×<ÿ×@ÿ×Bÿ×Dÿ×Jÿ×Lÿ×Nÿ×Rÿ×Tÿ×Vÿ×Xÿ×Zÿ×\ÿ×^ÿ×`ÿ×R RDÿ×Fÿ×Gÿ×Hÿ×JÿìRÿ×Tÿ×¢ÿ×£ÿפÿ×¥ÿצÿקÿרÿשÿתÿ׫ÿ׬ÿ×­ÿ×´ÿ×µÿ׶ÿ×·ÿ׸ÿ׺ÿ×Ãÿ×Åÿ×Çÿ×Éÿ×Ëÿ×Íÿ×Ïÿ×Ñÿ×Óÿ×Õÿ××ÿ×Ùÿ×Ûÿ×Ýÿ×ßÿìáÿìãÿìåÿìÿ×ÿ×ÿ×ÿ×Dÿ×Fÿ×Hÿ×R RYÿ×`ÿ×ÿ× ÿ×"ÿ×&ÿ×(ÿ×*ÿ×,ÿ×.ÿ×0ÿ×2ÿ×4ÿ×6ÿ×8ÿ×:ÿ×<ÿ×@ÿ×Bÿ×Dÿ×Jÿ×Lÿ×Nÿ×Rÿ×Tÿ×Vÿ×Xÿ×Zÿ×\ÿ×^ÿ×`ÿ×R RDÿ×Fÿ×Gÿ×Hÿ×JÿìRÿ×Tÿ×¢ÿ×£ÿפÿ×¥ÿצÿקÿרÿשÿתÿ׫ÿ׬ÿ×­ÿ×´ÿ×µÿ׶ÿ×·ÿ׸ÿ׺ÿ×Ãÿ×Åÿ×Çÿ×Éÿ×Ëÿ×Íÿ×Ïÿ×Ñÿ×Óÿ×Õÿ××ÿ×Ùÿ×Ûÿ×Ýÿ×ßÿìáÿìãÿìåÿìÿ×ÿ×ÿ×ÿ×Dÿ×Fÿ×Hÿ×R RYÿ×`ÿ×ÿ× ÿ×"ÿ×&ÿ×(ÿ×*ÿ×,ÿ×.ÿ×0ÿ×2ÿ×4ÿ×6ÿ×8ÿ×:ÿ×<ÿ×@ÿ×Bÿ×Dÿ×Jÿ×Lÿ×Nÿ×Rÿ×Tÿ×Vÿ×Xÿ×Zÿ×\ÿ×^ÿ×`ÿ×$ÿ…$ÿ®$ÿ…$")$$ÿq$&ÿ×$*ÿ×$2ÿ×$4ÿ×$7)$Dÿ\$Fÿq$Gÿq$Hÿq$Jÿq$Pÿš$Qÿš$Rÿq$Sÿš$Tÿq$Uÿš$Vÿ…$Xÿš$Yÿ×$Zÿ×$[ÿ×$\ÿ×$]ÿ®$‚ÿq$ƒÿq$„ÿq$…ÿq$†ÿq$‡ÿq$‰ÿ×$”ÿ×$•ÿ×$–ÿ×$—ÿ×$˜ÿ×$šÿ×$¢ÿq$£ÿ\$¤ÿ\$¥ÿ\$¦ÿ\$§ÿ\$¨ÿ\$©ÿq$ªÿq$«ÿq$¬ÿq$­ÿq$´ÿq$µÿq$¶ÿq$·ÿq$¸ÿq$ºÿq$»ÿš$¼ÿš$½ÿš$¾ÿš$¿ÿ×$Âÿq$Ãÿ\$Äÿq$Åÿ\$Æÿq$Çÿ\$Èÿ×$Éÿq$Êÿ×$Ëÿq$Ìÿ×$Íÿq$Îÿ×$Ïÿq$Ñÿq$Óÿq$Õÿq$×ÿq$Ùÿq$Ûÿq$Ýÿq$Þÿ×$ßÿq$àÿ×$áÿq$âÿ×$ãÿq$äÿ×$åÿq$úÿš$ÿš$ÿš$ ÿš$ÿ×$ÿq$ÿ×$ÿq$ÿ×$ÿq$ÿ×$ÿq$ÿš$ÿš$ÿ…$!ÿ…$$)$&)$+ÿš$-ÿš$/ÿš$1ÿš$3ÿš$5ÿš$7ÿ×$<ÿ®$>ÿ®$@ÿ®$Cÿq$Dÿ\$Fÿ\$Gÿ×$Hÿq$Jÿ…$ûÿ×$ýÿ×$ÿ®$ÿ®$ÿ®$ÿ…$ ÿ…$Wÿš$Xÿq$Yÿ\$_ÿ×$`ÿq$bÿš$ÿq$ÿ\$ÿq$ ÿ\$!ÿq$"ÿ\$#ÿq$%ÿq$&ÿ\$'ÿq$(ÿ\$)ÿq$*ÿ\$+ÿq$,ÿ\$-ÿq$.ÿ\$/ÿq$0ÿ\$1ÿq$2ÿ\$3ÿq$4ÿ\$6ÿq$8ÿq$:ÿq$<ÿq$@ÿq$Bÿq$Dÿq$Iÿ×$Jÿq$Kÿ×$Lÿq$Mÿ×$Nÿq$Oÿ×$Qÿ×$Rÿq$Sÿ×$Tÿq$Uÿ×$Vÿq$Wÿ×$Xÿq$Yÿ×$Zÿq$[ÿ×$\ÿq$]ÿ×$^ÿq$_ÿ×$`ÿq$bÿš$dÿš$fÿš$hÿš$jÿš$lÿš$nÿš$pÿ×$)%)% )%)% )&ÿ…&ÿ®&ÿ…&")&$ÿq&&ÿ×&*ÿ×&2ÿ×&4ÿ×&7)&Dÿ\&Fÿq&Gÿq&Hÿq&Jÿq&Pÿš&Qÿš&Rÿq&Sÿš&Tÿq&Uÿš&Vÿ…&Xÿš&Yÿ×&Zÿ×&[ÿ×&\ÿ×&]ÿ®&‚ÿq&ƒÿq&„ÿq&…ÿq&†ÿq&‡ÿq&‰ÿ×&”ÿ×&•ÿ×&–ÿ×&—ÿ×&˜ÿ×&šÿ×&¢ÿq&£ÿ\&¤ÿ\&¥ÿ\&¦ÿ\&§ÿ\&¨ÿ\&©ÿq&ªÿq&«ÿq&¬ÿq&­ÿq&´ÿq&µÿq&¶ÿq&·ÿq&¸ÿq&ºÿq&»ÿš&¼ÿš&½ÿš&¾ÿš&¿ÿ×&Âÿq&Ãÿ\&Äÿq&Åÿ\&Æÿq&Çÿ\&Èÿ×&Éÿq&Êÿ×&Ëÿq&Ìÿ×&Íÿq&Îÿ×&Ïÿq&Ñÿq&Óÿq&Õÿq&×ÿq&Ùÿq&Ûÿq&Ýÿq&Þÿ×&ßÿq&àÿ×&áÿq&âÿ×&ãÿq&äÿ×&åÿq&úÿš&ÿš&ÿš& ÿš&ÿ×&ÿq&ÿ×&ÿq&ÿ×&ÿq&ÿ×&ÿq&ÿš&ÿš&ÿ…&!ÿ…&$)&&)&+ÿš&-ÿš&/ÿš&1ÿš&3ÿš&5ÿš&7ÿ×&<ÿ®&>ÿ®&@ÿ®&Cÿq&Dÿ\&Fÿ\&Gÿ×&Hÿq&Jÿ…&ûÿ×&ýÿ×&ÿ®&ÿ®&ÿ®&ÿ…& ÿ…&Wÿš&Xÿq&Yÿ\&_ÿ×&`ÿq&bÿš&ÿq&ÿ\&ÿq& ÿ\&!ÿq&"ÿ\&#ÿq&%ÿq&&ÿ\&'ÿq&(ÿ\&)ÿq&*ÿ\&+ÿq&,ÿ\&-ÿq&.ÿ\&/ÿq&0ÿ\&1ÿq&2ÿ\&3ÿq&4ÿ\&6ÿq&8ÿq&:ÿq&<ÿq&@ÿq&Bÿq&Dÿq&Iÿ×&Jÿq&Kÿ×&Lÿq&Mÿ×&Nÿq&Oÿ×&Qÿ×&Rÿq&Sÿ×&Tÿq&Uÿ×&Vÿq&Wÿ×&Xÿq&Yÿ×&Zÿq&[ÿ×&\ÿq&]ÿ×&^ÿq&_ÿ×&`ÿq&bÿš&dÿš&fÿš&hÿš&jÿš&lÿš&nÿš&pÿ×&)')' )')' )(ÿ…(ÿ®(ÿ…(")($ÿq(&ÿ×(*ÿ×(2ÿ×(4ÿ×(7)(Dÿ\(Fÿq(Gÿq(Hÿq(Jÿq(Pÿš(Qÿš(Rÿq(Sÿš(Tÿq(Uÿš(Vÿ…(Xÿš(Yÿ×(Zÿ×([ÿ×(\ÿ×(]ÿ®(‚ÿq(ƒÿq(„ÿq(…ÿq(†ÿq(‡ÿq(‰ÿ×(”ÿ×(•ÿ×(–ÿ×(—ÿ×(˜ÿ×(šÿ×(¢ÿq(£ÿ\(¤ÿ\(¥ÿ\(¦ÿ\(§ÿ\(¨ÿ\(©ÿq(ªÿq(«ÿq(¬ÿq(­ÿq(´ÿq(µÿq(¶ÿq(·ÿq(¸ÿq(ºÿq(»ÿš(¼ÿš(½ÿš(¾ÿš(¿ÿ×(Âÿq(Ãÿ\(Äÿq(Åÿ\(Æÿq(Çÿ\(Èÿ×(Éÿq(Êÿ×(Ëÿq(Ìÿ×(Íÿq(Îÿ×(Ïÿq(Ñÿq(Óÿq(Õÿq(×ÿq(Ùÿq(Ûÿq(Ýÿq(Þÿ×(ßÿq(àÿ×(áÿq(âÿ×(ãÿq(äÿ×(åÿq(úÿš(ÿš(ÿš( ÿš(ÿ×(ÿq(ÿ×(ÿq(ÿ×(ÿq(ÿ×(ÿq(ÿš(ÿš(ÿ…(!ÿ…($)(&)(+ÿš(-ÿš(/ÿš(1ÿš(3ÿš(5ÿš(7ÿ×(<ÿ®(>ÿ®(@ÿ®(Cÿq(Dÿ\(Fÿ\(Gÿ×(Hÿq(Jÿ…(ûÿ×(ýÿ×(ÿ®(ÿ®(ÿ®(ÿ…( ÿ…(Wÿš(Xÿq(Yÿ\(_ÿ×(`ÿq(bÿš(ÿq(ÿ\(ÿq( ÿ\(!ÿq("ÿ\(#ÿq(%ÿq(&ÿ\('ÿq((ÿ\()ÿq(*ÿ\(+ÿq(,ÿ\(-ÿq(.ÿ\(/ÿq(0ÿ\(1ÿq(2ÿ\(3ÿq(4ÿ\(6ÿq(8ÿq(:ÿq(<ÿq(@ÿq(Bÿq(Dÿq(Iÿ×(Jÿq(Kÿ×(Lÿq(Mÿ×(Nÿq(Oÿ×(Qÿ×(Rÿq(Sÿ×(Tÿq(Uÿ×(Vÿq(Wÿ×(Xÿq(Yÿ×(Zÿq([ÿ×(\ÿq(]ÿ×(^ÿq(_ÿ×(`ÿq(bÿš(dÿš(fÿš(hÿš(jÿš(lÿš(nÿš(pÿ×()*ÿ×*ÿ×*$ÿì*‚ÿì*ƒÿì*„ÿì*…ÿì*†ÿì*‡ÿì*Âÿì*Äÿì*Æÿì*Cÿì*ÿ×* ÿ×*Xÿì*ÿì*ÿì*!ÿì*#ÿì*%ÿì*'ÿì*)ÿì*+ÿì*-ÿì*/ÿì*1ÿì*3ÿì,ÿ×,ÿ×,$ÿì,‚ÿì,ƒÿì,„ÿì,…ÿì,†ÿì,‡ÿì,Âÿì,Äÿì,Æÿì,Cÿì,ÿ×, ÿ×,Xÿì,ÿì,ÿì,!ÿì,#ÿì,%ÿì,'ÿì,)ÿì,+ÿì,-ÿì,/ÿì,1ÿì,3ÿì.ÿ×.ÿ×.$ÿì.‚ÿì.ƒÿì.„ÿì.…ÿì.†ÿì.‡ÿì.Âÿì.Äÿì.Æÿì.Cÿì.ÿ×. ÿ×.Xÿì.ÿì.ÿì.!ÿì.#ÿì.%ÿì.'ÿì.)ÿì.+ÿì.-ÿì./ÿì.1ÿì.3ÿì0ÿ×0ÿ×0$ÿì0‚ÿì0ƒÿì0„ÿì0…ÿì0†ÿì0‡ÿì0Âÿì0Äÿì0Æÿì0Cÿì0ÿ×0 ÿ×0Xÿì0ÿì0ÿì0!ÿì0#ÿì0%ÿì0'ÿì0)ÿì0+ÿì0-ÿì0/ÿì01ÿì03ÿì2ÿ×2ÿ×2$ÿì2‚ÿì2ƒÿì2„ÿì2…ÿì2†ÿì2‡ÿì2Âÿì2Äÿì2Æÿì2Cÿì2ÿ×2 ÿ×2Xÿì2ÿì2ÿì2!ÿì2#ÿì2%ÿì2'ÿì2)ÿì2+ÿì2-ÿì2/ÿì21ÿì23ÿì4ÿ×4ÿ×4$ÿì4‚ÿì4ƒÿì4„ÿì4…ÿì4†ÿì4‡ÿì4Âÿì4Äÿì4Æÿì4Cÿì4ÿ×4 ÿ×4Xÿì4ÿì4ÿì4!ÿì4#ÿì4%ÿì4'ÿì4)ÿì4+ÿì4-ÿì4/ÿì41ÿì43ÿì6ÿš6ÿš6")6$ÿ®6&ÿì6*ÿì62ÿì64ÿì6Dÿ×6Fÿ×6Gÿ×6Hÿ×6Jÿì6Pÿì6Qÿì6Rÿ×6Sÿì6Tÿ×6Uÿì6Vÿì6Xÿì6‚ÿ®6ƒÿ®6„ÿ®6…ÿ®6†ÿ®6‡ÿ®6‰ÿì6”ÿì6•ÿì6–ÿì6—ÿì6˜ÿì6šÿì6¢ÿ×6£ÿ×6¤ÿ×6¥ÿ×6¦ÿ×6§ÿ×6¨ÿ×6©ÿ×6ªÿ×6«ÿ×6¬ÿ×6­ÿ×6´ÿ×6µÿ×6¶ÿ×6·ÿ×6¸ÿ×6ºÿ×6»ÿì6¼ÿì6½ÿì6¾ÿì6Âÿ®6Ãÿ×6Äÿ®6Åÿ×6Æÿ®6Çÿ×6Èÿì6Éÿ×6Êÿì6Ëÿ×6Ìÿì6Íÿ×6Îÿì6Ïÿ×6Ñÿ×6Óÿ×6Õÿ×6×ÿ×6Ùÿ×6Ûÿ×6Ýÿ×6Þÿì6ßÿì6àÿì6áÿì6âÿì6ãÿì6äÿì6åÿì6úÿì6ÿì6ÿì6 ÿì6ÿì6ÿ×6ÿì6ÿ×6ÿì6ÿ×6ÿì6ÿ×6ÿì6ÿì6ÿì6!ÿì6+ÿì6-ÿì6/ÿì61ÿì63ÿì65ÿì6Cÿ®6Dÿ×6Fÿ×6Gÿì6Hÿ×6Jÿì6ÿš6 ÿš6Wÿì6Xÿ®6Yÿ×6_ÿì6`ÿ×6bÿì6ÿ®6ÿ×6ÿ®6 ÿ×6!ÿ®6"ÿ×6#ÿ®6%ÿ®6&ÿ×6'ÿ®6(ÿ×6)ÿ®6*ÿ×6+ÿ®6,ÿ×6-ÿ®6.ÿ×6/ÿ®60ÿ×61ÿ®62ÿ×63ÿ®64ÿ×66ÿ×68ÿ×6:ÿ×6<ÿ×6@ÿ×6Bÿ×6Dÿ×6Iÿì6Jÿ×6Kÿì6Lÿ×6Mÿì6Nÿ×6Oÿì6Qÿì6Rÿ×6Sÿì6Tÿ×6Uÿì6Vÿ×6Wÿì6Xÿ×6Yÿì6Zÿ×6[ÿì6\ÿ×6]ÿì6^ÿ×6_ÿì6`ÿ×6bÿì6dÿì6fÿì6hÿì6jÿì6lÿì6nÿì7R7 R7ÿ®7ÿ®7")7R7ÿ®7 R7 ÿ®8ÿ…8ÿ…8")8$ÿ…8&ÿ×8*ÿ×82ÿ×84ÿ×8Dÿš8Fÿš8Gÿš8Hÿš8Jÿ×8PÿÃ8QÿÃ8Rÿš8SÿÃ8Tÿš8UÿÃ8Vÿ®8XÿÃ8]ÿ×8‚ÿ…8ƒÿ…8„ÿ…8…ÿ…8†ÿ…8‡ÿ…8‰ÿ×8”ÿ×8•ÿ×8–ÿ×8—ÿ×8˜ÿ×8šÿ×8¢ÿš8£ÿš8¤ÿš8¥ÿš8¦ÿš8§ÿš8¨ÿš8©ÿš8ªÿš8«ÿš8¬ÿš8­ÿš8´ÿš8µÿš8¶ÿš8·ÿš8¸ÿš8ºÿš8»ÿÃ8¼ÿÃ8½ÿÃ8¾ÿÃ8Âÿ…8Ãÿš8Äÿ…8Åÿš8Æÿ…8Çÿš8Èÿ×8Éÿš8Êÿ×8Ëÿš8Ìÿ×8Íÿš8Îÿ×8Ïÿš8Ñÿš8Óÿš8Õÿš8×ÿš8Ùÿš8Ûÿš8Ýÿš8Þÿ×8ßÿ×8àÿ×8áÿ×8âÿ×8ãÿ×8äÿ×8åÿ×8úÿÃ8ÿÃ8ÿÃ8 ÿÃ8ÿ×8ÿš8ÿ×8ÿš8ÿ×8ÿš8ÿ×8ÿš8ÿÃ8ÿÃ8ÿ®8!ÿ®8+ÿÃ8-ÿÃ8/ÿÃ81ÿÃ83ÿÃ85ÿÃ8<ÿ×8>ÿ×8@ÿ×8Cÿ…8Dÿš8Fÿš8Gÿ×8Hÿš8Jÿ®8ÿ…8 ÿ…8WÿÃ8Xÿ…8Yÿš8_ÿ×8`ÿš8bÿÃ8ÿ…8ÿš8ÿ…8 ÿš8!ÿ…8"ÿš8#ÿ…8%ÿ…8&ÿš8'ÿ…8(ÿš8)ÿ…8*ÿš8+ÿ…8,ÿš8-ÿ…8.ÿš8/ÿ…80ÿš81ÿ…82ÿš83ÿ…84ÿš86ÿš88ÿš8:ÿš8<ÿš8@ÿš8Bÿš8Dÿš8Iÿ×8Jÿš8Kÿ×8Lÿš8Mÿ×8Nÿš8Oÿ×8Qÿ×8Rÿš8Sÿ×8Tÿš8Uÿ×8Vÿš8Wÿ×8Xÿš8Yÿ×8Zÿš8[ÿ×8\ÿš8]ÿ×8^ÿš8_ÿ×8`ÿš8bÿÃ8dÿÃ8fÿÃ8hÿÃ8jÿÃ8lÿÃ8nÿÃ9R9 R9ÿ®9ÿ®9")9R9ÿ®9 R9 ÿ®:ÿ…:ÿ…:"):$ÿ…:&ÿ×:*ÿ×:2ÿ×:4ÿ×:Dÿš:Fÿš:Gÿš:Hÿš:Jÿ×:PÿÃ:QÿÃ:Rÿš:SÿÃ:Tÿš:UÿÃ:Vÿ®:XÿÃ:]ÿ×:‚ÿ…:ƒÿ…:„ÿ…:…ÿ…:†ÿ…:‡ÿ…:‰ÿ×:”ÿ×:•ÿ×:–ÿ×:—ÿ×:˜ÿ×:šÿ×:¢ÿš:£ÿš:¤ÿš:¥ÿš:¦ÿš:§ÿš:¨ÿš:©ÿš:ªÿš:«ÿš:¬ÿš:­ÿš:´ÿš:µÿš:¶ÿš:·ÿš:¸ÿš:ºÿš:»ÿÃ:¼ÿÃ:½ÿÃ:¾ÿÃ:Âÿ…:Ãÿš:Äÿ…:Åÿš:Æÿ…:Çÿš:Èÿ×:Éÿš:Êÿ×:Ëÿš:Ìÿ×:Íÿš:Îÿ×:Ïÿš:Ñÿš:Óÿš:Õÿš:×ÿš:Ùÿš:Ûÿš:Ýÿš:Þÿ×:ßÿ×:àÿ×:áÿ×:âÿ×:ãÿ×:äÿ×:åÿ×:úÿÃ:ÿÃ:ÿÃ: ÿÃ:ÿ×:ÿš:ÿ×:ÿš:ÿ×:ÿš:ÿ×:ÿš:ÿÃ:ÿÃ:ÿ®:!ÿ®:+ÿÃ:-ÿÃ:/ÿÃ:1ÿÃ:3ÿÃ:5ÿÃ:<ÿ×:>ÿ×:@ÿ×:Cÿ…:Dÿš:Fÿš:Gÿ×:Hÿš:Jÿ®:ÿ…: ÿ…:WÿÃ:Xÿ…:Yÿš:_ÿ×:`ÿš:bÿÃ:ÿ…:ÿš:ÿ…: ÿš:!ÿ…:"ÿš:#ÿ…:%ÿ…:&ÿš:'ÿ…:(ÿš:)ÿ…:*ÿš:+ÿ…:,ÿš:-ÿ…:.ÿš:/ÿ…:0ÿš:1ÿ…:2ÿš:3ÿ…:4ÿš:6ÿš:8ÿš::ÿš:<ÿš:@ÿš:Bÿš:Dÿš:Iÿ×:Jÿš:Kÿ×:Lÿš:Mÿ×:Nÿš:Oÿ×:Qÿ×:Rÿš:Sÿ×:Tÿš:Uÿ×:Vÿš:Wÿ×:Xÿš:Yÿ×:Zÿš:[ÿ×:\ÿš:]ÿ×:^ÿš:_ÿ×:`ÿš:bÿÃ:dÿÃ:fÿÃ:hÿÃ:jÿÃ:lÿÃ:nÿÃ;&ÿì;*ÿì;2ÿì;4ÿì;‰ÿì;”ÿì;•ÿì;–ÿì;—ÿì;˜ÿì;šÿì;Èÿì;Êÿì;Ìÿì;Îÿì;Þÿì;àÿì;âÿì;äÿì;ÿì;ÿì;ÿì;ÿì;Gÿì;_ÿì;Iÿì;Kÿì;Mÿì;Oÿì;Qÿì;Sÿì;Uÿì;Wÿì;Yÿì;[ÿì;]ÿì;_ÿì=&ÿì=*ÿì=2ÿì=4ÿì=‰ÿì=”ÿì=•ÿì=–ÿì=—ÿì=˜ÿì=šÿì=Èÿì=Êÿì=Ìÿì=Îÿì=Þÿì=àÿì=âÿì=äÿì=ÿì=ÿì=ÿì=ÿì=Gÿì=_ÿì=Iÿì=Kÿì=Mÿì=Oÿì=Qÿì=Sÿì=Uÿì=Wÿì=Yÿì=[ÿì=]ÿì=_ÿì?&ÿì?*ÿì?2ÿì?4ÿì?‰ÿì?”ÿì?•ÿì?–ÿì?—ÿì?˜ÿì?šÿì?Èÿì?Êÿì?Ìÿì?Îÿì?Þÿì?àÿì?âÿì?äÿì?ÿì?ÿì?ÿì?ÿì?Gÿì?_ÿì?Iÿì?Kÿì?Mÿì?Oÿì?Qÿì?Sÿì?Uÿì?Wÿì?Yÿì?[ÿì?]ÿì?_ÿìCÿqC ÿqC&ÿ×C*ÿ×C- C2ÿ×C4ÿ×C7ÿqC9ÿ®C:ÿ®C<ÿ…C‰ÿ×C”ÿ×C•ÿ×C–ÿ×C—ÿ×C˜ÿ×Cšÿ×CŸÿ…CÈÿ×CÊÿ×CÌÿ×CÎÿ×CÞÿ×Càÿ×Câÿ×Cäÿ×Cÿ×Cÿ×Cÿ×Cÿ×C$ÿqC&ÿqC6ÿ®C8ÿ…C:ÿ…CGÿ×Cúÿ®Cüÿ®Cþÿ®Cÿ…CÿqC ÿqC_ÿ×CIÿ×CKÿ×CMÿ×COÿ×CQÿ×CSÿ×CUÿ×CWÿ×CYÿ×C[ÿ×C]ÿ×C_ÿ×Coÿ…Cqÿ…Csÿ…CÿqDÿìD ÿìDÿìD ÿìE-{Gÿ®Gÿ®G$ÿ×G7ÿÃG9ÿìG:ÿìG;ÿ×G<ÿìG=ÿìG‚ÿ×Gƒÿ×G„ÿ×G…ÿ×G†ÿ×G‡ÿ×GŸÿìGÂÿ×GÄÿ×GÆÿ×G$ÿÃG&ÿÃG6ÿìG8ÿìG:ÿìG;ÿìG=ÿìG?ÿìGCÿ×G ÿìGúÿìGüÿìGþÿìGÿìGÿ®G ÿ®GXÿ×Gÿ×Gÿ×G!ÿ×G#ÿ×G%ÿ×G'ÿ×G)ÿ×G+ÿ×G-ÿ×G/ÿ×G1ÿ×G3ÿ×GoÿìGqÿìGsÿìGÿÃVÿqV ÿqVfÿ×Vmÿ×VqÿqVrÿ…Vsÿ×Vuÿ®Vxÿ…VÿqV ÿqVTÿ…[ÿ®[ÿ®[Vÿ×[_ÿ×[bÿ×[dÿì[iÿ×[pÿì[qÿÃ[rÿì[tÿ×[uÿì[xÿì[ˆÿì[ÿ®[ ÿ®[Tÿì\ÿ…\ÿ…\Vÿ…\_ÿ…\bÿ…\fÿ×\iÿ…\mÿ×\sÿÃ\vÿì\yÿš\zÿ®\{ÿÃ\|ÿÃ\}ÿÃ\~ÿš\ÿÃ\‚ÿ®\„ÿÃ\†ÿÃ\‡ÿÃ\‰ÿÃ\Œÿš\Žÿš\ÿš\ÿš\’ÿÃ\“ÿš\•ÿÃ\–ÿÃ\˜ÿÃ\™ÿš\šÿÃ\›ÿÃ\ÿ…\ ÿ…\!ÿì]qÿ×]rÿì]xÿì]Tÿì^ÿ×^ ÿ×^ÿ×^ ÿ×_ÿq_ ÿq_fÿ×_mÿ×_qÿq_rÿ…_sÿ×_uÿ®_xÿ…_ÿq_ ÿq_Tÿ…`ÿ®`ÿ®`Vÿ×`_ÿ×`bÿ×`iÿ×`tÿ×`ÿ®` ÿ®aÿ…aÿ®aÿ…aVÿ\a_ÿ\abÿ\afÿÃaiÿ\amÿÃasÿšavÿÃayÿqazÿša{ÿša|ÿ®a}ÿša~ÿqa€ÿ×aÿÃa‚ÿša„ÿša†ÿ®a‡ÿša‰ÿšaŠÿ×aŒÿqaŽÿšaÿqaÿqa’ÿša“ÿqa”ÿ×a•ÿša–ÿša˜ÿša™ÿqašÿša›ÿšaÿ®aÿ®aÿ®aÿ…a ÿ…a!ÿÃaSÿ×bÿqb ÿqbfÿ×bmÿ×bqÿqbrÿ…bsÿ×buÿ®bxÿ…bÿqb ÿqbTÿ…dfÿìdmÿìdsÿÃfÿ®fÿ®fVÿ×f_ÿ×fbÿ×fdÿìfiÿ×fpÿìfqÿÃfrÿìftÿ×fuÿìfxÿìfˆÿìfÿ®f ÿ®fTÿìhfÿ×hmÿ×hsÿÃhÿìh‘ÿìiÿqi ÿqifÿ×imÿ×iqÿqirÿ…isÿ×iuÿ®ixÿ…iÿqi ÿqiTÿ…mÿ®mÿ®mVÿ×m_ÿ×mbÿ×mdÿìmiÿ×mpÿìmqÿÃmrÿìmtÿ×muÿìmxÿìmˆÿìmÿ®m ÿ®mTÿìoþöoþöoVÿšo_ÿšobÿšodÿìoiÿšotÿ×oˆÿ×oþöo þöqÿ…qÿ®qÿ…qVÿ\q_ÿ\qbÿ\qfÿÃqiÿ\qmÿÃqsÿšqvÿÃqyÿqqzÿšq{ÿšq|ÿ®q}ÿšq~ÿqq€ÿ×qÿÃq‚ÿšq„ÿšq†ÿ®q‡ÿšq‰ÿšqŠÿ×qŒÿqqŽÿšqÿqqÿqq’ÿšq“ÿqq”ÿ×q•ÿšq–ÿšq˜ÿšq™ÿqqšÿšq›ÿšqÿ®qÿ®qÿ®qÿ…q ÿ…q!ÿÃqSÿ×rÿ…rÿ…rVÿ…r_ÿ…rbÿ…rfÿ×riÿ…rmÿ×rsÿÃrvÿìryÿšrzÿ®r{ÿÃr|ÿÃr}ÿÃr~ÿšrÿÃr‚ÿ®r„ÿÃr†ÿÃr‡ÿÃr‰ÿÃrŒÿšrŽÿšrÿšrÿšr’ÿÃr“ÿšr•ÿÃr–ÿÃr˜ÿÃr™ÿšršÿÃr›ÿÃrÿ…r ÿ…r!ÿìsÿšsÿšsVÿ×s_ÿ×sbÿ×sdÿÃsiÿ×spÿìsqÿ®srÿÃstÿìsxÿÃsˆÿìsÿšs ÿšsTÿÃtfÿ×tmÿ×tsÿÃtÿìt‘ÿìuÿ…uÿ…uVÿ®u_ÿ®ubÿ®ufÿìuiÿ®umÿìuÿ…u ÿ…vqÿ×vrÿìvxÿìvTÿìxÿ…xÿ…xVÿ…x_ÿ…xbÿ…xfÿ×xiÿ…xmÿ×xsÿÃxvÿìxyÿšxzÿ®x{ÿÃx|ÿÃx}ÿÃx~ÿšxÿÃx‚ÿ®x„ÿÃx†ÿÃx‡ÿÃx‰ÿÃxŒÿšxŽÿšxÿšxÿšx’ÿÃx“ÿšx•ÿÃx–ÿÃx˜ÿÃx™ÿšxšÿÃx›ÿÃxÿ…x ÿ…x!ÿìyˆ){ÿì{ ÿì{ÿì{ ÿì|ÿ®| ÿ®|ÿì|‘ÿì|ÿ®| ÿ®~ˆ)€ÿ®€ÿ®€ˆÿì€ÿ®€ ÿ®ƒÿšƒyÿ׃~ÿ׃ÿ׃Œÿ׃ÿ׃ÿ׃ÿ׃‘ÿ׃“ÿ׃™ÿ׃ÿšƒÿšƒÿš„ÿì„ ÿì„ÿì„ ÿì…ÿ×…ÿ×…ÿ×… ÿ׆ÿ®† ÿ®†ÿ솑ÿì†ÿ®† ÿ®‡yÿׇ~ÿׇŒÿׇÿׇÿׇ“ÿׇ™ÿ׈ÿ…ˆ ÿ…ˆyÿìˆ~ÿ숀ÿ׈Šÿ׈Œÿìˆÿ׈ÿìˆÿ숑ÿ׈“ÿ숙ÿìˆÿ…ˆ ÿ…Šÿ®Šÿ®ŠˆÿìŠÿ®Š ÿ®ŒÿìŒ ÿ쌀ÿ׌Šÿ׌ÿìŒ ÿìŽÿìŽ ÿ쎀ÿ׎Šÿ׎ÿìŽ ÿìÿìÿìÿì ÿì“ÿì“ ÿì“€ÿדŠÿדÿì“ ÿì”ÿÔÿ×”ÿÔyÿ×”~ÿ×”ÿ×”Œÿ×”ÿ×”ÿ×”“ÿ×”™ÿ×”ÿ×”ÿ×”ÿ×”ÿÔ ÿ×ÿ×— ÿ×—ÿ×— ÿ×™ÿì™ ÿ와ÿ×™Šÿ×™ÿì™ ÿìÿ® ÿ®ÿ…¦ÿ…¨ÿ×¼ÿš½ÿ×ÁÿšÄÿ…Üÿ×Ýÿ×áÿ×äÿ×öÿ×ÿ® ÿ®nÿ®|ÿš€ÿ®‚ÿ®—ÿ®›ÿ®§ÿ®©ÿ…ªÿ×µÿš¶ÿ×·ÿš¸ÿ×¹ÿšºÿ×½ÿ…¾ÿ׿ÿšÀÿ×ÁÿšÂÿ×ÔÿšÕÿ×÷ÿ×øÿ×ùÿ×úÿ×ûÿ×üÿ×ýÿšþÿ×ÿ® ÿšÿÃÿšÿÃÿ…ÿמÿ…žÿ®žÿ…žŸÿמ¤ÿšžªÿqž®ÿšžµÿšž¸ÿמ»ÿמ¼)ž¾ÿ®žÌÿšžÍÿšžÎÿ…žÏÿqžÐÿמÑÿמÒÿšžÓÿšžÔÿšžÕÿ…žÖÿšž×ÿšžØÿqžÙÿšžÚÿšžÛÿqžÜÿ®žÝÿ®žÞÿqžßÿמàÿšžáÿšžâÿšžãÿšžäÿ®žåÿšžæÿšžçÿמèÿšžéÿÞêÿqžìÿšžíÿqžîÿ…žòÿ…žóÿšžõÿšžöÿ®ž÷ÿšžùÿšžÿ®žÿ®žÿ®žÿ…ž ÿ…žjÿqžkÿšžlÿמmÿמqÿšžrÿqžsÿ…žuÿšžwÿšžyÿšž}ÿšž~ÿמÿqžÿמƒÿמ„ÿמ…ÿqž†ÿמ‡ÿqžˆÿמ‰ÿqžŠÿמ‹ÿמŒÿמÿqž–ÿšžšÿšžžÿšž ÿמ¢ÿמ¤ÿšž¦ÿšžªÿ®ž¬ÿšž®ÿšž°ÿšž±ÿמ²ÿqž³ÿמ´ÿqžµ)ž¶ÿ®ž¸ÿ®žºÿ®ž¼ÿמ¾ÿ®žÀÿšžÂÿšžÄÿšžÅÿšžÆÿqžÇÿšžÈÿqžËÿמÍÿšžÎÿšžÏÿ…žÑÿšžÓÿšžÕÿšž×ÿšžÙÿqžÛÿqžÝÿqžàÿqžæÿמèÿמêÿÞìÿšžîÿšžïÿמðÿqžñÿמòÿqžóÿמôÿqžöÿמøÿ®žúÿ®žüÿ®žþÿšžÿšžÿšžÿמÿמ ÿqž ÿqž ÿqž ÿqžÿšžÿšžÿšžÿ…žÿšžÿמÿqžÿ®žÿqžÿšžÿ…ŸŸÿן¸ÿן»ÿן¾ÿןáÿןlÿן~ÿן„ÿן†ÿןˆÿןŠÿןŒÿן±ÿן³ÿןÀÿןÂÿןÅÿןÇÿןÕÿןïÿןñÿןóÿןþÿן ÿן ÿןÿןÿןÿ× ÿ× ÿפÿ®¤ ÿ®¤ÿ…¤¦ÿ…¤¨ÿפ¼ÿš¤½ÿפÁÿš¤Äÿ…¤ÜÿפÝÿפáÿפäÿפöÿפÿ®¤ ÿ®¤nÿ®¤|ÿš¤€ÿ®¤‚ÿ®¤—ÿ®¤›ÿ®¤§ÿ®¤©ÿ…¤ªÿפµÿš¤¶ÿפ·ÿš¤¸ÿפ¹ÿš¤ºÿפ½ÿ…¤¾ÿפ¿ÿš¤ÀÿפÁÿš¤ÂÿפÔÿš¤Õÿפ÷ÿפøÿפùÿפúÿפûÿפüÿפýÿš¤þÿפÿ®¤ ÿš¤ÿäÿš¤ÿäÿ…¤ÿ×¥ÿ®¥ ÿ®¥ÿ…¥¦ÿ…¥¨ÿ×¥¼ÿš¥½ÿ×¥Áÿš¥Äÿ…¥Üÿ×¥Ýÿ×¥áÿ×¥äÿ×¥öÿ×¥ÿ®¥ ÿ®¥nÿ®¥|ÿš¥€ÿ®¥‚ÿ®¥—ÿ®¥›ÿ®¥§ÿ®¥©ÿ…¥ªÿ×¥µÿš¥¶ÿ×¥·ÿš¥¸ÿ×¥¹ÿš¥ºÿ×¥½ÿ…¥¾ÿ×¥¿ÿš¥Àÿ×¥Áÿš¥Âÿ×¥Ôÿš¥Õÿ×¥÷ÿ×¥øÿ×¥ùÿ×¥úÿ×¥ûÿ×¥üÿ×¥ýÿš¥þÿ×¥ÿ®¥ ÿš¥ÿÃ¥ÿš¥ÿÃ¥ÿ…¥ÿצÿ®¦ ÿ®¦ÿ…¦¦ÿ…¦¨ÿצ¼ÿš¦½ÿצÁÿš¦Äÿ…¦ÜÿצÝÿצáÿצäÿצöÿצÿ®¦ ÿ®¦nÿ®¦|ÿš¦€ÿ®¦‚ÿ®¦—ÿ®¦›ÿ®¦§ÿ®¦©ÿ…¦ªÿצµÿš¦¶ÿצ·ÿš¦¸ÿצ¹ÿš¦ºÿצ½ÿ…¦¾ÿצ¿ÿš¦ÀÿצÁÿš¦ÂÿצÔÿš¦Õÿצ÷ÿצøÿצùÿצúÿצûÿצüÿצýÿš¦þÿצÿ®¦ ÿš¦ÿæÿš¦ÿæÿ…¦ÿקŸÿק¸ÿק»ÿק¾ÿקÁÿקáÿקlÿק|ÿק~ÿק„ÿק†ÿקˆÿקŠÿקŒÿק±ÿק³ÿק¿ÿקÀÿקÁÿקÂÿקÅÿš§Çÿš§ÔÿקÕÿקïÿקñÿקóÿקýÿקþÿק ÿק ÿקÿקÿקÿקÿì¨ÿ…¨ÿ…¨Ÿÿ쨤ÿš¨ªÿq¨®ÿš¨µÿš¨¸ÿ쨻ÿ쨾ÿèÉÿì¨Îÿ®¨ÏÿרÕÿ®¨ØÿרÛÿרÞÿרáÿרêÿרëf¨íÿרîÿì¨òÿ®¨ôf¨ÿ…¨ ÿ…¨jÿרlÿì¨rÿq¨sÿ®¨~ÿì¨ÿר„ÿ쨅ÿר†ÿ쨇ÿרˆÿ쨉ÿרŠÿ쨌ÿì¨ÿר˜f¨¨f¨±ÿ쨲ÿר³ÿ쨴ÿרÀÿרÂÿרÅÿרÆÿèÇÿרÈÿèÎÿš¨Ïÿ®¨ÕÿרÙÿq¨Ûÿq¨Ýÿq¨àÿרïÿì¨ðÿרñÿì¨òÿרóÿì¨ôÿרþÿר ÿq¨ ÿר ÿq¨ ÿרÿš¨ÿ®¨ÿì¨ÿרÿרÿš¨ÿ®ªÿqª ÿqªÿšª¦ÿšª¼ÿqª¾ÿתÁÿšªÄÿšªÜÿתáÿתäÿתÿqª ÿqªnÿת|ÿšª€ÿ®ª‚ÿ®ª—ÿת›ÿת§ÿת©ÿšªªÿתµÿqª¶ÿת·ÿ…ª¹ÿ…ª½ÿšª¾ÿת¿ÿšªÀÿתÁÿšªÂÿתÅÿšªÇÿšªÔÿšªÕÿתáÿתãÿתýÿšªþÿתÿת ÿqªÿתÿqªÿתÿšªÿ׫ÿ׫ ÿ׫ªÿì«Áÿ׫ÿ׫ ÿ׫rÿì«|ÿ׫¿ÿ׫Áÿ׫Åÿ׫Çÿ׫Ôÿ׫Ùÿì«Ûÿì«Ýÿì«ýÿ׬ÿ®¬ÿ®¬ÿ®¬ ÿ®¬€ÿ쬂ÿ쬷ÿ쬹ÿì¬ ÿ׬ÿ×­ÿ…­ÿ®­ÿ…­Ÿÿ×­¤ÿš­ªÿq­®ÿš­µÿš­¸ÿ×­»ÿ×­¼)­¾ÿ®­Ìÿš­Íÿš­Îÿ…­Ïÿq­Ðÿ×­Ñÿ×­Òÿš­Óÿš­Ôÿš­Õÿ…­Öÿš­×ÿš­Øÿq­Ùÿš­Úÿš­Ûÿq­Üÿ®­Ýÿ®­Þÿq­ßÿ×­àÿš­áÿš­âÿš­ãÿš­äÿ®­åÿš­æÿš­çÿ×­èÿš­éÿíêÿq­ìÿš­íÿq­îÿ…­òÿ…­óÿš­õÿš­öÿ®­÷ÿš­ùÿš­ÿ®­ÿ®­ÿ®­ÿ…­ ÿ…­jÿq­kÿš­lÿ×­mÿ×­qÿš­rÿq­sÿ…­uÿš­wÿš­yÿš­}ÿš­~ÿ×­ÿq­ÿ×­ƒÿ×­„ÿ×­…ÿq­†ÿ×­‡ÿq­ˆÿ×­‰ÿq­Šÿ×­‹ÿ×­Œÿ×­ÿq­–ÿš­šÿš­žÿš­ ÿ×­¢ÿ×­¤ÿš­¦ÿš­ªÿ®­¬ÿš­®ÿš­°ÿš­±ÿ×­²ÿq­³ÿ×­´ÿq­µ)­¶ÿ®­¸ÿ®­ºÿ®­¼ÿ×­¾ÿ®­Àÿš­Âÿš­Äÿš­Åÿš­Æÿq­Çÿš­Èÿq­Ëÿ×­Íÿš­Îÿš­Ïÿ…­Ñÿš­Óÿš­Õÿš­×ÿš­Ùÿq­Ûÿq­Ýÿq­àÿq­æÿ×­èÿ×­êÿíìÿš­îÿš­ïÿ×­ðÿq­ñÿ×­òÿq­óÿ×­ôÿq­öÿ×­øÿ®­úÿ®­üÿ®­þÿš­ÿš­ÿš­ÿ×­ÿ×­ ÿq­ ÿq­ ÿq­ ÿq­ÿš­ÿš­ÿš­ÿ…­ÿš­ÿ×­ÿq­ÿ®­ÿq­ÿš­ÿ…®£á®ê)®ÿ×®ÿ×°Ÿÿ×°¸ÿ×°»ÿ×°¾ÿ×°Áÿ×°áÿ×°lÿ×°|ÿ×°~ÿ×°„ÿ×°†ÿ×°ˆÿ×°Šÿ×°Œÿ×°±ÿ×°³ÿ×°¿ÿ×°Àÿ×°Áÿ×°Âÿ×°Åÿš°Çÿš°Ôÿ×°Õÿ×°ïÿ×°ñÿ×°óÿ×°ýÿ×°þÿ×° ÿ×° ÿ×°ÿ×°ÿ×°ÿ×°ÿì±ÿ®±ÿ®±ÿ®± ÿ®±€ÿ챂ÿì±·ÿì±¹ÿì± ÿ×±ÿ×´Ÿÿ×´¸ÿ×´»ÿ×´¾ÿ×´Áÿ×´áÿ×´lÿ×´|ÿ×´~ÿ×´„ÿ×´†ÿ×´ˆÿ×´Šÿ×´Œÿ×´±ÿ×´³ÿ×´¿ÿ×´Àÿ×´Áÿ×´Âÿ×´Åÿš´Çÿš´Ôÿ×´Õÿ×´ïÿ×´ñÿ×´óÿ×´ýÿ×´þÿ×´ ÿ×´ ÿ×´ÿ×´ÿ×´ÿ×´ÿì¸ÿ®¸ÿ®¸ÿ츤ÿ׸¦ÿ츨ÿ׸ªÿ׸®ÿ׸°ÿ׸±ÿ층ÿ׸¼ÿø½ÿ׸¿ÿ׸Áÿ׸Äÿì¸Çÿì¸Îÿì¸Õÿì¸òÿì¸ÿ®¸ ÿ®¸rÿ׸sÿì¸zÿì¸|ÿ׸€ÿ츂ÿ츟ÿ׸¡ÿ츩ÿ층ÿø·ÿ츹ÿ츻ÿ׸½ÿ츿ÿ׸Áÿ׸Êÿ׸Îÿ׸Ïÿì¸Ôÿ׸Ùÿ׸Ûÿ׸Ýÿ׸åÿ׸çÿì¸õÿì¸÷ÿ׸ùÿ׸ûÿ׸ýÿ׸ÿ׸ÿ׸ ÿ׸ÿ׸ÿ׸ÿì¸ÿì¸ÿ׸ÿìºþöºþöº¤ÿ…ºªÿšº®ÿ…º°ÿ׺µÿ…º¿ÿ׺ÎÿšºÕÿšºòÿšºþöº þöºrÿšºsÿšºvÿ캟ÿ׺»ÿ׺Êÿ׺Îÿ…ºÏÿšºÙÿšºÛÿšºÝÿšºåÿ׺ÿ׺ÿ׺ ÿ®º ÿ®ºÿ…ºÿšºÿ…ºÿš»Ÿÿ×»¸ÿ×»»ÿ×»¾ÿ×»áÿ×»lÿ×»~ÿ×»„ÿ×»†ÿ×»ˆÿ×»Šÿ×»Œÿ×»±ÿ×»³ÿ×»Àÿ×»Âÿ×»Åÿ×»Çÿ×»Õÿ×»ïÿ×»ñÿ×»óÿ×»þÿ×» ÿ×» ÿ×»ÿ×»ÿ×»ÿ×¼ÿ…¼ÿ®¼ÿ…¼Ÿÿ×¼¤ÿš¼ªÿq¼®ÿš¼µÿš¼¸ÿ×¼»ÿ×¼¼)¼¾ÿ®¼Ìÿš¼Íÿš¼Îÿ…¼Ïÿq¼Ðÿ×¼Ñÿ×¼Òÿš¼Óÿš¼Ôÿš¼Õÿ…¼Öÿš¼×ÿš¼Øÿq¼Ùÿš¼Úÿš¼Ûÿq¼Üÿ®¼Ýÿ®¼Þÿq¼ßÿ×¼àÿš¼áÿš¼âÿš¼ãÿš¼äÿ®¼åÿš¼æÿš¼çÿ×¼èÿš¼éÿüêÿq¼ìÿš¼íÿq¼îÿ…¼òÿ…¼óÿš¼õÿš¼öÿ®¼÷ÿš¼ùÿš¼ÿ®¼ÿ®¼ÿ®¼ÿ…¼ ÿ…¼jÿq¼kÿš¼lÿ×¼mÿ×¼qÿš¼rÿq¼sÿ…¼uÿš¼wÿš¼yÿš¼}ÿš¼~ÿ×¼ÿq¼ÿ×¼ƒÿ×¼„ÿ×¼…ÿq¼†ÿ×¼‡ÿq¼ˆÿ×¼‰ÿq¼Šÿ×¼‹ÿ×¼Œÿ×¼ÿq¼–ÿš¼šÿš¼žÿš¼ ÿ×¼¢ÿ×¼¤ÿš¼¦ÿš¼ªÿ®¼¬ÿš¼®ÿš¼°ÿš¼±ÿ×¼²ÿq¼³ÿ×¼´ÿq¼µ)¼¶ÿ®¼¸ÿ®¼ºÿ®¼¼ÿ×¼¾ÿ®¼Àÿš¼Âÿš¼Äÿš¼Åÿš¼Æÿq¼Çÿš¼Èÿq¼Ëÿ×¼Íÿš¼Îÿš¼Ïÿ…¼Ñÿš¼Óÿš¼Õÿš¼×ÿš¼Ùÿq¼Ûÿq¼Ýÿq¼àÿq¼æÿ×¼èÿ×¼êÿüìÿš¼îÿš¼ïÿ×¼ðÿq¼ñÿ×¼òÿq¼óÿ×¼ôÿq¼öÿ×¼øÿ®¼úÿ®¼üÿ®¼þÿš¼ÿš¼ÿš¼ÿ×¼ÿ×¼ ÿq¼ ÿq¼ ÿq¼ ÿq¼ÿš¼ÿš¼ÿš¼ÿ…¼ÿš¼ÿ×¼ÿq¼ÿ®¼ÿq¼ÿš¼ÿ…½ÿ…½ÿ…½Ÿÿ콤ÿš½ªÿq½®ÿš½µÿš½¸ÿì½»ÿì½¾ÿýÉÿì½Îÿ®½Ïÿ×½Õÿ®½Øÿ×½Ûÿ×½Þÿ×½áÿ×½êÿ×½ëf½íÿ×½îÿì½òÿ®½ôf½ÿ…½ ÿ…½jÿ×½lÿì½rÿq½sÿ®½~ÿì½ÿ×½„ÿì½…ÿ×½†ÿ콇ÿ×½ˆÿ콉ÿ×½Šÿ콌ÿì½ÿ×½˜f½¨f½±ÿì½²ÿ×½³ÿì½´ÿ×½Àÿ×½Âÿ×½Åÿ×½ÆÿýÇÿ×½ÈÿýÎÿš½Ïÿ®½Õÿ×½Ùÿq½Ûÿq½Ýÿq½àÿ×½ïÿì½ðÿ×½ñÿì½òÿ×½óÿì½ôÿ×½þÿ×½ ÿq½ ÿ×½ ÿq½ ÿ×½ÿš½ÿ®½ÿì½ÿ×½ÿ×½ÿš½ÿ®¾ÿ®¾ÿ®¾ÿ×¾¤ÿ×¾¦ÿ×¾¨ÿþªÿ×¾®ÿ×¾°ÿ×¾±ÿ×¾µÿ×¾¼ÿþ½ÿþ¿ÿ×¾Äÿ×¾Çÿ×¾Îÿì¾Õÿì¾òÿì¾ÿ®¾ ÿ®¾rÿ×¾sÿì¾zÿ×¾€ÿ쾂ÿ쾟ÿ×¾¡ÿ×¾©ÿ×¾µÿþ·ÿþ¹ÿþ»ÿ×¾½ÿ×¾Êÿ×¾Îÿ×¾Ïÿì¾Ùÿ×¾Ûÿ×¾Ýÿ×¾åÿ×¾çÿ×¾õÿ×¾÷ÿþùÿþûÿþÿ×¾ÿ×¾ ÿ×¾ÿ×¾ÿ×¾ÿì¾ÿ×¾ÿ×¾ÿì¿Ÿÿ׿¸ÿ׿»ÿ׿¾ÿ׿Áÿ׿áÿ׿lÿ׿|ÿ׿~ÿ׿„ÿ׿†ÿ׿ˆÿ׿Šÿ׿Œÿ׿±ÿ׿³ÿ׿¿ÿ׿Àÿ׿Áÿ׿Âÿ׿Åÿš¿Çÿš¿Ôÿ׿Õÿ׿ïÿ׿ñÿ׿óÿ׿ýÿ׿þÿ׿ ÿ׿ ÿ׿ÿ׿ÿ׿ÿ׿ÿìÀ£áÀê)Àÿ×Àÿ×ãáÃê)Ãÿ×Ãÿ×Äÿ®Ä ÿ®Äÿ…Ħÿ…Ĩÿ×ļÿšÄ½ÿ×ÄÁÿšÄÄÿ…ÄÜÿ×ÄÝÿ×Äáÿ×Ääÿ×Äöÿ×Äÿ®Ä ÿ®Änÿ®Ä|ÿšÄ€ÿ®Ä‚ÿ®Ä—ÿ®Ä›ÿ®Ä§ÿ®Ä©ÿ…Īÿ×ĵÿšÄ¶ÿ×Ä·ÿšÄ¸ÿ×ĹÿšÄºÿ׼ÿ…ľÿ×Ä¿ÿšÄÀÿ×ÄÁÿšÄÂÿ×ÄÔÿšÄÕÿ×Ä÷ÿ×Äøÿ×Äùÿ×Äúÿ×Äûÿ×Äüÿ×ÄýÿšÄþÿ×Äÿ®Ä ÿšÄÿÃÄÿšÄÿÃÄÿ…Äÿ×Æÿ®Æ ÿ®Æÿ…Ʀÿ…ƨÿ×ƼÿšÆ½ÿ×ÆÁÿšÆÄÿ…ÆÜÿ×ÆÝÿ×Æáÿ×Æäÿ×Æöÿ×Æÿ®Æ ÿ®Ænÿ®Æ|ÿšÆ€ÿ®Æ‚ÿ®Æ—ÿ®Æ›ÿ®Æ§ÿ®Æ©ÿ…ƪÿ×ƵÿšÆ¶ÿ×Æ·ÿšÆ¸ÿ×ƹÿšÆºÿ×ƽÿ…ƾÿ×Æ¿ÿšÆÀÿ×ÆÁÿšÆÂÿ×ÆÔÿšÆÕÿ×Æ÷ÿ×Æøÿ×Æùÿ×Æúÿ×Æûÿ×Æüÿ×ÆýÿšÆþÿ×Æÿ®Æ ÿšÆÿÃÆÿšÆÿÃÆÿ…Æÿ×Çÿ®Çÿ®ÇÿìǤÿ×ǦÿìǨÿ×Ǫÿ×Ç®ÿ×Ç°ÿ×DZÿìǵÿ×ǼÿÃǽÿ×Ç¿ÿ×ÇÁÿ×ÇÄÿìÇÇÿìÇÎÿìÇÕÿìÇòÿìÇÿ®Ç ÿ®Çrÿ×ÇsÿìÇzÿìÇ|ÿ×Ç€ÿìÇ‚ÿìÇŸÿ×Ç¡ÿìÇ©ÿìǵÿÃÇ·ÿìǹÿìÇ»ÿ×ǽÿìÇ¿ÿ×ÇÁÿ×ÇÊÿ×ÇÎÿ×ÇÏÿìÇÔÿ×ÇÙÿ×ÇÛÿ×ÇÝÿ×Çåÿ×ÇçÿìÇõÿìÇ÷ÿ×Çùÿ×Çûÿ×Çýÿ×Çÿ×Çÿ×Ç ÿ×Çÿ×Çÿ×ÇÿìÇÿìÇÿ×ÇÿìÈÿ®Èÿ®ÈÿìȤÿ×ȦÿìȨÿ×Ȫÿ×È®ÿ×È°ÿ×ȱÿìȵÿ×ȼÿÃȽÿ×È¿ÿ×ÈÁÿ×ÈÄÿìÈÇÿìÈÎÿìÈÕÿìÈòÿìÈÿ®È ÿ®Èrÿ×ÈsÿìÈzÿìÈ|ÿ×È€ÿìÈ‚ÿìÈŸÿ×È¡ÿìÈ©ÿìȵÿÃÈ·ÿìȹÿìÈ»ÿ×ȽÿìÈ¿ÿ×ÈÁÿ×ÈÊÿ×ÈÎÿ×ÈÏÿìÈÔÿ×ÈÙÿ×ÈÛÿ×ÈÝÿ×Èåÿ×ÈçÿìÈõÿìÈ÷ÿ×Èùÿ×Èûÿ×Èýÿ×Èÿ×Èÿ×È ÿ×Èÿ×Èÿ×ÈÿìÈÿìÈÿ×ÈÿìÊÿìÊ ÿìÊÿìÊ ÿìÌé)ÍÿšÍÿ×ÍÿšÍÎÿÃÍÏÿìÍÕÿÃÍØÿìÍÛÿìÍÞÿìÍêÿìÍíÿìÍòÿÃÍÿ×Íÿ×Íÿ×ÍÿšÍ ÿšÍjÿìÍsÿÃÍÿìÍ…ÿì͇ÿì͉ÿìÍÿìͲÿìÍ´ÿìÍÏÿÃÍàÿìÍðÿìÍòÿìÍôÿìÍ ÿìÍ ÿìÍÿÃÍÿìÍÿìÍÿÃÎÿìÎ ÿìÎÿìÎ ÿìÏÿìÏ ÿìÏÿìÏ ÿìÐÏÿ×ÐØÿ×ÐÛÿ×ÐÞÿ×Ðáÿ×Ðêÿ×Ðíÿ×Ðjÿ×Ðÿ×Ð…ÿ×Їÿ×Љÿ×Ðÿ×вÿ×дÿ×ÐÀÿ×ÐÂÿ×ÐÆÿ×ÐÈÿ×ÐÕÿ×Ðàÿ×Ððÿ×Ðòÿ×Ðôÿ×Ðþÿ×Ð ÿ×Ð ÿ×Ðÿ×Ðÿ×Ñé)ÔÏÿ×ÔØÿ×ÔÛÿ×ÔÞÿ×Ôáÿ×Ôêÿ×Ôíÿ×Ôjÿ×Ôÿ×Ô…ÿ×Ô‡ÿ×Ô‰ÿ×Ôÿ×Ô²ÿ×Ô´ÿ×ÔÀÿ×ÔÂÿ×ÔÆÿ×ÔÈÿ×ÔÕÿ×Ôàÿ×Ôðÿ×Ôòÿ×Ôôÿ×Ôþÿ×Ô ÿ×Ô ÿ×Ôÿ×Ôÿ×ØÿìØ ÿìØÐÿ×ØÜÿìØÝÿìØßÿ×ØáÿìØäÿìØöÿìØÿìØ ÿìØ ÿ×تÿìضÿìؼÿ×ؾÿìØÀÿìØÂÿìØËÿ×ØÕÿìØæÿ×ØøÿìØúÿìØüÿìØþÿìØÿ×Øÿ×ØÿìØÿìØÿìÚÿìÚ ÿìÚÐÿ×ÚÜÿìÚÝÿìÚßÿ×ÚáÿìÚäÿìÚöÿìÚÿìÚ ÿìÚ ÿ×ÚªÿìÚ¶ÿìÚ¼ÿ×Ú¾ÿìÚÀÿìÚÂÿìÚËÿ×ÚÕÿìÚæÿ×ÚøÿìÚúÿìÚüÿìÚþÿìÚÿ×Úÿ×ÚÿìÚÿìÚÿìÜÿšÜÿ×ÜÿšÜÎÿÃÜÏÿìÜÕÿÃÜØÿìÜÛÿìÜÞÿìÜêÿìÜíÿìÜòÿÃÜÿ×Üÿ×Üÿ×ÜÿšÜ ÿšÜjÿìÜsÿÃÜÿìÜ…ÿì܇ÿì܉ÿìÜÿìܲÿìÜ´ÿìÜÏÿÃÜàÿìÜðÿìÜòÿìÜôÿìÜ ÿìÜ ÿìÜÿÃÜÿìÜÿìÜÿÃÝÿ®Ýÿ®ÝÎÿ×ÝÕÿ×Ýòÿ×Ýÿ®Ý ÿ®Ýsÿ×ÝÏÿ×Ýÿ×Ýÿ×ÞÿìÞ ÿìÞÐÿ×ÞÜÿìÞÝÿìÞßÿ×ÞáÿìÞäÿìÞöÿìÞÿìÞ ÿìÞ ÿ×ÞªÿìÞ¶ÿìÞ¼ÿ×Þ¾ÿìÞÀÿìÞÂÿìÞËÿ×ÞÕÿìÞæÿ×ÞøÿìÞúÿìÞüÿìÞþÿìÞÿ×Þÿ×ÞÿìÞÿìÞÿìßÏÿ×ßØÿ×ßÛÿ×ßÞÿ×ßáÿ×ßêÿ×ßíÿ×ßjÿ×ßÿ×ß…ÿ×߇ÿ×߉ÿ×ßÿ×ß²ÿ×ß´ÿ×ßÀÿ×ßÂÿ×ßÆÿ×ßÈÿ×ßÕÿ×ßàÿ×ßðÿ×ßòÿ×ßôÿ×ßþÿ×ß ÿ×ß ÿ×ßÿ×ßÿ×àÿìà ÿìàÿìà ÿìãÿìã ÿìãÿìã ÿìäÿ…ä ÿ…äÐÿ×äÜÿšäÝÿÃäßÿ×äáÿ®ääÿšäöÿÃäÿ…ä ÿ…ämÿ×äÿ×äƒÿ×ä‹ÿ×ä ÿ×äªÿšä¶ÿšä¸ÿÃäºÿÃä¼ÿ×ä¾ÿšäÀÿ®äÂÿ®äÆÿ×äÈÿ×äËÿ×äÕÿ®äæÿ×äêÿ×äøÿÃäúÿÃäüÿÃäþÿ®äÿ×äÿ×äÿšäÿšäÿšæÿ…æ ÿ…æÐÿ×æÜÿšæÝÿÃæßÿ×æáÿ®æäÿšæöÿÃæÿ…æ ÿ…æmÿ×æÿ×æƒÿ×æ‹ÿ×æ ÿ×æªÿšæ¶ÿšæ¸ÿÃæºÿÃæ¼ÿ×æ¾ÿšæÀÿ®æÂÿ®æÆÿ×æÈÿ×æËÿ×æÕÿ®ææÿ×æêÿ×æøÿÃæúÿÃæüÿÃæþÿ®æÿ×æÿ×æÿšæÿšæÿšçÿìç ÿìçÐÿ×çÜÿìçÝÿìçßÿ×çáÿìçäÿìçöÿìçÿìç ÿìç ÿ×çªÿìç¶ÿìç¼ÿ×ç¾ÿìçÀÿìçÂÿìçËÿ×çÕÿìçæÿ×çøÿìçúÿìçüÿìçþÿìçÿ×çÿ×çÿìçÿìçÿìèÿìè ÿìèÐÿ×èÜÿìèÝÿìèßÿ×èáÿìèäÿìèöÿìèÿìè ÿìè ÿ×èªÿìè¶ÿìè¼ÿ×è¾ÿìèÀÿìèÂÿìèËÿ×èÕÿìèæÿ×èøÿìèúÿìèüÿìèþÿìèÿ×èÿ×èÿìèÿìèÿìêÿìê ÿìêÿìê ÿìëÿìë ÿìëÿìë ÿìëÿ×ëÿ×ìÿšìÿ×ìÿšìÎÿÃìÏÿììÕÿÃìØÿììÛÿììÞÿììêÿììíÿììòÿÃìÿ×ìÿ×ìÿ×ìÿšì ÿšìjÿììsÿÃìÿìì…ÿìì‡ÿìì‰ÿììÿìì²ÿìì´ÿììÏÿÃìàÿììðÿììòÿììôÿìì ÿìì ÿììÿÃìÿììÿììÿÃòÿ…ò ÿ…òÐÿ×òÜÿšòÝÿÃòßÿ×òáÿ®òäÿšòöÿÃòÿ…ò ÿ…òmÿ×òÿ×òƒÿ×ò‹ÿ×ò ÿ×òªÿšò¶ÿšò¸ÿÃòºÿÃò¼ÿ×ò¾ÿšòÀÿ®òÂÿ®òÆÿ×òÈÿ×òËÿ×òÕÿ®òæÿ×òêÿ×òøÿÃòúÿÃòüÿÃòþÿ®òÿ×òÿ×òÿšòÿšòÿšóÿ…ó ÿ…óÐÿ×óÜÿšóÝÿÃóßÿ×óáÿ®óäÿšóöÿÃóÿ…ó ÿ…ómÿ×óÿ×óƒÿ×ó‹ÿ×ó ÿ×óªÿšó¶ÿšó¸ÿÃóºÿÃó¼ÿ×ó¾ÿšóÀÿ®óÂÿ®óÆÿ×óÈÿ×óËÿ×óÕÿ®óæÿ×óêÿ×óøÿÃóúÿÃóüÿÃóþÿ®óÿ×óÿ×óÿšóÿšóÿšôÿìô ÿìôÿìô ÿìôÿ×ôÿ×õÏÿ×õØÿ×õÛÿ×õÞÿ×õáÿ×õêÿ×õíÿ×õjÿ×õÿ×õ…ÿ×õ‡ÿ×õ‰ÿ×õÿ×õ²ÿ×õ´ÿ×õÀÿ×õÂÿ×õÆÿ×õÈÿ×õÕÿ×õàÿ×õðÿ×õòÿ×õôÿ×õþÿ×õ ÿ×õ ÿ×õÿ×õÿ×öÿ®öÿ®öÎÿ×öÕÿ×öòÿ×öÿ®ö ÿ®ösÿ×öÏÿ×öÿ×öÿ×øÿ…øÿ®øÿ…øŸÿ×ø¤ÿšøªÿqø®ÿšøµÿšø¸ÿ×ø»ÿ×ø¼)ø¾ÿ®øÌÿšøÍÿšøÎÿ…øÏÿqøÐÿ×øÑÿ×øÒÿšøÓÿšøÔÿšøÕÿ…øÖÿšø×ÿšøØÿqøÙÿšøÚÿšøÛÿqøÜÿ®øÝÿ®øÞÿqøßÿ×øàÿšøáÿšøâÿšøãÿšøäÿ®øåÿšøæÿšøçÿ×øèÿšøéÿÃøêÿqøìÿšøíÿqøîÿ…øòÿ…øóÿšøõÿšøöÿ®ø÷ÿšøùÿšøÿ®øÿ®øÿ®øÿ…ø ÿ…øjÿqøkÿšølÿ×ømÿ×øqÿšørÿqøsÿ…øuÿšøwÿšøyÿšø}ÿšø~ÿ×øÿqøÿ×øƒÿ×ø„ÿ×ø…ÿqø†ÿ×ø‡ÿqøˆÿ×ø‰ÿqøŠÿ×ø‹ÿ×øŒÿ×øÿqø–ÿšøšÿšøžÿšø ÿ×ø¢ÿ×ø¤ÿšø¦ÿšøªÿ®ø¬ÿšø®ÿšø°ÿšø±ÿ×ø²ÿqø³ÿ×ø´ÿqøµ)ø¶ÿ®ø¸ÿ®øºÿ®ø¼ÿ×ø¾ÿ®øÀÿšøÂÿšøÄÿšøÅÿšøÆÿqøÇÿšøÈÿqøËÿ×øÍÿšøÎÿšøÏÿ…øÑÿšøÓÿšøÕÿšø×ÿšøÙÿqøÛÿqøÝÿqøàÿqøæÿ×øèÿ×øêÿÃøìÿšøîÿšøïÿ×øðÿqøñÿ×øòÿqøóÿ×øôÿqøöÿ×øøÿ®øúÿ®øüÿ®øþÿšøÿšøÿšøÿ×øÿ×ø ÿqø ÿqø ÿqø ÿqøÿšøÿšøÿšøÿ…øÿšøÿ×øÿqøÿ®øÿqøÿšøÿ…ùÿšùÿ×ùÿšùÎÿÃùÏÿìùÕÿÃùØÿìùÛÿìùÞÿìùêÿìùíÿìùòÿÃùÿ×ùÿ×ùÿ×ùÿšù ÿšùjÿìùsÿÃùÿìù…ÿìù‡ÿìù‰ÿìùÿìù²ÿìù´ÿìùÏÿÃùàÿìùðÿìùòÿìùôÿìù ÿìù ÿìùÿÃùÿìùÿìùÿÃúÿšúÿšú")ú$ÿ®ú&ÿìú*ÿìú2ÿìú4ÿìúDÿ×úFÿ×úGÿ×úHÿ×úJÿìúPÿìúQÿìúRÿ×úSÿìúTÿ×úUÿìúVÿìúXÿìú‚ÿ®úƒÿ®ú„ÿ®ú…ÿ®ú†ÿ®ú‡ÿ®ú‰ÿìú”ÿìú•ÿìú–ÿìú—ÿìú˜ÿìúšÿìú¢ÿ×ú£ÿ×ú¤ÿ×ú¥ÿ×ú¦ÿ×ú§ÿ×ú¨ÿ×ú©ÿ×úªÿ×ú«ÿ×ú¬ÿ×ú­ÿ×ú´ÿ×úµÿ×ú¶ÿ×ú·ÿ×ú¸ÿ×úºÿ×ú»ÿìú¼ÿìú½ÿìú¾ÿìúÂÿ®úÃÿ×úÄÿ®úÅÿ×úÆÿ®úÇÿ×úÈÿìúÉÿ×úÊÿìúËÿ×úÌÿìúÍÿ×úÎÿìúÏÿ×úÑÿ×úÓÿ×úÕÿ×ú×ÿ×úÙÿ×úÛÿ×úÝÿ×úÞÿìúßÿìúàÿìúáÿìúâÿìúãÿìúäÿìúåÿìúúÿìúÿìúÿìú ÿìúÿìúÿ×úÿìúÿ×úÿìúÿ×úÿìúÿ×úÿìúÿìúÿìú!ÿìú+ÿìú-ÿìú/ÿìú1ÿìú3ÿìú5ÿìúCÿ®úDÿ×úFÿ×úGÿìúHÿ×úJÿìúÿšú ÿšúWÿìúXÿ®úYÿ×ú_ÿìú`ÿ×úbÿìúÿ®úÿ×úÿ®ú ÿ×ú!ÿ®ú"ÿ×ú#ÿ®ú%ÿ®ú&ÿ×ú'ÿ®ú(ÿ×ú)ÿ®ú*ÿ×ú+ÿ®ú,ÿ×ú-ÿ®ú.ÿ×ú/ÿ®ú0ÿ×ú1ÿ®ú2ÿ×ú3ÿ®ú4ÿ×ú6ÿ×ú8ÿ×ú:ÿ×ú<ÿ×ú@ÿ×úBÿ×úDÿ×úIÿìúJÿ×úKÿìúLÿ×úMÿìúNÿ×úOÿìúQÿìúRÿ×úSÿìúTÿ×úUÿìúVÿ×úWÿìúXÿ×úYÿìúZÿ×ú[ÿìú\ÿ×ú]ÿìú^ÿ×ú_ÿìú`ÿ×úbÿìúdÿìúfÿìúhÿìújÿìúlÿìúnÿìûRû Rûÿ®ûÿ®û")ûRûÿ®û Rû ÿ®üÿšüÿšü")ü$ÿ®ü&ÿìü*ÿìü2ÿìü4ÿìüDÿ×üFÿ×üGÿ×üHÿ×üJÿìüPÿìüQÿìüRÿ×üSÿìüTÿ×üUÿìüVÿìüXÿìü‚ÿ®üƒÿ®ü„ÿ®ü…ÿ®ü†ÿ®ü‡ÿ®ü‰ÿìü”ÿìü•ÿìü–ÿìü—ÿìü˜ÿìüšÿìü¢ÿ×ü£ÿ×ü¤ÿ×ü¥ÿ×ü¦ÿ×ü§ÿ×ü¨ÿ×ü©ÿ×üªÿ×ü«ÿ×ü¬ÿ×ü­ÿ×ü´ÿ×üµÿ×ü¶ÿ×ü·ÿ×ü¸ÿ×üºÿ×ü»ÿìü¼ÿìü½ÿìü¾ÿìüÂÿ®üÃÿ×üÄÿ®üÅÿ×üÆÿ®üÇÿ×üÈÿìüÉÿ×üÊÿìüËÿ×üÌÿìüÍÿ×üÎÿìüÏÿ×üÑÿ×üÓÿ×üÕÿ×ü×ÿ×üÙÿ×üÛÿ×üÝÿ×üÞÿìüßÿìüàÿìüáÿìüâÿìüãÿìüäÿìüåÿìüúÿìüÿìüÿìü ÿìüÿìüÿ×üÿìüÿ×üÿìüÿ×üÿìüÿ×üÿìüÿìüÿìü!ÿìü+ÿìü-ÿìü/ÿìü1ÿìü3ÿìü5ÿìüCÿ®üDÿ×üFÿ×üGÿìüHÿ×üJÿìüÿšü ÿšüWÿìüXÿ®üYÿ×ü_ÿìü`ÿ×übÿìüÿ®üÿ×üÿ®ü ÿ×ü!ÿ®ü"ÿ×ü#ÿ®ü%ÿ®ü&ÿ×ü'ÿ®ü(ÿ×ü)ÿ®ü*ÿ×ü+ÿ®ü,ÿ×ü-ÿ®ü.ÿ×ü/ÿ®ü0ÿ×ü1ÿ®ü2ÿ×ü3ÿ®ü4ÿ×ü6ÿ×ü8ÿ×ü:ÿ×ü<ÿ×ü@ÿ×üBÿ×üDÿ×üIÿìüJÿ×üKÿìüLÿ×üMÿìüNÿ×üOÿìüQÿìüRÿ×üSÿìüTÿ×üUÿìüVÿ×üWÿìüXÿ×üYÿìüZÿ×ü[ÿìü\ÿ×ü]ÿìü^ÿ×ü_ÿìü`ÿ×übÿìüdÿìüfÿìühÿìüjÿìülÿìünÿìýRý Rýÿ®ýÿ®ý")ýRýÿ®ý Rý ÿ®þÿšþÿšþ")þ$ÿ®þ&ÿìþ*ÿìþ2ÿìþ4ÿìþDÿ×þFÿ×þGÿ×þHÿ×þJÿìþPÿìþQÿìþRÿ×þSÿìþTÿ×þUÿìþVÿìþXÿìþ‚ÿ®þƒÿ®þ„ÿ®þ…ÿ®þ†ÿ®þ‡ÿ®þ‰ÿìþ”ÿìþ•ÿìþ–ÿìþ—ÿìþ˜ÿìþšÿìþ¢ÿ×þ£ÿ×þ¤ÿ×þ¥ÿ×þ¦ÿ×þ§ÿ×þ¨ÿ×þ©ÿ×þªÿ×þ«ÿ×þ¬ÿ×þ­ÿ×þ´ÿ×þµÿ×þ¶ÿ×þ·ÿ×þ¸ÿ×þºÿ×þ»ÿìþ¼ÿìþ½ÿìþ¾ÿìþÂÿ®þÃÿ×þÄÿ®þÅÿ×þÆÿ®þÇÿ×þÈÿìþÉÿ×þÊÿìþËÿ×þÌÿìþÍÿ×þÎÿìþÏÿ×þÑÿ×þÓÿ×þÕÿ×þ×ÿ×þÙÿ×þÛÿ×þÝÿ×þÞÿìþßÿìþàÿìþáÿìþâÿìþãÿìþäÿìþåÿìþúÿìþÿìþÿìþ ÿìþÿìþÿ×þÿìþÿ×þÿìþÿ×þÿìþÿ×þÿìþÿìþÿìþ!ÿìþ+ÿìþ-ÿìþ/ÿìþ1ÿìþ3ÿìþ5ÿìþCÿ®þDÿ×þFÿ×þGÿìþHÿ×þJÿìþÿšþ ÿšþWÿìþXÿ®þYÿ×þ_ÿìþ`ÿ×þbÿìþÿ®þÿ×þÿ®þ ÿ×þ!ÿ®þ"ÿ×þ#ÿ®þ%ÿ®þ&ÿ×þ'ÿ®þ(ÿ×þ)ÿ®þ*ÿ×þ+ÿ®þ,ÿ×þ-ÿ®þ.ÿ×þ/ÿ®þ0ÿ×þ1ÿ®þ2ÿ×þ3ÿ®þ4ÿ×þ6ÿ×þ8ÿ×þ:ÿ×þ<ÿ×þ@ÿ×þBÿ×þDÿ×þIÿìþJÿ×þKÿìþLÿ×þMÿìþNÿ×þOÿìþQÿìþRÿ×þSÿìþTÿ×þUÿìþVÿ×þWÿìþXÿ×þYÿìþZÿ×þ[ÿìþ\ÿ×þ]ÿìþ^ÿ×þ_ÿìþ`ÿ×þbÿìþdÿìþfÿìþhÿìþjÿìþlÿìþnÿìÿRÿ Rÿÿ®ÿÿ®ÿ")ÿRÿÿ®ÿ Rÿ ÿ®ÿ…ÿ…")$ÿ…&ÿ×*ÿ×2ÿ×4ÿ×DÿšFÿšGÿšHÿšJÿ×PÿÃQÿÃRÿšSÿÃTÿšUÿÃVÿ®XÿÃ]ÿׂÿ…ƒÿ…„ÿ……ÿ…†ÿ…‡ÿ…‰ÿ×”ÿוÿ×–ÿ×—ÿטÿךÿ×¢ÿš£ÿš¤ÿš¥ÿš¦ÿš§ÿš¨ÿš©ÿšªÿš«ÿš¬ÿš­ÿš´ÿšµÿš¶ÿš·ÿš¸ÿšºÿš»ÿüÿýÿþÿÃÂÿ…ÃÿšÄÿ…ÅÿšÆÿ…ÇÿšÈÿ×ÉÿšÊÿ×ËÿšÌÿ×ÍÿšÎÿ×ÏÿšÑÿšÓÿšÕÿš×ÿšÙÿšÛÿšÝÿšÞÿ×ßÿ×àÿ×áÿ×âÿ×ãÿ×äÿ×åÿ×úÿÃÿÃÿà ÿÃÿ×ÿšÿ×ÿšÿ×ÿšÿ×ÿšÿÃÿÃÿ®!ÿ®+ÿÃ-ÿÃ/ÿÃ1ÿÃ3ÿÃ5ÿÃ<ÿ×>ÿ×@ÿ×Cÿ…DÿšFÿšGÿ×HÿšJÿ®ÿ… ÿ…WÿÃXÿ…Yÿš_ÿ×`ÿšbÿÃÿ…ÿšÿ… ÿš!ÿ…"ÿš#ÿ…%ÿ…&ÿš'ÿ…(ÿš)ÿ…*ÿš+ÿ…,ÿš-ÿ….ÿš/ÿ…0ÿš1ÿ…2ÿš3ÿ…4ÿš6ÿš8ÿš:ÿš<ÿš@ÿšBÿšDÿšIÿ×JÿšKÿ×LÿšMÿ×NÿšOÿ×Qÿ×RÿšSÿ×TÿšUÿ×VÿšWÿ×XÿšYÿ×Zÿš[ÿ×\ÿš]ÿ×^ÿš_ÿ×`ÿšbÿÃdÿÃfÿÃhÿÃjÿÃlÿÃnÿÃR Rÿ®ÿ®")Rÿ® R ÿ®7ÿ®$ÿ®&ÿ®qÿ®ÿ®¦ÿ®¼ÿ®Äÿ®Üÿ×äÿשÿ®ªÿ×µÿ®¶ÿ×½ÿ®¾ÿ×ÿ®ÿ×ÿ®7ÿ®$ÿ®&ÿ®qÿ®ÿ®¦ÿ®¼ÿ®Äÿ®Üÿ×äÿשÿ®ªÿ×µÿ®¶ÿ×½ÿ®¾ÿ×ÿ®ÿ×ÿ®7ÿ®$ÿ®&ÿ®qÿ®ÿ®¦ÿ®¼ÿ®Äÿ®Üÿ×äÿשÿ®ªÿ×µÿ®¶ÿ×½ÿ®¾ÿ×ÿ®ÿ×ÿ®$ÿq7)9):)<Dÿ®Fÿ…Gÿ…Hÿ…JÿÃPÿÃQÿÃRÿ…SÿÃTÿ…UÿÃVÿÃXÿÂÿqƒÿq„ÿq…ÿq†ÿq‡ÿqŸ¢ÿ…£ÿ®¤ÿ®¥ÿ®¦ÿ®§ÿ®¨ÿ®©ÿ…ªÿ…«ÿ…¬ÿ…­ÿ…´ÿ…µÿ…¶ÿ…·ÿ…¸ÿ…ºÿ…»ÿüÿýÿþÿÃÂÿqÃÿ®ÄÿqÅÿ®ÆÿqÇÿ®Éÿ…Ëÿ…Íÿ…Ïÿ…Ñÿ…Óÿ…Õÿ…×ÿ…Ùÿ…Ûÿ…Ýÿ…ßÿÃáÿÃãÿÃåÿÃúÿÃÿÃÿà ÿÃÿ…ÿ…ÿ…ÿ…ÿÃÿÃÿÃ!ÿÃ$)&)+ÿÃ-ÿÃ/ÿÃ1ÿÃ3ÿÃ5ÿÃ6)8:CÿqDÿ®Fÿ®Hÿ…JÿÃVÿq_ÿqbÿqiÿqyÿ®zÿ×{ÿ×~ÿ®ÿÂÿ׃ÿׄÿׇÿ׉ÿ׌ÿ®ŽÿÃÿ®ÿ®“ÿ®™ÿ®¤ÿ…ªÿq®ÿ…µÿ…Êÿ×ÎÿqÏÿ…ÕÿqØÿ…Ûÿ…Þÿ…êÿ…íÿ…îÿÃòÿqú)ü)þ)WÿÃXÿqYÿ®`ÿ…bÿÃjÿ…rÿqsÿq}ÿìÿ……ÿ…‡ÿ…‰ÿ…ÿ…²ÿ…´ÿ…Îÿ…ÏÿqÙÿqÚÿ×ÛÿqÜÿ×ÝÿqÞÿ×àÿ…âÿ×äÿ×ðÿ…òÿ…ôÿ… ÿq ÿ… ÿq ÿ…ÿ…ÿqÿ…ÿ…ÿ…ÿqÿqÿ®ÿq ÿ®!ÿq"ÿ®#ÿq%ÿq&ÿ®'ÿq(ÿ®)ÿq*ÿ®+ÿq,ÿ®-ÿq.ÿ®/ÿq0ÿ®1ÿq2ÿ®3ÿq4ÿ®6ÿ…8ÿ…:ÿ…<ÿ…@ÿ…Bÿ…Dÿ…Jÿ…Lÿ…Nÿ…Rÿ…Tÿ…Vÿ…Xÿ…Zÿ…\ÿ…^ÿ…`ÿ…bÿÃdÿÃfÿÃhÿÃjÿÃlÿÃnÿÃoqs)$ÿq7)9):)<Dÿ®Fÿ…Gÿ…Hÿ…JÿÃPÿÃQÿÃRÿ…SÿÃTÿ…UÿÃVÿÃXÿÂÿqƒÿq„ÿq…ÿq†ÿq‡ÿqŸ¢ÿ…£ÿ®¤ÿ®¥ÿ®¦ÿ®§ÿ®¨ÿ®©ÿ…ªÿ…«ÿ…¬ÿ…­ÿ…´ÿ…µÿ…¶ÿ…·ÿ…¸ÿ…ºÿ…»ÿüÿýÿþÿÃÂÿqÃÿ®ÄÿqÅÿ®ÆÿqÇÿ®Éÿ…Ëÿ…Íÿ…Ïÿ…Ñÿ…Óÿ…Õÿ…×ÿ…Ùÿ…Ûÿ…Ýÿ…ßÿÃáÿÃãÿÃåÿÃúÿÃÿÃÿà ÿÃÿ…ÿ…ÿ…ÿ…ÿÃÿÃÿÃ!ÿÃ$)&)+ÿÃ-ÿÃ/ÿÃ1ÿÃ3ÿÃ5ÿÃ6)8:CÿqDÿ®Fÿ®Hÿ…JÿÃVÿq_ÿqbÿqiÿqyÿ®zÿ×{ÿ×~ÿ®ÿÂÿ׃ÿׄÿׇÿ׉ÿ׌ÿ®ŽÿÃÿ®ÿ®“ÿ®™ÿ®¤ÿ…ªÿq®ÿ…µÿ…Êÿ×ÎÿqÏÿ…ÕÿqØÿ…Ûÿ…Þÿ…êÿ…íÿ…îÿÃòÿqú)ü)þ)WÿÃXÿqYÿ®`ÿ…bÿÃjÿ…rÿqsÿq}ÿìÿ……ÿ…‡ÿ…‰ÿ…ÿ…²ÿ…´ÿ…Îÿ…ÏÿqÙÿqÚÿ×ÛÿqÜÿ×ÝÿqÞÿ×àÿ…âÿ×äÿ×ðÿ…òÿ…ôÿ… ÿq ÿ… ÿq ÿ…ÿ…ÿqÿ…ÿ…ÿ…ÿqÿqÿ®ÿq ÿ®!ÿq"ÿ®#ÿq%ÿq&ÿ®'ÿq(ÿ®)ÿq*ÿ®+ÿq,ÿ®-ÿq.ÿ®/ÿq0ÿ®1ÿq2ÿ®3ÿq4ÿ®6ÿ…8ÿ…:ÿ…<ÿ…@ÿ…Bÿ…Dÿ…Jÿ…Lÿ…Nÿ…Rÿ…Tÿ…Vÿ…Xÿ…Zÿ…\ÿ…^ÿ…`ÿ…bÿÃdÿÃfÿÃhÿÃjÿÃlÿÃnÿÃoqs)&ÿš*ÿš2ÿš4ÿš7ÿq8ÿ×9ÿ…:ÿ…<ÿ…‰ÿš”ÿš•ÿš–ÿš—ÿš˜ÿššÿš›ÿלÿ×ÿמÿןÿ…ÈÿšÊÿšÌÿšÎÿšÞÿšàÿšâÿšäÿšÿšÿšÿšÿš$ÿq&ÿq*ÿ×,ÿ×.ÿ×0ÿ×2ÿ×4ÿ×6ÿ…8ÿ…:ÿ…Gÿšfÿ®mÿ®qÿqrÿ…sÿšuÿ…xÿ……ÿ×ÿqŸÿš¦ÿq¸ÿš»ÿš¼ÿq¾ÿ®Áÿ\ÄÿqÜÿšáÿ…äÿšúÿ…üÿ…þÿ…ÿ…Tÿ…_ÿšaÿ×lÿš|ÿ\~ÿš€ÿ…‚ÿ…„ÿš†ÿšˆÿšŠÿšŒÿš©ÿqªÿš±ÿš³ÿšµÿq¶ÿš·ÿ…¹ÿ…½ÿq¾ÿš¿ÿ\Àÿ…Áÿ\Âÿ…Åÿ…Çÿ…Ôÿ\Õÿ…ïÿšñÿšóÿšýÿ\þÿ… ÿ…ÿšÿ…ÿšÿšÿqÿšIÿšKÿšMÿšOÿšQÿšSÿšUÿšWÿšYÿš[ÿš]ÿš_ÿšaÿ×cÿ×eÿ×gÿ×iÿ×kÿ×mÿ×oÿ…qÿ…sÿ…ÿq $ÿq 7) 9) :) < Dÿ® Fÿ… Gÿ… Hÿ… Jÿà Pÿà Qÿà Rÿ… Sÿà Tÿ… Uÿà Vÿà Xÿà ‚ÿq ƒÿq „ÿq …ÿq †ÿq ‡ÿq Ÿ ¢ÿ… £ÿ® ¤ÿ® ¥ÿ® ¦ÿ® §ÿ® ¨ÿ® ©ÿ… ªÿ… «ÿ… ¬ÿ… ­ÿ… ´ÿ… µÿ… ¶ÿ… ·ÿ… ¸ÿ… ºÿ… »ÿà ¼ÿà ½ÿà ¾ÿà Âÿq Ãÿ® Äÿq Åÿ® Æÿq Çÿ® Éÿ… Ëÿ… Íÿ… Ïÿ… Ñÿ… Óÿ… Õÿ… ×ÿ… Ùÿ… Ûÿ… Ýÿ… ßÿà áÿà ãÿà åÿà úÿà ÿà ÿà  ÿà ÿ… ÿ… ÿ… ÿ… ÿà ÿà ÿà !ÿà $) &) +ÿà -ÿà /ÿà 1ÿà 3ÿà 5ÿà 6) 8 : Cÿq Dÿ® Fÿ® Hÿ… Jÿà Vÿq _ÿq bÿq iÿq yÿ® zÿ× {ÿ× ~ÿ® ÿà ‚ÿ× ƒÿ× „ÿ× ‡ÿ× ‰ÿ× Œÿ® Žÿà ÿ® ÿ® “ÿ® ™ÿ® ¤ÿ… ªÿq ®ÿ… µÿ… Êÿ× Îÿq Ïÿ… Õÿq Øÿ… Ûÿ… Þÿ… êÿ… íÿ… îÿà òÿq ú) ü) þ)  Wÿà Xÿq Yÿ® `ÿ… bÿà jÿ… rÿq sÿq }ÿì ÿ… …ÿ… ‡ÿ… ‰ÿ… ÿ… ²ÿ… ´ÿ… Îÿ… Ïÿq Ùÿq Úÿ× Ûÿq Üÿ× Ýÿq Þÿ× àÿ… âÿ× äÿ× ðÿ… òÿ… ôÿ…  ÿq  ÿ…  ÿq  ÿ… ÿ… ÿq ÿ… ÿ… ÿ… ÿq ÿq ÿ® ÿq  ÿ® !ÿq "ÿ® #ÿq %ÿq &ÿ® 'ÿq (ÿ® )ÿq *ÿ® +ÿq ,ÿ® -ÿq .ÿ® /ÿq 0ÿ® 1ÿq 2ÿ® 3ÿq 4ÿ® 6ÿ… 8ÿ… :ÿ… <ÿ… @ÿ… Bÿ… Dÿ… Jÿ… Lÿ… Nÿ… Rÿ… Tÿ… Vÿ… Xÿ… Zÿ… \ÿ… ^ÿ… `ÿ… bÿà dÿà fÿà hÿà jÿà lÿà nÿà o q s ) &ÿš *ÿš 2ÿš 4ÿš 7ÿq 8ÿ× 9ÿ… :ÿ… <ÿ… ‰ÿš ”ÿš •ÿš –ÿš —ÿš ˜ÿš šÿš ›ÿ× œÿ× ÿ× žÿ× Ÿÿ… Èÿš Êÿš Ìÿš Îÿš Þÿš àÿš âÿš äÿš ÿš ÿš ÿš ÿš $ÿq &ÿq *ÿ× ,ÿ× .ÿ× 0ÿ× 2ÿ× 4ÿ× 6ÿ… 8ÿ… :ÿ… Gÿš fÿ® mÿ® qÿq rÿ… sÿš uÿ… xÿ… …ÿ× ÿq Ÿÿš ¦ÿq ¸ÿš »ÿš ¼ÿq ¾ÿ® Áÿ\ Äÿq Üÿš áÿ… äÿš úÿ… üÿ… þÿ… ÿ… Tÿ… _ÿš aÿ× lÿš |ÿ\ ~ÿš €ÿ… ‚ÿ… „ÿš †ÿš ˆÿš Šÿš Œÿš ©ÿq ªÿš ±ÿš ³ÿš µÿq ¶ÿš ·ÿ… ¹ÿ… ½ÿq ¾ÿš ¿ÿ\ Àÿ… Áÿ\ Âÿ… Åÿ… Çÿ… Ôÿ\ Õÿ… ïÿš ñÿš óÿš ýÿ\ þÿ…  ÿ… ÿš ÿ… ÿš ÿš ÿq ÿš Iÿš Kÿš Mÿš Oÿš Qÿš Sÿš Uÿš Wÿš Yÿš [ÿš ]ÿš _ÿš aÿ× cÿ× eÿ× gÿ× iÿ× kÿ× mÿ× oÿ… qÿ… sÿ… ÿq!qÿ×!rÿì!xÿì!TÿìSÿÃSÿÃSÿÃS ÿÃTÿ…Tÿ…TVÿ…T_ÿ…Tbÿ…Tfÿ×Tiÿ…Tmÿ×TsÿÃTvÿìTyÿšTzÿ®T{ÿÃT|ÿÃT}ÿÃT~ÿšTÿÃT‚ÿ®T„ÿÃT†ÿÃT‡ÿÃT‰ÿÃTŒÿšTŽÿšTÿšTÿšT’ÿÃT“ÿšT•ÿÃT–ÿÃT˜ÿÃT™ÿšTšÿÃT›ÿÃTÿ…T ÿ…T!ÿìXÿqX ÿqX&ÿ×X*ÿ×X- X2ÿ×X4ÿ×X7ÿqX9ÿ®X:ÿ®X<ÿ…X‰ÿ×X”ÿ×X•ÿ×X–ÿ×X—ÿ×X˜ÿ×Xšÿ×XŸÿ…XÈÿ×XÊÿ×XÌÿ×XÎÿ×XÞÿ×Xàÿ×Xâÿ×Xäÿ×Xÿ×Xÿ×Xÿ×Xÿ×X$ÿqX&ÿqX6ÿ®X8ÿ…X:ÿ…XGÿ×Xúÿ®Xüÿ®Xþÿ®Xÿ…XÿqX ÿqX_ÿ×XIÿ×XKÿ×XMÿ×XOÿ×XQÿ×XSÿ×XUÿ×XWÿ×XYÿ×X[ÿ×X]ÿ×X_ÿ×Xoÿ…Xqÿ…Xsÿ…XÿqYÿìY ÿìYÿìY ÿìZÿ®Zÿ®ZVÿ×Z_ÿ×Zbÿ×ZdÿìZiÿ×ZpÿìZqÿÃZrÿìZtÿ×ZuÿìZxÿìZˆÿìZÿ®Z ÿ®ZTÿì`IR`WR`Yf`Zf`[f`\f`¿f`%R`'R`7f`ûf`ýf`4R`5R`]R`^R`pf`R`RbIfbWfbYfbZfb[fb\fb¿fb%fb'fb7fbûfbýfb4fb5fb]fb^fbpfbfbfjÿìj ÿìjÿìj ÿìlÿ®lÿ®lÿìl¤ÿ×l¦ÿìl¨ÿ×lªÿ×l®ÿ×l°ÿ×l±ÿìlµÿ×l¼ÿÃl½ÿ×l¿ÿ×lÁÿ×lÄÿìlÇÿìlÎÿìlÕÿìlòÿìlÿ®l ÿ®lrÿ×lsÿìlzÿìl|ÿ×l€ÿìl‚ÿìlŸÿ×l¡ÿìl©ÿìlµÿÃl·ÿìl¹ÿìl»ÿ×l½ÿìl¿ÿ×lÁÿ×lÊÿ×lÎÿ×lÏÿìlÔÿ×lÙÿ×lÛÿ×lÝÿ×låÿ×lçÿìlõÿìl÷ÿ×lùÿ×lûÿ×lýÿ×lÿ×lÿ×l ÿ×lÿ×lÿ×lÿìlÿìlÿ×lÿìmÿ®mÿ®mÎÿ×mÕÿ×mòÿ×mÿ®m ÿ®msÿ×mÏÿ×mÿ×mÿ×nÿ®n ÿ®nÿ×n¦ÿ×n¼ÿ®nÁÿ®nÄÿ×nÜÿ×näÿ×nÿ®n ÿ®n|ÿ®n€ÿÃn‚ÿÃn©ÿ×nªÿ×nµÿ®n¶ÿ×n·ÿÃn¹ÿÃn½ÿ×n¾ÿ×n¿ÿ®nÁÿ®nÔÿ®nýÿ®n ÿšnÿšnÿ×nÿ×oÿ…o ÿ…oÐÿ×oÜÿšoÝÿÃoßÿ×oáÿ®oäÿšoöÿÃoÿ…o ÿ…omÿ×oÿ×oƒÿ×o‹ÿ×o ÿ×oªÿšo¶ÿšo¸ÿÃoºÿÃo¼ÿ×o¾ÿšoÀÿ®oÂÿ®oÆÿ×oÈÿ×oËÿ×oÕÿ®oæÿ×oêÿ×oøÿÃoúÿÃoüÿÃoþÿ®oÿ×oÿ×oÿšoÿšoÿšpŸÿ×p¸ÿ×p»ÿ×p¾ÿ×páÿ×plÿ×p~ÿ×p„ÿ×p†ÿ×pˆÿ×pŠÿ×pŒÿ×p±ÿ×p³ÿ×pÀÿ×pÂÿ×pÅÿ×pÇÿ×pÕÿ×pïÿ×pñÿ×póÿ×pþÿ×p ÿ×p ÿ×pÿ×pÿ×pÿ×rÿqr ÿqrÿšr¦ÿšr¼ÿqr¾ÿ×rÁÿšrÄÿšrÜÿ×ráÿ×räÿ×rÿqr ÿqrnÿ×r|ÿšr€ÿ®r‚ÿ®r—ÿ×r›ÿ×r§ÿ×r©ÿšrªÿ×rµÿqr¶ÿ×r·ÿ…r¹ÿ…r½ÿšr¾ÿ×r¿ÿšrÀÿ×rÁÿšrÂÿ×rÅÿšrÇÿšrÔÿšrÕÿ×ráÿ×rãÿ×rýÿšrþÿ×rÿ×r ÿqrÿ×rÿqrÿ×rÿšrÿ×sÿqs ÿqsÏÿ×sØÿ×sÛÿ×sÜÿšsÝÿÃsÞÿ×sáÿÃsäÿšsêÿ×síÿ×söÿÃsÿqs ÿqsjÿ×smÿ×s}ÿìsÿ×sÿ×sƒÿ×s…ÿ×s‡ÿ×s‰ÿ×s‹ÿ×sÿ×sªÿšs²ÿ×s´ÿ×s¶ÿšs¸ÿ×sºÿ×s¾ÿšsÀÿÃsÂÿÃsÆÿ×sÈÿ×sÕÿÃsàÿ×sðÿ×sòÿ×sôÿ×søÿÃsúÿÃsüÿÃsþÿÃs ÿ×s ÿ×sÿ…sÿ…sÿ×sÿšsÿ×tÿqt ÿqtÿšt¦ÿšt¼ÿqt¾ÿ×tÁÿštÄÿštÜÿ×táÿ×täÿ×tÿqt ÿqtnÿ×t|ÿšt€ÿ®t‚ÿ®t—ÿ×t›ÿ×t§ÿ×t©ÿštªÿ×tµÿqt¶ÿ×t·ÿ…t¹ÿ…t½ÿšt¾ÿ×t¿ÿštÀÿ×tÁÿštÂÿ×tÅÿštÇÿštÔÿštÕÿ×táÿ×tãÿ×týÿštþÿ×tÿ×t ÿqtÿ×tÿqtÿ×tÿštÿ×uÿqu ÿquÏÿ×uØÿ×uÛÿ×uÜÿšuÝÿÃuÞÿ×uáÿÃuäÿšuêÿ×uíÿ×uöÿÃuÿqu ÿqujÿ×umÿ×u}ÿìuÿ×uÿ×uƒÿ×u…ÿ×u‡ÿ×u‰ÿ×u‹ÿ×uÿ×uªÿšu²ÿ×u´ÿ×u¶ÿšu¸ÿ×uºÿ×u¾ÿšuÀÿÃuÂÿÃuÆÿ×uÈÿ×uÕÿÃuàÿ×uðÿ×uòÿ×uôÿ×uøÿÃuúÿÃuüÿÃuþÿÃu ÿ×u ÿ×uÿ…uÿ…uÿ×uÿšuÿ×v ÿìvÿìx ÿìxÿìzÿ®zÿ®zÿ®z ÿ®z€ÿìz‚ÿìz·ÿìz¹ÿìz ÿ×zÿ×|ÿq|ÿq|¤ÿÃ|ªÿ®|®ÿÃ|µÿÃ|Îÿ×|Õÿ×|òÿ×|ÿq| ÿq|rÿ®|sÿ×|ÎÿÃ|Ïÿ×|Ùÿ®|Ûÿ®|Ýÿ®| ÿ®| ÿ®|ÿÃ|ÿ×|ÿÃ|ÿ×}ÿì} ÿì}Ðÿ×}Üÿì}Ýÿì}ßÿ×}áÿì}äÿì}öÿì}ÿì} ÿì} ÿ×}ªÿì}¶ÿì}¼ÿ×}¾ÿì}Àÿì}Âÿì}Ëÿ×}Õÿì}æÿ×}øÿì}úÿì}üÿì}þÿì}ÿ×}ÿ×}ÿì}ÿì}ÿì~ÿ®~ÿ®~ÿì~¤ÿ×~¦ÿì~¨ÿ×~ªÿ×~®ÿ×~°ÿ×~±ÿì~µÿ×~¼ÿÃ~½ÿ×~¿ÿ×~Áÿ×~Äÿì~Çÿì~Îÿì~Õÿì~òÿì~ÿ®~ ÿ®~rÿ×~sÿì~zÿì~|ÿ×~€ÿì~‚ÿì~Ÿÿ×~¡ÿì~©ÿì~µÿÃ~·ÿì~¹ÿì~»ÿ×~½ÿì~¿ÿ×~Áÿ×~Êÿ×~Îÿ×~Ïÿì~Ôÿ×~Ùÿ×~Ûÿ×~Ýÿ×~åÿ×~çÿì~õÿì~÷ÿ×~ùÿ×~ûÿ×~ýÿ×~ÿ×~ÿ×~ ÿ×~ÿ×~ÿ×~ÿì~ÿì~ÿ×~ÿìÿì ÿìÐÿ×ÜÿìÝÿìßÿ×áÿìäÿìöÿìÿì ÿì ÿתÿì¶ÿì¼ÿ×¾ÿìÀÿìÂÿìËÿ×Õÿìæÿ×øÿìúÿìüÿìþÿìÿ×ÿ×ÿìÿìÿì€ÿ…€ÿ…€Ÿÿ쀤ÿš€ªÿq€®ÿš€µÿš€¸ÿ쀻ÿ쀾ÿÀÉÿì€Îÿ®€Ïÿ×€Õÿ®€Øÿ×€Ûÿ×€Þÿ×€áÿ×€êÿ×€ëf€íÿ×€îÿì€òÿ®€ôf€ÿ…€ ÿ…€jÿ×€lÿì€rÿq€sÿ®€~ÿì€ÿ×€„ÿ쀅ÿ×€†ÿ쀇ÿ×€ˆÿ쀉ÿ×€Šÿ쀌ÿì€ÿ×€˜f€¨f€±ÿ쀲ÿ×€³ÿ쀴ÿ×€Àÿ×€Âÿ×€Åÿ×€ÆÿÀÇÿ×€ÈÿÀÎÿš€Ïÿ®€Õÿ×€Ùÿq€Ûÿq€Ýÿq€àÿ×€ïÿì€ðÿ×€ñÿì€òÿ×€óÿì€ôÿ×€þÿ×€ ÿq€ ÿ×€ ÿq€ ÿ×€ÿš€ÿ®€ÿì€ÿ×€ÿ×€ÿš€ÿ®ÿ®ÿ®Îÿ×Õÿ×òÿ×ÿ® ÿ®sÿ×Ïÿ×ÿ×ÿׂÿ…‚ÿ…‚Ÿÿ삤ÿš‚ªÿq‚®ÿš‚µÿš‚¸ÿì‚»ÿ삾ÿÂÉÿì‚Îÿ®‚ÏÿׂÕÿ®‚ØÿׂÛÿׂÞÿׂáÿׂêÿׂëf‚íÿׂîÿì‚òÿ®‚ôf‚ÿ…‚ ÿ…‚jÿׂlÿì‚rÿq‚sÿ®‚~ÿì‚ÿׂ„ÿì‚…ÿׂ†ÿ삇ÿׂˆÿ삉ÿׂŠÿì‚Œÿì‚ÿׂ˜f‚¨f‚±ÿ삲ÿׂ³ÿì‚´ÿׂÀÿׂÂÿׂÅÿׂÆÿÂÇÿׂÈÿÂÎÿš‚Ïÿ®‚ÕÿׂÙÿq‚Ûÿq‚Ýÿq‚àÿׂïÿì‚ðÿׂñÿì‚òÿׂóÿì‚ôÿׂþÿׂ ÿq‚ ÿׂ ÿq‚ ÿׂÿš‚ÿ®‚ÿì‚ÿׂÿׂÿš‚ÿ®ƒÿ®ƒÿ®ƒÎÿ׃Õÿ׃òÿ׃ÿ®ƒ ÿ®ƒsÿ׃Ïÿ׃ÿ׃ÿׄÿ®„ÿ®„ÎÿׄÕÿׄòÿׄÿ®„ ÿ®„sÿׄÏÿׄÿׄÿ×…ÿ®…ÿ®…Îÿ×…Õÿ×…òÿ×…ÿ®… ÿ®…sÿ×…Ïÿ×…ÿ×…ÿ׆ÿ®†ÿ®†ÿ솤ÿ׆¦ÿ솨ÿ׆ªÿ׆®ÿ׆°ÿ׆±ÿ솵ÿ׆¼ÿƽÿ׆¿ÿ׆Áÿ׆Äÿì†Çÿì†Îÿì†Õÿì†òÿì†ÿ®† ÿ®†rÿ׆sÿì†zÿì†|ÿ׆€ÿ솂ÿ솟ÿ׆¡ÿ솩ÿ솵ÿÆ·ÿ솹ÿ솻ÿ׆½ÿ솿ÿ׆Áÿ׆Êÿ׆Îÿ׆Ïÿì†Ôÿ׆Ùÿ׆Ûÿ׆Ýÿ׆åÿ׆çÿì†õÿì†÷ÿ׆ùÿ׆ûÿ׆ýÿ׆ÿ׆ÿ׆ ÿ׆ÿ׆ÿ׆ÿì†ÿì†ÿ׆ÿì‡ÿì‡ ÿì‡ÐÿׇÜÿì‡Ýÿì‡ßÿׇáÿì‡äÿì‡öÿì‡ÿì‡ ÿ쇠ÿׇªÿ쇶ÿ쇼ÿׇ¾ÿì‡Àÿì‡Âÿì‡ËÿׇÕÿì‡æÿׇøÿì‡úÿì‡üÿì‡þÿì‡ÿׇÿׇÿì‡ÿì‡ÿìˆÿ®ˆÿ®ˆÿ숤ÿ׈¦ÿ숨ÿ׈ªÿ׈®ÿ׈°ÿ׈±ÿ숵ÿ׈¼ÿȽÿ׈¿ÿ׈Áÿ׈ÄÿìˆÇÿìˆÎÿìˆÕÿìˆòÿìˆÿ®ˆ ÿ®ˆrÿ׈sÿìˆzÿìˆ|ÿ׈€ÿ숂ÿ숟ÿ׈¡ÿ숩ÿ숵ÿÈ·ÿ숹ÿ숻ÿ׈½ÿ숿ÿ׈Áÿ׈Êÿ׈Îÿ׈ÏÿìˆÔÿ׈Ùÿ׈Ûÿ׈Ýÿ׈åÿ׈çÿìˆõÿìˆ÷ÿ׈ùÿ׈ûÿ׈ýÿ׈ÿ׈ÿ׈ ÿ׈ÿ׈ÿ׈ÿìˆÿìˆÿ׈ÿì‰ÿì‰ ÿì‰Ðÿ׉Üÿì‰Ýÿì‰ßÿ׉áÿì‰äÿì‰öÿì‰ÿì‰ ÿ쉠ÿ׉ªÿ쉶ÿ쉼ÿ׉¾ÿì‰Àÿì‰Âÿì‰Ëÿ׉Õÿì‰æÿ׉øÿì‰úÿì‰üÿì‰þÿì‰ÿ׉ÿ׉ÿì‰ÿì‰ÿìŠÿ®Šÿ®Šÿ스ÿ׊¦ÿ슨ÿ׊ªÿ׊®ÿ׊°ÿ׊±ÿ습ÿ׊¼ÿʽÿ׊¿ÿ׊Áÿ׊ÄÿìŠÇÿìŠÎÿìŠÕÿìŠòÿìŠÿ®Š ÿ®Šrÿ׊sÿìŠzÿìŠ|ÿ׊€ÿ슂ÿ슟ÿ׊¡ÿ슩ÿ습ÿÊ·ÿ승ÿ슻ÿ׊½ÿ슿ÿ׊Áÿ׊Êÿ׊Îÿ׊ÏÿìŠÔÿ׊Ùÿ׊Ûÿ׊Ýÿ׊åÿ׊çÿìŠõÿìŠ÷ÿ׊ùÿ׊ûÿ׊ýÿ׊ÿ׊ÿ׊ ÿ׊ÿ׊ÿ׊ÿìŠÿìŠÿ׊ÿì‹ÿ®‹ÿ®‹Îÿ׋Õÿ׋òÿ׋ÿ®‹ ÿ®‹sÿ׋Ïÿ׋ÿ׋ÿ׌Ÿÿ׌¸ÿ׌»ÿ׌¾ÿ׌áÿ׌lÿ׌~ÿ׌„ÿ׌†ÿ׌ˆÿ׌Šÿ׌Œÿ׌±ÿ׌³ÿ׌Àÿ׌Âÿ׌Åÿ׌Çÿ׌Õÿ׌ïÿ׌ñÿ׌óÿ׌þÿ׌ ÿ׌ ÿ׌ÿ׌ÿ׌ÿו£á•ê)•ÿוÿ×–ÿì– ÿì–ÿì– ÿì—ÿ®— ÿ®—ÿ×—¦ÿ×—¼ÿ®—Áÿ®—Äÿ×—Üÿ×—äÿ×—ÿ®— ÿ®—|ÿ®—€ÿׂÿשÿ×—ªÿ×—µÿ®—¶ÿ×—·ÿ×¹ÿ×½ÿ×—¾ÿ×—¿ÿ®—Áÿ®—Ôÿ®—ýÿ®— ÿš—ÿš—ÿ×—ÿטÿ…˜ ÿ…˜ÐÿטÜÿš˜ÝÿØßÿטáÿ®˜äÿš˜öÿØÿ…˜ ÿ…˜mÿטÿטƒÿט‹ÿט ÿטªÿš˜¶ÿš˜¸ÿغÿؼÿט¾ÿš˜Àÿ®˜Âÿ®˜ÆÿטÈÿטËÿטÕÿ®˜æÿטêÿטøÿØúÿØüÿØþÿ®˜ÿטÿטÿš˜ÿš˜ÿš™þö™þö™¤ÿ…™ªÿš™®ÿ…™°ÿ×™µÿ…™¿ÿ×™Îÿš™Õÿš™òÿš™þö™ þö™rÿš™sÿš™vÿ왟ÿ×™»ÿ×™Êÿ×™Îÿ…™Ïÿš™Ùÿš™Ûÿš™Ýÿš™åÿ×™ÿ×™ÿ×™ ÿ®™ ÿ®™ÿ…™ÿš™ÿ…™ÿššÿìš ÿìšÐÿךÜÿìšÝÿìšßÿךáÿìšäÿìšöÿìšÿìš ÿìš ÿךªÿ욶ÿìš¼ÿך¾ÿìšÀÿìšÂÿìšËÿךÕÿìšæÿךøÿìšúÿìšüÿìšþÿìšÿךÿךÿìšÿìšÿì›ÿš›ÿ×›ÿš›)›Ÿÿ×›¤ÿ®›¦)›ªÿ…›®ÿ®›µÿ®›¸ÿ×›»ÿ×›¼)›¾ÿÛÄ)›ÌÿÛÍÿÛÎÿš›Ïÿ®›Ðÿ×›Ñÿ×›ÒÿÛÓÿÛÔÿÛÕÿš›ÖÿÛ×ÿÛØÿ®›ÙÿÛÚÿÛÛÿ®›Þÿ®›ßÿ×›àÿÛáÿš›âÿÛãÿÛåÿÛæÿÛçÿ×›èÿÛêÿ®›ë)›ìÿÛíÿ®›îÿÛòÿš›óÿÛô)›õÿÛ÷ÿÛùÿÛÿ×›ÿ×›ÿ×›ÿš› ÿš›jÿ®›kÿÛlÿ×›qÿÛrÿ…›sÿš›uÿÛwÿ×›yÿÛ}ÿÛ~ÿ×›ÿ®›„ÿ×›…ÿ®›†ÿ×›‡ÿ®›ˆÿ×›‰ÿ®›Šÿ×›Œÿ×›ÿ®›–ÿÛ˜)›šÿÛžÿÛ ÿ×›¢ÿ×›¤ÿÛ¦ÿÛ¨)›©)›¬ÿÛ®ÿÛ°ÿÛ±ÿ×›²ÿ®›³ÿ×›´ÿ®›µ)›¼ÿ×›½)›Àÿš›Âÿš›ÄÿÛÅÿ×›ÆÿÛÇÿ×›ÈÿÛËÿ×›ÍÿÛÎÿ®›Ïÿš›ÑÿÛÓÿÛÕÿš›×ÿÛÙÿ…›Ûÿ…›Ýÿ…›àÿ®›æÿ×›èÿ×›ìÿÛîÿÛïÿ×›ðÿ®›ñÿ×›òÿ®›óÿ×›ôÿ®›öÿ×›þÿš›ÿÛÿÛÿ×›ÿ×› ÿš› ÿ®› ÿš› ÿ®›ÿ×›ÿ×›ÿ®›ÿš›ÿÛÿ×›ÿ®›)›ÿ®›ÿ®›ÿšœÿÃœÿÃœÎÿÃœÏÿלÕÿÃœØÿלÛÿלÞÿלêÿלíÿלòÿÃœÿÃœ ÿÃœjÿלsÿÃœÿל…ÿל‡ÿל‰ÿלÿל²ÿל´ÿלÏÿÃœàÿלðÿלòÿלôÿל ÿל ÿלÿÃœÿלÿלÿÃÿà ÿÃÿãf¦ÿüÿÃÁÿ®ÄÿÃÜÿ×áÿ×äÿ×ÿà ÿÃ|ÿ®€ÿÂÿéÿêÿ×µÿöÿ×·ÿ×¹ÿ×½ÿþÿ׿ÿ®Àÿ×Áÿ®Âÿ×Ôÿ®Õÿ×ýÿ®þÿ× ÿ×ÿÃÿ×ÿÃÿÃÿמÿÞ ÿÞÿÞ ÿÞÿמÿןŸÿן£áŸ¸ÿן»ÿן¾ÿßÜÿןáÿ®Ÿäÿןlÿן{=Ÿ}ÿìŸ~ÿן„ÿן†ÿןˆÿןŠÿןŒÿןªÿן±ÿן³ÿן¶ÿן¾ÿןÀÿ®ŸÂÿ®ŸÅÿßÆÿןÇÿßÈÿןÕÿ®Ÿïÿןñÿןóÿןþÿ®Ÿÿןÿןÿןÿ× Ïÿì Øÿì Ûÿì Þÿì áÿì êÿì íÿì jÿì ÿì …ÿì ‡ÿì ‰ÿì ÿì ²ÿì ´ÿì Àÿì Âÿì Õÿì àÿì ðÿì òÿì ôÿì þÿì  ÿì  ÿì ÿ× ÿ× ÿì ÿì¡ÿ®¡ÿ®¡ÿ®¡ ÿ®¡€ÿì¡‚ÿì¡·ÿ졹ÿì¡ ÿסÿ×¢é)£Ÿÿ×££á£¸ÿ×£»ÿ×£¾ÿãÜÿ×£áÿ®£äÿ×£lÿ×£{=£}ÿì£~ÿ×£„ÿ×£†ÿ×£ˆÿ×£Šÿ×£Œÿ×£ªÿ×£±ÿ×£³ÿ×£¶ÿ×£¾ÿ×£Àÿ®£Âÿ®£ÅÿãÆÿ×£ÇÿãÈÿ×£Õÿ®£ïÿ×£ñÿ×£óÿ×£þÿ®£ÿ×£ÿ×£ÿ×£ÿפÏÿì¤Øÿì¤Ûÿì¤Þÿì¤áÿì¤êÿì¤íÿì¤jÿì¤ÿ줅ÿ줇ÿ줉ÿì¤ÿ줲ÿ줴ÿì¤Àÿì¤Âÿì¤Õÿì¤àÿì¤ðÿì¤òÿì¤ôÿì¤þÿì¤ ÿì¤ ÿì¤ÿפÿפÿì¤ÿ쥟ÿ×¥¸ÿ×¥»ÿ×¥¾ÿ×¥Áÿ×¥áÿ×¥lÿ×¥|ÿ×¥~ÿ×¥„ÿ×¥†ÿ×¥ˆÿ×¥Šÿ×¥Œÿ×¥±ÿ×¥³ÿ×¥¿ÿ×¥Àÿ×¥Áÿ×¥Âÿ×¥Åÿš¥Çÿš¥Ôÿ×¥Õÿ×¥ïÿ×¥ñÿ×¥óÿ×¥ýÿ×¥þÿ×¥ ÿ×¥ ÿ×¥ÿ×¥ÿ×¥ÿ×¥ÿì¦ÏÿצØÿצÛÿצÞÿצáÿצêÿצíÿצjÿצÿצ…ÿצ‡ÿצ‰ÿצÿצ²ÿצ´ÿצÀÿצÂÿצÆÿצÈÿצÕÿצàÿצðÿצòÿצôÿצþÿצ ÿצ ÿצÿצÿקŸÿק¸ÿק»ÿק¾ÿקÁÿקáÿקlÿק|ÿק~ÿק„ÿק†ÿקˆÿקŠÿקŒÿק±ÿק³ÿק¿ÿקÀÿקÁÿקÂÿקÅÿš§Çÿš§ÔÿקÕÿקïÿקñÿקóÿקýÿקþÿק ÿק ÿקÿקÿקÿקÿì¨ÏÿרØÿרÛÿרÞÿרáÿרêÿרíÿרjÿרÿר…ÿר‡ÿר‰ÿרÿר²ÿר´ÿרÀÿרÂÿרÆÿרÈÿרÕÿרàÿרðÿרòÿרôÿרþÿר ÿר ÿרÿרÿשŸÿש¸ÿש»ÿש¾ÿשÁÿשáÿשlÿש|ÿש~ÿש„ÿש†ÿשˆÿשŠÿשŒÿש±ÿש³ÿש¿ÿשÀÿשÁÿשÂÿשÅÿš©Çÿš©ÔÿשÕÿשïÿשñÿשóÿשýÿשþÿש ÿש ÿשÿשÿשÿשÿìªÏÿתØÿתÛÿתÞÿתáÿתêÿתíÿתjÿתÿת…ÿת‡ÿת‰ÿתÿת²ÿת´ÿתÀÿתÂÿתÆÿתÈÿתÕÿתàÿתðÿתòÿתôÿתþÿת ÿת ÿתÿתÿ׫£á«ê)«ÿ׫ÿ׬ÿì¬ ÿì¬ÿì¬ ÿì­ÿš­ÿ×­ÿš­)­Ÿÿ×­¤ÿ®­¦)­ªÿ…­®ÿ®­µÿ®­¸ÿ×­»ÿ×­¼)­¾ÿíÄ)­ÌÿíÍÿíÎÿš­Ïÿ®­Ðÿ×­Ñÿ×­ÒÿíÓÿíÔÿíÕÿš­Öÿí×ÿíØÿ®­ÙÿíÚÿíÛÿ®­Þÿ®­ßÿ×­àÿíáÿš­âÿíãÿíåÿíæÿíçÿ×­èÿíêÿ®­ë)­ìÿííÿ®­îÿíòÿš­óÿíô)­õÿí÷ÿíùÿíÿ×­ÿ×­ÿ×­ÿš­ ÿš­jÿ®­kÿílÿ×­qÿírÿ…­sÿš­uÿíwÿ×­yÿí}ÿí~ÿ×­ÿ®­„ÿ×­…ÿ®­†ÿ×­‡ÿ®­ˆÿ×­‰ÿ®­Šÿ×­Œÿ×­ÿ®­–ÿí˜)­šÿížÿí ÿ×­¢ÿ×­¤ÿí¦ÿí¨)­©)­¬ÿí®ÿí°ÿí±ÿ×­²ÿ®­³ÿ×­´ÿ®­µ)­¼ÿ×­½)­Àÿš­Âÿš­ÄÿíÅÿ×­ÆÿíÇÿ×­ÈÿíËÿ×­ÍÿíÎÿ®­Ïÿš­ÑÿíÓÿíÕÿš­×ÿíÙÿ…­Ûÿ…­Ýÿ…­àÿ®­æÿ×­èÿ×­ìÿíîÿíïÿ×­ðÿ®­ñÿ×­òÿ®­óÿ×­ôÿ®­öÿ×­þÿš­ÿíÿíÿ×­ÿ×­ ÿš­ ÿ®­ ÿš­ ÿ®­ÿ×­ÿ×­ÿ®­ÿš­ÿíÿ×­ÿ®­)­ÿ®­ÿ®­ÿš®ÿš®ÿ×®ÿš®ÎÿîÏÿì®ÕÿîØÿì®Ûÿì®Þÿì®êÿì®íÿì®òÿîÿ×®ÿ×®ÿ×®ÿš® ÿš®jÿì®sÿîÿì®…ÿ쮇ÿ쮉ÿì®ÿ쮲ÿì®´ÿì®Ïÿîàÿì®ðÿì®òÿì®ôÿì® ÿì® ÿì®ÿîÿì®ÿì®ÿïÿ\¯ ÿ\¯ÿš¯£f¯¦ÿš¯¼ÿH¯Áÿ…¯Äÿš¯Üÿ®¯áÿׯäÿ®¯ÿ\¯ ÿ\¯|ÿ…¯€ÿq¯‚ÿq¯©ÿš¯ªÿ®¯µÿH¯¶ÿ®¯·ÿš¯¹ÿš¯½ÿš¯¾ÿ®¯¿ÿ…¯ÀÿׯÁÿ…¯ÂÿׯÅÿïÆÿׯÇÿïÈÿׯÔÿ…¯Õÿׯýÿ…¯þÿׯ ÿH¯ÿ®¯ÿH¯ÿ®¯ÿš¯ÿ®°ÿq° ÿq°Üÿš°áÿ×°äÿš°ÿq° ÿq°mÿ×°ÿ×°ƒÿ×°‹ÿ×°ªÿš°¶ÿš°¸ÿ×°ºÿ×°¾ÿš°Àÿ×°Âÿ×°Æÿ×°Èÿ×°Õÿ×°þÿ×°ÿq°ÿq°ÿš±ÿ×±¦ÿ×±¼ÿñÄÿ×±€ÿ챂ÿ챩ÿ×±µÿñ·ÿì±¹ÿì±½ÿ×± ÿ×±ÿ×±ÿײÿì² ÿì²ÐÿײÜÿì²Ýÿì²ßÿײáÿì²äÿì²öÿì²ÿì² ÿì² ÿײªÿ첶ÿì²¼ÿײ¾ÿì²Àÿì²Âÿì²ËÿײÕÿì²æÿײøÿì²úÿì²üÿì²þÿì²ÿײÿײÿì²ÿì²ÿ쳟ÿ׳¸ÿ׳»ÿ׳¾ÿ׳áÿ׳lÿ׳~ÿ׳„ÿ׳†ÿ׳ˆÿ׳Šÿ׳Œÿ׳±ÿ׳³ÿ׳Àÿ׳Âÿ׳Åÿ׳Çÿ׳Õÿ׳ïÿ׳ñÿ׳óÿ׳þÿ׳ ÿ׳ ÿ׳ÿ׳ÿ׳ÿ×µÿ…µÿ®µÿ…µŸÿ×µ¤ÿšµªÿqµ®ÿšµµÿšµ¸ÿ×µ»ÿ×µ¼)µ¾ÿ®µÌÿšµÍÿšµÎÿ…µÏÿqµÐÿ×µÑÿ×µÒÿšµÓÿšµÔÿšµÕÿ…µÖÿšµ×ÿšµØÿqµÙÿšµÚÿšµÛÿqµÜÿ®µÝÿ®µÞÿqµßÿ×µàÿšµáÿšµâÿšµãÿšµäÿ®µåÿšµæÿšµçÿ×µèÿšµéÿõêÿqµìÿšµíÿqµîÿ…µòÿ…µóÿšµõÿšµöÿ®µ÷ÿšµùÿšµÿ®µÿ®µÿ®µÿ…µ ÿ…µjÿqµkÿšµlÿ×µmÿ×µqÿšµrÿqµsÿ…µuÿšµwÿšµyÿšµ}ÿšµ~ÿ×µÿqµÿ×µƒÿ×µ„ÿ×µ…ÿqµ†ÿ×µ‡ÿqµˆÿ×µ‰ÿqµŠÿ×µ‹ÿ×µŒÿ×µÿqµ–ÿšµšÿšµžÿšµ ÿ×µ¢ÿ×µ¤ÿšµ¦ÿšµªÿ®µ¬ÿšµ®ÿšµ°ÿšµ±ÿ×µ²ÿqµ³ÿ×µ´ÿqµµ)µ¶ÿ®µ¸ÿ®µºÿ®µ¼ÿ×µ¾ÿ®µÀÿšµÂÿšµÄÿšµÅÿšµÆÿqµÇÿšµÈÿqµËÿ×µÍÿšµÎÿšµÏÿ…µÑÿšµÓÿšµÕÿšµ×ÿšµÙÿqµÛÿqµÝÿqµàÿqµæÿ×µèÿ×µêÿõìÿšµîÿšµïÿ×µðÿqµñÿ×µòÿqµóÿ×µôÿqµöÿ×µøÿ®µúÿ®µüÿ®µþÿšµÿšµÿšµÿ×µÿ×µ ÿqµ ÿqµ ÿqµ ÿqµÿšµÿšµÿšµÿ…µÿšµÿ×µÿqµÿ®µÿqµÿšµÿ…¶ÿš¶ÿ׶ÿš¶ÎÿöÏÿì¶ÕÿöØÿì¶Ûÿì¶Þÿì¶êÿì¶íÿì¶òÿöÿ׶ÿ׶ÿ׶ÿš¶ ÿš¶jÿì¶sÿöÿ춅ÿ춇ÿ춉ÿì¶ÿ춲ÿ춴ÿì¶Ïÿöàÿì¶ðÿì¶òÿì¶ôÿì¶ ÿì¶ ÿì¶ÿöÿì¶ÿì¶ÿ÷ÿ…·ÿ…·Ÿÿ×·¤ÿ®·ªÿ…·®ÿ®·µÿ®·¸ÿ×·»ÿ×·¾ÿ÷Êÿ®·Ìÿ÷Íÿ÷Îÿš·Ïÿš·Òÿ÷Óÿ÷Ôÿ÷Õÿš·Öÿ÷×ÿ÷Øÿš·Ùÿ÷Úÿ÷Ûÿš·Þÿš·àÿ÷áÿ®·âÿ÷ãÿ÷åÿ÷æÿ÷èÿ÷éÿ×·êÿš·ë)·ìÿ÷íÿš·îÿ®·òÿš·óÿ÷ô)·õÿ÷÷ÿ÷ùÿ÷ÿ…· ÿ…·jÿš·kÿ÷lÿ×·qÿ÷rÿ…·sÿš·uÿ÷wÿ×·yÿ÷}ÿ×·~ÿ×·ÿš·„ÿ×·…ÿš·†ÿ×·‡ÿš·ˆÿ×·‰ÿš·Šÿ×·Œÿ×·ÿš·–ÿ÷˜)·šÿ÷žÿ÷¤ÿ÷¦ÿ÷¨)·¬ÿ÷®ÿ÷°ÿ÷±ÿ×·²ÿš·³ÿ×·´ÿš·Àÿ®·Âÿ®·Äÿ÷Æÿ®·Èÿ®·Íÿ÷Îÿ®·Ïÿš·Ñÿ÷Óÿ÷Õÿ®·×ÿ÷Ùÿ…·Úÿ®·Ûÿ…·Üÿ®·Ýÿ…·Þÿ®·àÿš·áÿì·âÿ®·ãÿì·äÿ®·ìÿ÷îÿ÷ïÿ×·ðÿš·ñÿ×·òÿš·óÿ×·ôÿš·þÿ®·ÿ÷ÿ÷ ÿ®· ÿš· ÿ®· ÿš·ÿ×·ÿ×·ÿ®·ÿš·ÿ÷ÿ×·ÿš·ÿì·ÿš·ÿ®·ÿš¸ÿ®¸ÿ®¸Îÿì¸Õÿì¸òÿì¸ÿ®¸ ÿ®¸sÿì¸Ïÿì¸ÿì¸ÿì¹ÿ…¹ÿ…¹Ÿÿ×¹¤ÿ®¹ªÿ…¹®ÿ®¹µÿ®¹¸ÿ×¹»ÿ×¹¾ÿùÊÿ®¹ÌÿùÍÿùÎÿš¹Ïÿš¹ÒÿùÓÿùÔÿùÕÿš¹Öÿù×ÿùØÿš¹ÙÿùÚÿùÛÿš¹Þÿš¹àÿùáÿ®¹âÿùãÿùåÿùæÿùèÿùéÿ×¹êÿš¹ë)¹ìÿùíÿš¹îÿ®¹òÿš¹óÿùô)¹õÿù÷ÿùùÿùÿ…¹ ÿ…¹jÿš¹kÿùlÿ×¹qÿùrÿ…¹sÿš¹uÿùwÿ×¹yÿù}ÿ×¹~ÿ×¹ÿš¹„ÿ×¹…ÿš¹†ÿ×¹‡ÿš¹ˆÿ×¹‰ÿš¹Šÿ×¹Œÿ×¹ÿš¹–ÿù˜)¹šÿùžÿù¤ÿù¦ÿù¨)¹¬ÿù®ÿù°ÿù±ÿ×¹²ÿš¹³ÿ×¹´ÿš¹Àÿ®¹Âÿ®¹ÄÿùÆÿ®¹Èÿ®¹ÍÿùÎÿ®¹Ïÿš¹ÑÿùÓÿùÕÿ®¹×ÿùÙÿ…¹Úÿ®¹Ûÿ…¹Üÿ®¹Ýÿ…¹Þÿ®¹àÿš¹áÿì¹âÿ®¹ãÿì¹äÿ®¹ìÿùîÿùïÿ×¹ðÿš¹ñÿ×¹òÿš¹óÿ×¹ôÿš¹þÿ®¹ÿùÿù ÿ®¹ ÿš¹ ÿ®¹ ÿš¹ÿ×¹ÿ×¹ÿ®¹ÿš¹ÿùÿ×¹ÿš¹ÿì¹ÿš¹ÿ®¹ÿšºÿ®ºÿ®ºÎÿìºÕÿìºòÿìºÿ®º ÿ®ºsÿìºÏÿìºÿìºÿ컟ÿ×»£á»¸ÿ×»»ÿ×»¾ÿûÜÿ×»áÿ®»äÿ×»lÿ×»{=»}ÿì»~ÿ×»„ÿ×»†ÿ×»ˆÿ×»Šÿ×»Œÿ×»ªÿ×»±ÿ×»³ÿ×»¶ÿ×»¾ÿ×»Àÿ®»Âÿ®»ÅÿûÆÿ×»ÇÿûÈÿ×»Õÿ®»ïÿ×»ñÿ×»óÿ×»þÿ®»ÿ×»ÿ×»ÿ×»ÿ×¼Ïÿì¼Øÿì¼Ûÿì¼Þÿì¼áÿì¼êÿì¼íÿì¼jÿì¼ÿì¼…ÿ켇ÿ켉ÿì¼ÿì¼²ÿì¼´ÿì¼Àÿì¼Âÿì¼Õÿì¼àÿì¼ðÿì¼òÿì¼ôÿì¼þÿì¼ ÿì¼ ÿì¼ÿ×¼ÿ×¼ÿì¼ÿì½£á½ê)½ÿ×½ÿ×¾ÿì¾ ÿì¾ÿì¾ ÿì¿£á¿ê)¿ÿ׿ÿ×ÀÿìÀ ÿìÀÿìÀ ÿìÃÿÃà ÿÃÃÿ×æÿ×üÿ…ÃÁÿ®ÃÄÿ×ÃÜÿ×ÃÝÿìÃáÿìÃäÿ×ÃöÿìÃÿÃà ÿÃÃ|ÿ®Ã€ÿÃÂÿÃéÿ×êÿ×õÿ…öÿ×÷ÿšÃ¹ÿšÃ½ÿ×þÿ×ÿÿ®ÃÀÿìÃÁÿ®ÃÂÿìÃÔÿ®ÃÕÿìÃøÿìÃúÿìÃüÿìÃýÿ®Ãþÿìà ÿ®Ãÿ×Ãÿ®Ãÿ×Ãÿ×Ãÿ×ÄÿšÄ ÿšÄÜÿ×ÄÝÿ×Ääÿ×Äöÿ×ÄÿšÄ ÿšÄªÿ×Ķÿ×ĸÿ×ĺÿ׾ÿ×Äøÿ×Äúÿ×Äüÿ×Äÿ®Äÿ®Äÿ׿ÿ×Å€ÿìÅ‚ÿìŵÿ×Å·ÿìŹÿìÅ ÿìÅÿìÆÿìÆ ÿìÆÿìÆ ÿìǼÿ×Ç€ÿìÇ‚ÿìǵÿ×Ç·ÿìǹÿìÇ ÿìÇÿìÈÿìÈ ÿìÈÿìÈ ÿìÊŸÿ×ʸÿ×Ê»ÿ×ʾÿ×ÊÁÿ×Êáÿ×Êlÿ×Ê|ÿ×Ê~ÿ×Ê„ÿ×ʆÿ×ʈÿ×ÊŠÿ×ÊŒÿ×ʱÿ×ʳÿ×Ê¿ÿ×ÊÀÿ×ÊÁÿ×ÊÂÿ×ÊÅÿšÊÇÿšÊÔÿ×ÊÕÿ×Êïÿ×Êñÿ×Êóÿ×Êýÿ×Êþÿ×Ê ÿ×Ê ÿ×Êÿ×Êÿ×Êÿ×ÊÿìËÏÿ×ËØÿ×ËÛÿ×ËÞÿ×Ëáÿ×Ëêÿ×Ëíÿ×Ëjÿ×Ëÿ×Ë…ÿסÿ×ˉÿ×Ëÿ×˲ÿ×Ë´ÿ×ËÀÿ×ËÂÿ×ËÆÿ×ËÈÿ×ËÕÿ×Ëàÿ×Ëðÿ×Ëòÿ×Ëôÿ×Ëþÿ×Ë ÿ×Ë ÿ×Ëÿ×Ëÿ×ÌÿÃÌ ÿÃÌ£f̼ÿ×̾ÿ×ÌÁÿ®ÌÜÿÃÌáÿ×ÌäÿÃÌÿÃÌ ÿÃÌmÿìÌ|ÿ®Ì€ÿ×ÌÿìÌ‚ÿ×̃ÿìÌ‹ÿì̪ÿÃ̵ÿ×̶ÿÃÌ·ÿ×̸ÿì̹ÿ×̺ÿì̾ÿÃÌ¿ÿ®ÌÀÿ×ÌÁÿ®ÌÂÿ×ÌÅÿÃÌÆÿ×ÌÇÿÃÌÈÿ×ÌÔÿ®ÌÕÿ×Ìýÿ®Ìþÿ×Ì ÿ×ÌÿÃÌÿ×ÌÿÃÌÿÃÍáÿ×ÍÀÿ×ÍÂÿ×ÍÕÿ×Íþÿ×ΣáÎê)Îÿ×Îÿ×ÏÿìÏ ÿìÏÿìÏ ÿìÒ£áÒê)Òÿ×Òÿ×ÓÿìÓ ÿìÓÿìÓ ÿìÖ£áÖê)Öÿ×Öÿ××ÿì× ÿì×ÿì× ÿìÙÿqÙ ÿqÙÿšÙ¦ÿšÙ¼ÿqÙ¾ÿ×ÙÁÿšÙÄÿšÙÜÿ×Ùáÿ×Ùäÿ×ÙÿqÙ ÿqÙnÿ×Ù|ÿšÙ€ÿ®Ù‚ÿ®Ù—ÿ×Ù›ÿ×Ù§ÿ×Ù©ÿšÙªÿ×ÙµÿqÙ¶ÿ×Ù·ÿ…Ù¹ÿ…Ù½ÿšÙ¾ÿ×Ù¿ÿšÙÀÿ×ÙÁÿšÙÂÿ×ÙÅÿšÙÇÿšÙÔÿšÙÕÿ×Ùáÿ×Ùãÿ×ÙýÿšÙþÿ×Ùÿ×Ù ÿqÙÿ×ÙÿqÙÿ×ÙÿšÙÿ×ÚÿìÚ ÿìÚÿìÚ ÿìÛÿqÛ ÿqÛÿšÛ¦ÿšÛ¼ÿqÛ¾ÿ×ÛÁÿšÛÄÿšÛÜÿ×Ûáÿ×Ûäÿ×ÛÿqÛ ÿqÛnÿ×Û|ÿšÛ€ÿ®Û‚ÿ®Û—ÿ×Û›ÿ×Û§ÿ×Û©ÿšÛªÿ×ÛµÿqÛ¶ÿ×Û·ÿ…Û¹ÿ…Û½ÿšÛ¾ÿ×Û¿ÿšÛÀÿ×ÛÁÿšÛÂÿ×ÛÅÿšÛÇÿšÛÔÿšÛÕÿ×Ûáÿ×Ûãÿ×ÛýÿšÛþÿ×Ûÿ×Û ÿqÛÿ×ÛÿqÛÿ×ÛÿšÛÿ×ÜÿìÜ ÿìÜÿìÜ ÿìÞÿìÞ ÿìÞÿìÞ ÿìàÿìà ÿìàÿìà ÿìáÿ®áÿ®áÿìá¤ÿ×á¦ÿìá¨ÿ×áªÿ×á®ÿ×á°ÿ×á±ÿìáµÿ×á¼ÿÃá½ÿ×á¿ÿ×áÁÿ×áÄÿìáÇÿìáÎÿìáÕÿìáòÿìáÿ®á ÿ®árÿ×ásÿìázÿìá|ÿ×á€ÿìá‚ÿìáŸÿ×á¡ÿìá©ÿìáµÿÃá·ÿìá¹ÿìá»ÿ×á½ÿìá¿ÿ×áÁÿ×áÊÿ×áÎÿ×áÏÿìáÔÿ×áÙÿ×áÛÿ×áÝÿ×áåÿ×áçÿìáõÿìá÷ÿ×áùÿ×áûÿ×áýÿ×áÿ×áÿ×á ÿ×áÿ×áÿ×áÿìáÿìáÿ×áÿìâÿìâ ÿìâÐÿ×âÜÿìâÝÿìâßÿ×âáÿìâäÿìâöÿìâÿìâ ÿìâ ÿ×âªÿìâ¶ÿìâ¼ÿ×â¾ÿìâÀÿìâÂÿìâËÿ×âÕÿìâæÿ×âøÿìâúÿìâüÿìâþÿìâÿ×âÿ×âÿìâÿìâÿìãÿ®ãÿ®ãÿìã¤ÿ×ã¦ÿìã¨ÿ×ãªÿ×ã®ÿ×ã°ÿ×ã±ÿìãµÿ×ã¼ÿÃã½ÿ×ã¿ÿ×ãÁÿ×ãÄÿìãÇÿìãÎÿìãÕÿìãòÿìãÿ®ã ÿ®ãrÿ×ãsÿìãzÿìã|ÿ×ã€ÿìã‚ÿìãŸÿ×ã¡ÿìã©ÿìãµÿÃã·ÿìã¹ÿìã»ÿ×ã½ÿìã¿ÿ×ãÁÿ×ãÊÿ×ãÎÿ×ãÏÿìãÔÿ×ãÙÿ×ãÛÿ×ãÝÿ×ãåÿ×ãçÿìãõÿìã÷ÿ×ãùÿ×ãûÿ×ãýÿ×ãÿ×ãÿ×ã ÿ×ãÿ×ãÿ×ãÿìãÿìãÿ×ãÿìäÿìä ÿìäÐÿ×äÜÿìäÝÿìäßÿ×äáÿìääÿìäöÿìäÿìä ÿìä ÿ×äªÿìä¶ÿìä¼ÿ×ä¾ÿìäÀÿìäÂÿìäËÿ×äÕÿìäæÿ×äøÿìäúÿìäüÿìäþÿìäÿ×äÿ×äÿìäÿìäÿìåŸÿ×å¸ÿ×å»ÿ×å¾ÿ×åÁÿ×åáÿ×ålÿ×å|ÿ×å~ÿ×å„ÿ×å†ÿ×åˆÿ×åŠÿ×åŒÿ×å±ÿ×å³ÿ×å¿ÿ×åÀÿ×åÁÿ×åÂÿ×åÅÿšåÇÿšåÔÿ×åÕÿ×åïÿ×åñÿ×åóÿ×åýÿ×åþÿ×å ÿ×å ÿ×åÿ×åÿ×åÿ×åÿìæÏÿ×æØÿ×æÛÿ×æÞÿ×æáÿ×æêÿ×æíÿ×æjÿ×æÿ×æ…ÿ×æ‡ÿ×æ‰ÿ×æÿ×æ²ÿ×æ´ÿ×æÀÿ×æÂÿ×æÆÿ×æÈÿ×æÕÿ×æàÿ×æðÿ×æòÿ×æôÿ×æþÿ×æ ÿ×æ ÿ×æÿ×æÿ×çÿ®çÿ®çÿ®ç ÿ®ç€ÿìç‚ÿìç·ÿìç¹ÿìç ÿ×çÿ×èé)éÿìé ÿìéÿìé ÿìéÿ×éÿ×ïÿ®ïÿ®ïÿìï¤ÿ×ï¦ÿìï¨ÿ×ïªÿ×ï®ÿ×ï°ÿ×ï±ÿìïµÿ×ï¼ÿÃï½ÿ×ï¿ÿ×ïÁÿ×ïÄÿìïÇÿìïÎÿìïÕÿìïòÿìïÿ®ï ÿ®ïrÿ×ïsÿìïzÿìï|ÿ×ï€ÿìï‚ÿìïŸÿ×ï¡ÿìï©ÿìïµÿÃï·ÿìï¹ÿìï»ÿ×ï½ÿìï¿ÿ×ïÁÿ×ïÊÿ×ïÎÿ×ïÏÿìïÔÿ×ïÙÿ×ïÛÿ×ïÝÿ×ïåÿ×ïçÿìïõÿìï÷ÿ×ïùÿ×ïûÿ×ïýÿ×ïÿ×ïÿ×ï ÿ×ïÿ×ïÿ×ïÿìïÿìïÿ×ïÿìðÿìð ÿìðÐÿ×ðÜÿìðÝÿìðßÿ×ðáÿìðäÿìðöÿìðÿìð ÿìð ÿ×ðªÿìð¶ÿìð¼ÿ×ð¾ÿìðÀÿìðÂÿìðËÿ×ðÕÿìðæÿ×ðøÿìðúÿìðüÿìðþÿìðÿ×ðÿ×ðÿìðÿìðÿìñÿ®ñÿ®ñÿìñ¤ÿ×ñ¦ÿìñ¨ÿ×ñªÿ×ñ®ÿ×ñ°ÿ×ñ±ÿìñµÿ×ñ¼ÿÃñ½ÿ×ñ¿ÿ×ñÁÿ×ñÄÿìñÇÿìñÎÿìñÕÿìñòÿìñÿ®ñ ÿ®ñrÿ×ñsÿìñzÿìñ|ÿ×ñ€ÿìñ‚ÿìñŸÿ×ñ¡ÿìñ©ÿìñµÿÃñ·ÿìñ¹ÿìñ»ÿ×ñ½ÿìñ¿ÿ×ñÁÿ×ñÊÿ×ñÎÿ×ñÏÿìñÔÿ×ñÙÿ×ñÛÿ×ñÝÿ×ñåÿ×ñçÿìñõÿìñ÷ÿ×ñùÿ×ñûÿ×ñýÿ×ñÿ×ñÿ×ñ ÿ×ñÿ×ñÿ×ñÿìñÿìñÿ×ñÿìòÿìò ÿìòÐÿ×òÜÿìòÝÿìòßÿ×òáÿìòäÿìòöÿìòÿìò ÿìò ÿ×òªÿìò¶ÿìò¼ÿ×ò¾ÿìòÀÿìòÂÿìòËÿ×òÕÿìòæÿ×òøÿìòúÿìòüÿìòþÿìòÿ×òÿ×òÿìòÿìòÿìóÿ®óÿ®óÿìó¤ÿ×ó¦ÿìó¨ÿ×óªÿ×ó®ÿ×ó°ÿ×ó±ÿìóµÿ×ó¼ÿÃó½ÿ×ó¿ÿ×óÁÿ×óÄÿìóÇÿìóÎÿìóÕÿìóòÿìóÿ®ó ÿ®órÿ×ósÿìózÿìó|ÿ×ó€ÿìó‚ÿìóŸÿ×ó¡ÿìó©ÿìóµÿÃó·ÿìó¹ÿìó»ÿ×ó½ÿìó¿ÿ×óÁÿ×óÊÿ×óÎÿ×óÏÿìóÔÿ×óÙÿ×óÛÿ×óÝÿ×óåÿ×óçÿìóõÿìó÷ÿ×óùÿ×óûÿ×óýÿ×óÿ×óÿ×ó ÿ×óÿ×óÿ×óÿìóÿìóÿ×óÿìôÿìô ÿìôÐÿ×ôÜÿìôÝÿìôßÿ×ôáÿìôäÿìôöÿìôÿìô ÿìô ÿ×ôªÿìô¶ÿìô¼ÿ×ô¾ÿìôÀÿìôÂÿìôËÿ×ôÕÿìôæÿ×ôøÿìôúÿìôüÿìôþÿìôÿ×ôÿ×ôÿìôÿìôÿìõÿ®õÿ®õÿìõ¤ÿ×õ¦ÿìõ¨ÿ×õªÿ×õ®ÿ×õ°ÿ×õ±ÿìõµÿ×õ¼ÿÃõ½ÿ×õ¿ÿ×õÁÿ×õÄÿìõÇÿìõÎÿìõÕÿìõòÿìõÿ®õ ÿ®õrÿ×õsÿìõzÿìõ|ÿ×õ€ÿìõ‚ÿìõŸÿ×õ¡ÿìõ©ÿìõµÿÃõ·ÿìõ¹ÿìõ»ÿ×õ½ÿìõ¿ÿ×õÁÿ×õÊÿ×õÎÿ×õÏÿìõÔÿ×õÙÿ×õÛÿ×õÝÿ×õåÿ×õçÿìõõÿìõ÷ÿ×õùÿ×õûÿ×õýÿ×õÿ×õÿ×õ ÿ×õÿ×õÿ×õÿìõÿìõÿ×õÿìöÿìö ÿìöÐÿ×öÜÿìöÝÿìößÿ×öáÿìöäÿìööÿìöÿìö ÿìö ÿ×öªÿìö¶ÿìö¼ÿ×ö¾ÿìöÀÿìöÂÿìöËÿ×öÕÿìöæÿ×öøÿìöúÿìöüÿìöþÿìöÿ×öÿ×öÿìöÿìöÿì÷ÿ…÷ÿ…÷Ÿÿì÷¤ÿš÷ªÿq÷®ÿš÷µÿš÷¸ÿì÷»ÿì÷¾ÿÃ÷Éÿì÷Îÿ®÷Ïÿ×÷Õÿ®÷Øÿ×÷Ûÿ×÷Þÿ×÷áÿ×÷êÿ×÷ëf÷íÿ×÷îÿì÷òÿ®÷ôf÷ÿ…÷ ÿ…÷jÿ×÷lÿì÷rÿq÷sÿ®÷~ÿì÷ÿ×÷„ÿì÷…ÿ×÷†ÿì÷‡ÿ×÷ˆÿì÷‰ÿ×÷Šÿì÷Œÿì÷ÿ×÷˜f÷¨f÷±ÿì÷²ÿ×÷³ÿì÷´ÿ×÷Àÿ×÷Âÿ×÷Åÿ×÷ÆÿÃ÷Çÿ×÷ÈÿÃ÷Îÿš÷Ïÿ®÷Õÿ×÷Ùÿq÷Ûÿq÷Ýÿq÷àÿ×÷ïÿì÷ðÿ×÷ñÿì÷òÿ×÷óÿì÷ôÿ×÷þÿ×÷ ÿq÷ ÿ×÷ ÿq÷ ÿ×÷ÿš÷ÿ®÷ÿì÷ÿ×÷ÿ×÷ÿš÷ÿ®øÿ®øÿ®øÎÿ×øÕÿ×øòÿ×øÿ®ø ÿ®øsÿ×øÏÿ×øÿ×øÿ×ùÿ…ùÿ…ùŸÿìù¤ÿšùªÿqù®ÿšùµÿšù¸ÿìù»ÿìù¾ÿÃùÉÿìùÎÿ®ùÏÿ×ùÕÿ®ùØÿ×ùÛÿ×ùÞÿ×ùáÿ×ùêÿ×ùëfùíÿ×ùîÿìùòÿ®ùôfùÿ…ù ÿ…ùjÿ×ùlÿìùrÿqùsÿ®ù~ÿìùÿ×ù„ÿìù…ÿ×ù†ÿìù‡ÿ×ùˆÿìù‰ÿ×ùŠÿìùŒÿìùÿ×ù˜fù¨fù±ÿìù²ÿ×ù³ÿìù´ÿ×ùÀÿ×ùÂÿ×ùÅÿ×ùÆÿÃùÇÿ×ùÈÿÃùÎÿšùÏÿ®ùÕÿ×ùÙÿqùÛÿqùÝÿqùàÿ×ùïÿìùðÿ×ùñÿìùòÿ×ùóÿìùôÿ×ùþÿ×ù ÿqù ÿ×ù ÿqù ÿ×ùÿšùÿ®ùÿìùÿ×ùÿ×ùÿšùÿ®úÿ®úÿ®úÎÿ×úÕÿ×úòÿ×úÿ®ú ÿ®úsÿ×úÏÿ×úÿ×úÿ×ûÿ…ûÿ…ûŸÿìû¤ÿšûªÿqû®ÿšûµÿšû¸ÿìû»ÿìû¾ÿÃûÉÿìûÎÿ®ûÏÿ×ûÕÿ®ûØÿ×ûÛÿ×ûÞÿ×ûáÿ×ûêÿ×ûëfûíÿ×ûîÿìûòÿ®ûôfûÿ…û ÿ…ûjÿ×ûlÿìûrÿqûsÿ®û~ÿìûÿ×û„ÿìû…ÿ×û†ÿìû‡ÿ×ûˆÿìû‰ÿ×ûŠÿìûŒÿìûÿ×û˜fû¨fû±ÿìû²ÿ×û³ÿìû´ÿ×ûÀÿ×ûÂÿ×ûÅÿ×ûÆÿÃûÇÿ×ûÈÿÃûÎÿšûÏÿ®ûÕÿ×ûÙÿqûÛÿqûÝÿqûàÿ×ûïÿìûðÿ×ûñÿìûòÿ×ûóÿìûôÿ×ûþÿ×û ÿqû ÿ×û ÿqû ÿ×ûÿšûÿ®ûÿìûÿ×ûÿ×ûÿšûÿ®üÿ®üÿ®üÎÿ×üÕÿ×üòÿ×üÿ®ü ÿ®üsÿ×üÏÿ×üÿ×üÿ×ÿÿ…ÿÿ®ÿÿ…ÿŸÿ×ÿ¤ÿšÿªÿqÿ®ÿšÿµÿšÿ¸ÿ×ÿ»ÿ×ÿ¼)ÿ¾ÿ®ÿÌÿšÿÍÿšÿÎÿ…ÿÏÿqÿÐÿ×ÿÑÿ×ÿÒÿšÿÓÿšÿÔÿšÿÕÿ…ÿÖÿšÿ×ÿšÿØÿqÿÙÿšÿÚÿšÿÛÿqÿÜÿ®ÿÝÿ®ÿÞÿqÿßÿ×ÿàÿšÿáÿšÿâÿšÿãÿšÿäÿ®ÿåÿšÿæÿšÿçÿ×ÿèÿšÿéÿÃÿêÿqÿìÿšÿíÿqÿîÿ…ÿòÿ…ÿóÿšÿõÿšÿöÿ®ÿ÷ÿšÿùÿšÿÿ®ÿÿ®ÿÿ®ÿÿ…ÿ ÿ…ÿjÿqÿkÿšÿlÿ×ÿmÿ×ÿqÿšÿrÿqÿsÿ…ÿuÿšÿwÿšÿyÿšÿ}ÿšÿ~ÿ×ÿÿqÿÿ×ÿƒÿ×ÿ„ÿ×ÿ…ÿqÿ†ÿ×ÿ‡ÿqÿˆÿ×ÿ‰ÿqÿŠÿ×ÿ‹ÿ×ÿŒÿ×ÿÿqÿ–ÿšÿšÿšÿžÿšÿ ÿ×ÿ¢ÿ×ÿ¤ÿšÿ¦ÿšÿªÿ®ÿ¬ÿšÿ®ÿšÿ°ÿšÿ±ÿ×ÿ²ÿqÿ³ÿ×ÿ´ÿqÿµ)ÿ¶ÿ®ÿ¸ÿ®ÿºÿ®ÿ¼ÿ×ÿ¾ÿ®ÿÀÿšÿÂÿšÿÄÿšÿÅÿšÿÆÿqÿÇÿšÿÈÿqÿËÿ×ÿÍÿšÿÎÿšÿÏÿ…ÿÑÿšÿÓÿšÿÕÿšÿ×ÿšÿÙÿqÿÛÿqÿÝÿqÿàÿqÿæÿ×ÿèÿ×ÿêÿÃÿìÿšÿîÿšÿïÿ×ÿðÿqÿñÿ×ÿòÿqÿóÿ×ÿôÿqÿöÿ×ÿøÿ®ÿúÿ®ÿüÿ®ÿþÿšÿÿšÿÿšÿÿ×ÿÿ×ÿ ÿqÿ ÿqÿ ÿqÿ ÿqÿÿšÿÿšÿÿšÿÿ…ÿÿšÿÿ×ÿÿqÿÿ®ÿÿqÿÿšÿÿ…ÿšÿ×ÿšÎÿÃÏÿìÕÿÃØÿìÛÿìÞÿìêÿìíÿìòÿÃÿ×ÿ×ÿ×ÿš ÿšjÿìsÿÃÿì…ÿì‡ÿì‰ÿìÿì²ÿì´ÿìÏÿÃàÿìðÿìòÿìôÿì ÿì ÿìÿÃÿìÿìÿÃÿšÿ×ÿš)Ÿÿפÿ®¦)ªÿ…®ÿ®µÿ®¸ÿ×»ÿ×¼)¾ÿÃÄ)ÌÿÃÍÿÃÎÿšÏÿ®Ðÿ×Ñÿ×ÒÿÃÓÿÃÔÿÃÕÿšÖÿÃ×ÿÃØÿ®ÙÿÃÚÿÃÛÿ®Þÿ®ßÿ×àÿÃáÿšâÿÃãÿÃåÿÃæÿÃçÿ×èÿÃêÿ®ë)ìÿÃíÿ®îÿÃòÿšóÿÃô)õÿÃ÷ÿÃùÿÃÿ×ÿ×ÿ×ÿš ÿšjÿ®kÿÃlÿ×qÿÃrÿ…sÿšuÿÃwÿ×yÿÃ}ÿÃ~ÿ×ÿ®„ÿ×…ÿ®†ÿׇÿ®ˆÿ׉ÿ®Šÿ׌ÿ×ÿ®–ÿØ)šÿÞÿàÿ×¢ÿפÿæÿè)©)¬ÿîÿðÿñÿײÿ®³ÿ×´ÿ®µ)¼ÿ×½)ÀÿšÂÿšÄÿÃÅÿ×ÆÿÃÇÿ×ÈÿÃËÿ×ÍÿÃÎÿ®ÏÿšÑÿÃÓÿÃÕÿš×ÿÃÙÿ…Ûÿ…Ýÿ…àÿ®æÿ×èÿ×ìÿÃîÿÃïÿ×ðÿ®ñÿ×òÿ®óÿ×ôÿ®öÿ×þÿšÿÃÿÃÿ×ÿ× ÿš ÿ® ÿš ÿ®ÿ×ÿ×ÿ®ÿšÿÃÿ×ÿ®)ÿ®ÿ®ÿšÿÃÿÃÎÿÃÏÿ×ÕÿÃØÿ×Ûÿ×Þÿ×êÿ×íÿ×òÿÃÿà ÿÃjÿ×sÿÃÿ×…ÿׇÿ׉ÿ×ÿײÿ×´ÿ×ÏÿÃàÿ×ðÿ×òÿ×ôÿ× ÿ× ÿ×ÿÃÿ×ÿ×ÿßÿ×£á¸ÿ×»ÿ×¾ÿÃÜÿ×áÿ®äÿ×lÿ×{=}ÿì~ÿׄÿ׆ÿ׈ÿ׊ÿ׌ÿתÿ×±ÿ׳ÿ׶ÿ×¾ÿ×Àÿ®Âÿ®ÅÿÃÆÿ×ÇÿÃÈÿ×Õÿ®ïÿ×ñÿ×óÿ×þÿ®ÿ×ÿ×ÿ×ÿ×ÏÿìØÿìÛÿìÞÿìáÿìêÿìíÿìjÿìÿì…ÿì‡ÿì‰ÿìÿì²ÿì´ÿìÀÿìÂÿìÕÿìàÿìðÿìòÿìôÿìþÿì ÿì ÿìÿ×ÿ×ÿìÿìŸÿ׸ÿ×»ÿ×¾ÿ×Áÿ×áÿ×lÿ×|ÿ×~ÿׄÿ׆ÿ׈ÿ׊ÿ׌ÿ×±ÿ׳ÿ׿ÿ×Àÿ×Áÿ×Âÿ×ÅÿšÇÿšÔÿ×Õÿ×ïÿ×ñÿ×óÿ×ýÿ×þÿ× ÿ× ÿ×ÿ×ÿ×ÿ×ÿìÏÿìØÿìÛÿìÞÿìáÿìêÿìíÿìjÿìÿì…ÿì‡ÿì‰ÿìÿì²ÿì´ÿìÀÿìÂÿìÕÿìàÿìðÿìòÿìôÿìþÿì ÿì ÿìÿ×ÿ×ÿìÿì ÿš ÿš ÿ® ¦ÿ® ¨ÿà ªÿà °ÿà ¼ÿq ½ÿà ¿ÿà Áÿà Äÿ® Ðÿ× Üÿà ßÿ× áÿ× äÿà ÿš  ÿš rÿà vÿ× |ÿà €ÿà ‚ÿà Ÿÿà  ÿ× ©ÿ® ªÿà µÿq ¶ÿà ·ÿà ¹ÿà »ÿà ¼ÿ× ½ÿ® ¾ÿà ¿ÿà Àÿ× Áÿà Âÿ× Êÿà Ëÿ× Ôÿà Õÿ× Ùÿà Ûÿà Ýÿà åÿà æÿ× ÷ÿà ùÿà ûÿà ýÿà þÿ× ÿà ÿ× ÿà ÿ×  ÿ× ÿ× ÿ× ÿ× ÿ® ÿà ÿš ÿš Ðÿ× Üÿà Ýÿ× ßÿ× áÿ× äÿà öÿ× ÿš  ÿš  ÿ× ªÿà ¶ÿà ¼ÿ× ¾ÿà Àÿ× Âÿ× Ëÿ× Õÿ× æÿ× øÿ× úÿ× üÿ× þÿ× ÿ× ÿ× ÿš ÿš ÿà ÿš ÿš ÿ® ¦ÿ® ¨ÿà ªÿà °ÿà ¼ÿq ½ÿà ¿ÿà Áÿà Äÿ® Ðÿ× Üÿà ßÿ× áÿ× äÿà ÿš  ÿš rÿà vÿ× |ÿà €ÿà ‚ÿà Ÿÿà  ÿ× ©ÿ® ªÿà µÿq ¶ÿà ·ÿà ¹ÿà »ÿà ¼ÿ× ½ÿ® ¾ÿà ¿ÿà Àÿ× Áÿà Âÿ× Êÿà Ëÿ× Ôÿà Õÿ× Ùÿà Ûÿà Ýÿà åÿà æÿ× ÷ÿà ùÿà ûÿà ýÿà þÿ× ÿà ÿ× ÿà ÿ×  ÿ× ÿ× ÿ× ÿ× ÿ® ÿÃÿš ÿšÐÿ×ÜÿÃÝÿ×ßÿ×áÿ×äÿÃöÿ×ÿš ÿš ÿתÿöÿüÿ×¾ÿÃÀÿ×Âÿ×Ëÿ×Õÿ×æÿ×øÿ×úÿ×üÿ×þÿ×ÿ×ÿ×ÿšÿšÿãáê)ÿ×ÿ×ÿì ÿìÿì ÿìÿš ÿšÿ®¦ÿ®¨ÿêÿðÿüÿq½ÿÿÿÃÁÿÃÄÿ®Ðÿ×ÜÿÃßÿ×áÿ×äÿÃÿš ÿšrÿÃvÿ×|ÿÀÿÂÿßÿàÿשÿ®ªÿõÿq¶ÿ÷ÿùÿûÿüÿ×½ÿ®¾ÿÿÿÃÀÿ×ÁÿÃÂÿ×ÊÿÃËÿ×ÔÿÃÕÿ×ÙÿÃÛÿÃÝÿÃåÿÃæÿ×÷ÿÃùÿÃûÿÃýÿÃþÿ×ÿÃÿ×ÿÃÿ× ÿ×ÿ×ÿ×ÿ×ÿ®ÿÃÿš ÿšÐÿ×ÜÿÃÝÿ×ßÿ×áÿ×äÿÃöÿ×ÿš ÿš ÿתÿöÿüÿ×¾ÿÃÀÿ×Âÿ×Ëÿ×Õÿ×æÿ×øÿ×úÿ×üÿ×þÿ×ÿ×ÿ×ÿšÿšÿÃÿš ÿšÿ®¦ÿ®¨ÿêÿðÿüÿq½ÿÿÿÃÁÿÃÄÿ®Ðÿ×ÜÿÃßÿ×áÿ×äÿÃÿš ÿšrÿÃvÿ×|ÿÀÿÂÿßÿàÿשÿ®ªÿõÿq¶ÿ÷ÿùÿûÿüÿ×½ÿ®¾ÿÿÿÃÀÿ×ÁÿÃÂÿ×ÊÿÃËÿ×ÔÿÃÕÿ×ÙÿÃÛÿÃÝÿÃåÿÃæÿ×÷ÿÃùÿÃûÿÃýÿÃþÿ×ÿÃÿ×ÿÃÿ× ÿ×ÿ×ÿ×ÿ×ÿ®ÿÃÿš ÿšÐÿ×ÜÿÃÝÿ×ßÿ×áÿ×äÿÃöÿ×ÿš ÿš ÿתÿöÿüÿ×¾ÿÃÀÿ×Âÿ×Ëÿ×Õÿ×æÿ×øÿ×úÿ×üÿ×þÿ×ÿ×ÿ×ÿšÿšÿÃÿ®ÿ®ªÿì°ÿ×¼ÿ׿ÿ×ÿ® ÿ®rÿì€ÿì‚ÿìŸÿ×µÿ×·ÿì¹ÿì»ÿ×Êÿ×ÙÿìÛÿìÝÿìåÿ×ÿ×ÿ×ÿ× ÿ×ÐÿìÝÿìßÿìöÿìÿ× ÿ× ÿì¼ÿìËÿìæÿìøÿìúÿìüÿìÿìÿìÿ×ÿ×ÿ® ÿ®ÿæÿêÿ×°ÿ×¼ÿÿÿ×Áÿ×ÄÿÃÜÿ×äÿ×ÿ® ÿ®rÿ×|ÿ×€ÿׂÿןÿשÿêÿ×µÿöÿ×·ÿ×¹ÿ×»ÿ×½ÿþÿ׿ÿ×Áÿ×Êÿ×Ôÿ×Ùÿ×Ûÿ×Ýÿ×åÿ×ýÿ×ÿ×ÿ× ÿ×ÿ×ÿÃÿ×ÿš ÿšÐÿ×ÜÿÃÝÿ×ßÿ×áÿ×äÿÃöÿ×ÿš ÿš ÿתÿöÿüÿ×¾ÿÃÀÿ×Âÿ×Ëÿ×Õÿ×æÿ×øÿ×úÿ×üÿ×þÿ×ÿ×ÿ×ÿšÿšÿÃáÿ×Àÿ×Âÿ×Õÿ×þÿ×£áê)ÿ×ÿ×ÿì ÿìÿì ÿìÿq ÿq&ÿ×*ÿ×- 2ÿ×4ÿ×7ÿq9ÿ®:ÿ®<ÿ…‰ÿ×”ÿוÿ×–ÿ×—ÿטÿךÿןÿ…Èÿ×Êÿ×Ìÿ×Îÿ×Þÿ×àÿ×âÿ×äÿ×ÿ×ÿ×ÿ×ÿ×$ÿq&ÿq6ÿ®8ÿ…:ÿ…Gÿ×úÿ®üÿ®þÿ®ÿ…ÿq ÿq_ÿ×Iÿ×Kÿ×Mÿ×Oÿ×Qÿ×Sÿ×Uÿ×Wÿ×Yÿ×[ÿ×]ÿ×_ÿ×oÿ…qÿ…sÿ…ÿqÿì ÿìÿì ÿìÿq ÿq&ÿ×*ÿ×- 2ÿ×4ÿ×7ÿq9ÿ®:ÿ®<ÿ…‰ÿ×”ÿוÿ×–ÿ×—ÿטÿךÿןÿ…Èÿ×Êÿ×Ìÿ×Îÿ×Þÿ×àÿ×âÿ×äÿ×ÿ×ÿ×ÿ×ÿ×$ÿq&ÿq6ÿ®8ÿ…:ÿ…Gÿ×úÿ®üÿ®þÿ®ÿ…ÿq ÿq_ÿ×Iÿ×Kÿ×Mÿ×Oÿ×Qÿ×Sÿ×Uÿ×Wÿ×Yÿ×[ÿ×]ÿ×_ÿ×oÿ…qÿ…sÿ…ÿq ÿì ÿì ÿì  ÿì!ÿq! ÿq!&ÿ×!*ÿ×!- !2ÿ×!4ÿ×!7ÿq!9ÿ®!:ÿ®!<ÿ…!‰ÿ×!”ÿ×!•ÿ×!–ÿ×!—ÿ×!˜ÿ×!šÿ×!Ÿÿ…!Èÿ×!Êÿ×!Ìÿ×!Îÿ×!Þÿ×!àÿ×!âÿ×!äÿ×!ÿ×!ÿ×!ÿ×!ÿ×!$ÿq!&ÿq!6ÿ®!8ÿ…!:ÿ…!Gÿ×!úÿ®!üÿ®!þÿ®!ÿ…!ÿq! ÿq!_ÿ×!Iÿ×!Kÿ×!Mÿ×!Oÿ×!Qÿ×!Sÿ×!Uÿ×!Wÿ×!Yÿ×![ÿ×!]ÿ×!_ÿ×!oÿ…!qÿ…!sÿ…!ÿq"ÿì" ÿì"ÿì" ÿì#ÿq# ÿq#&ÿ×#*ÿ×#- #2ÿ×#4ÿ×#7ÿq#9ÿ®#:ÿ®#<ÿ…#‰ÿ×#”ÿ×#•ÿ×#–ÿ×#—ÿ×#˜ÿ×#šÿ×#Ÿÿ…#Èÿ×#Êÿ×#Ìÿ×#Îÿ×#Þÿ×#àÿ×#âÿ×#äÿ×#ÿ×#ÿ×#ÿ×#ÿ×#$ÿq#&ÿq#6ÿ®#8ÿ…#:ÿ…#Gÿ×#úÿ®#üÿ®#þÿ®#ÿ…#ÿq# ÿq#_ÿ×#Iÿ×#Kÿ×#Mÿ×#Oÿ×#Qÿ×#Sÿ×#Uÿ×#Wÿ×#Yÿ×#[ÿ×#]ÿ×#_ÿ×#oÿ…#qÿ…#sÿ…#ÿq$ÿì$ ÿì$ÿì$ ÿì%ÿq% ÿq%&ÿ×%*ÿ×%- %2ÿ×%4ÿ×%7ÿq%9ÿ®%:ÿ®%<ÿ…%‰ÿ×%”ÿ×%•ÿ×%–ÿ×%—ÿ×%˜ÿ×%šÿ×%Ÿÿ…%Èÿ×%Êÿ×%Ìÿ×%Îÿ×%Þÿ×%àÿ×%âÿ×%äÿ×%ÿ×%ÿ×%ÿ×%ÿ×%$ÿq%&ÿq%6ÿ®%8ÿ…%:ÿ…%Gÿ×%úÿ®%üÿ®%þÿ®%ÿ…%ÿq% ÿq%_ÿ×%Iÿ×%Kÿ×%Mÿ×%Oÿ×%Qÿ×%Sÿ×%Uÿ×%Wÿ×%Yÿ×%[ÿ×%]ÿ×%_ÿ×%oÿ…%qÿ…%sÿ…%ÿq&ÿì& ÿì&ÿì& ÿì'ÿq' ÿq'&ÿ×'*ÿ×'- '2ÿ×'4ÿ×'7ÿq'9ÿ®':ÿ®'<ÿ…'‰ÿ×'”ÿ×'•ÿ×'–ÿ×'—ÿ×'˜ÿ×'šÿ×'Ÿÿ…'Èÿ×'Êÿ×'Ìÿ×'Îÿ×'Þÿ×'àÿ×'âÿ×'äÿ×'ÿ×'ÿ×'ÿ×'ÿ×'$ÿq'&ÿq'6ÿ®'8ÿ…':ÿ…'Gÿ×'úÿ®'üÿ®'þÿ®'ÿ…'ÿq' ÿq'_ÿ×'Iÿ×'Kÿ×'Mÿ×'Oÿ×'Qÿ×'Sÿ×'Uÿ×'Wÿ×'Yÿ×'[ÿ×']ÿ×'_ÿ×'oÿ…'qÿ…'sÿ…'ÿq(ÿì( ÿì(ÿì( ÿì)ÿq) ÿq)&ÿ×)*ÿ×)- )2ÿ×)4ÿ×)7ÿq)9ÿ®):ÿ®)<ÿ…)‰ÿ×)”ÿ×)•ÿ×)–ÿ×)—ÿ×)˜ÿ×)šÿ×)Ÿÿ…)Èÿ×)Êÿ×)Ìÿ×)Îÿ×)Þÿ×)àÿ×)âÿ×)äÿ×)ÿ×)ÿ×)ÿ×)ÿ×)$ÿq)&ÿq)6ÿ®)8ÿ…):ÿ…)Gÿ×)úÿ®)üÿ®)þÿ®)ÿ…)ÿq) ÿq)_ÿ×)Iÿ×)Kÿ×)Mÿ×)Oÿ×)Qÿ×)Sÿ×)Uÿ×)Wÿ×)Yÿ×)[ÿ×)]ÿ×)_ÿ×)oÿ…)qÿ…)sÿ…)ÿq*ÿì* ÿì*ÿì* ÿì+ÿq+ ÿq+&ÿ×+*ÿ×+- +2ÿ×+4ÿ×+7ÿq+9ÿ®+:ÿ®+<ÿ…+‰ÿ×+”ÿ×+•ÿ×+–ÿ×+—ÿ×+˜ÿ×+šÿ×+Ÿÿ…+Èÿ×+Êÿ×+Ìÿ×+Îÿ×+Þÿ×+àÿ×+âÿ×+äÿ×+ÿ×+ÿ×+ÿ×+ÿ×+$ÿq+&ÿq+6ÿ®+8ÿ…+:ÿ…+Gÿ×+úÿ®+üÿ®+þÿ®+ÿ…+ÿq+ ÿq+_ÿ×+Iÿ×+Kÿ×+Mÿ×+Oÿ×+Qÿ×+Sÿ×+Uÿ×+Wÿ×+Yÿ×+[ÿ×+]ÿ×+_ÿ×+oÿ…+qÿ…+sÿ…+ÿq,ÿì, ÿì,ÿì, ÿì-ÿq- ÿq-&ÿ×-*ÿ×-- -2ÿ×-4ÿ×-7ÿq-9ÿ®-:ÿ®-<ÿ…-‰ÿ×-”ÿ×-•ÿ×-–ÿ×-—ÿ×-˜ÿ×-šÿ×-Ÿÿ…-Èÿ×-Êÿ×-Ìÿ×-Îÿ×-Þÿ×-àÿ×-âÿ×-äÿ×-ÿ×-ÿ×-ÿ×-ÿ×-$ÿq-&ÿq-6ÿ®-8ÿ…-:ÿ…-Gÿ×-úÿ®-üÿ®-þÿ®-ÿ…-ÿq- ÿq-_ÿ×-Iÿ×-Kÿ×-Mÿ×-Oÿ×-Qÿ×-Sÿ×-Uÿ×-Wÿ×-Yÿ×-[ÿ×-]ÿ×-_ÿ×-oÿ…-qÿ…-sÿ…-ÿq.ÿì. ÿì.ÿì. ÿì/ÿq/ ÿq/&ÿ×/*ÿ×/- /2ÿ×/4ÿ×/7ÿq/9ÿ®/:ÿ®/<ÿ…/‰ÿ×/”ÿ×/•ÿ×/–ÿ×/—ÿ×/˜ÿ×/šÿ×/Ÿÿ…/Èÿ×/Êÿ×/Ìÿ×/Îÿ×/Þÿ×/àÿ×/âÿ×/äÿ×/ÿ×/ÿ×/ÿ×/ÿ×/$ÿq/&ÿq/6ÿ®/8ÿ…/:ÿ…/Gÿ×/úÿ®/üÿ®/þÿ®/ÿ…/ÿq/ ÿq/_ÿ×/Iÿ×/Kÿ×/Mÿ×/Oÿ×/Qÿ×/Sÿ×/Uÿ×/Wÿ×/Yÿ×/[ÿ×/]ÿ×/_ÿ×/oÿ…/qÿ…/sÿ…/ÿq0ÿì0 ÿì0ÿì0 ÿì1ÿq1 ÿq1&ÿ×1*ÿ×1- 12ÿ×14ÿ×17ÿq19ÿ®1:ÿ®1<ÿ…1‰ÿ×1”ÿ×1•ÿ×1–ÿ×1—ÿ×1˜ÿ×1šÿ×1Ÿÿ…1Èÿ×1Êÿ×1Ìÿ×1Îÿ×1Þÿ×1àÿ×1âÿ×1äÿ×1ÿ×1ÿ×1ÿ×1ÿ×1$ÿq1&ÿq16ÿ®18ÿ…1:ÿ…1Gÿ×1úÿ®1üÿ®1þÿ®1ÿ…1ÿq1 ÿq1_ÿ×1Iÿ×1Kÿ×1Mÿ×1Oÿ×1Qÿ×1Sÿ×1Uÿ×1Wÿ×1Yÿ×1[ÿ×1]ÿ×1_ÿ×1oÿ…1qÿ…1sÿ…1ÿq2ÿì2 ÿì2ÿì2 ÿì3ÿq3 ÿq3&ÿ×3*ÿ×3- 32ÿ×34ÿ×37ÿq39ÿ®3:ÿ®3<ÿ…3‰ÿ×3”ÿ×3•ÿ×3–ÿ×3—ÿ×3˜ÿ×3šÿ×3Ÿÿ…3Èÿ×3Êÿ×3Ìÿ×3Îÿ×3Þÿ×3àÿ×3âÿ×3äÿ×3ÿ×3ÿ×3ÿ×3ÿ×3$ÿq3&ÿq36ÿ®38ÿ…3:ÿ…3Gÿ×3úÿ®3üÿ®3þÿ®3ÿ…3ÿq3 ÿq3_ÿ×3Iÿ×3Kÿ×3Mÿ×3Oÿ×3Qÿ×3Sÿ×3Uÿ×3Wÿ×3Yÿ×3[ÿ×3]ÿ×3_ÿ×3oÿ…3qÿ…3sÿ…3ÿq4ÿì4 ÿì4ÿì4 ÿì5-{6ÿì6 ÿì6Yÿ×6Zÿ×6[ÿ×6\ÿ×6]ÿì6¿ÿ×67ÿ×6<ÿì6>ÿì6@ÿì6ûÿ×6ýÿ×6ÿì6 ÿì6pÿ×7-{8ÿì8 ÿì8Yÿ×8Zÿ×8[ÿ×8\ÿ×8]ÿì8¿ÿ×87ÿ×8<ÿì8>ÿì8@ÿì8ûÿ×8ýÿ×8ÿì8 ÿì8pÿ×9-{:ÿì: ÿì:Yÿ×:Zÿ×:[ÿ×:\ÿ×:]ÿì:¿ÿ×:7ÿ×:<ÿì:>ÿì:@ÿì:ûÿ×:ýÿ×:ÿì: ÿì:pÿ×;-{<ÿì< ÿì<Yÿ×<Zÿ×<[ÿ×<\ÿ×<]ÿì<¿ÿ×<7ÿ×<<ÿì<>ÿì<@ÿì<ûÿ×<ýÿ×<ÿì< ÿì<pÿ×=-{>ÿì> ÿì>Yÿ×>Zÿ×>[ÿ×>\ÿ×>]ÿì>¿ÿ×>7ÿ×><ÿì>>ÿì>@ÿì>ûÿ×>ýÿ×>ÿì> ÿì>pÿ×?-{@ÿì@ ÿì@Yÿ×@Zÿ×@[ÿ×@\ÿ×@]ÿì@¿ÿ×@7ÿ×@<ÿì@>ÿì@@ÿì@ûÿ×@ýÿ×@ÿì@ ÿì@pÿ×A-{BÿìB ÿìBYÿ×BZÿ×B[ÿ×B\ÿ×B]ÿìB¿ÿ×B7ÿ×B<ÿìB>ÿìB@ÿìBûÿ×Býÿ×BÿìB ÿìBpÿ×C-{DÿìD ÿìDYÿ×DZÿ×D[ÿ×D\ÿ×D]ÿìD¿ÿ×D7ÿ×D<ÿìD>ÿìD@ÿìDûÿ×Dýÿ×DÿìD ÿìDpÿ×Iÿ®Iÿ®I$ÿ×I7ÿÃI9ÿìI:ÿìI;ÿ×I<ÿìI=ÿìI‚ÿ×Iƒÿ×I„ÿ×I…ÿ×I†ÿ×I‡ÿ×IŸÿìIÂÿ×IÄÿ×IÆÿ×I$ÿÃI&ÿÃI6ÿìI8ÿìI:ÿìI;ÿìI=ÿìI?ÿìICÿ×I ÿìIúÿìIüÿìIþÿìIÿìIÿ®I ÿ®IXÿ×Iÿ×Iÿ×I!ÿ×I#ÿ×I%ÿ×I'ÿ×I)ÿ×I+ÿ×I-ÿ×I/ÿ×I1ÿ×I3ÿ×IoÿìIqÿìIsÿìIÿÃJÿìJ ÿìJYÿ×JZÿ×J[ÿ×J\ÿ×J]ÿìJ¿ÿ×J7ÿ×J<ÿìJ>ÿìJ@ÿìJûÿ×Jýÿ×JÿìJ ÿìJpÿ×Kÿ®Kÿ®K$ÿ×K7ÿÃK9ÿìK:ÿìK;ÿ×K<ÿìK=ÿìK‚ÿ×Kƒÿ×K„ÿ×K…ÿ×K†ÿ×K‡ÿ×KŸÿìKÂÿ×KÄÿ×KÆÿ×K$ÿÃK&ÿÃK6ÿìK8ÿìK:ÿìK;ÿìK=ÿìK?ÿìKCÿ×K ÿìKúÿìKüÿìKþÿìKÿìKÿ®K ÿ®KXÿ×Kÿ×Kÿ×K!ÿ×K#ÿ×K%ÿ×K'ÿ×K)ÿ×K+ÿ×K-ÿ×K/ÿ×K1ÿ×K3ÿ×KoÿìKqÿìKsÿìKÿÃLÿìL ÿìLYÿ×LZÿ×L[ÿ×L\ÿ×L]ÿìL¿ÿ×L7ÿ×L<ÿìL>ÿìL@ÿìLûÿ×Lýÿ×LÿìL ÿìLpÿ×Mÿ®Mÿ®M$ÿ×M7ÿÃM9ÿìM:ÿìM;ÿ×M<ÿìM=ÿìM‚ÿ×Mƒÿ×M„ÿ×M…ÿ×M†ÿ×M‡ÿ×MŸÿìMÂÿ×MÄÿ×MÆÿ×M$ÿÃM&ÿÃM6ÿìM8ÿìM:ÿìM;ÿìM=ÿìM?ÿìMCÿ×M ÿìMúÿìMüÿìMþÿìMÿìMÿ®M ÿ®MXÿ×Mÿ×Mÿ×M!ÿ×M#ÿ×M%ÿ×M'ÿ×M)ÿ×M+ÿ×M-ÿ×M/ÿ×M1ÿ×M3ÿ×MoÿìMqÿìMsÿìMÿÃOÿ®Oÿ®O$ÿ×O7ÿÃO9ÿìO:ÿìO;ÿ×O<ÿìO=ÿìO‚ÿ×Oƒÿ×O„ÿ×O…ÿ×O†ÿ×O‡ÿ×OŸÿìOÂÿ×OÄÿ×OÆÿ×O$ÿÃO&ÿÃO6ÿìO8ÿìO:ÿìO;ÿìO=ÿìO?ÿìOCÿ×O ÿìOúÿìOüÿìOþÿìOÿìOÿ®O ÿ®OXÿ×Oÿ×Oÿ×O!ÿ×O#ÿ×O%ÿ×O'ÿ×O)ÿ×O+ÿ×O-ÿ×O/ÿ×O1ÿ×O3ÿ×OoÿìOqÿìOsÿìOÿÃQÿ®Qÿ®Q$ÿ×Q7ÿÃQ9ÿìQ:ÿìQ;ÿ×Q<ÿìQ=ÿìQ‚ÿ×Qƒÿ×Q„ÿ×Q…ÿ×Q†ÿ×Q‡ÿ×QŸÿìQÂÿ×QÄÿ×QÆÿ×Q$ÿÃQ&ÿÃQ6ÿìQ8ÿìQ:ÿìQ;ÿìQ=ÿìQ?ÿìQCÿ×Q ÿìQúÿìQüÿìQþÿìQÿìQÿ®Q ÿ®QXÿ×Qÿ×Qÿ×Q!ÿ×Q#ÿ×Q%ÿ×Q'ÿ×Q)ÿ×Q+ÿ×Q-ÿ×Q/ÿ×Q1ÿ×Q3ÿ×QoÿìQqÿìQsÿìQÿÃSÿ®Sÿ®S$ÿ×S7ÿÃS9ÿìS:ÿìS;ÿ×S<ÿìS=ÿìS‚ÿ×Sƒÿ×S„ÿ×S…ÿ×S†ÿ×S‡ÿ×SŸÿìSÂÿ×SÄÿ×SÆÿ×S$ÿÃS&ÿÃS6ÿìS8ÿìS:ÿìS;ÿìS=ÿìS?ÿìSCÿ×S ÿìSúÿìSüÿìSþÿìSÿìSÿ®S ÿ®SXÿ×Sÿ×Sÿ×S!ÿ×S#ÿ×S%ÿ×S'ÿ×S)ÿ×S+ÿ×S-ÿ×S/ÿ×S1ÿ×S3ÿ×SoÿìSqÿìSsÿìSÿÃUÿ®Uÿ®U$ÿ×U7ÿÃU9ÿìU:ÿìU;ÿ×U<ÿìU=ÿìU‚ÿ×Uƒÿ×U„ÿ×U…ÿ×U†ÿ×U‡ÿ×UŸÿìUÂÿ×UÄÿ×UÆÿ×U$ÿÃU&ÿÃU6ÿìU8ÿìU:ÿìU;ÿìU=ÿìU?ÿìUCÿ×U ÿìUúÿìUüÿìUþÿìUÿìUÿ®U ÿ®UXÿ×Uÿ×Uÿ×U!ÿ×U#ÿ×U%ÿ×U'ÿ×U)ÿ×U+ÿ×U-ÿ×U/ÿ×U1ÿ×U3ÿ×UoÿìUqÿìUsÿìUÿÃXIRXWRXYfXZfX[fX\fX¿fX%RX'RX7fXûfXýfX4RX5RX]RX^RXpfXRXRZIRZWRZYfZZfZ[fZ\fZ¿fZ%RZ'RZ7fZûfZýfZ4RZ5RZ]RZ^RZpfZRZR\IR\WR\Yf\Zf\[f\\f\¿f\%R\'R\7f\ûf\ýf\4R\5R\]R\^R\pf\R\R^IR^WR^Yf^Zf^[f^\f^¿f^%R^'R^7f^ûf^ýf^4R^5R^]R^^R^pf^R^R`IR`WR`Yf`Zf`[f`\f`¿f`%R`'R`7f`ûf`ýf`4R`5R`]R`^R`pf`R`Raÿ×aÿ×a$ÿìa‚ÿìaƒÿìa„ÿìa…ÿìa†ÿìa‡ÿìaÂÿìaÄÿìaÆÿìaCÿìaÿ×a ÿ×aXÿìaÿìaÿìa!ÿìa#ÿìa%ÿìa'ÿìa)ÿìa+ÿìa-ÿìa/ÿìa1ÿìa3ÿìfIffWffYffZff[ff\ff¿ff%ff'ff7ffûffýff4ff5ff]ff^ffpfffffhIfhWfhYfhZfh[fh\fh¿fh%fh'fh7fhûfhýfh4fh5fh]fh^fhpfhfhfjIfjWfjYfjZfj[fj\fj¿fj%fj'fj7fjûfjýfj4fj5fj]fj^fjpfjfjflIflWflYflZfl[fl\fl¿fl%fl'fl7flûflýfl4fl5fl]fl^flpflflfnIfnWfnYfnZfn[fn\fn¿fn%fn'fn7fnûfnýfn4fn5fn]fn^fnpfnfnfoÿ…oÿ…o")o$ÿ…o&ÿ×o*ÿ×o2ÿ×o4ÿ×oDÿšoFÿšoGÿšoHÿšoJÿ×oPÿÃoQÿÃoRÿšoSÿÃoTÿšoUÿÃoVÿ®oXÿÃo]ÿ×o‚ÿ…oƒÿ…o„ÿ…o…ÿ…o†ÿ…o‡ÿ…o‰ÿ×o”ÿ×o•ÿ×o–ÿ×o—ÿ×o˜ÿ×ošÿ×o¢ÿšo£ÿšo¤ÿšo¥ÿšo¦ÿšo§ÿšo¨ÿšo©ÿšoªÿšo«ÿšo¬ÿšo­ÿšo´ÿšoµÿšo¶ÿšo·ÿšo¸ÿšoºÿšo»ÿÃo¼ÿÃo½ÿÃo¾ÿÃoÂÿ…oÃÿšoÄÿ…oÅÿšoÆÿ…oÇÿšoÈÿ×oÉÿšoÊÿ×oËÿšoÌÿ×oÍÿšoÎÿ×oÏÿšoÑÿšoÓÿšoÕÿšo×ÿšoÙÿšoÛÿšoÝÿšoÞÿ×oßÿ×oàÿ×oáÿ×oâÿ×oãÿ×oäÿ×oåÿ×oúÿÃoÿÃoÿÃo ÿÃoÿ×oÿšoÿ×oÿšoÿ×oÿšoÿ×oÿšoÿÃoÿÃoÿ®o!ÿ®o+ÿÃo-ÿÃo/ÿÃo1ÿÃo3ÿÃo5ÿÃo<ÿ×o>ÿ×o@ÿ×oCÿ…oDÿšoFÿšoGÿ×oHÿšoJÿ®oÿ…o ÿ…oWÿÃoXÿ…oYÿšo_ÿ×o`ÿšobÿÃoÿ…oÿšoÿ…o ÿšo!ÿ…o"ÿšo#ÿ…o%ÿ…o&ÿšo'ÿ…o(ÿšo)ÿ…o*ÿšo+ÿ…o,ÿšo-ÿ…o.ÿšo/ÿ…o0ÿšo1ÿ…o2ÿšo3ÿ…o4ÿšo6ÿšo8ÿšo:ÿšo<ÿšo@ÿšoBÿšoDÿšoIÿ×oJÿšoKÿ×oLÿšoMÿ×oNÿšoOÿ×oQÿ×oRÿšoSÿ×oTÿšoUÿ×oVÿšoWÿ×oXÿšoYÿ×oZÿšo[ÿ×o\ÿšo]ÿ×o^ÿšo_ÿ×o`ÿšobÿÃodÿÃofÿÃohÿÃojÿÃolÿÃonÿÃpRp Rpÿ®pÿ®p")pRpÿ®p Rp ÿ®qÿ…qÿ…q")q$ÿ…q&ÿ×q*ÿ×q2ÿ×q4ÿ×qDÿšqFÿšqGÿšqHÿšqJÿ×qPÿÃqQÿÃqRÿšqSÿÃqTÿšqUÿÃqVÿ®qXÿÃq]ÿ×q‚ÿ…qƒÿ…q„ÿ…q…ÿ…q†ÿ…q‡ÿ…q‰ÿ×q”ÿ×q•ÿ×q–ÿ×q—ÿ×q˜ÿ×qšÿ×q¢ÿšq£ÿšq¤ÿšq¥ÿšq¦ÿšq§ÿšq¨ÿšq©ÿšqªÿšq«ÿšq¬ÿšq­ÿšq´ÿšqµÿšq¶ÿšq·ÿšq¸ÿšqºÿšq»ÿÃq¼ÿÃq½ÿÃq¾ÿÃqÂÿ…qÃÿšqÄÿ…qÅÿšqÆÿ…qÇÿšqÈÿ×qÉÿšqÊÿ×qËÿšqÌÿ×qÍÿšqÎÿ×qÏÿšqÑÿšqÓÿšqÕÿšq×ÿšqÙÿšqÛÿšqÝÿšqÞÿ×qßÿ×qàÿ×qáÿ×qâÿ×qãÿ×qäÿ×qåÿ×qúÿÃqÿÃqÿÃq ÿÃqÿ×qÿšqÿ×qÿšqÿ×qÿšqÿ×qÿšqÿÃqÿÃqÿ®q!ÿ®q+ÿÃq-ÿÃq/ÿÃq1ÿÃq3ÿÃq5ÿÃq<ÿ×q>ÿ×q@ÿ×qCÿ…qDÿšqFÿšqGÿ×qHÿšqJÿ®qÿ…q ÿ…qWÿÃqXÿ…qYÿšq_ÿ×q`ÿšqbÿÃqÿ…qÿšqÿ…q ÿšq!ÿ…q"ÿšq#ÿ…q%ÿ…q&ÿšq'ÿ…q(ÿšq)ÿ…q*ÿšq+ÿ…q,ÿšq-ÿ…q.ÿšq/ÿ…q0ÿšq1ÿ…q2ÿšq3ÿ…q4ÿšq6ÿšq8ÿšq:ÿšq<ÿšq@ÿšqBÿšqDÿšqIÿ×qJÿšqKÿ×qLÿšqMÿ×qNÿšqOÿ×qQÿ×qRÿšqSÿ×qTÿšqUÿ×qVÿšqWÿ×qXÿšqYÿ×qZÿšq[ÿ×q\ÿšq]ÿ×q^ÿšq_ÿ×q`ÿšqbÿÃqdÿÃqfÿÃqhÿÃqjÿÃqlÿÃqnÿÃrRr Rrÿ®rÿ®r")rRrÿ®r Rr ÿ®sÿ…sÿ…s")s$ÿ…s&ÿ×s*ÿ×s2ÿ×s4ÿ×sDÿšsFÿšsGÿšsHÿšsJÿ×sPÿÃsQÿÃsRÿšsSÿÃsTÿšsUÿÃsVÿ®sXÿÃs]ÿ×s‚ÿ…sƒÿ…s„ÿ…s…ÿ…s†ÿ…s‡ÿ…s‰ÿ×s”ÿ×s•ÿ×s–ÿ×s—ÿ×s˜ÿ×sšÿ×s¢ÿšs£ÿšs¤ÿšs¥ÿšs¦ÿšs§ÿšs¨ÿšs©ÿšsªÿšs«ÿšs¬ÿšs­ÿšs´ÿšsµÿšs¶ÿšs·ÿšs¸ÿšsºÿšs»ÿÃs¼ÿÃs½ÿÃs¾ÿÃsÂÿ…sÃÿšsÄÿ…sÅÿšsÆÿ…sÇÿšsÈÿ×sÉÿšsÊÿ×sËÿšsÌÿ×sÍÿšsÎÿ×sÏÿšsÑÿšsÓÿšsÕÿšs×ÿšsÙÿšsÛÿšsÝÿšsÞÿ×sßÿ×sàÿ×sáÿ×sâÿ×sãÿ×säÿ×såÿ×súÿÃsÿÃsÿÃs ÿÃsÿ×sÿšsÿ×sÿšsÿ×sÿšsÿ×sÿšsÿÃsÿÃsÿ®s!ÿ®s+ÿÃs-ÿÃs/ÿÃs1ÿÃs3ÿÃs5ÿÃs<ÿ×s>ÿ×s@ÿ×sCÿ…sDÿšsFÿšsGÿ×sHÿšsJÿ®sÿ…s ÿ…sWÿÃsXÿ…sYÿšs_ÿ×s`ÿšsbÿÃsÿ…sÿšsÿ…s ÿšs!ÿ…s"ÿšs#ÿ…s%ÿ…s&ÿšs'ÿ…s(ÿšs)ÿ…s*ÿšs+ÿ…s,ÿšs-ÿ…s.ÿšs/ÿ…s0ÿšs1ÿ…s2ÿšs3ÿ…s4ÿšs6ÿšs8ÿšs:ÿšs<ÿšs@ÿšsBÿšsDÿšsIÿ×sJÿšsKÿ×sLÿšsMÿ×sNÿšsOÿ×sQÿ×sRÿšsSÿ×sTÿšsUÿ×sVÿšsWÿ×sXÿšsYÿ×sZÿšs[ÿ×s\ÿšs]ÿ×s^ÿšs_ÿ×s`ÿšsbÿÃsdÿÃsfÿÃshÿÃsjÿÃslÿÃsnÿÃtRt Rtÿ®tÿ®t")tRtÿ®t Rt ÿ®{ {{ {ÿ…ÿ®ÿ…")$ÿq&ÿ×*ÿ×2ÿ×4ÿ×7)Dÿ\FÿqGÿqHÿqJÿqPÿšQÿšRÿqSÿšTÿqUÿšVÿ…XÿšYÿ×Zÿ×[ÿ×\ÿ×]ÿ®‚ÿqƒÿq„ÿq…ÿq†ÿq‡ÿq‰ÿ×”ÿוÿ×–ÿ×—ÿטÿךÿ×¢ÿq£ÿ\¤ÿ\¥ÿ\¦ÿ\§ÿ\¨ÿ\©ÿqªÿq«ÿq¬ÿq­ÿq´ÿqµÿq¶ÿq·ÿq¸ÿqºÿq»ÿš¼ÿš½ÿš¾ÿš¿ÿ×ÂÿqÃÿ\ÄÿqÅÿ\ÆÿqÇÿ\Èÿ×ÉÿqÊÿ×ËÿqÌÿ×ÍÿqÎÿ×ÏÿqÑÿqÓÿqÕÿq×ÿqÙÿqÛÿqÝÿqÞÿ×ßÿqàÿ×áÿqâÿ×ãÿqäÿ×åÿqúÿšÿšÿš ÿšÿ×ÿqÿ×ÿqÿ×ÿqÿ×ÿqÿšÿšÿ…!ÿ…$)&)+ÿš-ÿš/ÿš1ÿš3ÿš5ÿš7ÿ×<ÿ®>ÿ®@ÿ®CÿqDÿ\Fÿ\Gÿ×HÿqJÿ…ûÿ×ýÿ×ÿ®ÿ®ÿ®ÿ… ÿ…WÿšXÿqYÿ\_ÿ×`ÿqbÿšÿqÿ\ÿq ÿ\!ÿq"ÿ\#ÿq%ÿq&ÿ\'ÿq(ÿ\)ÿq*ÿ\+ÿq,ÿ\-ÿq.ÿ\/ÿq0ÿ\1ÿq2ÿ\3ÿq4ÿ\6ÿq8ÿq:ÿq<ÿq@ÿqBÿqDÿqIÿ×JÿqKÿ×LÿqMÿ×NÿqOÿ×Qÿ×RÿqSÿ×TÿqUÿ×VÿqWÿ×XÿqYÿ×Zÿq[ÿ×\ÿq]ÿ×^ÿq_ÿ×`ÿqbÿšdÿšfÿšhÿšjÿšlÿšnÿšpÿ×)) )) )>9 9BI 9 gsR{Í á .ý .+*Y rƒ õ  < õ Q i ¤y ( 8E \} \Ù T5Digitized data copyright © 2010-2011, Google Corporation.Open SansRegularAscender - Open Sans Build 100Version 1.10OpenSansOpen Sans is a trademark of Google and may be registered in certain jurisdictions.Ascender Corporationhttp://www.ascendercorp.com/http://www.ascendercorp.com/typedesigners.htmlLicensed under the Apache License, Version 2.0http://www.apache.org/licenses/LICENSE-2.0Digitized data copyright © 2010-2011, Google Corporation.Open SansRegularAscender - Open Sans Build 100Version 1.10OpenSansOpen Sans is a trademark of Google and may be registered in certain jurisdictions.Ascender Corporationhttp://www.ascendercorp.com/http://www.ascendercorp.com/typedesigners.htmlLicensed under the Apache License, Version 2.0http://www.apache.org/licenses/LICENSE-2.0ÿffª      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«.notdefnullnonmarkingreturnspaceexclamquotedbl numbersigndollarpercent ampersand quotesingle parenleft parenrightasteriskpluscommahyphenperiodslashzeroonetwothreefourfivesixseveneightninecolon semicolonlessequalgreaterquestionatABCDEFGHI.altJKLMNOPQRSTUVWXYZ bracketleft backslash bracketright asciicircum underscoregraveabcdefghijklmnopqrstuvwxyz braceleftbar braceright asciitildenonbreakingspace exclamdowncentsterlingcurrencyyen brokenbarsectiondieresis copyright ordfeminine guillemotleft logicalnotuni00AD registered overscoredegree plusminus twosuperior threesuperioracutemu paragraphperiodcenteredcedilla onesuperior ordmasculineguillemotright onequarteronehalf threequarters questiondownAgraveAacute AcircumflexAtilde AdieresisAringAECcedillaEgraveEacute Ecircumflex Edieresis Igrave.alt Iacute.altIcircumflex.alt Idieresis.altEthNtildeOgraveOacute OcircumflexOtilde OdieresismultiplyOslashUgraveUacute Ucircumflex UdieresisYacuteThorn germandblsagraveaacute acircumflexatilde adieresisaringaeccedillaegraveeacute ecircumflex edieresisigraveiacute icircumflex idieresisethntildeograveoacute ocircumflexotilde odieresisdivideoslashugraveuacute ucircumflex udieresisyacutethorn ydieresisAmacronamacronAbreveabreveAogonekaogonekCacutecacute Ccircumflex ccircumflexCdotcdotCcaronccaronDcarondcaronDcroatdcroatEmacronemacronEbreveebreve Edotaccent edotaccentEogonekeogonekEcaronecaron Gcircumflex gcircumflexGbrevegbreveGdotgdot Gcommaaccent gcommaaccent Hcircumflex hcircumflexHbarhbar Itilde.altitilde Imacron.altimacron Ibreve.altibreve Iogonek.altiogonekIdotaccent.altdotlessiIJ.altij Jcircumflex jcircumflex Kcommaaccent kcommaaccent kgreenlandicLacutelacute Lcommaaccent lcommaaccentLcaronlcaronLdotldotLslashlslashNacutenacute Ncommaaccent ncommaaccentNcaronncaron napostropheEngengOmacronomacronObreveobreve Ohungarumlaut ohungarumlautOEoeRacuteracute Rcommaaccent rcommaaccentRcaronrcaronSacutesacute Scircumflex scircumflexScedillascedillaScaronscaron Tcommaaccent tcommaaccentTcarontcaronTbartbarUtildeutildeUmacronumacronUbreveubreveUringuring Uhungarumlaut uhungarumlautUogonekuogonek Wcircumflex wcircumflex Ycircumflex ycircumflex YdieresisZacutezacute Zdotaccent zdotaccentZcaronzcaronlongsflorin Aringacute aringacuteAEacuteaeacute Oslashacute oslashacute Scommaaccent scommaaccent circumflexcaronmacronbreve dotaccentringogonektilde hungarumlauttonos dieresistonos Alphatonos anoteleia EpsilontonosEtatonos Iotatonos.alt Omicrontonos Upsilontonos OmegatonosiotadieresistonosAlphaBetaGammauni0394EpsilonZetaEtaThetaIota.altKappaLambdaMuNuXiOmicronPiRhoSigmaTauUpsilonPhiChiPsiuni03A9Iotadieresis.altUpsilondieresis alphatonos epsilontonosetatonos iotatonosupsilondieresistonosalphabetagammadeltaepsilonzetaetathetaiotakappalambdauni03BCnuxiomicronpirhosigma1sigmatauupsilonphichipsiomega iotadieresisupsilondieresis omicrontonos upsilontonos omegatonos afii10023 afii10051 afii10052 afii10053 afii10054 afii10055.alt afii10056.alt afii10057 afii10058 afii10059 afii10060 afii10061 afii10062 afii10145 afii10017 afii10018 afii10019 afii10020 afii10021 afii10022 afii10024 afii10025 afii10026 afii10027 afii10028 afii10029 afii10030 afii10031 afii10032 afii10033 afii10034 afii10035 afii10036 afii10037 afii10038 afii10039 afii10040 afii10041 afii10042 afii10043 afii10044 afii10045 afii10046 afii10047 afii10048 afii10049 afii10065 afii10066 afii10067 afii10068 afii10069 afii10070 afii10072 afii10073 afii10074 afii10075 afii10076 afii10077 afii10078 afii10079 afii10080 afii10081 afii10082 afii10083 afii10084 afii10085 afii10086 afii10087 afii10088 afii10089 afii10090 afii10091 afii10092 afii10093 afii10094 afii10095 afii10096 afii10097 afii10071 afii10099 afii10100 afii10101 afii10102 afii10103 afii10104 afii10105 afii10106 afii10107 afii10108 afii10109 afii10110 afii10193 afii10050 afii10098WgravewgraveWacutewacute Wdieresis wdieresisYgraveygraveendashemdash afii00208 underscoredbl quoteleft quoterightquotesinglbase quotereversed quotedblleft quotedblright quotedblbasedagger daggerdblbulletellipsis perthousandminutesecond guilsinglleftguilsinglright exclamdblfraction nsuperiorfranc afii08941pesetaEuro afii61248 afii61289 afii61352 trademarkOmega estimated oneeighth threeeighths fiveeighths seveneighths partialdiffDeltaproduct summationminusradicalinfinityintegral approxequalnotequal lessequal greaterequallozengeuniFB01uniFB02 cyrillicbrevedotlessjcaroncommaaccent commaaccentcommaaccentrotate zerosuperior foursuperior fivesuperior sixsuperior sevensuperior eightsuperior ninesuperioruni2000uni2001uni2002uni2003uni2004uni2005uni2006uni2007uni2008uni2009uni200Auni200BuniFEFFuniFFFCuniFFFDuni01F0uni02BCuni03D1uni03D2uni03D6uni1E3Euni1E3Funi1E00uni1E01uni1F4Duni02F3 dasiaoxiauniFB03uniFB04OhornohornUhornuhornuni0300uni0301uni0303hookdotbelowuni0400uni040Duni0450uni045Duni0460uni0461uni0462uni0463uni0464uni0465uni0466uni0467uni0468uni0469uni046Auni046Buni046Cuni046Duni046Euni046Funi0470uni0471uni0472uni0473uni0474uni0475uni0476uni0477uni0478uni0479uni047Auni047Buni047Cuni047Duni047Euni047Funi0480uni0481uni0482uni0483uni0484uni0485uni0486uni0488uni0489uni048Auni048Buni048Cuni048Duni048Euni048Funi0492uni0493uni0494uni0495uni0496uni0497uni0498uni0499uni049Auni049Buni049Cuni049Duni049Euni049Funi04A0uni04A1uni04A2uni04A3uni04A4uni04A5uni04A6uni04A7uni04A8uni04A9uni04AAuni04ABuni04ACuni04ADuni04AEuni04AFuni04B0uni04B1uni04B2uni04B3uni04B4uni04B5uni04B6uni04B7uni04B8uni04B9uni04BAuni04BBuni04BCuni04BDuni04BEuni04BF uni04C0.altuni04C1uni04C2uni04C3uni04C4uni04C5uni04C6uni04C7uni04C8uni04C9uni04CAuni04CBuni04CCuni04CDuni04CE uni04CF.altuni04D0uni04D1uni04D2uni04D3uni04D4uni04D5uni04D6uni04D7uni04D8uni04D9uni04DAuni04DBuni04DCuni04DDuni04DEuni04DFuni04E0uni04E1uni04E2uni04E3uni04E4uni04E5uni04E6uni04E7uni04E8uni04E9uni04EAuni04EBuni04ECuni04EDuni04EEuni04EFuni04F0uni04F1uni04F2uni04F3uni04F4uni04F5uni04F6uni04F7uni04F8uni04F9uni04FAuni04FBuni04FCuni04FDuni04FEuni04FFuni0500uni0501uni0502uni0503uni0504uni0505uni0506uni0507uni0508uni0509uni050Auni050Buni050Cuni050Duni050Euni050Funi0510uni0511uni0512uni0513uni1EA0uni1EA1uni1EA2uni1EA3uni1EA4uni1EA5uni1EA6uni1EA7uni1EA8uni1EA9uni1EAAuni1EABuni1EACuni1EADuni1EAEuni1EAFuni1EB0uni1EB1uni1EB2uni1EB3uni1EB4uni1EB5uni1EB6uni1EB7uni1EB8uni1EB9uni1EBAuni1EBBuni1EBCuni1EBDuni1EBEuni1EBFuni1EC0uni1EC1uni1EC2uni1EC3uni1EC4uni1EC5uni1EC6uni1EC7 uni1EC8.altuni1EC9 uni1ECA.altuni1ECBuni1ECCuni1ECDuni1ECEuni1ECFuni1ED0uni1ED1uni1ED2uni1ED3uni1ED4uni1ED5uni1ED6uni1ED7uni1ED8uni1ED9uni1EDAuni1EDBuni1EDCuni1EDDuni1EDEuni1EDFuni1EE0uni1EE1uni1EE2uni1EE3uni1EE4uni1EE5uni1EE6uni1EE7uni1EE8uni1EE9uni1EEAuni1EEBuni1EECuni1EEDuni1EEEuni1EEFuni1EF0uni1EF1uni1EF4uni1EF5uni1EF6uni1EF7uni1EF8uni1EF9uni20ABuni030Fcircumflexacutecombcircumflexgravecombcircumflexhookcombcircumflextildecombbreveacutecombbrevegravecomb brevehookcombbrevetildecombcyrillichookleftcyrillicbighookUCcyrillicbighookLCone.pnumzero.osone.ostwo.osthree.osfour.osfive.ossix.osseven.oseight.osnine.osffuni2120Tcedillatcedillag.altgcircumflex.alt gbreve.altgdot.altgcommaaccent.altIIgraveIacute Icircumflex IdieresisItildeImacronIbreveIogonek IdotaccentIJ IotatonosIota Iotadieresis afii10055 afii10056uni04C0uni04CFuni1EC8uni1ECA ÿÿ © 46latnMOL ROM ÿÿÿÿÿÿ nälatnMOL (ROM Bÿÿ  ÿÿ  ÿÿ  liga°liga¶liga¼lnumÂlnumÈlnumÎloclÔloclÚonumàonumèonumðpnumøpnumþpnumsalt saltsaltss01"ss01*ss012ss02:ss02@ss02Fss03Lss03Rss03Xtnum^tnumftnumn    &.6>FNV^PzªÆîô2H‘’“”•JJßßááããåå.,Ž‘êìîðòôZgw¡¢ÉØEG–© ƒ„…†‡ˆ‰Š‹Œ ƒ…†‡ˆ‰Š‹Œ„‚‚ ‚ ƒŒ‚ ‚ƒŒ !$%IJ6 "(^IO]ILI5O4LI^V0‚R *†H†÷  ‚C0‚?1 0 +0a +‚7 S0Q0, +‚7¢€<<<Obsolete>>>0!0 +‚¸¹€Ùõ@¦mn³TA6™ÞÓ} ‚]0‚z0‚b 8%×úøa¯žôç&µÖZÕ0  *†H†÷ 0S1 0 UUS10U VeriSign, Inc.1+0)U"VeriSign Time Stamping Services CA0 070615000000Z 120614235959Z0\1 0 UUS10U VeriSign, Inc.1402U+VeriSign Time Stamping Services Signer - G20Ÿ0  *†H†÷ 0‰ĵòR¼ˆ†`)J[/K‘k‡‘ó5TX5êÑ6^bMRQ4qÂ{f‰ÈÝ*Äj ö7Ù˜t‘ö’®°µv–ñ©JcEG.k ’NK+ŒîXJ‹Ôä,ø‚ªXÙÍBó-ÀuÞ«ÇŽšlL•ÞÛïgárÂIž`<áâ¾£cxi{­-£Ä0Á04+(0&0$+0†http://ocsp.verisign.com0 Uÿ003U,0*0( & $†"http://crl.verisign.com/tss-ca.crl0U%ÿ 0 +0UÿÀ0U0¤010 UTSA1-20  *†H†÷ ‚PÅKÈ$€ßä $ÂÞ±¡¡¦‚- ƒ7 ‚,°ZaµØþˆÛñ‘‘³V@¦ë’¾89°u6t:˜Oä7º™‰Ê•B°¹Ç WàúÕdB5NÑ3¢ÈMª'Çòá†L8MƒxÆüSàëà‡Ý¤–ž^ ˜â¥¾¿‚…Ã`áß­(ØÇ¥KdÚÇ[½¬9Õ8"¡3‹/Ššë¼!?DA µe$¼HÓD€ë¡ÏÉ´ÏTÇ£€\ùy>]r}ˆž,C¢ÊSÎ}=ö*:¸O”¥m ƒ]ù^Sô³WpÃûõ­• ÞÄ€`É+n†ñëôx'ÑÅî4[^¹I2ò30‚Ä0‚- G¿•ßRFC÷ÛmH 1¤0  *†H†÷ 0‹1 0 UZA10U Western Cape10U Durbanville10 U Thawte10U Thawte Certification10UThawte Timestamping CA0 031204000000Z 131203235959Z0S1 0 UUS10U VeriSign, Inc.1+0)U"VeriSign Time Stamping Services CA0‚"0  *†H†÷ ‚0‚ ‚©Ê²¤ÌÍ ¯ }‰¬‡uð´NñßÁ¿ga½£dÚ»ùÊ3«„0‰X~ŒÛkÝ6ž¿Ñìxòw¦~o<¿“¯ ºhôl”ʽR-«H=õ¶Õ]_Ÿú/k¤÷£š¦ÈáLRã`ì@~¹ Þ?Ǵ߇½_zj1.™¨G Î1s W-Íx43•™¹Þh/ªæ㊌*Ë!‡f½ƒXWou¿<ª&‡]Ê<Ÿ„êTÁ nÄþÅJݹ—"|Û>'ÑxìŸ1Éñæ"ÛijGCš_ ä^õî|ñ}«bõM ÞÐ"V¨•Í®ˆv®îº óäMÙ ûh ®;³‡Á»£Û0Ø04+(0&0$+0†http://ocsp.verisign.com0Uÿ0ÿ0AU:0806 4 2†0http://crl.verisign.com/ThawteTimestampingCA.crl0U% 0 +0Uÿ0$U0¤010U TSA2048-1-530  *†H†÷ JkùêXÂD1‰y™+–¿‚¬ÖLÍ°ŠXnß)£^ÈÊ“çR ïG'/8°äÉ“NšÔ"b÷?7!Op1€ñ‹8‡³èè—þÏU–N$Ò©'Nz®·aAó*ÎçÉÙ^Ý»+…>µµÙáWÿ¾´Å~õÏ žð—þ+Ó;R8'÷?J0‚ü0‚e eR&á².áY)…¬"ç\0  *†H†÷ 0_1 0 UUS10U VeriSign, Inc.1705U .Class 3 Public Primary Certification Authority0 090521000000Z 190520235959Z0¶1 0 UUS10U VeriSign, Inc.10U VeriSign Trust Network1;09U 2Terms of use at https://www.verisign.com/rpa (c)09100.U'VeriSign Class 3 Code Signing 2009-2 CA0‚"0  *†H†÷ ‚0‚ ‚¾g´`ªIoV|fÉ^† Õñ¬§qƒŽ‹‰øˆ‰º-„!•äÑœPLûÒ"½Úò²5;à ûü.Z¿‰|=;%öóX{œôµÆ ¸€Î¾'tag'MjåìaXy£à'°áM4+G D¹Þf$fŠÍOºÅ8ÈTáröfuj¹IhÏ8y ª0¨Û,`Hž×ª©ƒ×8‘09–:|@T¶­à/ƒÜ¨R>³×+ý!¶§\£ ©¦P4.M§ÎÉ^%ÔŒ¼ón|)¼]ü1‡ZÕŒ…gXˆ ¿5ðê+£!çöƒå¨í`x^{`ƒýW ]A cT`ÖC!Û0‚×0Uÿ0ÿ0pU i0g0e `†H†øE0V0(+https://www.verisign.com/cps0*+0https://www.verisign.com/rpa0Uÿ0m+ a0_¡] [0Y0W0U image/gif0!00+åÓ†¬ŽkÃÏ€jÔH,{.0%#http://logo.verisign.com/vslogo.gif0U%0++04+(0&0$+0†http://ocsp.verisign.com01U*0(0& $ "† http://crl.verisign.com/pca3.crl0)U"0 ¤010UClass3CA2048-1-550U—Ðk¨&pÈ¡?”-Ä5›¤¡ò0  *†H†÷ ‹ÀÝ”ØA¢ai°¨xÇ0Æ<~B÷$¶äƒsœ¡âú/ëÀÊDçràP¶U ƒn–’äšQj´71Ü¥-ëŒÇOçM2º…øN¾úgUeðj¾zÊd8xEv1ó†z`³]ö‹fv‚Yáƒå½I¥8VåÞAwX0‚0‚û fãðgyÊmPSoˆƒ0  *†H†÷ 0¶1 0 UUS10U VeriSign, Inc.10U VeriSign Trust Network1;09U 2Terms of use at https://www.verisign.com/rpa (c)09100.U'VeriSign Class 3 Code Signing 2009-2 CA0 100729000000Z 120808235959Z0Ð1 0 UUS10U Massachusetts10 UWoburn10U Monotype Imaging Inc.1>0<U 5Digital ID Class 3 - Microsoft Software Validation v210U Type Operations10UMonotype Imaging Inc.0Ÿ0  *†H†÷ 0‰”D •i|U ÐÛ25ŠL3«^ ¡L×*‡8ט¥@ðI "SOÂC¦Ê‹©VïnH¨9c;$¹˜ÏÊ5}rãGWýyËŠJç@p-5c®€ÏįØû÷Éü‰Øפ Û ò¢ò{ïÍuÁ÷ePd"½}¼­¸KÌXEMÑYLM£‚ƒ0‚0 U00Uÿ€0DU=0;09 7 5†3http://csc3-2009-2-crl.verisign.com/CSC3-2009-2.crl0DU =0;09 `†H†øE0*0(+https://www.verisign.com/rpa0U% 0 +0u+i0g0$+0†http://ocsp.verisign.com0?+0†3http://csc3-2009-2-aia.verisign.com/CSC3-2009-2.cer0U#0€—Ðk¨&pÈ¡?”-Ä5›¤¡ò0 `†H†øB0 +‚70ÿ0  *†H†÷ ‚Næ"‡ßgAâÒî~ΙÖc½ðµ“åjrbáõÒ<8î¨=_ºG‚_[KIô ú“ ÐVD¢ˆóû®÷ 5Þ< ¬D”`E*›þ›oL;±4gp†ÿZ9\Zãl‚«5|eKý˜mµ”Iœˆp¾=±b•´Û´ÔÚèA~þ}¹¤’ënò"ŠÆw6MŠZ S1Ó+(¯RázkµwD½ ­ô]%,ãÍŠ0>KœyʦN® ÂÌ$ Á”‚öñº¶›šØ\<ñê'M<‰o3ŠÓ†ÞéX3u=ë“iâDoNlÏÕ…ÚV¦š¦?ËL!hò`ºáè]9!2í1‚g0‚c0Ë0¶1 0 UUS10U VeriSign, Inc.10U VeriSign Trust Network1;09U 2Terms of use at https://www.verisign.com/rpa (c)09100.U'VeriSign Class 3 Code Signing 2009-2 CAfãðgyÊmPSoˆƒ0 + p0 +‚7 100 *†H†÷  1  +‚70 +‚7 10  +‚70# *†H†÷  1HãêÛcƱW' ·eôS•0  *†H†÷ €E;¼ÔºïÚ¿b;ÞìJ„EqAÉþ.•ó‰±RôAëm2,H¿)‘¼²/]d$4.º–´¶Js—àöŸA÷÷h¶õ€xA¾SÀ~xR[ª!Bܾ œ3ÓFP;™+Yiì…ØcÑ-Ö4í£œòñT@ÕG  ŒfïÞ>¡‚0‚{ *†H†÷  1‚l0‚h0g0S1 0 UUS10U VeriSign, Inc.1+0)U"VeriSign Time Stamping Services CA8%×úøa¯žôç&µÖZÕ0 + ]0 *†H†÷  1  *†H†÷ 0 *†H†÷  1 110505165510Z0# *†H†÷  1T+ ½î'üS“ô8V0  *†H†÷ €Áw‰®›o"ãkåEÚN‘@ðŸï;'JV¬:ý¨”j|÷œÁ{“`NÄ+W•”Ëášg3Ñ+)Èì¾¼Y±¤)™ìˆ™$‡w›ÊûÔÔILtÈ=.o ÉÍèåÐ!9³VÕû¬½¬©8½°Õ £Ùc­°•´hXÃâ×)ÿ‘¤Çmongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/web/client/resources/fonts/Orbitron/000077500000000000000000000000001321131462300340575ustar00rootroot00000000000000OFL.txt000077500000000000000000000106101321131462300351620ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/web/client/resources/fonts/OrbitronCopyright (c) 2009, Matt McInerney (matt@pixelspread.com), with Reserved Font Name Orbitron. This Font Software is licensed under the SIL Open Font License, Version 1.1. This license is copied below, and is also available with a FAQ at: http://scripts.sil.org/OFL ----------------------------------------------------------- SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007 ----------------------------------------------------------- PREAMBLE The goals of the Open Font License (OFL) are to stimulate worldwide development of collaborative font projects, to support the font creation efforts of academic and linguistic communities, and to provide a free and open framework in which fonts may be shared and improved in partnership with others. The OFL allows the licensed fonts to be used, studied, modified and redistributed freely as long as they are not sold by themselves. The fonts, including any derivative works, can be bundled, embedded, redistributed and/or sold with any software provided that any reserved names are not used by derivative works. The fonts and derivatives, however, cannot be released under any other type of license. The requirement for fonts to remain under this license does not apply to any document created using the fonts or their derivatives. DEFINITIONS "Font Software" refers to the set of files released by the Copyright Holder(s) under this license and clearly marked as such. This may include source files, build scripts and documentation. "Reserved Font Name" refers to any names specified as such after the copyright statement(s). "Original Version" refers to the collection of Font Software components as distributed by the Copyright Holder(s). "Modified Version" refers to any derivative made by adding to, deleting, or substituting -- in part or in whole -- any of the components of the Original Version, by changing formats or by porting the Font Software to a new environment. "Author" refers to any designer, engineer, programmer, technical writer or other person who contributed to the Font Software. PERMISSION & CONDITIONS Permission is hereby granted, free of charge, to any person obtaining a copy of the Font Software, to use, study, copy, merge, embed, modify, redistribute, and sell modified and unmodified copies of the Font Software, subject to the following conditions: 1) Neither the Font Software nor any of its individual components, in Original or Modified Versions, may be sold by itself. 2) Original or Modified Versions of the Font Software may be bundled, redistributed and/or sold with any software, provided that each copy contains the above copyright notice and this license. These can be included either as stand-alone text files, human-readable headers or in the appropriate machine-readable metadata fields within text or binary files as long as those fields can be easily viewed by the user. 3) No Modified Version of the Font Software may use the Reserved Font Name(s) unless explicit written permission is granted by the corresponding Copyright Holder. This restriction only applies to the primary font name as presented to the users. 4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font Software shall not be used to promote, endorse or advertise any Modified Version, except to acknowledge the contribution(s) of the Copyright Holder(s) and the Author(s) or with their explicit written permission. 5) The Font Software, modified or unmodified, in part or in whole, must be distributed entirely under this license, and must not be distributed under any other license. The requirement for fonts to remain under this license does not apply to any document created using the Font Software. TERMINATION This license becomes null and void if any of the above conditions are not met. DISCLAIMER THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM OTHER DEALINGS IN THE FONT SOFTWARE. Orbitron-Regular.ttf000077500000000000000000001150741321131462300377270ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/web/client/resources/fonts/Orbitron DSIG’ìFFTMX_Óbš GDEF)$’ô(GPOS Ô=å•ÐNGSUB]Ò“²OS/2…ÞíÛ¨`cmapjQ™ðBgaspÿÿ’äglyfÚâjM 4HXheadõò%,6hhea|Pd$hmtxÙ*èkern0P/ÃRŒžlocaÐâ¾\<ömaxpAGˆ name_O¢`W,8(postc¹ð0TŽprephŒ…4m3_<õ èÉ#ê É#ê ÿEÿ Fóîÿ_ÿEÿðFúúD@(¼ŠŒ¼ŠÝ2ú€'Bpyrs@ à îÿóóDÑ MÜ:t; "Æ0ª5à;48ë±Á6;Ö6 B9‡>9:5Ú>949”B9<3Ö6Á3Ù~;Û;¦?9D:@;68B:þ:Ó:>8S9Ü9 9 9 8@8<68t69763÷<6ë#›#,.&5363<6Õ ¶4›6·3›´3—5«)œ6Ð4ïÿE†6.4Ò6¸6´3˜6˜4®0š5·5/#´.­*º6!Ö6!3”Ò5|!Þ'6·-Õ!A8Õ!£D:D:D:D:D:D:_668þ:þ:þ:þ:Ü$Ü$ÜÿôÜÿã@8<6<6<6<6<6"5<6<6<6<6&A9Õ4Õ4Õ4Õ4Õ4Õ4š5µ3~3~3~3~3ÖÖ1ÖÿñÖÿàÄ6´3´3´3´3´3ü·5·5·5·5°*°*Ö4^5™463¯0&53º6,)(é-é#“Ä666¨!¦6k/k6s>6#;. /1›Ó “166‘;ÿä6421…=6ƒ6;684d6:6,.;56ƒ5=68321µ3Õ5¼6µ3Á6~6O6²3Ë6Ö6‘6ª6“686Ä6´3”64¼6¯1„·5¹5!Ò56"º6´.°´3º6< D@]~£¨°´¶¸Ï×Ýï÷ýÿ1Sax~ÇÚÜ    " & ¬"ààà ÿÿ _¡¨°´¶¸¿ÑÙßñùÿ1R`x}ÆØÜ    " & ¬"àààÿÿÿãÿâÿÀÿ¼ÿµÿ²ÿ±ÿ°ÿªÿ©ÿ¨ÿ§ÿ¦ÿ¥ÿ¤ÿsÿSÿGÿ1ÿ-ýæýÖýÕàŸàœàšà–à“àÞ© ¼ » º  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`noqsz„ˆ‡‰‹ŠŒŽ‘’”“•–—™˜šœ›Ÿž ¡ebc¸g†fdpia¹jm~¥¦²³¶·´µ£©ºltkurwxyv|}{‚ƒ¤¬±®¯°h­¸ÿ…°$X°Zf†¤ÈÜìúFZ”Úö,f~Ð 6H\nžêZ|¨ÀÖ&2Rn~š°âF|ÂÖø *H`xˆ–¨´Âê  : h – ° ì  : T j ” ² ä  @ X ž º Ü ð  ( R j ” ¢ Ì ê þ . \ n œ ª Ü êN~²ò&p Èè(L`tŒ¤Ð D‚Ì "Lv¢Îì*ZŠ¼ú.x¶ÜH‚¼ÐäüH‚¼úB€šÂìDt¨´ê.€Òô8J\v¸Öäò*BVlž¬¬Äô$Xv–´ÈâüüD\t¤ÈâPŒÀÒì*bŒÀì  Z | ¨ À Ô! !"!.!N!r!Œ!œ!¶!Ì!þ","`"’"Ø"ì##(#<#d#‚#²#Ì#â$$,:ŒÐ3#53'3ŒRRRRRyýû;D(Ð#53#5RíRÐŒŒŒŒ Ï#3##7!#7#537#5373!73!7!yGŸ¹5R6þü5R6eG¦À8Q98Q9þLGþü+RÜR««««RÜR¤¤¤¤þÒÜ"ÿŽúC/9C#54&+32+#5#"&=3;5#"&=46;5332#326=4&%5#"3úSÉÉ3GG3ÉRÊ2GRÊÊ2GG2ÊRÉ3GzÉÉþÕÊWìG2 2GrrG2îF3ž3GrrGþ¶î Rìž0ÿÿ¤Ñ#3C35%32+"&=46326=4&+"32+"&=46326=4&+"‰ØýI^3GG3^3GGŠŠH_2GG2_3FF‰‰lekjG3T2GG2T3Gþö~~€G2U2GG2U2Gþö5’Ï&3%'#!"&=463&=463!2#54&#!"53!267#" †‰?&þ2G6-9G2›)E Sþe Rý¢å þ§OHM*3G2×++5d3G=)7"‹þù‹û×;DÐ#5RÐŒŒ4ÊÐ73#"&546;#"­2GG2RRG2Ý3GSþ#8ÎÐ3532654&+532#82HH2RÝSG3þ#2G;ÂÏ'.'7'753§’Z ) [Z* Z‘“RfO/}  {{ ~/O1š™d—ê 33##5#53©RœœR˜˜ê™R››R6ÿ}ˆR736R.$Rb(? ;ÿÁQ!5ÁþzQRR6ˆR7#5ˆRRRRÐ7úþjfhý˜9Ð!2#!"&546!"!265²å2GG2þ3FF4ýÿ ÐG3þ#2GG2Ý3GSþ_c¡.Ð73#½pSSïáý0tb9Ñ(!2#!"3!!463!26=4&#!"#546²å2GG2þ^ý)F3åþRFÑG3©2G•R3F©3G5 Ñ3#!"&=33!26=4&#!5!26=4&#!"#5463!2á(G2þ3GSåþ+µþ;SG3Å3FŒ%5§2GG2§R—3GG3—¾Ñ 3##5!53!NppRþ ì\Rþs Rºº\»ƒþ¾9Ñ%3!2#!"&=33!26=4&#!!!"‹å2GG2þ3FRåý¢×ý¢W“F3ª2GG2ª‡S9Ñ&!2#!"&5463!!"54&#!3!26²å2GG2þ3FF3àþ ýôåŸF3­2GG2Þ3GSþÚ­Ô\Ñ !5!2#4&ãþ à2GR~SG3ý©W9Ñ)9#!"&=47&=463!254&#!"3!2654&#!"3!26G2þ3FF3å(EFþåþåk§()')ª2GG2ª)')(“3G=ý媪Ožž3 Ñ(!"&=463!2#!"&'!26=4&3!54&#!"’þ3GG3å2GG2þ'@ Xýä þ1G2­3GG3þ"2G.$‘&­Ô6ˆL73##56RRRRRRLRR3ÿ}…L #53…RR.$LRRþb(? —@%5%W@þn’(¹_èaç_;—@±%!5%!5@ýûýûéRRÈRR;Í>75-5;@þÀ’_¹¹_çaÐ2#!"#5463!26=4&#!#532GG2þîRG2ýûÌRRÐG3Â2G**3FÂý„R9Ð(53234&#!"3!!"&5463!2!"&=46354&+"u_2Gqþ^ý¢3FF3å2Gþe3FF°‰G2Xþ#RG2Ý3GG3þjG3T2Gþ÷¥~: Ð !2#!#46!4&#!"²à2FQýÒQF .þ ÐF2ý¨þùX2Fþˆ; Ð/#!!2'!"3!26=4&54&#!"3!26ß(F2ý¨92Fxþ?Á6þ àŠ%4¨2FÐF2™Û™™ýù¨¨8Ð!"3!!"&5463!ýªVýª2FF2Vþ QF2à2F: Ð !2#!%4&#!"3!26:X2FF2ý¨þ àÐF2þ 2Fxàþ :ËÐ !!!!!ËýÀÏþ1@ýoÐQîRîQÐ:ËÐ !!!!#:‘ýÀÏþ1QÐQîRþÁ8Ð%#54&#!"3!26=#5!#!"&5463!2Qþ à²F2þ 2FF2à2FXþ ²Rþü2FF2à2FF9Ð 3#!#3!ÉRRýÁQQ?Ðý0?þÁÐþÁ9ŠÐ339QÐý0ÔÐ%3#!"&=33!26ƒQF2þ 2FQàxXý¨2FF2999èÐ 3 ###33hþÓ.iþôèRRèÐþ˜þ˜?þÁÐþÁ9 Ñ33!9QÑý€Q8lÐ 3# #3Ò+oQþ·þ·Qoldý0tþy‡ýŒÐ8Ð %3##3·QoýðQo\tý0týŒÐ6Ð!2#!"&546!2654&#!"®à2FF2þ 2FF2àþ ÐF2þ 2FF2à2Fýàþ 8Ï !2#!"'#54&#!"3!268X2FF2þ Qþ àÏF2Ó2Fþð„ÓÓ6dÐ %3!"&5463!2!2654&#!"býJ2FF2à2Fý¨àþ QQF2à2FF2þ àþ 7Ï!+#!"'#!2!26=4&#!"F2nâkáþø QX2Fý¨àþ WÓ2Fþô þðÏFþÕÓÓ3Ð3#54&#!"3!2#!"&=33!26=4&#!"&=463!2Qþ à2FF2þ 2FQàþ 2FF2à2FX¡F2¡2FF2¡F2¡2FFäÐ!!#!ÐþÁQþÀÐQý6Ð%3#!"&533!26µQF2þ 2FQàxXý¨2FF2Xý¨#ÂÐ%3#3óp_þ`^þ__Oý0Ð#|Ð 3# #33$XþúGààFþúVÓÒbÓÐý0gý™Ðý¾Bý¾.ôÐ 3 # # 3‹hþÒ/iúûh.þÒhûÐþ˜þ˜)þ×hhþ×øÐ3#3™_þµQþµ]Ðþ?þñÁþ 3Ð 5!!!53ÐýŒtý0tQoýðQo6ÌÑ33#36–DDÑSýÔRÿÕ%5ÿþkjlh3ÉÑ53#533––C~Sý/R,6ÿ®!!5ý(RR h“ó#'q"P#ó‹‹4ƒD2!"&=!54&#!55!3 3Gþ*2Güþ+üþVDG2þ5G2Ò€Rþ§€6… 2#!34&#!"3!26 2GG2þ*R«þ¤\DG2þ®2G¾þ5Rþ®3‚D7!!"&5463!!"¬Öþ*2GG2Ôþ,RRG2R2GRþ®f 3!"&5463!!2654&#!"Rþ+3GG3ƒþ}\þ¤üþG2R2GþRþ®3‚D2!3!!"&5463!54&#!"3GþÖþ*2GG2'ªþ¤DG2Ò€RG2R2Gù€5‚"3##46;®ûûRF3Ô°ERþ‰3FR)ÿwD&#!5!26=!"&5463!2!2654&#!"wF3þ–jþ}2GG2\3Fþ+\þ¤k3GSkG2R2GG2þ‡Rþ®6…2#4&#!"#3 2GRþ¤RRDG2þ5Ëþ5¾4†333#4RRRRDý¼RÿEÿ ´3#+53265aSSSG3õõRlýC3GS½6x 3 #'##33 lþùkä RR DþÞþÞùùþI4 3;#"&54Rbb2GýwRG26­D2#4&+"#4&+"#43FQñSòSDG2þ5Ëþ5Ëþ5D6…D2#4&#!"# 2GRþ¤RDG2þ5Ëþ5D3‚D!2#!"&546!"3!2654&¬\3GG3þ¤2GGŽþ¤\DG2þ®2GG2R2GRþ®R6ÿ…D 2#!#4&#!"3!26 2GG2þ|Rýþ¤\DG2þ®2Gæ*þ5Rþ®ÿcD 463!#5!"&53!2654&#!"G3ÕRþ}3GS\þ¤Ë2GüÖæG2Rþ®R4óD !!"#46­FþºRGDRþ5Ë2G0D3#54&#!"3!2#!"&=33!26=4&#!"&=463!2Sþ¤\3GG3þ¤2GR\þ¤2GG2\3GËYG2Y2GG2YG2Y2GG5‚#;#"&533‚ûÔÔ3FRûòþ‡RG2‰¾5„D3#!"&533!2652RG3þ¤2GR\Dþ52GG2Ëþ5õD3#3•`þ¿_þÀ`Dý¼Dþ #D 3# #33½YÛGØÍHäX°»lÇDý¼ßþ!DþP°þQ.D 3#'#3kòól½¼lòòl¼DþãþÙèè'Ü*ÿxB#!5!26=!"&533!2653xF3þ–jþ}2GR\Rl3GSlG2Éþ7É6…D 5!!!56Oþ õý±õòRpþ~Rp‚ÜÐ;#"&=.'57546;#"˜2G"/G2T#ªRG2£`¤3GS«C6ÿˆJ36Rs½üC3÷Ð757'54&+532+5326wTT2G".G2y©EB­SG3¤_¢2GRõkb327#"&#"5632' "##†*'#(†) G% C5‡Ø#5#3‡RRRRØSSý(!ÿmÖ#3##5#"&546;533#"3müüüR…3FF3…Rüþ²…üþVRssG2\3G‡‡þªþ¤'³Ð#54&#!"!!!!535#535463!2³SþÑ`þ ÐýtiiiG3/3GGÁRñRRñRÁ3GG36h<º#5##5#53’|2GG2ÈSG3Èþ_R C¶SSÐG3Â2G]]3FÂr`)<ý0R ÁÑ3##5!53!53QppRþ y[þ‚ R Rºº]ºþZcÐ !333#dýœlðjRoþàÐý]ýsý0Wþ©1“Ð 3##33)jýžpþàpRiïÐý0Wþ©Ðýsþêþ£6 Ñ33#6SkýpÑýŒtý/ØÑ 3#3#5! !okdpSþ”lþÚ&Ñý/Ê«þ¨6 Ñ 3#'!#!6pdl«þ–SS'Ñý/ÊÊuþ¨ÿäEÐ !#'!#3!E_iþ0j_‚^/¹p··ÐLþ„4Ð#5!"3!53#!"&5463!2QýøN C'þ 2FF2à'Cl^qþ q^(>&þÿþê'=='þä3Ð3#!5!26=4&#!"&533!²QF2ý¨Xþ 2FQÐý¨2FQ¡F2þç1Ð#!26=4&#!5!2#!"3!!"&=46©àý¨X2FF2þ Xý¨2FF‘¡QF2¡2F¡QF2¡2F3‚D 2!"&5463!4&#!"3Gþ*2GG2ƒþ¤DG2þ5G2R2Gþyþ®5£D !2#5!#46!54&#!"®|2GRþ6RG Êþ„DG2þ5  Ë2Gþ¯Ø6E/#!!2'!"3!26=4&54&#!"3!26c(G2þ À3Gzþ¹G7þ™g:%4V2GEG2]›]]þ†VV3€E!"3!!"&5463!€þ,Ôþ,2GG2Ôóþ­RG2S2G6E !2#!%4&#!"3!266à2GG2þ þ™gEG2þ­2GySþ­6EE !!!!!EþCKþµ½ýñER¨R§RE6EE !!!!#6þCKþµRER¨Rù3‚E%#54&#!"3!26=#5!#!"&5463!2‚Sþ¤\³G3þ¤2GG2\3GÌþ­`R²2GG2S2GG6–D 3#5!#3!DRRþDRR¼Dý¼ùùDù6ˆD336RDý¼^D%3#!"&=33!26 RG2þ™2GRgyËþ52GG2006…#54&#!#3!26=…Rþ|RR„DÒ((((ÒÒùþIÒ6xD 3 #'##33 lþùkä RR DþÞþÞùùDù6D33!6RDþR6 E %3# #3ŸùqRþèþéRnßfý»ùþrŽþE6D %3##3=RoþhRo\èý¼éþD3‚D!2#!"&546!2654&#!"¬\3GG3þ¤2GG2\þ¤DG2þ®2GG2R2GþRþ®6…D !2#!"'#54&#!"3!266Ö2GG2þ¤ Rýþ¤\DG2‚2GÔI‚‚4áD %3!"&5463!2!2654&#!"~cýÌ2GG2\3Gþ*\þ¤RRG2R2GG2þ®&Rþ®6‡D+#'##!2!26=4&#!"„F3kçiä²RÕ3Fþ+\þ¤Ë‚2GÐÐÐDGÛ‚‚1€D3#54&#!"3!2#!"&=33!26=4&#!"&=463!2€Sþ¤\3GG3þ¤2GR\þ¤2GG2\3GËYG2Y2GG2YG2Y2GGoD!!#!YþýRþüDRþò5„D%3#!"&533!262RG3þ¤2GR\yËþ52GG2Ëþ55„D 3!"&533!2Rþ*2GR„Dý¼G2Ëþ5D%3#3‹`þº^þ¹aQóý¼D5¬D3"&53;2653;2653¯3GRñRóRG2Ëþ5Ëþ5Ëý¼"D 3# #33ÄXÝHØÍHèX³ÀdËDý¼Óþ-DþQ¯þR6…D!#54&#!"#547&=33!26=…Rþ¤RR\DÒ((((ÒÒÒÒ((((ÒÒÒ.D 3#'#3lòól½¼lòòl¼DþäþØéé(Û…D3#53$aþðSþð`ÙDþ„ÈÈ|þå3‚D#7"3!!"&=463!26=4&#!5!2#¬Öþ*2GG2\þ+Õ3GG3ùYRG2Y2GYRG2Y2G6…D 5!!!56Oþ õý±õòRpþ~Rp‚šÂŒ"Xÿÿ$:ÿá$<ÿó%9ÿÏ%<ÿá'9ÿã'=ÿå(0ÿã(2ÿá)-ÿ)5)7 )[ÿì*:ÿå.$ÿâ.+ÿã/9ÿ/:ÿ/<ÿM0Eÿö29ÿå2:ÿå2;ÿÙ3$ 3-ÿE3F 3X59ÿí5:ÿí61ÿí6:ÿç6<ÿö7Qÿ…7Uÿ‡7Wÿ›7Yÿ­7[ÿ¥7\ÿ™9$ÿÛ92ÿß96ÿì9Qÿâ9UÿØ:$ÿå:2ÿé:Cÿñ:GÿÝ:Kÿö:Qÿç:Wÿì;%ÿÝ<6ÿÝ<CÿŸ<Gÿ‰<Kÿí<Qÿ‰<Rÿ<Uÿ‹<WÿŸ=<ÿöCDÿçCEÿöCNÿöCOÿìCPÿñCTÿûCUÿìCXÿìCYÿâCZÿñC\ÿçDFEGÿçEJÿñEMÿìEVÿçEWÿìE\ÿìFGÿìFQÿêFWÿéGEÿìGGÿñGNÿìGTÿûGXÿìGYÿâGZÿïHÿKHVHW ICÿñIEÿñIGÿñIQÿìITÿñIUÿëIWÿçIYÿìJCJH JKKCÿÝKEÿñKHÿÑKPÿñKRÿçKSÿñKXÿûKZÿ×LGÿìMGÿûNCÿöNFNGÿñNOÿöNQÿöNXÿÅNYÿ¿Nµÿ©OMÿóOOÿóOYÿçPDÿìPEÿìPQÿñPRÿöPZÿçQCÿöQNÿìQPÿñQQÿìQTÿöQUÿìQVÿéQWÿéQXÿóQYÿÝQZÿÝRFRKRU SWÿçTÿ TÿìTQÿûUEÿíUGÿñUMÿñUPÿéUWÿìUXÿìUZÿÛU\ÿéVDVFVJVKV\WDÿñWEÿìWF WGÿñWHÿöWOÿìWPWRÿñWUÿñWVÿñWZÿñW\ÿñXGÿâXQÿãXUÿçYGÿìYQÿìYTÿìYUÿñZGÿÏ[Cÿé[Eÿì[Gÿì[N [Pÿñ[Qÿé\Cÿç\Gÿç\Nÿì\Vÿì\\ÿìÃÅþ«ÄÅþ—ÆÂþ§ÆÓþ­V9tÀÙ,;†¡Éø % "z Ë +%:6œ6É r ® É Xá h  •  § Ú  D4 , "Vâ 46f 6·Copyright (c) 2009, Matt McInerney <matt@pixelspread.com>Copyright (c) 2009, Matt McInerney OrbitronOrbitronRegularRegularFontForge 2.0 : Orbitron Regular : 7-12-2010FontForge 2.0 : Orbitron Regular : 7-12-2010Orbitron-LightOrbitron-Light1.0001.000Orbitron-RegularOrbitron-RegularMatt McInerneyMatt McInerneyMatt McInerneyMatt McInerneyhttp://theleagueofmoveabletype.comhttp://theleagueofmoveabletype.comhttp://pixelspread.comhttp://pixelspread.comCopyright (c) 2009, Matt McInerney <matt@pixelspread.com>, with Reserved Font Name Orbitron. This Font Software is licensed under the SIL Open Font License, Version 1.1. This license is copied below, and is also available with a FAQ at: http://scripts.sil.org/OFL ----------------------------------------------------------- SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007 ----------------------------------------------------------- PREAMBLE The goals of the Open Font License (OFL) are to stimulate worldwide development of collaborative font projects, to support the font creation efforts of academic and linguistic communities, and to provide a free and open framework in which fonts may be shared and improved in partnership with others. The OFL allows the licensed fonts to be used, studied, modified and redistributed freely as long as they are not sold by themselves. The fonts, including any derivative works, can be bundled, embedded, redistributed and/or sold with any software provided that any reserved names are not used by derivative works. The fonts and derivatives, however, cannot be released under any other type of license. The requirement for fonts to remain under this license does not apply to any document created using the fonts or their derivatives. DEFINITIONS "Font Software" refers to the set of files released by the Copyright Holder(s) under this license and clearly marked as such. This may include source files, build scripts and documentation. "Reserved Font Name" refers to any names specified as such after the copyright statement(s). "Original Version" refers to the collection of Font Software components as distributed by the Copyright Holder(s). "Modified Version" refers to any derivative made by adding to, deleting, or substituting -- in part or in whole -- any of the components of the Original Version, by changing formats or by porting the Font Software to a new environment. "Author" refers to any designer, engineer, programmer, technical writer or other person who contributed to the Font Software. PERMISSION & CONDITIONS Permission is hereby granted, free of charge, to any person obtaining a copy of the Font Software, to use, study, copy, merge, embed, modify, redistribute, and sell modified and unmodified copies of the Font Software, subject to the following conditions: 1) Neither the Font Software nor any of its individual components, in Original or Modified Versions, may be sold by itself. 2) Original or Modified Versions of the Font Software may be bundled, redistributed and/or sold with any software, provided that each copy contains the above copyright notice and this license. These can be included either as stand-alone text files, human-readable headers or in the appropriate machine-readable metadata fields within text or binary files as long as those fields can be easily viewed by the user. 3) No Modified Version of the Font Software may use the Reserved Font Name(s) unless explicit written permission is granted by the corresponding Copyright Holder. This restriction only applies to the primary font name as presented to the users. 4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font Software shall not be used to promote, endorse or advertise any Modified Version, except to acknowledge the contribution(s) of the Copyright Holder(s) and the Author(s) or with their explicit written permission. 5) The Font Software, modified or unmodified, in part or in whole, must be distributed entirely under this license, and must not be distributed under any other license. The requirement for fonts to remain under this license does not apply to any document created using the Font Software. TERMINATION This license becomes null and void if any of the above conditions are not met. DISCLAIMER THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM OTHER DEALINGS IN THE FONT SOFTWARE.Copyright (c) 2009, Matt McInerney , with Reserved Font Name Orbitron. This Font Software is licensed under the SIL Open Font License, Version 1.1. This license is copied below, and is also available with a FAQ at: http://scripts.sil.org/OFL ----------------------------------------------------------- SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007 ----------------------------------------------------------- PREAMBLE The goals of the Open Font License (OFL) are to stimulate worldwide development of collaborative font projects, to support the font creation efforts of academic and linguistic communities, and to provide a free and open framework in which fonts may be shared and improved in partnership with others. The OFL allows the licensed fonts to be used, studied, modified and redistributed freely as long as they are not sold by themselves. The fonts, including any derivative works, can be bundled, embedded, redistributed and/or sold with any software provided that any reserved names are not used by derivative works. The fonts and derivatives, however, cannot be released under any other type of license. The requirement for fonts to remain under this license does not apply to any document created using the fonts or their derivatives. DEFINITIONS "Font Software" refers to the set of files released by the Copyright Holder(s) under this license and clearly marked as such. This may include source files, build scripts and documentation. "Reserved Font Name" refers to any names specified as such after the copyright statement(s). "Original Version" refers to the collection of Font Software components as distributed by the Copyright Holder(s). "Modified Version" refers to any derivative made by adding to, deleting, or substituting -- in part or in whole -- any of the components of the Original Version, by changing formats or by porting the Font Software to a new environment. "Author" refers to any designer, engineer, programmer, technical writer or other person who contributed to the Font Software. PERMISSION & CONDITIONS Permission is hereby granted, free of charge, to any person obtaining a copy of the Font Software, to use, study, copy, merge, embed, modify, redistribute, and sell modified and unmodified copies of the Font Software, subject to the following conditions: 1) Neither the Font Software nor any of its individual components, in Original or Modified Versions, may be sold by itself. 2) Original or Modified Versions of the Font Software may be bundled, redistributed and/or sold with any software, provided that each copy contains the above copyright notice and this license. These can be included either as stand-alone text files, human-readable headers or in the appropriate machine-readable metadata fields within text or binary files as long as those fields can be easily viewed by the user. 3) No Modified Version of the Font Software may use the Reserved Font Name(s) unless explicit written permission is granted by the corresponding Copyright Holder. This restriction only applies to the primary font name as presented to the users. 4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font Software shall not be used to promote, endorse or advertise any Modified Version, except to acknowledge the contribution(s) of the Copyright Holder(s) and the Author(s) or with their explicit written permission. 5) The Font Software, modified or unmodified, in part or in whole, must be distributed entirely under this license, and must not be distributed under any other license. The requirement for fonts to remain under this license does not apply to any document created using the Font Software. TERMINATION This license becomes null and void if any of the above conditions are not met. DISCLAIMER THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM OTHER DEALINGS IN THE FONT SOFTWARE.http://scripts.sil.org/OFLhttp://scripts.sil.org/OFLOrbitronOrbitronÿµ2ú  !"#$%&'()*+,-./0123456789:;<=>?@BCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`a£„…ŽƒˆÞ¢­ÉÇ®bcdËeÈÊÏÌÍÎfÓÐѯgðÖÔÕhë‰jikmln oqprsutvwxzy{}|¸~€ìº×°±äå»æçØáÛÜÝÙ²³¶·´µ‡«ï      !"#$%&'()*+,-./0123456789:;<=>?@EurouniE000 seven.altnine.alttwo.alt question.altfour.altW.alt2W.altV.altA.altA.alt2CRA.alt3C.altI.altJ.altK.altM.altN.altO.altQ.altR.altS.altV.alt2V.alt3W.alt3W.alt4X.altY.altZ.alta.alta.scb.scc.scd.sce.scf.scg.sch.sci.scj.sck.altk.scl.scm.scn.sco.scp.scq.scr.scs.sct.scu.scv.altv.scw.altw.scx.altx.scy.scz.altz.scÿÿ ù (tlatnÿÿaalt&salt.smcp4ss01:ss02@ss03F (08@8Ò2ŒÈÖäR&¿Á½¾ÀÉÊËÌÍÎÏÐÑÒ×ØÙÜÝÞßàáâãäçèéêëìíîïð÷&"&,-.012456;<=DEFGHIJKLNOPQRSTUVW[R &.4:@FLÅÆÔÄÓÖÃÂÛÚæåòñôóöõùø $9:CMXYZ\2ÀÉÊËÌÍÎÏÐÑÒÔÖ×ØÙÚåñóõø"&,-.0124569:;<=CMXYZ\:ÛÜÝÞßàáâãäæçèéêëìíîïðòôö÷ùC\ ÅÄÃ$9: ÆÓÂ$9:¿Á½¾ ,latnÿÿkernÖ1lr|†š¬²¼ÊÐÞðú"8V\~„²¸Òàþ .<^djŒš°Þìò"8jxŠªÀÆÌXÿÿ:ÿá<ÿó9ÿÏ<ÿá9ÿã=ÿå0ÿã2ÿá-ÿ57 [ÿì:ÿå$ÿâ+ÿã9ÿ:ÿ<ÿMEÿö9ÿå:ÿå;ÿÙ$ -ÿEF X9ÿí:ÿí1ÿí:ÿç<ÿöQÿ…Uÿ‡Wÿ›Yÿ­[ÿ¥\ÿ™$ÿÛ2ÿß6ÿìQÿâUÿØ$ÿå2ÿéCÿñGÿÝKÿöQÿçWÿì%ÿÝ6ÿÝCÿŸGÿ‰KÿíQÿ‰RÿUÿ‹WÿŸ<ÿö DÿçEÿöNÿöOÿìPÿñTÿûUÿìXÿìYÿâZÿñ\ÿçFGÿçJÿñMÿìVÿçWÿì\ÿìGÿìQÿêWÿéEÿìGÿñNÿìTÿûXÿìYÿâZÿïÿKVW CÿñEÿñGÿñQÿìTÿñUÿëWÿçYÿìCH KCÿÝEÿñHÿÑPÿñRÿçSÿñXÿûZÿ×GÿìGÿûCÿöFGÿñOÿöQÿöXÿÅYÿ¿µÿ©MÿóOÿóYÿçDÿìEÿìQÿñRÿöZÿç CÿöNÿìPÿñQÿìTÿöUÿìVÿéWÿéXÿóYÿÝZÿÝFKU Wÿçÿ ÿìQÿûEÿíGÿñMÿñPÿéWÿìXÿìZÿÛ\ÿéDFJK\ DÿñEÿìF GÿñHÿöOÿìPRÿñUÿñVÿñZÿñ\ÿñGÿâQÿãUÿçGÿìQÿìTÿìUÿñGÿÏCÿéEÿìGÿìN PÿñQÿéCÿçGÿçNÿìVÿì\ÿìÅþ«Åþ—Âþ§Óþ­ ""$%'*.023 57 9=C\ÃÄ.ÆÆ0Çþ°ßÇ=<É#ægmongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/web/client/resources/fonts/Oswald/000077500000000000000000000000001321131462300335125ustar00rootroot00000000000000OFL.txt000077500000000000000000000106161321131462300346230ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/web/client/resources/fonts/OswaldCopyright (c) 2011-2012, Vernon Adams (vern@newtypography.co.uk), with Reserved Font Names 'Oswald' This Font Software is licensed under the SIL Open Font License, Version 1.1. This license is copied below, and is also available with a FAQ at: http://scripts.sil.org/OFL ----------------------------------------------------------- SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007 ----------------------------------------------------------- PREAMBLE The goals of the Open Font License (OFL) are to stimulate worldwide development of collaborative font projects, to support the font creation efforts of academic and linguistic communities, and to provide a free and open framework in which fonts may be shared and improved in partnership with others. The OFL allows the licensed fonts to be used, studied, modified and redistributed freely as long as they are not sold by themselves. The fonts, including any derivative works, can be bundled, embedded, redistributed and/or sold with any software provided that any reserved names are not used by derivative works. The fonts and derivatives, however, cannot be released under any other type of license. The requirement for fonts to remain under this license does not apply to any document created using the fonts or their derivatives. DEFINITIONS "Font Software" refers to the set of files released by the Copyright Holder(s) under this license and clearly marked as such. This may include source files, build scripts and documentation. "Reserved Font Name" refers to any names specified as such after the copyright statement(s). "Original Version" refers to the collection of Font Software components as distributed by the Copyright Holder(s). "Modified Version" refers to any derivative made by adding to, deleting, or substituting -- in part or in whole -- any of the components of the Original Version, by changing formats or by porting the Font Software to a new environment. "Author" refers to any designer, engineer, programmer, technical writer or other person who contributed to the Font Software. PERMISSION & CONDITIONS Permission is hereby granted, free of charge, to any person obtaining a copy of the Font Software, to use, study, copy, merge, embed, modify, redistribute, and sell modified and unmodified copies of the Font Software, subject to the following conditions: 1) Neither the Font Software nor any of its individual components, in Original or Modified Versions, may be sold by itself. 2) Original or Modified Versions of the Font Software may be bundled, redistributed and/or sold with any software, provided that each copy contains the above copyright notice and this license. These can be included either as stand-alone text files, human-readable headers or in the appropriate machine-readable metadata fields within text or binary files as long as those fields can be easily viewed by the user. 3) No Modified Version of the Font Software may use the Reserved Font Name(s) unless explicit written permission is granted by the corresponding Copyright Holder. This restriction only applies to the primary font name as presented to the users. 4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font Software shall not be used to promote, endorse or advertise any Modified Version, except to acknowledge the contribution(s) of the Copyright Holder(s) and the Author(s) or with their explicit written permission. 5) The Font Software, modified or unmodified, in part or in whole, must be distributed entirely under this license, and must not be distributed under any other license. The requirement for fonts to remain under this license does not apply to any document created using the Font Software. TERMINATION This license becomes null and void if any of the above conditions are not met. DISCLAIMER THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM OTHER DEALINGS IN THE FONT SOFTWARE. Oswald-Regular.ttf000077500000000000000000001434001321131462300370070ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/web/client/resources/fonts/Oswald FFTMe%Ú´üGDEF(ȵ(GPOS¦Ðëµ@œGSUB¸ô¸æÆÜ$OS/2š‰cÕ¨Vcmap®ÀÒ«Œncvt åÂè.fpgmä.„ ü bgasp´ôglyfroòË`–lheadÿV–Î,6hhea’ñd$hmtxv Œloca­€ÔþHmaxpà ˆ name×üöY¯Ìpost´Ô prepþ˜(`…{+|$_<õ Ì|„ÌÎaÿ-ýtë x Œý±œÿ‚ÿ££w}(6jž b3™3™×f o@Knewt@ û Œý± ŒO“ìDª w@À>@@ÀÏN@€€>€€€@€jÀ@˜L€€@@@`€@üGN?S\;p:-@;\·€€@@@À@@€€€ö€ z€S`m€]€5€¯`À€Œ€^€7€À€€€œ`€œ`T€NR~ÿÿär  .úÿý·>€@@€€@€€»Tu_3_¥^z8 àu€ûÿÖÁuåvàuàuº]uô\µulE¼6Ûrhbh2GÀ@€€À@À €@€i0‹^À`€€øFJl@€€øF€{€@€€@€€€Ûr¸€@@@@ƒc@—E±B G{P      €ÿ‚S`]€]€]€]€ÿÌŒÿÌÿÌ€"€€œ`œ`œ`œ`œ`@œ`ärärärärúÿý¸H€€»T»T»T»T»T»T¹a…3Ž^Ž^Ž^Ž^ÿÀ€ÿÀÿÀ€àuº]º]º]º]º]€€ÛrÛrÛrÛrJ €J »T »T »TS`…3S`…3S`…3S`…3m€_€" `]€Ž^]€¥^]€Ž^]€Ž^¯`È ¯`È ¯`È ¯`Í!À€àuÀÿÿÿ«ÿŸ3'ÿÌÿÀÿÌÿÀŒ€žŒû€€@ÿð^€ÁuÀ€7€ñv7€åv7€ñv7€ñv±1 €€àu€€àu€€àuœ`º]œ`º]œ`º]€€€T€¨uT€µuT€¨UNRlENRlENRlENRlE~ÿÿ¼6~ÿÿ’6ärÛrärÛrärÛrärÛrärÛrärÛr õúÿýJúÿý·>G·>G·>GÀ$€{€(_·€2€àv€{€Ûu$€Ÿ€L_¯`È  » »T] ¥ ]€Ž^ÿ9ÿ-ÿÌÿÀœ`º œ`º]TÿMµÿÂT€¨UärÛärÛrNRlE~ÿÿ¼6@@@@€@€@ÿÒÀ€Ú€@J%z€um€_5€z8À€àu€uNRlE~ÿÿ¼6 õ õ õúÿýJ€€}€€>€}€€À>RdRdÀÝF@A@@Ëœ˜À€À¢.‰.Ä.Rÿº$6¶..dHN@~He~’Ìõ7ÇÝ& AWak…ó    " : D t ¬!"""""+ûÿÿ  Lh’Äñ7ÆØ& @V`j€ò    9 D t ¬!"""""+ûÿÿÿãÿÂÿÀÿ½ÿ»ÿ¨ÿwÿSÿIÿ.þ þþ_þ^þJãoãiãWã7ã#ããâÿâ“átáqápáoáYáPá!àêàu߉߇߅ßp›   !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`a†‡‰‹“˜ž£¢¤¦¥§©«ª¬­¯®°±³µ´¶¸·¼»½¾rdei‘x¡pk—vjˆšsgw˜›l|¨ºcn:m}b‚…—‡ˆŒ‰Š¹Á3”–’“œy‹Ž„ŒƒŠ‘Ž•–”œ›ñflqhijzmkg°,° `f-°, d °ÀP°&Z°E[X!#!ŠX °PPX!°@Y °8PX!°8YY ° Ead°(PX!° E °0PX!°0Y °ÀPX f ŠŠa ° PX` ° PX!° ` °6PX!°6``YYY°+YY#°PXeYY-°, E °%ad °CPX°#B°#B!!Y°`-°,#!#! d±bB °#B² *! °C Š Š°+±0%ŠQX`PaRYX#Y! °@SX°+!°@Y#°PXeY-°,°#B°#B°#B°C°CQX°C+²C`B°eY-°,°C E °Ec°Eb`D-°,°C E °+#±%` EŠ#a d ° PX!°°0PX° °@YY#°PXeY°%#aDD-°,±E°aD-°,°` ° CJ°PX ° #BY° CJ°RX ° #BY-° , ¸b ¸cŠ#a° C` Š` ° #B#-° ,± CUX± C°aB° +Y°C°%B²C`B± %B± %B°# °%PX°C°%BŠŠ Š#a°*!#°a Š#a°*!°C°%B°%a°*!Y° CG° CG`°€b °Ec°Eb`±#D°C°>²C`B-° ,±ETX° #B `°aµ BBŠ`± +°i+"Y-° ,± +-° ,± +-°,± +-°,± +-°,± +-°,± +-°,± +-°,± +-°,± +-°,± +-°,°+±ETX° #B `°aµ BBŠ`± +°i+"Y-°,±+-°,±+-°,±+-°,±+-°,±+-°,±+-°,±+-°,±+-°,±+-° ,± +-°!, `°` C#°`C°%°%QX# <°`#°e!!Y-°",°!+°!*-°#, G °Ec°Eb`#a8# ŠUX G °Ec°Eb`#a8!Y-°$,±ETX°°#*°0"Y-°%,°+±ETX°°#*°0"Y-°&, 5°`-°',°Ec°Eb°+°Ec°Eb°+°´D>#8±&*-°(, < G °Ec°Eb`°Ca8-°),.<-°*, < G °Ec°Eb`°Ca°Cc8-°+,±% . G°#B°%IŠŠG#G#ab°#B²**-°,,°°%°%G#G#a°E+eŠ.# <Š8-°-,°°%°% .G#G#a °#B°E+ °`PX °@QX³  ³&YBB# ° C Š#G#G#a#F`°C°€b` °+ ŠŠa °C`d#°CadPX°Ca°C`Y°%°€ba# °&#Fa8#° CF°%° CG#G#a` °C°€b`# °+#°C`°+°%a°%°€b°&a °%`d#°%`dPX!#!Y# °&#Fa8Y-°.,° °& .G#G#a#<8-°/,° ° #B F#G°+#a8-°0,°°%°%G#G#a°TX. <#!°%°%G#G#a °%°%G#G#a°%°%I°%a°Ec#bc°Eb`#.# <Š8#!Y-°1,° ° C .G#G#a `° `f°€b# <Š8-°2,# .F°%FRX ,°+*-°5,°,+# .F°%FRX ºDÊ ,h¤8RÈf°Z²6fšâ†¢"ÒÒülÜ2v $L,  F z –!!6!f!ž""´"Ð# #6#R#”#¼$$@$¢%Z&b&è&ú' ''0'B'T'š'¬'¾'Ð'â'ô(((*(<(’(¤(¶(È(Ú(ì(þ))†)˜)ª)¼)Î)à**Œ*ž*°*Â*Ô*æ*ø,&,8,J,\,n,€,’,¤,¶,È-D-V-h-z-Œ-ž-°-ì.X.j.|.Ž. .²//*/ >>.>ž>°>Â>Ô>à>ì>ø????(?4?@?R?^?p?€?’?¤?¶?Æ?Ø?ê?ü@@ @2@D@T@f@x@Š@š@¬@¾@Ð@à@òAAA(A:ALAˆA¬AÐAøBBBB~CCDCnC¤CäCöDDD,D>DPDbDtD†D˜DªD¼DÎDàDòEEE(E:ELE^EpEŒE¨EÖFF@FŒFìG&GPG GÆGÞGöHHHHÀHìIII$IVIÌJ(JlJŒJ˜JìK6DdUµ$+3!%!!D þ$˜þhUú«DÍ@@+@(M ?M @ +!!€@.Ò€€ú€þ€ÿ>0#@ M @ +!!!Á@@þ=@@0Ðþ0Ðþ0@F@C  V   U ? @+37##537#53!3!3#3#!#µÁÀþoZZu‘¬RRÀRRTo‹¦ZÿZÀZ@Àü€ÀÀÀ@ýÀ@ýÀÀÀÀý€€ý€ÿ€@€ 19@6!0)(%$ >QO@11  +%654&''"5&'%%&&546353&''À€84€\d€@Ðã  ¡ÿXiöË€)<ÿ c€qаÆNr4Åóh[˜eûqã@þÛK+ÍGÓˆÆêny Vþ˜@¼QýÊfXùžµØqNî 4?K@H  WW W O  @65:85?6?,*"!   + ".54>2'2#"3".54>32'2#"q¾V*)UÂU)*V… 8ýÛþæþP¾V*(UaN|T8+V… 8M‰®hj«…II…«ji®‰w) þà4Zb9ÃîúMˆ®hj¬…I1VzTh¯ˆv)!þß4[a9€ÿîÀ HT@Q091>dO?P?O@ =<;:65(&HH % +6654&#"27'.'"&5%.54632>7!3".'!@_F:A?""zf{ ?. ,50>@M @ +!~@@0Ðþ0€ÿÀ@@#@K°PX@O?O@@WKOCYµ+".54>3"3@P‚[C) "A^[2I))I2@+[dŸÉƒjz•ã¥]?À?`’„T0§@ª1Tƒ`>@ÿÀ@#HK°PX@O?O@@WKOCY@ ##+52>54&4654.#52@2I))I2P‚[C) "A^@À?`’„T0§@ª1Tƒ`>À+[dŸÉƒjz•ã¥]?jˆV€@  ;] +'7%737W˜¬þÿ=õÀö=þÿ¬˜‰ˆZób¡„,þÔ„¡còZ@€€À +@(IUMA +5#53533#ÀÀÀÀÀ€ÀÀÀÀÀÀLÿLJK° PX@dYM @@deM @Y@ +'265#!Œ@E;€(Cÿ€d ? @+!#5673ÀÁ?À€ÀE{ùGÈ$2@/=dO?M @$$#-+3>54&#"!5432!GÁ6, c]7N)ÿØèÚæ?5/þ@€€ KE%D5G%k•6`k?@@üõÝS„VCýÀÿNÿîÎ0…µ+>K° PX@,\\WO?P@@.ddWO?P@Y@&$!  00 +"&55!2>54&#2654&#"!54632Úæ(HdH(w‰ŒtTl2H(ÿçÙÚæˆx}ƒØõÝ@V ? @  +!!!3#SþÀ@Æƾú@Ìû½òþ4\ÿîÜ5L@I(>dbWM ?P@+)'&%$#"  55 +"!32>45454.#"#!!632ïÌ%@,#9)  (;%DdÚýÐl”W…V7>d¡ (3KO1 0)H1Y11 +=G00X<ÆÿþN@5\ˆ˜]sº¬tEpÿîð9w@ .>K° PX@%\WO?O@@&dWO?O@Y@1/,*('%#99.+$2>544.#"".54>32!4&#"632ùnN) $0|D)…\–gG @deØèÿSmÀJ¶l™U&2h°À6`k?&'H'l—¯b@n»«xFõÝ€€þ€ÿ€K²t~Ѧ]-ú$@!>M ? @+3!5!¾Hþ'Íþº+Õ{ù{@ÿîÀ !9?@<4(>WO?O@#"/-"9#9   +2>5#"2>54.""467&&546322C  ¢ CdH((NrO))zìÕ\fVRÔÓÒÓQVe\Ô'.WX<ÿK° PX@&\WO?P@@'dWO?P@Y@.,$"99 +274.""&5!32#".54>32zF)NnN) $0ØèSmÀL´l™U&2h°v\–gG @d€€@j`66`k?&'H'l—¯býÀn»«xF€€@.@+UIMA +!!€ÿ@ÿýÀÿ@@@8@5dUU @  +!'265#!@À@E;€(C@ÿüÀ€K° PX@#\bWM @@$dbWM @Y@  +!!>54#"!54632€ÿ?]oE0ÀlTÿçÙÛæ˶ÿ€@&@cdˆKÀ@ÛåçÙÔþëWÿ€ÿ€v$Nj@g#L M >  d b  W  X  K O  CKIA?:8430.&$!NN +27&#" ! #"&'#"&&54>325!324.#"327tE/" ¾þNþt–jsƒ,X]`$9rj—G-DjCBI t4tÄŠÆ{>:‚á¡}«^ßö(“3&3;¿ýŠ»Åt°þYþƒe«‚JD<€p²oM‹…`;I?ýÈ&,$ ”Û£RZ¤Þˆ¬û»^7Ä3 *@'>V ? @  +!!!!€þ€€ÿ`þÀ`€ú€ùÀþ@€@ $4@1>WO ?O @$#"#!' +3 4.#326&##!2#€€@$I32!5.#"2>55!Lq¬nEEn¬q}¶m7ÿ/H0>Y2 3UrR/1m»@q©ÀyÿyÀ©p@J¾(95KP5-(?jeJý€@hgF+,DjdB@@‹Ò¡T€  &@#O ?O @  ! +3! !'32>5454.##€çëþé‹?Z8  '3D*ˆæþæý@þÙþçÀ=7tKO @1:O.9 # €@ .@+UM ?M @ +3!!!!!€Àþ@@þÀÀÀýÀÀý€À€@ (@%UM ? @ +3!!!!€Àþ@@þÀÀýÀÀüÀ`ÿî`3|´2=K°PX@'dUO?O@@+dUO? ?O@Y@10/.-,&$ 33 +".5!2!5.#"32>55!5!#'`{µrD }¸r:ÿ 2S9Nk9%7S6@^7 ÿÀ@KFxºÎ†Æ’KÁ%6?[X7!9mƒWýÀ@gkN?!2OzxM@¾ü‚ÀÒ€@ &@#U ? @ +3!!!!!€Àÿþ@ýù@üÀŒŒ@ ? @ +3!Œù@ ?O @ +152>5!#S]< U—tÀ;_T@úÀzŸt3€€ %@" > ? @ +3!!!€€@þÁþÀþÀ€ýý@ûÀ@ÿýÀ€@@ ?N @+3!!€ÀùÀÀ€@ &@# > ? @ +3!!!#€bþþbÿÿÀÿú¤\ù†úz†úz€ #@ > ? @ +33!#€ÀÀ¶þ6û¬Tù¨ûX`ÿî<'@$O?O@  +".54>3 $ 654& N‡Ár44rÁ‡è5rÁþógfþðfRžÕŠÒ›NþÔþäýv‹ÕŸSÒ¢ž œššœüöž€ (@%WO ? @  #"( +32>54.##! ##€@WoU%Kwb@ÿÀÀçÙÀ7fO`wLùÀþÛåüÀ`ÿ< %.@+">SO?O@)#+$ 654& "&'#".54>3 3ÇgfþðfÇm×1+9‡Ár44rÁ‡è×u0À¢ž œššœüöžýž˜]RžÕŠÒ›NþÔþäývþtƒ*5€@0@->UO ? @"# +326&##! ##€@    @ÿ@"rn þþþÀ‡2‡ùÀÞþþ Ø(ü€@üÀRÿî)/@,>O?O@ )) +"'%3254.'&&54632&'&&#"SòÿíÀ@4-þÀXiöËÚÿws\d€@óö@þ€À9aQ1$EÕˆÆêÕÃ%@"z“g\—fÿÏþàÅÞÿÿ @M ? @+!!5!!?þÀ€þÀääùärÿír@ ?O@+".5!2>5!çê²sH5aŠa5Hs>o¨Ã{€û€SpL22LpS€û€{èo   @> ? @+!!!Œþ€½BD½þ€ü@þ@ÀÀù  &@# > ? @+!!!!! KþÀ€A?€€?A€þÀÿ€@@€üÀþ@üÀþ@ù@þüÀ %@" > ? @ +3!!#>þÀþÀ<þþþ¡_ý@Àü¥ü[ýÿýý"@> ? @+!!!}þ€þ€@Àü€€û@ýÀ>~ ,@)=M ?M @ +35!5!!>@þýÀ@À€ÀÀú€À€ÿÀ€@'@$UIMA+!!!€ÿ@€€ù€€@@ ? @ +!!ÀÀù€ÿÀ€@'@$UIMA+5!!5!€ÿ@€€€ø€@€@@>f]+!!@ÿ€€ý€Àþ@À@M @ +15!ÀÀ€€@g @ +!€ÿ€€€þ€Tÿîu5£@">0=K° PX@\O?O@K°PX@ dO?O@@$dO? ?O@YY@/.)'%$ 55 +%266767"&54>76754&#"!6632#'Ô3J,>"k•?F¤Th 6JB9ÿÊ´³Í!ÿ"00HÀ b .3/D%ŸÒ¹t]˜[a$)\ak[P ¸ÚݵýÀÈxÀ(,A#uÿîµÿ-‹K°PX@>@>YK°PX@ ?O?O@@! ?O? ?O@Y@ --  +%2>54&4.#""&'!!>325)7 0"jVcNx:ÿ$$EJ-AfB. -EsÀ32!5."32>55!²]‰R23Q‰]Ê°ÿ 5L4  4%"1,Y“>d››gSTfœ›c>ÚÖ"$0HH'-TY:|ú7SM*&@7*!e›t=]ÿîžÿ,‹K°PX@%*>@%*>YK°PX@ ?O?O@@! ?O? ?O@Y@)('&!,, +%27&#"".'&7>32!!5Þ]cVj&4  4UE"0@Z7+KD)!ÿ:xÀ(%3%GK3àƒ@d]2Ò`¤±f/·BktYS6 1&#~ùt32!32>75335.#"Ü]‰Q24S‡ZR}S7 þ/ (4 þ ¸þÃþ 4&'5 @g¡¡kTTd›’^9+Wj—’_@ %OLE4>>/63ÍÒM3LL(*OL58xÀ`@ >K°!PX@O ?M? @@WM? @Y@$&+3#5354>32&&#"3#¸€€ %?iI>` >@*ÀÀ@À1Qqi?% ¾ QO`ÀûÀ þÊ !oîK°PX@DQY.>@DQY.>YK°PX@)dWO? P @K°$PX@3dWO?O? P @@0dW  TO?O@YY@%" cbXWOKJEA?"o%o !% + 4.#"2>54''26".5467&&54>7&54663267:3"#"#'*@"B./B!à+8)%ÍÓ'7+->,; 0d ?? @#$+3!>32!4&#"u9HHRfÿ!7NZýv471xWû½ÀB>Kü €€ÀKK°!PX@M ?? @@U? @Y@ +!!€ÿÀÿú@ûÿÖþÀ–À‚@ >K°PX@M ??P@K°!PX@TM ?@@UT@YY@  +!"'5325!–þÀT,#€«Àÿù¶•ëúù”¥uµ )@& > ?? @ +3!!!u@þáÿÀ€ü'ÙþAü¿k«þ@vv@ ? @ +3!vùuu3[@ 2%>K°PX@O? @@?O? @Y@33('$" +3!6326632!454.#"!4544.#"u‰¶\V?’o 3& ÿ 'N+ ÿ ^b‘£QXSV %:&J** ü]¦ !$/ü¡ -QüuuV@ >K°PX@d? @@d?? @Y@ #$+3!>32!4&#"u9HHRfÿ&:!A Š471xWû½ÀC=ü ]ÿî] +@O?O@+ &546 2>54."«þd²²œ²þe6)  )6)  ðâ€âððâþ€â-"@%%€%%@"--"@%%þ€%%@"-uþ€µ4¦@3>K°PX@ d?P?@K°PX@$d??P?@@$d?P?M@YY@4420#!  +%2>5'4.#"!>32#"'5)7  1 Xþ¨;+C$AfB. -EsJ‚~À@4>YK°PX@ d?P?@K°PX@$d??P?@@$d?P?M@YY@77650.#!  +%27.#"#".554>325!Üe[  1   5æ9yNJsE-*ErK+KE'"À4 (J9_4/LFCea5ýÀó;JKv¡œTÃWŒa;2%$€ù€uµhK°PX@ ><@ >YK°PX@O? @@?O? @Y@ ##+3!6632&#"u'•[&GGPb«Lqþå`Oü EÿîE,0@->O?O@ ,, +"&'732654'%.54632.#"Åž¿#ÀE{=C@ÿ+:<ѯS†[;À/@'=C@+=:Ѽ–@ÀC=Y;À3J\6¤®5`uH@&7@#C=<0À"?Sf:¤®6ÿîvÀh@ >K°!PX@ ?M?P@@fM?P@Y@  +"&'#53!3#327Ø—‰€€ÀÀ*@:`šœÀÀþ@ÀýMH Ð rÿîrmK°PX@ >@ >YK°PX@d?@@d? ?@Y@  +"&5!32>7!!5,Tf1'(')ÿ&#H7RwXCü (2 $õûŠ!3T @>? @+!334þàö²¢öþâü?Áûí &@# >? @ +!333#í㎆ꈌäø숊ü4Ìü>ÂûrüŽQ '@$ >? @ +3533!ÿ÷««óÿÿ˜¨€fþéýšý€íþþÀTB¶ >K°PX@?P@@T@Y@ +52>5!67!#TL[. þÞ• 5CþÀ θþÀÀ3=6ÆüÉI‡+ieúÀ‹uG ,@)=M?M @ +35!5!!GÀþ€€þ@ÀÀ€ÀÀü€À@ÿÀ€@8[µ+>K°PX@WO?O@@ WWKOCY@ 87+".546.#2>&54>3"3€„²b( "& +k§ƒ':)À_a(>(@JšÊ’ ;2$ ! ;(I'Oƒ§k+À ""=7.þZZ)Å’88_1@ €ÿ€@€@IMA +3€À€ø@ÿÀ€@<eµ>K°PX@WO?O@@!WWKOCY@<<.-,+ +52>4545467&4.#523"@0$ a_À '0­¿T &* )"7*>dbIMA8810&%!  +%5.554>753%4&'>5!ß#  $X~L-/M|UN²¢ÿ 4!­¨Îa '=4Z3kbK° PX@'\UO?M  @@(dUO?M  @Y@&&$( +157#5354>32#4.#"!!!€€€!:PsI¥™À6*!0ÿÀ€?AÀÀS~hd?&дN5LS,#2P>+þŽÀýÀÀié—"9@6" >< ;SO@#+264&#"'7&547'76 7' '¥¶ee[\d}ZV??VZVa aVZW@@WZVaþôaªvÀvuÀþÈZV`ˆ…aVZV??VZWbƒ„dVZV??0Î=@: >V  U ?  @ +!#535#53!!3#3#€ÀÀÀ•þÛÌÊþÙ™ÀÀÀ¨¦1üP°ûϦ¨ÿ^ÿò)î)@&UM @ +33^ËËËyuý‹üytýŒ`ÿï` I3@0D21$>O?O@86-+II +654.'".'732654&'%.5467.54632.#"`/A`&@R†[<ÀE{=C#ÿ3 #4.#"32>53ü–þýµh°>È–µh±þÂþ¡0ð‚L‡Äs™ñ€‚Œ:[=+  $@nM·)%  $#.³n¾–ÊF»n¾þ÷–Éþº»“—œuЗX—ÿ›þÿC-NLs^EW|{L/þ¬):@! +":%B$@,=+2!$E>.œ½lÿö¦_ (kK°0PX@ &>@ &>YK° PX@\WO @K° PX@\WO@K° PX@\WO @K°PX@\WO@K°PX@\WO @K°PX@\WO@K°0PX@dWO@@"dW ?O@YYYYYYY@ %$ ( (   +%2675"&54>76754#"#6632#5v$<_:%'Sn5KW LZ²Ž€Oj9±k,½3/9'-šnSDcF^‹—†¡-]vVý÷o5D@@ÀÀ µ $+%5 5Àþ@Àÿþ@þ@Àÿ@€þÀÿþÿþÀ€þÀÿþÿ€€€EK°PX@[IMA@gIMAY@ +5!5!þ€ÀÀþ€€À€€@IMA +5!€ÀÀÀFÿò²‡!*6U@R1> dWWUO @+++6+65432.,*($"  +"$&54$32$ 654.#"32654&##3 ##ü–þýµh°>È–µh±þÂþ¡0ð‚L‡Äs™ñ€‚,!]D9BGœð}”¨Rn¾–ÊF»n¾þ÷–Éþº»“—œuЗX—ÿ›þÿ½GaKMüß—þî›DþZþ{-@IMA +5!{²˜˜€€ @SO@#+ &546 264&#"´þ˜ÌÌhÌþ%¶ee[\dγ²ÍͲ³$vÀvuÀ€ÀÀ;@8U UM @  +35!5#53533#€@þ€ÀÀÀÀÀÀÀ€ÀÀÀÀÀÀ@@@À#a´=K°PX@ \WIMA@!dWIMAY@ ##+5>54."#462!@À)!  À…ö…KXƒ@@€ 54&5$ $y‡‡yG›j‘#€€€€2ÛK° PX@;\ \  Z\WWKPDK°PX@=\  d  b\WWKPD@?d  d  bdWWKPDYY@ /. +"&532>54춮."#462ûö…À 8HI7 À…ö…gYZf€†z$ $G9€8H$ $y‡‡y[b^\y€€@g @ +!€€ÿ€€þ€rÿr,@) >O ?M@"+32>7!!5!r1'(')ÿ$ycÿ (2 $õûŠ?Jüý€ @W @ $+!"&5463!##~¤ÊÖÁÙ²‹l¬œ©£úlü”@Â@Â@IMA +!@Âÿ@þ*@'>fKPDA+5232654.'53#@IDP,,€/EZ2#98RA.þ€' À€ .B)&;( @€€,@)>dIMA+#5673À€¨X@€@€Smü€cÿò  5*@'WO@'%55   +"&54632'2>4554544.#"½¢¢½´ªª¹!  #* .ØÐ?ÐØâÆþÁÆâÈ -7í5* ,%?,%í+3G))@@ÀÀ µ $+%%%ÿÀü€ÿÀ@@ÿ@þ€þ@ÿ@þ€EÿÿU _@\  >=  d  UV ?M   @  +3!533#%!#5673•€þÀT¬€€ûÄ?ýÀþ,€¨X@ý€€@ýÀ€ÿùè@€Smü€Bj#'/Û@ +>=K°PX@2d\I W ?M   @K°PX@3d \ W   U ?M   @@4d  d W   U ?M   @YY@(($$(/(/.-*)$'$'&%## +%5>54."#462!!#5673jÀ)!  À…ö…KXƒ@ûH?ýÀþ€¨X@€ 54&5$ $y‡‡yG›j‘#€ùè@€Smü€GË DI@ >=K° PX@R \  \ Z  \  W  XV ? O ?M @K°PX@T \  d  b  \  W  XV ? O ?M @@V  d  d  b  d  W  XV ? O ?M @YY@)A@@?;:8710('&%  +3!533#!"&532>54춮."#462 €þÀT¬€€û¼?ýÀþ»ö…À 8HI7 À…ö…gYZf‚ý€€@ýÀ€ÿùü†z$ $G9€8H$ $y‡‡y[b^\yPÿû1"£¶>K° PX@%dZM?P @K°PX@&dbM?P @@$dbUP @YY@"" +53 4>75332>53W݆þ¢8L'Ø V3A!p*: Û·Rßßû©_)VAU,S'ÙþóeDed/~#@I/º×ÿÿø&$CPø ±¸ø°'+ÿÿø&$vPø ±¸ø°'+ÿÿø&$fø ±¸ø°'+ÿÿ&$l0Ì ±¸Ì°'+ÿÿx&$jPx ±¸x°'+ÿÿ A&$jÐÁ ±¸Á°'+ÿ‚@@@=>UUM ?M  @ +3!!!!!!!‰÷ýüÂþ@@þÀÀý@þÀ¿€’úîÀýÀÀý€ÀÀþ@ÿÿ`ýÿ)&&z„ÿÿ ±¸ÿÿ°'+ÿÿ€@ø&(C ø ±¸ø°'+ÿÿ€@ø&(v ø ±¸ø°'+ÿÿ€@ø&(f`ø ±¸ø°'+ÿÿ€@x&(j x ±¸x°'+ÿÿÿÌŒø&,CÿLø ±¸ø°'+ÿÿŒLø&,vLø ±¸ø°'+ÿÿÿÌLø&,fÿŒø ±¸ø°'+ÿÿÿÌLx&,jÿLx ±¸x°'+" (6@3UO ?O @('&%$" ! +3#53! !'32>5454.##3#€^^€çëþé~€?Z8  '3D*{T˜æþæý@þÙþçÀ=7tKO @1:O.9 # ý¬˜ÿÿ€&1l`Ì ±¸Ì°'+ÿÿ`ÿî<ø&2CŽø ±¸ø°'+ÿÿ`ÿî<ø&2vŽø ±¸ø°'+ÿÿ`ÿî<ø&2fÎø ±¸ø°'+ÿÿ`ÿî<&2lnÌ ±¸Ì°'+ÿÿ`ÿî<x&2jŽx ±¸x°'+@@ÀÀ ³$+'7'77'À€ÀÀ€ÀÀ€ÀÀ€À@€ÀÀ€ÀÀ€ÀÀ€À`ÿd<˜+D@A! +> <;O?O@*(  +%2654''&#"'7&4>327#"'N‡gþ°1}P4Qˆf Z-ß4rÁ‡nO*].Ø5rÁ†hOÀ¢ž CûmöšœüöŠýî«~—ŠÒ›NŸ®þwýv‹ÕŸSÿÿrÿírø&8C²ø ±¸ø°'+ÿÿrÿírø&8v²ø ±¸ø°'+ÿÿrÿírø&8fòø ±¸ø°'+ÿÿrÿírx&8j²x ±¸x°'+ÿÿÿýýø&<v=ø ±¸ø°'+H£,@)WW ? @  $!$ +32654&##332##D-›‘Müü´ØÓííƒEƒ°¤ˆû\þƒþíúþøþþþ”€ÿî*eµ%>K°PX@WO?O @@#WO? ?O@Y@**#(+52>544>54.#"!4632Oe88P, "D41A! ÿÅ»ßálo„—úÒ%UpVŸÔ6_k@@8)I  d>YK° PX@1\  \ WO? P @K°PX@2\  d WO? P @K°)PX@3d  d WO? P @@=d  d WO?O? P @YYY@ ca_^TRHF<:6421.,hh'+3>54&#"27&'"&54>754&#"!6632663232>54453#"'`u(,'>B) þTW'8MQ*k•0RMuZC6J2;ÿ˳_‰&X±¹**>6M:V/ &ÿ¯ÅàS 6Ogü 3)Oi9-L*'ýÀcŽ“4P5ŸÒ¹tAnOC+(«ak:T>¸ÚPHCUâÀ'@/% +%PNE5-#?$"äîÅ.=<ÿÿ0ýÿ2&Fzÿÿ ±¸ÿÿ°'+ÿÿ[ÿî^ø&HCø ±¸ÿø°'+ÿÿ[ÿî^ø&Hvÿø ±¸ÿø°'+ÿÿ[ÿî^ø&Hf]ø ±¸ÿø°'+ÿÿ[ÿî^x&Hjÿx ±¸ÿx°'+ÿÿÿÀ€ø&ñCÿ@ÿø ±¸ÿø°'+ÿÿ€@ø&ñv@ø ±¸ÿø°'+ÿÿÿÀ@ø&ñf€ø ±¸ÿø°'+ÿÿÿÀ@x&ñjÿ@ÿx ±¸ÿx°'+ÿî@8R@O/.10'&%$">O?O?O@,+*) 88  +%2>5&#"".54>324'5%&47@7N)KuÀ (E.j b<6T‰XZEþE@HµƒòJ`äœ\5i°À6`k?Ònþ€IPQY*ÒDs¬ºue²°}NR@Áef€J ÒXo5€$½þ¡þ€|Ó¥^ÿÿuu&QlÌ ±¸ÿÌ°'+ÿÿ]ÿî]ø&RCø ±¸ÿø°'+ÿÿ]ÿî]ø&Rvÿø ±¸ÿø°'+ÿÿ]ÿî]ø&Rf]ø ±¸ÿø°'+ÿÿ]ÿî]&RlýÌ ±¸ÿÌ°'+ÿÿ]ÿî]x&Rjÿx ±¸ÿx°'+é€o ?@<UUIMA   +!5!!Àþ@€þ@oÿþÑÀÀþ©ÿ€ÿ"€Ó /B@?'$/>&%<;O?O@ .,#!  " +&#"2>5'7&4>327#"'€îR) €) Ñ!ÀLT˜(X—ikXRW\p²Î^@ZI-"@%%ý€-"@%%cý¹þbïb3€n¦}A(éþÿpþûþ€âðÿÿrÿîrø&XC2ø ±¸ÿø°'+ÿÿrÿîrø&Xv2ÿø ±¸ÿø°'+ÿÿrÿîrø&Xfrø ±¸ÿø°'+ÿÿrÿîrx&Xj2ÿx ±¸ÿx°'+ÿÿþÀTø&\vêÿø ±¸ÿø°'+€þfÀÿ+I@F*>O?O?M @++(&  +%2>54.#"!>32#"&'@)7 0"jVcþ$$EJ-AfB. +EuKNx:À32!5.#"2>55!Äxq¬nEEn¬q}¶m7ÿ/H0>Y2 3UrR/1m»xÿøv@q©ÀyÿyÀ©p@J¾(95KP5-(?jeJý€@hgF+,DjdB@@‹Ò¡T0ÿî2x5‚K° PX@-\bUO?O @@.dbUO?O @Y@0/)'55 +!".'&7>32!5."32>55!]«]‰R23Q‰]Ê°ÿ 5L4  4%"1,Y“xÿúv>d››gSTfœ›c>ÚÖ"$0HH'-TY:|ú7SM*&@7*!e›t=ÿÿ`ÿî)ø&&gÄø ±¸ø°'+ÿÿ0ÿî2ø&Fg]ø ±¸ÿø°'+ÿÿ€ ø&'gÆø ±¸ø°'+ÿÿ]ÿî6ÿ&Gêÿ ±¸ÿ°'+ÿÿ"’`ÿî ÿ=­K°PX@.;>@.; >YK°PX@*dU ?? P @@.dU ?? ? P @Y@:9876543210/*(== +%27&#"".5454>32!5!5!3#!5à]cVj'  ('JsF, .BfB+KD)!þü€€ÿ:xÀ(%3 #7,E,HT=XAJ4-ÒKv¢œT`d°aA01&#[Š™™Šú$t55!5!#'à€{µrD }¸r:ÿ 2S9Nk9%7S6@^7 ÿÀ@KxÿøvFxºÎ†Æ’KÁ%6?[X7!9mƒWýÀ@gkN?!2OzxM@¾ü‚ÀÒ þÊx%sK°PX@HU] 2 >@HU] 2 >YK°PX@2  d U  WO? P @K°$PX@<  d U  WO?O? P @@9  d U  W  TO?O@YY@#)&gf\[SONIEC&s)s%"  +! 4.#"2>54''26".5467&&54>7&54663267:3"#"#'rþ¸@"B./B!à+8)%ÍÓ'7+->,; 0@W\ A* >YK° PX@6Zf V   W O ?O@K°PX@5ff V   W O ?O@K°$PX@?ff V   WO ? O ?O@@<ff V   WSO ? O  @YYY@#85  edca[ZYXTR5v8v4 1  %+ 4.#"4&&>3"32>54'&''26".5467&&54>7&54663263"#"'#A@"B./B!2 )<&@E;€R+8)%»Ó'7+->,; 0 >dU ??  @#$ +3#535!3#>32!4&#"€§§9HHRfÿ!7NZª˜¾¾˜þÌ471xWû½ÀB>Kü ÿÿÿ«m&,lÿ,Ì ±¸Ì°'+ÿÿÿŸa&ñlÿ ÿÌ ±¸ÿÌ°'+ÿÿ3å&,qÿ¸ù ±¸ù°'+ÿÿ'Ù&ñq¬ù ±¸ÿù°'+ÿÿÿÌLø&,hÿŒø ±¸ø°'+ÿÿÿÀ@ø&ñh€ø ±¸ÿø°'+ÿÿÿÌþŒ&,kú±°°'+ÿÿÿÀþ€À&Lkî±°°'+ŒŒx)@&U ? @ +!!Œÿxÿøˆù€€@? @ +3!€ûÿÿŒ'-,ÿÿ€þÀ–À'MLÿÿšø&-fÿÚø ±¸ø°'+ÿÿÿðþÀpø&ef°ø ±¸ÿø°'+ÿÿ€ý†€'pÛÿÕ. ±¸ÿÕ°'+ÿÿuý†µ'ppÿÕN ±¸ÿÕ°'+€À %@" >? @ +3!!!€@þáÿÊvýàþüçkµþJÿÿ€@ø&/v ø ±¸ø°'+ÿÿv:æ&Ov:æ ±¸æ°'+ÿÿ€ý†@'p;ÿÕ/ ±¸ÿÕ°'+ÿÿvý†v&pQÕO ±¸ÿÕ°'+ÿÿ€Ù&/ ±¸°'+ÿÿv&OÇ ±¸°'+ÿÿ€X'&/yî ±¸°'+ÿÿv9&Oyù1q +@( > ?N @ +357!%!±€€ þöÀZGÎGØý·”Δü×À , %@" > ? @  +357!7Ž‚‚žžˆ<À<¸þ½IÃFûÿÿ€ø&1v€ø ±¸ø°'+ÿÿuuø&Qv5ÿø ±¸ÿø°'+ÿÿ€ý†'p›ÿÕ1 ±¸ÿÕ°'+ÿÿuý†u'pPÿÕQ ±¸ÿÕ°'+ÿÿ€ø&1gÀø ±¸ø°'+ÿÿuuø&Qguø ±¸ÿø°'+ÿÿ`ÿî<&2qúù ±¸ù°'+ÿÿ]ÿî]&Rq‰ÿù ±¸ÿù°'+ÿÿ`ÿî<ø&2hÎø ±¸ø°'+ÿÿ]ÿî]ø&Rh]ø ±¸ÿø°'+ÿÿ`ÿî<ø&2m¡ø ±¸ø°'+ÿÿ]ÿî°ø&Rm0ø ±¸ÿø°'+€ÿî@ "K°PX@ !>@ ! >YK°PX@"UO?O @@6UO?M ? M ?O @Y@  ""% +$ 65&&#" !25!!!!!!5÷wx†‰wþ°PÀþ@@þÀÀý@LÀ¦š“Ÿ¦šýšþˆR€R’€ÀýÀÀý€À€’€ÿî€5c…@ ?b>K° PX@)  \ UO?P @@*  d UO?P @Y@76a_]\USJIB@><6c7c) +!454.#"2>54.""&54632632!32>45!#"'€ *& þe6)  )6)  Dβ²Î°PJ·Q}S7 þ/ * µË´LL&*L+9 !7'D$!ý½-"@%%€%%@"--"@%%þ€%%@"-âðâ€âð’’+Wk—’^@ %OLE4.D"'æì’’ÿÿ€@ø&5v ø ±¸ø°'+ÿÿuÕø&UvÕÿø ±¸ÿø°'+ÿÿ€ý†@'p»ÿÕ5 ±¸ÿÕ°'+ÿÿuý†µ&pPÕU ±¸ÿÕ°'+ÿÿ€@ø&5gàø ±¸ø°'+ÿÿUÕø&Ugø ±¸ÿø°'+ÿÿRÿîø&6vrø ±¸ø°'+ÿÿEÿîEø&Vvÿø ±¸ÿø°'+ÿÿRÿîø&6f²ø ±¸ø°'+ÿÿEÿîEø&VfPø ±¸ÿø°'+ÿÿRýÿ&6zrÿÿ ±¸ÿÿ°'+ÿÿEýÿE&Vzÿÿ ±¸ÿÿ°'+ÿÿRÿîø&6g²ø ±¸ø°'+ÿÿEÿîEø&VgPø ±¸ÿø°'+ÿÿÿÿþ'zÿ7±°°'+ÿÿ6ýÿ–À'z–ÿÿW ±¸ÿÿ°'+ÿÿÿÿø&7g?ø ±¸ø°'+ÿÿ6ÿîÀ&W¶À ±¸À°'+ÿÿrÿír&8l’Ì ±¸Ì°'+ÿÿrÿîr&XlÌ ±¸ÿÌ°'+ÿÿrÿír&8qù ±¸ù°'+ÿÿrÿîr&Xqžÿù ±¸ÿù°'+ÿÿrÿírø&8hòø ±¸ø°'+ÿÿrÿîrø&Xhrø ±¸ÿø°'+ÿÿrÿír x&8j2ø ±¸ø°'+ÿÿrÿîrx&Xj²ÿø ±¸ÿø°'+ÿÿrÿírø&8mÅø ±¸ø°'+ÿÿrÿîÅø&XmEø ±¸ÿø°'+ÿÿrýôr&8k`ÿõ ±¸ÿõ°'+ÿÿrýör&Xk©ÿ÷ ±¸ÿ÷°'+ÿÿ  ø&:f‹ø ±¸ø°'+ÿÿíø&Zfúÿø ±¸ÿø°'+ÿÿÿýýø&<f}ø ±¸ø°'+ÿÿþÀTø&\f*ø ±¸ÿø°'+ÿÿÿýýx&<j=x ±¸x°'+ÿÿ>~ø&=vø ±¸ø°'+ÿÿGø&]vÉÿø ±¸ÿø°'+>~x ?@< =UM ?M @   +!5!5!!^ýà@þýÀ@xÿøˆÀ€ÀÀú€ÀGx ?@< =UM?M @   +!5!5!! þ>Àþ€€þ@ÀxÿúˆÀ€ÀÀü€Àÿÿ>~ø&=g^ø ±¸ø°'+ÿÿGø&]g ø ±¸ÿø°'+ÿ€À&t@>K°!PX@SO ?M@@WSM@Y@  && +"'53265#5354>32&&#"3#ž>`<@*ˆˆ %@gI>` >@*¸¸ $@hÿ ¾ QOàÀ@Nod<# ¾ QO`Àü@Ood<"ÿÿ€ëø'8m' ±¸ø°'+ÿÿ€t'9m' ±¸ÿø°'+ÿÿ]ÿî!ÿ'9G ±¸ÿø°'+ÿÿ€7'-7/ÿÿ€þÀÍ'M7/ÿÿvþÀ{'MåOÿÿ€€'-€1ÿÿ€þÀ'M€1ÿÿuþÀvÀ'MàQÿÿ€ë'=m'ÿÿ€t']m'ÿÿ]ÿî!ÿ']Gÿÿ`ÿî` 'v* ±¸°'+ÿÿ þÊ'v¤Jÿÿ 'n5 $ ±¸ °'+ÿÿÿîu &nù D±° °'+ÿÿø'oÃø$ ±¸ø°'+ÿÿTÿîuø&opøD ±¸ÿø°'+ÿÿ @ 'n ( ±¸ °'+ÿÿ ÿî^ &n H±° °'+ÿÿ€@ø'o`ø( ±¸ø°'+ÿÿ[ÿî^ø&o`øH ±¸ÿø°'+ÿÿÿ9ß 'nÿ1 , ±¸ °'+ÿÿÿ-Ó 'nÿ% ñ±° °'+ÿÿÿÌLø'oÿŒø, ±¸ø°'+ÿÿÿÀ@ø&o€øñ ±¸ÿø°'+ÿÿ`ÿî< 'ns 2 ±¸ °'+ÿÿ ÿî] &n R±° °'+ÿÿ`ÿî<ø'oàø2 ±¸ø°'+ÿÿ]ÿî]ø&o`øR ±¸ÿø°'+ÿÿÿM@ 'nÿE 5 ±¸ °'+ÿÿÿµ &nº U±° °'+ÿÿ€@ø&5oàø ±¸ø°'+ÿÿUÕø&Uoø ±¸ÿø°'+ÿÿrÿír 'n— 8 ±¸ °'+ÿÿÿîr &n X±° °'+ÿÿrÿírø&8oòø ±¸ø°'+ÿÿrÿîrø&Xorø ±¸ÿø°'+ÿÿRýt'p®ÿÃ6 ±¸ÿð'+ÿÿEýtE'p ÿÃV ±¸ÿð'+ÿÿÿÿý†'pÿÕ7 ±¸ÿÕ°'+ÿÿ6ýtvÀ'p3ÿÃW ±¸ÿð'+þÀÀ E@ >K°PX@?P@@T@Y@     +"'5325!€T,#€«þÀ¶•ëúù”¥@€À @>g @+!#@ÀÀÀ€€€€þ€ÿ@€À @>g @+33ÀÀ€€ÀÀ€€ÿþ€@€À @T @    +"&532653€³À1ž1À‹€ºÆfZ[eȸ@¦@¦@IMA +!@¦ÿ@€@€!@WKOC+"&462264&"µê‹‹ê‹þÄxDDxD€ŒèŒŒè EvEDxÿÒýÿ’ )@&fKPD  +".546733263e/;O1<%& ¢^€^,0Oýÿ%2lÃr>f(J€¬AÑùK°PX@TO @K°PX@\TO @K°!PX@\T ?O @K°%PX@!\\TO @K°&PX@"d\TO @@#ddTO @YYYYY@  +"&&#"#46323253e0e^)0šsi:®13šs¬,+CtVEuŸÚ€€#@ M @ +!!3€ÿþZXΦ€€þ€€þ€€®#@ M @ +3!!.¦ÎXþZÿ€€€þ€€þ€@€À >K°PX@[O @@gO @Y@ "+4632#4&"@‹µ³À1ž1€È¸ºÆfZ[e%ý±%ÿ±JK° PX@dYM@@deM@Y@ +'265#!e@E;€(Cý±€3"3€*H2@E;€ ;UY7#€þ¿>?4K°!PX@ M@@IMAY@  +!~@@þ¿€þ€}5@2d R @ +4&54>3"3!4&54>3"3*H2@E;€ý€*H2@E;€ ;UY7#€þÀ@CK°PX@M@@IMAY@ +!!!Á@@þ=@@þÀ€þ€€þ€dï &@#UM @ +!#5333#,ÈÈúÉÉÞÈZþ¦Èü"dïaK°"PX@" UM? M  @@ U U M  @Y@ +!#53#5333#3#,ÈÈÈÈúÉÉÉÉôÈ^ÈþâÈþ¢Èþ ÝSï£ @KOC   +"&54632æ{Ž|{ŽS§‚¦§‚¦@@À³$+%5þ@Àÿ@€þÀÿþÿ@@À³$+7%@ÿÀ@@ÿ@þ€m@f] +3Ûþæîú@@À 6@3>=IUMA  +3!533#€þÀT¬€€Àý€€@ýÀ€ÿÿå?O@Ld  dW U   U O@;:53-,+*)(!%+".'#535#53>32##"3#3#32>53M¾’^=DDDF;\^r£^,ú¡) ÄÄÄ %9&+>!÷;]4[‰œc¦™¦cœ]6J·x##2 ;"!¦™¦0`R6f¤’c˜®œîµ $+#5!#!33##;£ñ¤òhkò ‰g‰®¦ššýZ@þ;ÅüÀ+ýÕ+ýÕ€@³$+3!!!€Àÿþ@ù@ùÀ$$+5!î$——m³$+3Ûþæîúÿ€À³$+"'532654>32&&#"ž>`<@* %@gI>` >@* $@hÿ ¾ QOàNod<# ¾ QOû Ood<"."À†@ >K°!PX@+O ? O ?M?  @@$K UM?  @Y@ +!#5354>32&&#"!!!"üŒ€€ %?iI>` >@*tÿþŒÀÿú@@À1Qqi?% ¾ QO`û@ûÀ.Àc@ >K°PX@O ?M? @@WM? @Y@"6 +3#5354>32!&#"3#®€€ %?iImÂ’ÿœ^@*ÀÀ@À1Qqi?% ùoòQO`ÀûÀ.ÆÀ/³ $+3#5354>32&&#"!54>32&&#"3#!!®€€ %?iI>` >@*X %?iI>` >@*ÀÀÿþ¨@À1Qqi?% ¾ QO`1Qqi?% ¾ QO`ÀûÀ@ûÀÿº ® ³$+%!ݨþ5<²¼<þ3ªþ+R ýâþ£ýâGÿÿ6ÿîÀ'W’W.6À5µ$+!#5354>32&&#"!54>32&&#"!!!!!6úx€€ %?iI>` >@*2 %?iI>` >@*VÿþªÿþÎÀÿú@@À1Qqi?% ¾ QO`1Qqi?% ¾ QO`û@ûÀ@ûÀ.À2³ $+3#5354>32&&#"!54>32!&#"3#!!®€€ %?iI>` >@* %?iIiº}ŒÿŽV@*ÀÀÿþæ@À1Qqi?% ¾ QO`1Qqi?% ùoòQO`ÀûÀ@ûÀn;;A"HjNxÆ&Ô ú ú ;  j v3  © µ Dà  œ# ¿ LÛ ' ' v3 &? &? 4e Copyright (c) 2011-12 by vernon adams. All rights reserved.OswaldRegularvernonadams: Oswald Light: 2011-12Oswald RegularVersion 2.002; ttfautohint (v0.92.18-e454-dirty) -l 8 -r 50 -G 200 -x 0 -w "g"Oswald-RegularOswald is a trademark of vernon adams.vernon adamsnewtypography.co.ukhttp://scripts.sil.org/OFLCopyright (c) 2011-12 by vernon adams. All rights reserved.OswaldRegularvernonadams: Oswald Light: 2011-12Oswald RegularVersion 2.002; ttfautohint (v0.92.18-e454-dirty) -l 8 -r 50 -G 200 -x 0 -w "g"Oswald-RegularOswald is a trademark of vernon adams.vernon adamsnewtypography.co.ukhttp://scripts.sil.org/OFLÿÿÌ=¢ÏÌWïÄÌ|F ¢ $2DFLTlatnÿÿkern V¤M*B Œú(~Ì8ÖâàìúNx† ÆÌÒØ******    ââââââì@@@@ØØ**â*âììììö @ @NNNpžžäî f8*8BM$'()-./379DEFGHIJKSUYZ[\‚ƒ„…†‡Š‹Œ¢£¤¥¦§©ª«¬­¿ÁÂÄÅÆÇÉËÍÏÐÑØÙÚÛÝßáôùý !KcŠÿØÿØ$ÿà9ÿÝ:ÿì<ÿë‚ÿàƒÿà„ÿà…ÿà†ÿà‡ÿàŸÿëÂÿàÄÿàÆÿà3ÿëKÿàÿˆÿˆJÿÀUÿØVÿÕ©ÿÀ´ÿ‡µÿ‡¶ÿ‡·ÿ‡¸ÿ‡ÉÿÀËÿÀÍÿÀÏÿÀÛÿ­ÝÿÀßÿÀáÿÀÿ‡ÿØÿØÿÀÿÀÿÀÿÀXÿ‡ ´ÿöµÿö¶ÿö·ÿö¸ÿöÛÿûÿö(*,XÿöFÿÀJÿÀVÿÀ©ÿÀÉÿÀËÿÀÍÿÀÏÿÀÛÿ¶ÝÿÀßÿÀáÿÀ ÿ˜ÿ¶ÿÀÿÀÿÀÿÀ(ÿÌ*ÿÌ,ÿÌJÿàVÿàËÿàÍÿàÛÿàÝÿàßÿàáÿàÿàÿàÿàÿàÿà!ÿ'ÿÐ)ÿÐ+ÿЊÿ`ÿtFÿ¼¶ÿ±¶ÿŠÉÿ€MÿØYÿØ\ÿØ¿ÿØÁÿØõÿØMÿÜõÿÜÿÎÿØIÿÐRÿú®ÿõ¯ÿõ°ÿõ±ÿõ´ÿöµÿö¶ÿö·ÿö¸ÿöÛÿïúÿúþÿúÿöXÿö JÿòRÿù´ÿñµÿñ¶ÿñ·ÿñ¸ÿñÛÿóÿñXÿñ\ÿí¿ÿíÁÿíMÿÐYÿÛ\ÿë¿ÿëÁÿëõÿÐ Fÿ÷©ÿ÷´ÿ÷µÿ÷¶ÿ÷·ÿ÷¸ÿ÷Éÿ÷Ïÿ÷ÏÿÀÙÿöÛÿèÏÿÀXÿÞWÿÞ"ÿÞMÿÙõÿÙÿØÿØGÿÌÑÿÌ JÿÀVÿÀËÿÀÍÿÀÛÿÀÝÿÀßÿÀáÿÀÿÀÿÀÿÀÿÀÿÀMÿÜ[ÿÈõÿÜRÿñ´ÿñµÿñ¶ÿñ·ÿñ¸ÿñÛÿóÿñ Rÿö´ÿöµÿö¶ÿö·ÿö¸ÿöÛÿûÿö(*,JÿàVÿàËÿàÍÿàÛÿàÝÿàßÿàáÿàÿàÿàÿàÿàÿà!ÿ'ÿÐ)ÿÐ+ÿÐ;ÿÊ!ÿÑJÿëMÿÜ[ÿØÝÿëßÿëáÿëõÿÜÿ¦ÿØFÿ÷JÿðRÿ÷Uÿé©ÿ÷´ÿ÷µÿ÷¶ÿ÷·ÿ÷¸ÿ÷Éÿ÷Ëÿ÷Íÿ÷Ïÿ÷Ýÿðßÿðáÿðÿ÷ÿéÿé Fÿ÷Rÿ÷©ÿ÷´ÿ÷µÿ÷¶ÿ÷·ÿ÷¸ÿ÷Éÿ÷Ïÿ÷&ÿ`ÿ¦Fÿ€Jÿ€KÿáLÿáRÿ\Uÿ€Vÿ€©ÿ€®ÿá¯ÿá°ÿá±ÿá´ÿ\µÿ\¶ÿ\·ÿ\¸ÿ\Éÿ€Ëÿ€Íÿ€Ïÿ€ÛÿWÝÿ€ßÿ€áÿ€ ÿ¸ÿ\ÿ€ÿ€ÿ€ÿ€ÿ€ÿ€(ÿ*ÿ,ÿ*ÿð4ÿ÷‰ÿçFÿ°µÿ\GÿºÑÿºø´ n"ÿ÷ÿÎÿûÿßÿÊÿ´ÿºÿˆÿùÿôÿòÿúÿÜÿéÿÌÿýÿÛÿðÿïÿïÿãÿäÿÝÿÀÿÒÿÃÿùÿâþüÿìÿLÿúÿõÿáÿæÿòÿØÿ¢ÿÉÿØÿÀÿËÿäÿÜÿÜÿóÿËÿ÷ÿÑÿóÿãÿºÿºÿ×ÿñÿËÿØÿØÿØÿëÿºÿçÿÄÿªÿÌÿºÿÌÿÝÿâÿùÿüÿïÿöÿ°ÿùÿðÿúÿîÿõÿð\$')-./2345789:<EGIJKNPQRSUWYZ[\‚ƒ„…†‡’”•–—˜š›œžŸ³´µ¶·¸º¿ÀÁÂÄÆÑÝßáçô÷ø !3KUWXY[\_cdŠI$$''))--..//22334455 77 88 99 ::<<EEGGIIJJKKNNPQRSUUWWYYZZ[[ \\!‚‡’’”˜šš›ž ŸŸ³³´¸ºº¿¿!ÀÀÁÁ!ÂÂÄÄÆÆÑÑÝÝßßááççôô÷ø      !! 33KKUUWWXXYY [[ \\__ cc ddŠŠE $$&&**2244778899::;;<< DD EE FH JJMMRR TT UUVVXXYY[[\\‚‡‰‰”˜šš›žŸŸ ¢¨ ©­ ²² ´¸ ºº »¾¿¿ÁÁÂÂÃà ÄÄÅÅ ÆÆÇÇ ÈÈÉÉ ÎÎÏÏ ÕÕ ÙÙ ââõõ 33 KKLL PP UUWWXX __``ccŠŠ ""DFLTlatnÿÿmongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/web/client/resources/ico/000077500000000000000000000000001321131462300317025ustar00rootroot00000000000000goconvey-buildfail.ico000066400000000000000000000353561321131462300361150ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/web/client/resources/ico h6  ¨ž00 ¨%F(  × × ªªª0ªªª–ªªªØªªªøªªªøªªªØªªª–ªªª0ªªª ªªª˜ªªªþªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªþªªª˜ªªª ªªª ªªªÀªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÀªªª ªªª˜ªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªª˜ªªª0ªªªþªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªþªªª0ªªª–ªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªª–ªªªØªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªØªªªøªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªøªªªøªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªøªªªØªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªØªªª–ªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªª–ªªª0ªªªþªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªþªªª0ªªª˜ªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªª˜ªªª ªªªÀªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÀªªª ªªª ªªª˜ªªªþªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªþªªª˜ªªª ªªª0ªªª–ªªªØªªªøªªªøªªªØªªª–ªªª0ðÀ€€€€Àð( @ × × ªªª ªªªXªªª™ªªªÇªªªéªªªøªªªøªªªéªªªÇªªª™ªªªXªªª ªªª$ªªª›ªªªôªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªôªªª›ªªª$ªªª ªªª‰ªªªúªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªúªªª‰ªªª ªªª#ªªªÑªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÑªªª#ªªª0ªªªèªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªèªªª0ªªª#ªªªèªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªèªªª#ªªª ªªªÑªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÑªªª ªªª‰ªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªª‰ªªª$ªªªúªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªúªªª$ªªª›ªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªª›ªªª ªªªôªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªôªªª ªªªXªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªXªªª™ªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªª™ªªªÇªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÇªªªéªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªéªªªøªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªøªªªøªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªøªªªéªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªéªªªÇªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÇªªª™ªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªª™ªªªXªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªXªªª ªªªôªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªôªªª ªªª›ªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªª›ªªª$ªªªúªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªúªªª$ªªª‰ªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªª‰ªªª ªªªÑªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÑªªª ªªª#ªªªèªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªèªªª#ªªª0ªªªèªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªèªªª0ªªª#ªªªÑªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÑªªª#ªªª ªªª‰ªªªúªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªúªªª‰ªªª ªªª$ªªª›ªªªôªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªôªªª›ªªª$ªªª ªªªXªªª™ªªªÇªªªéªªªøªªªøªªªéªªªÇªªª™ªªªXªªª ÿÀÿÿÿü?øðàÀÀ€€€€ÀÀàðøü?ÿÿÿÀÿ(0` $× × ªªªªªª#ªªªXªªªŽªªªµªªªÚªªªëªªªøªªªøªªªëªªªÚªªªµªªªŽªªªXªªª#ªªªªªªªªªªªªmªªªÆªªªñªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªñªªªÆªªªmªªªªªªªªªªªªªªªëªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªëªªªªªªªªª ªªªtªªªóªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªóªªªtªªª ªªª-ªªªÅªªªþªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªþªªªÅªªª-ªªªªªªOªªªìªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªìªªªOªªªªªªªªªkªªªùªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªùªªªkªªªªªªªªªkªªªøªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªøªªªkªªªªªªOªªªùªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªùªªªOªªª-ªªªìªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªìªªª-ªªª ªªªÅªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÅªªª ªªªtªªªþªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªþªªªtªªªªªªóªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªóªªªªªªªªªªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªªªªªªªªªªëªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªëªªªªªªmªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªmªªªªªªÆªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÆªªªªªª#ªªªñªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªñªªª#ªªªXªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªXªªªŽªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªŽªªªµªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªµªªªÚªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÚªªªëªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªëªªªøªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªøªªªøªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªøªªªëªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªëªªªÚªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÚªªªµªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªµªªªŽªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªŽªªªXªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªXªªª#ªªªñªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªñªªª#ªªªªªªÆªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÆªªªªªªmªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªmªªªªªªëªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªëªªªªªªªªªªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªªªªªªªªªªóªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªóªªªªªªtªªªþªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªþªªªtªªª ªªªÅªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÅªªª ªªª-ªªªìªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªìªªª-ªªªOªªªùªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªùªªªOªªªªªªkªªªøªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªøªªªkªªªªªªªªªkªªªùªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªùªªªkªªªªªªªªªOªªªìªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªìªªªOªªªªªª-ªªªÅªªªþªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªþªªªÅªªª-ªªª ªªªtªªªóªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªóªªªtªªª ªªªªªªªªªëªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªëªªªªªªªªªªªªªªªmªªªÆªªªñªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªÿªªªñªªªÆªªªmªªªªªªªªªªªª#ªªªXªªªŽªªªµªªªÚªªªëªªªøªªªøªªªëªªªÚªªªµªªªŽªªªXªªª#ªªªÿÿÿÿÿøÿÿðÿÿÀÿÿ€ÿÿÿü?ü?øðààÀ€€€€€€Àààðøü?ü?ÿÿÿ€ÿÿÀÿÿðÿÿøÿÿÿÿÿgoconvey-fail.ico000066400000000000000000000353561321131462300350750ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/web/client/resources/ico h6  ¨ž00 ¨%F(  × × œç0œç–œçØœçøœçøœç؜疜ç0œç œç˜œçþœçÿœçÿœçÿœçÿœçÿœçÿœçþœç˜œç œç œçÀœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÀœç œç˜œçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœç˜œç0œçþœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçþœç0œç–œçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœç–œçØœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçØœçøœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçøœçøœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçøœçØœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœç؜疜çÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœç–œç0œçþœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçþœç0œç˜œçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœç˜œç œçÀœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÀœç œç œç˜œçþœçÿœçÿœçÿœçÿœçÿœçÿœçþœç˜œç œç0œç–œçØœçøœçøœç؜疜ç0ðÀ€€€€Àð( @ × × œç œçXœç™œçÇœçéœçøœçøœçéœçǜ癜çXœç œç$œç›œçôœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçôœç›œç$œç œç‰œçúœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçúœç‰œç œç#œçÑœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÑœç#œç0œçèœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçèœç0œç#œçèœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçèœç#œç œçÑœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÑœç œç‰œçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœç‰œç$œçúœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçúœç$œç›œçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœç›œç œçôœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçôœç œçXœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçXœç™œçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœç™œçÇœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÇœçéœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçéœçøœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçøœçøœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçøœçéœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçéœçÇœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçǜ癜çÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœç™œçXœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçXœç œçôœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçôœç œç›œçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœç›œç$œçúœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçúœç$œç‰œçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœç‰œç œçÑœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÑœç œç#œçèœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçèœç#œç0œçèœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçèœç0œç#œçÑœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÑœç#œç œç‰œçúœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçúœç‰œç œç$œç›œçôœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçôœç›œç$œç œçXœç™œçÇœçéœçøœçøœçéœçǜ癜çXœç ÿÀÿÿÿü?øðàÀÀ€€€€ÀÀàðøü?ÿÿÿÀÿ(0` $× × œçœç#œçXœçŽœçµœçÚœçëœçøœçøœçëœçڜ絜玜çXœç#œçœçœçœçmœçÆœçñœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçñœçÆœçmœçœçœçœçœçëœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçëœçœçœç œçtœçóœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçóœçtœç œç-œçÅœçþœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçþœçÅœç-œçœçOœçìœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçìœçOœçœçœçkœçùœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçùœçkœçœçœçkœçøœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçøœçkœçœçOœçùœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçùœçOœç-œçìœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçìœç-œç œçÅœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÅœç œçtœçþœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçþœçtœçœçóœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçóœçœçœçœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçœçœçœçëœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçëœçœçmœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçmœçœçÆœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÆœçœç#œçñœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçñœç#œçXœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçXœçŽœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçŽœçµœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçµœçÚœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÚœçëœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçëœçøœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçøœçøœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçøœçëœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçëœçÚœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçڜ絜çÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçµœçŽœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçŽœçXœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçXœç#œçñœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçñœç#œçœçÆœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÆœçœçmœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçmœçœçëœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçëœçœçœçœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçœçœçœçóœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçóœçœçtœçþœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçþœçtœç œçÅœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÅœç œç-œçìœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçìœç-œçOœçùœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçùœçOœçœçkœçøœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçøœçkœçœçœçkœçùœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçùœçkœçœçœçOœçìœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçìœçOœçœç-œçÅœçþœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçþœçÅœç-œç œçtœçóœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçóœçtœç œçœçœçëœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçëœçœçœçœçœçmœçÆœçñœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçÿœçñœçÆœçmœçœçœçœç#œçXœçŽœçµœçÚœçëœçøœçøœçëœçڜ絜玜çXœç#œçÿÿÿÿÿøÿÿðÿÿÀÿÿ€ÿÿÿü?ü?øðààÀ€€€€€€Àààðøü?ü?ÿÿÿ€ÿÿÀÿÿðÿÿøÿÿÿÿÿgoconvey-ok.ico000066400000000000000000000353561321131462300345730ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/web/client/resources/ico h6  ¨ž00 ¨%F(  × × , Z0, Z–, ZØ, Zø, Zø, ZØ, Z–, Z0, Z , Z˜, Zþ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zþ, Z˜, Z , Z , ZÀ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, ZÀ, Z , Z˜, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Z˜, Z0, Zþ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zþ, Z0, Z–, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Z–, ZØ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, ZØ, Zø, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zø, Zø, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zø, ZØ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, ZØ, Z–, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Z–, Z0, Zþ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zþ, Z0, Z˜, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Z˜, Z , ZÀ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, ZÀ, Z , Z , Z˜, Zþ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zþ, Z˜, Z , Z0, Z–, ZØ, Zø, Zø, ZØ, Z–, Z0ðÀ€€€€Àð( @ × × , Z , ZX, Z™, ZÇ, Zé, Zø, Zø, Zé, ZÇ, Z™, ZX, Z , Z$, Z›, Zô, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zô, Z›, Z$, Z , Z‰, Zú, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zú, Z‰, Z , Z#, ZÑ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, ZÑ, Z#, Z0, Zè, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zè, Z0, Z#, Zè, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zè, Z#, Z , ZÑ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, ZÑ, Z , Z‰, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Z‰, Z$, Zú, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zú, Z$, Z›, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Z›, Z , Zô, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zô, Z , ZX, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, ZX, Z™, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Z™, ZÇ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, ZÇ, Zé, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zé, Zø, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zø, Zø, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zø, Zé, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zé, ZÇ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, ZÇ, Z™, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Z™, ZX, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, ZX, Z , Zô, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zô, Z , Z›, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Z›, Z$, Zú, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zú, Z$, Z‰, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Z‰, Z , ZÑ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, ZÑ, Z , Z#, Zè, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zè, Z#, Z0, Zè, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zè, Z0, Z#, ZÑ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, ZÑ, Z#, Z , Z‰, Zú, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zú, Z‰, Z , Z$, Z›, Zô, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zô, Z›, Z$, Z , ZX, Z™, ZÇ, Zé, Zø, Zø, Zé, ZÇ, Z™, ZX, Z ÿÀÿÿÿü?øðàÀÀ€€€€ÀÀàðøü?ÿÿÿÀÿ(0` $× × , Z, Z#, ZX, ZŽ, Zµ, ZÚ, Zë, Zø, Zø, Zë, ZÚ, Zµ, ZŽ, ZX, Z#, Z, Z, Z, Zm, ZÆ, Zñ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zñ, ZÆ, Zm, Z, Z, Z, Z, Zë, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zë, Z, Z, Z , Zt, Zó, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zó, Zt, Z , Z-, ZÅ, Zþ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zþ, ZÅ, Z-, Z, ZO, Zì, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zì, ZO, Z, Z, Zk, Zù, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zù, Zk, Z, Z, Zk, Zø, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zø, Zk, Z, ZO, Zù, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zù, ZO, Z-, Zì, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zì, Z-, Z , ZÅ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, ZÅ, Z , Zt, Zþ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zþ, Zt, Z, Zó, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zó, Z, Z, Z, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Z, Z, Z, Zë, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zë, Z, Zm, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zm, Z, ZÆ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, ZÆ, Z, Z#, Zñ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zñ, Z#, ZX, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, ZX, ZŽ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, ZŽ, Zµ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zµ, ZÚ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, ZÚ, Zë, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zë, Zø, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zø, Zø, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zø, Zë, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zë, ZÚ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, ZÚ, Zµ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zµ, ZŽ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, ZŽ, ZX, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, ZX, Z#, Zñ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zñ, Z#, Z, ZÆ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, ZÆ, Z, Zm, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zm, Z, Zë, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zë, Z, Z, Z, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Z, Z, Z, Zó, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zó, Z, Zt, Zþ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zþ, Zt, Z , ZÅ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, ZÅ, Z , Z-, Zì, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zì, Z-, ZO, Zù, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zù, ZO, Z, Zk, Zø, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zø, Zk, Z, Z, Zk, Zù, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zù, Zk, Z, Z, ZO, Zì, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zì, ZO, Z, Z-, ZÅ, Zþ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zþ, ZÅ, Z-, Z , Zt, Zó, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zó, Zt, Z , Z, Z, Zë, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zë, Z, Z, Z, Z, Zm, ZÆ, Zñ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zÿ, Zñ, ZÆ, Zm, Z, Z, Z, Z#, ZX, ZŽ, Zµ, ZÚ, Zë, Zø, Zø, Zë, ZÚ, Zµ, ZŽ, ZX, Z#, ZÿÿÿÿÿøÿÿðÿÿÀÿÿ€ÿÿÿü?ü?øðààÀ€€€€€€Àààðøü?ü?ÿÿÿ€ÿÿÀÿÿðÿÿøÿÿÿÿÿgoconvey-panic.ico000066400000000000000000000353561321131462300352540ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/web/client/resources/ico h6  ¨ž00 ¨%F(  × × ª0ª–ªØªøªøªØª–ª0ª ª˜ªþªÿªÿªÿªÿªÿªÿªþª˜ª ª ªÀªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÀª ª˜ªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿª˜ª0ªþªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªþª0ª–ªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿª–ªØªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªØªøªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªøªøªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªøªØªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªØª–ªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿª–ª0ªþªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªþª0ª˜ªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿª˜ª ªÀªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÀª ª ª˜ªþªÿªÿªÿªÿªÿªÿªþª˜ª ª0ª–ªØªøªøªØª–ª0ðÀ€€€€Àð( @ × × ª ªXª™ªÇªéªøªøªéªÇª™ªXª ª$ª›ªôªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªôª›ª$ª ª‰ªúªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªúª‰ª ª#ªÑªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÑª#ª0ªèªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªèª0ª#ªèªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªèª#ª ªÑªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÑª ª‰ªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿª‰ª$ªúªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªúª$ª›ªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿª›ª ªôªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªôª ªXªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªXª™ªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿª™ªÇªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÇªéªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªéªøªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªøªøªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªøªéªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªéªÇªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÇª™ªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿª™ªXªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªXª ªôªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªôª ª›ªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿª›ª$ªúªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªúª$ª‰ªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿª‰ª ªÑªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÑª ª#ªèªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªèª#ª0ªèªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªèª0ª#ªÑªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÑª#ª ª‰ªúªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªúª‰ª ª$ª›ªôªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªôª›ª$ª ªXª™ªÇªéªøªøªéªÇª™ªXª ÿÀÿÿÿü?øðàÀÀ€€€€ÀÀàðøü?ÿÿÿÀÿ(0` $× × ªª#ªXªŽªµªÚªëªøªøªëªÚªµªŽªXª#ªªªªmªÆªñªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªñªÆªmªªªªªëªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªëªªª ªtªóªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªóªtª ª-ªÅªþªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªþªÅª-ªªOªìªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªìªOªªªkªùªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªùªkªªªkªøªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªøªkªªOªùªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªùªOª-ªìªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªìª-ª ªÅªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÅª ªtªþªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªþªtªªóªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªóªªªªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªªªªëªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªëªªmªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªmªªÆªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÆªª#ªñªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªñª#ªXªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªXªŽªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªŽªµªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªµªÚªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÚªëªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªëªøªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªøªøªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªøªëªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªëªÚªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÚªµªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªµªŽªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªŽªXªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªXª#ªñªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªñª#ªªÆªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÆªªmªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªmªªëªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªëªªªªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªªªªóªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªóªªtªþªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªþªtª ªÅªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÅª ª-ªìªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªìª-ªOªùªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªùªOªªkªøªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªøªkªªªkªùªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªùªkªªªOªìªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªìªOªª-ªÅªþªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªþªÅª-ª ªtªóªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªóªtª ªªªëªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªëªªªªªmªÆªñªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªÿªñªÆªmªªªª#ªXªŽªµªÚªëªøªøªëªÚªµªŽªXª#ªÿÿÿÿÿøÿÿðÿÿÀÿÿ€ÿÿÿü?ü?øðààÀ€€€€€€Àààðøü?ü?ÿÿÿ€ÿÿÀÿÿðÿÿøÿÿÿÿÿmongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/web/client/resources/js/000077500000000000000000000000001321131462300315445ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/web/client/resources/js/composer.js000066400000000000000000000070361321131462300337370ustar00rootroot00000000000000var composer = { tab: "\t", template: "", isFunc: function(scope) { if (!scope.title || typeof scope.depth === 'undefined') return false; return scope.title.indexOf("Test") === 0 && scope.depth === 0; }, discardLastKey: false }; $(function() { // Begin layout sizing var headerHeight = $('header').outerHeight(); var padding = $('#input, #output').css('padding-top').replace("px", "") * 2 + 1; var outputPlaceholder = $('#output').text(); $(window).resize(function() { $('#input, #output').height($(window).height() - headerHeight - padding); }); $(window).resize(); // End layout sizing $('#input').keydown(function(e) { // 13=Enter, 16=Shift composer.discardLastKey = e.keyCode === 13 || e.keyCode === 16; }).keyup(function(e) { if (!composer.discardLastKey) generate($(this).val()); }); composer.template = $('#tpl-convey').text(); tabOverride.set(document.getElementById('input')); $('#input').focus(); }); // Begin Markup.js custom pipes Mark.pipes.recursivelyRender = function(val) { return !val || val.length === 0 ? "\n" : Mark.up(composer.template, val); } Mark.pipes.indent = function(val) { return new Array(val + 1).join("\t"); } Mark.pipes.notTestFunc = function(scope) { return !composer.isFunc(scope); } Mark.pipes.safeFunc = function(val) { return val.replace(/[^a-z0-9_]/gi, ''); } Mark.pipes.properCase = function(str) { if (str.length === 0) return ""; str = str.charAt(0).toUpperCase() + str.substr(1); if (str.length < 2) return str; return str.replace(/[\s_][a-z]+/g, function(txt) { return txt.charAt(0) + txt.charAt(1).toUpperCase() + txt.substr(2).toLowerCase(); }); } Mark.pipes.showImports = function(item) { console.log(item); if (root.title === "(root)" && root.stories.length > 0) return 'import (\n\t"testing"\n\t. "github.com/smartystreets/goconvey/convey"\n)\n'; else return ""; } // End Markup.js custom pipes function generate(input) { var root = parseInput(input); $('#output').text(Mark.up(composer.template, root.stories)); if (root.stories.length > 0 && root.stories[0].title.substr(0, 4) === "Test") $('#output').prepend('import (\n\t"testing"\n\t. "github.com/smartystreets/goconvey/convey"\n)\n\n'); } function parseInput(input) { lines = input.split("\n"); if (!lines) return; var root = { title: "(root)", stories: [] }; for (i in lines) { line = lines[i]; lineText = $.trim(line); if (!lineText) continue; // Figure out how deep to put this story indent = line.match(new RegExp("^" + composer.tab + "+")); tabs = indent ? indent[0].length / composer.tab.length : 0; // Starting at root, traverse into the right spot in the arrays var curScope = root, prevScope = root; for (j = 0; j < tabs && curScope.stories.length > 0; j++) { curScope = curScope.stories[curScope.stories.length - 1]; prevScope = curScope; } // Don't go crazy, though! (avoid excessive indentation) if (tabs > curScope.depth + 1) tabs = curScope.depth + 1; // Only top-level Convey() calls need the *testing.T object passed in var showT = composer.isFunc(prevScope) || (!composer.isFunc(curScope) && tabs === 0); // Save the story at this scope curScope.stories.push({ title: lineText.replace(/"/g, "\\\""), // escape quotes stories: [], depth: tabs, showT: showT }); } return root; } function suppress(event) { if (!event) return false; if (event.preventDefault) event.preventDefault(); if (event.stopPropagation) event.stopPropagation(); event.cancelBubble = true; return false; } mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/web/client/resources/js/config.js000066400000000000000000000010601321131462300333440ustar00rootroot00000000000000// Configure the GoConvey web UI client in here convey.config = { // Install new themes by adding them here; the first one will be default themes: { "dark": { name: "Dark", filename: "dark.css", coverage: "hsla({{hue}}, 75%, 30%, .5)" }, "dark-bigtext": { name: "Dark-BigText", filename: "dark-bigtext.css", coverage: "hsla({{hue}}, 75%, 30%, .5)" }, "light": { name: "Light", filename: "light.css", coverage: "hsla({{hue}}, 62%, 75%, 1)" } }, // Path to the themes (end with forward-slash) themePath: "/resources/css/themes/" }; mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/web/client/resources/js/convey.js000066400000000000000000000040761321131462300334140ustar00rootroot00000000000000var convey = { // *** Don't edit in here unless you're brave *** statuses: { // contains some constants related to overall test status pass: { class: 'ok', text: "Pass" }, // class name must also be that in the favicon file name fail: { class: 'fail', text: "Fail" }, panic: { class: 'panic', text: "Panic" }, buildfail: { class: 'buildfail', text: "Build Failure" } }, frameCounter: 0, // gives each frame a unique ID maxHistory: 20, // how many tests to keep in the history notif: undefined, // the notification currently being displayed notifTimer: undefined, // the timer that clears the notifications automatically poller: new Poller(), // the server poller status: "", // what the _server_ is currently doing (not overall test results) overallClass: "", // class name of the "overall" status banner theme: "", // theme currently being used packageStates: {}, // packages manually collapsed or expanded during this page's lifetime uiEffects: true, // whether visual effects are enabled framesOnSamePath: 0, // number of consecutive frames on this same watch path layout: { selClass: "sel", // CSS class when an element is "selected" header: undefined, // container element of the header area (overall, controls) frame: undefined, // container element of the main body area (above footer) footer: undefined // container element of the footer (stuck to bottom) }, history: [], // complete history of states (test results and aggregated data), including the current one moments: {}, // elements that display time relative to the current time, keyed by ID, with the moment() as a value intervals: {}, // ntervals that execute periodically intervalFuncs: { // functions executed by each interval in convey.intervals time: function() { var t = new Date(); var h = zerofill(t.getHours(), 2); var m = zerofill(t.getMinutes(), 2); var s = zerofill(t.getSeconds(), 2); $('#time').text(h + ":" + m + ":" + s); }, momentjs: function() { for (var id in convey.moments) $('#'+id).html(convey.moments[id].fromNow()); } } }; mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/web/client/resources/js/goconvey.js000066400000000000000000001021001321131462300337250ustar00rootroot00000000000000$(init); $(window).load(function() { // Things may shift after all the elements (images/fonts) are loaded // In Chrome, calling reframe() doesn't work (maybe a quirk); we need to trigger resize $(window).resize(); }); function init() { log("Welcome to GoConvey!"); log("Initializing interface"); convey.overall = emptyOverall(); loadTheme(); $('body').show(); initPoller(); wireup(); latest(); } function loadTheme(thmID) { var defaultTheme = "dark"; var linkTagId = "themeRef"; if (!thmID) thmID = get('theme') || defaultTheme; log("Initializing theme: " + thmID); if (!convey.config.themes[thmID]) { replacement = Object.keys(convey.config.themes)[0] || defaultTheme; log("NOTICE: Could not find '" + thmID + "' theme; defaulting to '" + replacement + "'"); thmID = replacement; } convey.theme = thmID; save('theme', convey.theme); var linkTag = $('#'+linkTagId); var fullPath = convey.config.themePath + convey.config.themes[convey.theme].filename; if (linkTag.length === 0) { $('head').append(''); } else linkTag.attr('href', fullPath); colorizeCoverageBars(); } function initPoller() { $(convey.poller).on('serverstarting', function(event) { log("Server is starting..."); convey.status = "starting"; showServerDown("Server starting"); $('#run-tests').addClass('spin-slowly disabled'); }); $(convey.poller).on('pollsuccess', function(event, data) { if (convey.status !== "starting") hideServerDown(); // These two if statements determine if the server is now busy // (and wasn't before) or is not busy (regardless of whether it was before) if ((!convey.status || convey.status === "idle") && data.status && data.status !== "idle") $('#run-tests').addClass('spin-slowly disabled'); else if (convey.status !== "idle" && data.status === "idle") { $('#run-tests').removeClass('spin-slowly disabled'); } switch (data.status) { case "executing": $(convey.poller).trigger('serverexec', data); break; case "idle": $(convey.poller).trigger('serveridle', data); break; } convey.status = data.status; }); $(convey.poller).on('pollfail', function(event, data) { log("Poll failed; server down"); convey.status = "down"; showServerDown("Server down"); }); $(convey.poller).on('serverexec', function(event, data) { log("Server status: executing"); $('.favicon').attr('href', '/favicon.ico'); // indicates running tests }); $(convey.poller).on('serveridle', function(event, data) { log("Server status: idle"); log("Tests have finished executing"); latest(); }); convey.poller.start(); } function wireup() { log("Wireup"); customMarkupPipes(); var themes = []; for (var k in convey.config.themes) themes.push({ id: k, name: convey.config.themes[k].name }); $('#theme').html(render('tpl-theme-enum', themes)); enumSel("theme", convey.theme); loadSettingsFromStorage(); $('#stories').on('click', '.toggle-all-pkg', function(event) { if ($(this).closest('.story-pkg').data('pkg-state') === "expanded") collapseAll(); else expandAll(); return suppress(event); }); // Wireup the settings switches $('.enum#theme').on('click', 'li:not(.sel)', function() { loadTheme($(this).data('theme')); }); $('.enum#pkg-expand-collapse').on('click', 'li:not(.sel)', function() { var newSetting = $(this).data('pkg-expand-collapse'); convey.packageStates = {}; save('pkg-expand-collapse', newSetting); if (newSetting === "expanded") expandAll(); else collapseAll(); }); $('.enum#show-debug-output').on('click', 'li:not(.sel)', function() { var newSetting = $(this).data('show-debug-output'); save('show-debug-output', newSetting); if (newSetting === "show") $('.story-line-desc .message').show(); else $('.story-line-desc .message').hide(); }); $('.enum#ui-effects').on('click', 'li:not(.sel)', function() { var newSetting = $(this).data('ui-effects'); convey.uiEffects = newSetting; save('ui-effects', newSetting); }); // End settings wireup convey.layout.header = $('header').first(); convey.layout.frame = $('.frame').first(); convey.layout.footer = $('footer').last(); updateWatchPath(); $('#path').change(function() { // Updates the watched directory with the server and makes sure it exists var tb = $(this); var newpath = encodeURIComponent($.trim(tb.val())); $.post('/watch?root='+newpath) .done(function() { tb.removeClass('error'); }) .fail(function() { tb.addClass('error'); }); convey.framesOnSamePath = 1; }); $('#run-tests').click(function() { var self = $(this); if (self.hasClass('spin-slowly') || self.hasClass('disabled')) return; log("Test run invoked from web UI"); $.get("/execute"); }); $('#play-pause').click(function() { $.get('/pause'); if ($(this).hasClass(convey.layout.selClass)) { // Un-pausing if (!$('footer .replay').is(':visible')) $('footer .recording').show(); $('footer .paused').hide(); log("Resuming auto-execution of tests"); } else { // Pausing $('footer .recording').hide(); $('footer .paused').show(); log("Pausing auto-execution of tests"); } $(this).toggleClass("throb " + convey.layout.selClass); }); $('#toggle-notif').click(function() { log("Turning notifications " + (notif() ? "off" : "on")); $(this).toggleClass("fa-bell-o fa-bell " + convey.layout.selClass); save('notifications', !notif()); if (notif() && 'Notification' in window) { if (Notification.permission !== 'denied') { Notification.requestPermission(function(per) { if (!('permission' in Notification)) Notification.permission = per; }); } else log("Permission denied to show desktop notification"); } }); $('#show-history').click(function() { toggle($('.history'), $(this)); }); $('#show-settings').click(function() { toggle($('.settings'), $(this)); }); $('#show-gen').click(function() { var writer = window.open("/composer.html"); if (window.focus) writer.focus(); }); // Wire-up the tipsy tooltips $('.controls li, .pkg-cover-name').tipsy({ live: true }); $('footer .replay').tipsy({ live: true, gravity: 'e' }); $('#path').tipsy({ delayIn: 500 }); $('.ignore').tipsy({ live: true, gravity: $.fn.tipsy.autoNS }); $('.disabled').tipsy({ live: true, gravity: $.fn.tipsy.autoNS }); $('#logo').tipsy({ gravity: 'w' }); $('.toggler').not('.narrow').prepend(''); $('.toggler.narrow').prepend(''); $('.toggler').not('.narrow').click(function() { var target = $('#' + $(this).data('toggle')); $('.fa-angle-down, .fa-angle-up', this).toggleClass('fa-angle-down fa-angle-up'); target.toggle(); }); $('.toggler.narrow').click(function() { var target = $('#' + $(this).data('toggle')); $('.fa-angle-down, .fa-angle-up', this).toggleClass('fa-angle-down fa-angle-up'); target.toggleClass('hide-narrow show-narrow'); }); // Enumerations are horizontal lists where one item can be selected at a time $('.enum').on('click', 'li', enumSel); // Start ticking time convey.intervals.time = setInterval(convey.intervalFuncs.time, 1000); convey.intervals.momentjs = setInterval(convey.intervalFuncs.momentjs, 5000); convey.intervalFuncs.time(); // Ignore/un-ignore package $('#stories').on('click', '.fa.ignore', function(event) { var pkg = $(this).data('pkg'); if ($(this).hasClass('disabled')) return; else if ($(this).hasClass('unwatch')) $.get("/ignore", { paths: pkg }); else $.get("/reinstate", { paths: pkg }); $(this).toggleClass('watch unwatch fa-eye fa-eye-slash clr-red'); return suppress(event); }); // Show "All" link when hovering the toggler on packages in the stories $('#stories').on({ mouseenter: function() { $('.toggle-all-pkg', this).stop().show('fast'); }, mouseleave: function() { $('.toggle-all-pkg', this).stop().hide('fast'); } }, '.pkg-toggle-container'); // Toggle a package in the stories when clicked $('#stories').on('click', '.story-pkg', function(event) { togglePackage(this, true); return suppress(event); }); // Select a story line when it is clicked $('#stories').on('click', '.story-line', function() { $('.story-line-sel').not(this).removeClass('story-line-sel'); $(this).toggleClass('story-line-sel'); }); // Render a frame from the history when clicked $('.history .container').on('click', '.item', function(event) { var frame = getFrame($(this).data("frameid")); changeStatus(frame.overall.status, true); renderFrame(frame); $(this).addClass('selected'); // Update current status down in the footer if ($(this).is(':first-child')) { // Now on current frame $('footer .replay').hide(); if ($('#play-pause').hasClass(convey.layout.selClass)) // Was/is paused $('footer .paused').show(); else $('footer .recording').show(); // Was/is recording } else { $('footer .recording, footer .replay').hide(); $('footer .replay').show(); } return suppress(event); }); $('footer').on('click', '.replay', function() { // Clicking "REPLAY" in the corner should bring them back to the current frame // and hide, if visible, the history panel for convenience $('.history .item:first-child').click(); if ($('#show-history').hasClass('sel')) $('#show-history').click(); }); // Keyboard shortcuts! $(document).keydown(function(e) { if (e.ctrlKey || e.metaKey || e.shiftKey) return; switch (e.keyCode) { case 67: // c $('#show-gen').click(); break; case 82: // r $('#run-tests').click(); break; case 78: // n $('#toggle-notif').click(); break; case 87: // w $('#path').focus(); break; case 80: // p $('#play-pause').click(); break; } return suppress(e); }); $('body').on('keydown', 'input, textarea, select', function(e) { // If user is typing something, don't let this event bubble // up to the document to annoyingly fire keyboard shortcuts e.stopPropagation(); }); // Keep everything positioned and sized properly on window resize reframe(); $(window).resize(reframe); } function expandAll() { $('.story-pkg').each(function() { expandPackage($(this).data('pkg')); }); } function collapseAll() { $('.story-pkg').each(function() { collapsePackage($(this).data('pkg')); }); } function expandPackage(pkgId) { var pkg = $('.story-pkg.pkg-'+pkgId); var rows = $('.story-line.pkg-'+pkgId); pkg.data('pkg-state', "expanded").addClass('expanded').removeClass('collapsed'); $('.pkg-toggle', pkg) .addClass('fa-minus-square-o') .removeClass('fa-plus-square-o'); rows.show(); } function collapsePackage(pkgId) { var pkg = $('.story-pkg.pkg-'+pkgId); var rows = $('.story-line.pkg-'+pkgId); pkg.data('pkg-state', "collapsed").addClass('collapsed').removeClass('expanded'); $('.pkg-toggle', pkg) .addClass('fa-plus-square-o') .removeClass('fa-minus-square-o'); rows.hide(); } function togglePackage(storyPkgElem) { var pkgId = $(storyPkgElem).data('pkg'); if ($(storyPkgElem).data('pkg-state') === "expanded") { collapsePackage(pkgId); convey.packageStates[$(storyPkgElem).data('pkg-name')] = "collapsed"; } else { expandPackage(pkgId); convey.packageStates[$(storyPkgElem).data('pkg-name')] = "expanded"; } } function loadSettingsFromStorage() { var pkgExpCollapse = get("pkg-expand-collapse"); if (!pkgExpCollapse) { pkgExpCollapse = "expanded"; save("pkg-expand-collapse", pkgExpCollapse); } enumSel("pkg-expand-collapse", pkgExpCollapse); var showDebugOutput = get("show-debug-output"); if (!showDebugOutput) { showDebugOutput = "show"; save("show-debug-output", showDebugOutput); } enumSel("show-debug-output", showDebugOutput); var uiEffects = get("ui-effects"); if (uiEffects === null) uiEffects = "true"; convey.uiEffects = uiEffects === "true"; enumSel("ui-effects", uiEffects); if (notif()) $('#toggle-notif').toggleClass("fa-bell-o fa-bell " + convey.layout.selClass); } function latest() { log("Fetching latest test results"); $.getJSON("/latest", process); } function process(data, status, jqxhr) { if (!data || !data.Revision) { log("No data received or revision timestamp was missing"); return; } if (data.Paused && !$('#play-pause').hasClass(convey.layout.selClass)) { $('footer .recording').hide(); $('footer .paused').show(); $('#play-pause').toggleClass("throb " + convey.layout.selClass); } if (current() && data.Revision === current().results.Revision) { log("No changes"); changeStatus(current().overall.status); // re-assures that status is unchanged return; } // Put the new frame in the queue so we can use current() to get to it convey.history.push(newFrame()); convey.framesOnSamePath++; // Store the raw results in our frame current().results = data; log("Updating watch path"); updateWatchPath(); // Remove all templated items from the DOM as we'll // replace them with new ones; also remove tipsy tooltips // that may have lingered around $('.templated, .tipsy').remove(); var uniqueID = 0; var coverageAvgHelper = { countedPackages: 0, coverageSum: 0 }; var packages = { tested: [], ignored: [], coverage: {}, nogofiles: [], notestfiles: [], notestfn: [] }; log("Compiling package statistics"); // Look for failures and panics through the packages->tests->stories... for (var i in data.Packages) { pkg = makeContext(data.Packages[i]); current().overall.duration += pkg.Elapsed; pkg._id = uniqueID++; if (pkg.Outcome === "build failure") { current().overall.failedBuilds++; current().failedBuilds.push(pkg); continue; } if (pkg.Outcome === "no go code") packages.nogofiles.push(pkg); else if (pkg.Outcome === "no test files") packages.notestfiles.push(pkg); else if (pkg.Outcome === "no test functions") packages.notestfn.push(pkg); else if (pkg.Outcome === "ignored" || pkg.Outcome === "disabled") packages.ignored.push(pkg); else { if (pkg.Coverage >= 0) coverageAvgHelper.coverageSum += pkg.Coverage; coverageAvgHelper.countedPackages++; packages.coverage[pkg.PackageName] = pkg.Coverage; packages.tested.push(pkg); } for (var j in pkg.TestResults) { test = makeContext(pkg.TestResults[j]); test._id = uniqueID++; test._pkgid = pkg._id; test._pkg = pkg.PackageName; if (test.Stories.length === 0) { // Here we've got ourselves a classic Go test, // not a GoConvey test that has stories and assertions // so we'll treat this whole test as a single assertion current().overall.assertions++; if (test.Error) { test._status = convey.statuses.panic; pkg._panicked++; test._panicked++; current().assertions.panicked.push(test); } else if (test.Passed === false) { test._status = convey.statuses.fail; pkg._failed++; test._failed++; current().assertions.failed.push(test); } else if (test.Skipped) { test._status = convey.statuses.skipped; pkg._skipped++; test._skipped++; current().assertions.skipped.push(test); } else { test._status = convey.statuses.pass; pkg._passed++; test._passed++; current().assertions.passed.push(test); } } else test._status = convey.statuses.pass; var storyPath = [{ Depth: -1, Title: test.TestName, _id: test._id }]; // Maintains the current assertion's story as we iterate for (var k in test.Stories) { var story = makeContext(test.Stories[k]); story._id = uniqueID; story._pkgid = pkg._id; current().overall.assertions += story.Assertions.length; // Establish the current story path so we can report the context // of failures and panicks more conveniently at the top of the page if (storyPath.length > 0) for (var x = storyPath[storyPath.length - 1].Depth; x >= test.Stories[k].Depth; x--) storyPath.pop(); storyPath.push({ Depth: test.Stories[k].Depth, Title: test.Stories[k].Title, _id: test.Stories[k]._id }); for (var l in story.Assertions) { var assertion = story.Assertions[l]; assertion._id = uniqueID; assertion._pkg = pkg.PackageName; assertion._pkgId = pkg._id; assertion._failed = !!assertion.Failure; assertion._panicked = !!assertion.Error; assertion._maxDepth = storyPath[storyPath.length - 1].Depth; $.extend(assertion._path = [], storyPath); if (assertion.Failure) { current().assertions.failed.push(assertion); pkg._failed++; test._failed++; story._failed++; } if (assertion.Error) { current().assertions.panicked.push(assertion); pkg._panicked++; test._panicked++; story._panicked++; } if (assertion.Skipped) { current().assertions.skipped.push(assertion); pkg._skipped++; test._skipped++; story._skipped++; } if (!assertion.Failure && !assertion.Error && !assertion.Skipped) { current().assertions.passed.push(assertion); pkg._passed++; test._passed++; story._passed++; } } assignStatus(story); uniqueID++; } if (!test.Passed && !test._failed && !test._panicked) { // Edge case: Developer is using the GoConvey DSL, but maybe // in some cases is using t.Error() instead of So() assertions. // This can be detected, assuming all child stories with // assertions (in this test) are passing. test._status = convey.statuses.fail; pkg._failed++; test._failed++; current().assertions.failed.push(test); } } } current().overall.passed = current().assertions.passed.length; current().overall.panics = current().assertions.panicked.length; current().overall.failures = current().assertions.failed.length; current().overall.skipped = current().assertions.skipped.length; current().overall.coverage = Math.round((coverageAvgHelper.coverageSum / (coverageAvgHelper.countedPackages || 1)) * 100) / 100; current().overall.duration = Math.round(current().overall.duration * 1000) / 1000; // Compute the coverage delta (difference in overall coverage between now and last frame) // Only compare coverage on the same watch path var coverDelta = current().overall.coverage; if (convey.framesOnSamePath > 2) coverDelta = current().overall.coverage - convey.history[convey.history.length - 2].overall.coverage; current().coverDelta = Math.round(coverDelta * 100) / 100; // Build failures trump panics, // Panics trump failures, // Failures trump pass. if (current().overall.failedBuilds) changeStatus(convey.statuses.buildfail); else if (current().overall.panics) changeStatus(convey.statuses.panic); else if (current().overall.failures) changeStatus(convey.statuses.fail); else changeStatus(convey.statuses.pass); // Save our organized package lists current().packages = packages; log(" Assertions: " + current().overall.assertions); log(" Passed: " + current().overall.passed); log(" Skipped: " + current().overall.skipped); log(" Failures: " + current().overall.failures); log(" Panics: " + current().overall.panics); log("Build Failures: " + current().overall.failedBuilds); log(" Coverage: " + current().overall.coverage + "% (" + showCoverDelta(current().coverDelta) + ")"); // Save timestamp when this test was executed convey.moments['last-test'] = moment(); // Render... render ALL THE THINGS! (All model/state modifications are DONE!) renderFrame(current()); // Now, just finish up miscellaneous UI things // Add this frame to the history pane var framePiece = render('tpl-history', current()); $('.history .container').prepend(framePiece); $('.history .item:first-child').addClass('selected'); convey.moments['frame-'+current().id] = moment(); if (convey.history.length > convey.maxHistory) { // Delete the oldest frame out of the history pane if we have too many convey.history.splice(0, 1); $('.history .container .item').last().remove(); } // Now add the momentjs time to the new frame in the history convey.intervalFuncs.momentjs(); // Show notification, if enabled if (notif()) { log("Showing notification"); if (convey.notif) { clearTimeout(convey.notifTimer); convey.notif.close(); } var notifText = notifSummary(current()) convey.notif = new Notification(notifText.title, { body: notifText.body, icon: $('.favicon').attr('href') }); convey.notifTimer = setTimeout(function() { convey.notif.close(); }, 5000); } // Update title in title bar if (current().overall.passed === current().overall.assertions && current().overall.status.class === "ok") $('title').text("GoConvey (ALL PASS)"); else $('title').text("GoConvey [" + current().overall.status.text + "] " + current().overall.passed + "/" + current().overall.assertions); // All done! log("Processing complete"); } // Updates the entire UI given a frame from the history function renderFrame(frame) { log("Rendering frame (id: " + frame.id + ")"); $('#coverage').html(render('tpl-coverage', frame.packages.tested.sort(sortPackages))); $('#ignored').html(render('tpl-ignored', frame.packages.ignored.sort(sortPackages))); $('#nogofiles').html(render('tpl-nogofiles', frame.packages.nogofiles.sort(sortPackages))); $('#notestfiles').html(render('tpl-notestfiles', frame.packages.notestfiles.sort(sortPackages))); $('#notestfn').html(render('tpl-notestfn', frame.packages.notestfn.sort(sortPackages))); if (frame.overall.failedBuilds) { $('.buildfailures').show(); $('#buildfailures').html(render('tpl-buildfailures', frame.failedBuilds)); } else $('.buildfailures').hide(); if (frame.overall.panics) { $('.panics').show(); $('#panics').html(render('tpl-panics', frame.assertions.panicked)); } else $('.panics').hide(); if (frame.overall.failures) { $('.failures').show(); $('#failures').html(render('tpl-failures', frame.assertions.failed)); $(".failure").each(function() { $(this).prettyTextDiff(); }); } else $('.failures').hide(); $('#stories').html(render('tpl-stories', frame.packages.tested.sort(sortPackages))); $('#stories').append(render('tpl-stories', frame.packages.ignored.sort(sortPackages))); var pkgDefaultView = get('pkg-expand-collapse'); $('.story-pkg.expanded').each(function() { if (pkgDefaultView === "collapsed" && convey.packageStates[$(this).data('pkg-name')] !== "expanded") collapsePackage($(this).data('pkg')); }); redrawCoverageBars(); $('#assert-count').html(""+frame.overall.assertions+" assertion" + (frame.overall.assertions !== 1 ? "s" : "")); $('#skip-count').html(""+frame.assertions.skipped.length + " skipped"); $('#fail-count').html(""+frame.assertions.failed.length + " failed"); $('#panic-count').html(""+frame.assertions.panicked.length + " panicked"); $('#duration').html(""+frame.overall.duration + "s"); $('#narrow-assert-count').html(""+frame.overall.assertions+""); $('#narrow-skip-count').html(""+frame.assertions.skipped.length + ""); $('#narrow-fail-count').html(""+frame.assertions.failed.length + ""); $('#narrow-panic-count').html(""+frame.assertions.panicked.length + ""); $('.history .item').removeClass('selected'); if (get('show-debug-output') === "hide") $('.story-line-desc .message').hide(); log("Rendering finished"); } function enumSel(id, val) { if (typeof id === "string" && typeof val === "string") { $('.enum#'+id+' > li').each(function() { if ($(this).data(id).toString() === val) { $(this).addClass(convey.layout.selClass).siblings().removeClass(convey.layout.selClass); return false; } }); } else $(this).addClass(convey.layout.selClass).siblings().removeClass(convey.layout.selClass); } function toggle(jqelem, switchelem) { var speed = 250; var transition = 'easeInOutQuart'; var containerSel = '.container'; if (!jqelem.is(':visible')) { $(containerSel, jqelem).css('opacity', 0); jqelem.stop().slideDown(speed, transition, function() { if (switchelem) switchelem.toggleClass(convey.layout.selClass); $(containerSel, jqelem).stop().animate({ opacity: 1 }, speed); reframe(); }); } else { $(containerSel, jqelem).stop().animate({ opacity: 0 }, speed, function() { if (switchelem) switchelem.toggleClass(convey.layout.selClass); jqelem.stop().slideUp(speed, transition, function() { reframe(); }); }); } } function changeStatus(newStatus, isHistoricalFrame) { if (!newStatus || !newStatus.class || !newStatus.text) newStatus = convey.statuses.pass; var sameStatus = newStatus.class === convey.overallClass; // The CSS class .flash and the jQuery UI 'pulsate' effect don't play well together. // This series of callbacks does the flickering/pulsating as well as // enabling/disabling flashing in the proper order so that they don't overlap. // TODO: I suppose the pulsating could also be done with just CSS, maybe...? if (convey.uiEffects) { var times = sameStatus ? 3 : 2; var duration = sameStatus ? 500 : 300; $('.overall .status').removeClass('flash').effect("pulsate", {times: times}, duration, function() { $(this).text(newStatus.text); if (newStatus !== convey.statuses.pass) // only flicker extra when not currently passing { $(this).effect("pulsate", {times: 1}, 300, function() { $(this).effect("pulsate", {times: 1}, 500, function() { if (newStatus === convey.statuses.panic || newStatus === convey.statuses.buildfail) $(this).addClass('flash'); else $(this).removeClass('flash'); }); }); } }); } else $('.overall .status').text(newStatus.text); if (!sameStatus) // change the color $('.overall').switchClass(convey.overallClass, newStatus.class, 1000); if (!isHistoricalFrame) current().overall.status = newStatus; convey.overallClass = newStatus.class; $('.favicon').attr('href', '/resources/ico/goconvey-'+newStatus.class+'.ico'); } function updateWatchPath() { $.get("/watch", function(data) { var newPath = $.trim(data); if (newPath !== $('#path').val()) convey.framesOnSamePath = 1; $('#path').val(newPath); }); } function notifSummary(frame) { var body = frame.overall.passed + " passed, "; if (frame.overall.failedBuilds) body += frame.overall.failedBuilds + " build" + (frame.overall.failedBuilds !== 1 ? "s" : "") + " failed, "; if (frame.overall.failures) body += frame.overall.failures + " failed, "; if (frame.overall.panics) body += frame.overall.panics + " panicked, "; body += frame.overall.skipped + " skipped"; body += "\r\n" + frame.overall.duration + "s"; if (frame.coverDelta > 0) body += "\r\n↑ coverage (" + showCoverDelta(frame.coverDelta) + ")"; else if (frame.coverDelta < 0) body += "\r\n↓ coverage (" + showCoverDelta(frame.coverDelta) + ")"; return { title: frame.overall.status.text.toUpperCase(), body: body }; } function redrawCoverageBars() { $('.pkg-cover-bar').each(function() { var pkgName = $(this).data("pkg"); var hue = $(this).data("width"); var hueDiff = hue; if (convey.history.length > 1) { var oldHue = convey.history[convey.history.length - 2].packages.coverage[pkgName] || 0; $(this).width(oldHue + "%"); hueDiff = hue - oldHue; } $(this).animate({ width: "+=" + hueDiff + "%" }, 1250); }); colorizeCoverageBars(); } function colorizeCoverageBars() { var colorTpl = convey.config.themes[convey.theme].coverage || "hsla({{hue}}, 75%, 30%, .3)"; //default color template $('.pkg-cover-bar').each(function() { var hue = $(this).data("width"); $(this).css({ background: colorTpl.replace("{{hue}}", hue) }); }); } function getFrame(id) { for (var i in convey.history) if (convey.history[i].id === id) return convey.history[i]; } function render(templateID, context) { var tpl = $('#' + templateID).text(); return $($.trim(Mark.up(tpl, context))); } function reframe() { var heightBelowHeader = $(window).height() - convey.layout.header.outerHeight(); var middleHeight = heightBelowHeader - convey.layout.footer.outerHeight(); convey.layout.frame.height(middleHeight); var pathWidth = $(window).width() - $('#logo').outerWidth() - $('#control-buttons').outerWidth() - 10; $('#path-container').width(pathWidth); } function notif() { return get('notifications') === "true"; // stored as strings } function showServerDown(message) { $('.server-down .notice-message').text(message); $('.server-down').show(); $('.server-not-down').hide(); reframe(); } function hideServerDown() { $('.server-down').hide(); $('.server-not-down').show(); reframe(); } function log(msg) { var jqLog = $('#log'); if (jqLog.length > 0) { var t = new Date(); var h = zerofill(t.getHours(), 2); var m = zerofill(t.getMinutes(), 2); var s = zerofill(t.getSeconds(), 2); var ms = zerofill(t.getMilliseconds(), 3); date = h + ":" + m + ":" + s + "." + ms; $(jqLog).append(render('tpl-log-line', { time: date, msg: msg })); $(jqLog).parent('.col').scrollTop(jqLog[0].scrollHeight); } else console.log(msg); } function zerofill(val, count) { // Cheers to http://stackoverflow.com/a/9744576/1048862 var pad = new Array(1 + count).join('0'); return (pad + val).slice(-pad.length); } // Sorts packages ascending by only the last part of their name // Can be passed into Array.sort() function sortPackages(a, b) { var aPkg = splitPathName(a.PackageName); var bPkg = splitPathName(b.PackageName); if (aPkg.length === 0 || bPkg.length === 0) return 0; var aName = aPkg.parts[aPkg.parts.length - 1].toLowerCase(); var bName = bPkg.parts[bPkg.parts.length - 1].toLowerCase(); if (aName < bName) return -1; else if (aName > bName) return 1; else return 0; /* MEMO: Use to sort by entire package name: if (a.PackageName < b.PackageName) return -1; else if (a.PackageName > b.PackageName) return 1; else return 0; */ } function get(key) { var val = localStorage.getItem(key); if (val && (val[0] === '[' || val[0] === '{')) return JSON.parse(val); else return val; } function save(key, val) { if (typeof val === 'object') val = JSON.stringify(val); else if (typeof val === 'number' || typeof val === 'boolean') val = val.toString(); localStorage.setItem(key, val); } function splitPathName(str) { var delim = str.indexOf('\\') > -1 ? '\\' : '/'; return { delim: delim, parts: str.split(delim) }; } function newFrame() { return { results: {}, // response from server (with some of our own context info) packages: {}, // packages organized into statuses for convenience (like with coverage) overall: emptyOverall(), // overall status info, compiled from server's response assertions: emptyAssertions(), // lists of assertions, compiled from server's response failedBuilds: [], // list of packages that failed to build timestamp: moment(), // the timestamp of this "freeze-state" id: convey.frameCounter++, // unique ID for this frame coverDelta: 0 // difference in total coverage from the last frame to this one }; } function emptyOverall() { return { status: {}, duration: 0, assertions: 0, passed: 0, panics: 0, failures: 0, skipped: 0, failedBuilds: 0, coverage: 0 }; } function emptyAssertions() { return { passed: [], failed: [], panicked: [], skipped: [] }; } function makeContext(obj) { obj._passed = 0; obj._failed = 0; obj._panicked = 0; obj._skipped = 0; obj._status = ''; return obj; } function current() { return convey.history[convey.history.length - 1]; } function assignStatus(obj) { if (obj._skipped) obj._status = 'skip'; else if (obj.Outcome === "ignored") obj._status = convey.statuses.ignored; else if (obj._panicked) obj._status = convey.statuses.panic; else if (obj._failed || obj.Outcome === "failed") obj._status = convey.statuses.fail; else obj._status = convey.statuses.pass; } function showCoverDelta(delta) { if (delta > 0) return "+" + delta + "%"; else if (delta === 0) return "±" + delta + "%"; else return delta + "%"; } function customMarkupPipes() { // MARKUP.JS custom pipes Mark.pipes.relativePath = function(str) { basePath = new RegExp($('#path').val()+'[\\/]', 'gi'); return str.replace(basePath, ''); }; Mark.pipes.htmlSafe = function(str) { return str.replace(//g, ">"); }; Mark.pipes.ansiColours = ansispan; Mark.pipes.boldPkgName = function(str) { var pkg = splitPathName(str); pkg.parts[0] = '' + pkg.parts[0]; pkg.parts[pkg.parts.length - 1] = "" + pkg.parts[pkg.parts.length - 1] + ""; return pkg.parts.join(pkg.delim); }; Mark.pipes.needsDiff = function(test) { return !!test.Failure && (test.Expected !== "" || test.Actual !== ""); }; Mark.pipes.coveragePct = function(str) { // Expected input: 75% to be represented as: "75.0" var num = parseInt(str); // we only need int precision if (num < 0) return "0"; else if (num <= 5) return "5px"; // Still shows low coverage else if (num > 100) str = "100"; return str; }; Mark.pipes.coverageDisplay = function(str) { var num = parseFloat(str); return num < 0 ? "" : num + "% coverage"; }; Mark.pipes.coverageReportName = function(str) { return str.replace(/\//g, "-"); }; } function suppress(event) { if (!event) return false; if (event.preventDefault) event.preventDefault(); if (event.stopPropagation) event.stopPropagation(); event.cancelBubble = true; return false; } mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/web/client/resources/js/lib/000077500000000000000000000000001321131462300323125ustar00rootroot00000000000000ansispan.js000066400000000000000000000041671321131462300344150ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/web/client/resources/js/lib/* Copyright (C) 2011 by Maciej MaÅ‚ecki 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. */ var ansispan = function (str) { Object.keys(ansispan.foregroundColors).forEach(function (ansi) { var span = ''; // // `\033[Xm` == `\033[0;Xm` sets foreground color to `X`. // str = str.replace( new RegExp('\033\\[' + ansi + 'm', 'g'), span ).replace( new RegExp('\033\\[0;' + ansi + 'm', 'g'), span ); }); // // `\033[1m` enables bold font, `\033[22m` disables it // str = str.replace(/\033\[1m/g, '').replace(/\033\[22m/g, ''); // // `\033[3m` enables italics font, `\033[23m` disables it // str = str.replace(/\033\[3m/g, '').replace(/\033\[23m/g, ''); str = str.replace(/\033\[m/g, ''); str = str.replace(/\033\[0m/g, ''); return str.replace(/\033\[39m/g, ''); }; ansispan.foregroundColors = { '30': 'black', '31': 'red', '32': 'green', '33': 'yellow', '34': 'blue', '35': 'purple', '36': 'cyan', '37': 'white' }; if (typeof module !== 'undefined' && module.exports) { module.exports = ansispan; } diff-match-patch.min.js000066400000000000000000000453671321131462300364710ustar00rootroot00000000000000mongo-tools-r3.6.3/vendor/src/github.com/smartystreets/goconvey/web/client/resources/js/lib(function(){function diff_match_patch(){this.Diff_Timeout=1;this.Diff_EditCost=4;this.Match_Threshold=0.5;this.Match_Distance=1E3;this.Patch_DeleteThreshold=0.5;this.Patch_Margin=4;this.Match_MaxBits=32} diff_match_patch.prototype.diff_main=function(a,b,c,d){"undefined"==typeof d&&(d=0>=this.Diff_Timeout?Number.MAX_VALUE:(new Date).getTime()+1E3*this.Diff_Timeout);if(null==a||null==b)throw Error("Null input. (diff_main)");if(a==b)return a?[[0,a]]:[];"undefined"==typeof c&&(c=!0);var e=c,f=this.diff_commonPrefix(a,b);c=a.substring(0,f);a=a.substring(f);b=b.substring(f);var f=this.diff_commonSuffix(a,b),g=a.substring(a.length-f);a=a.substring(0,a.length-f);b=b.substring(0,b.length-f);a=this.diff_compute_(a, b,e,d);c&&a.unshift([0,c]);g&&a.push([0,g]);this.diff_cleanupMerge(a);return a}; diff_match_patch.prototype.diff_compute_=function(a,b,c,d){if(!a)return[[1,b]];if(!b)return[[-1,a]];var e=a.length>b.length?a:b,f=a.length>b.length?b:a,g=e.indexOf(f);return-1!=g?(c=[[1,e.substring(0,g)],[0,f],[1,e.substring(g+f.length)]],a.length>b.length&&(c[0][0]=c[2][0]=-1),c):1==f.length?[[-1,a],[1,b]]:(e=this.diff_halfMatch_(a,b))?(f=e[0],a=e[1],g=e[2],b=e[3],e=e[4],f=this.diff_main(f,g,c,d),c=this.diff_main(a,b,c,d),f.concat([[0,e]],c)):c&&100c);v++){for(var n=-v+r;n<=v-t;n+=2){var l=g+n,m;m=n==-v||n!=v&&j[l-1]d)t+=2;else if(s>e)r+=2;else if(q&&(l=g+k-n,0<=l&&l= u)return this.diff_bisectSplit_(a,b,m,s,c)}}for(n=-v+p;n<=v-w;n+=2){l=g+n;u=n==-v||n!=v&&i[l-1]d)w+=2;else if(m>e)p+=2;else if(!q&&(l=g+k-n,0<=l&&(l=u)))return this.diff_bisectSplit_(a,b,m,s,c)}}return[[-1,a],[1,b]]}; diff_match_patch.prototype.diff_bisectSplit_=function(a,b,c,d,e){var f=a.substring(0,c),g=b.substring(0,d);a=a.substring(c);b=b.substring(d);f=this.diff_main(f,g,!1,e);e=this.diff_main(a,b,!1,e);return f.concat(e)}; diff_match_patch.prototype.diff_linesToChars_=function(a,b){function c(a){for(var b="",c=0,f=-1,g=d.length;fd?a=a.substring(c-d):c=a.length?[h,j,n,l,g]:null}if(0>=this.Diff_Timeout)return null; var d=a.length>b.length?a:b,e=a.length>b.length?b:a;if(4>d.length||2*e.lengthd[4].length?g:d:d:g;var j;a.length>b.length?(g=h[0],d=h[1],e=h[2],j=h[3]):(e=h[0],j=h[1],g=h[2],d=h[3]);h=h[4];return[g,d,e,j,h]}; diff_match_patch.prototype.diff_cleanupSemantic=function(a){for(var b=!1,c=[],d=0,e=null,f=0,g=0,h=0,j=0,i=0;f=e){if(d>=b.length/2||d>=c.length/2)a.splice(f,0,[0,c.substring(0,d)]),a[f-1][1]=b.substring(0,b.length-d),a[f+1][1]=c.substring(d),f++}else if(e>=b.length/2||e>=c.length/2)a.splice(f,0,[0,b.substring(0,e)]),a[f-1][0]=1,a[f-1][1]=c.substring(0,c.length-e),a[f+1][0]=-1,a[f+1][1]=b.substring(e),f++;f++}f++}}; diff_match_patch.prototype.diff_cleanupSemanticLossless=function(a){function b(a,b){if(!a||!b)return 6;var c=a.charAt(a.length-1),d=b.charAt(0),e=c.match(diff_match_patch.nonAlphaNumericRegex_),f=d.match(diff_match_patch.nonAlphaNumericRegex_),g=e&&c.match(diff_match_patch.whitespaceRegex_),h=f&&d.match(diff_match_patch.whitespaceRegex_),c=g&&c.match(diff_match_patch.linebreakRegex_),d=h&&d.match(diff_match_patch.linebreakRegex_),i=c&&a.match(diff_match_patch.blanklineEndRegex_),j=d&&b.match(diff_match_patch.blanklineStartRegex_); return i||j?5:c||d?4:e&&!g&&h?3:g||h?2:e||f?1:0}for(var c=1;c=i&&(i=k,g=d,h=e,j=f)}a[c-1][1]!=g&&(g?a[c-1][1]=g:(a.splice(c-1,1),c--),a[c][1]= h,j?a[c+1][1]=j:(a.splice(c+1,1),c--))}c++}};diff_match_patch.nonAlphaNumericRegex_=/[^a-zA-Z0-9]/;diff_match_patch.whitespaceRegex_=/\s/;diff_match_patch.linebreakRegex_=/[\r\n]/;diff_match_patch.blanklineEndRegex_=/\n\r?\n$/;diff_match_patch.blanklineStartRegex_=/^\r?\n\r?\n/; diff_match_patch.prototype.diff_cleanupEfficiency=function(a){for(var b=!1,c=[],d=0,e=null,f=0,g=!1,h=!1,j=!1,i=!1;fb)break;e=c;f=d}return a.length!=g&&-1===a[g][0]?f:f+(b-e)}; diff_match_patch.prototype.diff_prettyHtml=function(a){for(var b=[],c=/&/g,d=//g,f=/\n/g,g=0;g");switch(h){case 1:b[g]=''+j+"";break;case -1:b[g]=''+j+"";break;case 0:b[g]=""+j+""}}return b.join("")}; diff_match_patch.prototype.diff_text1=function(a){for(var b=[],c=0;cthis.Match_MaxBits)throw Error("Pattern too long for this browser.");var e=this.match_alphabet_(b),f=this,g=this.Match_Threshold,h=a.indexOf(b,c);-1!=h&&(g=Math.min(d(0,h),g),h=a.lastIndexOf(b,c+b.length),-1!=h&&(g=Math.min(d(0,h),g)));for(var j=1<=i;p--){var w=e[a.charAt(p-1)];k[p]=0===t?(k[p+1]<<1|1)&w:(k[p+1]<<1|1)&w|((r[p+1]|r[p])<<1|1)|r[p+1];if(k[p]&j&&(w=d(t,p-1),w<=g))if(g=w,h=p-1,h>c)i=Math.max(1,2*c-h);else break}if(d(t+1,c)>g)break;r=k}return h}; diff_match_patch.prototype.match_alphabet_=function(a){for(var b={},c=0;c=2*this.Patch_Margin&& e&&(this.patch_addContext_(a,h),c.push(a),a=new diff_match_patch.patch_obj,e=0,h=d,f=g)}1!==i&&(f+=k.length);-1!==i&&(g+=k.length)}e&&(this.patch_addContext_(a,h),c.push(a));return c};diff_match_patch.prototype.patch_deepCopy=function(a){for(var b=[],c=0;cthis.Match_MaxBits){if(j=this.match_main(b,h.substring(0,this.Match_MaxBits),g),-1!=j&&(i=this.match_main(b,h.substring(h.length-this.Match_MaxBits),g+h.length-this.Match_MaxBits),-1==i||j>=i))j=-1}else j=this.match_main(b,h,g); if(-1==j)e[f]=!1,d-=a[f].length2-a[f].length1;else if(e[f]=!0,d=j-g,g=-1==i?b.substring(j,j+h.length):b.substring(j,i+this.Match_MaxBits),h==g)b=b.substring(0,j)+this.diff_text2(a[f].diffs)+b.substring(j+h.length);else if(g=this.diff_main(h,g,!1),h.length>this.Match_MaxBits&&this.diff_levenshtein(g)/h.length>this.Patch_DeleteThreshold)e[f]=!1;else{this.diff_cleanupSemanticLossless(g);for(var h=0,k,i=0;ie[0][1].length){var f=b-e[0][1].length;e[0][1]=c.substring(e[0][1].length)+e[0][1];d.start1-=f;d.start2-=f;d.length1+=f;d.length2+=f}d=a[a.length-1];e=d.diffs;0==e.length||0!=e[e.length-1][0]?(e.push([0, c]),d.length1+=b,d.length2+=b):b>e[e.length-1][1].length&&(f=b-e[e.length-1][1].length,e[e.length-1][1]+=c.substring(0,f),d.length1+=f,d.length2+=f);return c}; diff_match_patch.prototype.patch_splitMax=function(a){for(var b=this.Match_MaxBits,c=0;c2*b?(h.length1+=i.length,e+=i.length,j=!1,h.diffs.push([g,i]),d.diffs.shift()):(i=i.substring(0,b-h.length1-this.Patch_Margin),h.length1+=i.length,e+=i.length,0===g?(h.length2+=i.length,f+=i.length):j=!1,h.diffs.push([g,i]),i==d.diffs[0][1]?d.diffs.shift():d.diffs[0][1]=d.diffs[0][1].substring(i.length))}g=this.diff_text2(h.diffs);g=g.substring(g.length-this.Patch_Margin);i=this.diff_text1(d.diffs).substring(0,this.Patch_Margin);""!==i&& (h.length1+=i.length,h.length2+=i.length,0!==h.diffs.length&&0===h.diffs[h.diffs.length-1][0]?h.diffs[h.diffs.length-1][1]+=i:h.diffs.push([0,i]));j||a.splice(++c,0,h)}}};diff_match_patch.prototype.patch_toText=function(a){for(var b=[],c=0;ca?this[a+this.length]:this[a]:d.call(this)},pushStack:function(a){var b=o.merge(this.constructor(),a);return b.prevObject=this,b.context=this.context,b},each:function(a,b){return o.each(this,a,b)},map:function(a){return this.pushStack(o.map(this,function(b,c){return a.call(b,c,b)}))},slice:function(){return this.pushStack(d.apply(this,arguments))},first:function(){return this.eq(0)},last:function(){return this.eq(-1)},eq:function(a){var b=this.length,c=+a+(0>a?b:0);return this.pushStack(c>=0&&b>c?[this[c]]:[])},end:function(){return this.prevObject||this.constructor(null)},push:f,sort:c.sort,splice:c.splice},o.extend=o.fn.extend=function(){var a,b,c,d,e,f,g=arguments[0]||{},h=1,i=arguments.length,j=!1;for("boolean"==typeof g&&(j=g,g=arguments[h]||{},h++),"object"==typeof g||o.isFunction(g)||(g={}),h===i&&(g=this,h--);i>h;h++)if(null!=(a=arguments[h]))for(b in a)c=g[b],d=a[b],g!==d&&(j&&d&&(o.isPlainObject(d)||(e=o.isArray(d)))?(e?(e=!1,f=c&&o.isArray(c)?c:[]):f=c&&o.isPlainObject(c)?c:{},g[b]=o.extend(j,f,d)):void 0!==d&&(g[b]=d));return g},o.extend({expando:"jQuery"+(n+Math.random()).replace(/\D/g,""),isReady:!0,error:function(a){throw new Error(a)},noop:function(){},isFunction:function(a){return"function"===o.type(a)},isArray:Array.isArray,isWindow:function(a){return null!=a&&a===a.window},isNumeric:function(a){return a-parseFloat(a)>=0},isPlainObject:function(a){if("object"!==o.type(a)||a.nodeType||o.isWindow(a))return!1;try{if(a.constructor&&!j.call(a.constructor.prototype,"isPrototypeOf"))return!1}catch(b){return!1}return!0},isEmptyObject:function(a){var b;for(b in a)return!1;return!0},type:function(a){return null==a?a+"":"object"==typeof a||"function"==typeof a?h[i.call(a)]||"object":typeof a},globalEval:function(a){var b,c=eval;a=o.trim(a),a&&(1===a.indexOf("use strict")?(b=m.createElement("script"),b.text=a,m.head.appendChild(b).parentNode.removeChild(b)):c(a))},camelCase:function(a){return a.replace(p,"ms-").replace(q,r)},nodeName:function(a,b){return a.nodeName&&a.nodeName.toLowerCase()===b.toLowerCase()},each:function(a,b,c){var d,e=0,f=a.length,g=s(a);if(c){if(g){for(;f>e;e++)if(d=b.apply(a[e],c),d===!1)break}else for(e in a)if(d=b.apply(a[e],c),d===!1)break}else if(g){for(;f>e;e++)if(d=b.call(a[e],e,a[e]),d===!1)break}else for(e in a)if(d=b.call(a[e],e,a[e]),d===!1)break;return a},trim:function(a){return null==a?"":k.call(a)},makeArray:function(a,b){var c=b||[];return null!=a&&(s(Object(a))?o.merge(c,"string"==typeof a?[a]:a):f.call(c,a)),c},inArray:function(a,b,c){return null==b?-1:g.call(b,a,c)},merge:function(a,b){for(var c=+b.length,d=0,e=a.length;c>d;d++)a[e++]=b[d];return a.length=e,a},grep:function(a,b,c){for(var d,e=[],f=0,g=a.length,h=!c;g>f;f++)d=!b(a[f],f),d!==h&&e.push(a[f]);return e},map:function(a,b,c){var d,f=0,g=a.length,h=s(a),i=[];if(h)for(;g>f;f++)d=b(a[f],f,c),null!=d&&i.push(d);else for(f in a)d=b(a[f],f,c),null!=d&&i.push(d);return e.apply([],i)},guid:1,proxy:function(a,b){var c,e,f;return"string"==typeof b&&(c=a[b],b=a,a=c),o.isFunction(a)?(e=d.call(arguments,2),f=function(){return a.apply(b||this,e.concat(d.call(arguments)))},f.guid=a.guid=a.guid||o.guid++,f):void 0},now:Date.now,support:l}),o.each("Boolean Number String Function Array Date RegExp Object Error".split(" "),function(a,b){h["[object "+b+"]"]=b.toLowerCase()});function s(a){var b=a.length,c=o.type(a);return"function"===c||o.isWindow(a)?!1:1===a.nodeType&&b?!0:"array"===c||0===b||"number"==typeof b&&b>0&&b-1 in a}var t=function(a){var b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s="sizzle"+-new Date,t=a.document,u=0,v=0,w=eb(),x=eb(),y=eb(),z=function(a,b){return a===b&&(j=!0),0},A="undefined",B=1<<31,C={}.hasOwnProperty,D=[],E=D.pop,F=D.push,G=D.push,H=D.slice,I=D.indexOf||function(a){for(var b=0,c=this.length;c>b;b++)if(this[b]===a)return b;return-1},J="checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped",K="[\\x20\\t\\r\\n\\f]",L="(?:\\\\.|[\\w-]|[^\\x00-\\xa0])+",M=L.replace("w","w#"),N="\\["+K+"*("+L+")"+K+"*(?:([*^$|!~]?=)"+K+"*(?:(['\"])((?:\\\\.|[^\\\\])*?)\\3|("+M+")|)|)"+K+"*\\]",O=":("+L+")(?:\\(((['\"])((?:\\\\.|[^\\\\])*?)\\3|((?:\\\\.|[^\\\\()[\\]]|"+N.replace(3,8)+")*)|.*)\\)|)",P=new RegExp("^"+K+"+|((?:^|[^\\\\])(?:\\\\.)*)"+K+"+$","g"),Q=new RegExp("^"+K+"*,"+K+"*"),R=new RegExp("^"+K+"*([>+~]|"+K+")"+K+"*"),S=new RegExp("="+K+"*([^\\]'\"]*?)"+K+"*\\]","g"),T=new RegExp(O),U=new RegExp("^"+M+"$"),V={ID:new RegExp("^#("+L+")"),CLASS:new RegExp("^\\.("+L+")"),TAG:new RegExp("^("+L.replace("w","w*")+")"),ATTR:new RegExp("^"+N),PSEUDO:new RegExp("^"+O),CHILD:new RegExp("^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\("+K+"*(even|odd|(([+-]|)(\\d*)n|)"+K+"*(?:([+-]|)"+K+"*(\\d+)|))"+K+"*\\)|)","i"),bool:new RegExp("^(?:"+J+")$","i"),needsContext:new RegExp("^"+K+"*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\("+K+"*((?:-\\d)?\\d*)"+K+"*\\)|)(?=[^-]|$)","i")},W=/^(?:input|select|textarea|button)$/i,X=/^h\d$/i,Y=/^[^{]+\{\s*\[native \w/,Z=/^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,$=/[+~]/,_=/'|\\/g,ab=new RegExp("\\\\([\\da-f]{1,6}"+K+"?|("+K+")|.)","ig"),bb=function(a,b,c){var d="0x"+b-65536;return d!==d||c?b:0>d?String.fromCharCode(d+65536):String.fromCharCode(d>>10|55296,1023&d|56320)};try{G.apply(D=H.call(t.childNodes),t.childNodes),D[t.childNodes.length].nodeType}catch(cb){G={apply:D.length?function(a,b){F.apply(a,H.call(b))}:function(a,b){var c=a.length,d=0;while(a[c++]=b[d++]);a.length=c-1}}}function db(a,b,d,e){var f,g,h,i,j,m,p,q,u,v;if((b?b.ownerDocument||b:t)!==l&&k(b),b=b||l,d=d||[],!a||"string"!=typeof a)return d;if(1!==(i=b.nodeType)&&9!==i)return[];if(n&&!e){if(f=Z.exec(a))if(h=f[1]){if(9===i){if(g=b.getElementById(h),!g||!g.parentNode)return d;if(g.id===h)return d.push(g),d}else if(b.ownerDocument&&(g=b.ownerDocument.getElementById(h))&&r(b,g)&&g.id===h)return d.push(g),d}else{if(f[2])return G.apply(d,b.getElementsByTagName(a)),d;if((h=f[3])&&c.getElementsByClassName&&b.getElementsByClassName)return G.apply(d,b.getElementsByClassName(h)),d}if(c.qsa&&(!o||!o.test(a))){if(q=p=s,u=b,v=9===i&&a,1===i&&"object"!==b.nodeName.toLowerCase()){m=ob(a),(p=b.getAttribute("id"))?q=p.replace(_,"\\$&"):b.setAttribute("id",q),q="[id='"+q+"'] ",j=m.length;while(j--)m[j]=q+pb(m[j]);u=$.test(a)&&mb(b.parentNode)||b,v=m.join(",")}if(v)try{return G.apply(d,u.querySelectorAll(v)),d}catch(w){}finally{p||b.removeAttribute("id")}}}return xb(a.replace(P,"$1"),b,d,e)}function eb(){var a=[];function b(c,e){return a.push(c+" ")>d.cacheLength&&delete b[a.shift()],b[c+" "]=e}return b}function fb(a){return a[s]=!0,a}function gb(a){var b=l.createElement("div");try{return!!a(b)}catch(c){return!1}finally{b.parentNode&&b.parentNode.removeChild(b),b=null}}function hb(a,b){var c=a.split("|"),e=a.length;while(e--)d.attrHandle[c[e]]=b}function ib(a,b){var c=b&&a,d=c&&1===a.nodeType&&1===b.nodeType&&(~b.sourceIndex||B)-(~a.sourceIndex||B);if(d)return d;if(c)while(c=c.nextSibling)if(c===b)return-1;return a?1:-1}function jb(a){return function(b){var c=b.nodeName.toLowerCase();return"input"===c&&b.type===a}}function kb(a){return function(b){var c=b.nodeName.toLowerCase();return("input"===c||"button"===c)&&b.type===a}}function lb(a){return fb(function(b){return b=+b,fb(function(c,d){var e,f=a([],c.length,b),g=f.length;while(g--)c[e=f[g]]&&(c[e]=!(d[e]=c[e]))})})}function mb(a){return a&&typeof a.getElementsByTagName!==A&&a}c=db.support={},f=db.isXML=function(a){var b=a&&(a.ownerDocument||a).documentElement;return b?"HTML"!==b.nodeName:!1},k=db.setDocument=function(a){var b,e=a?a.ownerDocument||a:t,g=e.defaultView;return e!==l&&9===e.nodeType&&e.documentElement?(l=e,m=e.documentElement,n=!f(e),g&&g!==g.top&&(g.addEventListener?g.addEventListener("unload",function(){k()},!1):g.attachEvent&&g.attachEvent("onunload",function(){k()})),c.attributes=gb(function(a){return a.className="i",!a.getAttribute("className")}),c.getElementsByTagName=gb(function(a){return a.appendChild(e.createComment("")),!a.getElementsByTagName("*").length}),c.getElementsByClassName=Y.test(e.getElementsByClassName)&&gb(function(a){return a.innerHTML="
",a.firstChild.className="i",2===a.getElementsByClassName("i").length}),c.getById=gb(function(a){return m.appendChild(a).id=s,!e.getElementsByName||!e.getElementsByName(s).length}),c.getById?(d.find.ID=function(a,b){if(typeof b.getElementById!==A&&n){var c=b.getElementById(a);return c&&c.parentNode?[c]:[]}},d.filter.ID=function(a){var b=a.replace(ab,bb);return function(a){return a.getAttribute("id")===b}}):(delete d.find.ID,d.filter.ID=function(a){var b=a.replace(ab,bb);return function(a){var c=typeof a.getAttributeNode!==A&&a.getAttributeNode("id");return c&&c.value===b}}),d.find.TAG=c.getElementsByTagName?function(a,b){return typeof b.getElementsByTagName!==A?b.getElementsByTagName(a):void 0}:function(a,b){var c,d=[],e=0,f=b.getElementsByTagName(a);if("*"===a){while(c=f[e++])1===c.nodeType&&d.push(c);return d}return f},d.find.CLASS=c.getElementsByClassName&&function(a,b){return typeof b.getElementsByClassName!==A&&n?b.getElementsByClassName(a):void 0},p=[],o=[],(c.qsa=Y.test(e.querySelectorAll))&&(gb(function(a){a.innerHTML="",a.querySelectorAll("[t^='']").length&&o.push("[*^$]="+K+"*(?:''|\"\")"),a.querySelectorAll("[selected]").length||o.push("\\["+K+"*(?:value|"+J+")"),a.querySelectorAll(":checked").length||o.push(":checked")}),gb(function(a){var b=e.createElement("input");b.setAttribute("type","hidden"),a.appendChild(b).setAttribute("name","D"),a.querySelectorAll("[name=d]").length&&o.push("name"+K+"*[*^$|!~]?="),a.querySelectorAll(":enabled").length||o.push(":enabled",":disabled"),a.querySelectorAll("*,:x"),o.push(",.*:")})),(c.matchesSelector=Y.test(q=m.webkitMatchesSelector||m.mozMatchesSelector||m.oMatchesSelector||m.msMatchesSelector))&&gb(function(a){c.disconnectedMatch=q.call(a,"div"),q.call(a,"[s!='']:x"),p.push("!=",O)}),o=o.length&&new RegExp(o.join("|")),p=p.length&&new RegExp(p.join("|")),b=Y.test(m.compareDocumentPosition),r=b||Y.test(m.contains)?function(a,b){var c=9===a.nodeType?a.documentElement:a,d=b&&b.parentNode;return a===d||!(!d||1!==d.nodeType||!(c.contains?c.contains(d):a.compareDocumentPosition&&16&a.compareDocumentPosition(d)))}:function(a,b){if(b)while(b=b.parentNode)if(b===a)return!0;return!1},z=b?function(a,b){if(a===b)return j=!0,0;var d=!a.compareDocumentPosition-!b.compareDocumentPosition;return d?d:(d=(a.ownerDocument||a)===(b.ownerDocument||b)?a.compareDocumentPosition(b):1,1&d||!c.sortDetached&&b.compareDocumentPosition(a)===d?a===e||a.ownerDocument===t&&r(t,a)?-1:b===e||b.ownerDocument===t&&r(t,b)?1:i?I.call(i,a)-I.call(i,b):0:4&d?-1:1)}:function(a,b){if(a===b)return j=!0,0;var c,d=0,f=a.parentNode,g=b.parentNode,h=[a],k=[b];if(!f||!g)return a===e?-1:b===e?1:f?-1:g?1:i?I.call(i,a)-I.call(i,b):0;if(f===g)return ib(a,b);c=a;while(c=c.parentNode)h.unshift(c);c=b;while(c=c.parentNode)k.unshift(c);while(h[d]===k[d])d++;return d?ib(h[d],k[d]):h[d]===t?-1:k[d]===t?1:0},e):l},db.matches=function(a,b){return db(a,null,null,b)},db.matchesSelector=function(a,b){if((a.ownerDocument||a)!==l&&k(a),b=b.replace(S,"='$1']"),!(!c.matchesSelector||!n||p&&p.test(b)||o&&o.test(b)))try{var d=q.call(a,b);if(d||c.disconnectedMatch||a.document&&11!==a.document.nodeType)return d}catch(e){}return db(b,l,null,[a]).length>0},db.contains=function(a,b){return(a.ownerDocument||a)!==l&&k(a),r(a,b)},db.attr=function(a,b){(a.ownerDocument||a)!==l&&k(a);var e=d.attrHandle[b.toLowerCase()],f=e&&C.call(d.attrHandle,b.toLowerCase())?e(a,b,!n):void 0;return void 0!==f?f:c.attributes||!n?a.getAttribute(b):(f=a.getAttributeNode(b))&&f.specified?f.value:null},db.error=function(a){throw new Error("Syntax error, unrecognized expression: "+a)},db.uniqueSort=function(a){var b,d=[],e=0,f=0;if(j=!c.detectDuplicates,i=!c.sortStable&&a.slice(0),a.sort(z),j){while(b=a[f++])b===a[f]&&(e=d.push(f));while(e--)a.splice(d[e],1)}return i=null,a},e=db.getText=function(a){var b,c="",d=0,f=a.nodeType;if(f){if(1===f||9===f||11===f){if("string"==typeof a.textContent)return a.textContent;for(a=a.firstChild;a;a=a.nextSibling)c+=e(a)}else if(3===f||4===f)return a.nodeValue}else while(b=a[d++])c+=e(b);return c},d=db.selectors={cacheLength:50,createPseudo:fb,match:V,attrHandle:{},find:{},relative:{">":{dir:"parentNode",first:!0}," ":{dir:"parentNode"},"+":{dir:"previousSibling",first:!0},"~":{dir:"previousSibling"}},preFilter:{ATTR:function(a){return a[1]=a[1].replace(ab,bb),a[3]=(a[4]||a[5]||"").replace(ab,bb),"~="===a[2]&&(a[3]=" "+a[3]+" "),a.slice(0,4)},CHILD:function(a){return a[1]=a[1].toLowerCase(),"nth"===a[1].slice(0,3)?(a[3]||db.error(a[0]),a[4]=+(a[4]?a[5]+(a[6]||1):2*("even"===a[3]||"odd"===a[3])),a[5]=+(a[7]+a[8]||"odd"===a[3])):a[3]&&db.error(a[0]),a},PSEUDO:function(a){var b,c=!a[5]&&a[2];return V.CHILD.test(a[0])?null:(a[3]&&void 0!==a[4]?a[2]=a[4]:c&&T.test(c)&&(b=ob(c,!0))&&(b=c.indexOf(")",c.length-b)-c.length)&&(a[0]=a[0].slice(0,b),a[2]=c.slice(0,b)),a.slice(0,3))}},filter:{TAG:function(a){var b=a.replace(ab,bb).toLowerCase();return"*"===a?function(){return!0}:function(a){return a.nodeName&&a.nodeName.toLowerCase()===b}},CLASS:function(a){var b=w[a+" "];return b||(b=new RegExp("(^|"+K+")"+a+"("+K+"|$)"))&&w(a,function(a){return b.test("string"==typeof a.className&&a.className||typeof a.getAttribute!==A&&a.getAttribute("class")||"")})},ATTR:function(a,b,c){return function(d){var e=db.attr(d,a);return null==e?"!="===b:b?(e+="","="===b?e===c:"!="===b?e!==c:"^="===b?c&&0===e.indexOf(c):"*="===b?c&&e.indexOf(c)>-1:"$="===b?c&&e.slice(-c.length)===c:"~="===b?(" "+e+" ").indexOf(c)>-1:"|="===b?e===c||e.slice(0,c.length+1)===c+"-":!1):!0}},CHILD:function(a,b,c,d,e){var f="nth"!==a.slice(0,3),g="last"!==a.slice(-4),h="of-type"===b;return 1===d&&0===e?function(a){return!!a.parentNode}:function(b,c,i){var j,k,l,m,n,o,p=f!==g?"nextSibling":"previousSibling",q=b.parentNode,r=h&&b.nodeName.toLowerCase(),t=!i&&!h;if(q){if(f){while(p){l=b;while(l=l[p])if(h?l.nodeName.toLowerCase()===r:1===l.nodeType)return!1;o=p="only"===a&&!o&&"nextSibling"}return!0}if(o=[g?q.firstChild:q.lastChild],g&&t){k=q[s]||(q[s]={}),j=k[a]||[],n=j[0]===u&&j[1],m=j[0]===u&&j[2],l=n&&q.childNodes[n];while(l=++n&&l&&l[p]||(m=n=0)||o.pop())if(1===l.nodeType&&++m&&l===b){k[a]=[u,n,m];break}}else if(t&&(j=(b[s]||(b[s]={}))[a])&&j[0]===u)m=j[1];else while(l=++n&&l&&l[p]||(m=n=0)||o.pop())if((h?l.nodeName.toLowerCase()===r:1===l.nodeType)&&++m&&(t&&((l[s]||(l[s]={}))[a]=[u,m]),l===b))break;return m-=e,m===d||m%d===0&&m/d>=0}}},PSEUDO:function(a,b){var c,e=d.pseudos[a]||d.setFilters[a.toLowerCase()]||db.error("unsupported pseudo: "+a);return e[s]?e(b):e.length>1?(c=[a,a,"",b],d.setFilters.hasOwnProperty(a.toLowerCase())?fb(function(a,c){var d,f=e(a,b),g=f.length;while(g--)d=I.call(a,f[g]),a[d]=!(c[d]=f[g])}):function(a){return e(a,0,c)}):e}},pseudos:{not:fb(function(a){var b=[],c=[],d=g(a.replace(P,"$1"));return d[s]?fb(function(a,b,c,e){var f,g=d(a,null,e,[]),h=a.length;while(h--)(f=g[h])&&(a[h]=!(b[h]=f))}):function(a,e,f){return b[0]=a,d(b,null,f,c),!c.pop()}}),has:fb(function(a){return function(b){return db(a,b).length>0}}),contains:fb(function(a){return function(b){return(b.textContent||b.innerText||e(b)).indexOf(a)>-1}}),lang:fb(function(a){return U.test(a||"")||db.error("unsupported lang: "+a),a=a.replace(ab,bb).toLowerCase(),function(b){var c;do if(c=n?b.lang:b.getAttribute("xml:lang")||b.getAttribute("lang"))return c=c.toLowerCase(),c===a||0===c.indexOf(a+"-");while((b=b.parentNode)&&1===b.nodeType);return!1}}),target:function(b){var c=a.location&&a.location.hash;return c&&c.slice(1)===b.id},root:function(a){return a===m},focus:function(a){return a===l.activeElement&&(!l.hasFocus||l.hasFocus())&&!!(a.type||a.href||~a.tabIndex)},enabled:function(a){return a.disabled===!1},disabled:function(a){return a.disabled===!0},checked:function(a){var b=a.nodeName.toLowerCase();return"input"===b&&!!a.checked||"option"===b&&!!a.selected},selected:function(a){return a.parentNode&&a.parentNode.selectedIndex,a.selected===!0},empty:function(a){for(a=a.firstChild;a;a=a.nextSibling)if(a.nodeType<6)return!1;return!0},parent:function(a){return!d.pseudos.empty(a)},header:function(a){return X.test(a.nodeName)},input:function(a){return W.test(a.nodeName)},button:function(a){var b=a.nodeName.toLowerCase();return"input"===b&&"button"===a.type||"button"===b},text:function(a){var b;return"input"===a.nodeName.toLowerCase()&&"text"===a.type&&(null==(b=a.getAttribute("type"))||"text"===b.toLowerCase())},first:lb(function(){return[0]}),last:lb(function(a,b){return[b-1]}),eq:lb(function(a,b,c){return[0>c?c+b:c]}),even:lb(function(a,b){for(var c=0;b>c;c+=2)a.push(c);return a}),odd:lb(function(a,b){for(var c=1;b>c;c+=2)a.push(c);return a}),lt:lb(function(a,b,c){for(var d=0>c?c+b:c;--d>=0;)a.push(d);return a}),gt:lb(function(a,b,c){for(var d=0>c?c+b:c;++db;b++)d+=a[b].value;return d}function qb(a,b,c){var d=b.dir,e=c&&"parentNode"===d,f=v++;return b.first?function(b,c,f){while(b=b[d])if(1===b.nodeType||e)return a(b,c,f)}:function(b,c,g){var h,i,j=[u,f];if(g){while(b=b[d])if((1===b.nodeType||e)&&a(b,c,g))return!0}else while(b=b[d])if(1===b.nodeType||e){if(i=b[s]||(b[s]={}),(h=i[d])&&h[0]===u&&h[1]===f)return j[2]=h[2];if(i[d]=j,j[2]=a(b,c,g))return!0}}}function rb(a){return a.length>1?function(b,c,d){var e=a.length;while(e--)if(!a[e](b,c,d))return!1;return!0}:a[0]}function sb(a,b,c,d,e){for(var f,g=[],h=0,i=a.length,j=null!=b;i>h;h++)(f=a[h])&&(!c||c(f,d,e))&&(g.push(f),j&&b.push(h));return g}function tb(a,b,c,d,e,f){return d&&!d[s]&&(d=tb(d)),e&&!e[s]&&(e=tb(e,f)),fb(function(f,g,h,i){var j,k,l,m=[],n=[],o=g.length,p=f||wb(b||"*",h.nodeType?[h]:h,[]),q=!a||!f&&b?p:sb(p,m,a,h,i),r=c?e||(f?a:o||d)?[]:g:q;if(c&&c(q,r,h,i),d){j=sb(r,n),d(j,[],h,i),k=j.length;while(k--)(l=j[k])&&(r[n[k]]=!(q[n[k]]=l))}if(f){if(e||a){if(e){j=[],k=r.length;while(k--)(l=r[k])&&j.push(q[k]=l);e(null,r=[],j,i)}k=r.length;while(k--)(l=r[k])&&(j=e?I.call(f,l):m[k])>-1&&(f[j]=!(g[j]=l))}}else r=sb(r===g?r.splice(o,r.length):r),e?e(null,g,r,i):G.apply(g,r)})}function ub(a){for(var b,c,e,f=a.length,g=d.relative[a[0].type],i=g||d.relative[" "],j=g?1:0,k=qb(function(a){return a===b},i,!0),l=qb(function(a){return I.call(b,a)>-1},i,!0),m=[function(a,c,d){return!g&&(d||c!==h)||((b=c).nodeType?k(a,c,d):l(a,c,d))}];f>j;j++)if(c=d.relative[a[j].type])m=[qb(rb(m),c)];else{if(c=d.filter[a[j].type].apply(null,a[j].matches),c[s]){for(e=++j;f>e;e++)if(d.relative[a[e].type])break;return tb(j>1&&rb(m),j>1&&pb(a.slice(0,j-1).concat({value:" "===a[j-2].type?"*":""})).replace(P,"$1"),c,e>j&&ub(a.slice(j,e)),f>e&&ub(a=a.slice(e)),f>e&&pb(a))}m.push(c)}return rb(m)}function vb(a,b){var c=b.length>0,e=a.length>0,f=function(f,g,i,j,k){var m,n,o,p=0,q="0",r=f&&[],s=[],t=h,v=f||e&&d.find.TAG("*",k),w=u+=null==t?1:Math.random()||.1,x=v.length;for(k&&(h=g!==l&&g);q!==x&&null!=(m=v[q]);q++){if(e&&m){n=0;while(o=a[n++])if(o(m,g,i)){j.push(m);break}k&&(u=w)}c&&((m=!o&&m)&&p--,f&&r.push(m))}if(p+=q,c&&q!==p){n=0;while(o=b[n++])o(r,s,g,i);if(f){if(p>0)while(q--)r[q]||s[q]||(s[q]=E.call(j));s=sb(s)}G.apply(j,s),k&&!f&&s.length>0&&p+b.length>1&&db.uniqueSort(j)}return k&&(u=w,h=t),r};return c?fb(f):f}g=db.compile=function(a,b){var c,d=[],e=[],f=y[a+" "];if(!f){b||(b=ob(a)),c=b.length;while(c--)f=ub(b[c]),f[s]?d.push(f):e.push(f);f=y(a,vb(e,d))}return f};function wb(a,b,c){for(var d=0,e=b.length;e>d;d++)db(a,b[d],c);return c}function xb(a,b,e,f){var h,i,j,k,l,m=ob(a);if(!f&&1===m.length){if(i=m[0]=m[0].slice(0),i.length>2&&"ID"===(j=i[0]).type&&c.getById&&9===b.nodeType&&n&&d.relative[i[1].type]){if(b=(d.find.ID(j.matches[0].replace(ab,bb),b)||[])[0],!b)return e;a=a.slice(i.shift().value.length)}h=V.needsContext.test(a)?0:i.length;while(h--){if(j=i[h],d.relative[k=j.type])break;if((l=d.find[k])&&(f=l(j.matches[0].replace(ab,bb),$.test(i[0].type)&&mb(b.parentNode)||b))){if(i.splice(h,1),a=f.length&&pb(i),!a)return G.apply(e,f),e;break}}}return g(a,m)(f,b,!n,e,$.test(a)&&mb(b.parentNode)||b),e}return c.sortStable=s.split("").sort(z).join("")===s,c.detectDuplicates=!!j,k(),c.sortDetached=gb(function(a){return 1&a.compareDocumentPosition(l.createElement("div"))}),gb(function(a){return a.innerHTML="","#"===a.firstChild.getAttribute("href")})||hb("type|href|height|width",function(a,b,c){return c?void 0:a.getAttribute(b,"type"===b.toLowerCase()?1:2)}),c.attributes&&gb(function(a){return a.innerHTML="",a.firstChild.setAttribute("value",""),""===a.firstChild.getAttribute("value")})||hb("value",function(a,b,c){return c||"input"!==a.nodeName.toLowerCase()?void 0:a.defaultValue}),gb(function(a){return null==a.getAttribute("disabled")})||hb(J,function(a,b,c){var d;return c?void 0:a[b]===!0?b.toLowerCase():(d=a.getAttributeNode(b))&&d.specified?d.value:null}),db}(a);o.find=t,o.expr=t.selectors,o.expr[":"]=o.expr.pseudos,o.unique=t.uniqueSort,o.text=t.getText,o.isXMLDoc=t.isXML,o.contains=t.contains;var u=o.expr.match.needsContext,v=/^<(\w+)\s*\/?>(?:<\/\1>|)$/,w=/^.[^:#\[\.,]*$/;function x(a,b,c){if(o.isFunction(b))return o.grep(a,function(a,d){return!!b.call(a,d,a)!==c});if(b.nodeType)return o.grep(a,function(a){return a===b!==c});if("string"==typeof b){if(w.test(b))return o.filter(b,a,c);b=o.filter(b,a)}return o.grep(a,function(a){return g.call(b,a)>=0!==c})}o.filter=function(a,b,c){var d=b[0];return c&&(a=":not("+a+")"),1===b.length&&1===d.nodeType?o.find.matchesSelector(d,a)?[d]:[]:o.find.matches(a,o.grep(b,function(a){return 1===a.nodeType}))},o.fn.extend({find:function(a){var b,c=this.length,d=[],e=this;if("string"!=typeof a)return this.pushStack(o(a).filter(function(){for(b=0;c>b;b++)if(o.contains(e[b],this))return!0}));for(b=0;c>b;b++)o.find(a,e[b],d);return d=this.pushStack(c>1?o.unique(d):d),d.selector=this.selector?this.selector+" "+a:a,d},filter:function(a){return this.pushStack(x(this,a||[],!1))},not:function(a){return this.pushStack(x(this,a||[],!0))},is:function(a){return!!x(this,"string"==typeof a&&u.test(a)?o(a):a||[],!1).length}});var y,z=/^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]*))$/,A=o.fn.init=function(a,b){var c,d;if(!a)return this;if("string"==typeof a){if(c="<"===a[0]&&">"===a[a.length-1]&&a.length>=3?[null,a,null]:z.exec(a),!c||!c[1]&&b)return!b||b.jquery?(b||y).find(a):this.constructor(b).find(a);if(c[1]){if(b=b instanceof o?b[0]:b,o.merge(this,o.parseHTML(c[1],b&&b.nodeType?b.ownerDocument||b:m,!0)),v.test(c[1])&&o.isPlainObject(b))for(c in b)o.isFunction(this[c])?this[c](b[c]):this.attr(c,b[c]);return this}return d=m.getElementById(c[2]),d&&d.parentNode&&(this.length=1,this[0]=d),this.context=m,this.selector=a,this}return a.nodeType?(this.context=this[0]=a,this.length=1,this):o.isFunction(a)?"undefined"!=typeof y.ready?y.ready(a):a(o):(void 0!==a.selector&&(this.selector=a.selector,this.context=a.context),o.makeArray(a,this))};A.prototype=o.fn,y=o(m);var B=/^(?:parents|prev(?:Until|All))/,C={children:!0,contents:!0,next:!0,prev:!0};o.extend({dir:function(a,b,c){var d=[],e=void 0!==c;while((a=a[b])&&9!==a.nodeType)if(1===a.nodeType){if(e&&o(a).is(c))break;d.push(a)}return d},sibling:function(a,b){for(var c=[];a;a=a.nextSibling)1===a.nodeType&&a!==b&&c.push(a);return c}}),o.fn.extend({has:function(a){var b=o(a,this),c=b.length;return this.filter(function(){for(var a=0;c>a;a++)if(o.contains(this,b[a]))return!0})},closest:function(a,b){for(var c,d=0,e=this.length,f=[],g=u.test(a)||"string"!=typeof a?o(a,b||this.context):0;e>d;d++)for(c=this[d];c&&c!==b;c=c.parentNode)if(c.nodeType<11&&(g?g.index(c)>-1:1===c.nodeType&&o.find.matchesSelector(c,a))){f.push(c);break}return this.pushStack(f.length>1?o.unique(f):f)},index:function(a){return a?"string"==typeof a?g.call(o(a),this[0]):g.call(this,a.jquery?a[0]:a):this[0]&&this[0].parentNode?this.first().prevAll().length:-1},add:function(a,b){return this.pushStack(o.unique(o.merge(this.get(),o(a,b))))},addBack:function(a){return this.add(null==a?this.prevObject:this.prevObject.filter(a))}});function D(a,b){while((a=a[b])&&1!==a.nodeType);return a}o.each({parent:function(a){var b=a.parentNode;return b&&11!==b.nodeType?b:null},parents:function(a){return o.dir(a,"parentNode")},parentsUntil:function(a,b,c){return o.dir(a,"parentNode",c)},next:function(a){return D(a,"nextSibling")},prev:function(a){return D(a,"previousSibling")},nextAll:function(a){return o.dir(a,"nextSibling")},prevAll:function(a){return o.dir(a,"previousSibling")},nextUntil:function(a,b,c){return o.dir(a,"nextSibling",c)},prevUntil:function(a,b,c){return o.dir(a,"previousSibling",c)},siblings:function(a){return o.sibling((a.parentNode||{}).firstChild,a)},children:function(a){return o.sibling(a.firstChild)},contents:function(a){return a.contentDocument||o.merge([],a.childNodes)}},function(a,b){o.fn[a]=function(c,d){var e=o.map(this,b,c);return"Until"!==a.slice(-5)&&(d=c),d&&"string"==typeof d&&(e=o.filter(d,e)),this.length>1&&(C[a]||o.unique(e),B.test(a)&&e.reverse()),this.pushStack(e)}});var E=/\S+/g,F={};function G(a){var b=F[a]={};return o.each(a.match(E)||[],function(a,c){b[c]=!0}),b}o.Callbacks=function(a){a="string"==typeof a?F[a]||G(a):o.extend({},a);var b,c,d,e,f,g,h=[],i=!a.once&&[],j=function(l){for(b=a.memory&&l,c=!0,g=e||0,e=0,f=h.length,d=!0;h&&f>g;g++)if(h[g].apply(l[0],l[1])===!1&&a.stopOnFalse){b=!1;break}d=!1,h&&(i?i.length&&j(i.shift()):b?h=[]:k.disable())},k={add:function(){if(h){var c=h.length;!function g(b){o.each(b,function(b,c){var d=o.type(c);"function"===d?a.unique&&k.has(c)||h.push(c):c&&c.length&&"string"!==d&&g(c)})}(arguments),d?f=h.length:b&&(e=c,j(b))}return this},remove:function(){return h&&o.each(arguments,function(a,b){var c;while((c=o.inArray(b,h,c))>-1)h.splice(c,1),d&&(f>=c&&f--,g>=c&&g--)}),this},has:function(a){return a?o.inArray(a,h)>-1:!(!h||!h.length)},empty:function(){return h=[],f=0,this},disable:function(){return h=i=b=void 0,this},disabled:function(){return!h},lock:function(){return i=void 0,b||k.disable(),this},locked:function(){return!i},fireWith:function(a,b){return!h||c&&!i||(b=b||[],b=[a,b.slice?b.slice():b],d?i.push(b):j(b)),this},fire:function(){return k.fireWith(this,arguments),this},fired:function(){return!!c}};return k},o.extend({Deferred:function(a){var b=[["resolve","done",o.Callbacks("once memory"),"resolved"],["reject","fail",o.Callbacks("once memory"),"rejected"],["notify","progress",o.Callbacks("memory")]],c="pending",d={state:function(){return c},always:function(){return e.done(arguments).fail(arguments),this},then:function(){var a=arguments;return o.Deferred(function(c){o.each(b,function(b,f){var g=o.isFunction(a[b])&&a[b];e[f[1]](function(){var a=g&&g.apply(this,arguments);a&&o.isFunction(a.promise)?a.promise().done(c.resolve).fail(c.reject).progress(c.notify):c[f[0]+"With"](this===d?c.promise():this,g?[a]:arguments)})}),a=null}).promise()},promise:function(a){return null!=a?o.extend(a,d):d}},e={};return d.pipe=d.then,o.each(b,function(a,f){var g=f[2],h=f[3];d[f[1]]=g.add,h&&g.add(function(){c=h},b[1^a][2].disable,b[2][2].lock),e[f[0]]=function(){return e[f[0]+"With"](this===e?d:this,arguments),this},e[f[0]+"With"]=g.fireWith}),d.promise(e),a&&a.call(e,e),e},when:function(a){var b=0,c=d.call(arguments),e=c.length,f=1!==e||a&&o.isFunction(a.promise)?e:0,g=1===f?a:o.Deferred(),h=function(a,b,c){return function(e){b[a]=this,c[a]=arguments.length>1?d.call(arguments):e,c===i?g.notifyWith(b,c):--f||g.resolveWith(b,c)}},i,j,k;if(e>1)for(i=new Array(e),j=new Array(e),k=new Array(e);e>b;b++)c[b]&&o.isFunction(c[b].promise)?c[b].promise().done(h(b,k,c)).fail(g.reject).progress(h(b,j,i)):--f;return f||g.resolveWith(k,c),g.promise()}});var H;o.fn.ready=function(a){return o.ready.promise().done(a),this},o.extend({isReady:!1,readyWait:1,holdReady:function(a){a?o.readyWait++:o.ready(!0)},ready:function(a){(a===!0?--o.readyWait:o.isReady)||(o.isReady=!0,a!==!0&&--o.readyWait>0||(H.resolveWith(m,[o]),o.fn.trigger&&o(m).trigger("ready").off("ready")))}});function I(){m.removeEventListener("DOMContentLoaded",I,!1),a.removeEventListener("load",I,!1),o.ready()}o.ready.promise=function(b){return H||(H=o.Deferred(),"complete"===m.readyState?setTimeout(o.ready):(m.addEventListener("DOMContentLoaded",I,!1),a.addEventListener("load",I,!1))),H.promise(b)},o.ready.promise();var J=o.access=function(a,b,c,d,e,f,g){var h=0,i=a.length,j=null==c;if("object"===o.type(c)){e=!0;for(h in c)o.access(a,b,h,c[h],!0,f,g)}else if(void 0!==d&&(e=!0,o.isFunction(d)||(g=!0),j&&(g?(b.call(a,d),b=null):(j=b,b=function(a,b,c){return j.call(o(a),c)})),b))for(;i>h;h++)b(a[h],c,g?d:d.call(a[h],h,b(a[h],c)));return e?a:j?b.call(a):i?b(a[0],c):f};o.acceptData=function(a){return 1===a.nodeType||9===a.nodeType||!+a.nodeType};function K(){Object.defineProperty(this.cache={},0,{get:function(){return{}}}),this.expando=o.expando+Math.random()}K.uid=1,K.accepts=o.acceptData,K.prototype={key:function(a){if(!K.accepts(a))return 0;var b={},c=a[this.expando];if(!c){c=K.uid++;try{b[this.expando]={value:c},Object.defineProperties(a,b)}catch(d){b[this.expando]=c,o.extend(a,b)}}return this.cache[c]||(this.cache[c]={}),c},set:function(a,b,c){var d,e=this.key(a),f=this.cache[e];if("string"==typeof b)f[b]=c;else if(o.isEmptyObject(f))o.extend(this.cache[e],b);else for(d in b)f[d]=b[d];return f},get:function(a,b){var c=this.cache[this.key(a)];return void 0===b?c:c[b]},access:function(a,b,c){var d;return void 0===b||b&&"string"==typeof b&&void 0===c?(d=this.get(a,b),void 0!==d?d:this.get(a,o.camelCase(b))):(this.set(a,b,c),void 0!==c?c:b)},remove:function(a,b){var c,d,e,f=this.key(a),g=this.cache[f];if(void 0===b)this.cache[f]={};else{o.isArray(b)?d=b.concat(b.map(o.camelCase)):(e=o.camelCase(b),b in g?d=[b,e]:(d=e,d=d in g?[d]:d.match(E)||[])),c=d.length;while(c--)delete g[d[c]]}},hasData:function(a){return!o.isEmptyObject(this.cache[a[this.expando]]||{})},discard:function(a){a[this.expando]&&delete this.cache[a[this.expando]]}};var L=new K,M=new K,N=/^(?:\{[\w\W]*\}|\[[\w\W]*\])$/,O=/([A-Z])/g;function P(a,b,c){var d;if(void 0===c&&1===a.nodeType)if(d="data-"+b.replace(O,"-$1").toLowerCase(),c=a.getAttribute(d),"string"==typeof c){try{c="true"===c?!0:"false"===c?!1:"null"===c?null:+c+""===c?+c:N.test(c)?o.parseJSON(c):c}catch(e){}M.set(a,b,c)}else c=void 0;return c}o.extend({hasData:function(a){return M.hasData(a)||L.hasData(a)},data:function(a,b,c){return M.access(a,b,c)},removeData:function(a,b){M.remove(a,b)},_data:function(a,b,c){return L.access(a,b,c)},_removeData:function(a,b){L.remove(a,b)}}),o.fn.extend({data:function(a,b){var c,d,e,f=this[0],g=f&&f.attributes;if(void 0===a){if(this.length&&(e=M.get(f),1===f.nodeType&&!L.get(f,"hasDataAttrs"))){c=g.length; while(c--)d=g[c].name,0===d.indexOf("data-")&&(d=o.camelCase(d.slice(5)),P(f,d,e[d]));L.set(f,"hasDataAttrs",!0)}return e}return"object"==typeof a?this.each(function(){M.set(this,a)}):J(this,function(b){var c,d=o.camelCase(a);if(f&&void 0===b){if(c=M.get(f,a),void 0!==c)return c;if(c=M.get(f,d),void 0!==c)return c;if(c=P(f,d,void 0),void 0!==c)return c}else this.each(function(){var c=M.get(this,d);M.set(this,d,b),-1!==a.indexOf("-")&&void 0!==c&&M.set(this,a,b)})},null,b,arguments.length>1,null,!0)},removeData:function(a){return this.each(function(){M.remove(this,a)})}}),o.extend({queue:function(a,b,c){var d;return a?(b=(b||"fx")+"queue",d=L.get(a,b),c&&(!d||o.isArray(c)?d=L.access(a,b,o.makeArray(c)):d.push(c)),d||[]):void 0},dequeue:function(a,b){b=b||"fx";var c=o.queue(a,b),d=c.length,e=c.shift(),f=o._queueHooks(a,b),g=function(){o.dequeue(a,b)};"inprogress"===e&&(e=c.shift(),d--),e&&("fx"===b&&c.unshift("inprogress"),delete f.stop,e.call(a,g,f)),!d&&f&&f.empty.fire()},_queueHooks:function(a,b){var c=b+"queueHooks";return L.get(a,c)||L.access(a,c,{empty:o.Callbacks("once memory").add(function(){L.remove(a,[b+"queue",c])})})}}),o.fn.extend({queue:function(a,b){var c=2;return"string"!=typeof a&&(b=a,a="fx",c--),arguments.length",l.checkClone=b.cloneNode(!0).cloneNode(!0).lastChild.checked,b.innerHTML="",l.noCloneChecked=!!b.cloneNode(!0).lastChild.defaultValue}();var U="undefined";l.focusinBubbles="onfocusin"in a;var V=/^key/,W=/^(?:mouse|contextmenu)|click/,X=/^(?:focusinfocus|focusoutblur)$/,Y=/^([^.]*)(?:\.(.+)|)$/;function Z(){return!0}function $(){return!1}function _(){try{return m.activeElement}catch(a){}}o.event={global:{},add:function(a,b,c,d,e){var f,g,h,i,j,k,l,m,n,p,q,r=L.get(a);if(r){c.handler&&(f=c,c=f.handler,e=f.selector),c.guid||(c.guid=o.guid++),(i=r.events)||(i=r.events={}),(g=r.handle)||(g=r.handle=function(b){return typeof o!==U&&o.event.triggered!==b.type?o.event.dispatch.apply(a,arguments):void 0}),b=(b||"").match(E)||[""],j=b.length;while(j--)h=Y.exec(b[j])||[],n=q=h[1],p=(h[2]||"").split(".").sort(),n&&(l=o.event.special[n]||{},n=(e?l.delegateType:l.bindType)||n,l=o.event.special[n]||{},k=o.extend({type:n,origType:q,data:d,handler:c,guid:c.guid,selector:e,needsContext:e&&o.expr.match.needsContext.test(e),namespace:p.join(".")},f),(m=i[n])||(m=i[n]=[],m.delegateCount=0,l.setup&&l.setup.call(a,d,p,g)!==!1||a.addEventListener&&a.addEventListener(n,g,!1)),l.add&&(l.add.call(a,k),k.handler.guid||(k.handler.guid=c.guid)),e?m.splice(m.delegateCount++,0,k):m.push(k),o.event.global[n]=!0)}},remove:function(a,b,c,d,e){var f,g,h,i,j,k,l,m,n,p,q,r=L.hasData(a)&&L.get(a);if(r&&(i=r.events)){b=(b||"").match(E)||[""],j=b.length;while(j--)if(h=Y.exec(b[j])||[],n=q=h[1],p=(h[2]||"").split(".").sort(),n){l=o.event.special[n]||{},n=(d?l.delegateType:l.bindType)||n,m=i[n]||[],h=h[2]&&new RegExp("(^|\\.)"+p.join("\\.(?:.*\\.|)")+"(\\.|$)"),g=f=m.length;while(f--)k=m[f],!e&&q!==k.origType||c&&c.guid!==k.guid||h&&!h.test(k.namespace)||d&&d!==k.selector&&("**"!==d||!k.selector)||(m.splice(f,1),k.selector&&m.delegateCount--,l.remove&&l.remove.call(a,k));g&&!m.length&&(l.teardown&&l.teardown.call(a,p,r.handle)!==!1||o.removeEvent(a,n,r.handle),delete i[n])}else for(n in i)o.event.remove(a,n+b[j],c,d,!0);o.isEmptyObject(i)&&(delete r.handle,L.remove(a,"events"))}},trigger:function(b,c,d,e){var f,g,h,i,k,l,n,p=[d||m],q=j.call(b,"type")?b.type:b,r=j.call(b,"namespace")?b.namespace.split("."):[];if(g=h=d=d||m,3!==d.nodeType&&8!==d.nodeType&&!X.test(q+o.event.triggered)&&(q.indexOf(".")>=0&&(r=q.split("."),q=r.shift(),r.sort()),k=q.indexOf(":")<0&&"on"+q,b=b[o.expando]?b:new o.Event(q,"object"==typeof b&&b),b.isTrigger=e?2:3,b.namespace=r.join("."),b.namespace_re=b.namespace?new RegExp("(^|\\.)"+r.join("\\.(?:.*\\.|)")+"(\\.|$)"):null,b.result=void 0,b.target||(b.target=d),c=null==c?[b]:o.makeArray(c,[b]),n=o.event.special[q]||{},e||!n.trigger||n.trigger.apply(d,c)!==!1)){if(!e&&!n.noBubble&&!o.isWindow(d)){for(i=n.delegateType||q,X.test(i+q)||(g=g.parentNode);g;g=g.parentNode)p.push(g),h=g;h===(d.ownerDocument||m)&&p.push(h.defaultView||h.parentWindow||a)}f=0;while((g=p[f++])&&!b.isPropagationStopped())b.type=f>1?i:n.bindType||q,l=(L.get(g,"events")||{})[b.type]&&L.get(g,"handle"),l&&l.apply(g,c),l=k&&g[k],l&&l.apply&&o.acceptData(g)&&(b.result=l.apply(g,c),b.result===!1&&b.preventDefault());return b.type=q,e||b.isDefaultPrevented()||n._default&&n._default.apply(p.pop(),c)!==!1||!o.acceptData(d)||k&&o.isFunction(d[q])&&!o.isWindow(d)&&(h=d[k],h&&(d[k]=null),o.event.triggered=q,d[q](),o.event.triggered=void 0,h&&(d[k]=h)),b.result}},dispatch:function(a){a=o.event.fix(a);var b,c,e,f,g,h=[],i=d.call(arguments),j=(L.get(this,"events")||{})[a.type]||[],k=o.event.special[a.type]||{};if(i[0]=a,a.delegateTarget=this,!k.preDispatch||k.preDispatch.call(this,a)!==!1){h=o.event.handlers.call(this,a,j),b=0;while((f=h[b++])&&!a.isPropagationStopped()){a.currentTarget=f.elem,c=0;while((g=f.handlers[c++])&&!a.isImmediatePropagationStopped())(!a.namespace_re||a.namespace_re.test(g.namespace))&&(a.handleObj=g,a.data=g.data,e=((o.event.special[g.origType]||{}).handle||g.handler).apply(f.elem,i),void 0!==e&&(a.result=e)===!1&&(a.preventDefault(),a.stopPropagation()))}return k.postDispatch&&k.postDispatch.call(this,a),a.result}},handlers:function(a,b){var c,d,e,f,g=[],h=b.delegateCount,i=a.target;if(h&&i.nodeType&&(!a.button||"click"!==a.type))for(;i!==this;i=i.parentNode||this)if(i.disabled!==!0||"click"!==a.type){for(d=[],c=0;h>c;c++)f=b[c],e=f.selector+" ",void 0===d[e]&&(d[e]=f.needsContext?o(e,this).index(i)>=0:o.find(e,this,null,[i]).length),d[e]&&d.push(f);d.length&&g.push({elem:i,handlers:d})}return h]*)\/>/gi,bb=/<([\w:]+)/,cb=/<|&#?\w+;/,db=/<(?:script|style|link)/i,eb=/checked\s*(?:[^=]|=\s*.checked.)/i,fb=/^$|\/(?:java|ecma)script/i,gb=/^true\/(.*)/,hb=/^\s*\s*$/g,ib={option:[1,""],thead:[1,"","
"],col:[2,"","
"],tr:[2,"","
"],td:[3,"","
"],_default:[0,"",""]};ib.optgroup=ib.option,ib.tbody=ib.tfoot=ib.colgroup=ib.caption=ib.thead,ib.th=ib.td;function jb(a,b){return o.nodeName(a,"table")&&o.nodeName(11!==b.nodeType?b:b.firstChild,"tr")?a.getElementsByTagName("tbody")[0]||a.appendChild(a.ownerDocument.createElement("tbody")):a}function kb(a){return a.type=(null!==a.getAttribute("type"))+"/"+a.type,a}function lb(a){var b=gb.exec(a.type);return b?a.type=b[1]:a.removeAttribute("type"),a}function mb(a,b){for(var c=0,d=a.length;d>c;c++)L.set(a[c],"globalEval",!b||L.get(b[c],"globalEval"))}function nb(a,b){var c,d,e,f,g,h,i,j;if(1===b.nodeType){if(L.hasData(a)&&(f=L.access(a),g=L.set(b,f),j=f.events)){delete g.handle,g.events={};for(e in j)for(c=0,d=j[e].length;d>c;c++)o.event.add(b,e,j[e][c])}M.hasData(a)&&(h=M.access(a),i=o.extend({},h),M.set(b,i))}}function ob(a,b){var c=a.getElementsByTagName?a.getElementsByTagName(b||"*"):a.querySelectorAll?a.querySelectorAll(b||"*"):[];return void 0===b||b&&o.nodeName(a,b)?o.merge([a],c):c}function pb(a,b){var c=b.nodeName.toLowerCase();"input"===c&&T.test(a.type)?b.checked=a.checked:("input"===c||"textarea"===c)&&(b.defaultValue=a.defaultValue)}o.extend({clone:function(a,b,c){var d,e,f,g,h=a.cloneNode(!0),i=o.contains(a.ownerDocument,a);if(!(l.noCloneChecked||1!==a.nodeType&&11!==a.nodeType||o.isXMLDoc(a)))for(g=ob(h),f=ob(a),d=0,e=f.length;e>d;d++)pb(f[d],g[d]);if(b)if(c)for(f=f||ob(a),g=g||ob(h),d=0,e=f.length;e>d;d++)nb(f[d],g[d]);else nb(a,h);return g=ob(h,"script"),g.length>0&&mb(g,!i&&ob(a,"script")),h},buildFragment:function(a,b,c,d){for(var e,f,g,h,i,j,k=b.createDocumentFragment(),l=[],m=0,n=a.length;n>m;m++)if(e=a[m],e||0===e)if("object"===o.type(e))o.merge(l,e.nodeType?[e]:e);else if(cb.test(e)){f=f||k.appendChild(b.createElement("div")),g=(bb.exec(e)||["",""])[1].toLowerCase(),h=ib[g]||ib._default,f.innerHTML=h[1]+e.replace(ab,"<$1>")+h[2],j=h[0];while(j--)f=f.lastChild;o.merge(l,f.childNodes),f=k.firstChild,f.textContent=""}else l.push(b.createTextNode(e));k.textContent="",m=0;while(e=l[m++])if((!d||-1===o.inArray(e,d))&&(i=o.contains(e.ownerDocument,e),f=ob(k.appendChild(e),"script"),i&&mb(f),c)){j=0;while(e=f[j++])fb.test(e.type||"")&&c.push(e)}return k},cleanData:function(a){for(var b,c,d,e,f,g,h=o.event.special,i=0;void 0!==(c=a[i]);i++){if(o.acceptData(c)&&(f=c[L.expando],f&&(b=L.cache[f]))){if(d=Object.keys(b.events||{}),d.length)for(g=0;void 0!==(e=d[g]);g++)h[e]?o.event.remove(c,e):o.removeEvent(c,e,b.handle);L.cache[f]&&delete L.cache[f]}delete M.cache[c[M.expando]]}}}),o.fn.extend({text:function(a){return J(this,function(a){return void 0===a?o.text(this):this.empty().each(function(){(1===this.nodeType||11===this.nodeType||9===this.nodeType)&&(this.textContent=a)})},null,a,arguments.length)},append:function(){return this.domManip(arguments,function(a){if(1===this.nodeType||11===this.nodeType||9===this.nodeType){var b=jb(this,a);b.appendChild(a)}})},prepend:function(){return this.domManip(arguments,function(a){if(1===this.nodeType||11===this.nodeType||9===this.nodeType){var b=jb(this,a);b.insertBefore(a,b.firstChild)}})},before:function(){return this.domManip(arguments,function(a){this.parentNode&&this.parentNode.insertBefore(a,this)})},after:function(){return this.domManip(arguments,function(a){this.parentNode&&this.parentNode.insertBefore(a,this.nextSibling)})},remove:function(a,b){for(var c,d=a?o.filter(a,this):this,e=0;null!=(c=d[e]);e++)b||1!==c.nodeType||o.cleanData(ob(c)),c.parentNode&&(b&&o.contains(c.ownerDocument,c)&&mb(ob(c,"script")),c.parentNode.removeChild(c));return this},empty:function(){for(var a,b=0;null!=(a=this[b]);b++)1===a.nodeType&&(o.cleanData(ob(a,!1)),a.textContent="");return this},clone:function(a,b){return a=null==a?!1:a,b=null==b?a:b,this.map(function(){return o.clone(this,a,b)})},html:function(a){return J(this,function(a){var b=this[0]||{},c=0,d=this.length;if(void 0===a&&1===b.nodeType)return b.innerHTML;if("string"==typeof a&&!db.test(a)&&!ib[(bb.exec(a)||["",""])[1].toLowerCase()]){a=a.replace(ab,"<$1>");try{for(;d>c;c++)b=this[c]||{},1===b.nodeType&&(o.cleanData(ob(b,!1)),b.innerHTML=a);b=0}catch(e){}}b&&this.empty().append(a)},null,a,arguments.length)},replaceWith:function(){var a=arguments[0];return this.domManip(arguments,function(b){a=this.parentNode,o.cleanData(ob(this)),a&&a.replaceChild(b,this)}),a&&(a.length||a.nodeType)?this:this.remove()},detach:function(a){return this.remove(a,!0)},domManip:function(a,b){a=e.apply([],a);var c,d,f,g,h,i,j=0,k=this.length,m=this,n=k-1,p=a[0],q=o.isFunction(p);if(q||k>1&&"string"==typeof p&&!l.checkClone&&eb.test(p))return this.each(function(c){var d=m.eq(c);q&&(a[0]=p.call(this,c,d.html())),d.domManip(a,b)});if(k&&(c=o.buildFragment(a,this[0].ownerDocument,!1,this),d=c.firstChild,1===c.childNodes.length&&(c=d),d)){for(f=o.map(ob(c,"script"),kb),g=f.length;k>j;j++)h=c,j!==n&&(h=o.clone(h,!0,!0),g&&o.merge(f,ob(h,"script"))),b.call(this[j],h,j);if(g)for(i=f[f.length-1].ownerDocument,o.map(f,lb),j=0;g>j;j++)h=f[j],fb.test(h.type||"")&&!L.access(h,"globalEval")&&o.contains(i,h)&&(h.src?o._evalUrl&&o._evalUrl(h.src):o.globalEval(h.textContent.replace(hb,"")))}return this}}),o.each({appendTo:"append",prependTo:"prepend",insertBefore:"before",insertAfter:"after",replaceAll:"replaceWith"},function(a,b){o.fn[a]=function(a){for(var c,d=[],e=o(a),g=e.length-1,h=0;g>=h;h++)c=h===g?this:this.clone(!0),o(e[h])[b](c),f.apply(d,c.get());return this.pushStack(d)}});var qb,rb={};function sb(b,c){var d=o(c.createElement(b)).appendTo(c.body),e=a.getDefaultComputedStyle?a.getDefaultComputedStyle(d[0]).display:o.css(d[0],"display");return d.detach(),e}function tb(a){var b=m,c=rb[a];return c||(c=sb(a,b),"none"!==c&&c||(qb=(qb||o("