From aad5ad9bf0c02aa4e79bc6b7d6c934612fff4026 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?J=C3=B6rg=20Frings-F=C3=BCrst?= Date: Wed, 6 Mar 2024 10:24:08 +0100 Subject: New upstream version 4.2.0 --- FLOSSE | 89 + GPLv2 | 340 + LICENSE | 28 + NEWS | 1271 ++ PACKAGE-README.md | 66 + README.md | 12 + build/bootstrap.build | 10 + build/export.build | 9 + build/root.build | 37 + buildfile | 11 + doc/buildfile | 293 + doc/custom-literals.xsd | 48 + doc/cxx/parser/guide/figure-1.png | Bin 0 -> 34195 bytes doc/cxx/parser/guide/figure-1.svg | 373 + doc/cxx/parser/guide/guide.html2ps.in | 65 + doc/cxx/parser/guide/index.xhtml | 4163 ++++ doc/cxx/parser/guide/index.xhtml.in | 4163 ++++ doc/cxx/tree/guide/guide.html2ps.in | 65 + doc/cxx/tree/guide/index.xhtml | 2736 +++ doc/cxx/tree/guide/index.xhtml.in | 2736 +++ doc/cxx/tree/manual/index.xhtml | 6826 ++++++ doc/cxx/tree/manual/index.xhtml.in | 6826 ++++++ doc/cxx/tree/manual/manual.html2ps.in | 66 + doc/default.css | 319 + .../cxx/parser/guide/cxx-parser-guide.pdf | Bin 0 -> 191458 bytes .../cxx/parser/guide/cxx-parser-guide.ps | 20741 +++++++++++++++++++ doc/pregenerated/cxx/tree/guide/cxx-tree-guide.pdf | Bin 0 -> 128925 bytes doc/pregenerated/cxx/tree/guide/cxx-tree-guide.ps | 3515 ++++ .../cxx/tree/manual/cxx-tree-manual.pdf | Bin 0 -> 261393 bytes .../cxx/tree/manual/cxx-tree-manual.ps | 7387 +++++++ doc/pregenerated/xsd.1 | 1500 ++ doc/pregenerated/xsd.xhtml | 1621 ++ doc/xsd-epilogue.1 | 576 + doc/xsd-epilogue.xhtml | 429 + doc/xsd-parser-header.1 | 4 + doc/xsd-parser-header.xhtml | 1 + doc/xsd-prologue.1 | 119 + doc/xsd-prologue.xhtml | 123 + doc/xsd-tree-header.1 | 4 + doc/xsd-tree-header.xhtml | 1 + manifest | 164 + tests/build/bootstrap.build | 8 + tests/build/root.build | 16 + tests/buildfile | 4 + tests/testscript | 26 + xsd/buildfile | 121 + xsd/cxx/elements.cxx | 1365 ++ xsd/cxx/elements.hxx | 626 + xsd/cxx/literal-map.cxx | 261 + xsd/cxx/literal-map.hxx | 19 + xsd/cxx/option-types.cxx | 59 + xsd/cxx/option-types.hxx | 38 + xsd/cxx/options.cli | 560 + xsd/cxx/parser/attribute-validation-source.cxx | 412 + xsd/cxx/parser/attribute-validation-source.hxx | 18 + xsd/cxx/parser/characters-validation-source.cxx | 73 + xsd/cxx/parser/characters-validation-source.hxx | 18 + xsd/cxx/parser/driver-source.cxx | 775 + xsd/cxx/parser/driver-source.hxx | 18 + xsd/cxx/parser/element-validation-source.cxx | 1600 ++ xsd/cxx/parser/element-validation-source.hxx | 18 + xsd/cxx/parser/elements.cxx | 247 + xsd/cxx/parser/elements.hxx | 315 + xsd/cxx/parser/generator.cxx | 1133 + xsd/cxx/parser/generator.hxx | 45 + xsd/cxx/parser/impl-header.cxx | 232 + xsd/cxx/parser/impl-header.hxx | 18 + xsd/cxx/parser/impl-source.cxx | 384 + xsd/cxx/parser/impl-source.hxx | 18 + xsd/cxx/parser/name-processor.cxx | 1175 ++ xsd/cxx/parser/name-processor.hxx | 30 + xsd/cxx/parser/options.cli | 147 + xsd/cxx/parser/parser-forward.cxx | 110 + xsd/cxx/parser/parser-forward.hxx | 18 + xsd/cxx/parser/parser-header.cxx | 1440 ++ xsd/cxx/parser/parser-header.hxx | 18 + xsd/cxx/parser/parser-inline.cxx | 399 + xsd/cxx/parser/parser-inline.hxx | 18 + xsd/cxx/parser/parser-source.cxx | 957 + xsd/cxx/parser/parser-source.hxx | 18 + xsd/cxx/parser/print-impl-common.hxx | 641 + xsd/cxx/parser/state-processor.cxx | 319 + xsd/cxx/parser/state-processor.hxx | 25 + xsd/cxx/parser/type-processor.cxx | 347 + xsd/cxx/parser/type-processor.hxx | 31 + xsd/cxx/parser/validator.cxx | 723 + xsd/cxx/parser/validator.hxx | 30 + xsd/cxx/tree/counter.cxx | 265 + xsd/cxx/tree/counter.hxx | 25 + xsd/cxx/tree/default-value.cxx | 1273 ++ xsd/cxx/tree/default-value.hxx | 363 + xsd/cxx/tree/elements.cxx | 1409 ++ xsd/cxx/tree/elements.hxx | 2122 ++ xsd/cxx/tree/fundamental-header.hxx | 1337 ++ xsd/cxx/tree/generator.cxx | 1268 ++ xsd/cxx/tree/generator.hxx | 44 + xsd/cxx/tree/name-processor.cxx | 2427 +++ xsd/cxx/tree/name-processor.hxx | 28 + xsd/cxx/tree/options.cli | 479 + xsd/cxx/tree/order-processor.cxx | 243 + xsd/cxx/tree/order-processor.hxx | 29 + xsd/cxx/tree/parser-header.cxx | 472 + xsd/cxx/tree/parser-header.hxx | 19 + xsd/cxx/tree/parser-source.cxx | 541 + xsd/cxx/tree/parser-source.hxx | 18 + xsd/cxx/tree/polymorphism-processor.cxx | 740 + xsd/cxx/tree/polymorphism-processor.hxx | 30 + xsd/cxx/tree/serialization-header.cxx | 579 + xsd/cxx/tree/serialization-header.hxx | 18 + xsd/cxx/tree/serialization-source.cxx | 1499 ++ xsd/cxx/tree/serialization-source.hxx | 18 + xsd/cxx/tree/stream-extraction-source.cxx | 864 + xsd/cxx/tree/stream-extraction-source.hxx | 18 + xsd/cxx/tree/stream-header.cxx | 181 + xsd/cxx/tree/stream-header.hxx | 18 + xsd/cxx/tree/stream-insertion-header.cxx | 178 + xsd/cxx/tree/stream-insertion-header.hxx | 18 + xsd/cxx/tree/stream-insertion-source.cxx | 623 + xsd/cxx/tree/stream-insertion-source.hxx | 18 + xsd/cxx/tree/stream-source.cxx | 496 + xsd/cxx/tree/stream-source.hxx | 18 + xsd/cxx/tree/tree-forward.cxx | 325 + xsd/cxx/tree/tree-forward.hxx | 18 + xsd/cxx/tree/tree-header.cxx | 4337 ++++ xsd/cxx/tree/tree-header.hxx | 18 + xsd/cxx/tree/tree-inline.cxx | 1161 ++ xsd/cxx/tree/tree-inline.hxx | 18 + xsd/cxx/tree/tree-source.cxx | 3912 ++++ xsd/cxx/tree/tree-source.hxx | 18 + xsd/cxx/tree/validator.cxx | 676 + xsd/cxx/tree/validator.hxx | 29 + xsd/elements.hxx | 125 + xsd/options-parser.hxx | 29 + xsd/options.cli | 322 + xsd/pregenerated/xsd/cxx/options.cxx | 739 + xsd/pregenerated/xsd/cxx/options.hxx | 451 + xsd/pregenerated/xsd/cxx/options.ixx | 615 + xsd/pregenerated/xsd/cxx/parser/options.cxx | 776 + xsd/pregenerated/xsd/cxx/parser/options.hxx | 186 + xsd/pregenerated/xsd/cxx/parser/options.ixx | 162 + xsd/pregenerated/xsd/cxx/tree/options.cxx | 1343 ++ xsd/pregenerated/xsd/cxx/tree/options.hxx | 414 + xsd/pregenerated/xsd/cxx/tree/options.ixx | 504 + xsd/pregenerated/xsd/options.cxx | 1297 ++ xsd/pregenerated/xsd/options.hxx | 702 + xsd/pregenerated/xsd/options.ixx | 555 + xsd/processing/cardinality/processor.cxx | 407 + xsd/processing/cardinality/processor.hxx | 28 + xsd/processing/inheritance/processor.cxx | 492 + xsd/processing/inheritance/processor.hxx | 28 + xsd/type-map/lexer.cxx | 131 + xsd/type-map/lexer.hxx | 74 + xsd/type-map/parser.cxx | 279 + xsd/type-map/parser.hxx | 41 + xsd/type-map/type-map.hxx | 178 + xsd/types.hxx | 19 + xsd/version.hxx.in | 55 + xsd/xsd.cxx | 1157 ++ xsd/xsd.hxx | 24 + 159 files changed, 120933 insertions(+) create mode 100644 FLOSSE create mode 100644 GPLv2 create mode 100644 LICENSE create mode 100644 NEWS create mode 100644 PACKAGE-README.md create mode 100644 README.md create mode 100644 build/bootstrap.build create mode 100644 build/export.build create mode 100644 build/root.build create mode 100644 buildfile create mode 100644 doc/buildfile create mode 100644 doc/custom-literals.xsd create mode 100644 doc/cxx/parser/guide/figure-1.png create mode 100644 doc/cxx/parser/guide/figure-1.svg create mode 100644 doc/cxx/parser/guide/guide.html2ps.in create mode 100644 doc/cxx/parser/guide/index.xhtml create mode 100644 doc/cxx/parser/guide/index.xhtml.in create mode 100644 doc/cxx/tree/guide/guide.html2ps.in create mode 100644 doc/cxx/tree/guide/index.xhtml create mode 100644 doc/cxx/tree/guide/index.xhtml.in create mode 100644 doc/cxx/tree/manual/index.xhtml create mode 100644 doc/cxx/tree/manual/index.xhtml.in create mode 100644 doc/cxx/tree/manual/manual.html2ps.in create mode 100644 doc/default.css create mode 100644 doc/pregenerated/cxx/parser/guide/cxx-parser-guide.pdf create mode 100644 doc/pregenerated/cxx/parser/guide/cxx-parser-guide.ps create mode 100644 doc/pregenerated/cxx/tree/guide/cxx-tree-guide.pdf create mode 100644 doc/pregenerated/cxx/tree/guide/cxx-tree-guide.ps create mode 100644 doc/pregenerated/cxx/tree/manual/cxx-tree-manual.pdf create mode 100644 doc/pregenerated/cxx/tree/manual/cxx-tree-manual.ps create mode 100644 doc/pregenerated/xsd.1 create mode 100644 doc/pregenerated/xsd.xhtml create mode 100644 doc/xsd-epilogue.1 create mode 100644 doc/xsd-epilogue.xhtml create mode 100644 doc/xsd-parser-header.1 create mode 100644 doc/xsd-parser-header.xhtml create mode 100644 doc/xsd-prologue.1 create mode 100644 doc/xsd-prologue.xhtml create mode 100644 doc/xsd-tree-header.1 create mode 100644 doc/xsd-tree-header.xhtml create mode 100644 manifest create mode 100644 tests/build/bootstrap.build create mode 100644 tests/build/root.build create mode 100644 tests/buildfile create mode 100644 tests/testscript create mode 100644 xsd/buildfile create mode 100644 xsd/cxx/elements.cxx create mode 100644 xsd/cxx/elements.hxx create mode 100644 xsd/cxx/literal-map.cxx create mode 100644 xsd/cxx/literal-map.hxx create mode 100644 xsd/cxx/option-types.cxx create mode 100644 xsd/cxx/option-types.hxx create mode 100644 xsd/cxx/options.cli create mode 100644 xsd/cxx/parser/attribute-validation-source.cxx create mode 100644 xsd/cxx/parser/attribute-validation-source.hxx create mode 100644 xsd/cxx/parser/characters-validation-source.cxx create mode 100644 xsd/cxx/parser/characters-validation-source.hxx create mode 100644 xsd/cxx/parser/driver-source.cxx create mode 100644 xsd/cxx/parser/driver-source.hxx create mode 100644 xsd/cxx/parser/element-validation-source.cxx create mode 100644 xsd/cxx/parser/element-validation-source.hxx create mode 100644 xsd/cxx/parser/elements.cxx create mode 100644 xsd/cxx/parser/elements.hxx create mode 100644 xsd/cxx/parser/generator.cxx create mode 100644 xsd/cxx/parser/generator.hxx create mode 100644 xsd/cxx/parser/impl-header.cxx create mode 100644 xsd/cxx/parser/impl-header.hxx create mode 100644 xsd/cxx/parser/impl-source.cxx create mode 100644 xsd/cxx/parser/impl-source.hxx create mode 100644 xsd/cxx/parser/name-processor.cxx create mode 100644 xsd/cxx/parser/name-processor.hxx create mode 100644 xsd/cxx/parser/options.cli create mode 100644 xsd/cxx/parser/parser-forward.cxx create mode 100644 xsd/cxx/parser/parser-forward.hxx create mode 100644 xsd/cxx/parser/parser-header.cxx create mode 100644 xsd/cxx/parser/parser-header.hxx create mode 100644 xsd/cxx/parser/parser-inline.cxx create mode 100644 xsd/cxx/parser/parser-inline.hxx create mode 100644 xsd/cxx/parser/parser-source.cxx create mode 100644 xsd/cxx/parser/parser-source.hxx create mode 100644 xsd/cxx/parser/print-impl-common.hxx create mode 100644 xsd/cxx/parser/state-processor.cxx create mode 100644 xsd/cxx/parser/state-processor.hxx create mode 100644 xsd/cxx/parser/type-processor.cxx create mode 100644 xsd/cxx/parser/type-processor.hxx create mode 100644 xsd/cxx/parser/validator.cxx create mode 100644 xsd/cxx/parser/validator.hxx create mode 100644 xsd/cxx/tree/counter.cxx create mode 100644 xsd/cxx/tree/counter.hxx create mode 100644 xsd/cxx/tree/default-value.cxx create mode 100644 xsd/cxx/tree/default-value.hxx create mode 100644 xsd/cxx/tree/elements.cxx create mode 100644 xsd/cxx/tree/elements.hxx create mode 100644 xsd/cxx/tree/fundamental-header.hxx create mode 100644 xsd/cxx/tree/generator.cxx create mode 100644 xsd/cxx/tree/generator.hxx create mode 100644 xsd/cxx/tree/name-processor.cxx create mode 100644 xsd/cxx/tree/name-processor.hxx create mode 100644 xsd/cxx/tree/options.cli create mode 100644 xsd/cxx/tree/order-processor.cxx create mode 100644 xsd/cxx/tree/order-processor.hxx create mode 100644 xsd/cxx/tree/parser-header.cxx create mode 100644 xsd/cxx/tree/parser-header.hxx create mode 100644 xsd/cxx/tree/parser-source.cxx create mode 100644 xsd/cxx/tree/parser-source.hxx create mode 100644 xsd/cxx/tree/polymorphism-processor.cxx create mode 100644 xsd/cxx/tree/polymorphism-processor.hxx create mode 100644 xsd/cxx/tree/serialization-header.cxx create mode 100644 xsd/cxx/tree/serialization-header.hxx create mode 100644 xsd/cxx/tree/serialization-source.cxx create mode 100644 xsd/cxx/tree/serialization-source.hxx create mode 100644 xsd/cxx/tree/stream-extraction-source.cxx create mode 100644 xsd/cxx/tree/stream-extraction-source.hxx create mode 100644 xsd/cxx/tree/stream-header.cxx create mode 100644 xsd/cxx/tree/stream-header.hxx create mode 100644 xsd/cxx/tree/stream-insertion-header.cxx create mode 100644 xsd/cxx/tree/stream-insertion-header.hxx create mode 100644 xsd/cxx/tree/stream-insertion-source.cxx create mode 100644 xsd/cxx/tree/stream-insertion-source.hxx create mode 100644 xsd/cxx/tree/stream-source.cxx create mode 100644 xsd/cxx/tree/stream-source.hxx create mode 100644 xsd/cxx/tree/tree-forward.cxx create mode 100644 xsd/cxx/tree/tree-forward.hxx create mode 100644 xsd/cxx/tree/tree-header.cxx create mode 100644 xsd/cxx/tree/tree-header.hxx create mode 100644 xsd/cxx/tree/tree-inline.cxx create mode 100644 xsd/cxx/tree/tree-inline.hxx create mode 100644 xsd/cxx/tree/tree-source.cxx create mode 100644 xsd/cxx/tree/tree-source.hxx create mode 100644 xsd/cxx/tree/validator.cxx create mode 100644 xsd/cxx/tree/validator.hxx create mode 100644 xsd/elements.hxx create mode 100644 xsd/options-parser.hxx create mode 100644 xsd/options.cli create mode 100644 xsd/pregenerated/xsd/cxx/options.cxx create mode 100644 xsd/pregenerated/xsd/cxx/options.hxx create mode 100644 xsd/pregenerated/xsd/cxx/options.ixx create mode 100644 xsd/pregenerated/xsd/cxx/parser/options.cxx create mode 100644 xsd/pregenerated/xsd/cxx/parser/options.hxx create mode 100644 xsd/pregenerated/xsd/cxx/parser/options.ixx create mode 100644 xsd/pregenerated/xsd/cxx/tree/options.cxx create mode 100644 xsd/pregenerated/xsd/cxx/tree/options.hxx create mode 100644 xsd/pregenerated/xsd/cxx/tree/options.ixx create mode 100644 xsd/pregenerated/xsd/options.cxx create mode 100644 xsd/pregenerated/xsd/options.hxx create mode 100644 xsd/pregenerated/xsd/options.ixx create mode 100644 xsd/processing/cardinality/processor.cxx create mode 100644 xsd/processing/cardinality/processor.hxx create mode 100644 xsd/processing/inheritance/processor.cxx create mode 100644 xsd/processing/inheritance/processor.hxx create mode 100644 xsd/type-map/lexer.cxx create mode 100644 xsd/type-map/lexer.hxx create mode 100644 xsd/type-map/parser.cxx create mode 100644 xsd/type-map/parser.hxx create mode 100644 xsd/type-map/type-map.hxx create mode 100644 xsd/types.hxx create mode 100644 xsd/version.hxx.in create mode 100644 xsd/xsd.cxx create mode 100644 xsd/xsd.hxx diff --git a/FLOSSE b/FLOSSE new file mode 100644 index 0000000..cbf8b2c --- /dev/null +++ b/FLOSSE @@ -0,0 +1,89 @@ +1. Intent + +We want specified Free/Libre and Open Source Software ("FLOSS") to be +able to use the specified GPL-licensed XSD runtime library (libxsd) and +XSD generated code (collectively called the "Program") despite the fact +that not all FLOSS licenses are compatible with version 2 of the GNU +General Public License (the "GPL"). + +It is our intent to allow distribution of the entire Derivative Work +(including the Program) under one or more of the FLOSS licenses listed +in section 3 (section 2.a). It is also our intent to disallow simple +relicensing of the Program for the sole purpose of using it in +proprietary applications (section 2.b and 2.c). As an example, consider +two hypothetical scenarios: + + a) You created a program that uses the XSD generated code and the XSD + runtime library to access information in XML instance documents. + Your program performs useful computations based on this information + (sections 2.b and 2.c are satisfied). You distribute your program, + including the XSD generated code and the XSD runtime library under + the BSD license and make it available at no charge to all third + parties (section 2.a is satisfied). Later you (or someone else) may + choose to base their proprietary application on your code since the + BSD license does not prohibit it. + + This scenario falls under this FLOSS Exception. + + + b) You created a library that uses the XSD generated code and the XSD + runtime library to access information in XML instance documents. You + did not add to the library any other useful code that uses the XSD + generated code or the XSD runtime library (neither section 2.b nor + 2.c is satisfied). You distribute your library, including the XSD + generated code and the XSD runtime library under the BSD license and + make it available at no charge to all third parties (section 2.a + is satisfied). Later you base your proprietary application on this + library since the BSD license does not prohibit it. + + This scenario does not fall under this FLOSS Exception (neither + section 2.b nor 2.c is satisfied). You created the library for the + sole purpose of making the XSD generated code and the XSD runtime + library available to your proprietary application. + + +2. Legal Terms and Conditions + +As a special exception to the terms and conditions of version 2 of +the GPL you are free to distribute a verbatim copy of the Program +as part of the Derivative Work that is formed from the Program or +any part thereof and one or more works (each, a "FLOSS Work") as +long as you also meet all of these conditions: + + a) You must cause the Derivative Work that in whole or in part + contains or is derived from the Program or any part thereof, + to be licensed as a whole at no charge to all third parties + under the terms of one or more of the licenses listed in + section 3. + + b) The Derivative Work should contain one or more FLOSS Work that + can be reasonably considered as derived from the Program or some + part thereof. + + c) The Derivative Work should not contain any part of the Program + that cannot be reasonably considered as a base of one or more + FLOSS Work. + + +3. FLOSS License List + + a) Any license listed in the "GPL-Compatible Free Software Licenses" + and the "GPL-Incompatible Free Software Licenses" sections of the + License List as published by the Free Software Foundation (FSF): + + http://www.gnu.org/licenses/license-list.html + + +4. Definitions + +Terms used, but not defined, herein shall have the meaning provided in +the GPL. + +Derivative Work means a derivative work under copyright law. + + +5. Applicability + +You may choose to redistribute a copy of the Program exclusively under +the terms of the GPL by removing the FLOSS Exception notice from that +copy of the Program. diff --git a/GPLv2 b/GPLv2 new file mode 100644 index 0000000..3912109 --- /dev/null +++ b/GPLv2 @@ -0,0 +1,340 @@ + GNU GENERAL PUBLIC LICENSE + Version 2, June 1991 + + Copyright (C) 1989, 1991 Free Software Foundation, Inc. + 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +License is intended to guarantee your freedom to share and change free +software--to make sure the software is free for all its users. This +General Public License applies to most of the Free Software +Foundation's software and to any other program whose authors commit to +using it. (Some other Free Software Foundation software is covered by +the GNU Library General Public License instead.) You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +this service if you wish), that you receive source code or can get it +if you want it, that you can change the software or use pieces of it +in new free programs; and that you know you can do these things. + + To protect your rights, we need to make restrictions that forbid +anyone to deny you these rights or to ask you to surrender the rights. +These restrictions translate to certain responsibilities for you if you +distribute copies of the software, or if you modify it. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must give the recipients all the rights that +you have. You must make sure that they, too, receive or can get the +source code. And you must show them these terms so they know their +rights. + + We protect your rights with two steps: (1) copyright the software, and +(2) offer you this license which gives you legal permission to copy, +distribute and/or modify the software. + + Also, for each author's protection and ours, we want to make certain +that everyone understands that there is no warranty for this free +software. If the software is modified by someone else and passed on, we +want its recipients to know that what they have is not the original, so +that any problems introduced by others will not reflect on the original +authors' reputations. + + Finally, any free program is threatened constantly by software +patents. We wish to avoid the danger that redistributors of a free +program will individually obtain patent licenses, in effect making the +program proprietary. To prevent this, we have made it clear that any +patent must be licensed for everyone's free use or not licensed at all. + + The precise terms and conditions for copying, distribution and +modification follow. + + GNU GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License applies to any program or other work which contains +a notice placed by the copyright holder saying it may be distributed +under the terms of this General Public License. The "Program", below, +refers to any such program or work, and a "work based on the Program" +means either the Program or any derivative work under copyright law: +that is to say, a work containing the Program or a portion of it, +either verbatim or with modifications and/or translated into another +language. (Hereinafter, translation is included without limitation in +the term "modification".) Each licensee is addressed as "you". + +Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running the Program is not restricted, and the output from the Program +is covered only if its contents constitute a work based on the +Program (independent of having been made by running the Program). +Whether that is true depends on what the Program does. + + 1. You may copy and distribute verbatim copies of the Program's +source code as you receive it, in any medium, provided that you +conspicuously and appropriately publish on each copy an appropriate +copyright notice and disclaimer of warranty; keep intact all the +notices that refer to this License and to the absence of any warranty; +and give any other recipients of the Program a copy of this License +along with the Program. + +You may charge a fee for the physical act of transferring a copy, and +you may at your option offer warranty protection in exchange for a fee. + + 2. You may modify your copy or copies of the Program or any portion +of it, thus forming a work based on the Program, and copy and +distribute such modifications or work under the terms of Section 1 +above, provided that you also meet all of these conditions: + + a) You must cause the modified files to carry prominent notices + stating that you changed the files and the date of any change. + + b) You must cause any work that you distribute or publish, that in + whole or in part contains or is derived from the Program or any + part thereof, to be licensed as a whole at no charge to all third + parties under the terms of this License. + + c) If the modified program normally reads commands interactively + when run, you must cause it, when started running for such + interactive use in the most ordinary way, to print or display an + announcement including an appropriate copyright notice and a + notice that there is no warranty (or else, saying that you provide + a warranty) and that users may redistribute the program under + these conditions, and telling the user how to view a copy of this + License. (Exception: if the Program itself is interactive but + does not normally print such an announcement, your work based on + the Program is not required to print an announcement.) + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Program, +and can be reasonably considered independent and separate works in +themselves, then this License, and its terms, do not apply to those +sections when you distribute them as separate works. But when you +distribute the same sections as part of a whole which is a work based +on the Program, the distribution of the whole must be on the terms of +this License, whose permissions for other licensees extend to the +entire whole, and thus to each and every part regardless of who wrote it. + +Thus, it is not the intent of this section to claim rights or contest +your rights to work written entirely by you; rather, the intent is to +exercise the right to control the distribution of derivative or +collective works based on the Program. + +In addition, mere aggregation of another work not based on the Program +with the Program (or with a work based on the Program) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may copy and distribute the Program (or a work based on it, +under Section 2) in object code or executable form under the terms of +Sections 1 and 2 above provided that you also do one of the following: + + a) Accompany it with the complete corresponding machine-readable + source code, which must be distributed under the terms of Sections + 1 and 2 above on a medium customarily used for software interchange; or, + + b) Accompany it with a written offer, valid for at least three + years, to give any third party, for a charge no more than your + cost of physically performing source distribution, a complete + machine-readable copy of the corresponding source code, to be + distributed under the terms of Sections 1 and 2 above on a medium + customarily used for software interchange; or, + + c) Accompany it with the information you received as to the offer + to distribute corresponding source code. (This alternative is + allowed only for noncommercial distribution and only if you + received the program in object code or executable form with such + an offer, in accord with Subsection b above.) + +The source code for a work means the preferred form of the work for +making modifications to it. For an executable work, complete source +code means all the source code for all modules it contains, plus any +associated interface definition files, plus the scripts used to +control compilation and installation of the executable. However, as a +special exception, the source code distributed need not include +anything that is normally distributed (in either source or binary +form) with the major components (compiler, kernel, and so on) of the +operating system on which the executable runs, unless that component +itself accompanies the executable. + +If distribution of executable or object code is made by offering +access to copy from a designated place, then offering equivalent +access to copy the source code from the same place counts as +distribution of the source code, even though third parties are not +compelled to copy the source along with the object code. + + 4. You may not copy, modify, sublicense, or distribute the Program +except as expressly provided under this License. Any attempt +otherwise to copy, modify, sublicense or distribute the Program is +void, and will automatically terminate your rights under this License. +However, parties who have received copies, or rights, from you under +this License will not have their licenses terminated so long as such +parties remain in full compliance. + + 5. You are not required to accept this License, since you have not +signed it. However, nothing else grants you permission to modify or +distribute the Program or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Program (or any work based on the +Program), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Program or works based on it. + + 6. Each time you redistribute the Program (or any work based on the +Program), the recipient automatically receives a license from the +original licensor to copy, distribute or modify the Program subject to +these terms and conditions. You may not impose any further +restrictions on the recipients' exercise of the rights granted herein. +You are not responsible for enforcing compliance by third parties to +this License. + + 7. If, as a consequence of a court judgment or allegation of patent +infringement or for any other reason (not limited to patent issues), +conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot +distribute so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you +may not distribute the Program at all. For example, if a patent +license would not permit royalty-free redistribution of the Program by +all those who receive copies directly or indirectly through you, then +the only way you could satisfy both it and this License would be to +refrain entirely from distribution of the Program. + +If any portion of this section is held invalid or unenforceable under +any particular circumstance, the balance of the section is intended to +apply and the section as a whole is intended to apply in other +circumstances. + +It is not the purpose of this section to induce you to infringe any +patents or other property right claims or to contest validity of any +such claims; this section has the sole purpose of protecting the +integrity of the free software distribution system, which is +implemented by public license practices. Many people have made +generous contributions to the wide range of software distributed +through that system in reliance on consistent application of that +system; it is up to the author/donor to decide if he or she is willing +to distribute software through any other system and a licensee cannot +impose that choice. + +This section is intended to make thoroughly clear what is believed to +be a consequence of the rest of this License. + + 8. If the distribution and/or use of the Program is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Program under this License +may add an explicit geographical distribution limitation excluding +those countries, so that distribution is permitted only in or among +countries not thus excluded. In such case, this License incorporates +the limitation as if written in the body of this License. + + 9. The Free Software Foundation may publish revised and/or new versions +of the General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + +Each version is given a distinguishing version number. If the Program +specifies a version number of this License which applies to it and "any +later version", you have the option of following the terms and conditions +either of that version or of any later version published by the Free +Software Foundation. If the Program does not specify a version number of +this License, you may choose any version ever published by the Free Software +Foundation. + + 10. If you wish to incorporate parts of the Program into other free +programs whose distribution conditions are different, write to the author +to ask for permission. For software which is copyrighted by the Free +Software Foundation, write to the Free Software Foundation; we sometimes +make exceptions for this. Our decision will be guided by the two goals +of preserving the free status of all derivatives of our free software and +of promoting the sharing and reuse of software generally. + + NO WARRANTY + + 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY +FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN +OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES +PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED +OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS +TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE +PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, +REPAIR OR CORRECTION. + + 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR +REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, +INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING +OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED +TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY +YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER +PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE +POSSIBILITY OF SUCH DAMAGES. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +convey the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + + +Also add information on how to contact you by electronic and paper mail. + +If the program is interactive, make it output a short notice like this +when it starts in an interactive mode: + + Gnomovision version 69, Copyright (C) year name of author + Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, the commands you use may +be called something other than `show w' and `show c'; they could even be +mouse-clicks or menu items--whatever suits your program. + +You should also get your employer (if you work as a programmer) or your +school, if any, to sign a "copyright disclaimer" for the program, if +necessary. Here is a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the program + `Gnomovision' (which makes passes at compilers) written by James Hacker. + + , 1 April 1989 + Ty Coon, President of Vice + +This General Public License does not permit incorporating your program into +proprietary programs. If your program is a subroutine library, you may +consider it more useful to permit linking proprietary applications with the +library. If this is what you want to do, use the GNU Library General +Public License instead of this License. diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..ec7f72f --- /dev/null +++ b/LICENSE @@ -0,0 +1,28 @@ +Copyright (c) 2005-2023 Code Synthesis. + +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License version 2 as +published by the Free Software Foundation. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for details. + +You should have received a copy of the GNU General Public License +along with this program; if not, write to the Free Software +Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + +In addition, as a special exception, Code Synthesis gives permission to +link this program with the Xerces-C++ library (or with modified versions +of Xerces-C++ that use the same license as Xerces-C++), and distribute +linked combinations including the two. You must obey the GNU General +Public License version 2 in all respects for all of the code used other +than Xerces-C++. If you modify this copy of the program, you may extend +this exception to your version of the program, but you are not obligated +to do so. If you do not wish to do so, delete this exception statement +from your version. + +In addition, Code Synthesis makes a special exception for the Free/Libre +and Open Source Software (FLOSS) which is described in the accompanying +FLOSSE file. diff --git a/NEWS b/NEWS new file mode 100644 index 0000000..cd4e0ce --- /dev/null +++ b/NEWS @@ -0,0 +1,1271 @@ +Version 4.2.0 + + * In this version we have switched to the build2 build system. For the + step-by-step instructions on how to build XSD from source on all the + major platforms, see: + + https://codesynthesis.com/products/xsd/doc/install-build2.xhtml + + * In this version we have changed the default C++ standard that is used + by the generated code from C++98 to C++11. While you can still request + C++98 with the --std=c++98 option, note that this is the last release + that supports the C++98 standard and the next release will require C++11 + or later (in fact, building the XSD compiler itself already requires + C++11 or later). Note also that the --std option now recognizes the + c++14, c++17, c++20, and c++23 additional values. + + * This version will be the last release that supports Xerces-C++ earlier + than 3.1.0 and the next release will require Xerces-C++ 3.1.0 or later. + + * New --file-list-only option that allows only writing the list of C++ + files that would be generated without actually generating them. + + * The --file-list option now recognize the `-` value as a request to write + to stdout. + + * New --dep-file option that allows specifying the dependency file name. + It also allows writing the dependency information to stdout by specifying + `-` as this option's value. + + * This version contains a large number of bug fixes and minor improvements + that have accumulated over the years. + +C++/Tree + + * Support for abstract XML Schema types. The corresponding C++ classes now + have the _clone() member function declared pure virtual which prevents + the construction of instances of such types. + + Note that if after upgrading to this version you start getting C++ + compile errors in the generated code with diagnostics saying that a + type cannot be instantiated because _clone() is pure virtual, then + it's a strong indication that this type (or its base) is polymorphic + and needs to be marked as such (see --polymorphic-type* options). + + * New base_string() accessors in the xml_schema::{string,uri} types that + return the underlying string. + + * Support for `ucc` (upper-camel-case) value in the --function-naming + option. + + * New C++/Tree `secure` example (xsd-examples/cxx/tree/secure/) shows how + to perform more secure XML parsing by disabling the XML External Entity + (XXE) Processing. See the accompanying README file for details. + +Version 4.1.0 + + * This version was never released. It was skipped due to a minor versioning + scheme adjustment in the pre-release component when migrating to build2. + +Version 4.0.0 + + * Xerces-C++ 2-series (2.8.0 and earlier) is no longer supported. + + * Visual Studio 2003 (7.1) is no longer supported. + + * HP aCC3 (HP-UX/PA-RISC) is no longer supported. + + * Oracle/Berkeley DB XML support has been removed since it no longer + supports the Xerces-C++-based document access. + + * New option, --std, specifies the C++ standard that the generated code + should conform to. Valid values are c++98 (default) and c++11. + + The C++ standard affects various aspects of the generated code that are + discussed in more detail in mapping-specific documentation (guides and + manuals). Overall, when C++11 is selected, the generated code relies on + the move semantics and uses std::unique_ptr instead of deprecated + std::auto_ptr. See also the documentation for the --std option in the + XSD compiler command line manual (man pages). + + * New option, --fat-type-file, triggers the placement of code corresponding + to global elements into type files instead of schema files in the file- + per-type mode. This option is primarily useful when trying to minimize + the amount of object code that is linked to an executable by packaging + compiled generated code into a static (archive) library. + +C++/Tree + + * Support for ordered types. C++/Tree flattens nested compositors which + sometimes can result in the loss of element ordering information that + could be significant to the application. Ordered types address this + problem. For more information, refer to Section 2.8.4, "Element Order" + in the C++/Tree Mapping User Manual. + + * Support for mixed content in ordered types. For more information, refer + to Section 2.13, "Mapping for Mixed Content Models" in the C++/Tree + Mapping User Manual. + + * xml_schema::type represents anyType content as a DOM fragment, similar + to wildcards. For more information, refer to Section 2.5.2, "Mapping + for anyType" in the C++/Tree Mapping User Manual. + + * xml_schema::simple_type represents anySimpleType content as a text + string. For more information, refer to Section 2.5.3, "Mapping for + anySimpleType" in the C++/Tree Mapping User Manual. + + * Improved streaming example that now provides better XML namespace + handling and supports streaming parsing and serialization at multiple + document levels. + + * New option, --generate-dep, triggers the generation of the make + dependency files (.d) for the generated C++ files. Other options + controlling dependency generation are: --generate-dep-only, + --dep-phony, --dep-target, --dep-suffix, and --dep-regex. For + details on this functionality, refer to the XSD compiler command + line manual (man pages). + + * New option, --suppress-assignment, suppresses the generation of copy + assignment operators for complex types. If this option is specified, + the copy assignment operators for such types are declared private and + left unimplemented. + + * Binary representation now stores string-based enumerations as integer + values corresponding to C++ enumerators instead of string literals. + + * Binary representation now pools polymorphic type-id strings in an + implicit string pool. The string pool support can also be used to + pool strings in other situations. For example, you can implement + string insertion/extraction operators for your stream to pool all + strings. This can be useful if your documents contain a large number + of repetitive strings. + + * New option, --polymorphic-plate, allows the creation of multiple + polymorphic map plates in the same application. For details, refer + to the XSD compiler command line manual (man pages). + + * To get the DOM association in the copy of an object model tree one + now needs to explicitly pass the xml_schema::flags::keep_dom flag as + the second argument to the copy constructor or clone() function. + +Version 3.3.0 + + * New option, --char-encoding, allows you to specify the character encoding + that should be used in the generated code. Valid values for the 'char' + character type are 'utf8' (default), 'iso8859-1' (new), 'lcp' (Xerces-C++ + local code page), and 'custom' (provides support for custom encodings). + Note that if you use a non-default character encoding and include some + libxsd headers (e.g., xsd/cxx/xml/string.hxx) directly, then you will + need to first include the correct xsd/cxx/xml/char-.hxx header, + where is iso8859-1, lcp, etc. This mechanism replaces the + XSD_USE_LCP macro. + + For the wchar_t character type the only valid value for this option is + 'auto' and the encoding is automatically selected between UTF-16 and + UTF-32, depending on the wchar_t type size. + + * When the XSD compiler is built with Xerces-C++ 3.1.0 or later, the + handling of multiple imports for the same namespace is enabled. Before, + all subsequent imports for a namespace were ignored which caused errors + in some schemas. Note that if your application has XML Schema validation + enabled, then you will also need to build it with Xerces-C++ 3.1.0 or + later to take advantage of this feature. + + * Automatic mapping for the urn-style XML namespaces. The last component + in the urn name is used to derive the C++ namespace name. + + * New option, --schema-file-regex, in combination with the existing + --type-file-regex, can be used to place the generated files into + subdirectories or to resolve file name conflicts in the file-per- + type mode (--file-per-type). + + * Warning id's have changed to start with a letter identifying the + component issuing the warning. F - compiler frontend, D - compiler + driver, P - C++/Parser mapping, T - C++/Tree mapping. + + * Strings used to match regular expressions supplied with the + --namespace-regex and --anonymous-regex options now include the file + component for the schema being compiled. + + * The XSD_NO_EXPORT macro can be used to omit code generated with the + --export/import-maps and, for C++/Tree, --generate-xml-schema options + during C++ compilation. This may be useful if you would like to use + the same generated code across multiple platforms. + + C++/Tree + + * New option, --generate-element-type, triggers the generation of types + instead of parsing/serialization functions for root elements. This + is primarily useful to distinguish object models with the same root + type but with different root elements. For more information, refer + to the messaging example and Section 2.9.1, "Element Types" in the + C++/Tree Mapping User Manual. To support the customization of the + element type naming the --element-type-regex option has been added. + See the NAMING CONVENTION section in the compiler command line manual + (man pages) for details. + + * New option, --generate-element-map, triggers the generation of a root + element map. The element map allows uniform parsing and serialization + of multiple root elements. This option can only be used together with + --generate-element-type. For more information, refer to the messaging + example and Section 2.9.2, "Element Map" in the C++/Tree Mapping + User Manual. + + * Prior to this version, if the --generate-polymorphic option is + specified, the compiler treats all types as potentially polymorphic. + Now by default only type hierarchies used in substitution groups and + those explicitly declared polymorphic with the new --polymorphic-type + option are treated as polymorphic. This results in smaller and faster + generated code. If you would like to continue using the old behavior, + you will need to specify --polymorphic-type-all. For more information, + on this change see Section 2.11, "Mapping for xsi:type and Substitution + Groups" in the C++/Tree Mapping User Manual. + + * New option, --generate-detach, triggers the generation of detach + functions for required elements and attributes. For optional and + sequence cardinalities the detach functions are now provided by the + respective containers even without this option. These functions, for + example, allow one to move sub-trees in the object model either within + the same tree or between different trees without copying. For more + information, refer to Section 2.8 "Mapping for Local Elements and + Attributes" in the C++/Tree Mapping User Manual. + + * New option, --export-xml-schema, causes the compiler to export/import + types in the XML Schema namespace using the export symbol provided + with the --export-symbol option. + + * New example, embedded, shows how to embed the binary representation of + the schema grammar into an application and then use it to parse and + validate XML documents. + + * New example, compression, shows how to compress an XML document during + serialization and decompress it during parsing using the zlib library. + + * New example, custom/mixed, shows how to use type customization to parse + and serialize mixed content. + + * The streaming example has been extended to show how to perform stream- + oriented, partially in-memory XML processing using the C++/Tree mapping. + With the partially in-memory parsing and serialization only a part of + the object model is in memory at any given time. With this approach one + can process parts of the document as they become available as well as + handle documents that are too large to fit into memory. + + * New default/fixed value initialization code. Now the default/fixed values + are parsed by the XSD compiler at compile time instead of the standard + parsing code at runtime. This will allow the compilation of schemas that + use the default/fixed values without support for XML parsing + (--suppress-parsing option). + + * Empty XML Schema enumeration values are now mapped to the 'empty' C++ + enumerator name instead of 'cxx'. + + * XML Schema union types with members that are enumeration types are + automatically converted to equivalent enumeration types with a union + of all the members' enumerators. + +Version 3.2.0 + + * New option, --disable-warning, disables printing of a warning with + the specified id. Specifying 'all' for the warning id disables all + warnings. + + * New options, --export-maps and --import-maps, provide support for + splitting a polymorphic type hierarchy across several Win32 DLLs. + See the compiler command line manual (man pages) for details. + + C++/Tree + + * During serialization the generated code automatically assigns + generic prefixes (p1, p2, etc) to XML namespaces used in the + vocabulary and for which no custom prefix-namespace mapping + was provided via the xml_schema::namespace_infomap argument. + The xml_schema::namespace_infomap argument in the serialization + functions is now default-initialized to an empty map. The + xml_schema::no_namespace_mapping and xml_schema::xsi_already_in_use + exceptions have been removed. + + * New example, performance, measures the performance of parsing and + serialization. This example also shows how to structure your code + to achieve the maximum performance for these two operations. + + * New example, xpath, shows how to use the C++/Tree mapping together + with XPath. + + * New options, --one-accessor-regex, --opt-accessor-regex, + --seq-accessor-regex, --one-modifier-regex, --opt-modifier-regex, + and --seq-modifier-regex, allow specification of transformations + for accessor and modifier function names for elements and attributes + with specific cardinalities. For more information see the NAMING + CONVENTION section in the compiler command line manual (man pages). + + * Support for comparison (--generate-comparison) and printing + (--generate-ostream) of polymorphic object models. + + * New serialization flag, xml_schema::flags::dont_pretty_print, + disables extra spaces and new lines that make the resulting XML + slightly bigger but easier to read. + + * New example, custom/double, shows how to customize parsing and + serialization code for the xsd:double XML Schema built-in type. + It can be used as a guide on how to customize built-in XML Schema + types that are mapped to fundamental C++ types. + + * Support for fractionDigits and totalDigits facets in serialization + of types derived from xsd:decimal. + + * New set of compile-time macros that control how the xsd:float, + xsd:double, and xsd:decimal types are serialized. The following + macros control the format: + + XSD_CXX_TREE_FLOAT_FIXED + XSD_CXX_TREE_FLOAT_SCIENTIFIC + XSD_CXX_TREE_DOUBLE_FIXED + XSD_CXX_TREE_DOUBLE_SCIENTIFIC + + The following macros control the precision: + + XSD_CXX_TREE_FLOAT_PRECISION_MAX + XSD_CXX_TREE_FLOAT_PRECISION + XSD_CXX_TREE_DOUBLE_PRECISION_MAX + XSD_CXX_TREE_DOUBLE_PRECISION + XSD_CXX_TREE_DECIMAL_PRECISION_MAX + XSD_CXX_TREE_DECIMAL_PRECISION + + If the *_PRECISION_MAX macro is defined then the maximum number of + potentially significant decimal digits that the type can represent + is used. Otherwise, if the *_PRECISION macro is defined then its + value is used. By default the precision is set to the number of + decimal digits that the type can represent without change. For + more information on these options, refer to the following paper: + + http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2005/n1822.pdf + + The old macro, XSD_FP_ALL_DIGITS, that was equivalent to defining + all three *_PRECISION_MAX macros has been removed. + + An alternative to using these macros is to customize the floating + point type as shown in the custom/double example. + + * An additional constructor is generated in situations where a type + contains one or more required element of complex type (that is, + it itself contains elements or attributes). In this constructor, + initializers for such elements are passed as std::auto_ptr and the + newly created instance is directly initialized with and assumes + ownership of the pointed to objects. This constructor is a logical + addition to the non-copying modifiers that were introduced in the + previous version. + + * Extra conversion operators in the fundamental_base class template + which is used to emulate inheritance from fundamental types are now + disabled by default since they cause problems on several compilers. + To enable them compile your code with the XSD_TREE_EXTRA_FUND_CONV + macro defined. + + C++/Parser + + * New options, --generate-xml-schema and --extern-xml-schema, trigger + generation of the mapping for the XML Schema namespace to a separate + header file and inclusion of that header into other generated header + files instead of generating the necessary declarations inline, + respectively. See the compiler command line manual (man pages) for + details. + + * New example, performance, measures the performance of XML parsing. + This example also shows how to structure your code to achieve the + maximum performance for this operation. + + * Type map files can now include comments. A comment starts with # + and ends with a new line or end of file. To specify a name that + contains # enclose it in "". + + * In type map files the optional argument type now defaults to the + return type if the return type ends with * or & (that is, it is + a pointer or a reference) and 'const return type&' otherwise. + + * The interface for polymorphic parsing has been simplified. Calling the + *_parser() functions multiple times to specify several parsers is no + longer supported. Instead you need to pass the xml_schema::parser_map + object which contains the parsers. For more information refer to + Section 5.4, "Support for Polymorphism" in the C++/Parser Mapping + Getting Started Guide. + + * The use of virtual inheritance has been reduced which results in a + much smaller object code size (more than factor of 2 on some tests) + and faster C++ compilation with less RAM used. + + * The low-level Expat-specific parsing API (parse_begin() and parse_end()) + has been extended to provide XML and XML Schema error translation to + exceptions or error handler calls. See Section 7.2, "Expat Document + Parser" in the C++/Parser Mapping Getting Started Guide for more + information. + +Version 3.1.0 + + * New option, --file-per-type, triggers generation of a separate set + of C++ files for each type defined in XML Schema. This compilation + mode is primarily useful when some of your schemas cannot be compiled + separately or have cyclic dependencies which involve inheritance. + Other new options that are useful in this compilation mode are + --type-file-regex, --type-file-regex-trace, and --file-list. See the + compiler command line manual (man pages) for more information. + + * New option, --options-file, allows additional command line options + to be provided in files, with one option per line. + + * New option, --reserved-name, allows insertion of additional names + with optional replacements to the list of names that should not be + used as identifiers. See the compiler command line manual (man pages) + for details. + + * New options, --location-map, --location-regex, and + --location-regex-trace, allow re-mapping of schema locations + specified in the include and import elements without modifying the + schema files. See the compiler command line manual (man pages) for + more information. + + * New option, --guard-prefix, allows specification of a prefix that + should be added to generated header inclusion guards. + + * New option, --file-list, triggers creation of a file with a list of + generated C++ files. This option is primarily useful in the file-per- + type compilation mode (--file-per-type) to create a list of generated + C++ files, for example, as a makefile fragment. Other new options + that are useful with --file-list are --file-list-prologue, + --file-list-epilogue, and --file-list-delim. See the compiler command + line manual (man pages) for more information. + + * Support for the upcoming Xerces-C++ 3.0.0 release. + + C++/Tree + + * New option, --generate-intellisense, triggers generation of workarounds + for IntelliSense bugs in Visual Studio 2005 (8.0). When this option is + used, the resulting code is slightly more verbose. IntelliSense in + Visual Studio 2008 (9.0) does not require these workarounds. Support + for IntelliSense in Visual Studio 2003 (7.1) is improved with this + option but is still incomplete. + + * New options, --type-naming and --function-naming, allow specification + of the type and function naming conventions that should be used in the + generated code. Supported values for --type-naming are: knr (K&R), ucc + (upper-camel-case), and java. Supported values for --function-naming + are: knr (K&R), lcc (lower-camel-case), and java. For more information + see the NAMING CONVENTION section in the compiler command line manual + (man pages). + + * New options, --type-regex, --accessor-regex, --modifier-regex, + --parser-regex, --serializer-regex, and --enumerator-regex, allow + specification of transformations for type, accessor function, + modifier function, parsing function, serialization function, and + enumerator names in order to produce the generated code using a + custom naming convention. For more information see the NAMING + CONVENTION section in the compiler command line manual (man pages). + + * Generated list classes now provide a complete set of constructors and + conform to the standard C++ sequence interface. + + * String-based types now provide two extra constructors that expect a + C string and std::string as their arguments. This allows direct + initialization of string-based types from string literals. + + * New implementations of the XML Schema date/time types (date, dateTime, + duration, gDay, gMonth, gMonthDay, gYear, gYearMonth, and time) that + represent the information in the numerical form. + + * New binary serialization examples: binary/boost, which shows how to + save/load the object model to/from a custom format using the Boost + serialization library as an example, and binary/xdr, which shows how to + save/load the object model to/from XDR (eXternal Data Representation) + binary format using the XDR API provided as part of Sun RPC. + + * The non-copying modifier functions can now be used to assemble object + models from scratch. For more information see Section 4.4, "Creating + the Object Model from Scratch" in the C++/Tree Mapping Getting Started + Guide as well as Section 2.8, "Mapping for Local Elements and Attributes" + in the C++/Tree Mapping User Manual. + + * Doxygen documentation was added to the XSD runtime for the built-in XML + Schema types, exceptions, etc. This allows linking of the generated + documentation to the XSD runtime documentation using the Doxygen tags + mechanism. The Doxygen configuration file for the XSD runtime is + provided in the documentation/cxx/tree/reference/ directory. + + * Support for customization of anyType. Because anyType is a base type + for every generated type, customizing it allows one to implement custom + functionality that spans the entire type system. See the comments + example in the examples/cxx/tree/custom/ directory. + + * New option, --omit-default-attributes, triggers generation of extra + checks that exclude attributes with default and fixed values from the + serialized XML documents. + + * The parsing functions that used to read from DOMInputSource were changed + to use InputSource to ease support of Xerces-C++ 3 and 2 series in the + same code base. + + * The parsing function that used to parse DOMDocument* was changed to + parse xml_schema::dom::auto_ptr& instead. If the keep_dom + and own_dom flags are specified then this parsing function resets the + passed automatic pointer and the returned object model assumes + ownership of the DOM document. xml_schema::dom::auto_ptr is a simple + automatic pointer for Xerces-C++ DOM with the same interface as + std::auto_ptr. + + * The xml_schema::tree_node_key DOM user data key was moved to + xml_schema::dom::tree_node_key. + + C++/Parser + + * New option, --generate-polymorphic, triggers generation of polymorphism- + aware code. This option should be used on XML vocabularies which use + xsi:type and/or substitution groups. For more information see Section + 5.4, "Support for Polymorphism" in the C++/Parser Mapping Getting + Started Guide we well as the polymorphism and polyroot examples in the + examples/cxx/parser/ directory. + + * The date/time types (date, dateTime, gDay, gMonth, gMonthDay, gYear, + gYearMonth, and time) now represent time zone in the numerical form. + + * In order to support parsing of polymorphic XML documents, the signatures + of the start_* functions (_start_element, _start_any_element, and + start_root_element) have changed to include a third argument of type + const ro_string*. This argument contains the resolved type name and + namespace in case the xsi:type attribute was specified. + +Version 3.0.0 + + * Anonymous type morphing (automatic type naming) is now performed by + default in both mappings. The --morph-anonymous option does not have + any effect but is preserved for backwards compatibility. A new option, + --preserve-anonymous, disables anonymous type morphing. This option is + useful together with --show-anonymous if you want to make sure your + schemas do not have any anonymous types. + + * A number of bugs fixed in both C++/Tree and C++/Parser mappings. + + C++/Tree + + * The new C++/Tree Mapping Getting Started Guide is available in the + documentation/cxx/tree/guide/ directory. + + * The type definitions for local elements and attributes in the form + name::type have been changed to name_type. For example, an element + bar in type foo with maxOccurs="unbounded" used to have its iterator + type defined as foo::bar::iterator. With this change it becomes + foo::bar_iterator. Furthermore, the container type name for sequence + elements has changed from foo::bar::container to foo::bar_sequence + and for optional elements and attributes from foo::bar::container + to foo::bar_optional. This is a backwards incompatible change and + may require application code adjustments (the C++ compiler will + pinpoint the affected places). + + * New option, --generate-doxygen, triggers generation of documentation + comments suitable for extraction by the Doxygen documentation system. + Documentation from annotations is added to the comments if present in + the schema. + + * New option, --generate-wildcard, triggers generation of the new + wildcard (any and anyAttribute) mapping. This mapping represents the + content matched by wildcards as DOM fragments. For more information on + the new mapping see Section 2.12, "Mapping for any and anyAttribute" + in the C++/Tree Mapping User Manual as well as the wildcard example in + the examples/cxx/tree/ directory. + + * New option, --generate-comparison, triggers generation of comparison + operators (== and !=) for complex types. Comparison is performed + memberwise. + + * Support for the RPC XDR binary stream in addition to ACE CDR. + + * New constructor is generated for complex types with ultimate bases + that are simple types and can be default-initialized. This constructor + includes initializers for all required members but omits the initializer + for the base type. See Section 2.7, "Mapping for Complex Types" in the + C++/Tree Mapping User Manual for more information. + + * Support for polymorphic binary serialization and extraction. Note that + the semantics of the --generate-insertion and --generate-extraction + options has changed. See the the compiler command line manual (man + pages) for details. + + * New parsing function with the DOMDocument* argument and the own_dom + flag allow the tree to assume the ownership of the DOM document + being parsed when DOM association is requested (keep_dom flag). + See the C++/Tree Mapping User Manual for more information. + + * New example, multiroot, shows how to handle XML vocabularies with + multiple root elements. + + * New example, caching, shows how to parse several XML documents while + reusing the underlying XML parser and caching the schemas used for + validation. + + * The mapping of built-in XML Schema type decimal has changed from + long double to double. The old mapping can be obtained by providing + a custom mapping for this type. + + * The xml_schema::errors type which is used in the xml_schema::parsing + and xml_schema::serialization exceptions has been renamed to + xml_schema::diagnostics and extended to include warnings in addition + to errors. + + * Serialization operators now clear the element being serialized to from + existing child nodes and attributes (except for special attributes such + as prefix-namespace mappings, etc.). + + * Improved built-in type parsing, including support for normalization and + whitespace collapsing. + + * Optimizations for the generated code size and compilation time, + including space optimizations for polymorphic parsing and + serialization. Optimizations for XML parsing speed. + + C++/Parser + + * The C++/Parser mapping have been significantly redesigned. See the new + Getting Started Guide in documentation/cxx/parser/guide/ for details. + + * The new C++/Parser Mapping Getting Started Guide is available in the + documentation/cxx/parser/guide/ directory. + + * The mapping now provides parser implementations for all built-in XML + Schema types. See Chapter 6, "Built-In XML Schema Type Parsers" in + the C++/Parser Mapping Getting Started Guide for more information. + + * The mapping now supports automatic generation of sample parser + implementations and a test driver. The --generate-noop-impl option + triggers generation of a sample implementation with empty function + bodies. The --generate-print-impl option triggers generation of a + sample implementation that prints the data stored in XML to STDOUT. + The --generate-test-driver option trigger generation of a test driver. + For more information on this feature see the compiler command line + manual (man pages) and the generated example in the examples/cxx/parser/ + directory. Other relevant options include: --force-overwrite, + --root-element-first, --root-element-last, and --root-element. + + * New example, wildcard, shows how to parse the XML data matched by + XML Schema wildcards (any and anyAttribute). + + * The xml_schema::document parser has been extended with overridable + virtual functions start_root_element and end_root_element to support + parsing of XML vocabularies with multiple document roots. See the + multiroot example in the examples/cxx/parser/ directory for more + information. + + * The xml_schema::errors type which is used in the xml_schema::parsing + exception has been renamed to xml_schema::diagnostics and extended to + include warnings in addition to errors. + +Version 2.3.1 + + * The compiler is now capable of translating multiple schemas with + one invocation. + + * New option, --sloc-limit, allows one to limit the amount of the + generated code. + + * New option, --proprietary-license, instructs the compiler not to + include the GPL banner in each generated file. Instead a short + notice about a required proprietary license is generated. You + should not use this option unless you have obtained a proprietary + license from Code Synthesis. + + * The default encoding for the 'char' character type is now UTF-8. + To get the previous behavior (local code page via the Xerces-C++ + transcode functions) define the XSD_USE_LCP preprocessor macro + when compiling your source code. + + C++/Tree + + * The --parts option has been improved to split generated code more + evenly by analyzing the complexity of the generated schema constructs. + + * Ability to customize serialization, std::ostream, and binary + insertion/extraction operators. See examples/cxx/tree/custom/wildcard + for an example on how to handle XML Schema wildcards (xsd:any and + xsd:anyAttribute) by customizing the parsing constructor and + serialization operators. + + * Optimizations for the run-time memory consumption. + + * Optimizations for space in the generated code. + + * Number of bug fixes. + + C++/Parser + + * Proper handling of an xsd:any nested content. Nested elements, + attributes, and text are reported via _any_* hooks of the current + parser. + + * Number of bug fixes, mostly in the generated validation code. + + +Version 2.3.0 + + * Name conflicts across type inheritance hierarchies are now detected + and resolved via name escaping. + + C++/Tree + + * New option, --suppress-parsing, suppresses generation of the parsing + constructors and functions. This can be used to minimize the generated + code footprint when parsing from XML is not used. + + * New option, --generate-forward, triggers generation of a forward + declaration header file for types defined in the schema. A set of + --fwd-* options that control the resulting file name as well as + prologue and epilogue code are available. + + * New option, --generate-xml-schema, triggers generation of the mapping + for the XML Schema namespace to a separate header file. See the man + pages for details and examples/cxx/tree/custom/calendar for an example. + + * New option, --extern-xml-schema, triggers inclusion of a header + file for the XML Schema namespace instead of generating the + necessary declarations inline. See the man pages for details and + examples/cxx/tree/custom/calendar for an example. + + * New options, --custom-type and --custom-type-regex, instruct the + compiler to use custom C++ type for a type defined in the schema. + The standard mapping can still be generated (with a different name) + usually to be used as a base. Built-in XML Schema types can be + customized using this mechanism. See the man pages for details and + examples/cxx/tree/custom/* for examples. + + * The generated parsing constructors and serialization operators have + been changed to use the Xerces-C++ DOM elements and attributes + instead of the internal wrapper types. This should provide easier + integration with other code and libraries that use the Xerces-C++ + DOM types such as Berkeley DB XML. + + * New example, examples/cxx/tree/dbxml, shows how to use the C++/Tree + mapping on top of the Berkeley DB XML database. + + C++/Parser + + * Validation of the attribute structure in the generated code. + + * Validation of the character content models including mixed content in + the generated code. + + * Validation of the built-in XML Schema types. + + * Optimizations for space and time in the generated code. In particular + data coping during parsing and validation was significantly reduced. + + +Version 2.2.0 + + * Detection of a version mismatch between the generated code and + the runtime. + + C++/Tree + + * Escaping of a global element name that conflicts with a global type + name. This is a backwards-incompatible change. Previous versions + map them to the same name. + + * New options, --generate--insertion and --generate-extraction, + trigger generation of (binary) data representation stream + insertion and extraction operators, respectively. This allows + one to serialize/deserialize in-memory representation to/from + data representation streams such as XSD, CDR, etc. ACE CDR + streams are supported out of the box (see the binary example). + User-supplied streams can be used via an adaptation layer. + + * New serialization flag, no_xml_declaration, instructs the XML + serialization functions to omit an XML declaration. This is useful + for streaming serialization (see the streaming example). + + * Optimizations to reduce generated code size. + + + C++/Parser + + * New options, --generate-validation and --suppress-validation, + trigger and suppress generation of the validation code, + respectively. The validation code is the implementation of the + XML Schema validation in the generated code (also known as + "perfect" parser). In this version validation of the element + structure has been implemented. + + * New architecture for underlying XML parsers. This is a backwards- + incompatible change. Existing applications will have to be + modified. See examples for details. + + +Version 2.1.1 + + C++/Tree + + * New option, --namespace-map, allows direct mapping of XML Schema + namespaces to C++ namespaces without the use of regular expressions. + + * Further optimizations in the container code and enum mapping to + reduce generated code size. + + * Number of bug fixes in the generated code. + + + C++/Parser + + * New option, --namespace-map, allows direct mapping of XML Schema + namespaces to C++ namespaces without the use of regular expressions. + + +Version 2.1.0 + + * Automatic handling of forward inheritance. XML Schema allows + inheritance from yet undefined types while it is illegal to do + so in C++. Now the translator automatically handles forward + inheritance by re-arranging the schema during compilation. + + + C++/Tree + + * New enum mapping with support for inheritance. Enumerators are + now parsed using binary search instead of linear search. + + * Associated DOM nodes now retain "back" pointers to tree nodes. + + * Optimizations to reduce generated code size. + + + C++/Parser + + * Specialization for void. You can now use void as a hook argument + type if you don't want to pass any data between parsers. + + * Support for re-use of implementations of base parsers in derived + parsers using the mixin C++ idiom. See the examples/cxx/parser/mixin + for more information. + + * Support for uninitialized parser. If you don't provide a parser + for element/attribute, that element/attribute will be ignored + during parsing. + + +Version 2.0.0 + + * New cardinality calculator. This improves support for schemas that + use complex structures with repeated elements, e.g., + + + + + + + + + + + + + + + + * New identifier escaping code. With this feature xsd generates proper + code for schemas that use the same name for an element and an attribute + in the same type or use several elements/attributes with different + qualified names but with the same local name, e.g., + + + + + + + + + + + + + + + + + + + + + + + + + + C++/Tree + + * New option, --generate-polymorphic, triggers generation of + polymorphism-aware code. Before this release xsd used to always + generate polymorphism-aware code. However, it appears to be quite + wasteful in terms of the generated code size (up to 40%). You will + now need to explicitly specify this option if you use substitution + groups or xsi:type. A warning is issued if this option is not + specified but the schema makes use of substitution groups. + + * New options, --root-element-first, --root-element-last, + --root-element-all, --root-element-none, and --root-element, control + generation of parsing and serialization functions. With these options + you can avoid generating extra code for global elements that are not + document roots. See the man pages for details. + + * New options, --parts and -parts-suffix, allows you to split generated + source code into a number of parts. This is useful when translating + large, monolithic schemas and a C++ compiler is not able to compile + the resulting source code at once (usually due to insufficient memory). + + * New option, --generate-default-ctor, triggers generation of default + constructors even for types that have required members. Required + members of an instance constructed using such a constructor are not + initialized and accessing them results in undefined behavior. Thanks + to Jean-Francois Dube for suggesting this + feature. + + * New option, --generate-from-base-ctor, triggers generation of + constructors that expect an instance of a base type followed by all + required members. Thanks to Jean-Francois Dube + for suggesting this feature. + + * Information scopes for attributes and elements with default/fixed values + now define the public static default_value function which allows one to + obtain the default/fixed value for the element/attribute. Thanks to + Dave Moss for suggesting this feature. + + * MSVC 7.1 has a limit on the length of the "if else if" chain. This + results in ICE when compiling generated code for enumerations with + a large number of values. This version addresses this issue. Thanks + to Cyrille Chépélov for reporting this and + suggesting a fix. + + + C++/Parser + + * The parser construction API has changed. Now, for element 'foo', + the name of the parser modifier function is 'foo_parser'. Likewise, + operator() for setting all parsers at once has been changed to the + 'parsers' function. + + +Version 1.9.0 + + C++/Tree + + * The size modifier function in the base64_binary and hex_binary + built-in types automatically adjusts capacity if needed. + + * More internal names (names that start with _xsd_) were made + private or protected. + + C++/Parser + + * Typedef for the parser base in the xml_schema namespace. + + C++/Parser-E + + * C++/Parser mapping optimized for embedded systems. For now it + is equivalent to 'cxx-parser --xml-parser expat'. + + +Version 1.8.0 + + * Moved to the build 0.2 series. + + C++/Tree + + * Support for default and fixed values in attributes. An optional + attribute with a default or fixed value is mapped to the One + cardinality class instead of the Optional cardinality class. + + * Mapping for base64Binary and hexBinary has improved. Now these + types support a basic buffer abstraction and perform automatic + encoding and decoding. + + * Internal names are protected. We've noticed (via bug reports) a + wide use of internal names (names that start with _xsd_) in user + code. This is not portable and instead you should use public + names. To prevent this from happening in the future we've made + all internal names protected. + + C++/Parser + + * Support for Expat as the underlying XML parser in addition to + Xerces-C++. This allows one to use the C++/Parser mapping in + memory-constrained environments such as embedded systems. To + select Expat instead of Xerces-C++ (default) add + '--xml-parser expat' to the command line. At the moment only + 'char' (UTF-8) is supported as the base character type when + Expat is selected. + + * The invalid_instance exception has been renamed to parsing. + + * Generic error_handler interface has been added in addition + to Xerces-C++-specific DOMErrorHandler. It allows you to + handle parsing errors and warnings without having to deal + with Xerces-C++ specifics. + + * The default error handling behavior has changed in parsing + functions. Instead of printing errors and warnings to STDERR, + the errors are now collected and thrown as part of the parsing + exception. + + * In parsing functions, the name, namespace arguments order has + been reversed to be consistent with the one used in parsing + hooks. + +Version 1.7.0 + + * Number of bug fixes in libxsd and the generated code. + + C++/Tree + + * Comprehensive XML Schema C++/Tree Mapping User Manual. + + * Basic support for union. A simple type that is defined using + derivation by union is mapped to a C++ class that derives from + string. + + * The _clone function has its arguments default-initialized. + + * The invalid_instance exception has been renamed to parsing. + + * Generic error_handler interface has been added in addition + to Xerces-C++-specific DOMErrorHandler. It allows you to + handle parsing/serialization errors and warnings without + having to deal with Xerces-C++ specifics. See the user + manual for more information. + + * The default error handling behavior has changed in parsing + and serialization functions. Instead of printing errors and + warnings to STDERR, the errors are now collected and thrown + as part of the parsing/serialization exception. See the user + manual for more information. + + * The optional and sequence containers now support operators ==, + !=, <, >, <=, and >=. + + * Flags argument has been added to serialization functions. The + only flag that is currently supported is dont_initialize. + + * Generated code cleanups. + + C++/Parser + + * Basic support for union. A simple type that is defined using + derivation by union is mapped to a C++ class template that + is just an alias for the generic parser. You are expected to + override the _characters function in your implementation. + + * Properties argument to parsing functions which allows to + programmatically specify schemas for instance document + validation. + + * Flags argument to parsing functions. The following flags + are supported: + + dont_validate - do not validate instance documents + dont_initialize - do not initialize the Xerces-C++ runtime + +Version 1.6.0 + + * Number of bug fixes in libxsd and the generated code. + + C++/Tree + + * Support for xsi:type and substitution groups in parsing and + serialization. See examples/cxx/tree/polymorphism for a code + sample. + + * Properties argument to parsing functions which allows to + programmatically specify schemas for instance document + validation. + + * Extra checks in parsing code which prevents construction + of inconsistent in-memory representation from invalid + instance documents. Should be useful when validation is + disabled. + + * Accessors and modifier were made normal member functions. + Before they were implemented via functors. + + * Workaround for g++-3.3 bug# 16650: + + http://gcc.gnu.org/bugzilla/show_bug.cgi?id=16650 + + C++/Parser + + * All "service" functions were renamed to start with '_'. + This should prevent hiding of service functions by + elements/attributes with the same names. + +Version 1.5.0 + + * Number of bug fixes in libxsd and the generated code. + + C++/Tree + + * Basic support for inheritance-by-restriction in complex types. + + * The following parsing flags have been introduced: + + keep_dom - keep association with underlying DOM nodes + dont_validate - do not validate instance documents + dont_initialize - do not initialize the Xerces-C++ runtime + + * "Type-less content" such as mixed content models, xsd:anyType/ + xsd:anySimpleType, and xsd:any/xsd:anyAttribute is supported by + exposing corresponding DOM nodes (see the keep_dom parsing flag). + Note that only a subset of XML Schema xsd:any functionality is + supported. The compiler will issue diagnostics for unsupported + cases. See examples/cxx/tree/mixed for a code sample. + + C++/Parser + + * Support for inheritance-by-restriction in complex types. + + * "Type-less content" such as mixed content models, xsd:anyType/ + xsd:anySimpleType, and xsd:any/xsd:anyAttribute is supported + by forwarding parsing events to a set of "unexpected" hooks. + Note that only a subset of XML Schema xsd:any functionality is + supported. The compiler will issue diagnostics for unsupported + cases. See examples/cxx/parser/mixed for a code sample. + +Version 1.4.0 + + * Number of improvements and bug fixes in the diagnostics code. + + * libxsd has been reorganized to provide a clean split of code with + regards to char/wchar_t use. It should be possible to use libxsd + and the xsd-generated code on platforms that lack wchar_t support, + such as mingw. + + C++/Tree + + * Work around for g++ bug# 23206. + + * Support for xsd:list. + + * Type/member name conflicts are auto-resolved. Such conflicts + occur when a type and an element or attribute withing this type + share the same name. + + * XML Schema extension, the 'refType' attribute, allows one to + specify referenced type for xsd:IDREF and xsd:IDREFS data types. + See examples/cxx/tree/library for details. + + * New option, --morph-anonymous, allows automatic morphing + of anonymous types to named ones. See the man pages for + details. + + * New option, --namespace-regex-trace, allows one to trace the + namespace mapping process. See the man pages for details. + + * Mapping for optional elements/attributes (cardinality 0..1) + has changed in a backwards-incompatible way. In the previous + version you would write: + + Bar& bar = ... + + if (bar.foo.present ()) // test + { + Foo& foo (bar.foo ()); // get + + bar.foo (Foo (...)); // set + + bar.foo.reset (); // reset + } + + Now you would write it like this: + + if (bar.foo ().present ()) // test + { + Foo& foo (bar.foo ().get ()); // get + + bar.foo (Foo (...)); // set + + bar.foo ().reset (); // reset + } + + Or using the pointer notation: + + if (bar.foo ()) // test + { + Foo& foo (*bar.foo ()); // get + + bar.foo (Foo (...)); // set + + bar.foo ().reset (); // reset + } + + C++/Parser + + * Support for xsd:list. + + * Type/member name conflicts are auto-resolved. Such conflicts + occur when a type and an element or attribute withing this type + share the same name. + + * New option, --namespace-regex-trace, allows one to trace the + namespace mapping process. See the man pages for details. + +Version 1.3.0 + + * Numerous bug fixes. + + * The XML subsystem of libxsd has been reorganized to provide + a clean split of DOM and SAX functionalities. + + C++/Parser + + * New option, --morph-anonymous, allows automatic morphing + of anonymous types to named ones. See the man pages for + details. + + C++/Tree + + * Additional parser functions provide support for reading + from std::istream. + +Version 1.2.0 + + C++/Parser + + * New backend that generates the C++/Parser mapping. + +Version 1.1.1 + + all backends + + * Bug fixes in the filesystem path handling logic. + +Version 1.1.0 + + C++/Tree + + * New option, --generate-serialization, triggers generation of + serialization functions. Serialization functions convert an in-memory + representation back to XML. + + * xsd::cxx::tree::vector has been extended to closely follow std::vector + API. This allows you to access and modify element sequences as if they + were of type std::vector. + + * Generated constructors from xml::attribute and xml::element are made + explicit. + + * The library example was extended to showcase modification and + serialization of the in-memory representation. + + * New "XML Schema C++/Tree Mapping Serialization Guide" has an in-depth + treatment of the serialization mechanisms provided by xsd. + +Version 1.0.1 + + all backends + + * Improved diagnostics. + + * Bug fixes in the schema inclusion/importing logic. + + C++/Tree + + * Two new options: --include-with-brackets and --include-prefix + +Version 1.0.0 + + * First public release. diff --git a/PACKAGE-README.md b/PACKAGE-README.md new file mode 100644 index 0000000..4a1ce70 --- /dev/null +++ b/PACKAGE-README.md @@ -0,0 +1,66 @@ +# XSD + +XSD is an open-source, cross-platform XML Schema to C++ data binding +compiler. Provided with an XML document specification (XML Schema), it +generates C++ classes that represent the given vocabulary as well as XML +parsing and serialization code. You can then access the data stored in XML +using types and functions that semantically correspond to your application +domain rather than dealing with generic elements/attributes and raw strings. + +For further information, refer to the [XSD project +page](https://codesynthesis.com/products/xsd/). + +## Usage + +XSD consists of several packages with the main ones being `xsd` (the XML +Schema to C++ compiler) and `libxsd` (the runtime library). There are also +several `*-tests` packages as well as `xsd-examples`. + +When specifying dependencies on XSD packages in your project, the `xsd` +package should be a build-time dependency. The `libxsd` library is +header-only and because it can be used either with Xerces-C++ or +Expat as the underlying XML parser, it does not have a dependency on +either, expecting your project to make the choice by depending on +one or the other explicitly and then importing and linking the +corresponding library. + +So, putting it all together, your project's `manifest` would normally +have the following fragment if using Xerces-C++: + +``` +depends: * xsd ^4.2.0 +depends: libxsd ^4.2.0 +depends libxerces-c ^3.2.4 +``` + +Or the following fragment if using Expat: + +``` +depends: * xsd ^4.2.0 +depends: libxsd ^4.2.0 +depends libexpat ^2.5.0 +``` + +Then your `buildfile` would have something along these lines if using +Xerces-C++: + +``` +import! [metadata] xsd = xsd%exe{xsd} + +import libs = libxsd%lib{xsd} +import libs += libxerces-c%lib{xerces-c} +``` + +Or along these lines if using Expat: + +``` +import! [metadata] xsd = xsd%exe{xsd} + +import libs = libxsd%lib{xsd} +import libs += libexpat%lib{expat} +``` + +Note that the `xsd` executable provides `build2` metadata. + +The compilation of XML Schema to C++ can be implemented using ad hoc recipes +or rules. See the `xsd-examples` package for the complete examples. diff --git a/README.md b/README.md new file mode 100644 index 0000000..e2b2887 --- /dev/null +++ b/README.md @@ -0,0 +1,12 @@ +# xsd - XML Schema to C++ data binding compiler + +XSD is an open-source, cross-platform XML Schema to C++ data binding +compiler. Provided with an XML document specification (XML Schema), it +generates C++ classes that represent the given vocabulary as well as XML +parsing and serialization code. You can then access the data stored in XML +using types and functions that semantically correspond to your application +domain rather than dealing with generic elements/attributes and raw strings. + +For further information, including licensing conditions, documentation, and +binary packages, refer to the [XSD project +page](https://codesynthesis.com/products/xsd/). diff --git a/build/bootstrap.build b/build/bootstrap.build new file mode 100644 index 0000000..6c0d4ab --- /dev/null +++ b/build/bootstrap.build @@ -0,0 +1,10 @@ +# file : build/bootstrap.build +# license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +project = xsd + +using version +using config +using test +using dist +using install diff --git a/build/export.build b/build/export.build new file mode 100644 index 0000000..68ffad0 --- /dev/null +++ b/build/export.build @@ -0,0 +1,9 @@ +# file : build/export.build +# license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +$out_root/ +{ + include xsd/ +} + +export $out_root/xsd/exe{xsd} diff --git a/build/root.build b/build/root.build new file mode 100644 index 0000000..cf9d6a6 --- /dev/null +++ b/build/root.build @@ -0,0 +1,37 @@ +# file : build/root.build +# license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +config [bool] config.xsd.develop ?= false + +develop = $config.xsd.develop + +define cli: file +cli{*}: extension = cli + +using in + +cxx.std = latest + +using cxx + +hxx{*}: extension = hxx +ixx{*}: extension = ixx +txx{*}: extension = txx +cxx{*}: extension = cxx + +if ($cxx.target.system == 'win32-msvc') + cxx.poptions += -D_CRT_SECURE_NO_WARNINGS -D_SCL_SECURE_NO_WARNINGS + +if ($cxx.class == 'msvc') + cxx.coptions += /wd4251 /wd4275 /wd4800 + +cxx.poptions =+ "-I$out_root" "-I$src_root" + +# Extract the copyright notice from the LICENSE file. +# +# Note that cat is a builtin which means this is both portable and fast. +# +if ($build.mode != 'skeleton') + copyright = $process.run_regex(cat $src_root/LICENSE, \ + 'Copyright \(c\) (.+)\.', \ + '\1') diff --git a/buildfile b/buildfile new file mode 100644 index 0000000..b0121dd --- /dev/null +++ b/buildfile @@ -0,0 +1,11 @@ +# file : buildfile +# license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +./: {*/ -build/} \ + doc{README.md PACKAGE-README.md NEWS} \ + legal{GPLv2 LICENSE FLOSSE} \ + manifest + +# Don't install tests. +# +tests/: install = false diff --git a/doc/buildfile b/doc/buildfile new file mode 100644 index 0000000..3d2b949 --- /dev/null +++ b/doc/buildfile @@ -0,0 +1,293 @@ +# file : doc/buildfile +# license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +define css: doc +css{*}: extension = css + +define xsd: doc +xsd{*}: extension = xsd + +define xhtml: doc +xhtml{*}: extension = xhtml + +define ps: doc +ps{*}: extension = ps + +define pdf: doc +pdf{*}: extension = pdf + +define html2ps: file +html2ps{*}: extension = html2ps + +define png: doc +png{*}: extension = png + +define svg: file +svg{*}: extension = svg + +./: css{default} xsd{custom-literals} {png svg}{**} + +# Man pages. +# + +## Consumption build ($develop == false). +# + +# Use pregenerated versions in the consumption build. +# +./: pregenerated/{man1 xhtml}{*}: include = (!$develop) + +# Distribute pregenerated versions only in the consumption build. +# +pregenerated/{man1 xhtml}{*}: dist = (!$develop) + +# +## + +## Development build ($develop == true). +# + +./: {man1 xhtml}{xsd}: include = $develop + +if $develop +{ + doc_version = [string] "$version.major.$version.minor.$version.patch" + if $version.pre_release + doc_version += "-$version.pre_release_string" + + # Let's take the last four-digit number to cover 2000-2021,2022. + # + doc_year = $regex.replace($copyright, '.+[-, ]([0-9][0-9][0-9][0-9]) .+', '\1') + + man_options = -v project="XSD" \ + -v version="$doc_version" \ + -v copyright="$copyright" \ + -I $src_root \ + --stdout \ + --suppress-undocumented \ + --exclude-base + + import! [metadata] cli = cli%exe{cli} +} + +# In the development build distribute regenerated versions, remapping their +# locations to the paths of the pregenerated versions (which are only +# distributed in the consumption build; see above). This way we make sure that +# the distributed files are always up-to-date. +# +{man1 xhtml}{xsd}: dist = ($develop ? pregenerated/ : false) + +ops = ../xsd/cli{options cxx/options cxx/tree/options cxx/parser/options} + +man1{xsd}: $ops \ + file{xsd-prologue.1 \ + xsd-tree-header.1 \ + xsd-parser-header.1 \ + xsd-epilogue.1} \ + $cli +% +if $develop +{{ + o = $path($>) + + # Use the copyright year to approximate the last authoring date. + # + $cli --generate-man $man_options \ + -v date="January $doc_year" \ + --class CXX::options \ + --class options \ + --man-prologue-file $path($<[4]) \ + $path($<[1]) >$o + + $cli --generate-man $man_options \ + -v date="January $doc_year" \ + --man-prologue-file $path($<[5]) \ + $path($<[2]) >>$o + + $cli --generate-man $man_options \ + -v date="January $doc_year" \ + --man-prologue-file $path($<[6]) \ + --man-epilogue-file $path($<[7]) \ + $path($<[3]) >>$o + + # If the result differs from the pregenerated version, copy it over. + # + if! diff $src_base/pregenerated/xsd.1 $o >- + cp $o $src_base/pregenerated/xsd.1 + end +}} + +xhtml{xsd}: $ops \ + file{xsd-prologue.xhtml \ + xsd-tree-header.xhtml \ + xsd-parser-header.xhtml \ + xsd-epilogue.xhtml} \ + $cli +% +if $develop +{{ + o = $path($>) + + $cli --generate-html $man_options \ + -v date="January $doc_year" \ + --class CXX::options \ + --class options \ + --html-prologue-file $path($<[4]) \ + $path($<[1]) >$o + + $cli --generate-html $man_options \ + -v date="January $doc_year" \ + --html-prologue-file $path($<[5]) \ + $path($<[2]) >>$o + + $cli --generate-html $man_options \ + -v date="January $doc_year" \ + --html-prologue-file $path($<[6]) \ + --html-epilogue-file $path($<[7]) \ + $path($<[3]) >>$o + + if! diff $src_base/pregenerated/xsd.xhtml $o >- + cp $o $src_base/pregenerated/xsd.xhtml + end +}} + +# +## + +# Manuals/guides. +# +# This case is slightly more involved because we make the generation of the +# manuals/guides ps/pdf files optional and also don't keep the result in the +# repository. Specifically: +# +# 1. In the consumption build we will install/redistribute ps/pdf if present. +# +# 2. In the development build we will generate ps/pdf if we are able to import +# the needed tools, issuing a warning otherwise. +# +# 3. We generate manuals/guides xhtml files from the templates and distribute +# them. + +manuals = cxx/parser/guide/index cxx/tree/guide/index cxx/tree/manual/index + +for m: $manuals +{ + ./: xhtml{$m}: in{$m} + { + in.symbol = '@' + + dist = true + clean = ($src_root != $out_root) + } +} + +## Consumption build ($develop == false). +# + +# Use pregenerated versions, if exist, in the consumption build. +# +./: pregenerated/{ps pdf}{**}: include = (!$develop) + +# Distribute pregenerated versions only in the consumption build. +# +pregenerated/{ps pdf}{*}: dist = (!$develop) + +# +## + +## Development build ($develop == true). +# + +html2pdf = false + +if $develop +{ + # Import the html2ps and ps2pdf programs from the system, if available. + # + import? html2ps = html2ps%exe{html2ps} + import? ps2pdf = ps2pdf14%exe{ps2pdf14} + + html2pdf = ($html2ps != [null] && $ps2pdf != [null]) + + if! $html2pdf + warn "html2ps and/or ps2pdf14 are not available, not generating .ps and .pdf documentation" +} + +for m: $manuals +{ + d = $directory($m) # cxx/parser/guide/, etc + p = "$leaf($directory($d))" # parser, tree + l = "$leaf($d)" # guide, manual + f = "cxx-$p-$l" # cxx-parser-guide, etc + + pf = $d/$f # cxx/parser/guide/cxx-parser-guide, etc + cf = $d/$l # cxx/parser/guide/guide, etc + + ./: {ps pdf}{$pf}: include = $html2pdf + + # In the development build distribute regenerated versions, remapping their + # locations to the paths of the pregenerated versions (which are only + # distributed in the consumption build; see above). This way we make sure + # that the distributed files are always up-to-date. + # + {ps pdf}{$pf}: \ + dist = ($html2pdf ? $relative([dir_path] "pregenerated/$d", $d) : false) + + pdf{$pf}: ps{$pf}: xhtml{$m} html2ps{$cf} + + html2ps{$cf}: in{$cf} + { + in.symbol = '@' + } +} + +# Note: the pregenerated file may not exist, thus --no-cleanup option is +# required for the mkdir and cp builtin calls. Strictly speaking we don't +# really need to copy them since they are not stored in the repository, but +# let's do that for consistency with the distributed source tree. +# +ps{~'/cxx-.+-(.+)/'}: xhtml{~'/index/'} html2ps{~'/\1/'} $html2ps +% +if $html2pdf +{{ + # cxx/parser/guide/, etc + # + d = [dir_path] $leaf($directory($path($>[0])), $out_base) + + # Note: --base must include trailing directory separator. + # + options = --base $src_base/$d + + diag html2ps ($<[0]) -> $> + $html2ps $options -f $path($<[1]) -o $path($>) $path($<[0]) + + # Note: must include trailing directory separator (see cp for details). + # + d = $src_base/pregenerated/$d + + mkdir -p --no-cleanup $d + cp --no-cleanup $path($>) $d +}} + +pdf{~'/(cxx-.+-.+)/'}: ps{~'/\1/'} $ps2pdf +% +if $html2pdf +{{ + options = -dOptimize=true -dEmbedAllFonts=true + + diag ps2pdf ($<[0]) -> $> + $ps2pdf $options $path($<[0]) $path($>) + + # Note: must include trailing directory separator (see cp for details). + # + d = $src_base/pregenerated/$leaf($directory($path($>[0])), $out_base) + + mkdir -p --no-cleanup $d + cp --no-cleanup $path($>) $d +}} + +# +## + +doc{*}: install.subdirs = true +pregenerated/doc{*}: install.subdirs = true diff --git a/doc/custom-literals.xsd b/doc/custom-literals.xsd new file mode 100644 index 0000000..c6f7613 --- /dev/null +++ b/doc/custom-literals.xsd @@ -0,0 +1,48 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/doc/cxx/parser/guide/figure-1.png b/doc/cxx/parser/guide/figure-1.png new file mode 100644 index 0000000..15d1723 Binary files /dev/null and b/doc/cxx/parser/guide/figure-1.png differ diff --git a/doc/cxx/parser/guide/figure-1.svg b/doc/cxx/parser/guide/figure-1.svg new file mode 100644 index 0000000..d994a79 --- /dev/null +++ b/doc/cxx/parser/guide/figure-1.svg @@ -0,0 +1,373 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + image/svg+xml + + + + + + + + class people_pimpl{ void person ();}; + + + + class person_pimpl{ void first_name (string); void last_name (string); void gender (); void age (short); void post_person ();}; + + + + class string_pimpl{ string post_string ();}; + + + class short_pimpl{ short post_short ();}; + + + class gender_pimpl{ void post_gender ();}; + + + + + + + diff --git a/doc/cxx/parser/guide/guide.html2ps.in b/doc/cxx/parser/guide/guide.html2ps.in new file mode 100644 index 0000000..8131487 --- /dev/null +++ b/doc/cxx/parser/guide/guide.html2ps.in @@ -0,0 +1,65 @@ +@@html2ps { + option { + toc: hb; + colour: 1; + hyphenate: 1; + titlepage: 1; + } + + datefmt: "%B %Y"; + + titlepage { + content: " +
+

C++/Parser Mapping

+

Getting Started Guide

+

 

+

 

+

 

+

 

+

 

+

 

+
+

Copyright © @copyright@.

+ +

Permission is granted to copy, distribute and/or modify this + document under the terms of the + GNU Free + Documentation License, version 1.2; with no Invariant Sections, + no Front-Cover Texts and no Back-Cover Texts. +

+ +

This document is available in the following formats: + XHTML, + PDF, and + PostScript.

"; + } + + toc { + indent: 2em; + } + + header { + odd-right: $H; + even-left: $H; + } + + footer { + odd-left: $D; + odd-center: $T; + odd-right: $N; + + even-left: $N; + even-center: $T; + even-right: $D; + } +} + +body { + font-size: 12pt; + text-align: justify; +} + +pre { + font-size: 10pt; +} diff --git a/doc/cxx/parser/guide/index.xhtml b/doc/cxx/parser/guide/index.xhtml new file mode 100644 index 0000000..6964a14 --- /dev/null +++ b/doc/cxx/parser/guide/index.xhtml @@ -0,0 +1,4163 @@ + + + + + + C++/Parser Mapping Getting Started Guide + + + + + + + + + + + + + +
+
+ +
+ +
+
C++/Parser Mapping
+
Getting Started Guide
+ +

Copyright © 2005-2023 Code Synthesis.

+ +

Permission is granted to copy, distribute and/or modify this + document under the terms of the + GNU Free + Documentation License, version 1.2; with no Invariant Sections, + no Front-Cover Texts and no Back-Cover Texts. +

+ +

This document is available in the following formats: + XHTML, + PDF, and + PostScript.

+ +
+ +

Table of Contents

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Preface + + + +
About This Document
More Information
+
1Introduction + + + +
1.1Mapping Overview
1.2Benefits
+
2Hello World Example + + + + + +
2.1Writing XML Document and Schema
2.2Translating Schema to C++
2.3Implementing Application Logic
2.4Compiling and Running
+
3Parser Skeletons + + + + + +
3.1Implementing the Gender Parser
3.2Implementing the Person Parser
3.3Implementing the People Parser
3.4Connecting the Parsers Together
+
4Type Maps + + + + +
4.1Object Model
4.2Type Map File Format
4.3Parser Implementations
+
5Mapping Configuration + + + + + + +
5.1C++ Standard
5.2Character Type and Encoding
5.3Underlying XML Parser
5.4XML Schema Validation
5.5Support for Polymorphism
+
6Built-In XML Schema Type Parsers + + + + + + + + + + + + + + +
6.1QName Parser
6.2NMTOKENS and IDREFS Parsers
6.3base64Binary and hexBinary Parsers
6.4Time Zone Representation
6.5date Parser
6.6dateTime Parser
6.7duration Parser
6.8gDay Parser
6.9gMonth Parser
6.10gMonthDay Parser
6.11gYear Parser
6.12gYearMonth Parser
6.13time Parser
+
7Document Parser and Error Handling + + + + +
7.1Xerces-C++ Document Parser
7.2Expat Document Parser
7.3Error Handling
+
Appendix A — Supported XML Schema Constructs
+
+ +

Preface

+ +

About This Document

+ +

The goal of this document is to provide you with an understanding of + the C++/Parser programming model and allow you to efficiently evaluate + XSD against your project's technical requirements. As such, this + document is intended for C++ developers and software architects + who are looking for an XML processing solution. Prior experience + with XML and C++ is required to understand this document. Basic + understanding of XML Schema is advantageous but not expected + or required. +

+ + +

More Information

+ +

Beyond this guide, you may also find the following sources of + information useful:

+ +
    +
  • XSD + Compiler Command Line Manual
    • + +
  • The cxx/parser/ directory in the + xsd-examples package + contains a collection of examples and a README file with an overview + of each example.
    • + +
  • The README file in the + xsd-examples package + explains how to build the examples.
    • + +
  • The xsd-users + mailing list is the place to ask technical questions about XSD and the C++/Parser mapping. + Furthermore, the archives + may already have answers to some of your questions.
    • + +
+ + + +

1 Introduction

+ +

Welcome to CodeSynthesis XSD and the C++/Parser mapping. XSD is a + cross-platform W3C XML Schema to C++ data binding compiler. C++/Parser + is a W3C XML Schema to C++ mapping that represents an XML vocabulary + as a set of parser skeletons which you can implement to perform XML + processing as required by your application logic. +

+ +

1.1 Mapping Overview

+ +

The C++/Parser mapping provides event-driven, stream-oriented + XML parsing, XML Schema validation, and C++ data binding. It was + specifically designed and optimized for high performance and + small footprint. Based on the static analysis of the schemas, XSD + generates compact, highly-optimized hierarchical state machines + that combine data extraction, validation, and even dispatching + in a single step. As a result, the generated code is typically + 2-10 times faster than general-purpose validating XML parsers + while maintaining the lowest static and dynamic memory footprints. +

+ +

To speed up application development, the C++/Parser mapping + can be instructed to generate sample parser implementations + and a test driver which can then be filled with the application + logic code. The mapping also provides a wide range of + mechanisms for controlling and customizing the generated code.

+ +

The next chapter shows how to create a simple application that uses + the C++/Parser mapping to parse, validate, and extract data from a + simple XML document. The following chapters show how to + use the C++/Parser mapping in more detail.

+ +

1.2 Benefits

+ +

Traditional XML access APIs such as Document Object Model (DOM) + or Simple API for XML (SAX) have a number of drawbacks that + make them less suitable for creating robust and maintainable + XML processing applications. These drawbacks include: +

+ +
    +
  • Generic representation of XML in terms of elements, attributes, + and text forces an application developer to write a substantial + amount of bridging code that identifies and transforms pieces + of information encoded in XML to a representation more suitable + for consumption by the application logic.
    • + +
  • String-based flow control defers error detection to runtime. + It also reduces code readability and maintainability.
    • + +
  • Lack of type safety because the data is represented + as text.
    • + +
  • Resulting applications are hard to debug, change, and + maintain.
    • +
+ +

In contrast, statically-typed, vocabulary-specific parser + skeletons produced by the C++/Parser mapping allow you to + operate in your domain terms instead of the generic elements, + attributes, and text. Static typing helps catch errors at + compile-time rather than at run-time. Automatic code generation + frees you for more interesting tasks (such as doing something + useful with the information stored in the XML documents) and + minimizes the effort needed to adapt your applications to + changes in the document structure. To summarize, the C++/Parser + mapping has the following key advantages over generic XML + access APIs:

+ +
    +
  • Ease of use. The generated code hides all the complexity + associated with recreating the document structure, maintaining the + dispatch state, and converting the data from the text representation + to data types suitable for manipulation by the application logic. + Parser skeletons also provide a convenient mechanism for building + custom in-memory representations.
    • + +
  • Natural representation. The generated parser skeletons + implement parser callbacks as virtual functions with names + corresponding to elements and attributes in XML. As a result, + you process the XML data using your domain vocabulary instead + of generic elements, attributes, and text. +
    • + +
  • Concise code. With a separate parser skeleton for each + XML Schema type, the application implementation is + simpler and thus easier to read and understand.
    • + +
  • Safety. The XML data is delivered to parser callbacks as + statically typed objects. The parser callbacks themselves are virtual + functions. This helps catch programming errors at compile-time + rather than at runtime.
    • + +
  • Maintainability. Automatic code generation minimizes the + effort needed to adapt the application to changes in the + document structure. With static typing, the C++ compiler + can pin-point the places in the application code that need to be + changed.
    • + +
  • Efficiency. The generated parser skeletons combine + data extraction, validation, and even dispatching in a single + step. This makes them much more efficient than traditional + architectures with separate stages for validation and data + extraction/dispatch.
    • +
+ + + + +

2 Hello World Example

+ +

In this chapter we will examine how to parse a very simple XML + document using the XSD-generated C++/Parser skeletons. + The code presented in this chapter is based on the hello + example which can be found in the cxx/parser/ directory in + the xsd-examples + package.

+ +

2.1 Writing XML Document and Schema

+ +

First, we need to get an idea about the structure + of the XML documents we are going to process. Our + hello.xml, for example, could look like this:

+ + 
+<?xml version="1.0"?>
+<hello>
+
+  <greeting>Hello</greeting>
+
+  <name>sun</name>
+  <name>moon</name>
+  <name>world</name>
+
+</hello>
+
+ +

Then we can write a description of the above XML in the + XML Schema language and save it into hello.xsd:

+ + 
+<?xml version="1.0"?>
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+
+  <xs:complexType name="hello">
+    <xs:sequence>
+      <xs:element name="greeting" type="xs:string"/>
+      <xs:element name="name" type="xs:string" maxOccurs="unbounded"/>
+    </xs:sequence>
+  </xs:complexType>
+
+  <xs:element name="hello" type="hello"/>
+
+</xs:schema>
+
+ +

Even if you are not familiar with XML Schema, it + should be easy to connect declarations in hello.xsd + to elements in hello.xml. The hello type + is defined as a sequence of the nested greeting and + name elements. Note that the term sequence in XML + Schema means that elements should appear in a particular order + as opposed to appearing multiple times. The name + element has its maxOccurs property set to + unbounded which means it can appear multiple times + in an XML document. Finally, the globally-defined hello + element prescribes the root element for our vocabulary. For an + easily-approachable introduction to XML Schema refer to + XML Schema Part 0: + Primer.

+ +

The above schema is a specification of our XML vocabulary; it tells + everybody what valid documents of our XML-based language should look + like. The next step is to compile this schema to generate + the object model and parsing functions.

+ +

2.2 Translating Schema to C++

+ +

Now we are ready to translate our hello.xsd to C++ parser + skeletons. To do this we invoke the XSD compiler from a terminal + (UNIX) or a command prompt (Windows): +

+ + 
+$ xsd cxx-parser --xml-parser expat hello.xsd
+
+ +

The --xml-parser option indicates that we want to + use Expat as the underlying XML parser (see Section + 5.3, "Underlying XML Parser"). The XSD compiler produces two + C++ files: hello-pskel.hxx and hello-pskel.cxx. + The following code fragment is taken from hello-pskel.hxx; + it should give you an idea about what gets generated: +

+ + 
+class hello_pskel
+{
+public:
+  // Parser callbacks. Override them in your implementation.
+  //
+  virtual void
+  pre ();
+
+  virtual void
+  greeting (const std::string&);
+
+  virtual void
+  name (const std::string&);
+
+  virtual void
+  post_hello ();
+
+  // Parser construction API.
+  //
+  void
+  greeting_parser (xml_schema::string_pskel&);
+
+  void
+  name_parser (xml_schema::string_pskel&);
+
+  void
+  parsers (xml_schema::string_pskel& /* greeting */,
+           xml_schema::string_pskel& /* name */);
+
+private:
+  ...
+};
+
+ +

The first four member functions shown above are called parser + callbacks. You would normally override them in your implementation + of the parser to do something useful. Let's go through all of + them one by one.

+ +

The pre() function is an initialization callback. It is + called when a new element of type hello is about + to be parsed. You would normally use this function to allocate a new + instance of the resulting type or clear accumulators that are used + to gather information during parsing. The default implementation + of this function does nothing.

+ +

The post_hello() function is a finalization callback. Its + name is constructed by adding the parser skeleton name to the + post_ prefix. The finalization callback is called when + parsing of the element is complete and the result, if any, should + be returned. Note that in our case the return type of + post_hello() is void which means there + is nothing to return. More on parser return types later. +

+ +

You may be wondering why the finalization callback is called + post_hello() instead of post() just + like pre(). The reason for this is that + finalization callbacks can have different return types and + result in function signature clashes across inheritance + hierarchies. To prevent this the signatures of finalization + callbacks are made unique by adding the type name to their names.

+ +

The greeting() and name() functions are + called when the greeting and name elements + have been parsed, respectively. Their arguments are of type + std::string and contain the data extracted from XML.

+ +

The last three functions are for connecting parsers to each other. + For example, there is a predefined parser for built-in XML Schema type + string in the XSD runtime. We will be using + it to parse the contents of greeting and + name elements, as shown in the next section.

+ +

2.3 Implementing Application Logic

+ +

At this point we have all the parts we need to do something useful + with the information stored in our XML document. The first step is + to implement the parser: +

+ + 
+#include <iostream>
+#include "hello-pskel.hxx"
+
+class hello_pimpl: public hello_pskel
+{
+public:
+  virtual void
+  greeting (const std::string& g)
+  {
+    greeting_ = g;
+  }
+
+  virtual void
+  name (const std::string& n)
+  {
+    std::cout << greeting_ << ", " << n << "!" << std::endl;
+  }
+
+private:
+  std::string greeting_;
+};
+
+ +

We left both pre() and post_hello() with the + default implementations; we don't have anything to initialize or + return. The rest is pretty straightforward: we store the greeting + in a member variable and later, when parsing names, use it to + say hello.

+ +

An observant reader my ask what happens if the name + element comes before greeting? Don't we need to + make sure greeting_ was initialized and report + an error otherwise? The answer is no, we don't have to do + any of this. The hello_pskel parser skeleton + performs validation of XML according to the schema from which + it was generated. As a result, it will check the order + of the greeting and name elements + and report an error if it is violated.

+ +

Now it is time to put this parser implementation to work:

+ + 
+using namespace std;
+
+int
+main (int argc, char* argv[])
+{
+  try
+  {
+    // Construct the parser.
+    //
+    xml_schema::string_pimpl string_p;
+    hello_pimpl hello_p;
+
+    hello_p.greeting_parser (string_p);
+    hello_p.name_parser (string_p);
+
+    // Parse the XML instance.
+    //
+    xml_schema::document doc_p (hello_p, "hello");
+
+    hello_p.pre ();
+    doc_p.parse (argv[1]);
+    hello_p.post_hello ();
+  }
+  catch (const xml_schema::exception& e)
+  {
+    cerr << e << endl;
+    return 1;
+  }
+}
+
+ +

The first part of this code snippet instantiates individual parsers + and assembles them into a complete vocabulary parser. + xml_schema::string_pimpl is an implementation of a parser + for built-in XML Schema type string. It is provided by + the XSD runtime along with parsers for other built-in types (for + more information on the built-in parsers see Chapter 6, + "Built-In XML Schema Type Parsers"). We use string_pimpl + to parse the greeting and name elements as + indicated by the calls to greeting_parser() and + name_parser(). +

+ +

Then we instantiate a document parser (doc_p). The + first argument to its constructor is the parser for + the root element (hello_p in our case). The + second argument is the root element name. +

+ +

The final piece is the calls to pre(), parse(), + and post_hello(). The call to parse() + perform the actual XML parsing while the calls to pre() and + post_hello() make sure that the parser for the root + element can perform proper initialization and cleanup.

+ +

While our parser implementation and test driver are pretty small and + easy to write by hand, for bigger XML vocabularies it can be a + substantial effort. To help with this task XSD can automatically + generate sample parser implementations and a test driver from your + schemas. You can request the generation of a sample implementation with + empty function bodies by specifying the --generate-noop-impl + option. Or you can generate a sample implementation that prints the + data store in XML by using the --generate-print-impl + option. To request the generation of a test driver you can use the + --generate-test-driver option. For more information + on these options refer to the + XSD + Compiler Command Line Manual. The 'generated' example + in the xsd-examples package + shows the sample implementation generation feature in action.

+ + +

2.4 Compiling and Running

+ +

After saving all the parts from the previous section in + driver.cxx, we are ready to compile our first + application and run it on the test XML document. On a UNIX + system this can be done with the following commands: +

+ + 
+$ c++ -std=c++11 -I.../libxsd -c driver.cxx hello-pskel.cxx
+$ c++ -std=c++11 -o driver driver.o hello-pskel.o -lexpat
+$ ./driver hello.xml
+Hello, sun!
+Hello, moon!
+Hello, world!
+
+ +

Here .../libxsd represents the path to the + libxsd package root + directory. We can also test the error handling. To test XML + well-formedness checking, we can try to parse + hello-pskel.hxx:

+ + 
+$ ./driver hello-pskel.hxx
+hello-pskel.hxx:1:0: not well-formed (invalid token)
+
+ +

We can also try to parse a valid XML but not from our + vocabulary, for example hello.xsd:

+ + 
+$ ./driver hello.xsd
+hello.xsd:2:0: expected element 'hello' instead of
+'http://www.w3.org/2001/XMLSchema#schema'
+
+ + + + + +

3 Parser Skeletons

+ +

As we have seen in the previous chapter, the XSD compiler generates + a parser skeleton class for each type defined in XML Schema. In + this chapter we will take a closer look at different functions + that comprise a parser skeleton as well as the way to connect + our implementations of these parser skeletons to create a complete + parser.

+ +

In this and subsequent chapters we will use the following schema + that describes a collection of person records. We save it in + people.xsd:

+ + 
+<?xml version="1.0"?>
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+
+  <xs:simpleType name="gender">
+    <xs:restriction base="xs:string">
+      <xs:enumeration value="male"/>
+      <xs:enumeration value="female"/>
+    </xs:restriction>
+  </xs:simpleType>
+
+  <xs:complexType name="person">
+    <xs:sequence>
+      <xs:element name="first-name" type="xs:string"/>
+      <xs:element name="last-name" type="xs:string"/>
+      <xs:element name="gender" type="gender"/>
+      <xs:element name="age" type="xs:short"/>
+    </xs:sequence>
+  </xs:complexType>
+
+  <xs:complexType name="people">
+    <xs:sequence>
+      <xs:element name="person" type="person" maxOccurs="unbounded"/>
+    </xs:sequence>
+  </xs:complexType>
+
+  <xs:element name="people" type="people"/>
+
+</xs:schema>
+
+ +

A sample XML instance to go along with this schema is saved + in people.xml:

+ + 
+<?xml version="1.0"?>
+<people>
+  <person>
+    <first-name>John</first-name>
+    <last-name>Doe</last-name>
+    <gender>male</gender>
+    <age>32</age>
+  </person>
+  <person>
+    <first-name>Jane</first-name>
+    <last-name>Doe</last-name>
+    <gender>female</gender>
+    <age>28</age>
+  </person>
+</people>
+
+ +

Compiling people.xsd with the XSD compiler results + in three parser skeletons being generated: gender_pskel, + person_pskel, and people_pskel. We are going + to examine and implement each of them in the subsequent sections.

+ +

3.1 Implementing the Gender Parser

+ +

The generated gender_pskel parser skeleton looks like + this:

+ + 
+class gender_pskel: public virtual xml_schema::string_pskel
+{
+public:
+  // Parser callbacks. Override them in your implementation.
+  //
+  virtual void
+  pre ();
+
+  virtual void
+  post_gender ();
+};
+
+ +

Notice that gender_pskel inherits from + xml_schema::string_skel which is a parser skeleton + for built-in XML Schema type string and is + predefined in the XSD runtime library. This is an example + of the general rule that parser skeletons follow: if a type + in XML Schema inherits from another then there will be an + equivalent inheritance between the corresponding parser + skeleton classes.

+ +

The pre() and post_gender() callbacks + should look familiar from the previous chapter. Let's now + implement the parser. Our implementation will simply print + the gender to cout:

+ + + 
+class gender_pimpl: public gender_pskel,
+                    public xml_schema::string_pimpl
+{
+public:
+  virtual void
+  post_gender ()
+  {
+    std::string s = post_string ();
+    cout << "gender: " << s << endl;
+  }
+};
+
+ +

While the code is quite short, there is a lot going on. First, + notice that we are inheriting from gender_pskel and + from xml_schema::string_pimpl. We've encountered + xml_schema::string_pimpl already; it is an + implementation of the xml_schema::string_pskel parser + skeleton for built-in XML Schema type string.

+ +

This is another common theme in the C++/Parser programming model: + reusing implementations of the base parsers in the derived ones with + the C++ mixin idiom. In our case, string_pimpl will + do all the dirty work of extracting the data and we can just get + it at the end with the call to post_string().

+ +

In case you are curious, here is what + xml_schema::string_pskel and + xml_schema::string_pimpl look like:

+ + 
+namespace xml_schema
+{
+  class string_pskel: public simple_content
+  {
+  public:
+    virtual std::string
+    post_string () = 0;
+  };
+
+  class string_pimpl: public virtual string_pskel
+  {
+  public:
+    virtual void
+    _pre ();
+
+    virtual void
+    _characters (const xml_schema::ro_string&);
+
+    virtual std::string
+    post_string ();
+
+  protected:
+    std::string str_;
+  };
+}
+
+ +

There are three new pieces in this code that we haven't seen yet. + They are the simple_content class as well as + the _pre() and _characters() functions. + The simple_content class is defined in the XSD + runtime and is a base class for all parser skeletons that conform + to the simple content model in XML Schema. Types with the + simple content model cannot have nested elements—only text + and attributes. There is also the complex_content + class which corresponds to the complex content mode (types with + nested elements, for example, person from + people.xsd).

+ +

The _pre() function is a parser callback. Remember we + talked about the pre() and post_*() callbacks + in the previous chapter? There are actually two more callbacks + with similar roles: _pre() and _post (). + As a result, each parser skeleton has four special callbacks:

+ + 
+  virtual void
+  pre ();
+
+  virtual void
+  _pre ();
+
+  virtual void
+  _post ();
+
+  virtual void
+  post_name ();
+
+ +

pre() and _pre() are initialization + callbacks. They get called in that order before a new instance of the type + is about to be parsed. The difference between pre() and + _pre() is conventional: pre() can + be completely overridden by a derived parser. The derived + parser can also override _pre() but has to always call + the original version. This allows you to partition initialization + into customizable and required parts.

+ +

Similarly, _post() and post_name() are + finalization callbacks with exactly the same semantics: + post_name() can be completely overridden by the derived + parser while the original _post() should always be called. +

+ +

The final bit we need to discuss in this section is the + _characters() function. As you might have guessed, it + is also a callback. A low-level one that delivers raw character content + for the type being parsed. You will seldom need to use this callback + directly. Using implementations for the built-in parsers provided by + the XSD runtime is usually a simpler and more convenient + alternative.

+ +

At this point you might be wondering why some post_*() + callbacks, for example post_string(), return some data + while others, for example post_gender(), have + void as a return type. This is a valid concern + and it will be addressed in the next chapter.

+ +

3.2 Implementing the Person Parser

+ +

The generated person_pskel parser skeleton looks like + this:

+ + 
+class person_pskel: public xml_schema::complex_content
+{
+public:
+  // Parser callbacks. Override them in your implementation.
+  //
+  virtual void
+  pre ();
+
+  virtual void
+  first_name (const std::string&);
+
+  virtual void
+  last_name (const std::string&);
+
+  virtual void
+  gender ();
+
+  virtual void
+  age (short);
+
+  virtual void
+  post_person ();
+
+  // Parser construction API.
+  //
+  void
+  first_name_parser (xml_schema::string_pskel&);
+
+  void
+  last_name_parser (xml_schema::string_pskel&);
+
+  void
+  gender_parser (gender_pskel&);
+
+  void
+  age_parser (xml_schema::short_pskel&);
+
+  void
+  parsers (xml_schema::string_pskel& /* first-name */,
+           xml_schema::string_pskel& /* last-name */,
+           gender_pskel&             /* gender */,
+           xml_schema::short_pskel&  /* age */);
+};
+
+ + +

As you can see, we have a parser callback for each of the nested + elements found in the person XML Schema type. + The implementation of this parser is straightforward:

+ + 
+class person_pimpl: public person_pskel
+{
+public:
+  virtual void
+  first_name (const std::string& n)
+  {
+    cout << "first: " << f << endl;
+  }
+
+  virtual void
+  last_name (const std::string& l)
+  {
+    cout << "last: " << l << endl;
+  }
+
+  virtual void
+  age (short a)
+  {
+    cout << "age: " << a << endl;
+  }
+};
+
+ +

Notice that we didn't override the gender() callback + because all the printing is done by gender_pimpl.

+ + +

3.3 Implementing the People Parser

+ +

The generated people_pskel parser skeleton looks like + this:

+ + 
+class people_pskel: public xml_schema::complex_content
+{
+public:
+  // Parser callbacks. Override them in your implementation.
+  //
+  virtual void
+  pre ();
+
+  virtual void
+  person ();
+
+  virtual void
+  post_people ();
+
+  // Parser construction API.
+  //
+  void
+  person_parser (person_pskel&);
+
+  void
+  parsers (person_pskel& /* person */);
+};
+
+ +

The person() callback will be called after parsing each + person element. While person_pimpl does + all the printing, one useful thing we can do in this callback is to + print an extra newline after each person record so that our + output is more readable:

+ + 
+class people_pimpl: public people_pskel
+{
+public:
+  virtual void
+  person ()
+  {
+    cout << endl;
+  }
+};
+
+ +

Now it is time to put everything together.

+ + +

3.4 Connecting the Parsers Together

+ +

At this point we have all the individual parsers implemented + and can proceed to assemble them into a complete parser + for our XML vocabulary. The first step is to instantiate + all the individual parsers that we will need:

+ + 
+xml_schema::short_pimpl short_p;
+xml_schema::string_pimpl string_p;
+
+gender_pimpl gender_p;
+person_pimpl person_p;
+people_pimpl people_p;
+
+ +

Notice that our schema uses two built-in XML Schema types: + string for the first-name and + last-name elements as well as short + for age. We will use predefined parsers that + come with the XSD runtime to handle these types. The next + step is to connect all the individual parsers. We do this + with the help of functions defined in the parser + skeletons and marked with the "Parser Construction API" + comment. One way to do it is to connect each individual + parser by calling the *_parser() functions:

+ + 
+person_p.first_name_parser (string_p);
+person_p.last_name_parser (string_p);
+person_p.gender_parser (gender_p);
+person_p.age_parser (short_p);
+
+people_p.person_parser (person_p);
+
+ +

You might be wondering what happens if you do not provide + a parser by not calling one of the *_parser() functions. + In that case the corresponding XML content will be skipped, + including validation. This is an efficient way to ignore parts + of the document that you are not interested in.

+ + +

An alternative, shorter, way to connect the parsers is by using + the parsers() functions which connects all the parsers + for a given type at once:

+ + 
+person_p.parsers (string_p, string_p, gender_p, short_p);
+people_p.parsers (person_p);
+
+ +

The following figure illustrates the resulting connections. Notice + the correspondence between return types of the post_*() + functions and argument types of element callbacks that are connected + by the arrows.

+ + +
+ +

The last step is the construction of the document parser and + invocation of the complete parser on our sample XML instance:

+ + 
+xml_schema::document doc_p (people_p, "people");
+
+people_p.pre ();
+doc_p.parse ("people.xml");
+people_p.post_people ();
+
+ +

Let's consider xml_schema::document in + more detail. While the exact definition of this class + varies depending on the underlying parser selected, + here is the common part:

+ + 
+namespace xml_schema
+{
+  class document
+  {
+  public:
+    document (xml_schema::parser_base&,
+              const std::string& root_element_name,
+              bool polymorphic = false);
+
+    document (xml_schema::parser_base&,
+              const std::string& root_element_namespace,
+              const std::string& root_element_name,
+              bool polymorphic = false);
+
+    void
+    parse (const std::string& file);
+
+    void
+    parse (std::istream&);
+
+    ...
+
+  };
+}
+
+ +

xml_schema::document is a root parser for + the vocabulary. The first argument to its constructors is the + parser for the type of the root element (people_impl + in our case). Because a type parser is only concerned with + the element's content and not with the element's name, we need + to specify the root element's name somewhere. That's + what is passed as the second and third arguments to the + document's constructors.

+ +

There are also two overloaded parse() functions + defined in the document class (there are actually + more but the others are specific to the underlying XML parser). + The first version parses a local file identified by a name. The + second version reads the data from an input stream. For more + information on the xml_schema::document class + refer to Chapter 7, "Document Parser and Error + Handling".

+ +

Let's now consider a step-by-step list of actions that happen + as we parse through people.xml. The content of + people.xml is repeated below for convenience.

+ + 
+<?xml version="1.0"?>
+<people>
+  <person>
+    <first-name>John</first-name>
+    <last-name>Doe</last-name>
+    <gender>male</gender>
+    <age>32</age>
+  </person>
+  <person>
+    <first-name>Jane</first-name>
+    <last-name>Doe</last-name>
+    <gender>female</gender>
+    <age>28</age>
+  </person>
+</people>
+
+ + +
    +
  1. people_p.pre() is called from + main(). We did not provide any implementation + for this callback so this call is a no-op.
    2. + +
  2. doc_p.parse("people.xml") is called from + main(). The parser opens the file and starts + parsing its content.
    3. + +
  3. The parser encounters the root element. doc_p + verifies that the root element is correct and calls + _pre() on people_p which is also + a no-op. Parsing is now delegated to people_p.
    4. + +
  4. The parser encounters the person element. + people_p determines that person_p + is responsible for parsing this element. pre() + and _pre() callbacks are called on person_p. + Parsing is now delegated to person_p.
    5. + +
  5. The parser encounters the first-name element. + person_p determines that string_p + is responsible for parsing this element. pre() + and _pre() callbacks are called on string_p. + Parsing is now delegated to string_p.
    6. + +
  6. The parser encounters character content consisting of + "John". The _characters() callback is + called on string_p.
    7. + +
  7. The parser encounters the end of first-name + element. The _post() and post_string() + callbacks are called on string_p. The + first_name() callback is called on person_p + with the return value of post_string(). The + first_name() implementation prints + "first: John" to cout. + Parsing is now returned to person_p.
    8. + +
  8. Steps analogous to 5-7 are performed for the last-name, + gender, and age elements.
    9. + +
  9. The parser encounters the end of person + element. The _post() and post_person() + callbacks are called on person_p. The + person() callback is called on people_p. + The person() implementation prints a new line + to cout. Parsing is now returned to + people_p.
    10. + +
  10. Steps 4-9 are performed for the second person + element.
    11. + +
  11. The parser encounters the end of people + element. The _post() callback is called on + people_p. The doc_p.parse("people.xml") + call returns to main().
    12. + +
  12. people_p.post_people() is called from + main() which is a no-op.
    13. + +
+ + + + + +

4 Type Maps

+ +

There are many useful things you can do inside parser callbacks as they + are right now. There are, however, times when you want to propagate + some information from one parser to another or to the caller of the + parser. One common task that would greatly benefit from such a + possibility is building a tree-like in-memory object model of the + data stored in XML. During execution, each individual sub-parser + would create a sub-tree and return it to its parent parser + which can then incorporate this sub-tree into the whole tree.

+ +

In this chapter we will discuss the mechanisms offered by the + C++/Parser mapping for returning information from individual + parsers and see how to use them to build an object model + of our people vocabulary.

+ +

4.1 Object Model

+ +

An object model for our person record example could + look like this (saved in the people.hxx file):

+ + 
+#include <string>
+#include <vector>
+
+enum gender
+{
+  male,
+  female
+};
+
+class person
+{
+public:
+  person (const std::string& first,
+          const std::string& last,
+          ::gender gender,
+          short age)
+    : first_ (first), last_ (last),
+      gender_ (gender), age_ (age)
+  {
+  }
+
+  const std::string&
+  first () const
+  {
+    return first_;
+  }
+
+  const std::string&
+  last () const
+  {
+    return last_;
+  }
+
+  ::gender
+  gender () const
+  {
+    return gender_;
+  }
+
+  short
+  age () const
+  {
+    return age_;
+  }
+
+private:
+  std::string first_;
+  std::string last_;
+  ::gender gender_;
+  short age_;
+};
+
+typedef std::vector<person> people;
+
+ +

While it is clear which parser is responsible for which part of + the object model, it is not exactly clear how, for + example, gender_pimpl will deliver gender + to person_pimpl. You might have noticed that + string_pimpl manages to deliver its value to the + first_name() callback of person_pimpl. Let's + see how we can utilize the same mechanism to propagate our + own data.

+ +

There is a way to tell the XSD compiler that you want to + exchange data between parsers. More precisely, for each + type defined in XML Schema, you can tell the compiler two things. + First, the return type of the post_*() callback + in the parser skeleton generated for this type. And, second, + the argument type for callbacks corresponding to elements and + attributes of this type. For example, for XML Schema type + gender we can specify the return type for + post_gender() in the gender_pskel + skeleton and the argument type for the gender() callback + in the person_pskel skeleton. As you might have guessed, + the generated code will then pass the return value from the + post_*() callback as an argument to the element or + attribute callback.

+ +

The way to tell the XSD compiler about these XML Schema to + C++ mappings is with type map files. Here is a simple type + map for the gender type from the previous paragraph:

+ + 
+include "people.hxx";
+gender ::gender ::gender;
+
+ +

The first line indicates that the generated code must include + people.hxx in order to get the definition for the + gender type. The second line specifies that both + argument and return types for the gender + XML Schema type should be the ::gender C++ enum + (we use fully-qualified C++ names to avoid name clashes). + The next section will describe the type map format in detail. + We save this type map in people.map and + then translate our schemas with the --type-map + option to let the XSD compiler know about our type map:

+ + 
+$ xsd cxx-parser --type-map people.map people.xsd
+
+ +

If we now look at the generated people-pskel.hxx, + we will see the following changes in the gender_pskel and + person_pskel skeletons:

+ + 
+#include "people.hxx"
+
+class gender_pskel: public virtual xml_schema::string_pskel
+{
+  virtual ::gender
+  post_gender () = 0;
+
+  ...
+};
+
+class person_pskel: public xml_schema::complex_content
+{
+  virtual void
+  gender (::gender);
+
+  ...
+};
+
+ +

Notice that #include "people.hxx" was added to + the generated header file from the type map to provide the + definition for the gender enum.

+ +

4.2 Type Map File Format

+ +

Type map files are used to define a mapping between XML Schema + and C++ types. The compiler uses this information + to determine return types of post_*() + callbacks in parser skeletons corresponding to XML Schema + types as well as argument types for callbacks corresponding + to elements and attributes of these types.

+ +

The compiler has a set of predefined mapping rules that map + the built-in XML Schema types to suitable C++ types (discussed + below) and all other types to void. + By providing your own type maps you can override these predefined + rules. The format of the type map file is presented below: +

+ + 
+namespace <schema-namespace> [<cxx-namespace>]
+{
+  (include <file-name>;)*
+  ([type] <schema-type> <cxx-ret-type> [<cxx-arg-type>];)*
+}
+
+ +

Both <schema-namespace> and + <schema-type> are regex patterns while + <cxx-namespace>, + <cxx-ret-type>, and + <cxx-arg-type> are regex pattern + substitutions. All names can be optionally enclosed in + " ", for example, to include white-spaces.

+ +

<schema-namespace> determines XML + Schema namespace. Optional <cxx-namespace> + is prefixed to every C++ type name in this namespace declaration. + <cxx-ret-type> is a C++ type name that is + used as a return type for the post_*() callback. + Optional <cxx-arg-type> is an argument + type for callbacks corresponding to elements and attributes + of this type. If <cxx-arg-type> is not + specified, it defaults to <cxx-ret-type> + if <cxx-ret-type> ends with * or + & (that is, it is a pointer or a reference) and + const <cxx-ret-type>& + otherwise. + <file-name> is a file name either in the + " " or < > format + and is added with the #include directive to + the generated code.

+ +

The # character starts a comment that ends + with a new line or end of file. To specify a name that contains + # enclose it in " ". + For example:

+ + 
+namespace http://www.example.com/xmlns/my my
+{
+  include "my.hxx";
+
+  # Pass apples by value.
+  #
+  apple apple;
+
+  # Pass oranges as pointers.
+  #
+  orange orange_t*;
+}
+
+ +

In the example above, for the + http://www.example.com/xmlns/my#orange + XML Schema type, the my::orange_t* C++ type will + be used as both return and argument types.

+ +

Several namespace declarations can be specified in a single + file. The namespace declaration can also be completely + omitted to map types in a schema without a namespace. For + instance:

+ + 
+include "my.hxx";
+apple apple;
+
+namespace http://www.example.com/xmlns/my
+{
+  orange "const orange_t*";
+}
+
+ +

The compiler has a number of predefined mapping rules for + the built-in XML Schema types which can be presented as the + following map files. The string-based XML Schema types are + mapped to either std::string or + std::wstring depending on the character type + selected (see Section 5.2, "Character Type and + Encoding" for more information). The binary XML Schema + types are mapped to either std::unique_ptr<xml_schema::buffer> + or std::auto_ptr<xml_schema::buffer> + depending on the C++ standard selected (C++11 or C++98, + respectively; refer to the --std XSD compiler + command line option for details).

+ + 
+namespace http://www.w3.org/2001/XMLSchema
+{
+  boolean bool bool;
+
+  byte "signed char" "signed char";
+  unsignedByte "unsigned char" "unsigned char";
+
+  short short short;
+  unsignedShort "unsigned short" "unsigned short";
+
+  int int int;
+  unsignedInt "unsigned int" "unsigned int";
+
+  long "long long" "long long";
+  unsignedLong "unsigned long long" "unsigned long long";
+
+  integer "long long" "long long";
+
+  negativeInteger "long long" "long long";
+  nonPositiveInteger "long long" "long long";
+
+  positiveInteger "unsigned long long" "unsigned long long";
+  nonNegativeInteger "unsigned long long" "unsigned long long";
+
+  float float float;
+  double double double;
+  decimal double double;
+
+  string std::string;
+  normalizedString std::string;
+  token std::string;
+  Name std::string;
+  NMTOKEN std::string;
+  NCName std::string;
+  ID std::string;
+  IDREF std::string;
+  language std::string;
+  anyURI std::string;
+
+  NMTOKENS xml_schema::string_sequence;
+  IDREFS xml_schema::string_sequence;
+
+  QName xml_schema::qname;
+
+  base64Binary std::[unique|auto]_ptr<xml_schema::buffer>
+               std::[unique|auto]_ptr<xml_schema::buffer>;
+  hexBinary std::[unique|auto]_ptr<xml_schema::buffer>
+            std::[unique|auto]_ptr<xml_schema::buffer>;
+
+  date xml_schema::date;
+  dateTime xml_schema::date_time;
+  duration xml_schema::duration;
+  gDay xml_schema::gday;
+  gMonth xml_schema::gmonth;
+  gMonthDay xml_schema::gmonth_day;
+  gYear xml_schema::gyear;
+  gYearMonth xml_schema::gyear_month;
+  time xml_schema::time;
+}
+
+ +

For more information about the mapping of the built-in XML Schema types + to C++ types refer to Chapter 6, "Built-In XML Schema Type + Parsers". The last predefined rule maps anything that wasn't + mapped by previous rules to void:

+ + 
+namespace .*
+{
+  .* void void;
+}
+
+ + +

When you provide your own type maps with the + --type-map option, they are evaluated first. This + allows you to selectively override any of the predefined rules. + Note also that if you change the mapping + of a built-in XML Schema type then it becomes your responsibility + to provide the corresponding parser skeleton and implementation + in the xml_schema namespace. You can include the + custom definitions into the generated header file using the + --hxx-prologue-* options.

+ +

4.3 Parser Implementations

+ +

With the knowledge from the previous section, we can proceed + with creating a type map that maps types in the people.xsd + schema to our object model classes in + people.hxx. In fact, we already have the beginning + of our type map file in people.map. Let's extend + it with the rest of the types:

+ + 
+include "people.hxx";
+
+gender ::gender ::gender;
+person ::person;
+people ::people;
+
+ +

There are a few things to note about this type map. We did not + provide the argument types for person and + people because the default constant reference is + exactly what we need. We also did not provide any mappings + for built-in XML Schema types string and + short because they are handled by the predefined + rules and we are happy with the result. Note also that + all C++ types are fully qualified. This is done to avoid + potential name conflicts in the generated code. Now we can + recompile our schema and move on to implementing the parsers:

+ + 
+$ xsd cxx-parser --xml-parser expat --type-map people.map people.xsd
+
+ +

Here is the implementation of our three parsers in full. One + way to save typing when implementing your own parsers is + to open the generated code and copy the signatures of parser + callbacks into your code. Or you could always auto generate the + sample implementations and fill them with your code.

+ + + 
+#include "people-pskel.hxx"
+
+class gender_pimpl: public gender_pskel,
+                    public xml_schema::string_pimpl
+{
+public:
+  virtual ::gender
+  post_gender ()
+  {
+    return post_string () == "male" ? male : female;
+  }
+};
+
+class person_pimpl: public person_pskel
+{
+public:
+  virtual void
+  first_name (const std::string& f)
+  {
+    first_ = f;
+  }
+
+  virtual void
+  last_name (const std::string& l)
+  {
+    last_ = l;
+  }
+
+  virtual void
+  gender (::gender g)
+  {
+    gender_ = g;
+  }
+
+  virtual void
+  age (short a)
+  {
+    age_ = a;
+  }
+
+  virtual ::person
+  post_person ()
+  {
+    return ::person (first_, last_, gender_, age_);
+  }
+
+private:
+  std::string first_;
+  std::string last_;
+  ::gender gender_;
+  short age_;
+};
+
+class people_pimpl: public people_pskel
+{
+public:
+  virtual void
+  person (const ::person& p)
+  {
+    people_.push_back (p);
+  }
+
+  virtual ::people
+  post_people ()
+  {
+    ::people r;
+    r.swap (people_);
+    return r;
+  }
+
+private:
+  ::people people_;
+};
+
+ +

This code fragment should look familiar by now. Just note that + all the post_*() callbacks now have return types instead + of void. Here is the implementation of the test + driver for this example:

+ + 
+#include <iostream>
+
+using namespace std;
+
+int
+main (int argc, char* argv[])
+{
+  // Construct the parser.
+  //
+  xml_schema::short_pimpl short_p;
+  xml_schema::string_pimpl string_p;
+
+  gender_pimpl gender_p;
+  person_pimpl person_p;
+  people_pimpl people_p;
+
+  person_p.parsers (string_p, string_p, gender_p, short_p);
+  people_p.parsers (person_p);
+
+  // Parse the document to obtain the object model.
+  //
+  xml_schema::document doc_p (people_p, "people");
+
+  people_p.pre ();
+  doc_p.parse (argv[1]);
+  people ppl = people_p.post_people ();
+
+  // Print the object model.
+  //
+  for (people::iterator i (ppl.begin ()); i != ppl.end (); ++i)
+  {
+    cout << "first:  " << i->first () << endl
+         << "last:   " << i->last () << endl
+         << "gender: " << (i->gender () == male ? "male" : "female") << endl
+         << "age:    " << i->age () << endl
+         << endl;
+  }
+}
+
+ +

The parser creation and assembly part is exactly the same as in + the previous chapter. The parsing part is a bit different: + post_people() now has a return value which is the + complete object model. We store it in the + ppl variable. The last bit of the code simply iterates + over the people vector and prints the information + for each person. We save the last two code fragments to + driver.cxx and proceed to compile and test + our new application:

+ + + 
+$ c++ -std=c++11 -I.../libxsd -c driver.cxx people-pskel.cxx
+$ c++ -std=c++11 -o driver driver.o people-pskel.o -lexpat
+$ ./driver people.xml
+first:  John
+last:   Doe
+gender: male
+age:    32
+
+first:  Jane
+last:   Doe
+gender: female
+age:    28
+
+ + + + + +

5 Mapping Configuration

+ +

The C++/Parser mapping has a number of configuration parameters that + determine the overall properties and behavior of the generated code. + Configuration parameters are specified with the XSD command line + options and include the C++ standard, the character type that is used + by the generated code, the underlying XML parser, whether the XML Schema + validation is performed in the generated code, and support for XML Schema + polymorphism. This chapter describes these configuration + parameters in more detail. For more ways to configure the generated + code refer to the + XSD + Compiler Command Line Manual. +

+ +

5.1 C++ Standard

+ +

The C++/Parser mapping provides support for ISO/IEC C++ 2011 (C++11) + and ISO/IEC C++ 1998/2003 (C++98). To select the C++ standard for the + generated code we use the --std XSD compiler command + line option. While the majority of the examples in this guide use + C++11, the document explains the C++11/98 usage difference and so + they can easily be converted to C++98.

+ +

5.2 Character Type and Encoding

+ +

The C++/Parser mapping has built-in support for two character types: + char and wchar_t. You can select the + character type with the --char-type command line + option. The default character type is char. The + string-based built-in XML Schema types are returned as either + std::string or std::wstring depending + on the character type selected.

+ +

Another aspect of the mapping that depends on the character type + is character encoding. For the char character type + the default encoding is UTF-8. Other supported encodings are + ISO-8859-1, Xerces-C++ Local Code Page (LPC), as well as + custom encodings. You can select which encoding should be used + in the object model with the --char-encoding command + line option.

+ +

For the wchar_t character type the encoding is + automatically selected between UTF-16 and UTF-32/UCS-4 depending + on the size of the wchar_t type. On some platforms + (for example, Windows with Visual C++ and AIX with IBM XL C++) + wchar_t is 2 bytes long. For these platforms the + encoding is UTF-16. On other platforms wchar_t is 4 bytes + long and UTF-32/UCS-4 is used.

+ +

Note also that the character encoding that is used in the object model + is independent of the encodings used in input and output XML. In fact, + all three (object mode, input XML, and output XML) can have different + encodings.

+ +

5.3 Underlying XML Parser

+ +

The C++/Parser mapping can be used with either Xerces-C++ or Expat + as the underlying XML parser. You can select the XML parser with + the --xml-parser command line option. Valid values + for this option are xerces and expat. + The default XML parser is Xerces-C++.

+ +

The generated code is identical for both parsers except for the + xml_schema::document class in which some of the + parse() functions are parser-specific as described + in Chapter 7, "Document Parser and Error Handling".

+ + +

5.4 XML Schema Validation

+ +

The C++/Parser mapping provides support for validating a + commonly-used subset of W3C XML Schema in the generated code. + For the list of supported XML Schema constructs refer to + Appendix A, "Supported XML Schema Constructs".

+ +

By default validation in the generated code is disabled if + the underlying XML parser is validating (Xerces-C++) and + enabled otherwise (Expat). See Section 5.3, + "Underlying XML Parser" for more information about + the underlying XML parser. You can override the default + behavior with the --generate-validation + and --suppress-validation command line options.

+ + +

5.5 Support for Polymorphism

+ +

By default the XSD compiler generates non-polymorphic code. If your + vocabulary uses XML Schema polymorphism in the form of xsi:type + and/or substitution groups, then you will need to compile your schemas + with the --generate-polymorphic option to produce + polymorphism-aware code as well as pass true as the last + argument to the xml_schema::document's constructors.

+ +

When using the polymorphism-aware generated code, you can specify + several parsers for a single element by passing a parser map + instead of an individual parser to the parser connection function + for the element. One of the parsers will then be looked up and used + depending on the xsi:type attribute value or an element + name from a substitution group. Consider the following schema as an + example:

+ + 
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+
+  <xs:complexType name="person">
+    <xs:sequence>
+      <xs:element name="name" type="xs:string"/>
+    </xs:sequence>
+  </xs:complexType>
+
+  <!-- substitution group root -->
+  <xs:element name="person" type="person"/>
+
+  <xs:complexType name="superman">
+    <xs:complexContent>
+      <xs:extension base="person">
+        <xs:attribute name="can-fly" type="xs:boolean"/>
+      </xs:extension>
+    </xs:complexContent>
+  </xs:complexType>
+
+  <xs:element name="superman"
+              type="superman"
+              substitutionGroup="person"/>
+
+  <xs:complexType name="batman">
+    <xs:complexContent>
+      <xs:extension base="superman">
+        <xs:attribute name="wing-span" type="xs:unsignedInt"/>
+      </xs:extension>
+    </xs:complexContent>
+  </xs:complexType>
+
+  <xs:element name="batman"
+              type="batman"
+              substitutionGroup="superman"/>
+
+  <xs:complexType name="supermen">
+    <xs:sequence>
+      <xs:element ref="person" maxOccurs="unbounded"/>
+    </xs:sequence>
+  </xs:complexType>
+
+  <xs:element name="supermen" type="supermen"/>
+
+</xs:schema>
+
+ +

Conforming XML documents can use the superman + and batman types in place of the person + type either by specifying the type with the xsi:type + attributes or by using the elements from the substitution + group, for instance:

+ + + 
+<supermen xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+
+  <person>
+    <name>John Doe</name>
+  </person>
+
+  <superman can-fly="false">
+    <name>James "007" Bond</name>
+  </superman>
+
+  <superman can-fly="true" wing-span="10" xsi:type="batman">
+    <name>Bruce Wayne</name>
+  </superman>
+
+</supermen>
+
+ +

To print the data stored in such XML documents we can implement + the parsers as follows:

+ + 
+class person_pimpl: public virtual person_pskel
+{
+public:
+  virtual void
+  pre ()
+  {
+    cout << "starting to parse person" << endl;
+  }
+
+  virtual void
+  name (const std::string& v)
+  {
+    cout << "name: " << v << endl;
+  }
+
+  virtual void
+  post_person ()
+  {
+    cout << "finished parsing person" << endl;
+  }
+};
+
+class superman_pimpl: public virtual superman_pskel,
+                      public person_pimpl
+{
+public:
+  virtual void
+  pre ()
+  {
+    cout << "starting to parse superman" << endl;
+  }
+
+  virtual void
+  can_fly (bool v)
+  {
+    cout << "can-fly: " << v << endl;
+  }
+
+  virtual void
+  post_person ()
+  {
+    post_superman ();
+  }
+
+  virtual void
+  post_superman ()
+  {
+    cout << "finished parsing superman" << endl
+  }
+};
+
+class batman_pimpl: public virtual batman_pskel,
+                    public superman_pimpl
+{
+public:
+  virtual void
+  pre ()
+  {
+    cout << "starting to parse batman" << endl;
+  }
+
+  virtual void
+  wing_span (unsigned int v)
+  {
+    cout << "wing-span: " << v << endl;
+  }
+
+  virtual void
+  post_superman ()
+  {
+    post_batman ();
+  }
+
+  virtual void
+  post_batman ()
+  {
+    cout << "finished parsing batman" << endl;
+  }
+};
+
+ +

Note that because the derived type parsers (superman_pskel + and batman_pskel) are called via the person_pskel + interface, we have to override the post_person() + virtual function in superman_pimpl to call + post_superman() and the post_superman() + virtual function in batman_pimpl to call + post_batman().

+ +

The following code fragment shows how to connect the parsers together. + Notice that for the person element in the supermen_p + parser we specify a parser map instead of a specific parser and we pass + true as the last argument to the document parser constructor + to indicate that we are parsing potentially-polymorphic XML documents:

+ + 
+int
+main (int argc, char* argv[])
+{
+  // Construct the parser.
+  //
+  xml_schema::string_pimpl string_p;
+  xml_schema::boolean_pimpl boolean_p;
+  xml_schema::unsigned_int_pimpl unsigned_int_p;
+
+  person_pimpl person_p;
+  superman_pimpl superman_p;
+  batman_pimpl batman_p;
+
+  xml_schema::parser_map_impl person_map;
+  supermen_pimpl supermen_p;
+
+  person_p.parsers (string_p);
+  superman_p.parsers (string_p, boolean_p);
+  batman_p.parsers (string_p, boolean_p, unsigned_int_p);
+
+  // Here we are specifying a parser map which containes several
+  // parsers that can be used to parse the person element.
+  //
+  person_map.insert (person_p);
+  person_map.insert (superman_p);
+  person_map.insert (batman_p);
+
+  supermen_p.person_parser (person_map);
+
+  // Parse the XML document. The last argument to the document's
+  // constructor indicates that we are parsing polymorphic XML
+  // documents.
+  //
+  xml_schema::document doc_p (supermen_p, "supermen", true);
+
+  supermen_p.pre ();
+  doc_p.parse (argv[1]);
+  supermen_p.post_supermen ();
+}
+
+ +

When polymorphism-aware code is generated, each element's + *_parser() function is overloaded to also accept + an object of the xml_schema::parser_map type. + For example, the supermen_pskel class from the + above example looks like this:

+ + 
+class supermen_pskel: public xml_schema::parser_complex_content
+{
+public:
+
+  ...
+
+  // Parser construction API.
+  //
+  void
+  parsers (person_pskel&);
+
+  // Individual element parsers.
+  //
+  void
+  person_parser (person_pskel&);
+
+  void
+  person_parser (const xml_schema::parser_map&);
+
+  ...
+};
+
+ +

Note that you can specify both the individual (static) parser and + the parser map. The individual parser will be used when the static + element type and the dynamic type of the object being parsed are + the same. This is the case, for example, when there is no + xsi:type attribute and the element hasn't been + substituted. Because the individual parser for an element is + cached and no map lookup is necessary, it makes sense to specify + both the individual parser and the parser map when most of the + objects being parsed are of the static type and optimal + performance is important. The following code fragment shows + how to change the above example to set both the individual + parser and the parser map:

+ + 
+int
+main (int argc, char* argv[])
+{
+  ...
+
+  person_map.insert (superman_p);
+  person_map.insert (batman_p);
+
+  supermen_p.person_parser (person_p);
+  supermen_p.person_parser (person_map);
+
+  ...
+}
+
+ + +

The xml_schema::parser_map interface and the + xml_schema::parser_map_impl default implementation + are presented below:

+ + 
+namespace xml_schema
+{
+  class parser_map
+  {
+  public:
+    virtual parser_base*
+    find (const ro_string* type) const = 0;
+  };
+
+  class parser_map_impl: public parser_map
+  {
+  public:
+    void
+    insert (parser_base&);
+
+    virtual parser_base*
+    find (const ro_string* type) const;
+
+  private:
+    parser_map_impl (const parser_map_impl&);
+
+    parser_map_impl&
+    operator= (const parser_map_impl&);
+
+    ...
+  };
+}
+
+ +

The type argument in the find() virtual + function is the type name and namespace from the xsi:type attribute + (the namespace prefix is resolved to the actual XML namespace) + or the type of an element from the substitution group in the form + "<name> <namespace>" with the space and the + namespace part absent if the type does not have a namespace. + You can obtain a parser's dynamic type in the same format + using the _dynamic_type() function. The static + type can be obtained by calling the static _static_type() + function, for example person_pskel::_static_type(). + Both functions return a C string (const char* or + const wchar_t*, depending on the character type + used) which is valid for as long as the application is running. + The following example shows how we can implement our own parser + map using std::map:

+ + + 
+#include <map>
+#include <string>
+
+class parser_map: public xml_schema::parser_map
+{
+public:
+ void
+ insert (xml_schema::parser_base& p)
+ {
+   map_[p._dynamic_type ()] = &p;
+ }
+
+ virtual xml_schema::parser_base*
+ find (const xml_schema::ro_string* type) const
+ {
+   map::const_iterator i = map_.find (type);
+   return i != map_.end () ? i->second : 0;
+ }
+
+private:
+  typedef std::map<std::string, xml_schema::parser_base*> map;
+  map map_;
+};
+
+ +

Most of code presented in this section is taken from the + polymorphism example which can be found in the + cxx/parser/ directory in the + xsd-examples package. + Handling of xsi:type and substitution groups when used on + root elements requires a number of special actions as shown in + the polyroot example.

+ + + + + +

6 Built-In XML Schema Type Parsers

+ +

The XSD runtime provides parser implementations for all built-in + XML Schema types as summarized in the following table. Declarations + for these types are automatically included into each generated + header file. As a result you don't need to include any headers + to gain access to these parser implementations. Note that some + parsers return either std::string or + std::wstring depending on the character type selected.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
XML Schema typeParser implementation in the xml_schema namespaceParser return type
anyType and anySimpleType types
anyTypeany_type_pimplvoid
anySimpleTypeany_simple_type_pimplvoid
fixed-length integral types
bytebyte_pimplsigned char
unsignedByteunsigned_byte_pimplunsigned char
shortshort_pimplshort
unsignedShortunsigned_short_pimplunsigned short
intint_pimplint
unsignedIntunsigned_int_pimplunsigned int
longlong_pimpllong long
unsignedLongunsigned_long_pimplunsigned long long
arbitrary-length integral types
integerinteger_pimpllong long
nonPositiveIntegernon_positive_integer_pimpllong long
nonNegativeIntegernon_negative_integer_pimplunsigned long long
positiveIntegerpositive_integer_pimplunsigned long long
negativeIntegernegative_integer_pimpllong long
boolean types
booleanboolean_pimplbool
fixed-precision floating-point types
floatfloat_pimplfloat
doubledouble_pimpldouble
arbitrary-precision floating-point types
decimaldecimal_pimpldouble
string-based types
stringstring_pimplstd::string or std::wstring
normalizedStringnormalized_string_pimplstd::string or std::wstring
tokentoken_pimplstd::string or std::wstring
Namename_pimplstd::string or std::wstring
NMTOKENnmtoken_pimplstd::string or std::wstring
NCNamencname_pimplstd::string or std::wstring
languagelanguage_pimplstd::string or std::wstring
qualified name
QNameqname_pimplxml_schema::qname
Section 6.1, + "QName Parser"
ID/IDREF types
IDid_pimplstd::string or std::wstring
IDREFidref_pimplstd::string or std::wstring
list types
NMTOKENSnmtokens_pimplxml_schema::string_sequence
Section + 6.2, "NMTOKENS and IDREFS Parsers"
IDREFSidrefs_pimplxml_schema::string_sequence
Section + 6.2, "NMTOKENS and IDREFS Parsers"
URI types
anyURIuri_pimplstd::string or std::wstring
binary types
base64Binarybase64_binary_pimplstd::[unique|auto]_ptr< xml_schema::buffer>
+ Section 6.3, "base64Binary and + hexBinary Parsers"
hexBinaryhex_binary_pimplstd::[unique|auto]_ptr< xml_schema::buffer>
+ Section 6.3, "base64Binary and + hexBinary Parsers"
date/time types
datedate_pimplxml_schema::date
Section 6.5, + "date Parser"
dateTimedate_time_pimplxml_schema::date_time
Section 6.6, + "dateTime Parser"
durationduration_pimplxml_schema::duration
Section 6.7, + "duration Parser"
gDaygday_pimplxml_schema::gday
Section 6.8, + "gDay Parser"
gMonthgmonth_pimplxml_schema::gmonth
Section 6.9, + "gMonth Parser"
gMonthDaygmonth_day_pimplxml_schema::gmonth_day
Section 6.10, + "gMonthDay Parser"
gYeargyear_pimplxml_schema::gyear
Section 6.11, + "gYear Parser"
gYearMonthgyear_month_pimplxml_schema::gyear_month
Section + 6.12, "gYearMonth Parser"
timetime_pimplxml_schema::time
Section 6.13, + "time Parser"
+ +

6.1 QName Parser

+ +

The return type of the qname_pimpl parser implementation + is xml_schema::qname which represents an XML qualified + name. Its interface is presented below. + Note that the std::string type in the interface becomes + std::wstring if the selected character type is + wchar_t.

+ + 
+namespace xml_schema
+{
+  class qname
+  {
+  public:
+    explicit
+    qname (const std::string& name);
+    qname (const std::string& prefix, const std::string& name);
+
+    const std::string&
+    prefix () const;
+
+    void
+    prefix (const std::string&);
+
+    const std::string&
+    name () const;
+
+    void
+    name (const std::string&);
+  };
+
+  bool
+  operator== (const qname&, const qname&);
+
+  bool
+  operator!= (const qname&, const qname&);
+}
+
+ + +

6.2 NMTOKENS and IDREFS Parsers

+ +

The return type of the nmtokens_pimpl and + idrefs_pimpl parser implementations is + xml_schema::string_sequence which represents a + sequence of strings. Its interface is presented below. + Note that the std::string type in the interface becomes + std::wstring if the selected character type is + wchar_t.

+ + 
+namespace xml_schema
+{
+  class string_sequence: public std::vector<std::string>
+  {
+  public:
+    string_sequence ();
+
+    explicit
+    string_sequence (std::vector<std::string>::size_type n,
+                     const std::string& x = std::string ());
+
+    template <typename I>
+    string_sequence (const I& begin, const I& end);
+  };
+
+  bool
+  operator== (const string_sequence&, const string_sequence&);
+
+  bool
+  operator!= (const string_sequence&, const string_sequence&);
+}
+
+ + +

6.3 base64Binary and hexBinary Parsers

+ +

The return type of the base64_binary_pimpl and + hex_binary_pimpl parser implementations is either + std::unique_ptr<xml_schema::buffer> (C++11) or + std::auto_ptr<xml_schema::buffer> (C++98), + depending on the C++ standard selected (--std XSD + compiler option). The xml_schema::buffer type + represents a binary buffer and its interface is presented below.

+ + 
+namespace xml_schema
+{
+  class buffer
+  {
+  public:
+    typedef std::size_t size_t;
+
+    class bounds {}; // Out of bounds exception.
+
+  public:
+    explicit
+    buffer (size_t size = 0);
+    buffer (size_t size, size_t capacity);
+    buffer (const void* data, size_t size);
+    buffer (const void* data, size_t size, size_t capacity);
+    buffer (void* data,
+            size_t size,
+            size_t capacity,
+            bool assume_ownership);
+
+  public:
+    buffer (const buffer&);
+
+    buffer&
+    operator= (const buffer&);
+
+    void
+    swap (buffer&);
+
+  public:
+    size_t
+    capacity () const;
+
+    bool
+    capacity (size_t);
+
+  public:
+    size_t
+    size () const;
+
+    bool
+    size (size_t);
+
+  public:
+    const char*
+    data () const;
+
+    char*
+    data ();
+
+    const char*
+    begin () const;
+
+    char*
+    begin ();
+
+    const char*
+    end () const;
+
+    char*
+    end ();
+  };
+
+  bool
+  operator== (const buffer&, const buffer&);
+
+  bool
+  operator!= (const buffer&, const buffer&);
+}
+
+ +

If the assume_ownership argument to the constructor + is true, the instance assumes the ownership of the + memory block pointed to by the data argument and will + eventually release it by calling operator delete(). The + capacity() and size() modifier functions + return true if the underlying buffer has moved. +

+ +

The bounds exception is thrown if the constructor + arguments violate the (size <= capacity) + constraint.

+ + +

6.4 Time Zone Representation

+ +

The date, dateTime, gDay, + gMonth, gMonthDay, gYear, + gYearMonth, and time XML Schema built-in + types all include an optional time zone component. The following + xml_schema::time_zone base class is used to represent + this information:

+ + 
+namespace xml_schema
+{
+  class time_zone
+  {
+  public:
+    time_zone ();
+    time_zone (short hours, short minutes);
+
+    bool
+    zone_present () const;
+
+    void
+    zone_reset ();
+
+    short
+    zone_hours () const;
+
+    void
+    zone_hours (short);
+
+    short
+    zone_minutes () const;
+
+    void
+    zone_minutes (short);
+  };
+
+  bool
+  operator== (const time_zone&, const time_zone&);
+
+  bool
+  operator!= (const time_zone&, const time_zone&);
+}
+
+ +

The zone_present() accessor function returns true + if the time zone is specified. The zone_reset() modifier + function resets the time zone object to the not specified + state. If the time zone offset is negative then both hours and + minutes components are represented as negative integers.

+ + +

6.5 date Parser

+ +

The return type of the date_pimpl parser implementation + is xml_schema::date which represents a year, a day, and a month + with an optional time zone. Its interface is presented below. + For more information on the base xml_schema::time_zone + class refer to Section 6.4, "Time Zone + Representation".

+ + 
+namespace xml_schema
+{
+  class date
+  {
+  public:
+    date (int year, unsigned short month, unsigned short day);
+    date (int year, unsigned short month, unsigned short day,
+          short zone_hours, short zone_minutes);
+
+    int
+    year () const;
+
+    void
+    year (int);
+
+    unsigned short
+    month () const;
+
+    void
+    month (unsigned short);
+
+    unsigned short
+    day () const;
+
+    void
+    day (unsigned short);
+  };
+
+  bool
+  operator== (const date&, const date&);
+
+  bool
+  operator!= (const date&, const date&);
+}
+
+ +

6.6 dateTime Parser

+ +

The return type of the date_time_pimpl parser implementation + is xml_schema::date_time which represents a year, a month, a day, + hours, minutes, and seconds with an optional time zone. Its interface + is presented below. + For more information on the base xml_schema::time_zone + class refer to Section 6.4, "Time Zone + Representation".

+ + 
+namespace xml_schema
+{
+  class date_time
+  {
+  public:
+    date_time (int year, unsigned short month, unsigned short day,
+               unsigned short hours, unsigned short minutes,
+               double seconds);
+
+    date_time (int year, unsigned short month, unsigned short day,
+               unsigned short hours, unsigned short minutes,
+               double seconds, short zone_hours, short zone_minutes);
+
+    int
+    year () const;
+
+    void
+    year (int);
+
+    unsigned short
+    month () const;
+
+    void
+    month (unsigned short);
+
+    unsigned short
+    day () const;
+
+    void
+    day (unsigned short);
+
+    unsigned short
+    hours () const;
+
+    void
+    hours (unsigned short);
+
+    unsigned short
+    minutes () const;
+
+    void
+    minutes (unsigned short);
+
+    double
+    seconds () const;
+
+    void
+    seconds (double);
+  };
+
+  bool
+  operator== (const date_time&, const date_time&);
+
+  bool
+  operator!= (const date_time&, const date_time&);
+}
+
+ +

6.7 duration Parser

+ +

The return type of the duration_pimpl parser implementation + is xml_schema::duration which represents a potentially + negative duration in the form of years, months, days, hours, minutes, + and seconds. Its interface is presented below.

+ + 
+namespace xml_schema
+{
+  class duration
+  {
+  public:
+    duration (bool negative,
+              unsigned int years, unsigned int months, unsigned int days,
+              unsigned int hours, unsigned int minutes, double seconds);
+
+    bool
+    negative () const;
+
+    void
+    negative (bool);
+
+    unsigned int
+    years () const;
+
+    void
+    years (unsigned int);
+
+    unsigned int
+    months () const;
+
+    void
+    months (unsigned int);
+
+    unsigned int
+    days () const;
+
+    void
+    days (unsigned int);
+
+    unsigned int
+    hours () const;
+
+    void
+    hours (unsigned int);
+
+    unsigned int
+    minutes () const;
+
+    void
+    minutes (unsigned int);
+
+    double
+    seconds () const;
+
+    void
+    seconds (double);
+  };
+
+  bool
+  operator== (const duration&, const duration&);
+
+  bool
+  operator!= (const duration&, const duration&);
+}
+
+ + +

6.8 gDay Parser

+ +

The return type of the gday_pimpl parser implementation + is xml_schema::gday which represents a day of the month with + an optional time zone. Its interface is presented below. + For more information on the base xml_schema::time_zone + class refer to Section 6.4, "Time Zone + Representation".

+ + 
+namespace xml_schema
+{
+  class gday
+  {
+  public:
+    explicit
+    gday (unsigned short day);
+    gday (unsigned short day, short zone_hours, short zone_minutes);
+
+    unsigned short
+    day () const;
+
+    void
+    day (unsigned short);
+  };
+
+  bool
+  operator== (const gday&, const gday&);
+
+  bool
+  operator!= (const gday&, const gday&);
+}
+
+ +

6.9 gMonth Parser

+ +

The return type of the gmonth_pimpl parser implementation + is xml_schema::gmonth which represents a month of the year + with an optional time zone. Its interface is presented below. + For more information on the base xml_schema::time_zone + class refer to Section 6.4, "Time Zone + Representation".

+ + 
+namespace xml_schema
+{
+  class gmonth
+  {
+  public:
+    explicit
+    gmonth (unsigned short month);
+    gmonth (unsigned short month, short zone_hours, short zone_minutes);
+
+    unsigned short
+    month () const;
+
+    void
+    month (unsigned short);
+  };
+
+  bool
+  operator== (const gmonth&, const gmonth&);
+
+  bool
+  operator!= (const gmonth&, const gmonth&);
+}
+
+ +

6.10 gMonthDay Parser

+ +

The return type of the gmonth_day_pimpl parser implementation + is xml_schema::gmonth_day which represents a day and a month + of the year with an optional time zone. Its interface is presented below. + For more information on the base xml_schema::time_zone + class refer to Section 6.4, "Time Zone + Representation".

+ + 
+namespace xml_schema
+{
+  class gmonth_day
+  {
+  public:
+    gmonth_day (unsigned short month, unsigned short day);
+    gmonth_day (unsigned short month, unsigned short day,
+                short zone_hours, short zone_minutes);
+
+    unsigned short
+    month () const;
+
+    void
+    month (unsigned short);
+
+    unsigned short
+    day () const;
+
+    void
+    day (unsigned short);
+  };
+
+  bool
+  operator== (const gmonth_day&, const gmonth_day&);
+
+  bool
+  operator!= (const gmonth_day&, const gmonth_day&);
+}
+
+ +

6.11 gYear Parser

+ +

The return type of the gyear_pimpl parser implementation + is xml_schema::gyear which represents a year with + an optional time zone. Its interface is presented below. + For more information on the base xml_schema::time_zone + class refer to Section 6.4, "Time Zone + Representation".

+ + 
+namespace xml_schema
+{
+  class gyear
+  {
+  public:
+    explicit
+    gyear (int year);
+    gyear (int year, short zone_hours, short zone_minutes);
+
+    int
+    year () const;
+
+    void
+    year (int);
+  };
+
+  bool
+  operator== (const gyear&, const gyear&);
+
+  bool
+  operator!= (const gyear&, const gyear&);
+}
+
+ +

6.12 gYearMonth Parser

+ +

The return type of the gyear_month_pimpl parser implementation + is xml_schema::gyear_month which represents a year and a month + with an optional time zone. Its interface is presented below. + For more information on the base xml_schema::time_zone + class refer to Section 6.4, "Time Zone + Representation".

+ + 
+namespace xml_schema
+{
+  class gyear_month
+  {
+  public:
+    gyear_month (int year, unsigned short month);
+    gyear_month (int year, unsigned short month,
+                 short zone_hours, short zone_minutes);
+
+    int
+    year () const;
+
+    void
+    year (int);
+
+    unsigned short
+    month () const;
+
+    void
+    month (unsigned short);
+  };
+
+  bool
+  operator== (const gyear_month&, const gyear_month&);
+
+  bool
+  operator!= (const gyear_month&, const gyear_month&);
+}
+
+ + +

6.13 time Parser

+ +

The return type of the time_pimpl parser implementation + is xml_schema::time which represents hours, minutes, + and seconds with an optional time zone. Its interface is presented below. + For more information on the base xml_schema::time_zone + class refer to Section 6.4, "Time Zone + Representation".

+ + 
+namespace xml_schema
+{
+  class time
+  {
+  public:
+    time (unsigned short hours, unsigned short minutes, double seconds);
+    time (unsigned short hours, unsigned short minutes, double seconds,
+          short zone_hours, short zone_minutes);
+
+    unsigned short
+    hours () const;
+
+    void
+    hours (unsigned short);
+
+    unsigned short
+    minutes () const;
+
+    void
+    minutes (unsigned short);
+
+    double
+    seconds () const;
+
+    void
+    seconds (double);
+  };
+
+  bool
+  operator== (const time&, const time&);
+
+  bool
+  operator!= (const time&, const time&);
+}
+
+ + + + + +

7 Document Parser and Error Handling

+ +

In this chapter we will discuss the xml_schema::document + type as well as the error handling mechanisms provided by the mapping + in more detail. As mentioned in Section 3.4, + "Connecting the Parsers Together", the interface of + xml_schema::document depends on the underlying XML + parser selected (Section 5.3, "Underlying XML + Parser"). The following sections describe the + document type interface for Xerces-C++ and + Expat as underlying parsers.

+ +

7.1 Xerces-C++ Document Parser

+ +

When Xerces-C++ is used as the underlying XML parser, the + document type has the following interface. Note that + if the character type is wchar_t, then the string type + in the interface becomes std::wstring + (see Section 5.2, "Character Type and Encoding").

+ + 
+namespace xml_schema
+{
+  class parser_base;
+  class error_handler;
+
+  class flags
+  {
+  public:
+    // Do not validate XML documents with the Xerces-C++ validator.
+    //
+    static const unsigned long dont_validate;
+
+    // Do not initialize the Xerces-C++ runtime.
+    //
+    static const unsigned long dont_initialize;
+
+    // Disable handling of subsequent imports for the same namespace
+    // in Xerces-C++ 3.1.0 and later.
+    //
+    static const unsigned long no_multiple_imports;
+  };
+
+  class properties
+  {
+  public:
+    // Add a location for a schema with a target namespace.
+    //
+    void
+    schema_location (const std::string& namespace_,
+                     const std::string& location);
+
+    // Add a location for a schema without a target namespace.
+    //
+    void
+    no_namespace_schema_location (const std::string& location);
+  };
+
+  class document
+  {
+  public:
+    document (parser_base& root,
+              const std::string& root_element_name,
+	      bool polymorphic = false);
+
+    document (parser_base& root,
+              const std::string& root_element_namespace,
+              const std::string& root_element_name,
+	      bool polymorphic = false);
+
+  public:
+    // Parse URI or a local file.
+    //
+    void
+    parse (const std::string& uri,
+           flags = 0,
+           const properties& = properties ());
+
+    // Parse URI or a local file with a user-provided error_handler
+    // object.
+    //
+    void
+    parse (const std::string& uri,
+           error_handler&,
+           flags = 0,
+           const properties& = properties ());
+
+    // Parse URI or a local file with a user-provided ErrorHandler
+    // object. Note that you must initialize the Xerces-C++ runtime
+    // before calling this function.
+    //
+    void
+    parse (const std::string& uri,
+           xercesc::ErrorHandler&,
+           flags = 0,
+           const properties& = properties ());
+
+    // Parse URI or a local file using a user-provided SAX2XMLReader
+    // object. Note that you must initialize the Xerces-C++ runtime
+    // before calling this function.
+    //
+    void
+    parse (const std::string& uri,
+           xercesc::SAX2XMLReader&,
+           flags = 0,
+           const properties& = properties ());
+
+  public:
+    // Parse std::istream.
+    //
+    void
+    parse (std::istream&,
+           flags = 0,
+           const properties& = properties ());
+
+    // Parse std::istream with a user-provided error_handler object.
+    //
+    void
+    parse (std::istream&,
+           error_handler&,
+           flags = 0,
+           const properties& = properties ());
+
+    // Parse std::istream with a user-provided ErrorHandler object.
+    // Note that you must initialize the Xerces-C++ runtime before
+    // calling this function.
+    //
+    void
+    parse (std::istream&,
+           xercesc::ErrorHandler&,
+           flags = 0,
+           const properties& = properties ());
+
+    // Parse std::istream using a user-provided SAX2XMLReader object.
+    // Note that you must initialize the Xerces-C++ runtime before
+    // calling this function.
+    //
+    void
+    parse (std::istream&,
+           xercesc::SAX2XMLReader&,
+           flags = 0,
+           const properties& = properties ());
+
+  public:
+    // Parse std::istream with a system id.
+    //
+    void
+    parse (std::istream&,
+           const std::string& system_id,
+           flags = 0,
+           const properties& = properties ());
+
+    // Parse std::istream with a system id and a user-provided
+    // error_handler object.
+    //
+    void
+    parse (std::istream&,
+           const std::string& system_id,
+           error_handler&,
+           flags = 0,
+           const properties& = properties ());
+
+    // Parse std::istream with a system id and a user-provided
+    // ErrorHandler object. Note that you must initialize the
+    // Xerces-C++ runtime before calling this function.
+    //
+    void
+    parse (std::istream&,
+           const std::string& system_id,
+           xercesc::ErrorHandler&,
+           flags = 0,
+           const properties& = properties ());
+
+    // Parse std::istream with a system id using a user-provided
+    // SAX2XMLReader object. Note that you must initialize the
+    // Xerces-C++ runtime before calling this function.
+    //
+    void
+    parse (std::istream&,
+           const std::string& system_id,
+           xercesc::SAX2XMLReader&,
+           flags = 0,
+           const properties& = properties ());
+
+  public:
+    // Parse std::istream with system and public ids.
+    //
+    void
+    parse (std::istream&,
+           const std::string& system_id,
+           const std::string& public_id,
+           flags = 0,
+           const properties& = properties ());
+
+    // Parse std::istream with system and public ids and a user-provided
+    // error_handler object.
+    //
+    void
+    parse (std::istream&,
+           const std::string& system_id,
+           const std::string& public_id,
+           error_handler&,
+           flags = 0,
+           const properties& = properties ());
+
+    // Parse std::istream with system and public ids and a user-provided
+    // ErrorHandler object. Note that you must initialize the Xerces-C++
+    // runtime before calling this function.
+    //
+    void
+    parse (std::istream&,
+           const std::string& system_id,
+           const std::string& public_id,
+           xercesc::ErrorHandler&,
+           flags = 0,
+           const properties& = properties ());
+
+    // Parse std::istream with system and public ids using a user-
+    // provided SAX2XMLReader object. Note that you must initialize
+    // the Xerces-C++ runtime before calling this function.
+    //
+    void
+    parse (std::istream&,
+           const std::string& system_id,
+           const std::string& public_id,
+           xercesc::SAX2XMLReader&,
+           flags = 0,
+           const properties& = properties ());
+
+  public:
+    // Parse InputSource. Note that you must initialize the Xerces-C++
+    // runtime before calling this function.
+    //
+    void
+    parse (const xercesc::InputSource&,
+           flags = 0,
+           const properties& = properties ());
+
+    // Parse InputSource with a user-provided error_handler object.
+    // Note that you must initialize the Xerces-C++ runtime before
+    // calling this function.
+    //
+    void
+    parse (const xercesc::InputSource&,
+           error_handler&,
+           flags = 0,
+           const properties& = properties ());
+
+    // Parse InputSource with a user-provided ErrorHandler object.
+    // Note that you must initialize the Xerces-C++ runtime before
+    // calling this function.
+    //
+    void
+    parse (const xercesc::InputSource&,
+           xercesc::ErrorHandler&,
+           flags = 0,
+           const properties& = properties ());
+
+    // Parse InputSource using a user-provided SAX2XMLReader object.
+    // Note that you must initialize the Xerces-C++ runtime before
+    // calling this function.
+    //
+    void
+    parse (const xercesc::InputSource&,
+           xercesc::SAX2XMLReader&,
+           flags = 0,
+           const properties& = properties ());
+  };
+}
+
+ +

The document class is a root parser for + the vocabulary. The first argument to its constructors is the + parser for the type of the root element. The parser_base + class is the base type for all parser skeletons. The second and + third arguments to the document's constructors are + the root element's name and namespace. The last argument, + polymorphic, specifies whether the XML documents + being parsed use polymorphism. For more information on support + for XML Schema polymorphism in the C++/Parser mapping refer + to Section 5.5, "Support for Polymorphism".

+ +

The rest of the document interface consists of overloaded + parse() functions. The last two arguments in each of these + functions are flags and properties. The + flags argument allows you to modify the default behavior + of the parsing functions. The properties argument allows + you to override the schema location attributes specified in XML + documents. Note that the schema location paths are relative to an + XML document unless they are complete URIs. For example if you want + to use a local schema file then you will need to use a URI in the + form file:///absolute/path/to/your/schema.

+ +

A number of overloaded parse() functions have the + system_id and public_id arguments. The + system id is a system identifier of the resources being + parsed (for example, URI or a full file path). The public id is a + public identifier of the resource (for example, an + application-specific name or a relative file path). The system id + is used to resolve relative paths (for example, schema paths). In + diagnostics messages the public id is used if it is available. + Otherwise the system id is used.

+ +

The error handling mechanisms employed by the document + parser are described in Section 7.3, "Error + Handling".

+ +

7.2 Expat Document Parser

+ +

When Expat is used as the underlying XML parser, the + document type has the following interface. Note that + if the character type is wchar_t, then the string type + in the interface becomes std::wstring + (see Section 5.2, "Character Type and Encoding").

+ + 
+namespace xml_schema
+{
+  class parser_base;
+  class error_handler;
+
+  class document
+  {
+  public:
+    document (parser_base&,
+              const std::string& root_element_name,
+              bool polymorphic = false);
+
+    document (parser_base&,
+              const std::string& root_element_namespace,
+              const std::string& root_element_name,
+              bool polymorphic = false);
+
+  public:
+    // Parse a local file. The file is accessed with std::ifstream
+    // in binary mode. The std::ios_base::failure exception is used
+    // to report io errors (badbit and failbit).
+    void
+    parse (const std::string& file);
+
+    // Parse a local file with a user-provided error_handler
+    // object. The file is accessed with std::ifstream in binary
+    // mode. The std::ios_base::failure exception is used to report
+    // io errors (badbit and failbit).
+    //
+    void
+    parse (const std::string& file, error_handler&);
+
+  public:
+    // Parse std::istream.
+    //
+    void
+    parse (std::istream&);
+
+    // Parse std::istream with a user-provided error_handler object.
+    //
+    void
+    parse (std::istream&, error_handler&);
+
+    // Parse std::istream with a system id.
+    //
+    void
+    parse (std::istream&, const std::string& system_id);
+
+    // Parse std::istream with a system id and a user-provided
+    // error_handler object.
+    //
+    void
+    parse (std::istream&,
+           const std::string& system_id,
+           error_handler&);
+
+    // Parse std::istream with system and public ids.
+    //
+    void
+    parse (std::istream&,
+           const std::string& system_id,
+           const std::string& public_id);
+
+    // Parse std::istream with system and public ids and a user-provided
+    // error_handler object.
+    //
+    void
+    parse (std::istream&,
+           const std::string& system_id,
+           const std::string& public_id,
+           error_handler&);
+
+  public:
+    // Parse a chunk of input. You can call these functions multiple
+    // times with the last call having the last argument true.
+    //
+    void
+    parse (const void* data, std::size_t size, bool last);
+
+    void
+    parse (const void* data, std::size_t size, bool last,
+           error_handler&);
+
+    void
+    parse (const void* data, std::size_t size, bool last,
+           const std::string& system_id);
+
+    void
+    parse (const void* data, std::size_t size, bool last,
+           const std::string& system_id,
+           error_handler&);
+
+    void
+    parse (const void* data, std::size_t size, bool last,
+           const std::string& system_id,
+           const std::string& public_id);
+
+    void
+    parse (const void* data, std::size_t size, bool last,
+           const std::string& system_id,
+           const std::string& public_id,
+           error_handler&);
+
+  public:
+    // Low-level Expat-specific parsing API.
+    //
+    void
+    parse_begin (XML_Parser);
+
+    void
+    parse_begin (XML_Parser, const std::string& public_id);
+
+    void
+    parse_begin (XML_Parser, error_handler&);
+
+    void
+    parse_begin (XML_Parser,
+                 const std::string& public_id,
+                 error_handler&);
+    void
+    parse_end ();
+  };
+}
+
+ +

The document class is a root parser for + the vocabulary. The first argument to its constructors is the + parser for the type of the root element. The parser_base + class is the base type for all parser skeletons. The second and + third arguments to the document's constructors are + the root element's name and namespace. The last argument, + polymorphic, specifies whether the XML documents + being parsed use polymorphism. For more information on support + for XML Schema polymorphism in the C++/Parser mapping refer + to Section 5.5, "Support for Polymorphism".

+ +

A number of overloaded parse() functions have the + system_id and public_id arguments. The + system id is a system identifier of the resources being + parsed (for example, URI or a full file path). The public id is a + public identifier of the resource (for example, an + application-specific name or a relative file path). The system id + is used to resolve relative paths. In diagnostics messages the + public id is used if it is available. Otherwise the system id + is used.

+ +

The parse_begin() and parse_end() functions + present a low-level, Expat-specific parsing API for maximum control. + A typical use-case would look like this (pseudo-code):

+ + 
+xxx_pimpl root_p;
+document doc_p (root_p, "root");
+
+root_p.pre ();
+doc_p.parse_begin (xml_parser, "file.xml");
+
+while (more_data_to_parse)
+{
+  // Call XML_Parse or XML_ParseBuffer.
+
+  if (status == XML_STATUS_ERROR)
+    break;
+}
+
+// Call parse_end even in case of an error to translate
+// XML and Schema errors to exceptions or error_handler
+// calls.
+//
+doc.parse_end ();
+result_type result (root_p.post_xxx ());
+
+ +

Note that if your vocabulary uses XML namespaces, the + XML_ParserCreateNS() functions should be used to create + the XML parser. Space (XML_Char (' ')) should be used + as a separator (the second argument to XML_ParserCreateNS()). +

+ +

The error handling mechanisms employed by the document + parser are described in Section 7.3, "Error + Handling".

+ + +

7.3 Error Handling

+ +

There are three categories of errors that can result from running + a parser on an XML document: System, XML, and Application. + The System category contains memory allocation and file/stream + operation errors. The XML category covers XML parsing and + well-formedness checking as well as XML Schema validation errors. + Finally, the Application category is for application logic errors + that you may want to propagate from parser implementations to the + caller of the parser. +

+ +

The System errors are mapped to the standard exceptions. The + out of memory condition is indicated by throwing an instance + of std::bad_alloc. The stream operation errors + are reported either by throwing an instance of + std::ios_base::failure if exceptions are enabled + or by setting the stream state.

+ +

Note that if you are parsing std::istream on + which exceptions are not enabled, then you will need to + check the stream state before calling the post() + callback, as shown in the following example:

+ + 
+int
+main (int argc, char* argv[])
+{
+  ...
+
+  std::ifstream ifs (argv[1]);
+
+  if (ifs.fail ())
+  {
+    cerr << argv[1] << ": unable to open" << endl;
+    return 1;
+  }
+
+  root_p.pre ();
+  doc_p.parse (ifs);
+
+  if (ifs.fail ())
+  {
+    cerr << argv[1] << ": io failure" << endl;
+    return 1;
+  }
+
+  result_type result (root_p.post_xxx ());
+}
+
+ +

The above example can be rewritten to use exceptions + as shown below:

+ + 
+int
+main (int argc, char* argv[])
+{
+  try
+  {
+    ...
+
+    std::ifstream ifs;
+    ifs.exceptions (std::ifstream::badbit | std::ifstream::failbit);
+    ifs.open (argv[1]);
+
+    root_p.pre ();
+    doc_p.parse (ifs);
+    result_type result (root_p.post_xxx ());
+  }
+  catch (const std::ifstream::failure&)
+  {
+    cerr << argv[1] << ": unable to open or io failure" << endl;
+    return 1;
+  }
+}
+
+ + +

For reporting application errors from parsing callbacks, you + can throw any exceptions of your choice. They are propagated to + the caller of the parser without any alterations.

+ +

The XML errors can be reported either by throwing the + xml_schema::parsing exception or by a callback + to the xml_schema::error_handler object (and + xercesc::ErrorHandler object in case of Xerces-C++).

+ +

The xml_schema::parsing exception contains + a list of warnings and errors that were accumulated during + parsing. Note that this exception is thrown only if there + was an error. This makes it impossible to obtain warnings + from an otherwise successful parsing using this mechanism. + The following listing shows the definition of + xml_schema::parsing exception. Note that if the + character type is wchar_t, then the string type + and output stream type in the definition become + std::wstring and std::wostream, + respectively (see Section 5.2, "Character Type + and Encoding").

+ + 
+namespace xml_schema
+{
+  class exception: public std::exception
+  {
+  protected:
+    virtual void
+    print (std::ostream&) const = 0;
+  };
+
+  inline std::ostream&
+  operator<< (std::ostream& os, const exception& e)
+  {
+    e.print (os);
+    return os;
+  }
+
+
+  class severity
+  {
+  public:
+    enum value
+    {
+      warning,
+      error
+    };
+  };
+
+
+  class error
+  {
+  public:
+    error (xml_schema::severity,
+           const std::string& id,
+           unsigned long line,
+           unsigned long column,
+           const std::string& message);
+
+    xml_schema::severity
+    severity () const;
+
+    const std::string&
+    id () const;
+
+    unsigned long
+    line () const;
+
+    unsigned long
+    column () const;
+
+    const std::string&
+    message () const;
+  };
+
+  std::ostream&
+  operator<< (std::ostream&, const error&);
+
+
+  class diagnostics: public std::vector<error>
+  {
+  };
+
+  std::ostream&
+  operator<< (std::ostream&, const diagnostics&);
+
+
+  class parsing: public exception
+  {
+  public:
+    parsing ();
+    parsing (const xml_schema::diagnostics&);
+
+    const xml_schema::diagnostics&
+    diagnostics () const;
+
+    virtual const char*
+    what () const throw ();
+
+  protected:
+    virtual void
+    print (std::ostream&) const;
+  };
+}
+
+ +

The following example shows how we can catch and print this + exception. The code will print diagnostics messages one per line + in case of an error.

+ + 
+int
+main (int argc, char* argv[])
+{
+  try
+  {
+    // Parse.
+  }
+  catch (const xml_schema::parsing& e)
+  {
+    cerr << e << endl;
+    return 1;
+  }
+}
+
+ +

With the error_handler approach the diagnostics + messages are delivered as parsing progresses. The following + listing presents the definition of the error_handler + interface. Note that if the character type is wchar_t, + then the string type in the interface becomes std::wstring + (see Section 5.2, "Character Type and Encoding").

+ + 
+namespace xml_schema
+{
+  class error_handler
+  {
+  public:
+    class severity
+    {
+    public:
+      enum value
+      {
+        warning,
+        error,
+        fatal
+      };
+    };
+
+    virtual bool
+    handle (const std::string& id,
+            unsigned long line,
+            unsigned long column,
+            severity,
+            const std::string& message) = 0;
+  };
+}
+
+ +

The return value of the handle() function indicates whether + parsing should continue if possible. The error with the fatal severity + level terminates the parsing process regardless of the returned value. + At the end of the parsing process with an error that was reported via + the error_handler object, an empty + xml_schema::parsing exception is thrown to indicate + the failure to the caller. You can alter this behavior by throwing + your own exception from the handle() function.

+ + + + + +

Appendix A — Supported XML Schema Constructs

+ +

The C++/Parser mapping supports validation of the following W3C XML + Schema constructs in the generated code.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
ConstructNotes
Structure
element
attribute
any
anyAttribute
all
sequence
choice
complex type, empty content
complex type, mixed content
complex type, simple content extension
complex type, simple content restrictionSimple type facets are not validated.
complex type, complex content extension
complex type, complex content restriction
list
Datatypes
byte
unsignedByte
short
unsignedShort
int
unsignedInt
long
unsignedLong
integer
nonPositiveInteger
nonNegativeInteger
positiveInteger
negativeInteger
boolean
float
double
decimal
string
normalizedString
token
Name
NMTOKEN
NCName
language
anyURI
IDIdentity constraint is not enforced.
IDREFIdentity constraint is not enforced.
NMTOKENS
IDREFSIdentity constraint is not enforced.
QName
base64Binary
hexBinary
date
dateTime
duration
gDay
gMonth
gMonthDay
gYear
gYearMonth
time
+ + +
+
+ + + diff --git a/doc/cxx/parser/guide/index.xhtml.in b/doc/cxx/parser/guide/index.xhtml.in new file mode 100644 index 0000000..119f421 --- /dev/null +++ b/doc/cxx/parser/guide/index.xhtml.in @@ -0,0 +1,4163 @@ + + + + + + C++/Parser Mapping Getting Started Guide + + + + + + + + + + + + + +
+
+ +
+ +
+
C++/Parser Mapping
+
Getting Started Guide
+ +

Copyright © @copyright@.

+ +

Permission is granted to copy, distribute and/or modify this + document under the terms of the + GNU Free + Documentation License, version 1.2; with no Invariant Sections, + no Front-Cover Texts and no Back-Cover Texts. +

+ +

This document is available in the following formats: + XHTML, + PDF, and + PostScript.

+ +
+ +

Table of Contents

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Preface + + + +
About This Document
More Information
+
1Introduction + + + +
1.1Mapping Overview
1.2Benefits
+
2Hello World Example + + + + + +
2.1Writing XML Document and Schema
2.2Translating Schema to C++
2.3Implementing Application Logic
2.4Compiling and Running
+
3Parser Skeletons + + + + + +
3.1Implementing the Gender Parser
3.2Implementing the Person Parser
3.3Implementing the People Parser
3.4Connecting the Parsers Together
+
4Type Maps + + + + +
4.1Object Model
4.2Type Map File Format
4.3Parser Implementations
+
5Mapping Configuration + + + + + + +
5.1C++ Standard
5.2Character Type and Encoding
5.3Underlying XML Parser
5.4XML Schema Validation
5.5Support for Polymorphism
+
6Built-In XML Schema Type Parsers + + + + + + + + + + + + + + +
6.1QName Parser
6.2NMTOKENS and IDREFS Parsers
6.3base64Binary and hexBinary Parsers
6.4Time Zone Representation
6.5date Parser
6.6dateTime Parser
6.7duration Parser
6.8gDay Parser
6.9gMonth Parser
6.10gMonthDay Parser
6.11gYear Parser
6.12gYearMonth Parser
6.13time Parser
+
7Document Parser and Error Handling + + + + +
7.1Xerces-C++ Document Parser
7.2Expat Document Parser
7.3Error Handling
+
Appendix A — Supported XML Schema Constructs
+
+ +

Preface

+ +

About This Document

+ +

The goal of this document is to provide you with an understanding of + the C++/Parser programming model and allow you to efficiently evaluate + XSD against your project's technical requirements. As such, this + document is intended for C++ developers and software architects + who are looking for an XML processing solution. Prior experience + with XML and C++ is required to understand this document. Basic + understanding of XML Schema is advantageous but not expected + or required. +

+ + +

More Information

+ +

Beyond this guide, you may also find the following sources of + information useful:

+ +
    +
  • XSD + Compiler Command Line Manual
    • + +
  • The cxx/parser/ directory in the + xsd-examples package + contains a collection of examples and a README file with an overview + of each example.
    • + +
  • The README file in the + xsd-examples package + explains how to build the examples.
    • + +
  • The xsd-users + mailing list is the place to ask technical questions about XSD and the C++/Parser mapping. + Furthermore, the archives + may already have answers to some of your questions.
    • + +
+ + + +

1 Introduction

+ +

Welcome to CodeSynthesis XSD and the C++/Parser mapping. XSD is a + cross-platform W3C XML Schema to C++ data binding compiler. C++/Parser + is a W3C XML Schema to C++ mapping that represents an XML vocabulary + as a set of parser skeletons which you can implement to perform XML + processing as required by your application logic. +

+ +

1.1 Mapping Overview

+ +

The C++/Parser mapping provides event-driven, stream-oriented + XML parsing, XML Schema validation, and C++ data binding. It was + specifically designed and optimized for high performance and + small footprint. Based on the static analysis of the schemas, XSD + generates compact, highly-optimized hierarchical state machines + that combine data extraction, validation, and even dispatching + in a single step. As a result, the generated code is typically + 2-10 times faster than general-purpose validating XML parsers + while maintaining the lowest static and dynamic memory footprints. +

+ +

To speed up application development, the C++/Parser mapping + can be instructed to generate sample parser implementations + and a test driver which can then be filled with the application + logic code. The mapping also provides a wide range of + mechanisms for controlling and customizing the generated code.

+ +

The next chapter shows how to create a simple application that uses + the C++/Parser mapping to parse, validate, and extract data from a + simple XML document. The following chapters show how to + use the C++/Parser mapping in more detail.

+ +

1.2 Benefits

+ +

Traditional XML access APIs such as Document Object Model (DOM) + or Simple API for XML (SAX) have a number of drawbacks that + make them less suitable for creating robust and maintainable + XML processing applications. These drawbacks include: +

+ +
    +
  • Generic representation of XML in terms of elements, attributes, + and text forces an application developer to write a substantial + amount of bridging code that identifies and transforms pieces + of information encoded in XML to a representation more suitable + for consumption by the application logic.
    • + +
  • String-based flow control defers error detection to runtime. + It also reduces code readability and maintainability.
    • + +
  • Lack of type safety because the data is represented + as text.
    • + +
  • Resulting applications are hard to debug, change, and + maintain.
    • +
+ +

In contrast, statically-typed, vocabulary-specific parser + skeletons produced by the C++/Parser mapping allow you to + operate in your domain terms instead of the generic elements, + attributes, and text. Static typing helps catch errors at + compile-time rather than at run-time. Automatic code generation + frees you for more interesting tasks (such as doing something + useful with the information stored in the XML documents) and + minimizes the effort needed to adapt your applications to + changes in the document structure. To summarize, the C++/Parser + mapping has the following key advantages over generic XML + access APIs:

+ +
    +
  • Ease of use. The generated code hides all the complexity + associated with recreating the document structure, maintaining the + dispatch state, and converting the data from the text representation + to data types suitable for manipulation by the application logic. + Parser skeletons also provide a convenient mechanism for building + custom in-memory representations.
    • + +
  • Natural representation. The generated parser skeletons + implement parser callbacks as virtual functions with names + corresponding to elements and attributes in XML. As a result, + you process the XML data using your domain vocabulary instead + of generic elements, attributes, and text. +
    • + +
  • Concise code. With a separate parser skeleton for each + XML Schema type, the application implementation is + simpler and thus easier to read and understand.
    • + +
  • Safety. The XML data is delivered to parser callbacks as + statically typed objects. The parser callbacks themselves are virtual + functions. This helps catch programming errors at compile-time + rather than at runtime.
    • + +
  • Maintainability. Automatic code generation minimizes the + effort needed to adapt the application to changes in the + document structure. With static typing, the C++ compiler + can pin-point the places in the application code that need to be + changed.
    • + +
  • Efficiency. The generated parser skeletons combine + data extraction, validation, and even dispatching in a single + step. This makes them much more efficient than traditional + architectures with separate stages for validation and data + extraction/dispatch.
    • +
+ + + + +

2 Hello World Example

+ +

In this chapter we will examine how to parse a very simple XML + document using the XSD-generated C++/Parser skeletons. + The code presented in this chapter is based on the hello + example which can be found in the cxx/parser/ directory in + the xsd-examples + package.

+ +

2.1 Writing XML Document and Schema

+ +

First, we need to get an idea about the structure + of the XML documents we are going to process. Our + hello.xml, for example, could look like this:

+ + 
+<?xml version="1.0"?>
+<hello>
+
+  <greeting>Hello</greeting>
+
+  <name>sun</name>
+  <name>moon</name>
+  <name>world</name>
+
+</hello>
+
+ +

Then we can write a description of the above XML in the + XML Schema language and save it into hello.xsd:

+ + 
+<?xml version="1.0"?>
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+
+  <xs:complexType name="hello">
+    <xs:sequence>
+      <xs:element name="greeting" type="xs:string"/>
+      <xs:element name="name" type="xs:string" maxOccurs="unbounded"/>
+    </xs:sequence>
+  </xs:complexType>
+
+  <xs:element name="hello" type="hello"/>
+
+</xs:schema>
+
+ +

Even if you are not familiar with XML Schema, it + should be easy to connect declarations in hello.xsd + to elements in hello.xml. The hello type + is defined as a sequence of the nested greeting and + name elements. Note that the term sequence in XML + Schema means that elements should appear in a particular order + as opposed to appearing multiple times. The name + element has its maxOccurs property set to + unbounded which means it can appear multiple times + in an XML document. Finally, the globally-defined hello + element prescribes the root element for our vocabulary. For an + easily-approachable introduction to XML Schema refer to + XML Schema Part 0: + Primer.

+ +

The above schema is a specification of our XML vocabulary; it tells + everybody what valid documents of our XML-based language should look + like. The next step is to compile this schema to generate + the object model and parsing functions.

+ +

2.2 Translating Schema to C++

+ +

Now we are ready to translate our hello.xsd to C++ parser + skeletons. To do this we invoke the XSD compiler from a terminal + (UNIX) or a command prompt (Windows): +

+ + 
+$ xsd cxx-parser --xml-parser expat hello.xsd
+
+ +

The --xml-parser option indicates that we want to + use Expat as the underlying XML parser (see Section + 5.3, "Underlying XML Parser"). The XSD compiler produces two + C++ files: hello-pskel.hxx and hello-pskel.cxx. + The following code fragment is taken from hello-pskel.hxx; + it should give you an idea about what gets generated: +

+ + 
+class hello_pskel
+{
+public:
+  // Parser callbacks. Override them in your implementation.
+  //
+  virtual void
+  pre ();
+
+  virtual void
+  greeting (const std::string&);
+
+  virtual void
+  name (const std::string&);
+
+  virtual void
+  post_hello ();
+
+  // Parser construction API.
+  //
+  void
+  greeting_parser (xml_schema::string_pskel&);
+
+  void
+  name_parser (xml_schema::string_pskel&);
+
+  void
+  parsers (xml_schema::string_pskel& /* greeting */,
+           xml_schema::string_pskel& /* name */);
+
+private:
+  ...
+};
+
+ +

The first four member functions shown above are called parser + callbacks. You would normally override them in your implementation + of the parser to do something useful. Let's go through all of + them one by one.

+ +

The pre() function is an initialization callback. It is + called when a new element of type hello is about + to be parsed. You would normally use this function to allocate a new + instance of the resulting type or clear accumulators that are used + to gather information during parsing. The default implementation + of this function does nothing.

+ +

The post_hello() function is a finalization callback. Its + name is constructed by adding the parser skeleton name to the + post_ prefix. The finalization callback is called when + parsing of the element is complete and the result, if any, should + be returned. Note that in our case the return type of + post_hello() is void which means there + is nothing to return. More on parser return types later. +

+ +

You may be wondering why the finalization callback is called + post_hello() instead of post() just + like pre(). The reason for this is that + finalization callbacks can have different return types and + result in function signature clashes across inheritance + hierarchies. To prevent this the signatures of finalization + callbacks are made unique by adding the type name to their names.

+ +

The greeting() and name() functions are + called when the greeting and name elements + have been parsed, respectively. Their arguments are of type + std::string and contain the data extracted from XML.

+ +

The last three functions are for connecting parsers to each other. + For example, there is a predefined parser for built-in XML Schema type + string in the XSD runtime. We will be using + it to parse the contents of greeting and + name elements, as shown in the next section.

+ +

2.3 Implementing Application Logic

+ +

At this point we have all the parts we need to do something useful + with the information stored in our XML document. The first step is + to implement the parser: +

+ + 
+#include <iostream>
+#include "hello-pskel.hxx"
+
+class hello_pimpl: public hello_pskel
+{
+public:
+  virtual void
+  greeting (const std::string& g)
+  {
+    greeting_ = g;
+  }
+
+  virtual void
+  name (const std::string& n)
+  {
+    std::cout << greeting_ << ", " << n << "!" << std::endl;
+  }
+
+private:
+  std::string greeting_;
+};
+
+ +

We left both pre() and post_hello() with the + default implementations; we don't have anything to initialize or + return. The rest is pretty straightforward: we store the greeting + in a member variable and later, when parsing names, use it to + say hello.

+ +

An observant reader my ask what happens if the name + element comes before greeting? Don't we need to + make sure greeting_ was initialized and report + an error otherwise? The answer is no, we don't have to do + any of this. The hello_pskel parser skeleton + performs validation of XML according to the schema from which + it was generated. As a result, it will check the order + of the greeting and name elements + and report an error if it is violated.

+ +

Now it is time to put this parser implementation to work:

+ + 
+using namespace std;
+
+int
+main (int argc, char* argv[])
+{
+  try
+  {
+    // Construct the parser.
+    //
+    xml_schema::string_pimpl string_p;
+    hello_pimpl hello_p;
+
+    hello_p.greeting_parser (string_p);
+    hello_p.name_parser (string_p);
+
+    // Parse the XML instance.
+    //
+    xml_schema::document doc_p (hello_p, "hello");
+
+    hello_p.pre ();
+    doc_p.parse (argv[1]);
+    hello_p.post_hello ();
+  }
+  catch (const xml_schema::exception& e)
+  {
+    cerr << e << endl;
+    return 1;
+  }
+}
+
+ +

The first part of this code snippet instantiates individual parsers + and assembles them into a complete vocabulary parser. + xml_schema::string_pimpl is an implementation of a parser + for built-in XML Schema type string. It is provided by + the XSD runtime along with parsers for other built-in types (for + more information on the built-in parsers see Chapter 6, + "Built-In XML Schema Type Parsers"). We use string_pimpl + to parse the greeting and name elements as + indicated by the calls to greeting_parser() and + name_parser(). +

+ +

Then we instantiate a document parser (doc_p). The + first argument to its constructor is the parser for + the root element (hello_p in our case). The + second argument is the root element name. +

+ +

The final piece is the calls to pre(), parse(), + and post_hello(). The call to parse() + perform the actual XML parsing while the calls to pre() and + post_hello() make sure that the parser for the root + element can perform proper initialization and cleanup.

+ +

While our parser implementation and test driver are pretty small and + easy to write by hand, for bigger XML vocabularies it can be a + substantial effort. To help with this task XSD can automatically + generate sample parser implementations and a test driver from your + schemas. You can request the generation of a sample implementation with + empty function bodies by specifying the --generate-noop-impl + option. Or you can generate a sample implementation that prints the + data store in XML by using the --generate-print-impl + option. To request the generation of a test driver you can use the + --generate-test-driver option. For more information + on these options refer to the + XSD + Compiler Command Line Manual. The 'generated' example + in the xsd-examples package + shows the sample implementation generation feature in action.

+ + +

2.4 Compiling and Running

+ +

After saving all the parts from the previous section in + driver.cxx, we are ready to compile our first + application and run it on the test XML document. On a UNIX + system this can be done with the following commands: +

+ + 
+$ c++ -std=c++11 -I.../libxsd -c driver.cxx hello-pskel.cxx
+$ c++ -std=c++11 -o driver driver.o hello-pskel.o -lexpat
+$ ./driver hello.xml
+Hello, sun!
+Hello, moon!
+Hello, world!
+
+ +

Here .../libxsd represents the path to the + libxsd package root + directory. We can also test the error handling. To test XML + well-formedness checking, we can try to parse + hello-pskel.hxx:

+ + 
+$ ./driver hello-pskel.hxx
+hello-pskel.hxx:1:0: not well-formed (invalid token)
+
+ +

We can also try to parse a valid XML but not from our + vocabulary, for example hello.xsd:

+ + 
+$ ./driver hello.xsd
+hello.xsd:2:0: expected element 'hello' instead of
+'http://www.w3.org/2001/XMLSchema#schema'
+
+ + + + + +

3 Parser Skeletons

+ +

As we have seen in the previous chapter, the XSD compiler generates + a parser skeleton class for each type defined in XML Schema. In + this chapter we will take a closer look at different functions + that comprise a parser skeleton as well as the way to connect + our implementations of these parser skeletons to create a complete + parser.

+ +

In this and subsequent chapters we will use the following schema + that describes a collection of person records. We save it in + people.xsd:

+ + 
+<?xml version="1.0"?>
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+
+  <xs:simpleType name="gender">
+    <xs:restriction base="xs:string">
+      <xs:enumeration value="male"/>
+      <xs:enumeration value="female"/>
+    </xs:restriction>
+  </xs:simpleType>
+
+  <xs:complexType name="person">
+    <xs:sequence>
+      <xs:element name="first-name" type="xs:string"/>
+      <xs:element name="last-name" type="xs:string"/>
+      <xs:element name="gender" type="gender"/>
+      <xs:element name="age" type="xs:short"/>
+    </xs:sequence>
+  </xs:complexType>
+
+  <xs:complexType name="people">
+    <xs:sequence>
+      <xs:element name="person" type="person" maxOccurs="unbounded"/>
+    </xs:sequence>
+  </xs:complexType>
+
+  <xs:element name="people" type="people"/>
+
+</xs:schema>
+
+ +

A sample XML instance to go along with this schema is saved + in people.xml:

+ + 
+<?xml version="1.0"?>
+<people>
+  <person>
+    <first-name>John</first-name>
+    <last-name>Doe</last-name>
+    <gender>male</gender>
+    <age>32</age>
+  </person>
+  <person>
+    <first-name>Jane</first-name>
+    <last-name>Doe</last-name>
+    <gender>female</gender>
+    <age>28</age>
+  </person>
+</people>
+
+ +

Compiling people.xsd with the XSD compiler results + in three parser skeletons being generated: gender_pskel, + person_pskel, and people_pskel. We are going + to examine and implement each of them in the subsequent sections.

+ +

3.1 Implementing the Gender Parser

+ +

The generated gender_pskel parser skeleton looks like + this:

+ + 
+class gender_pskel: public virtual xml_schema::string_pskel
+{
+public:
+  // Parser callbacks. Override them in your implementation.
+  //
+  virtual void
+  pre ();
+
+  virtual void
+  post_gender ();
+};
+
+ +

Notice that gender_pskel inherits from + xml_schema::string_skel which is a parser skeleton + for built-in XML Schema type string and is + predefined in the XSD runtime library. This is an example + of the general rule that parser skeletons follow: if a type + in XML Schema inherits from another then there will be an + equivalent inheritance between the corresponding parser + skeleton classes.

+ +

The pre() and post_gender() callbacks + should look familiar from the previous chapter. Let's now + implement the parser. Our implementation will simply print + the gender to cout:

+ + + 
+class gender_pimpl: public gender_pskel,
+                    public xml_schema::string_pimpl
+{
+public:
+  virtual void
+  post_gender ()
+  {
+    std::string s = post_string ();
+    cout << "gender: " << s << endl;
+  }
+};
+
+ +

While the code is quite short, there is a lot going on. First, + notice that we are inheriting from gender_pskel and + from xml_schema::string_pimpl. We've encountered + xml_schema::string_pimpl already; it is an + implementation of the xml_schema::string_pskel parser + skeleton for built-in XML Schema type string.

+ +

This is another common theme in the C++/Parser programming model: + reusing implementations of the base parsers in the derived ones with + the C++ mixin idiom. In our case, string_pimpl will + do all the dirty work of extracting the data and we can just get + it at the end with the call to post_string().

+ +

In case you are curious, here is what + xml_schema::string_pskel and + xml_schema::string_pimpl look like:

+ + 
+namespace xml_schema
+{
+  class string_pskel: public simple_content
+  {
+  public:
+    virtual std::string
+    post_string () = 0;
+  };
+
+  class string_pimpl: public virtual string_pskel
+  {
+  public:
+    virtual void
+    _pre ();
+
+    virtual void
+    _characters (const xml_schema::ro_string&);
+
+    virtual std::string
+    post_string ();
+
+  protected:
+    std::string str_;
+  };
+}
+
+ +

There are three new pieces in this code that we haven't seen yet. + They are the simple_content class as well as + the _pre() and _characters() functions. + The simple_content class is defined in the XSD + runtime and is a base class for all parser skeletons that conform + to the simple content model in XML Schema. Types with the + simple content model cannot have nested elements—only text + and attributes. There is also the complex_content + class which corresponds to the complex content mode (types with + nested elements, for example, person from + people.xsd).

+ +

The _pre() function is a parser callback. Remember we + talked about the pre() and post_*() callbacks + in the previous chapter? There are actually two more callbacks + with similar roles: _pre() and _post (). + As a result, each parser skeleton has four special callbacks:

+ + 
+  virtual void
+  pre ();
+
+  virtual void
+  _pre ();
+
+  virtual void
+  _post ();
+
+  virtual void
+  post_name ();
+
+ +

pre() and _pre() are initialization + callbacks. They get called in that order before a new instance of the type + is about to be parsed. The difference between pre() and + _pre() is conventional: pre() can + be completely overridden by a derived parser. The derived + parser can also override _pre() but has to always call + the original version. This allows you to partition initialization + into customizable and required parts.

+ +

Similarly, _post() and post_name() are + finalization callbacks with exactly the same semantics: + post_name() can be completely overridden by the derived + parser while the original _post() should always be called. +

+ +

The final bit we need to discuss in this section is the + _characters() function. As you might have guessed, it + is also a callback. A low-level one that delivers raw character content + for the type being parsed. You will seldom need to use this callback + directly. Using implementations for the built-in parsers provided by + the XSD runtime is usually a simpler and more convenient + alternative.

+ +

At this point you might be wondering why some post_*() + callbacks, for example post_string(), return some data + while others, for example post_gender(), have + void as a return type. This is a valid concern + and it will be addressed in the next chapter.

+ +

3.2 Implementing the Person Parser

+ +

The generated person_pskel parser skeleton looks like + this:

+ + 
+class person_pskel: public xml_schema::complex_content
+{
+public:
+  // Parser callbacks. Override them in your implementation.
+  //
+  virtual void
+  pre ();
+
+  virtual void
+  first_name (const std::string&);
+
+  virtual void
+  last_name (const std::string&);
+
+  virtual void
+  gender ();
+
+  virtual void
+  age (short);
+
+  virtual void
+  post_person ();
+
+  // Parser construction API.
+  //
+  void
+  first_name_parser (xml_schema::string_pskel&);
+
+  void
+  last_name_parser (xml_schema::string_pskel&);
+
+  void
+  gender_parser (gender_pskel&);
+
+  void
+  age_parser (xml_schema::short_pskel&);
+
+  void
+  parsers (xml_schema::string_pskel& /* first-name */,
+           xml_schema::string_pskel& /* last-name */,
+           gender_pskel&             /* gender */,
+           xml_schema::short_pskel&  /* age */);
+};
+
+ + +

As you can see, we have a parser callback for each of the nested + elements found in the person XML Schema type. + The implementation of this parser is straightforward:

+ + 
+class person_pimpl: public person_pskel
+{
+public:
+  virtual void
+  first_name (const std::string& n)
+  {
+    cout << "first: " << f << endl;
+  }
+
+  virtual void
+  last_name (const std::string& l)
+  {
+    cout << "last: " << l << endl;
+  }
+
+  virtual void
+  age (short a)
+  {
+    cout << "age: " << a << endl;
+  }
+};
+
+ +

Notice that we didn't override the gender() callback + because all the printing is done by gender_pimpl.

+ + +

3.3 Implementing the People Parser

+ +

The generated people_pskel parser skeleton looks like + this:

+ + 
+class people_pskel: public xml_schema::complex_content
+{
+public:
+  // Parser callbacks. Override them in your implementation.
+  //
+  virtual void
+  pre ();
+
+  virtual void
+  person ();
+
+  virtual void
+  post_people ();
+
+  // Parser construction API.
+  //
+  void
+  person_parser (person_pskel&);
+
+  void
+  parsers (person_pskel& /* person */);
+};
+
+ +

The person() callback will be called after parsing each + person element. While person_pimpl does + all the printing, one useful thing we can do in this callback is to + print an extra newline after each person record so that our + output is more readable:

+ + 
+class people_pimpl: public people_pskel
+{
+public:
+  virtual void
+  person ()
+  {
+    cout << endl;
+  }
+};
+
+ +

Now it is time to put everything together.

+ + +

3.4 Connecting the Parsers Together

+ +

At this point we have all the individual parsers implemented + and can proceed to assemble them into a complete parser + for our XML vocabulary. The first step is to instantiate + all the individual parsers that we will need:

+ + 
+xml_schema::short_pimpl short_p;
+xml_schema::string_pimpl string_p;
+
+gender_pimpl gender_p;
+person_pimpl person_p;
+people_pimpl people_p;
+
+ +

Notice that our schema uses two built-in XML Schema types: + string for the first-name and + last-name elements as well as short + for age. We will use predefined parsers that + come with the XSD runtime to handle these types. The next + step is to connect all the individual parsers. We do this + with the help of functions defined in the parser + skeletons and marked with the "Parser Construction API" + comment. One way to do it is to connect each individual + parser by calling the *_parser() functions:

+ + 
+person_p.first_name_parser (string_p);
+person_p.last_name_parser (string_p);
+person_p.gender_parser (gender_p);
+person_p.age_parser (short_p);
+
+people_p.person_parser (person_p);
+
+ +

You might be wondering what happens if you do not provide + a parser by not calling one of the *_parser() functions. + In that case the corresponding XML content will be skipped, + including validation. This is an efficient way to ignore parts + of the document that you are not interested in.

+ + +

An alternative, shorter, way to connect the parsers is by using + the parsers() functions which connects all the parsers + for a given type at once:

+ + 
+person_p.parsers (string_p, string_p, gender_p, short_p);
+people_p.parsers (person_p);
+
+ +

The following figure illustrates the resulting connections. Notice + the correspondence between return types of the post_*() + functions and argument types of element callbacks that are connected + by the arrows.

+ + +
+ +

The last step is the construction of the document parser and + invocation of the complete parser on our sample XML instance:

+ + 
+xml_schema::document doc_p (people_p, "people");
+
+people_p.pre ();
+doc_p.parse ("people.xml");
+people_p.post_people ();
+
+ +

Let's consider xml_schema::document in + more detail. While the exact definition of this class + varies depending on the underlying parser selected, + here is the common part:

+ + 
+namespace xml_schema
+{
+  class document
+  {
+  public:
+    document (xml_schema::parser_base&,
+              const std::string& root_element_name,
+              bool polymorphic = false);
+
+    document (xml_schema::parser_base&,
+              const std::string& root_element_namespace,
+              const std::string& root_element_name,
+              bool polymorphic = false);
+
+    void
+    parse (const std::string& file);
+
+    void
+    parse (std::istream&);
+
+    ...
+
+  };
+}
+
+ +

xml_schema::document is a root parser for + the vocabulary. The first argument to its constructors is the + parser for the type of the root element (people_impl + in our case). Because a type parser is only concerned with + the element's content and not with the element's name, we need + to specify the root element's name somewhere. That's + what is passed as the second and third arguments to the + document's constructors.

+ +

There are also two overloaded parse() functions + defined in the document class (there are actually + more but the others are specific to the underlying XML parser). + The first version parses a local file identified by a name. The + second version reads the data from an input stream. For more + information on the xml_schema::document class + refer to Chapter 7, "Document Parser and Error + Handling".

+ +

Let's now consider a step-by-step list of actions that happen + as we parse through people.xml. The content of + people.xml is repeated below for convenience.

+ + 
+<?xml version="1.0"?>
+<people>
+  <person>
+    <first-name>John</first-name>
+    <last-name>Doe</last-name>
+    <gender>male</gender>
+    <age>32</age>
+  </person>
+  <person>
+    <first-name>Jane</first-name>
+    <last-name>Doe</last-name>
+    <gender>female</gender>
+    <age>28</age>
+  </person>
+</people>
+
+ + +
    +
  1. people_p.pre() is called from + main(). We did not provide any implementation + for this callback so this call is a no-op.
    2. + +
  2. doc_p.parse("people.xml") is called from + main(). The parser opens the file and starts + parsing its content.
    3. + +
  3. The parser encounters the root element. doc_p + verifies that the root element is correct and calls + _pre() on people_p which is also + a no-op. Parsing is now delegated to people_p.
    4. + +
  4. The parser encounters the person element. + people_p determines that person_p + is responsible for parsing this element. pre() + and _pre() callbacks are called on person_p. + Parsing is now delegated to person_p.
    5. + +
  5. The parser encounters the first-name element. + person_p determines that string_p + is responsible for parsing this element. pre() + and _pre() callbacks are called on string_p. + Parsing is now delegated to string_p.
    6. + +
  6. The parser encounters character content consisting of + "John". The _characters() callback is + called on string_p.
    7. + +
  7. The parser encounters the end of first-name + element. The _post() and post_string() + callbacks are called on string_p. The + first_name() callback is called on person_p + with the return value of post_string(). The + first_name() implementation prints + "first: John" to cout. + Parsing is now returned to person_p.
    8. + +
  8. Steps analogous to 5-7 are performed for the last-name, + gender, and age elements.
    9. + +
  9. The parser encounters the end of person + element. The _post() and post_person() + callbacks are called on person_p. The + person() callback is called on people_p. + The person() implementation prints a new line + to cout. Parsing is now returned to + people_p.
    10. + +
  10. Steps 4-9 are performed for the second person + element.
    11. + +
  11. The parser encounters the end of people + element. The _post() callback is called on + people_p. The doc_p.parse("people.xml") + call returns to main().
    12. + +
  12. people_p.post_people() is called from + main() which is a no-op.
    13. + +
+ + + + + +

4 Type Maps

+ +

There are many useful things you can do inside parser callbacks as they + are right now. There are, however, times when you want to propagate + some information from one parser to another or to the caller of the + parser. One common task that would greatly benefit from such a + possibility is building a tree-like in-memory object model of the + data stored in XML. During execution, each individual sub-parser + would create a sub-tree and return it to its parent parser + which can then incorporate this sub-tree into the whole tree.

+ +

In this chapter we will discuss the mechanisms offered by the + C++/Parser mapping for returning information from individual + parsers and see how to use them to build an object model + of our people vocabulary.

+ +

4.1 Object Model

+ +

An object model for our person record example could + look like this (saved in the people.hxx file):

+ + 
+#include <string>
+#include <vector>
+
+enum gender
+{
+  male,
+  female
+};
+
+class person
+{
+public:
+  person (const std::string& first,
+          const std::string& last,
+          ::gender gender,
+          short age)
+    : first_ (first), last_ (last),
+      gender_ (gender), age_ (age)
+  {
+  }
+
+  const std::string&
+  first () const
+  {
+    return first_;
+  }
+
+  const std::string&
+  last () const
+  {
+    return last_;
+  }
+
+  ::gender
+  gender () const
+  {
+    return gender_;
+  }
+
+  short
+  age () const
+  {
+    return age_;
+  }
+
+private:
+  std::string first_;
+  std::string last_;
+  ::gender gender_;
+  short age_;
+};
+
+typedef std::vector<person> people;
+
+ +

While it is clear which parser is responsible for which part of + the object model, it is not exactly clear how, for + example, gender_pimpl will deliver gender + to person_pimpl. You might have noticed that + string_pimpl manages to deliver its value to the + first_name() callback of person_pimpl. Let's + see how we can utilize the same mechanism to propagate our + own data.

+ +

There is a way to tell the XSD compiler that you want to + exchange data between parsers. More precisely, for each + type defined in XML Schema, you can tell the compiler two things. + First, the return type of the post_*() callback + in the parser skeleton generated for this type. And, second, + the argument type for callbacks corresponding to elements and + attributes of this type. For example, for XML Schema type + gender we can specify the return type for + post_gender() in the gender_pskel + skeleton and the argument type for the gender() callback + in the person_pskel skeleton. As you might have guessed, + the generated code will then pass the return value from the + post_*() callback as an argument to the element or + attribute callback.

+ +

The way to tell the XSD compiler about these XML Schema to + C++ mappings is with type map files. Here is a simple type + map for the gender type from the previous paragraph:

+ + 
+include "people.hxx";
+gender ::gender ::gender;
+
+ +

The first line indicates that the generated code must include + people.hxx in order to get the definition for the + gender type. The second line specifies that both + argument and return types for the gender + XML Schema type should be the ::gender C++ enum + (we use fully-qualified C++ names to avoid name clashes). + The next section will describe the type map format in detail. + We save this type map in people.map and + then translate our schemas with the --type-map + option to let the XSD compiler know about our type map:

+ + 
+$ xsd cxx-parser --type-map people.map people.xsd
+
+ +

If we now look at the generated people-pskel.hxx, + we will see the following changes in the gender_pskel and + person_pskel skeletons:

+ + 
+#include "people.hxx"
+
+class gender_pskel: public virtual xml_schema::string_pskel
+{
+  virtual ::gender
+  post_gender () = 0;
+
+  ...
+};
+
+class person_pskel: public xml_schema::complex_content
+{
+  virtual void
+  gender (::gender);
+
+  ...
+};
+
+ +

Notice that #include "people.hxx" was added to + the generated header file from the type map to provide the + definition for the gender enum.

+ +

4.2 Type Map File Format

+ +

Type map files are used to define a mapping between XML Schema + and C++ types. The compiler uses this information + to determine return types of post_*() + callbacks in parser skeletons corresponding to XML Schema + types as well as argument types for callbacks corresponding + to elements and attributes of these types.

+ +

The compiler has a set of predefined mapping rules that map + the built-in XML Schema types to suitable C++ types (discussed + below) and all other types to void. + By providing your own type maps you can override these predefined + rules. The format of the type map file is presented below: +

+ + 
+namespace <schema-namespace> [<cxx-namespace>]
+{
+  (include <file-name>;)*
+  ([type] <schema-type> <cxx-ret-type> [<cxx-arg-type>];)*
+}
+
+ +

Both <schema-namespace> and + <schema-type> are regex patterns while + <cxx-namespace>, + <cxx-ret-type>, and + <cxx-arg-type> are regex pattern + substitutions. All names can be optionally enclosed in + " ", for example, to include white-spaces.

+ +

<schema-namespace> determines XML + Schema namespace. Optional <cxx-namespace> + is prefixed to every C++ type name in this namespace declaration. + <cxx-ret-type> is a C++ type name that is + used as a return type for the post_*() callback. + Optional <cxx-arg-type> is an argument + type for callbacks corresponding to elements and attributes + of this type. If <cxx-arg-type> is not + specified, it defaults to <cxx-ret-type> + if <cxx-ret-type> ends with * or + & (that is, it is a pointer or a reference) and + const <cxx-ret-type>& + otherwise. + <file-name> is a file name either in the + " " or < > format + and is added with the #include directive to + the generated code.

+ +

The # character starts a comment that ends + with a new line or end of file. To specify a name that contains + # enclose it in " ". + For example:

+ + 
+namespace http://www.example.com/xmlns/my my
+{
+  include "my.hxx";
+
+  # Pass apples by value.
+  #
+  apple apple;
+
+  # Pass oranges as pointers.
+  #
+  orange orange_t*;
+}
+
+ +

In the example above, for the + http://www.example.com/xmlns/my#orange + XML Schema type, the my::orange_t* C++ type will + be used as both return and argument types.

+ +

Several namespace declarations can be specified in a single + file. The namespace declaration can also be completely + omitted to map types in a schema without a namespace. For + instance:

+ + 
+include "my.hxx";
+apple apple;
+
+namespace http://www.example.com/xmlns/my
+{
+  orange "const orange_t*";
+}
+
+ +

The compiler has a number of predefined mapping rules for + the built-in XML Schema types which can be presented as the + following map files. The string-based XML Schema types are + mapped to either std::string or + std::wstring depending on the character type + selected (see Section 5.2, "Character Type and + Encoding" for more information). The binary XML Schema + types are mapped to either std::unique_ptr<xml_schema::buffer> + or std::auto_ptr<xml_schema::buffer> + depending on the C++ standard selected (C++11 or C++98, + respectively; refer to the --std XSD compiler + command line option for details).

+ + 
+namespace http://www.w3.org/2001/XMLSchema
+{
+  boolean bool bool;
+
+  byte "signed char" "signed char";
+  unsignedByte "unsigned char" "unsigned char";
+
+  short short short;
+  unsignedShort "unsigned short" "unsigned short";
+
+  int int int;
+  unsignedInt "unsigned int" "unsigned int";
+
+  long "long long" "long long";
+  unsignedLong "unsigned long long" "unsigned long long";
+
+  integer "long long" "long long";
+
+  negativeInteger "long long" "long long";
+  nonPositiveInteger "long long" "long long";
+
+  positiveInteger "unsigned long long" "unsigned long long";
+  nonNegativeInteger "unsigned long long" "unsigned long long";
+
+  float float float;
+  double double double;
+  decimal double double;
+
+  string std::string;
+  normalizedString std::string;
+  token std::string;
+  Name std::string;
+  NMTOKEN std::string;
+  NCName std::string;
+  ID std::string;
+  IDREF std::string;
+  language std::string;
+  anyURI std::string;
+
+  NMTOKENS xml_schema::string_sequence;
+  IDREFS xml_schema::string_sequence;
+
+  QName xml_schema::qname;
+
+  base64Binary std::[unique|auto]_ptr<xml_schema::buffer>
+               std::[unique|auto]_ptr<xml_schema::buffer>;
+  hexBinary std::[unique|auto]_ptr<xml_schema::buffer>
+            std::[unique|auto]_ptr<xml_schema::buffer>;
+
+  date xml_schema::date;
+  dateTime xml_schema::date_time;
+  duration xml_schema::duration;
+  gDay xml_schema::gday;
+  gMonth xml_schema::gmonth;
+  gMonthDay xml_schema::gmonth_day;
+  gYear xml_schema::gyear;
+  gYearMonth xml_schema::gyear_month;
+  time xml_schema::time;
+}
+
+ +

For more information about the mapping of the built-in XML Schema types + to C++ types refer to Chapter 6, "Built-In XML Schema Type + Parsers". The last predefined rule maps anything that wasn't + mapped by previous rules to void:

+ + 
+namespace .*
+{
+  .* void void;
+}
+
+ + +

When you provide your own type maps with the + --type-map option, they are evaluated first. This + allows you to selectively override any of the predefined rules. + Note also that if you change the mapping + of a built-in XML Schema type then it becomes your responsibility + to provide the corresponding parser skeleton and implementation + in the xml_schema namespace. You can include the + custom definitions into the generated header file using the + --hxx-prologue-* options.

+ +

4.3 Parser Implementations

+ +

With the knowledge from the previous section, we can proceed + with creating a type map that maps types in the people.xsd + schema to our object model classes in + people.hxx. In fact, we already have the beginning + of our type map file in people.map. Let's extend + it with the rest of the types:

+ + 
+include "people.hxx";
+
+gender ::gender ::gender;
+person ::person;
+people ::people;
+
+ +

There are a few things to note about this type map. We did not + provide the argument types for person and + people because the default constant reference is + exactly what we need. We also did not provide any mappings + for built-in XML Schema types string and + short because they are handled by the predefined + rules and we are happy with the result. Note also that + all C++ types are fully qualified. This is done to avoid + potential name conflicts in the generated code. Now we can + recompile our schema and move on to implementing the parsers:

+ + 
+$ xsd cxx-parser --xml-parser expat --type-map people.map people.xsd
+
+ +

Here is the implementation of our three parsers in full. One + way to save typing when implementing your own parsers is + to open the generated code and copy the signatures of parser + callbacks into your code. Or you could always auto generate the + sample implementations and fill them with your code.

+ + + 
+#include "people-pskel.hxx"
+
+class gender_pimpl: public gender_pskel,
+                    public xml_schema::string_pimpl
+{
+public:
+  virtual ::gender
+  post_gender ()
+  {
+    return post_string () == "male" ? male : female;
+  }
+};
+
+class person_pimpl: public person_pskel
+{
+public:
+  virtual void
+  first_name (const std::string& f)
+  {
+    first_ = f;
+  }
+
+  virtual void
+  last_name (const std::string& l)
+  {
+    last_ = l;
+  }
+
+  virtual void
+  gender (::gender g)
+  {
+    gender_ = g;
+  }
+
+  virtual void
+  age (short a)
+  {
+    age_ = a;
+  }
+
+  virtual ::person
+  post_person ()
+  {
+    return ::person (first_, last_, gender_, age_);
+  }
+
+private:
+  std::string first_;
+  std::string last_;
+  ::gender gender_;
+  short age_;
+};
+
+class people_pimpl: public people_pskel
+{
+public:
+  virtual void
+  person (const ::person& p)
+  {
+    people_.push_back (p);
+  }
+
+  virtual ::people
+  post_people ()
+  {
+    ::people r;
+    r.swap (people_);
+    return r;
+  }
+
+private:
+  ::people people_;
+};
+
+ +

This code fragment should look familiar by now. Just note that + all the post_*() callbacks now have return types instead + of void. Here is the implementation of the test + driver for this example:

+ + 
+#include <iostream>
+
+using namespace std;
+
+int
+main (int argc, char* argv[])
+{
+  // Construct the parser.
+  //
+  xml_schema::short_pimpl short_p;
+  xml_schema::string_pimpl string_p;
+
+  gender_pimpl gender_p;
+  person_pimpl person_p;
+  people_pimpl people_p;
+
+  person_p.parsers (string_p, string_p, gender_p, short_p);
+  people_p.parsers (person_p);
+
+  // Parse the document to obtain the object model.
+  //
+  xml_schema::document doc_p (people_p, "people");
+
+  people_p.pre ();
+  doc_p.parse (argv[1]);
+  people ppl = people_p.post_people ();
+
+  // Print the object model.
+  //
+  for (people::iterator i (ppl.begin ()); i != ppl.end (); ++i)
+  {
+    cout << "first:  " << i->first () << endl
+         << "last:   " << i->last () << endl
+         << "gender: " << (i->gender () == male ? "male" : "female") << endl
+         << "age:    " << i->age () << endl
+         << endl;
+  }
+}
+
+ +

The parser creation and assembly part is exactly the same as in + the previous chapter. The parsing part is a bit different: + post_people() now has a return value which is the + complete object model. We store it in the + ppl variable. The last bit of the code simply iterates + over the people vector and prints the information + for each person. We save the last two code fragments to + driver.cxx and proceed to compile and test + our new application:

+ + + 
+$ c++ -std=c++11 -I.../libxsd -c driver.cxx people-pskel.cxx
+$ c++ -std=c++11 -o driver driver.o people-pskel.o -lexpat
+$ ./driver people.xml
+first:  John
+last:   Doe
+gender: male
+age:    32
+
+first:  Jane
+last:   Doe
+gender: female
+age:    28
+
+ + + + + +

5 Mapping Configuration

+ +

The C++/Parser mapping has a number of configuration parameters that + determine the overall properties and behavior of the generated code. + Configuration parameters are specified with the XSD command line + options and include the C++ standard, the character type that is used + by the generated code, the underlying XML parser, whether the XML Schema + validation is performed in the generated code, and support for XML Schema + polymorphism. This chapter describes these configuration + parameters in more detail. For more ways to configure the generated + code refer to the + XSD + Compiler Command Line Manual. +

+ +

5.1 C++ Standard

+ +

The C++/Parser mapping provides support for ISO/IEC C++ 2011 (C++11) + and ISO/IEC C++ 1998/2003 (C++98). To select the C++ standard for the + generated code we use the --std XSD compiler command + line option. While the majority of the examples in this guide use + C++11, the document explains the C++11/98 usage difference and so + they can easily be converted to C++98.

+ +

5.2 Character Type and Encoding

+ +

The C++/Parser mapping has built-in support for two character types: + char and wchar_t. You can select the + character type with the --char-type command line + option. The default character type is char. The + string-based built-in XML Schema types are returned as either + std::string or std::wstring depending + on the character type selected.

+ +

Another aspect of the mapping that depends on the character type + is character encoding. For the char character type + the default encoding is UTF-8. Other supported encodings are + ISO-8859-1, Xerces-C++ Local Code Page (LPC), as well as + custom encodings. You can select which encoding should be used + in the object model with the --char-encoding command + line option.

+ +

For the wchar_t character type the encoding is + automatically selected between UTF-16 and UTF-32/UCS-4 depending + on the size of the wchar_t type. On some platforms + (for example, Windows with Visual C++ and AIX with IBM XL C++) + wchar_t is 2 bytes long. For these platforms the + encoding is UTF-16. On other platforms wchar_t is 4 bytes + long and UTF-32/UCS-4 is used.

+ +

Note also that the character encoding that is used in the object model + is independent of the encodings used in input and output XML. In fact, + all three (object mode, input XML, and output XML) can have different + encodings.

+ +

5.3 Underlying XML Parser

+ +

The C++/Parser mapping can be used with either Xerces-C++ or Expat + as the underlying XML parser. You can select the XML parser with + the --xml-parser command line option. Valid values + for this option are xerces and expat. + The default XML parser is Xerces-C++.

+ +

The generated code is identical for both parsers except for the + xml_schema::document class in which some of the + parse() functions are parser-specific as described + in Chapter 7, "Document Parser and Error Handling".

+ + +

5.4 XML Schema Validation

+ +

The C++/Parser mapping provides support for validating a + commonly-used subset of W3C XML Schema in the generated code. + For the list of supported XML Schema constructs refer to + Appendix A, "Supported XML Schema Constructs".

+ +

By default validation in the generated code is disabled if + the underlying XML parser is validating (Xerces-C++) and + enabled otherwise (Expat). See Section 5.3, + "Underlying XML Parser" for more information about + the underlying XML parser. You can override the default + behavior with the --generate-validation + and --suppress-validation command line options.

+ + +

5.5 Support for Polymorphism

+ +

By default the XSD compiler generates non-polymorphic code. If your + vocabulary uses XML Schema polymorphism in the form of xsi:type + and/or substitution groups, then you will need to compile your schemas + with the --generate-polymorphic option to produce + polymorphism-aware code as well as pass true as the last + argument to the xml_schema::document's constructors.

+ +

When using the polymorphism-aware generated code, you can specify + several parsers for a single element by passing a parser map + instead of an individual parser to the parser connection function + for the element. One of the parsers will then be looked up and used + depending on the xsi:type attribute value or an element + name from a substitution group. Consider the following schema as an + example:

+ + 
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+
+  <xs:complexType name="person">
+    <xs:sequence>
+      <xs:element name="name" type="xs:string"/>
+    </xs:sequence>
+  </xs:complexType>
+
+  <!-- substitution group root -->
+  <xs:element name="person" type="person"/>
+
+  <xs:complexType name="superman">
+    <xs:complexContent>
+      <xs:extension base="person">
+        <xs:attribute name="can-fly" type="xs:boolean"/>
+      </xs:extension>
+    </xs:complexContent>
+  </xs:complexType>
+
+  <xs:element name="superman"
+              type="superman"
+              substitutionGroup="person"/>
+
+  <xs:complexType name="batman">
+    <xs:complexContent>
+      <xs:extension base="superman">
+        <xs:attribute name="wing-span" type="xs:unsignedInt"/>
+      </xs:extension>
+    </xs:complexContent>
+  </xs:complexType>
+
+  <xs:element name="batman"
+              type="batman"
+              substitutionGroup="superman"/>
+
+  <xs:complexType name="supermen">
+    <xs:sequence>
+      <xs:element ref="person" maxOccurs="unbounded"/>
+    </xs:sequence>
+  </xs:complexType>
+
+  <xs:element name="supermen" type="supermen"/>
+
+</xs:schema>
+
+ +

Conforming XML documents can use the superman + and batman types in place of the person + type either by specifying the type with the xsi:type + attributes or by using the elements from the substitution + group, for instance:

+ + + 
+<supermen xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+
+  <person>
+    <name>John Doe</name>
+  </person>
+
+  <superman can-fly="false">
+    <name>James "007" Bond</name>
+  </superman>
+
+  <superman can-fly="true" wing-span="10" xsi:type="batman">
+    <name>Bruce Wayne</name>
+  </superman>
+
+</supermen>
+
+ +

To print the data stored in such XML documents we can implement + the parsers as follows:

+ + 
+class person_pimpl: public virtual person_pskel
+{
+public:
+  virtual void
+  pre ()
+  {
+    cout << "starting to parse person" << endl;
+  }
+
+  virtual void
+  name (const std::string& v)
+  {
+    cout << "name: " << v << endl;
+  }
+
+  virtual void
+  post_person ()
+  {
+    cout << "finished parsing person" << endl;
+  }
+};
+
+class superman_pimpl: public virtual superman_pskel,
+                      public person_pimpl
+{
+public:
+  virtual void
+  pre ()
+  {
+    cout << "starting to parse superman" << endl;
+  }
+
+  virtual void
+  can_fly (bool v)
+  {
+    cout << "can-fly: " << v << endl;
+  }
+
+  virtual void
+  post_person ()
+  {
+    post_superman ();
+  }
+
+  virtual void
+  post_superman ()
+  {
+    cout << "finished parsing superman" << endl
+  }
+};
+
+class batman_pimpl: public virtual batman_pskel,
+                    public superman_pimpl
+{
+public:
+  virtual void
+  pre ()
+  {
+    cout << "starting to parse batman" << endl;
+  }
+
+  virtual void
+  wing_span (unsigned int v)
+  {
+    cout << "wing-span: " << v << endl;
+  }
+
+  virtual void
+  post_superman ()
+  {
+    post_batman ();
+  }
+
+  virtual void
+  post_batman ()
+  {
+    cout << "finished parsing batman" << endl;
+  }
+};
+
+ +

Note that because the derived type parsers (superman_pskel + and batman_pskel) are called via the person_pskel + interface, we have to override the post_person() + virtual function in superman_pimpl to call + post_superman() and the post_superman() + virtual function in batman_pimpl to call + post_batman().

+ +

The following code fragment shows how to connect the parsers together. + Notice that for the person element in the supermen_p + parser we specify a parser map instead of a specific parser and we pass + true as the last argument to the document parser constructor + to indicate that we are parsing potentially-polymorphic XML documents:

+ + 
+int
+main (int argc, char* argv[])
+{
+  // Construct the parser.
+  //
+  xml_schema::string_pimpl string_p;
+  xml_schema::boolean_pimpl boolean_p;
+  xml_schema::unsigned_int_pimpl unsigned_int_p;
+
+  person_pimpl person_p;
+  superman_pimpl superman_p;
+  batman_pimpl batman_p;
+
+  xml_schema::parser_map_impl person_map;
+  supermen_pimpl supermen_p;
+
+  person_p.parsers (string_p);
+  superman_p.parsers (string_p, boolean_p);
+  batman_p.parsers (string_p, boolean_p, unsigned_int_p);
+
+  // Here we are specifying a parser map which containes several
+  // parsers that can be used to parse the person element.
+  //
+  person_map.insert (person_p);
+  person_map.insert (superman_p);
+  person_map.insert (batman_p);
+
+  supermen_p.person_parser (person_map);
+
+  // Parse the XML document. The last argument to the document's
+  // constructor indicates that we are parsing polymorphic XML
+  // documents.
+  //
+  xml_schema::document doc_p (supermen_p, "supermen", true);
+
+  supermen_p.pre ();
+  doc_p.parse (argv[1]);
+  supermen_p.post_supermen ();
+}
+
+ +

When polymorphism-aware code is generated, each element's + *_parser() function is overloaded to also accept + an object of the xml_schema::parser_map type. + For example, the supermen_pskel class from the + above example looks like this:

+ + 
+class supermen_pskel: public xml_schema::parser_complex_content
+{
+public:
+
+  ...
+
+  // Parser construction API.
+  //
+  void
+  parsers (person_pskel&);
+
+  // Individual element parsers.
+  //
+  void
+  person_parser (person_pskel&);
+
+  void
+  person_parser (const xml_schema::parser_map&);
+
+  ...
+};
+
+ +

Note that you can specify both the individual (static) parser and + the parser map. The individual parser will be used when the static + element type and the dynamic type of the object being parsed are + the same. This is the case, for example, when there is no + xsi:type attribute and the element hasn't been + substituted. Because the individual parser for an element is + cached and no map lookup is necessary, it makes sense to specify + both the individual parser and the parser map when most of the + objects being parsed are of the static type and optimal + performance is important. The following code fragment shows + how to change the above example to set both the individual + parser and the parser map:

+ + 
+int
+main (int argc, char* argv[])
+{
+  ...
+
+  person_map.insert (superman_p);
+  person_map.insert (batman_p);
+
+  supermen_p.person_parser (person_p);
+  supermen_p.person_parser (person_map);
+
+  ...
+}
+
+ + +

The xml_schema::parser_map interface and the + xml_schema::parser_map_impl default implementation + are presented below:

+ + 
+namespace xml_schema
+{
+  class parser_map
+  {
+  public:
+    virtual parser_base*
+    find (const ro_string* type) const = 0;
+  };
+
+  class parser_map_impl: public parser_map
+  {
+  public:
+    void
+    insert (parser_base&);
+
+    virtual parser_base*
+    find (const ro_string* type) const;
+
+  private:
+    parser_map_impl (const parser_map_impl&);
+
+    parser_map_impl&
+    operator= (const parser_map_impl&);
+
+    ...
+  };
+}
+
+ +

The type argument in the find() virtual + function is the type name and namespace from the xsi:type attribute + (the namespace prefix is resolved to the actual XML namespace) + or the type of an element from the substitution group in the form + "<name> <namespace>" with the space and the + namespace part absent if the type does not have a namespace. + You can obtain a parser's dynamic type in the same format + using the _dynamic_type() function. The static + type can be obtained by calling the static _static_type() + function, for example person_pskel::_static_type(). + Both functions return a C string (const char* or + const wchar_t*, depending on the character type + used) which is valid for as long as the application is running. + The following example shows how we can implement our own parser + map using std::map:

+ + + 
+#include <map>
+#include <string>
+
+class parser_map: public xml_schema::parser_map
+{
+public:
+ void
+ insert (xml_schema::parser_base& p)
+ {
+   map_[p._dynamic_type ()] = &p;
+ }
+
+ virtual xml_schema::parser_base*
+ find (const xml_schema::ro_string* type) const
+ {
+   map::const_iterator i = map_.find (type);
+   return i != map_.end () ? i->second : 0;
+ }
+
+private:
+  typedef std::map<std::string, xml_schema::parser_base*> map;
+  map map_;
+};
+
+ +

Most of code presented in this section is taken from the + polymorphism example which can be found in the + cxx/parser/ directory in the + xsd-examples package. + Handling of xsi:type and substitution groups when used on + root elements requires a number of special actions as shown in + the polyroot example.

+ + + + + +

6 Built-In XML Schema Type Parsers

+ +

The XSD runtime provides parser implementations for all built-in + XML Schema types as summarized in the following table. Declarations + for these types are automatically included into each generated + header file. As a result you don't need to include any headers + to gain access to these parser implementations. Note that some + parsers return either std::string or + std::wstring depending on the character type selected.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
XML Schema typeParser implementation in the xml_schema namespaceParser return type
anyType and anySimpleType types
anyTypeany_type_pimplvoid
anySimpleTypeany_simple_type_pimplvoid
fixed-length integral types
bytebyte_pimplsigned char
unsignedByteunsigned_byte_pimplunsigned char
shortshort_pimplshort
unsignedShortunsigned_short_pimplunsigned short
intint_pimplint
unsignedIntunsigned_int_pimplunsigned int
longlong_pimpllong long
unsignedLongunsigned_long_pimplunsigned long long
arbitrary-length integral types
integerinteger_pimpllong long
nonPositiveIntegernon_positive_integer_pimpllong long
nonNegativeIntegernon_negative_integer_pimplunsigned long long
positiveIntegerpositive_integer_pimplunsigned long long
negativeIntegernegative_integer_pimpllong long
boolean types
booleanboolean_pimplbool
fixed-precision floating-point types
floatfloat_pimplfloat
doubledouble_pimpldouble
arbitrary-precision floating-point types
decimaldecimal_pimpldouble
string-based types
stringstring_pimplstd::string or std::wstring
normalizedStringnormalized_string_pimplstd::string or std::wstring
tokentoken_pimplstd::string or std::wstring
Namename_pimplstd::string or std::wstring
NMTOKENnmtoken_pimplstd::string or std::wstring
NCNamencname_pimplstd::string or std::wstring
languagelanguage_pimplstd::string or std::wstring
qualified name
QNameqname_pimplxml_schema::qname
Section 6.1, + "QName Parser"
ID/IDREF types
IDid_pimplstd::string or std::wstring
IDREFidref_pimplstd::string or std::wstring
list types
NMTOKENSnmtokens_pimplxml_schema::string_sequence
Section + 6.2, "NMTOKENS and IDREFS Parsers"
IDREFSidrefs_pimplxml_schema::string_sequence
Section + 6.2, "NMTOKENS and IDREFS Parsers"
URI types
anyURIuri_pimplstd::string or std::wstring
binary types
base64Binarybase64_binary_pimplstd::[unique|auto]_ptr< xml_schema::buffer>
+ Section 6.3, "base64Binary and + hexBinary Parsers"
hexBinaryhex_binary_pimplstd::[unique|auto]_ptr< xml_schema::buffer>
+ Section 6.3, "base64Binary and + hexBinary Parsers"
date/time types
datedate_pimplxml_schema::date
Section 6.5, + "date Parser"
dateTimedate_time_pimplxml_schema::date_time
Section 6.6, + "dateTime Parser"
durationduration_pimplxml_schema::duration
Section 6.7, + "duration Parser"
gDaygday_pimplxml_schema::gday
Section 6.8, + "gDay Parser"
gMonthgmonth_pimplxml_schema::gmonth
Section 6.9, + "gMonth Parser"
gMonthDaygmonth_day_pimplxml_schema::gmonth_day
Section 6.10, + "gMonthDay Parser"
gYeargyear_pimplxml_schema::gyear
Section 6.11, + "gYear Parser"
gYearMonthgyear_month_pimplxml_schema::gyear_month
Section + 6.12, "gYearMonth Parser"
timetime_pimplxml_schema::time
Section 6.13, + "time Parser"
+ +

6.1 QName Parser

+ +

The return type of the qname_pimpl parser implementation + is xml_schema::qname which represents an XML qualified + name. Its interface is presented below. + Note that the std::string type in the interface becomes + std::wstring if the selected character type is + wchar_t.

+ + 
+namespace xml_schema
+{
+  class qname
+  {
+  public:
+    explicit
+    qname (const std::string& name);
+    qname (const std::string& prefix, const std::string& name);
+
+    const std::string&
+    prefix () const;
+
+    void
+    prefix (const std::string&);
+
+    const std::string&
+    name () const;
+
+    void
+    name (const std::string&);
+  };
+
+  bool
+  operator== (const qname&, const qname&);
+
+  bool
+  operator!= (const qname&, const qname&);
+}
+
+ + +

6.2 NMTOKENS and IDREFS Parsers

+ +

The return type of the nmtokens_pimpl and + idrefs_pimpl parser implementations is + xml_schema::string_sequence which represents a + sequence of strings. Its interface is presented below. + Note that the std::string type in the interface becomes + std::wstring if the selected character type is + wchar_t.

+ + 
+namespace xml_schema
+{
+  class string_sequence: public std::vector<std::string>
+  {
+  public:
+    string_sequence ();
+
+    explicit
+    string_sequence (std::vector<std::string>::size_type n,
+                     const std::string& x = std::string ());
+
+    template <typename I>
+    string_sequence (const I& begin, const I& end);
+  };
+
+  bool
+  operator== (const string_sequence&, const string_sequence&);
+
+  bool
+  operator!= (const string_sequence&, const string_sequence&);
+}
+
+ + +

6.3 base64Binary and hexBinary Parsers

+ +

The return type of the base64_binary_pimpl and + hex_binary_pimpl parser implementations is either + std::unique_ptr<xml_schema::buffer> (C++11) or + std::auto_ptr<xml_schema::buffer> (C++98), + depending on the C++ standard selected (--std XSD + compiler option). The xml_schema::buffer type + represents a binary buffer and its interface is presented below.

+ + 
+namespace xml_schema
+{
+  class buffer
+  {
+  public:
+    typedef std::size_t size_t;
+
+    class bounds {}; // Out of bounds exception.
+
+  public:
+    explicit
+    buffer (size_t size = 0);
+    buffer (size_t size, size_t capacity);
+    buffer (const void* data, size_t size);
+    buffer (const void* data, size_t size, size_t capacity);
+    buffer (void* data,
+            size_t size,
+            size_t capacity,
+            bool assume_ownership);
+
+  public:
+    buffer (const buffer&);
+
+    buffer&
+    operator= (const buffer&);
+
+    void
+    swap (buffer&);
+
+  public:
+    size_t
+    capacity () const;
+
+    bool
+    capacity (size_t);
+
+  public:
+    size_t
+    size () const;
+
+    bool
+    size (size_t);
+
+  public:
+    const char*
+    data () const;
+
+    char*
+    data ();
+
+    const char*
+    begin () const;
+
+    char*
+    begin ();
+
+    const char*
+    end () const;
+
+    char*
+    end ();
+  };
+
+  bool
+  operator== (const buffer&, const buffer&);
+
+  bool
+  operator!= (const buffer&, const buffer&);
+}
+
+ +

If the assume_ownership argument to the constructor + is true, the instance assumes the ownership of the + memory block pointed to by the data argument and will + eventually release it by calling operator delete(). The + capacity() and size() modifier functions + return true if the underlying buffer has moved. +

+ +

The bounds exception is thrown if the constructor + arguments violate the (size <= capacity) + constraint.

+ + +

6.4 Time Zone Representation

+ +

The date, dateTime, gDay, + gMonth, gMonthDay, gYear, + gYearMonth, and time XML Schema built-in + types all include an optional time zone component. The following + xml_schema::time_zone base class is used to represent + this information:

+ + 
+namespace xml_schema
+{
+  class time_zone
+  {
+  public:
+    time_zone ();
+    time_zone (short hours, short minutes);
+
+    bool
+    zone_present () const;
+
+    void
+    zone_reset ();
+
+    short
+    zone_hours () const;
+
+    void
+    zone_hours (short);
+
+    short
+    zone_minutes () const;
+
+    void
+    zone_minutes (short);
+  };
+
+  bool
+  operator== (const time_zone&, const time_zone&);
+
+  bool
+  operator!= (const time_zone&, const time_zone&);
+}
+
+ +

The zone_present() accessor function returns true + if the time zone is specified. The zone_reset() modifier + function resets the time zone object to the not specified + state. If the time zone offset is negative then both hours and + minutes components are represented as negative integers.

+ + +

6.5 date Parser

+ +

The return type of the date_pimpl parser implementation + is xml_schema::date which represents a year, a day, and a month + with an optional time zone. Its interface is presented below. + For more information on the base xml_schema::time_zone + class refer to Section 6.4, "Time Zone + Representation".

+ + 
+namespace xml_schema
+{
+  class date
+  {
+  public:
+    date (int year, unsigned short month, unsigned short day);
+    date (int year, unsigned short month, unsigned short day,
+          short zone_hours, short zone_minutes);
+
+    int
+    year () const;
+
+    void
+    year (int);
+
+    unsigned short
+    month () const;
+
+    void
+    month (unsigned short);
+
+    unsigned short
+    day () const;
+
+    void
+    day (unsigned short);
+  };
+
+  bool
+  operator== (const date&, const date&);
+
+  bool
+  operator!= (const date&, const date&);
+}
+
+ +

6.6 dateTime Parser

+ +

The return type of the date_time_pimpl parser implementation + is xml_schema::date_time which represents a year, a month, a day, + hours, minutes, and seconds with an optional time zone. Its interface + is presented below. + For more information on the base xml_schema::time_zone + class refer to Section 6.4, "Time Zone + Representation".

+ + 
+namespace xml_schema
+{
+  class date_time
+  {
+  public:
+    date_time (int year, unsigned short month, unsigned short day,
+               unsigned short hours, unsigned short minutes,
+               double seconds);
+
+    date_time (int year, unsigned short month, unsigned short day,
+               unsigned short hours, unsigned short minutes,
+               double seconds, short zone_hours, short zone_minutes);
+
+    int
+    year () const;
+
+    void
+    year (int);
+
+    unsigned short
+    month () const;
+
+    void
+    month (unsigned short);
+
+    unsigned short
+    day () const;
+
+    void
+    day (unsigned short);
+
+    unsigned short
+    hours () const;
+
+    void
+    hours (unsigned short);
+
+    unsigned short
+    minutes () const;
+
+    void
+    minutes (unsigned short);
+
+    double
+    seconds () const;
+
+    void
+    seconds (double);
+  };
+
+  bool
+  operator== (const date_time&, const date_time&);
+
+  bool
+  operator!= (const date_time&, const date_time&);
+}
+
+ +

6.7 duration Parser

+ +

The return type of the duration_pimpl parser implementation + is xml_schema::duration which represents a potentially + negative duration in the form of years, months, days, hours, minutes, + and seconds. Its interface is presented below.

+ + 
+namespace xml_schema
+{
+  class duration
+  {
+  public:
+    duration (bool negative,
+              unsigned int years, unsigned int months, unsigned int days,
+              unsigned int hours, unsigned int minutes, double seconds);
+
+    bool
+    negative () const;
+
+    void
+    negative (bool);
+
+    unsigned int
+    years () const;
+
+    void
+    years (unsigned int);
+
+    unsigned int
+    months () const;
+
+    void
+    months (unsigned int);
+
+    unsigned int
+    days () const;
+
+    void
+    days (unsigned int);
+
+    unsigned int
+    hours () const;
+
+    void
+    hours (unsigned int);
+
+    unsigned int
+    minutes () const;
+
+    void
+    minutes (unsigned int);
+
+    double
+    seconds () const;
+
+    void
+    seconds (double);
+  };
+
+  bool
+  operator== (const duration&, const duration&);
+
+  bool
+  operator!= (const duration&, const duration&);
+}
+
+ + +

6.8 gDay Parser

+ +

The return type of the gday_pimpl parser implementation + is xml_schema::gday which represents a day of the month with + an optional time zone. Its interface is presented below. + For more information on the base xml_schema::time_zone + class refer to Section 6.4, "Time Zone + Representation".

+ + 
+namespace xml_schema
+{
+  class gday
+  {
+  public:
+    explicit
+    gday (unsigned short day);
+    gday (unsigned short day, short zone_hours, short zone_minutes);
+
+    unsigned short
+    day () const;
+
+    void
+    day (unsigned short);
+  };
+
+  bool
+  operator== (const gday&, const gday&);
+
+  bool
+  operator!= (const gday&, const gday&);
+}
+
+ +

6.9 gMonth Parser

+ +

The return type of the gmonth_pimpl parser implementation + is xml_schema::gmonth which represents a month of the year + with an optional time zone. Its interface is presented below. + For more information on the base xml_schema::time_zone + class refer to Section 6.4, "Time Zone + Representation".

+ + 
+namespace xml_schema
+{
+  class gmonth
+  {
+  public:
+    explicit
+    gmonth (unsigned short month);
+    gmonth (unsigned short month, short zone_hours, short zone_minutes);
+
+    unsigned short
+    month () const;
+
+    void
+    month (unsigned short);
+  };
+
+  bool
+  operator== (const gmonth&, const gmonth&);
+
+  bool
+  operator!= (const gmonth&, const gmonth&);
+}
+
+ +

6.10 gMonthDay Parser

+ +

The return type of the gmonth_day_pimpl parser implementation + is xml_schema::gmonth_day which represents a day and a month + of the year with an optional time zone. Its interface is presented below. + For more information on the base xml_schema::time_zone + class refer to Section 6.4, "Time Zone + Representation".

+ + 
+namespace xml_schema
+{
+  class gmonth_day
+  {
+  public:
+    gmonth_day (unsigned short month, unsigned short day);
+    gmonth_day (unsigned short month, unsigned short day,
+                short zone_hours, short zone_minutes);
+
+    unsigned short
+    month () const;
+
+    void
+    month (unsigned short);
+
+    unsigned short
+    day () const;
+
+    void
+    day (unsigned short);
+  };
+
+  bool
+  operator== (const gmonth_day&, const gmonth_day&);
+
+  bool
+  operator!= (const gmonth_day&, const gmonth_day&);
+}
+
+ +

6.11 gYear Parser

+ +

The return type of the gyear_pimpl parser implementation + is xml_schema::gyear which represents a year with + an optional time zone. Its interface is presented below. + For more information on the base xml_schema::time_zone + class refer to Section 6.4, "Time Zone + Representation".

+ + 
+namespace xml_schema
+{
+  class gyear
+  {
+  public:
+    explicit
+    gyear (int year);
+    gyear (int year, short zone_hours, short zone_minutes);
+
+    int
+    year () const;
+
+    void
+    year (int);
+  };
+
+  bool
+  operator== (const gyear&, const gyear&);
+
+  bool
+  operator!= (const gyear&, const gyear&);
+}
+
+ +

6.12 gYearMonth Parser

+ +

The return type of the gyear_month_pimpl parser implementation + is xml_schema::gyear_month which represents a year and a month + with an optional time zone. Its interface is presented below. + For more information on the base xml_schema::time_zone + class refer to Section 6.4, "Time Zone + Representation".

+ + 
+namespace xml_schema
+{
+  class gyear_month
+  {
+  public:
+    gyear_month (int year, unsigned short month);
+    gyear_month (int year, unsigned short month,
+                 short zone_hours, short zone_minutes);
+
+    int
+    year () const;
+
+    void
+    year (int);
+
+    unsigned short
+    month () const;
+
+    void
+    month (unsigned short);
+  };
+
+  bool
+  operator== (const gyear_month&, const gyear_month&);
+
+  bool
+  operator!= (const gyear_month&, const gyear_month&);
+}
+
+ + +

6.13 time Parser

+ +

The return type of the time_pimpl parser implementation + is xml_schema::time which represents hours, minutes, + and seconds with an optional time zone. Its interface is presented below. + For more information on the base xml_schema::time_zone + class refer to Section 6.4, "Time Zone + Representation".

+ + 
+namespace xml_schema
+{
+  class time
+  {
+  public:
+    time (unsigned short hours, unsigned short minutes, double seconds);
+    time (unsigned short hours, unsigned short minutes, double seconds,
+          short zone_hours, short zone_minutes);
+
+    unsigned short
+    hours () const;
+
+    void
+    hours (unsigned short);
+
+    unsigned short
+    minutes () const;
+
+    void
+    minutes (unsigned short);
+
+    double
+    seconds () const;
+
+    void
+    seconds (double);
+  };
+
+  bool
+  operator== (const time&, const time&);
+
+  bool
+  operator!= (const time&, const time&);
+}
+
+ + + + + +

7 Document Parser and Error Handling

+ +

In this chapter we will discuss the xml_schema::document + type as well as the error handling mechanisms provided by the mapping + in more detail. As mentioned in Section 3.4, + "Connecting the Parsers Together", the interface of + xml_schema::document depends on the underlying XML + parser selected (Section 5.3, "Underlying XML + Parser"). The following sections describe the + document type interface for Xerces-C++ and + Expat as underlying parsers.

+ +

7.1 Xerces-C++ Document Parser

+ +

When Xerces-C++ is used as the underlying XML parser, the + document type has the following interface. Note that + if the character type is wchar_t, then the string type + in the interface becomes std::wstring + (see Section 5.2, "Character Type and Encoding").

+ + 
+namespace xml_schema
+{
+  class parser_base;
+  class error_handler;
+
+  class flags
+  {
+  public:
+    // Do not validate XML documents with the Xerces-C++ validator.
+    //
+    static const unsigned long dont_validate;
+
+    // Do not initialize the Xerces-C++ runtime.
+    //
+    static const unsigned long dont_initialize;
+
+    // Disable handling of subsequent imports for the same namespace
+    // in Xerces-C++ 3.1.0 and later.
+    //
+    static const unsigned long no_multiple_imports;
+  };
+
+  class properties
+  {
+  public:
+    // Add a location for a schema with a target namespace.
+    //
+    void
+    schema_location (const std::string& namespace_,
+                     const std::string& location);
+
+    // Add a location for a schema without a target namespace.
+    //
+    void
+    no_namespace_schema_location (const std::string& location);
+  };
+
+  class document
+  {
+  public:
+    document (parser_base& root,
+              const std::string& root_element_name,
+	      bool polymorphic = false);
+
+    document (parser_base& root,
+              const std::string& root_element_namespace,
+              const std::string& root_element_name,
+	      bool polymorphic = false);
+
+  public:
+    // Parse URI or a local file.
+    //
+    void
+    parse (const std::string& uri,
+           flags = 0,
+           const properties& = properties ());
+
+    // Parse URI or a local file with a user-provided error_handler
+    // object.
+    //
+    void
+    parse (const std::string& uri,
+           error_handler&,
+           flags = 0,
+           const properties& = properties ());
+
+    // Parse URI or a local file with a user-provided ErrorHandler
+    // object. Note that you must initialize the Xerces-C++ runtime
+    // before calling this function.
+    //
+    void
+    parse (const std::string& uri,
+           xercesc::ErrorHandler&,
+           flags = 0,
+           const properties& = properties ());
+
+    // Parse URI or a local file using a user-provided SAX2XMLReader
+    // object. Note that you must initialize the Xerces-C++ runtime
+    // before calling this function.
+    //
+    void
+    parse (const std::string& uri,
+           xercesc::SAX2XMLReader&,
+           flags = 0,
+           const properties& = properties ());
+
+  public:
+    // Parse std::istream.
+    //
+    void
+    parse (std::istream&,
+           flags = 0,
+           const properties& = properties ());
+
+    // Parse std::istream with a user-provided error_handler object.
+    //
+    void
+    parse (std::istream&,
+           error_handler&,
+           flags = 0,
+           const properties& = properties ());
+
+    // Parse std::istream with a user-provided ErrorHandler object.
+    // Note that you must initialize the Xerces-C++ runtime before
+    // calling this function.
+    //
+    void
+    parse (std::istream&,
+           xercesc::ErrorHandler&,
+           flags = 0,
+           const properties& = properties ());
+
+    // Parse std::istream using a user-provided SAX2XMLReader object.
+    // Note that you must initialize the Xerces-C++ runtime before
+    // calling this function.
+    //
+    void
+    parse (std::istream&,
+           xercesc::SAX2XMLReader&,
+           flags = 0,
+           const properties& = properties ());
+
+  public:
+    // Parse std::istream with a system id.
+    //
+    void
+    parse (std::istream&,
+           const std::string& system_id,
+           flags = 0,
+           const properties& = properties ());
+
+    // Parse std::istream with a system id and a user-provided
+    // error_handler object.
+    //
+    void
+    parse (std::istream&,
+           const std::string& system_id,
+           error_handler&,
+           flags = 0,
+           const properties& = properties ());
+
+    // Parse std::istream with a system id and a user-provided
+    // ErrorHandler object. Note that you must initialize the
+    // Xerces-C++ runtime before calling this function.
+    //
+    void
+    parse (std::istream&,
+           const std::string& system_id,
+           xercesc::ErrorHandler&,
+           flags = 0,
+           const properties& = properties ());
+
+    // Parse std::istream with a system id using a user-provided
+    // SAX2XMLReader object. Note that you must initialize the
+    // Xerces-C++ runtime before calling this function.
+    //
+    void
+    parse (std::istream&,
+           const std::string& system_id,
+           xercesc::SAX2XMLReader&,
+           flags = 0,
+           const properties& = properties ());
+
+  public:
+    // Parse std::istream with system and public ids.
+    //
+    void
+    parse (std::istream&,
+           const std::string& system_id,
+           const std::string& public_id,
+           flags = 0,
+           const properties& = properties ());
+
+    // Parse std::istream with system and public ids and a user-provided
+    // error_handler object.
+    //
+    void
+    parse (std::istream&,
+           const std::string& system_id,
+           const std::string& public_id,
+           error_handler&,
+           flags = 0,
+           const properties& = properties ());
+
+    // Parse std::istream with system and public ids and a user-provided
+    // ErrorHandler object. Note that you must initialize the Xerces-C++
+    // runtime before calling this function.
+    //
+    void
+    parse (std::istream&,
+           const std::string& system_id,
+           const std::string& public_id,
+           xercesc::ErrorHandler&,
+           flags = 0,
+           const properties& = properties ());
+
+    // Parse std::istream with system and public ids using a user-
+    // provided SAX2XMLReader object. Note that you must initialize
+    // the Xerces-C++ runtime before calling this function.
+    //
+    void
+    parse (std::istream&,
+           const std::string& system_id,
+           const std::string& public_id,
+           xercesc::SAX2XMLReader&,
+           flags = 0,
+           const properties& = properties ());
+
+  public:
+    // Parse InputSource. Note that you must initialize the Xerces-C++
+    // runtime before calling this function.
+    //
+    void
+    parse (const xercesc::InputSource&,
+           flags = 0,
+           const properties& = properties ());
+
+    // Parse InputSource with a user-provided error_handler object.
+    // Note that you must initialize the Xerces-C++ runtime before
+    // calling this function.
+    //
+    void
+    parse (const xercesc::InputSource&,
+           error_handler&,
+           flags = 0,
+           const properties& = properties ());
+
+    // Parse InputSource with a user-provided ErrorHandler object.
+    // Note that you must initialize the Xerces-C++ runtime before
+    // calling this function.
+    //
+    void
+    parse (const xercesc::InputSource&,
+           xercesc::ErrorHandler&,
+           flags = 0,
+           const properties& = properties ());
+
+    // Parse InputSource using a user-provided SAX2XMLReader object.
+    // Note that you must initialize the Xerces-C++ runtime before
+    // calling this function.
+    //
+    void
+    parse (const xercesc::InputSource&,
+           xercesc::SAX2XMLReader&,
+           flags = 0,
+           const properties& = properties ());
+  };
+}
+
+ +

The document class is a root parser for + the vocabulary. The first argument to its constructors is the + parser for the type of the root element. The parser_base + class is the base type for all parser skeletons. The second and + third arguments to the document's constructors are + the root element's name and namespace. The last argument, + polymorphic, specifies whether the XML documents + being parsed use polymorphism. For more information on support + for XML Schema polymorphism in the C++/Parser mapping refer + to Section 5.5, "Support for Polymorphism".

+ +

The rest of the document interface consists of overloaded + parse() functions. The last two arguments in each of these + functions are flags and properties. The + flags argument allows you to modify the default behavior + of the parsing functions. The properties argument allows + you to override the schema location attributes specified in XML + documents. Note that the schema location paths are relative to an + XML document unless they are complete URIs. For example if you want + to use a local schema file then you will need to use a URI in the + form file:///absolute/path/to/your/schema.

+ +

A number of overloaded parse() functions have the + system_id and public_id arguments. The + system id is a system identifier of the resources being + parsed (for example, URI or a full file path). The public id is a + public identifier of the resource (for example, an + application-specific name or a relative file path). The system id + is used to resolve relative paths (for example, schema paths). In + diagnostics messages the public id is used if it is available. + Otherwise the system id is used.

+ +

The error handling mechanisms employed by the document + parser are described in Section 7.3, "Error + Handling".

+ +

7.2 Expat Document Parser

+ +

When Expat is used as the underlying XML parser, the + document type has the following interface. Note that + if the character type is wchar_t, then the string type + in the interface becomes std::wstring + (see Section 5.2, "Character Type and Encoding").

+ + 
+namespace xml_schema
+{
+  class parser_base;
+  class error_handler;
+
+  class document
+  {
+  public:
+    document (parser_base&,
+              const std::string& root_element_name,
+              bool polymorphic = false);
+
+    document (parser_base&,
+              const std::string& root_element_namespace,
+              const std::string& root_element_name,
+              bool polymorphic = false);
+
+  public:
+    // Parse a local file. The file is accessed with std::ifstream
+    // in binary mode. The std::ios_base::failure exception is used
+    // to report io errors (badbit and failbit).
+    void
+    parse (const std::string& file);
+
+    // Parse a local file with a user-provided error_handler
+    // object. The file is accessed with std::ifstream in binary
+    // mode. The std::ios_base::failure exception is used to report
+    // io errors (badbit and failbit).
+    //
+    void
+    parse (const std::string& file, error_handler&);
+
+  public:
+    // Parse std::istream.
+    //
+    void
+    parse (std::istream&);
+
+    // Parse std::istream with a user-provided error_handler object.
+    //
+    void
+    parse (std::istream&, error_handler&);
+
+    // Parse std::istream with a system id.
+    //
+    void
+    parse (std::istream&, const std::string& system_id);
+
+    // Parse std::istream with a system id and a user-provided
+    // error_handler object.
+    //
+    void
+    parse (std::istream&,
+           const std::string& system_id,
+           error_handler&);
+
+    // Parse std::istream with system and public ids.
+    //
+    void
+    parse (std::istream&,
+           const std::string& system_id,
+           const std::string& public_id);
+
+    // Parse std::istream with system and public ids and a user-provided
+    // error_handler object.
+    //
+    void
+    parse (std::istream&,
+           const std::string& system_id,
+           const std::string& public_id,
+           error_handler&);
+
+  public:
+    // Parse a chunk of input. You can call these functions multiple
+    // times with the last call having the last argument true.
+    //
+    void
+    parse (const void* data, std::size_t size, bool last);
+
+    void
+    parse (const void* data, std::size_t size, bool last,
+           error_handler&);
+
+    void
+    parse (const void* data, std::size_t size, bool last,
+           const std::string& system_id);
+
+    void
+    parse (const void* data, std::size_t size, bool last,
+           const std::string& system_id,
+           error_handler&);
+
+    void
+    parse (const void* data, std::size_t size, bool last,
+           const std::string& system_id,
+           const std::string& public_id);
+
+    void
+    parse (const void* data, std::size_t size, bool last,
+           const std::string& system_id,
+           const std::string& public_id,
+           error_handler&);
+
+  public:
+    // Low-level Expat-specific parsing API.
+    //
+    void
+    parse_begin (XML_Parser);
+
+    void
+    parse_begin (XML_Parser, const std::string& public_id);
+
+    void
+    parse_begin (XML_Parser, error_handler&);
+
+    void
+    parse_begin (XML_Parser,
+                 const std::string& public_id,
+                 error_handler&);
+    void
+    parse_end ();
+  };
+}
+
+ +

The document class is a root parser for + the vocabulary. The first argument to its constructors is the + parser for the type of the root element. The parser_base + class is the base type for all parser skeletons. The second and + third arguments to the document's constructors are + the root element's name and namespace. The last argument, + polymorphic, specifies whether the XML documents + being parsed use polymorphism. For more information on support + for XML Schema polymorphism in the C++/Parser mapping refer + to Section 5.5, "Support for Polymorphism".

+ +

A number of overloaded parse() functions have the + system_id and public_id arguments. The + system id is a system identifier of the resources being + parsed (for example, URI or a full file path). The public id is a + public identifier of the resource (for example, an + application-specific name or a relative file path). The system id + is used to resolve relative paths. In diagnostics messages the + public id is used if it is available. Otherwise the system id + is used.

+ +

The parse_begin() and parse_end() functions + present a low-level, Expat-specific parsing API for maximum control. + A typical use-case would look like this (pseudo-code):

+ + 
+xxx_pimpl root_p;
+document doc_p (root_p, "root");
+
+root_p.pre ();
+doc_p.parse_begin (xml_parser, "file.xml");
+
+while (more_data_to_parse)
+{
+  // Call XML_Parse or XML_ParseBuffer.
+
+  if (status == XML_STATUS_ERROR)
+    break;
+}
+
+// Call parse_end even in case of an error to translate
+// XML and Schema errors to exceptions or error_handler
+// calls.
+//
+doc.parse_end ();
+result_type result (root_p.post_xxx ());
+
+ +

Note that if your vocabulary uses XML namespaces, the + XML_ParserCreateNS() functions should be used to create + the XML parser. Space (XML_Char (' ')) should be used + as a separator (the second argument to XML_ParserCreateNS()). +

+ +

The error handling mechanisms employed by the document + parser are described in Section 7.3, "Error + Handling".

+ + +

7.3 Error Handling

+ +

There are three categories of errors that can result from running + a parser on an XML document: System, XML, and Application. + The System category contains memory allocation and file/stream + operation errors. The XML category covers XML parsing and + well-formedness checking as well as XML Schema validation errors. + Finally, the Application category is for application logic errors + that you may want to propagate from parser implementations to the + caller of the parser. +

+ +

The System errors are mapped to the standard exceptions. The + out of memory condition is indicated by throwing an instance + of std::bad_alloc. The stream operation errors + are reported either by throwing an instance of + std::ios_base::failure if exceptions are enabled + or by setting the stream state.

+ +

Note that if you are parsing std::istream on + which exceptions are not enabled, then you will need to + check the stream state before calling the post() + callback, as shown in the following example:

+ + 
+int
+main (int argc, char* argv[])
+{
+  ...
+
+  std::ifstream ifs (argv[1]);
+
+  if (ifs.fail ())
+  {
+    cerr << argv[1] << ": unable to open" << endl;
+    return 1;
+  }
+
+  root_p.pre ();
+  doc_p.parse (ifs);
+
+  if (ifs.fail ())
+  {
+    cerr << argv[1] << ": io failure" << endl;
+    return 1;
+  }
+
+  result_type result (root_p.post_xxx ());
+}
+
+ +

The above example can be rewritten to use exceptions + as shown below:

+ + 
+int
+main (int argc, char* argv[])
+{
+  try
+  {
+    ...
+
+    std::ifstream ifs;
+    ifs.exceptions (std::ifstream::badbit | std::ifstream::failbit);
+    ifs.open (argv[1]);
+
+    root_p.pre ();
+    doc_p.parse (ifs);
+    result_type result (root_p.post_xxx ());
+  }
+  catch (const std::ifstream::failure&)
+  {
+    cerr << argv[1] << ": unable to open or io failure" << endl;
+    return 1;
+  }
+}
+
+ + +

For reporting application errors from parsing callbacks, you + can throw any exceptions of your choice. They are propagated to + the caller of the parser without any alterations.

+ +

The XML errors can be reported either by throwing the + xml_schema::parsing exception or by a callback + to the xml_schema::error_handler object (and + xercesc::ErrorHandler object in case of Xerces-C++).

+ +

The xml_schema::parsing exception contains + a list of warnings and errors that were accumulated during + parsing. Note that this exception is thrown only if there + was an error. This makes it impossible to obtain warnings + from an otherwise successful parsing using this mechanism. + The following listing shows the definition of + xml_schema::parsing exception. Note that if the + character type is wchar_t, then the string type + and output stream type in the definition become + std::wstring and std::wostream, + respectively (see Section 5.2, "Character Type + and Encoding").

+ + 
+namespace xml_schema
+{
+  class exception: public std::exception
+  {
+  protected:
+    virtual void
+    print (std::ostream&) const = 0;
+  };
+
+  inline std::ostream&
+  operator<< (std::ostream& os, const exception& e)
+  {
+    e.print (os);
+    return os;
+  }
+
+
+  class severity
+  {
+  public:
+    enum value
+    {
+      warning,
+      error
+    };
+  };
+
+
+  class error
+  {
+  public:
+    error (xml_schema::severity,
+           const std::string& id,
+           unsigned long line,
+           unsigned long column,
+           const std::string& message);
+
+    xml_schema::severity
+    severity () const;
+
+    const std::string&
+    id () const;
+
+    unsigned long
+    line () const;
+
+    unsigned long
+    column () const;
+
+    const std::string&
+    message () const;
+  };
+
+  std::ostream&
+  operator<< (std::ostream&, const error&);
+
+
+  class diagnostics: public std::vector<error>
+  {
+  };
+
+  std::ostream&
+  operator<< (std::ostream&, const diagnostics&);
+
+
+  class parsing: public exception
+  {
+  public:
+    parsing ();
+    parsing (const xml_schema::diagnostics&);
+
+    const xml_schema::diagnostics&
+    diagnostics () const;
+
+    virtual const char*
+    what () const throw ();
+
+  protected:
+    virtual void
+    print (std::ostream&) const;
+  };
+}
+
+ +

The following example shows how we can catch and print this + exception. The code will print diagnostics messages one per line + in case of an error.

+ + 
+int
+main (int argc, char* argv[])
+{
+  try
+  {
+    // Parse.
+  }
+  catch (const xml_schema::parsing& e)
+  {
+    cerr << e << endl;
+    return 1;
+  }
+}
+
+ +

With the error_handler approach the diagnostics + messages are delivered as parsing progresses. The following + listing presents the definition of the error_handler + interface. Note that if the character type is wchar_t, + then the string type in the interface becomes std::wstring + (see Section 5.2, "Character Type and Encoding").

+ + 
+namespace xml_schema
+{
+  class error_handler
+  {
+  public:
+    class severity
+    {
+    public:
+      enum value
+      {
+        warning,
+        error,
+        fatal
+      };
+    };
+
+    virtual bool
+    handle (const std::string& id,
+            unsigned long line,
+            unsigned long column,
+            severity,
+            const std::string& message) = 0;
+  };
+}
+
+ +

The return value of the handle() function indicates whether + parsing should continue if possible. The error with the fatal severity + level terminates the parsing process regardless of the returned value. + At the end of the parsing process with an error that was reported via + the error_handler object, an empty + xml_schema::parsing exception is thrown to indicate + the failure to the caller. You can alter this behavior by throwing + your own exception from the handle() function.

+ + + + + +

Appendix A — Supported XML Schema Constructs

+ +

The C++/Parser mapping supports validation of the following W3C XML + Schema constructs in the generated code.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
ConstructNotes
Structure
element
attribute
any
anyAttribute
all
sequence
choice
complex type, empty content
complex type, mixed content
complex type, simple content extension
complex type, simple content restrictionSimple type facets are not validated.
complex type, complex content extension
complex type, complex content restriction
list
Datatypes
byte
unsignedByte
short
unsignedShort
int
unsignedInt
long
unsignedLong
integer
nonPositiveInteger
nonNegativeInteger
positiveInteger
negativeInteger
boolean
float
double
decimal
string
normalizedString
token
Name
NMTOKEN
NCName
language
anyURI
IDIdentity constraint is not enforced.
IDREFIdentity constraint is not enforced.
NMTOKENS
IDREFSIdentity constraint is not enforced.
QName
base64Binary
hexBinary
date
dateTime
duration
gDay
gMonth
gMonthDay
gYear
gYearMonth
time
+ + +
+
+ + + diff --git a/doc/cxx/tree/guide/guide.html2ps.in b/doc/cxx/tree/guide/guide.html2ps.in new file mode 100644 index 0000000..461ffde --- /dev/null +++ b/doc/cxx/tree/guide/guide.html2ps.in @@ -0,0 +1,65 @@ +@@html2ps { + option { + toc: hb; + colour: 1; + hyphenate: 1; + titlepage: 1; + } + + datefmt: "%B %Y"; + + titlepage { + content: " +
+

C++/Tree Mapping

+

Getting Started Guide

+

 

+

 

+

 

+

 

+

 

+

 

+
+

Copyright © @copyright@.

+ +

Permission is granted to copy, distribute and/or modify this + document under the terms of the + GNU Free + Documentation License, version 1.2; with no Invariant Sections, + no Front-Cover Texts and no Back-Cover Texts. +

+ +

This document is available in the following formats: + XHTML, + PDF, and + PostScript.

"; + } + + toc { + indent: 2em; + } + + header { + odd-right: $H; + even-left: $H; + } + + footer { + odd-left: $D; + odd-center: $T; + odd-right: $N; + + even-left: $N; + even-center: $T; + even-right: $D; + } +} + +body { + font-size: 12pt; + text-align: justify; +} + +pre { + font-size: 10pt; +} diff --git a/doc/cxx/tree/guide/index.xhtml b/doc/cxx/tree/guide/index.xhtml new file mode 100644 index 0000000..fdaaa45 --- /dev/null +++ b/doc/cxx/tree/guide/index.xhtml @@ -0,0 +1,2736 @@ + + + + + + C++/Tree Mapping Getting Started Guide + + + + + + + + + + + + + +
+
+ +
+ +
+
C++/Tree Mapping
+
Getting Started Guide
+ +

Copyright © 2005-2023 Code Synthesis.

+ +

Permission is granted to copy, distribute and/or modify this + document under the terms of the + GNU Free + Documentation License, version 1.2; with no Invariant Sections, + no Front-Cover Texts and no Back-Cover Texts. +

+ +

This document is available in the following formats: + XHTML, + PDF, and + PostScript.

+ +
+ +

Table of Contents

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Preface + + + +
About This Document
More Information
+
1Introduction + + + +
1.1Mapping Overview
1.2Benefits
+
2Hello World Example + + + + + + + + +
2.1Writing XML Document and Schema
2.2Translating Schema to C++
2.3Implementing Application Logic
2.4Compiling and Running
2.5Adding Serialization
2.6Selecting Naming Convention
2.7Generating Documentation
+
3Overall Mapping Configuration + + + + + + +
3.1C++ Standard
3.2Character Type and Encoding
3.3Support for Polymorphism
3.4Namespace Mapping
3.5Thread Safety
+
4Working with Object Models + + + + + + +
4.1Attribute and Element Cardinalities
4.2Accessing the Object Model
4.3Modifying the Object Model
4.4Creating the Object Model from Scratch
4.5Mapping for the Built-in XML Schema Types
+
5Parsing + + + +
5.1XML Schema Validation and Searching
5.2Error Handling
+
6Serialization + + + +
6.1Namespace and Schema Information
6.2Error Handling
+
+
+ +

Preface

+ +

About This Document

+ +

The goal of this document is to provide you with an understanding of + the C++/Tree programming model and allow you to efficiently evaluate + XSD against your project's technical requirements. As such, this + document is intended for C++ developers and software architects + who are looking for an XML processing solution. For a more in-depth + description of the C++/Tree mapping refer to the + C++/Tree + Mapping User Manual.

+ +

Prior experience with XML and C++ is required to understand this + document. Basic understanding of XML Schema is advantageous but + not expected or required. +

+ + +

More Information

+ +

Beyond this guide, you may also find the following sources of + information useful:

+ + + + + +

1 Introduction

+ +

Welcome to CodeSynthesis XSD and the C++/Tree mapping. XSD is a + cross-platform W3C XML Schema to C++ data binding compiler. C++/Tree + is a W3C XML Schema to C++ mapping that represents the data stored + in XML as a statically-typed, vocabulary-specific object model. +

+ +

1.1 Mapping Overview

+ +

Based on a formal description of an XML vocabulary (schema), the + C++/Tree mapping produces a tree-like data structure suitable for + in-memory processing. The core of the mapping consists of C++ + classes that constitute the object model and are derived from + types defined in XML Schema as well as XML parsing and + serialization code.

+ +

Besides the core features, C++/Tree provide a number of additional + mapping elements that can be useful in some applications. These + include serialization and extraction to/from formats others than + XML, such as unstructured text (useful for debugging) and binary + representations such as XDR and CDR for high-speed data processing + as well as automatic documentation generation. The C++/Tree mapping + also provides a wide range of mechanisms for controlling and + customizing the generated code.

+ +

A typical application that uses C++/Tree for XML processing usually + performs the following three steps: it first reads (parses) an XML + document to an in-memory object model, it then performs some useful + computations on that object model which may involve modification + of the model, and finally it may write (serialize) the modified + object model back to XML.

+ +

The next chapter presents a simple application that performs these + three steps. The following chapters show how to use the C++/Tree + mapping in more detail.

+ +

1.2 Benefits

+ +

Traditional XML access APIs such as Document Object Model (DOM) + or Simple API for XML (SAX) have a number of drawbacks that + make them less suitable for creating robust and maintainable + XML processing applications. These drawbacks include: +

+ +
    +
  • Generic representation of XML in terms of elements, attributes, + and text forces an application developer to write a substantial + amount of bridging code that identifies and transforms pieces + of information encoded in XML to a representation more suitable + for consumption by the application logic.
    • + +
  • String-based flow control defers error detection to runtime. + It also reduces code readability and maintainability.
    • + +
  • Lack of type safety because the data is represented as text.
    • + +
  • Resulting applications are hard to debug, change, and + maintain.
    • +
+ +

In contrast, statically-typed, vocabulary-specific object model + produced by the C++/Tree mapping allows you to operate in your + domain terms instead of the generic elements, attributes, and + text. Static typing helps catch errors at compile-time rather + than at run-time. Automatic code generation frees you for more + interesting tasks (such as doing something useful with the + information stored in the XML documents) and minimizes the + effort needed to adapt your applications to changes in the + document structure. To summarize, the C++/Tree object model has + the following key advantages over generic XML access APIs:

+ +
    +
  • Ease of use. The generated code hides all the complexity + associated with parsing and serializing XML. This includes navigating + the structure and converting between the text representation and + data types suitable for manipulation by the application + logic.
    • + +
  • Natural representation. The object representation allows + you to access the XML data using your domain vocabulary instead + of generic elements, attributes, and text.
    • + +
  • Concise code. With the object representation the + application implementation is simpler and thus easier + to read and understand.
    • + +
  • Safety. The generated object model is statically + typed and uses functions instead of strings to access the + information. This helps catch programming errors at compile-time + rather than at runtime.
    • + +
  • Maintainability. Automatic code generation minimizes the + effort needed to adapt the application to changes in the + document structure. With static typing, the C++ compiler + can pin-point the places in the client code that need to be + changed.
    • + +
  • Compatibility. Sequences of elements are represented in + the object model as containers conforming to the standard C++ + sequence requirements. This makes it possible to use standard + C++ algorithms on the object representation and frees you from + learning yet another container interface, as is the case with + DOM.
    • + +
  • Efficiency. If the application makes repetitive use + of the data extracted from XML, then the C++/Tree object model + is more efficient because the navigation is performed using + function calls rather than string comparisons and the XML + data is extracted only once. Furthermore, the runtime memory + usage is reduced due to more efficient data storage + (for instance, storing numeric data as integers instead of + strings) as well as the static knowledge of cardinality + constraints.
    • +
+ + + + + +

2 Hello World Example

+ +

In this chapter we will examine how to parse, access, modify, and + serialize a very simple XML document using the XSD-generated + C++/Tree object model. The code presented in this chapter is + based on the hello example which can be found in + the cxx/tree/ directory in the + xsd-examples package.

+ +

2.1 Writing XML Document and Schema

+ +

First, we need to get an idea about the structure + of the XML documents we are going to process. Our + hello.xml, for example, could look like this:

+ + 
+<?xml version="1.0"?>
+<hello>
+
+  <greeting>Hello</greeting>
+
+  <name>sun</name>
+  <name>moon</name>
+  <name>world</name>
+
+</hello>
+
+ +

Then we can write a description of the above XML in the + XML Schema language and save it into hello.xsd:

+ + 
+<?xml version="1.0"?>
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+
+  <xs:complexType name="hello_t">
+    <xs:sequence>
+      <xs:element name="greeting" type="xs:string"/>
+      <xs:element name="name" type="xs:string" maxOccurs="unbounded"/>
+    </xs:sequence>
+  </xs:complexType>
+
+  <xs:element name="hello" type="hello_t"/>
+
+</xs:schema>
+
+ +

Even if you are not familiar with XML Schema, it + should be easy to connect declarations in hello.xsd + to elements in hello.xml. The hello_t type + is defined as a sequence of the nested greeting and + name elements. Note that the term sequence in XML + Schema means that elements should appear in a particular order + as opposed to appearing multiple times. The name + element has its maxOccurs property set to + unbounded which means it can appear multiple times + in an XML document. Finally, the globally-defined hello + element prescribes the root element for our vocabulary. For an + easily-approachable introduction to XML Schema refer to + XML Schema Part 0: + Primer.

+ +

The above schema is a specification of our XML vocabulary; it tells + everybody what valid documents of our XML-based language should look + like. We can also update our hello.xml to include the + information about the schema so that XML parsers can validate + our document:

+ + 
+<?xml version="1.0"?>
+<hello xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+       xsi:noNamespaceSchemaLocation="hello.xsd">
+
+  <greeting>Hello</greeting>
+
+  <name>sun</name>
+  <name>moon</name>
+  <name>world</name>
+
+</hello>
+
+ + +

The next step is to compile the schema to generate the object + model and parsing functions.

+ +

2.2 Translating Schema to C++

+ +

Now we are ready to translate our hello.xsd to C++. + To do this we invoke the XSD compiler from a terminal (UNIX) or + a command prompt (Windows): +

+ + 
+$ xsd cxx-tree hello.xsd
+
+ +

The XSD compiler produces two C++ files: hello.hxx and + hello.cxx. The following code fragment is taken from + hello.hxx; it should give you an idea about what gets + generated: +

+ + 
+class hello_t
+{
+public:
+  // greeting
+  //
+  typedef xml_schema::string greeting_type;
+
+  const greeting_type&
+  greeting () const;
+
+  greeting_type&
+  greeting ();
+
+  void
+  greeting (const greeting_type& x);
+
+  // name
+  //
+  typedef xml_schema::string name_type;
+  typedef xsd::sequence<name_type> name_sequence;
+  typedef name_sequence::iterator name_iterator;
+  typedef name_sequence::const_iterator name_const_iterator;
+
+  const name_sequence&
+  name () const;
+
+  name_sequence&
+  name ();
+
+  void
+  name (const name_sequence& s);
+
+  // Constructor.
+  //
+  hello_t (const greeting_type&);
+
+  ...
+
+};
+
+std::unique_ptr<hello_t>
+hello (const std::string& uri);
+
+std::unique_ptr<hello_t>
+hello (std::istream&);
+
+ +

The hello_t C++ class corresponds to the + hello_t XML Schema type. For each element + in this type a set of C++ type definitions as well as + accessor and modifier functions are generated inside the + hello_t class. Note that the type definitions + and member functions for the greeting and + name elements are different because of the + cardinality differences between these two elements + (greeting is a required single element and + name is a sequence of elements).

+ +

The xml_schema::string type used in the type + definitions is a C++ class provided by the XSD runtime + that corresponds to built-in XML Schema type + string. The xml_schema::string + is based on std::string and can be used as + such. Similarly, the sequence class template + that is used in the name_sequence type + definition is based on and has the same interface as + std::vector. The mapping between the built-in + XML Schema types and C++ types is described in more detail in + Section 4.5, "Mapping for the Built-in XML Schema + Types". The hello_t class also includes a + constructor with an initializer for the required + greeting element as its argument.

+ +

The hello overloaded global functions correspond + to the hello global element in XML Schema. A + global element in XML Schema is a valid document root. + By default XSD generated a set of parsing functions for each + global element defined in XML Schema (this can be overridden + with the --root-element-* options). Parsing + functions return a dynamically allocated object model as an + automatic pointer. The actual pointer used depends on the + C++ standard selected. For C++11 it is std::unique_ptr + as shown above. For C++98 it is std::auto_ptr. + For example, if we modify our XSD compiler invocation to + select C++98:

+ + 
+$ xsd cxx-tree --std c++98 hello.xsd
+
+ +

Then the parsing function signatures will become:

+ + 
+std::auto_ptr<hello_t>
+hello (const std::string& uri);
+
+std::auto_ptr<hello_t>
+hello (std::istream&);
+
+ +

For more information on parsing functions see Chapter 5, + "Parsing".

+ +

2.3 Implementing Application Logic

+ +

At this point we have all the parts we need to do something useful + with the information stored in our XML document: +

+ + 
+#include <iostream>
+#include "hello.hxx"
+
+using namespace std;
+
+int
+main (int argc, char* argv[])
+{
+  try
+  {
+    unique_ptr<hello_t> h (hello (argv[1]));
+
+    for (hello_t::name_const_iterator i (h->name ().begin ());
+         i != h->name ().end ();
+         ++i)
+    {
+      cerr << h->greeting () << ", " << *i << "!" << endl;
+    }
+  }
+  catch (const xml_schema::exception& e)
+  {
+    cerr << e << endl;
+    return 1;
+  }
+}
+
+ +

The first part of our application calls one of the parsing + functions to parser an XML file specified in the command line. + We then use the returned object model to iterate over names + and print a greeting line for each of them. Finally, we + catch and print the xml_schema::exception + exception in case something goes wrong. This exception + is the root of the exception hierarchy used by the + XSD-generated code. +

+ + +

2.4 Compiling and Running

+ +

After saving our application from the previous section in + driver.cxx, we are ready to compile our first + program and run it on the test XML document. On a UNIX + system this can be done with the following commands: +

+ + 
+$ c++ -std=c++11 -I.../libxsd -c driver.cxx hello.cxx
+$ c++ -std=c++11 -o driver driver.o hello.o -lxerces-c
+$ ./driver hello.xml
+Hello, sun!
+Hello, moon!
+Hello, world!
+
+ +

Here .../libxsd represents the path to the + libxsd package root + directory. Note also that we are required to link our + application with the Xerces-C++ library because the generated + code uses it as the underlying XML parser.

+ +

2.5 Adding Serialization

+ +

While parsing and accessing the XML data may be everything + you need, there are applications that require creating new + or modifying existing XML documents. By default XSD does + not produce serialization code. We will need to request + it with the --generate-serialization options:

+ + 
+$ xsd cxx-tree --generate-serialization hello.xsd
+
+ +

If we now examine the generated hello.hxx file, + we will find a set of overloaded serialization functions, + including the following version:

+ + 
+void
+hello (std::ostream&,
+       const hello_t&,
+       const xml_schema::namespace_infomap& =
+         xml_schema::namespace_infomap ());
+
+
+ +

Just like with parsing functions, XSD generates serialization + functions for each global element unless instructed otherwise + with one of the --root-element-* options. For more + information on serialization functions see Chapter 6, + "Serialization".

+ +

We first examine an application that modifies an existing + object model and serializes it back to XML:

+ + 
+#include <iostream>
+#include "hello.hxx"
+
+using namespace std;
+
+int
+main (int argc, char* argv[])
+{
+  try
+  {
+    unique_ptr<hello_t> h (hello (argv[1]));
+
+    // Change the greeting phrase.
+    //
+    h->greeting ("Hi");
+
+    // Add another entry to the name sequence.
+    //
+    h->name ().push_back ("mars");
+
+    // Serialize the modified object model to XML.
+    //
+    xml_schema::namespace_infomap map;
+    map[""].name = "";
+    map[""].schema = "hello.xsd";
+
+    hello (cout, *h, map);
+  }
+  catch (const xml_schema::exception& e)
+  {
+    cerr << e << endl;
+    return 1;
+  }
+}
+
+ +

First, our application parses an XML document and obtains its + object model as in the previous example. Then it changes the + greeting string and adds another entry to the list of names. + Finally, it serializes the object model back to XML by calling + the serialization function.

+ +

The first argument we pass to the serialization function is + cout which results in the XML being written to + the standard output for us to inspect. We could have also + written the result to a file or memory buffer by creating an + instance of std::ofstream or std::ostringstream + and passing it instead of cout. The second argument is the + object model we want to serialize. The final argument is an optional + namespace information map for our vocabulary. It captures information + such as namespaces, namespace prefixes to which they should be mapped, + and schemas associated with these namespaces. If we don't provide + this argument then generic namespace prefixes (p1, + p2, etc.) will be automatically assigned to XML namespaces + and no schema information will be added to the resulting document + (see Chapter 6, "Serialization" for details). + In our case, the prefix (map key) and namespace name are empty + because our vocabulary does not use XML namespaces.

+ +

If we now compile and run this application we will see the + output as shown in the following listing:

+ + 
+<?xml version="1.0"?>
+<hello xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+       xsi:noNamespaceSchemaLocation="hello.xsd">
+
+  <greeting>Hi</greeting>
+
+  <name>sun</name>
+  <name>moon</name>
+  <name>world</name>
+  <name>mars</name>
+
+</hello>
+
+ +

We can also create and serialize an object model from scratch + as shown in the following example:

+ + 
+#include <iostream>
+#include <fstream>
+#include "hello.hxx"
+
+using namespace std;
+
+int
+main (int argc, char* argv[])
+{
+  try
+  {
+    hello_t h ("Hi");
+
+    hello_t::name_sequence& ns (h.name ());
+
+    ns.push_back ("Jane");
+    ns.push_back ("John");
+
+    // Serialize the object model to XML.
+    //
+    xml_schema::namespace_infomap map;
+    map[""].name = "";
+    map[""].schema = "hello.xsd";
+
+    std::ofstream ofs (argv[1]);
+    hello (ofs, h, map);
+  }
+  catch (const xml_schema::exception& e)
+  {
+    cerr << e << endl;
+    return 1;
+  }
+}
+
+ +

In this example we used the generated constructor to create + an instance of type hello_t. To reduce typing, + we obtained a reference to the name sequence which we then + used to add a few names. The serialization part is identical + to the previous example except this time we are writing to + a file. If we compile and run this program, it produces the + following XML file:

+ + 
+<?xml version="1.0"?>
+<hello xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+       xsi:noNamespaceSchemaLocation="hello.xsd">
+
+  <greeting>Hi</greeting>
+
+  <name>Jane</name>
+  <name>John</name>
+
+</hello>
+
+ +

2.6 Selecting Naming Convention

+ +

By default XSD uses the so-called K&R (Kernighan and Ritchie) + identifier naming convention in the generated code. In this + convention both type and function names are in lower case and + words are separated by underscores. If your application code or + schemas use a different notation, you may want to change the + naming convention used in the generated code for consistency. + XSD supports a set of widely-used naming conventions + that you can select with the --type-naming and + --function-naming options. You can also further + refine one of the predefined conventions or create a completely + custom naming scheme by using the --*-regex options.

+ +

As an example, let's assume that our "Hello World" application + uses the so-called upper-camel-case naming convention for types + (that is, each word in a type name is capitalized) and the K&R + convention for function names. Since K&R is the default + convention for both type and function names, we only need to + change the type naming scheme:

+ + 
+$ xsd cxx-tree --type-naming ucc hello.xsd
+
+ +

The ucc argument to the --type-naming + options stands for upper-camel-case. If we now examine the + generated hello.hxx, we will see the following + changes compared to the declarations shown in the previous + sections:

+ + 
+class Hello_t
+{
+public:
+  // greeting
+  //
+  typedef xml_schema::String GreetingType;
+
+  const GreetingType&
+  greeting () const;
+
+  GreetingType&
+  greeting ();
+
+  void
+  greeting (const GreetingType& x);
+
+  // name
+  //
+  typedef xml_schema::String NameType;
+  typedef xsd::sequence<NameType> NameSequence;
+  typedef NameSequence::iterator NameIterator;
+  typedef NameSequence::const_iterator NameConstIterator;
+
+  const NameSequence&
+  name () const;
+
+  NameSequence&
+  name ();
+
+  void
+  name (const NameSequence& s);
+
+  // Constructor.
+  //
+  Hello_t (const GreetingType&);
+
+  ...
+
+};
+
+std::unique_ptr<Hello_t>
+hello (const std::string& uri);
+
+std::unique_ptr<Hello_t>
+hello (std::istream&);
+
+ +

Notice that the type names in the xml_schema namespace, + for example xml_schema::String, now also use the + upper-camel-case naming convention. The only thing that we may + be unhappy about in the above code is the _t + suffix in Hello_t. If we are not in a position + to change the schema, we can touch-up the ucc + convention with a custom translation rule using the + --type-regex option:

+ + 
+$ xsd cxx-tree --type-naming ucc --type-regex '/ (.+)_t/\u$1/' hello.xsd
+
+ +

This results in the following changes to the generated code:

+ + 
+class Hello
+{
+public:
+  // greeting
+  //
+  typedef xml_schema::String GreetingType;
+
+  const GreetingType&
+  greeting () const;
+
+  GreetingType&
+  greeting ();
+
+  void
+  greeting (const GreetingType& x);
+
+  // name
+  //
+  typedef xml_schema::String NameType;
+  typedef xsd::sequence<NameType> NameSequence;
+  typedef NameSequence::iterator NameIterator;
+  typedef NameSequence::const_iterator NameConstIterator;
+
+  const NameSequence&
+  name () const;
+
+  NameSequence&
+  name ();
+
+  void
+  name (const NameSequence& s);
+
+  // Constructor.
+  //
+  Hello (const GreetingType&);
+
+  ...
+
+};
+
+std::unique_ptr<Hello>
+hello (const std::string& uri);
+
+std::unique_ptr<Hello>
+hello (std::istream&);
+
+ +

For more detailed information on the --type-naming, + --function-naming, --type-regex, and + other --*-regex options refer to the NAMING + CONVENTION section in the XSD + Compiler Command Line Manual.

+ +

2.7 Generating Documentation

+ +

While our object model is quite simple, real-world vocabularies + can be quite complex with hundreds of types, elements, and + attributes. For such vocabularies figuring out which types + provide which member functions by studying the generated + source code or schemas can be a daunting task. To provide + application developers with a more accessible way of + understanding the generated object models, the XSD compiler + can be instructed to produce source code with documentation + comments in the Doxygen format. Then the source code can be + processed with the Doxygen + documentation system to extract this information and produce + documentation in various formats. +

+ +

In this section we will see how to generate documentation + for our "Hello World" vocabulary. To showcase the full power + of the XSD documentation facilities, we will first document + our schema. The XSD compiler will then transfer + this information from the schema to the generated code and + then to the object model documentation. Note that the + documentation in the schema is not required for XSD to + generate useful documentation. Below you will find + our hello.xsd with added documentation:

+ + 
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+
+  <xs:complexType name="hello_t">
+
+    <xs:annotation>
+      <xs:documentation>
+        The hello_t type consists of a greeting phrase and a
+        collection of names to which this greeting applies.
+      </xs:documentation>
+    </xs:annotation>
+
+    <xs:sequence>
+
+      <xs:element name="greeting" type="xs:string">
+        <xs:annotation>
+          <xs:documentation>
+            The greeting element contains the greeting phrase
+            for this hello object.
+          </xs:documentation>
+        </xs:annotation>
+      </xs:element>
+
+      <xs:element name="name" type="xs:string" maxOccurs="unbounded">
+        <xs:annotation>
+          <xs:documentation>
+            The name elements contains names to be greeted.
+          </xs:documentation>
+        </xs:annotation>
+      </xs:element>
+
+    </xs:sequence>
+  </xs:complexType>
+
+  <xs:element name="hello" type="hello_t">
+    <xs:annotation>
+      <xs:documentation>
+        The hello element is a root of the Hello XML vocabulary.
+        Every conforming document should start with this element.
+      </xs:documentation>
+    </xs:annotation>
+  </xs:element>
+
+</xs:schema>
+
+ +

The first step in obtaining the documentation is to recompile + our schema with the --generate-doxygen option:

+ + 
+$ xsd cxx-tree --generate-serialization --generate-doxygen hello.xsd
+
+ +

Now the generated hello.hxx file contains comments + in the Doxygen format. The next step is to process this file + with the Doxygen documentation system. If your project does + not use Doxygen then you first need to create a configuration + file for your project:

+ + 
+$ doxygen -g hello.doxygen
+
+ +

You only need to perform this step once. Now we can generate + the documentation by executing the following command in the + directory with the generated source code:

+ + 
+$ doxygen hello.doxygen
+
+ +

While the generated documentation can be useful as is, we can + go one step further and link (using the Doxygen tags mechanism) + the documentation for our object model with the documentation + for the XSD runtime library which defines C++ classes for the + built-in XML Schema types. This way we can seamlessly browse + between documentation for the hello_t class which + is generated by the XSD compiler and the xml_schema::string + class which is defined in the XSD runtime library. The Doxygen + configuration file for the XSD runtime is provided with the XSD + distribution.

+ +

You can view the result of the steps described in this section + on the Hello + Example Documentation page.

+ + + + +

3 Overall Mapping Configuration

+ +

The C++/Tree mapping has a number of configuration parameters that + determine the overall properties and behavior of the generated code. + Configuration parameters are specified with the XSD command line + options. This chapter describes configuration aspects that are most + commonly encountered by application developers. These include: the + C++ standard, the character type that is used by the generated code, + handling of vocabularies that use XML Schema polymorphism, XML Schema + to C++ namespace mapping, and thread safety. For more ways to configure + the generated code refer to the + XSD + Compiler Command Line Manual. +

+ +

3.1 C++ Standard

+ +

The C++/Tree mapping provides support for ISO/IEC C++ 2011 (C++11) + and ISO/IEC C++ 1998/2003 (C++98). To select the C++ standard for the + generated code we use the --std XSD compiler command + line option. While the majority of the examples in this guide use + C++11, the document explains the C++11/98 usage difference and so + they can easily be converted to C++98.

+ +

3.2 Character Type and Encoding

+ +

The C++/Tree mapping has built-in support for two character types: + char and wchar_t. You can select the + character type with the --char-type command line + option. The default character type is char. The + character type affects all string and string-based types that + are used in the mapping. These include the string-based built-in + XML Schema types, exception types, stream types, etc.

+ +

Another aspect of the mapping that depends on the character type + is character encoding. For the char character type + the default encoding is UTF-8. Other supported encodings are + ISO-8859-1, Xerces-C++ Local Code Page (LPC), as well as + custom encodings. You can select which encoding should be used + in the object model with the --char-encoding command + line option.

+ +

For the wchar_t character type the encoding is + automatically selected between UTF-16 and UTF-32/UCS-4 depending + on the size of the wchar_t type. On some platforms + (for example, Windows with Visual C++ and AIX with IBM XL C++) + wchar_t is 2 bytes long. For these platforms the + encoding is UTF-16. On other platforms wchar_t is 4 bytes + long and UTF-32/UCS-4 is used.

+ +

Note also that the character encoding that is used in the object model + is independent of the encodings used in input and output XML. In fact, + all three (object mode, input XML, and output XML) can have different + encodings.

+ +

3.3 Support for Polymorphism

+ +

By default XSD generates non-polymorphic code. If your vocabulary + uses XML Schema polymorphism in the form of xsi:type + and/or substitution groups, then you will need to compile + your schemas with the --generate-polymorphic option + to produce polymorphism-aware code. For more information on + working with polymorphic object models, refer to + Section 2.11, + "Mapping for xsi:type and Substitution Groups" in + the C++/Tree Mapping User Manual.

+ +

3.4 Namespace Mapping

+ +

XSD maps XML namespaces specified in the targetNamespace + attribute in XML Schema to one or more nested C++ namespaces. By + default, a namespace URI is mapped to a sequence of C++ namespace + names by removing the protocol and host parts and splitting the + rest into a sequence of names with '/' as the name + separator.

+ +

The default mapping of namespace URIs to C++ namespaces + can be altered using the --namespace-map and + --namespace-regex compiler options. For example, + to map namespace URI https://www.codesynthesis.com/my to + C++ namespace cs::my, we can use the following option:

+ + 
+--namespace-map https://www.codesynthesis.com/my=cs::my
+
+ +

A vocabulary without a namespace is mapped to the global scope. This + also can be altered with the above options by using an empty name + for the XML namespace:

+ + 
+--namespace-map =cs
+
+ +

3.5 Thread Safety

+ +

XSD-generated code is thread-safe in the sense that you can + use different instantiations of the object model in several + threads concurrently. This is possible due to the generated + code not relying on any writable global variables. If you need + to share the same object between several threads then you will + need to provide some form of synchronization. One approach would + be to use the generated code customization mechanisms to embed + synchronization primitives into the generated C++ classes. For more + information on generated code customization refer to the + C++/Tree + Mapping Customization Guide.

+ +

If you also would like to call parsing and/or serialization + functions from several threads potentially concurrently, then + you will need to make sure the Xerces-C++ runtime is initialized + and terminated only once. The easiest way to do this is to + initialize/terminate Xerces-C++ from main() when + there are no threads yet/anymore:

+ + 
+#include <xercesc/util/PlatformUtils.hpp>
+
+int
+main ()
+{
+  xercesc::XMLPlatformUtils::Initialize ();
+
+  {
+    // Start/terminate threads and parse/serialize here.
+  }
+
+  xercesc::XMLPlatformUtils::Terminate ();
+}
+
+ +

Because you initialize the Xerces-C++ runtime yourself you should + also pass the xml_schema::flags::dont_initialize flag + to parsing and serialization functions. See Chapter 5, + "Parsing" and Chapter 6, "Serialization" for + more information.

+ + + + + +

4 Working with Object Models

+ +

As we have seen in the previous chapters, the XSD compiler generates + a C++ class for each type defined in XML Schema. Together these classes + constitute an object model for an XML vocabulary. In this chapter we + will take a closer look at different elements that comprise an + object model class as well as how to create, access, and modify + object models.

+ +

In this and subsequent chapters we will use the following schema + that describes a collection of person records. We save it in + people.xsd:

+ + 
+<?xml version="1.0"?>
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+
+  <xs:simpleType name="gender_t">
+    <xs:restriction base="xs:string">
+      <xs:enumeration value="male"/>
+      <xs:enumeration value="female"/>
+    </xs:restriction>
+  </xs:simpleType>
+
+  <xs:complexType name="person_t">
+    <xs:sequence>
+      <xs:element name="first-name" type="xs:string"/>
+      <xs:element name="middle-name" type="xs:string" minOccurs="0"/>
+      <xs:element name="last-name" type="xs:string"/>
+      <xs:element name="gender" type="gender_t"/>
+      <xs:element name="age" type="xs:short"/>
+    </xs:sequence>
+    <xs:attribute name="id" type="xs:unsignedInt" use="required"/>
+  </xs:complexType>
+
+  <xs:complexType name="people_t">
+    <xs:sequence>
+      <xs:element name="person" type="person_t" maxOccurs="unbounded"/>
+    </xs:sequence>
+  </xs:complexType>
+
+  <xs:element name="people" type="people_t"/>
+
+</xs:schema>
+
+ +

A sample XML instance to go along with this schema is saved + in people.xml:

+ + 
+<?xml version="1.0"?>
+<people xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+        xsi:noNamespaceSchemaLocation="people.xsd">
+
+  <person id="1">
+    <first-name>John</first-name>
+    <last-name>Doe</last-name>
+    <gender>male</gender>
+    <age>32</age>
+  </person>
+
+  <person id="2">
+    <first-name>Jane</first-name>
+    <middle-name>Mary</middle-name>
+    <last-name>Doe</last-name>
+    <gender>female</gender>
+    <age>28</age>
+  </person>
+
+</people>
+
+ +

Compiling people.xsd with the XSD compiler results + in three generated C++ classes: gender_t, + person_t, and people_t. + The gender_t class is modelled after the C++ + enum type. Its definition is presented below:

+ + 
+class gender_t: public xml_schema::string
+{
+public:
+  enum value
+  {
+    male,
+    female
+  };
+
+  gender_t (value);
+  gender_t (const xml_schema::string&);
+
+  gender_t&
+  operator= (value);
+
+  operator value () const;
+};
+
+ +

The following listing shows how we can use this type:

+ + 
+gender_t m (gender_t::male);
+gender_t f ("female");
+
+if (m == "female" || f == gender_t::male)
+{
+  ...
+}
+
+switch (m)
+{
+case gender_t::male:
+  {
+    ...
+  }
+case gender_t::female:
+  {
+    ...
+  }
+}
+
+ +

The other two classes will be examined in detail in the subsequent + sections.

+ +

4.1 Attribute and Element Cardinalities

+ +

As we have seen in the previous chapters, XSD generates a different + set of type definitions and member functions for elements with + different cardinalities. The C++/Tree mapping divides all the possible + element and attribute cardinalities into three cardinality classes: + one, optional, and sequence.

+ +

The one cardinality class covers all elements that should + occur exactly once as well as required attributes. In our + example, the first-name, last-name, + gender, and age elements as well as + the id attribute belong to this cardinality class. + The following code fragment shows type definitions as well as the + accessor and modifier functions that are generated for the + gender element in the person_t class:

+ + 
+class person_t
+{
+  // gender
+  //
+  typedef gender_t gender_type;
+
+  const gender_type&
+  gender () const;
+
+  gender_type&
+  gender ();
+
+  void
+  gender (const gender_type&);
+};
+
+ +

The gender_type type is an alias for the element's type. + The first two accessor functions return read-only (constant) and + read-write references to the element's value, respectively. The + modifier function sets the new value for the element.

+ +

The optional cardinality class covers all elements that + can occur zero or one time as well as optional attributes. In our + example, the middle-name element belongs to this + cardinality class. The following code fragment shows the type + definitions as well as the accessor and modifier functions that + are generated for this element in the person_t class:

+ + 
+class person_t
+{
+  // middle-name
+  //
+  typedef xml_schema::string middle_name_type;
+  typedef xsd::optional<middle_name_type> middle_name_optional;
+
+  const middle_name_optional&
+  middle_name () const;
+
+  middle_name_optional&
+  middle_name ();
+
+  void
+  middle_name (const middle_name_type&);
+
+  void
+  middle_name (const middle_name_optional&);
+};
+
+ +

As with the gender element, middle_name_type + is an alias for the element's type. The middle_name_optional + type is a container for the element's optional value. It can be queried + for the presence of the value using the present() function. + The value itself can be retrieved using the get() + accessor and set using the set() modifier. The container + can be reverted to the value not present state with the call to the + reset() function. The following example shows how we + can use this container:

+ + 
+person_t::middle_name_optional n ("John");
+
+if (n.present ())
+{
+  cout << n.get () << endl;
+}
+
+n.set ("Jane");
+n.reset ();
+
+ + +

Unlike the one cardinality class, the accessor functions + for the optional class return read-only (constant) and + read-write references to the container instead of the element's + value directly. The modifier functions set the new value for the + element.

+ +

Finally, the sequence cardinality class covers all elements + that can occur more than once. In our example, the + person element in the people_t type + belongs to this cardinality class. The following code fragment shows + the type definitions as well as the accessor and modifier functions + that are generated for this element in the people_t + class:

+ + 
+class people_t
+{
+  // person
+  //
+  typedef person_t person_type;
+  typedef xsd::sequence<person_type> person_sequence;
+  typedef person_sequence::iterator person_iterator;
+  typedef person_sequence::const_iterator person_const_iterator;
+
+  const person_sequence&
+  person () const;
+
+  person_sequence&
+  person ();
+
+  void
+  person (const person_sequence&);
+};
+
+ +

Identical to the other cardinality classes, person_type + is an alias for the element's type. The person_sequence + type is a sequence container for the element's values. It is based + on and has the same interface as std::vector and + therefore can be used in similar ways. The person_iterator + and person_const_iterator types are read-only + (constant) and read-write iterators for the person_sequence + container.

+ +

Similar to the optional cardinality class, the + accessor functions for the sequence class return + read-only (constant) and read-write references to the sequence + container. The modifier functions copies the entries from + the passed sequence.

+ +

C++/Tree is a "flattening" mapping in a sense that many levels of + nested compositors (choice and sequence), + all potentially with their own cardinalities, are in the end mapped + to a flat set of elements with one of the three cardinality classes + discussed above. While this results in a simple and easy to use API + for most types, in certain cases, the order of elements in the actual + XML documents is not preserved once parsed into the object model. To + overcome this limitation we can mark certain schema types, for which + content order is not sufficiently preserved, as ordered. For more + information on this functionality refer to + Section + 2.8.4, "Element Order" in the C++/Tree Mapping User Manual.

+ +

For complex schemas with many levels of nested compositors + (choice and sequence) it can also + be hard to deduce the cardinality class of a particular element. + The generated Doxygen documentation can greatly help with + this task. For each element and attribute the documentation + clearly identifies its cardinality class. Alternatively, you + can study the generated header files to find out the cardinality + class of a particular attribute or element.

+ +

In the next sections we will examine how to access and modify + information stored in an object model using accessor and modifier + functions described in this section.

+ +

4.2 Accessing the Object Model

+ +

In this section we will learn how to get to the information + stored in the object model for our person records vocabulary. + The following application accesses and prints the contents + of the people.xml file:

+ + 
+#include <iostream>
+#include "people.hxx"
+
+using namespace std;
+
+int
+main ()
+{
+  unique_ptr<people_t> ppl (people ("people.xml"));
+
+  // Iterate over individual person records.
+  //
+  people_t::person_sequence& ps (ppl->person ());
+
+  for (people_t::person_iterator i (ps.begin ()); i != ps.end (); ++i)
+  {
+    person_t& p (*i);
+
+    // Print names: first-name and last-name are required elements,
+    // middle-name is optional.
+    //
+    cout << "name:   " << p.first_name () << " ";
+
+    if (p.middle_name ().present ())
+      cout << p.middle_name ().get () << " ";
+
+    cout << p.last_name () << endl;
+
+    // Print gender, age, and id which are all required.
+    //
+    cout << "gender: " << p.gender () << endl
+         << "age:    " << p.age () << endl
+         << "id:     " << p.id () << endl
+         << endl;
+  }
+}
+
+ +

This code shows common patterns of accessing elements and attributes + with different cardinality classes. For the sequence element + (person in people_t) we first obtain a + reference to the container and then iterate over individual + records. The values of elements and attributes with the + one cardinality class (first-name, + last-name, gender, age, + and id) can be obtained directly by calling the + corresponding accessor functions. For the optional element + middle-name we first check if the value is present + and only then call get() to retrieve it.

+ +

Note that when we want to reduce typing by creating a variable + representing a fragment of the object model that we are currently + working with (ps and p above), we obtain + a reference to that fragment instead of making a potentially + expensive copy. This is generally a good rule to follow when + creating high-performance applications.

+ +

If we run the above application on our sample + people.xml, the output looks as follows:

+ + 
+name:   John Doe
+gender: male
+age:    32
+id:     1
+
+name:   Jane Mary Doe
+gender: female
+age:    28
+id:     2
+
+ + +

4.3 Modifying the Object Model

+ +

In this section we will learn how to modify the information + stored in the object model for our person records vocabulary. + The following application changes the contents of the + people.xml file:

+ + 
+#include <iostream>
+#include "people.hxx"
+
+using namespace std;
+
+int
+main ()
+{
+  unique_ptr<people_t> ppl (people ("people.xml"));
+
+  // Iterate over individual person records and increment
+  // the age.
+  //
+  people_t::person_sequence& ps (ppl->person ());
+
+  for (people_t::person_iterator i (ps.begin ()); i != ps.end (); ++i)
+  {
+    // Alternative way: i->age ()++;
+    //
+    i->age (i->age () + 1);
+  }
+
+  // Add middle-name to the first record and remove it from
+  // the second.
+  //
+  person_t& john (ps[0]);
+  person_t& jane (ps[1]);
+
+  john.middle_name ("Mary");
+  jane.middle_name ().reset ();
+
+  // Add another John record.
+  //
+  ps.push_back (john);
+
+  // Serialize the modified object model to XML.
+  //
+  xml_schema::namespace_infomap map;
+  map[""].name = "";
+  map[""].schema = "people.xsd";
+
+  people (cout, *ppl, map);
+}
+
+ +

The first modification the above application performs is iterating + over person records and incrementing the age value. This code + fragment shows how to modify the value of a required attribute + or element. The next modification shows how to set a new value + for the optional middle-name element as well + as clear its value. Finally the example adds a copy of the + John Doe record to the person element sequence.

+ +

Note that in this case using references for the ps, + john, and jane variables is no longer + a performance improvement but a requirement for the application + to function correctly. If we hadn't used references, all our changes + would have been made on copies without affecting the object model.

+ +

If we run the above application on our sample people.xml, + the output looks as follows:

+ + 
+<?xml version="1.0"?>
+<people xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+        xsi:noNamespaceSchemaLocation="people.xsd">
+
+  <person id="1">
+    <first-name>John</first-name>
+    <middle-name>Mary</middle-name>
+    <last-name>Doe</last-name>
+    <gender>male</gender>
+    <age>33</age>
+  </person>
+
+  <person id="2">
+    <first-name>Jane</first-name>
+    <last-name>Doe</last-name>
+    <gender>female</gender>
+    <age>29</age>
+  </person>
+
+  <person id="1">
+    <first-name>John</first-name>
+    <middle-name>Mary</middle-name>
+    <last-name>Doe</last-name>
+    <gender>male</gender>
+    <age>33</age>
+  </person>
+
+</people>
+
+ + +

4.4 Creating the Object Model from Scratch

+ +

In this section we will learn how to create a new object model + for our person records vocabulary. The following application + recreates the content of the original people.xml + file:

+ + 
+#include <iostream>
+#include "people.hxx"
+
+using namespace std;
+
+int
+main ()
+{
+  people_t ppl;
+  people_t::person_sequence& ps (ppl.person ());
+
+  // Add the John Doe record.
+  //
+  ps.push_back (
+    person_t ("John",         // first-name
+              "Doe",          // last-name
+              gender_t::male, // gender
+              32,             // age
+              1));
+
+  // Add the Jane Doe record.
+  //
+  ps.push_back (
+    person_t ("Jane",           // first-name
+              "Doe",            // last-name
+              gender_t::female, // gender
+              28,               // age
+              2));              // id
+
+  // Add middle name to the Jane Doe record.
+  //
+  person_t& jane (ps.back ());
+  jane.middle_name ("Mary");
+
+  // Serialize the object model to XML.
+  //
+  xml_schema::namespace_infomap map;
+  map[""].name = "";
+  map[""].schema = "people.xsd";
+
+  people (cout, ppl, map);
+}
+
+ +

The only new part in the above application is the calls + to the people_t and person_t + constructors. As a general rule, for each C++ class + XSD generates a constructor with initializers + for each element and attribute belonging to the one + cardinality class. For our vocabulary, the following + constructors are generated:

+ + 
+class person_t
+{
+  person_t (const first_name_type&,
+            const last_name_type&,
+            const gender_type&,
+            const age_type&,
+            const id_type&);
+};
+
+class people_t
+{
+  people_t ();
+};
+
+ +

Note also that we set the middle-name element + on the Jane Doe record by obtaining a reference to that record + in the object model and setting the middle-name + value on it. This is a general rule that should be followed + in order to obtain the best performance: if possible, + direct modifications to the object model should be preferred + to modifications on temporaries with subsequent copying. The + following code fragment shows a semantically equivalent but + slightly slower version:

+ + 
+// Add the Jane Doe record.
+//
+person_t jane ("Jane",           // first-name
+               "Doe",            // last-name
+               gender_t::female, // gender
+               28,               // age
+               2);               // id
+
+jane.middle_name ("Mary");
+
+ps.push_back (jane);
+
+ +

We can also go one step further to reduce copying and improve + the performance of our application by using the non-copying + push_back() function which assumes ownership + of the passed objects:

+ + 
+// Add the Jane Doe record. C++11 version
+//
+unique_ptr<person_t> jane_p (
+  new person_t ("Jane",           // first-name
+                "Doe",            // last-name
+                gender_t::female, // gender
+                28,               // age
+                2));              // id
+ps.push_back (std::move (jane_p)); // assumes ownership
+
+// Add the John Doe record. C++98 version.
+//
+auto_ptr<person_t> john_p (
+  new person_t ("John",           // first-name
+                "Doe",            // last-name
+                gender_t::male,   // gender
+                32,               // age
+                1));
+ps.push_back (john_p); // assumes ownership
+
+ +

For more information on the non-copying modifier functions refer to + Section + 2.8, "Mapping for Local Elements and Attributes" in the C++/Tree Mapping + User Manual. The above application produces the following output:

+ + 
+<?xml version="1.0" ?>
+<people xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+        xsi:noNamespaceSchemaLocation="people.xsd">
+
+  <person id="1">
+    <first-name>John</first-name>
+    <last-name>Doe</last-name>
+    <gender>male</gender>
+    <age>32</age>
+  </person>
+
+  <person id="2">
+    <first-name>Jane</first-name>
+    <middle-name>Mary</middle-name>
+    <last-name>Doe</last-name>
+    <gender>female</gender>
+    <age>28</age>
+  </person>
+
+</people>
+
+ +

4.5 Mapping for the Built-in XML Schema Types

+ +

Our person record vocabulary uses several built-in XML Schema + types: string, short, and + unsignedInt. Until now we haven't talked about + the mapping of built-in XML Schema types to C++ types and how + to work with them. This section provides an overview + of the built-in types. For more detailed information refer + to Section + 2.5, "Mapping for Built-in Data Types" in the C++/Tree Mapping + User Manual.

+ +

In XML Schema, built-in types are defined in the XML Schema namespace. + By default, the C++/Tree mapping maps this namespace to C++ + namespace xml_schema (this mapping can be altered + with the --namespace-map option). The following table + summarizes the mapping of XML Schema built-in types to C++ types:

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
XML Schema typeAlias in the xml_schema namespaceC++ type
fixed-length integral types
bytebytesigned char
unsignedByteunsigned_byteunsigned char
shortshort_short
unsignedShortunsigned_shortunsigned short
intint_int
unsignedIntunsigned_intunsigned int
longlong_long long
unsignedLongunsigned_longunsigned long long
arbitrary-length integral types
integerintegerlong long
nonPositiveIntegernon_positive_integerlong long
nonNegativeIntegernon_negative_integerunsigned long long
positiveIntegerpositive_integerunsigned long long
negativeIntegernegative_integerlong long
boolean types
booleanbooleanbool
fixed-precision floating-point types
floatfloat_float
doubledouble_double
arbitrary-precision floating-point types
decimaldecimaldouble
string types
stringstringtype derived from std::basic_string
normalizedStringnormalized_stringtype derived from string
tokentokentype derived from normalized_string
Namenametype derived from token
NMTOKENnmtokentype derived from token
NMTOKENSnmtokenstype derived from sequence<nmtoken>
NCNamencnametype derived from name
languagelanguagetype derived from token
qualified name
QNameqnamexml_schema::qname
ID/IDREF types
IDidtype derived from ncname
IDREFidreftype derived from ncname
IDREFSidrefstype derived from sequence<idref>
URI types
anyURIuritype derived from std::basic_string
binary types
base64Binarybase64_binaryxml_schema::base64_binary
hexBinaryhex_binaryxml_schema::hex_binary
date/time types
datedatexml_schema::date
dateTimedate_timexml_schema::date_time
durationdurationxml_schema::duration
gDaygdayxml_schema::gday
gMonthgmonthxml_schema::gmonth
gMonthDaygmonth_dayxml_schema::gmonth_day
gYeargyearxml_schema::gyear
gYearMonthgyear_monthxml_schema::gyear_month
timetimexml_schema::time
entity types
ENTITYentitytype derived from name
ENTITIESentitiestype derived from sequence<entity>
+ +

As you can see from the table above a number of built-in + XML Schema types are mapped to fundamental C++ types such + as int or bool. All string-based + XML Schema types are mapped to C++ types that are derived + from either std::string or + std::wstring, depending on the character + type selected. For access and modification purposes these + types can be treated as std::string. A number + of built-in types, such as qname, the binary + types, and the date/time types do not have suitable + fundamental or standard C++ types to map to. As a result, + these types are implemented from scratch in the XSD runtime. + For more information on their interfaces refer to + Section + 2.5, "Mapping for Built-in Data Types" in the C++/Tree Mapping + User Manual.

+ + + + + +

5 Parsing

+ +

We have already seen how to parse XML to an object model in this guide + before. In this chapter we will discuss the parsing topic in more + detail.

+ +

By default, the C++/Tree mapping provides a total of 14 overloaded + parsing functions. They differ in the input methods used to + read XML as well as the error reporting mechanisms. It is also possible + to generate types for root elements instead of parsing and serialization + functions. This may be useful if your XML vocabulary has multiple + root elements. For more information on element types refer to + Section + 2.9, "Mapping for Global Elements" in the C++/Tree Mapping User + Manual.

+ + +

In this section we will discuss the most commonly used versions of + the parsing functions. For a comprehensive description of parsing + refer to Chapter + 3, "Parsing" in the C++/Tree Mapping User Manual. For the people + global element from our person record vocabulary, we will concentrate + on the following three parsing functions:

+ + 
+std::[unique|auto]_ptr<people_t>
+people (const std::string& uri,
+	xml_schema::flags f = 0,
+	const xml_schema::properties& p = xml_schema::properties ());
+
+std::[unique|auto]_ptr<people_t>
+people (std::istream& is,
+        xml_schema::flags f = 0,
+        const xml_schema::properties& p = xml_schema::properties ());
+
+std::[unique|auto]_ptr<people_t>
+people (std::istream& is,
+        const std::string& resource_id,
+        xml_schema::flags f = 0,
+        const xml_schema::properties& p = ::xml_schema::properties ());
+
+ +

The first function parses a local file or a URI. We have already + used this parsing function in the previous chapters. The second + and third functions read XML from a standard input stream. The + last function also requires a resource id. This id is used to + identify the XML document being parser in diagnostics messages + as well as to resolve relative paths to other documents (for example, + schemas) that might be referenced from the XML document.

+ +

The last two arguments to all three parsing functions are parsing + flags and properties. The flags argument provides a number of ways + to fine-tune the parsing process. The properties argument allows + to pass additional information to the parsing functions. We will + use these two arguments in Section 5.1, "XML Schema + Validation and Searching" below. All three functions return + the object model as either std::unique_ptr (C++11) or + std::auto_ptr (C++98), depending on the C++ standard + selected (--std XSD compiler option). The following + example shows how we can use the above parsing functions:

+ + 
+using std::unique_ptr;
+
+// Parse a local file or URI.
+//
+unique_ptr<people_t> p1 (people ("people.xml"));
+unique_ptr<people_t> p2 (people ("http://example.com/people.xml"));
+
+// Parse a local file via ifstream.
+//
+std::ifstream ifs ("people.xml");
+unique_ptr<people_t> p3 (people (ifs, "people.xml"));
+
+// Parse an XML string.
+//
+std::string str ("..."); // XML in a string.
+std::istringstream iss (str);
+unique_ptr<people_t> p4 (people (iss));
+
+ + +

5.1 XML Schema Validation and Searching

+ +

The C++/Tree mapping relies on the underlying Xerces-C++ XML + parser for full XML document validation. The XML Schema + validation is enabled by default and can be disabled by + passing the xml_schema::flags::dont_validate + flag to the parsing functions, for example:

+ + 
+unique_ptr<people_t> p (
+  people ("people.xml", xml_schema::flags::dont_validate));
+
+ +

Even when XML Schema validation is disabled, the generated + code still performs a number of checks to prevent + construction of an inconsistent object model (for example, an + object model with missing required attributes or elements).

+ +

When XML Schema validation is enabled, the XML parser needs + to locate a schema to validate against. There are several + methods to provide the schema location information to the + parser. The easiest and most commonly used method is to + specify schema locations in the XML document itself + with the schemaLocation or + noNamespaceSchemaLocation attributes, for example:

+ + 
+<?xml version="1.0" ?>
+<people xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+        xsi:noNamespaceSchemaLocation="people.xsd"
+        xsi:schemaLocation="http://www.w3.org/XML/1998/namespace xml.xsd">
+
+ +

As you might have noticed, we used this method in all the sample XML + documents presented in this guide up until now. Note that the + schema locations specified with these two attributes are relative + to the document's path unless they are absolute URIs (that is + start with http://, file://, etc.). + In particular, if you specify just file names as your schema + locations, as we did above, then the schemas should reside in + the same directory as the XML document itself.

+ +

Another method of providing the schema location information + is via the xml_schema::properties argument, as + shown in the following example:

+ + 
+xml_schema::properties props;
+props.no_namespace_schema_location ("people.xsd");
+props.schema_location ("http://www.w3.org/XML/1998/namespace", "xml.xsd");
+
+unique_ptr<people_t> p (people ("people.xml", 0, props));
+
+ +

The schema locations provided with this method overrides + those specified in the XML document. As with the previous + method, the schema locations specified this way are + relative to the document's path unless they are absolute URIs. + In particular, if you want to use local schemas that are + not related to the document being parsed, then you will + need to use the file:// URI. The following + example shows how to use schemas that reside in the current + working directory:

+ + 
+#include <unistd.h> // getcwd
+#include <limits.h> // PATH_MAX
+
+char cwd[PATH_MAX];
+if (getcwd (cwd, PATH_MAX) == 0)
+{
+  // Buffer too small?
+}
+
+xml_schema::properties props;
+
+props.no_namespace_schema_location (
+  "file:///" + std::string (cwd) + "/people.xsd");
+
+props.schema_location (
+  "http://www.w3.org/XML/1998/namespace",
+  "file:///" + std::string (cwd) + "/xml.xsd");
+
+unique_ptr<people_t> p (people ("people.xml", 0, props));
+
+ +

A third method is the most useful if you are planning to parse + several XML documents of the same vocabulary. In that case + it may be beneficial to pre-parse and cache the schemas in + the XML parser which can then be used to parse all documents + without re-parsing the schemas. For more information on + this method refer to the caching example in the + cxx/tree/ directory in the + xsd-examples package. + It is also possible to convert the schemas into a pre-compiled + binary representation and embed this representation directly into + the application executable. With this approach your application can + perform XML Schema validation without depending on any external + schema files. For more information on how to achieve this refer to + the embedded example in the cxx/tree/ + directory in the xsd-examples + package.

+ +

When the XML parser cannot locate a schema for the + XML document, the validation fails and XML document + elements and attributes for which schema definitions could + not be located are reported in the diagnostics. For + example, if we remove the noNamespaceSchemaLocation + attribute in people.xml from the previous chapter, + then we will get the following diagnostics if we try to parse + this file with validation enabled:

+ + 
+people.xml:2:63 error: no declaration found for element 'people'
+people.xml:4:18 error: no declaration found for element 'person'
+people.xml:4:18 error: attribute 'id' is not declared for element 'person'
+people.xml:5:17 error: no declaration found for element 'first-name'
+people.xml:6:18 error: no declaration found for element 'middle-name'
+people.xml:7:16 error: no declaration found for element 'last-name'
+people.xml:8:13 error: no declaration found for element 'gender'
+people.xml:9:10 error: no declaration found for element 'age'
+
+ +

5.2 Error Handling

+ +

The parsing functions offer a number of ways to handle error conditions + with the C++ exceptions being the most commonly used mechanism. All + C++/Tree exceptions derive from common base xml_schema::exception + which in turn derives from std::exception. The easiest + way to uniformly handle all possible C++/Tree exceptions and print + detailed information about the error is to catch and print + xml_schema::exception, as shown in the following + example:

+ + 
+try
+{
+  unique_ptr<people_t> p (people ("people.xml"));
+}
+catch (const xml_schema::exception& e)
+{
+  cerr << e << endl;
+}
+
+ +

Each individual C++/Tree exception also allows you to obtain + error details programmatically. For example, the + xml_schema::parsing exception is thrown when + the XML parsing and validation in the underlying XML parser + fails. It encapsulates various diagnostics information + such as the file name, line and column numbers, as well as the + error or warning message for each entry. For more information + about this and other exceptions that can be thrown during + parsing, refer to + Section + 3.3, "Error Handling" in the C++/Tree Mapping + User Manual.

+ +

Note that if you are parsing std::istream on which + exceptions are not enabled, then you will need to check the + stream state after the call to the parsing function in order + to detect any possible stream failures, for example:

+ + 
+std::ifstream ifs ("people.xml");
+
+if (ifs.fail ())
+{
+  cerr << "people.xml: unable to open" << endl;
+  return 1;
+}
+
+unique_ptr<people_t> p (people (ifs, "people.xml"));
+
+if (ifs.fail ())
+{
+  cerr << "people.xml: read error" << endl;
+  return 1;
+}
+
+ +

The above example can be rewritten to use exceptions as + shown below:

+ + 
+try
+{
+  std::ifstream ifs;
+  ifs.exceptions (std::ifstream::badbit | std::ifstream::failbit);
+  ifs.open ("people.xml");
+
+  unique_ptr<people_t> p (people (ifs, "people.xml"));
+}
+catch (const std::ifstream::failure&)
+{
+  cerr << "people.xml: unable to open or read error" << endl;
+  return 1;
+}
+
+ + + + + +

6 Serialization

+ +

We have already seen how to serialize an object model back to XML + in this guide before. In this chapter we will discuss the + serialization topic in more detail.

+ +

By default, the C++/Tree mapping provides a total of 8 overloaded + serialization functions. They differ in the output methods used to write + XML as well as the error reporting mechanisms. It is also possible to + generate types for root elements instead of parsing and serialization + functions. This may be useful if your XML vocabulary has multiple + root elements. For more information on element types refer to + Section + 2.9, "Mapping for Global Elements" in the C++/Tree Mapping User + Manual.

+ + +

In this section we will discuss the most commonly + used version of serialization functions. For a comprehensive description + of serialization refer to + Chapter + 4, "Serialization" in the C++/Tree Mapping User Manual. For the + people global element from our person record vocabulary, + we will concentrate on the following serialization function:

+ + 
+void
+people (std::ostream& os,
+        const people_t& x,
+        const xml_schema::namespace_infomap& map =
+          xml_schema::namespace_infomap (),
+        const std::string& encoding = "UTF-8",
+        xml_schema::flags f = 0);
+
+ +

This function serializes the object model passed as the second + argument to the standard output stream passed as the first + argument. The third argument is a namespace information map + which we will discuss in more detail in the next section. + The fourth argument is a character encoding that the resulting + XML document should be in. Possible valid values for this + argument are "US-ASCII", "ISO8859-1", "UTF-8", "UTF-16BE", + "UTF-16LE", "UCS-4BE", and "UCS-4LE". Finally, the flags + argument allows fine-tuning of the serialization process. + The following example shows how we can use the above serialization + function:

+ + 
+people_t& p = ...
+
+xml_schema::namespace_infomap map;
+map[""].schema = "people.xsd";
+
+// Serialize to stdout.
+//
+people (std::cout, p, map);
+
+// Serialize to a file.
+//
+std::ofstream ofs ("people.xml");
+people (ofs, p, map);
+
+// Serialize to a string.
+//
+std::ostringstream oss;
+people (oss, p, map);
+std::string xml (oss.str ());
+
+ + +

6.1 Namespace and Schema Information

+ +

While XML serialization can be done just from the object + model alone, it is often desirable to assign meaningful + prefixes to XML namespaces used in the vocabulary as + well as to provide the schema location information. + This is accomplished by passing the namespace information + map to the serialization function. The key in this map is + a namespace prefix that should be assigned to an XML namespace + specified in the name variable of the + map value. You can also assign an optional schema location for + this namespace in the schema variable. Based + on each key-value entry in this map, the serialization + function adds two attributes to the resulting XML document: + the namespace-prefix mapping attribute and schema location + attribute. The empty prefix indicates that the namespace + should be mapped without a prefix. For example, the following + map:

+ + 
+xml_schema::namespace_infomap map;
+
+map[""].name = "http://www.example.com/example";
+map[""].schema = "example.xsd";
+
+map["x"].name = "http://www.w3.org/XML/1998/namespace";
+map["x"].schema = "xml.xsd";
+
+ +

Results in the following XML document:

+ + 
+<?xml version="1.0" ?>
+<example
+  xmlns="http://www.example.com/example"
+  xmlns:x="http://www.w3.org/XML/1998/namespace"
+  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xsi:schemaLocation="http://www.example.com/example example.xsd
+                      http://www.w3.org/XML/1998/namespace xml.xsd">
+
+ +

The empty namespace indicates that the vocabulary has no target + namespace. For example, the following map results in only the + noNamespaceSchemaLocation attribute being added:

+ + 
+xml_schema::namespace_infomap map;
+
+map[""].name = "";
+map[""].schema = "example.xsd";
+
+ +

6.2 Error Handling

+ +

Similar to the parsing functions, the serialization functions offer a + number of ways to handle error conditions with the C++ exceptions being + the most commonly used mechanisms. As with parsing, the easiest way to + uniformly handle all possible serialization exceptions and print + detailed information about the error is to catch and print + xml_schema::exception:

+ + 
+try
+{
+  people_t& p = ...
+
+  xml_schema::namespace_infomap map;
+  map[""].schema = "people.xsd";
+
+  people (std::cout, p, map));
+}
+catch (const xml_schema::exception& e)
+{
+  cerr << e << endl;
+}
+
+ +

The most commonly encountered serialization exception is + xml_schema::serialization. It is thrown + when the XML serialization in the underlying XML writer + fails. It encapsulates various diagnostics information + such as the file name, line and column numbers, as well as the + error or warning message for each entry. For more information + about this and other exceptions that can be thrown during + serialization, refer to + Section + 4.4, "Error Handling" in the C++/Tree Mapping + User Manual.

+ +

Note that if you are serializing to std::ostream on + which exceptions are not enabled, then you will need to check the + stream state after the call to the serialization function in order + to detect any possible stream failures, for example:

+ + 
+std::ofstream ofs ("people.xml");
+
+if (ofs.fail ())
+{
+  cerr << "people.xml: unable to open" << endl;
+  return 1;
+}
+
+people (ofs, p, map));
+
+if (ofs.fail ())
+{
+  cerr << "people.xml: write error" << endl;
+  return 1;
+}
+
+ +

The above example can be rewritten to use exceptions as + shown below:

+ + 
+try
+{
+  std::ofstream ofs;
+  ofs.exceptions (std::ofstream::badbit | std::ofstream::failbit);
+  ofs.open ("people.xml");
+
+  people (ofs, p, map));
+}
+catch (const std::ofstream::failure&)
+{
+  cerr << "people.xml: unable to open or write error" << endl;
+  return 1;
+}
+
+ +
+
+ + + diff --git a/doc/cxx/tree/guide/index.xhtml.in b/doc/cxx/tree/guide/index.xhtml.in new file mode 100644 index 0000000..2f7f1e2 --- /dev/null +++ b/doc/cxx/tree/guide/index.xhtml.in @@ -0,0 +1,2736 @@ + + + + + + C++/Tree Mapping Getting Started Guide + + + + + + + + + + + + + +
+
+ +
+ +
+
C++/Tree Mapping
+
Getting Started Guide
+ +

Copyright © @copyright@.

+ +

Permission is granted to copy, distribute and/or modify this + document under the terms of the + GNU Free + Documentation License, version 1.2; with no Invariant Sections, + no Front-Cover Texts and no Back-Cover Texts. +

+ +

This document is available in the following formats: + XHTML, + PDF, and + PostScript.

+ +
+ +

Table of Contents

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Preface + + + +
About This Document
More Information
+
1Introduction + + + +
1.1Mapping Overview
1.2Benefits
+
2Hello World Example + + + + + + + + +
2.1Writing XML Document and Schema
2.2Translating Schema to C++
2.3Implementing Application Logic
2.4Compiling and Running
2.5Adding Serialization
2.6Selecting Naming Convention
2.7Generating Documentation
+
3Overall Mapping Configuration + + + + + + +
3.1C++ Standard
3.2Character Type and Encoding
3.3Support for Polymorphism
3.4Namespace Mapping
3.5Thread Safety
+
4Working with Object Models + + + + + + +
4.1Attribute and Element Cardinalities
4.2Accessing the Object Model
4.3Modifying the Object Model
4.4Creating the Object Model from Scratch
4.5Mapping for the Built-in XML Schema Types
+
5Parsing + + + +
5.1XML Schema Validation and Searching
5.2Error Handling
+
6Serialization + + + +
6.1Namespace and Schema Information
6.2Error Handling
+
+
+ +

Preface

+ +

About This Document

+ +

The goal of this document is to provide you with an understanding of + the C++/Tree programming model and allow you to efficiently evaluate + XSD against your project's technical requirements. As such, this + document is intended for C++ developers and software architects + who are looking for an XML processing solution. For a more in-depth + description of the C++/Tree mapping refer to the + C++/Tree + Mapping User Manual.

+ +

Prior experience with XML and C++ is required to understand this + document. Basic understanding of XML Schema is advantageous but + not expected or required. +

+ + +

More Information

+ +

Beyond this guide, you may also find the following sources of + information useful:

+ + + + + +

1 Introduction

+ +

Welcome to CodeSynthesis XSD and the C++/Tree mapping. XSD is a + cross-platform W3C XML Schema to C++ data binding compiler. C++/Tree + is a W3C XML Schema to C++ mapping that represents the data stored + in XML as a statically-typed, vocabulary-specific object model. +

+ +

1.1 Mapping Overview

+ +

Based on a formal description of an XML vocabulary (schema), the + C++/Tree mapping produces a tree-like data structure suitable for + in-memory processing. The core of the mapping consists of C++ + classes that constitute the object model and are derived from + types defined in XML Schema as well as XML parsing and + serialization code.

+ +

Besides the core features, C++/Tree provide a number of additional + mapping elements that can be useful in some applications. These + include serialization and extraction to/from formats others than + XML, such as unstructured text (useful for debugging) and binary + representations such as XDR and CDR for high-speed data processing + as well as automatic documentation generation. The C++/Tree mapping + also provides a wide range of mechanisms for controlling and + customizing the generated code.

+ +

A typical application that uses C++/Tree for XML processing usually + performs the following three steps: it first reads (parses) an XML + document to an in-memory object model, it then performs some useful + computations on that object model which may involve modification + of the model, and finally it may write (serialize) the modified + object model back to XML.

+ +

The next chapter presents a simple application that performs these + three steps. The following chapters show how to use the C++/Tree + mapping in more detail.

+ +

1.2 Benefits

+ +

Traditional XML access APIs such as Document Object Model (DOM) + or Simple API for XML (SAX) have a number of drawbacks that + make them less suitable for creating robust and maintainable + XML processing applications. These drawbacks include: +

+ +
    +
  • Generic representation of XML in terms of elements, attributes, + and text forces an application developer to write a substantial + amount of bridging code that identifies and transforms pieces + of information encoded in XML to a representation more suitable + for consumption by the application logic.
    • + +
  • String-based flow control defers error detection to runtime. + It also reduces code readability and maintainability.
    • + +
  • Lack of type safety because the data is represented as text.
    • + +
  • Resulting applications are hard to debug, change, and + maintain.
    • +
+ +

In contrast, statically-typed, vocabulary-specific object model + produced by the C++/Tree mapping allows you to operate in your + domain terms instead of the generic elements, attributes, and + text. Static typing helps catch errors at compile-time rather + than at run-time. Automatic code generation frees you for more + interesting tasks (such as doing something useful with the + information stored in the XML documents) and minimizes the + effort needed to adapt your applications to changes in the + document structure. To summarize, the C++/Tree object model has + the following key advantages over generic XML access APIs:

+ +
    +
  • Ease of use. The generated code hides all the complexity + associated with parsing and serializing XML. This includes navigating + the structure and converting between the text representation and + data types suitable for manipulation by the application + logic.
    • + +
  • Natural representation. The object representation allows + you to access the XML data using your domain vocabulary instead + of generic elements, attributes, and text.
    • + +
  • Concise code. With the object representation the + application implementation is simpler and thus easier + to read and understand.
    • + +
  • Safety. The generated object model is statically + typed and uses functions instead of strings to access the + information. This helps catch programming errors at compile-time + rather than at runtime.
    • + +
  • Maintainability. Automatic code generation minimizes the + effort needed to adapt the application to changes in the + document structure. With static typing, the C++ compiler + can pin-point the places in the client code that need to be + changed.
    • + +
  • Compatibility. Sequences of elements are represented in + the object model as containers conforming to the standard C++ + sequence requirements. This makes it possible to use standard + C++ algorithms on the object representation and frees you from + learning yet another container interface, as is the case with + DOM.
    • + +
  • Efficiency. If the application makes repetitive use + of the data extracted from XML, then the C++/Tree object model + is more efficient because the navigation is performed using + function calls rather than string comparisons and the XML + data is extracted only once. Furthermore, the runtime memory + usage is reduced due to more efficient data storage + (for instance, storing numeric data as integers instead of + strings) as well as the static knowledge of cardinality + constraints.
    • +
+ + + + + +

2 Hello World Example

+ +

In this chapter we will examine how to parse, access, modify, and + serialize a very simple XML document using the XSD-generated + C++/Tree object model. The code presented in this chapter is + based on the hello example which can be found in + the cxx/tree/ directory in the + xsd-examples package.

+ +

2.1 Writing XML Document and Schema

+ +

First, we need to get an idea about the structure + of the XML documents we are going to process. Our + hello.xml, for example, could look like this:

+ + 
+<?xml version="1.0"?>
+<hello>
+
+  <greeting>Hello</greeting>
+
+  <name>sun</name>
+  <name>moon</name>
+  <name>world</name>
+
+</hello>
+
+ +

Then we can write a description of the above XML in the + XML Schema language and save it into hello.xsd:

+ + 
+<?xml version="1.0"?>
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+
+  <xs:complexType name="hello_t">
+    <xs:sequence>
+      <xs:element name="greeting" type="xs:string"/>
+      <xs:element name="name" type="xs:string" maxOccurs="unbounded"/>
+    </xs:sequence>
+  </xs:complexType>
+
+  <xs:element name="hello" type="hello_t"/>
+
+</xs:schema>
+
+ +

Even if you are not familiar with XML Schema, it + should be easy to connect declarations in hello.xsd + to elements in hello.xml. The hello_t type + is defined as a sequence of the nested greeting and + name elements. Note that the term sequence in XML + Schema means that elements should appear in a particular order + as opposed to appearing multiple times. The name + element has its maxOccurs property set to + unbounded which means it can appear multiple times + in an XML document. Finally, the globally-defined hello + element prescribes the root element for our vocabulary. For an + easily-approachable introduction to XML Schema refer to + XML Schema Part 0: + Primer.

+ +

The above schema is a specification of our XML vocabulary; it tells + everybody what valid documents of our XML-based language should look + like. We can also update our hello.xml to include the + information about the schema so that XML parsers can validate + our document:

+ + 
+<?xml version="1.0"?>
+<hello xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+       xsi:noNamespaceSchemaLocation="hello.xsd">
+
+  <greeting>Hello</greeting>
+
+  <name>sun</name>
+  <name>moon</name>
+  <name>world</name>
+
+</hello>
+
+ + +

The next step is to compile the schema to generate the object + model and parsing functions.

+ +

2.2 Translating Schema to C++

+ +

Now we are ready to translate our hello.xsd to C++. + To do this we invoke the XSD compiler from a terminal (UNIX) or + a command prompt (Windows): +

+ + 
+$ xsd cxx-tree hello.xsd
+
+ +

The XSD compiler produces two C++ files: hello.hxx and + hello.cxx. The following code fragment is taken from + hello.hxx; it should give you an idea about what gets + generated: +

+ + 
+class hello_t
+{
+public:
+  // greeting
+  //
+  typedef xml_schema::string greeting_type;
+
+  const greeting_type&
+  greeting () const;
+
+  greeting_type&
+  greeting ();
+
+  void
+  greeting (const greeting_type& x);
+
+  // name
+  //
+  typedef xml_schema::string name_type;
+  typedef xsd::sequence<name_type> name_sequence;
+  typedef name_sequence::iterator name_iterator;
+  typedef name_sequence::const_iterator name_const_iterator;
+
+  const name_sequence&
+  name () const;
+
+  name_sequence&
+  name ();
+
+  void
+  name (const name_sequence& s);
+
+  // Constructor.
+  //
+  hello_t (const greeting_type&);
+
+  ...
+
+};
+
+std::unique_ptr<hello_t>
+hello (const std::string& uri);
+
+std::unique_ptr<hello_t>
+hello (std::istream&);
+
+ +

The hello_t C++ class corresponds to the + hello_t XML Schema type. For each element + in this type a set of C++ type definitions as well as + accessor and modifier functions are generated inside the + hello_t class. Note that the type definitions + and member functions for the greeting and + name elements are different because of the + cardinality differences between these two elements + (greeting is a required single element and + name is a sequence of elements).

+ +

The xml_schema::string type used in the type + definitions is a C++ class provided by the XSD runtime + that corresponds to built-in XML Schema type + string. The xml_schema::string + is based on std::string and can be used as + such. Similarly, the sequence class template + that is used in the name_sequence type + definition is based on and has the same interface as + std::vector. The mapping between the built-in + XML Schema types and C++ types is described in more detail in + Section 4.5, "Mapping for the Built-in XML Schema + Types". The hello_t class also includes a + constructor with an initializer for the required + greeting element as its argument.

+ +

The hello overloaded global functions correspond + to the hello global element in XML Schema. A + global element in XML Schema is a valid document root. + By default XSD generated a set of parsing functions for each + global element defined in XML Schema (this can be overridden + with the --root-element-* options). Parsing + functions return a dynamically allocated object model as an + automatic pointer. The actual pointer used depends on the + C++ standard selected. For C++11 it is std::unique_ptr + as shown above. For C++98 it is std::auto_ptr. + For example, if we modify our XSD compiler invocation to + select C++98:

+ + 
+$ xsd cxx-tree --std c++98 hello.xsd
+
+ +

Then the parsing function signatures will become:

+ + 
+std::auto_ptr<hello_t>
+hello (const std::string& uri);
+
+std::auto_ptr<hello_t>
+hello (std::istream&);
+
+ +

For more information on parsing functions see Chapter 5, + "Parsing".

+ +

2.3 Implementing Application Logic

+ +

At this point we have all the parts we need to do something useful + with the information stored in our XML document: +

+ + 
+#include <iostream>
+#include "hello.hxx"
+
+using namespace std;
+
+int
+main (int argc, char* argv[])
+{
+  try
+  {
+    unique_ptr<hello_t> h (hello (argv[1]));
+
+    for (hello_t::name_const_iterator i (h->name ().begin ());
+         i != h->name ().end ();
+         ++i)
+    {
+      cerr << h->greeting () << ", " << *i << "!" << endl;
+    }
+  }
+  catch (const xml_schema::exception& e)
+  {
+    cerr << e << endl;
+    return 1;
+  }
+}
+
+ +

The first part of our application calls one of the parsing + functions to parser an XML file specified in the command line. + We then use the returned object model to iterate over names + and print a greeting line for each of them. Finally, we + catch and print the xml_schema::exception + exception in case something goes wrong. This exception + is the root of the exception hierarchy used by the + XSD-generated code. +

+ + +

2.4 Compiling and Running

+ +

After saving our application from the previous section in + driver.cxx, we are ready to compile our first + program and run it on the test XML document. On a UNIX + system this can be done with the following commands: +

+ + 
+$ c++ -std=c++11 -I.../libxsd -c driver.cxx hello.cxx
+$ c++ -std=c++11 -o driver driver.o hello.o -lxerces-c
+$ ./driver hello.xml
+Hello, sun!
+Hello, moon!
+Hello, world!
+
+ +

Here .../libxsd represents the path to the + libxsd package root + directory. Note also that we are required to link our + application with the Xerces-C++ library because the generated + code uses it as the underlying XML parser.

+ +

2.5 Adding Serialization

+ +

While parsing and accessing the XML data may be everything + you need, there are applications that require creating new + or modifying existing XML documents. By default XSD does + not produce serialization code. We will need to request + it with the --generate-serialization options:

+ + 
+$ xsd cxx-tree --generate-serialization hello.xsd
+
+ +

If we now examine the generated hello.hxx file, + we will find a set of overloaded serialization functions, + including the following version:

+ + 
+void
+hello (std::ostream&,
+       const hello_t&,
+       const xml_schema::namespace_infomap& =
+         xml_schema::namespace_infomap ());
+
+
+ +

Just like with parsing functions, XSD generates serialization + functions for each global element unless instructed otherwise + with one of the --root-element-* options. For more + information on serialization functions see Chapter 6, + "Serialization".

+ +

We first examine an application that modifies an existing + object model and serializes it back to XML:

+ + 
+#include <iostream>
+#include "hello.hxx"
+
+using namespace std;
+
+int
+main (int argc, char* argv[])
+{
+  try
+  {
+    unique_ptr<hello_t> h (hello (argv[1]));
+
+    // Change the greeting phrase.
+    //
+    h->greeting ("Hi");
+
+    // Add another entry to the name sequence.
+    //
+    h->name ().push_back ("mars");
+
+    // Serialize the modified object model to XML.
+    //
+    xml_schema::namespace_infomap map;
+    map[""].name = "";
+    map[""].schema = "hello.xsd";
+
+    hello (cout, *h, map);
+  }
+  catch (const xml_schema::exception& e)
+  {
+    cerr << e << endl;
+    return 1;
+  }
+}
+
+ +

First, our application parses an XML document and obtains its + object model as in the previous example. Then it changes the + greeting string and adds another entry to the list of names. + Finally, it serializes the object model back to XML by calling + the serialization function.

+ +

The first argument we pass to the serialization function is + cout which results in the XML being written to + the standard output for us to inspect. We could have also + written the result to a file or memory buffer by creating an + instance of std::ofstream or std::ostringstream + and passing it instead of cout. The second argument is the + object model we want to serialize. The final argument is an optional + namespace information map for our vocabulary. It captures information + such as namespaces, namespace prefixes to which they should be mapped, + and schemas associated with these namespaces. If we don't provide + this argument then generic namespace prefixes (p1, + p2, etc.) will be automatically assigned to XML namespaces + and no schema information will be added to the resulting document + (see Chapter 6, "Serialization" for details). + In our case, the prefix (map key) and namespace name are empty + because our vocabulary does not use XML namespaces.

+ +

If we now compile and run this application we will see the + output as shown in the following listing:

+ + 
+<?xml version="1.0"?>
+<hello xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+       xsi:noNamespaceSchemaLocation="hello.xsd">
+
+  <greeting>Hi</greeting>
+
+  <name>sun</name>
+  <name>moon</name>
+  <name>world</name>
+  <name>mars</name>
+
+</hello>
+
+ +

We can also create and serialize an object model from scratch + as shown in the following example:

+ + 
+#include <iostream>
+#include <fstream>
+#include "hello.hxx"
+
+using namespace std;
+
+int
+main (int argc, char* argv[])
+{
+  try
+  {
+    hello_t h ("Hi");
+
+    hello_t::name_sequence& ns (h.name ());
+
+    ns.push_back ("Jane");
+    ns.push_back ("John");
+
+    // Serialize the object model to XML.
+    //
+    xml_schema::namespace_infomap map;
+    map[""].name = "";
+    map[""].schema = "hello.xsd";
+
+    std::ofstream ofs (argv[1]);
+    hello (ofs, h, map);
+  }
+  catch (const xml_schema::exception& e)
+  {
+    cerr << e << endl;
+    return 1;
+  }
+}
+
+ +

In this example we used the generated constructor to create + an instance of type hello_t. To reduce typing, + we obtained a reference to the name sequence which we then + used to add a few names. The serialization part is identical + to the previous example except this time we are writing to + a file. If we compile and run this program, it produces the + following XML file:

+ + 
+<?xml version="1.0"?>
+<hello xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+       xsi:noNamespaceSchemaLocation="hello.xsd">
+
+  <greeting>Hi</greeting>
+
+  <name>Jane</name>
+  <name>John</name>
+
+</hello>
+
+ +

2.6 Selecting Naming Convention

+ +

By default XSD uses the so-called K&R (Kernighan and Ritchie) + identifier naming convention in the generated code. In this + convention both type and function names are in lower case and + words are separated by underscores. If your application code or + schemas use a different notation, you may want to change the + naming convention used in the generated code for consistency. + XSD supports a set of widely-used naming conventions + that you can select with the --type-naming and + --function-naming options. You can also further + refine one of the predefined conventions or create a completely + custom naming scheme by using the --*-regex options.

+ +

As an example, let's assume that our "Hello World" application + uses the so-called upper-camel-case naming convention for types + (that is, each word in a type name is capitalized) and the K&R + convention for function names. Since K&R is the default + convention for both type and function names, we only need to + change the type naming scheme:

+ + 
+$ xsd cxx-tree --type-naming ucc hello.xsd
+
+ +

The ucc argument to the --type-naming + options stands for upper-camel-case. If we now examine the + generated hello.hxx, we will see the following + changes compared to the declarations shown in the previous + sections:

+ + 
+class Hello_t
+{
+public:
+  // greeting
+  //
+  typedef xml_schema::String GreetingType;
+
+  const GreetingType&
+  greeting () const;
+
+  GreetingType&
+  greeting ();
+
+  void
+  greeting (const GreetingType& x);
+
+  // name
+  //
+  typedef xml_schema::String NameType;
+  typedef xsd::sequence<NameType> NameSequence;
+  typedef NameSequence::iterator NameIterator;
+  typedef NameSequence::const_iterator NameConstIterator;
+
+  const NameSequence&
+  name () const;
+
+  NameSequence&
+  name ();
+
+  void
+  name (const NameSequence& s);
+
+  // Constructor.
+  //
+  Hello_t (const GreetingType&);
+
+  ...
+
+};
+
+std::unique_ptr<Hello_t>
+hello (const std::string& uri);
+
+std::unique_ptr<Hello_t>
+hello (std::istream&);
+
+ +

Notice that the type names in the xml_schema namespace, + for example xml_schema::String, now also use the + upper-camel-case naming convention. The only thing that we may + be unhappy about in the above code is the _t + suffix in Hello_t. If we are not in a position + to change the schema, we can touch-up the ucc + convention with a custom translation rule using the + --type-regex option:

+ + 
+$ xsd cxx-tree --type-naming ucc --type-regex '/ (.+)_t/\u$1/' hello.xsd
+
+ +

This results in the following changes to the generated code:

+ + 
+class Hello
+{
+public:
+  // greeting
+  //
+  typedef xml_schema::String GreetingType;
+
+  const GreetingType&
+  greeting () const;
+
+  GreetingType&
+  greeting ();
+
+  void
+  greeting (const GreetingType& x);
+
+  // name
+  //
+  typedef xml_schema::String NameType;
+  typedef xsd::sequence<NameType> NameSequence;
+  typedef NameSequence::iterator NameIterator;
+  typedef NameSequence::const_iterator NameConstIterator;
+
+  const NameSequence&
+  name () const;
+
+  NameSequence&
+  name ();
+
+  void
+  name (const NameSequence& s);
+
+  // Constructor.
+  //
+  Hello (const GreetingType&);
+
+  ...
+
+};
+
+std::unique_ptr<Hello>
+hello (const std::string& uri);
+
+std::unique_ptr<Hello>
+hello (std::istream&);
+
+ +

For more detailed information on the --type-naming, + --function-naming, --type-regex, and + other --*-regex options refer to the NAMING + CONVENTION section in the XSD + Compiler Command Line Manual.

+ +

2.7 Generating Documentation

+ +

While our object model is quite simple, real-world vocabularies + can be quite complex with hundreds of types, elements, and + attributes. For such vocabularies figuring out which types + provide which member functions by studying the generated + source code or schemas can be a daunting task. To provide + application developers with a more accessible way of + understanding the generated object models, the XSD compiler + can be instructed to produce source code with documentation + comments in the Doxygen format. Then the source code can be + processed with the Doxygen + documentation system to extract this information and produce + documentation in various formats. +

+ +

In this section we will see how to generate documentation + for our "Hello World" vocabulary. To showcase the full power + of the XSD documentation facilities, we will first document + our schema. The XSD compiler will then transfer + this information from the schema to the generated code and + then to the object model documentation. Note that the + documentation in the schema is not required for XSD to + generate useful documentation. Below you will find + our hello.xsd with added documentation:

+ + 
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+
+  <xs:complexType name="hello_t">
+
+    <xs:annotation>
+      <xs:documentation>
+        The hello_t type consists of a greeting phrase and a
+        collection of names to which this greeting applies.
+      </xs:documentation>
+    </xs:annotation>
+
+    <xs:sequence>
+
+      <xs:element name="greeting" type="xs:string">
+        <xs:annotation>
+          <xs:documentation>
+            The greeting element contains the greeting phrase
+            for this hello object.
+          </xs:documentation>
+        </xs:annotation>
+      </xs:element>
+
+      <xs:element name="name" type="xs:string" maxOccurs="unbounded">
+        <xs:annotation>
+          <xs:documentation>
+            The name elements contains names to be greeted.
+          </xs:documentation>
+        </xs:annotation>
+      </xs:element>
+
+    </xs:sequence>
+  </xs:complexType>
+
+  <xs:element name="hello" type="hello_t">
+    <xs:annotation>
+      <xs:documentation>
+        The hello element is a root of the Hello XML vocabulary.
+        Every conforming document should start with this element.
+      </xs:documentation>
+    </xs:annotation>
+  </xs:element>
+
+</xs:schema>
+
+ +

The first step in obtaining the documentation is to recompile + our schema with the --generate-doxygen option:

+ + 
+$ xsd cxx-tree --generate-serialization --generate-doxygen hello.xsd
+
+ +

Now the generated hello.hxx file contains comments + in the Doxygen format. The next step is to process this file + with the Doxygen documentation system. If your project does + not use Doxygen then you first need to create a configuration + file for your project:

+ + 
+$ doxygen -g hello.doxygen
+
+ +

You only need to perform this step once. Now we can generate + the documentation by executing the following command in the + directory with the generated source code:

+ + 
+$ doxygen hello.doxygen
+
+ +

While the generated documentation can be useful as is, we can + go one step further and link (using the Doxygen tags mechanism) + the documentation for our object model with the documentation + for the XSD runtime library which defines C++ classes for the + built-in XML Schema types. This way we can seamlessly browse + between documentation for the hello_t class which + is generated by the XSD compiler and the xml_schema::string + class which is defined in the XSD runtime library. The Doxygen + configuration file for the XSD runtime is provided with the XSD + distribution.

+ +

You can view the result of the steps described in this section + on the Hello + Example Documentation page.

+ + + + +

3 Overall Mapping Configuration

+ +

The C++/Tree mapping has a number of configuration parameters that + determine the overall properties and behavior of the generated code. + Configuration parameters are specified with the XSD command line + options. This chapter describes configuration aspects that are most + commonly encountered by application developers. These include: the + C++ standard, the character type that is used by the generated code, + handling of vocabularies that use XML Schema polymorphism, XML Schema + to C++ namespace mapping, and thread safety. For more ways to configure + the generated code refer to the + XSD + Compiler Command Line Manual. +

+ +

3.1 C++ Standard

+ +

The C++/Tree mapping provides support for ISO/IEC C++ 2011 (C++11) + and ISO/IEC C++ 1998/2003 (C++98). To select the C++ standard for the + generated code we use the --std XSD compiler command + line option. While the majority of the examples in this guide use + C++11, the document explains the C++11/98 usage difference and so + they can easily be converted to C++98.

+ +

3.2 Character Type and Encoding

+ +

The C++/Tree mapping has built-in support for two character types: + char and wchar_t. You can select the + character type with the --char-type command line + option. The default character type is char. The + character type affects all string and string-based types that + are used in the mapping. These include the string-based built-in + XML Schema types, exception types, stream types, etc.

+ +

Another aspect of the mapping that depends on the character type + is character encoding. For the char character type + the default encoding is UTF-8. Other supported encodings are + ISO-8859-1, Xerces-C++ Local Code Page (LPC), as well as + custom encodings. You can select which encoding should be used + in the object model with the --char-encoding command + line option.

+ +

For the wchar_t character type the encoding is + automatically selected between UTF-16 and UTF-32/UCS-4 depending + on the size of the wchar_t type. On some platforms + (for example, Windows with Visual C++ and AIX with IBM XL C++) + wchar_t is 2 bytes long. For these platforms the + encoding is UTF-16. On other platforms wchar_t is 4 bytes + long and UTF-32/UCS-4 is used.

+ +

Note also that the character encoding that is used in the object model + is independent of the encodings used in input and output XML. In fact, + all three (object mode, input XML, and output XML) can have different + encodings.

+ +

3.3 Support for Polymorphism

+ +

By default XSD generates non-polymorphic code. If your vocabulary + uses XML Schema polymorphism in the form of xsi:type + and/or substitution groups, then you will need to compile + your schemas with the --generate-polymorphic option + to produce polymorphism-aware code. For more information on + working with polymorphic object models, refer to + Section 2.11, + "Mapping for xsi:type and Substitution Groups" in + the C++/Tree Mapping User Manual.

+ +

3.4 Namespace Mapping

+ +

XSD maps XML namespaces specified in the targetNamespace + attribute in XML Schema to one or more nested C++ namespaces. By + default, a namespace URI is mapped to a sequence of C++ namespace + names by removing the protocol and host parts and splitting the + rest into a sequence of names with '/' as the name + separator.

+ +

The default mapping of namespace URIs to C++ namespaces + can be altered using the --namespace-map and + --namespace-regex compiler options. For example, + to map namespace URI https://www.codesynthesis.com/my to + C++ namespace cs::my, we can use the following option:

+ + 
+--namespace-map https://www.codesynthesis.com/my=cs::my
+
+ +

A vocabulary without a namespace is mapped to the global scope. This + also can be altered with the above options by using an empty name + for the XML namespace:

+ + 
+--namespace-map =cs
+
+ +

3.5 Thread Safety

+ +

XSD-generated code is thread-safe in the sense that you can + use different instantiations of the object model in several + threads concurrently. This is possible due to the generated + code not relying on any writable global variables. If you need + to share the same object between several threads then you will + need to provide some form of synchronization. One approach would + be to use the generated code customization mechanisms to embed + synchronization primitives into the generated C++ classes. For more + information on generated code customization refer to the + C++/Tree + Mapping Customization Guide.

+ +

If you also would like to call parsing and/or serialization + functions from several threads potentially concurrently, then + you will need to make sure the Xerces-C++ runtime is initialized + and terminated only once. The easiest way to do this is to + initialize/terminate Xerces-C++ from main() when + there are no threads yet/anymore:

+ + 
+#include <xercesc/util/PlatformUtils.hpp>
+
+int
+main ()
+{
+  xercesc::XMLPlatformUtils::Initialize ();
+
+  {
+    // Start/terminate threads and parse/serialize here.
+  }
+
+  xercesc::XMLPlatformUtils::Terminate ();
+}
+
+ +

Because you initialize the Xerces-C++ runtime yourself you should + also pass the xml_schema::flags::dont_initialize flag + to parsing and serialization functions. See Chapter 5, + "Parsing" and Chapter 6, "Serialization" for + more information.

+ + + + + +

4 Working with Object Models

+ +

As we have seen in the previous chapters, the XSD compiler generates + a C++ class for each type defined in XML Schema. Together these classes + constitute an object model for an XML vocabulary. In this chapter we + will take a closer look at different elements that comprise an + object model class as well as how to create, access, and modify + object models.

+ +

In this and subsequent chapters we will use the following schema + that describes a collection of person records. We save it in + people.xsd:

+ + 
+<?xml version="1.0"?>
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+
+  <xs:simpleType name="gender_t">
+    <xs:restriction base="xs:string">
+      <xs:enumeration value="male"/>
+      <xs:enumeration value="female"/>
+    </xs:restriction>
+  </xs:simpleType>
+
+  <xs:complexType name="person_t">
+    <xs:sequence>
+      <xs:element name="first-name" type="xs:string"/>
+      <xs:element name="middle-name" type="xs:string" minOccurs="0"/>
+      <xs:element name="last-name" type="xs:string"/>
+      <xs:element name="gender" type="gender_t"/>
+      <xs:element name="age" type="xs:short"/>
+    </xs:sequence>
+    <xs:attribute name="id" type="xs:unsignedInt" use="required"/>
+  </xs:complexType>
+
+  <xs:complexType name="people_t">
+    <xs:sequence>
+      <xs:element name="person" type="person_t" maxOccurs="unbounded"/>
+    </xs:sequence>
+  </xs:complexType>
+
+  <xs:element name="people" type="people_t"/>
+
+</xs:schema>
+
+ +

A sample XML instance to go along with this schema is saved + in people.xml:

+ + 
+<?xml version="1.0"?>
+<people xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+        xsi:noNamespaceSchemaLocation="people.xsd">
+
+  <person id="1">
+    <first-name>John</first-name>
+    <last-name>Doe</last-name>
+    <gender>male</gender>
+    <age>32</age>
+  </person>
+
+  <person id="2">
+    <first-name>Jane</first-name>
+    <middle-name>Mary</middle-name>
+    <last-name>Doe</last-name>
+    <gender>female</gender>
+    <age>28</age>
+  </person>
+
+</people>
+
+ +

Compiling people.xsd with the XSD compiler results + in three generated C++ classes: gender_t, + person_t, and people_t. + The gender_t class is modelled after the C++ + enum type. Its definition is presented below:

+ + 
+class gender_t: public xml_schema::string
+{
+public:
+  enum value
+  {
+    male,
+    female
+  };
+
+  gender_t (value);
+  gender_t (const xml_schema::string&);
+
+  gender_t&
+  operator= (value);
+
+  operator value () const;
+};
+
+ +

The following listing shows how we can use this type:

+ + 
+gender_t m (gender_t::male);
+gender_t f ("female");
+
+if (m == "female" || f == gender_t::male)
+{
+  ...
+}
+
+switch (m)
+{
+case gender_t::male:
+  {
+    ...
+  }
+case gender_t::female:
+  {
+    ...
+  }
+}
+
+ +

The other two classes will be examined in detail in the subsequent + sections.

+ +

4.1 Attribute and Element Cardinalities

+ +

As we have seen in the previous chapters, XSD generates a different + set of type definitions and member functions for elements with + different cardinalities. The C++/Tree mapping divides all the possible + element and attribute cardinalities into three cardinality classes: + one, optional, and sequence.

+ +

The one cardinality class covers all elements that should + occur exactly once as well as required attributes. In our + example, the first-name, last-name, + gender, and age elements as well as + the id attribute belong to this cardinality class. + The following code fragment shows type definitions as well as the + accessor and modifier functions that are generated for the + gender element in the person_t class:

+ + 
+class person_t
+{
+  // gender
+  //
+  typedef gender_t gender_type;
+
+  const gender_type&
+  gender () const;
+
+  gender_type&
+  gender ();
+
+  void
+  gender (const gender_type&);
+};
+
+ +

The gender_type type is an alias for the element's type. + The first two accessor functions return read-only (constant) and + read-write references to the element's value, respectively. The + modifier function sets the new value for the element.

+ +

The optional cardinality class covers all elements that + can occur zero or one time as well as optional attributes. In our + example, the middle-name element belongs to this + cardinality class. The following code fragment shows the type + definitions as well as the accessor and modifier functions that + are generated for this element in the person_t class:

+ + 
+class person_t
+{
+  // middle-name
+  //
+  typedef xml_schema::string middle_name_type;
+  typedef xsd::optional<middle_name_type> middle_name_optional;
+
+  const middle_name_optional&
+  middle_name () const;
+
+  middle_name_optional&
+  middle_name ();
+
+  void
+  middle_name (const middle_name_type&);
+
+  void
+  middle_name (const middle_name_optional&);
+};
+
+ +

As with the gender element, middle_name_type + is an alias for the element's type. The middle_name_optional + type is a container for the element's optional value. It can be queried + for the presence of the value using the present() function. + The value itself can be retrieved using the get() + accessor and set using the set() modifier. The container + can be reverted to the value not present state with the call to the + reset() function. The following example shows how we + can use this container:

+ + 
+person_t::middle_name_optional n ("John");
+
+if (n.present ())
+{
+  cout << n.get () << endl;
+}
+
+n.set ("Jane");
+n.reset ();
+
+ + +

Unlike the one cardinality class, the accessor functions + for the optional class return read-only (constant) and + read-write references to the container instead of the element's + value directly. The modifier functions set the new value for the + element.

+ +

Finally, the sequence cardinality class covers all elements + that can occur more than once. In our example, the + person element in the people_t type + belongs to this cardinality class. The following code fragment shows + the type definitions as well as the accessor and modifier functions + that are generated for this element in the people_t + class:

+ + 
+class people_t
+{
+  // person
+  //
+  typedef person_t person_type;
+  typedef xsd::sequence<person_type> person_sequence;
+  typedef person_sequence::iterator person_iterator;
+  typedef person_sequence::const_iterator person_const_iterator;
+
+  const person_sequence&
+  person () const;
+
+  person_sequence&
+  person ();
+
+  void
+  person (const person_sequence&);
+};
+
+ +

Identical to the other cardinality classes, person_type + is an alias for the element's type. The person_sequence + type is a sequence container for the element's values. It is based + on and has the same interface as std::vector and + therefore can be used in similar ways. The person_iterator + and person_const_iterator types are read-only + (constant) and read-write iterators for the person_sequence + container.

+ +

Similar to the optional cardinality class, the + accessor functions for the sequence class return + read-only (constant) and read-write references to the sequence + container. The modifier functions copies the entries from + the passed sequence.

+ +

C++/Tree is a "flattening" mapping in a sense that many levels of + nested compositors (choice and sequence), + all potentially with their own cardinalities, are in the end mapped + to a flat set of elements with one of the three cardinality classes + discussed above. While this results in a simple and easy to use API + for most types, in certain cases, the order of elements in the actual + XML documents is not preserved once parsed into the object model. To + overcome this limitation we can mark certain schema types, for which + content order is not sufficiently preserved, as ordered. For more + information on this functionality refer to + Section + 2.8.4, "Element Order" in the C++/Tree Mapping User Manual.

+ +

For complex schemas with many levels of nested compositors + (choice and sequence) it can also + be hard to deduce the cardinality class of a particular element. + The generated Doxygen documentation can greatly help with + this task. For each element and attribute the documentation + clearly identifies its cardinality class. Alternatively, you + can study the generated header files to find out the cardinality + class of a particular attribute or element.

+ +

In the next sections we will examine how to access and modify + information stored in an object model using accessor and modifier + functions described in this section.

+ +

4.2 Accessing the Object Model

+ +

In this section we will learn how to get to the information + stored in the object model for our person records vocabulary. + The following application accesses and prints the contents + of the people.xml file:

+ + 
+#include <iostream>
+#include "people.hxx"
+
+using namespace std;
+
+int
+main ()
+{
+  unique_ptr<people_t> ppl (people ("people.xml"));
+
+  // Iterate over individual person records.
+  //
+  people_t::person_sequence& ps (ppl->person ());
+
+  for (people_t::person_iterator i (ps.begin ()); i != ps.end (); ++i)
+  {
+    person_t& p (*i);
+
+    // Print names: first-name and last-name are required elements,
+    // middle-name is optional.
+    //
+    cout << "name:   " << p.first_name () << " ";
+
+    if (p.middle_name ().present ())
+      cout << p.middle_name ().get () << " ";
+
+    cout << p.last_name () << endl;
+
+    // Print gender, age, and id which are all required.
+    //
+    cout << "gender: " << p.gender () << endl
+         << "age:    " << p.age () << endl
+         << "id:     " << p.id () << endl
+         << endl;
+  }
+}
+
+ +

This code shows common patterns of accessing elements and attributes + with different cardinality classes. For the sequence element + (person in people_t) we first obtain a + reference to the container and then iterate over individual + records. The values of elements and attributes with the + one cardinality class (first-name, + last-name, gender, age, + and id) can be obtained directly by calling the + corresponding accessor functions. For the optional element + middle-name we first check if the value is present + and only then call get() to retrieve it.

+ +

Note that when we want to reduce typing by creating a variable + representing a fragment of the object model that we are currently + working with (ps and p above), we obtain + a reference to that fragment instead of making a potentially + expensive copy. This is generally a good rule to follow when + creating high-performance applications.

+ +

If we run the above application on our sample + people.xml, the output looks as follows:

+ + 
+name:   John Doe
+gender: male
+age:    32
+id:     1
+
+name:   Jane Mary Doe
+gender: female
+age:    28
+id:     2
+
+ + +

4.3 Modifying the Object Model

+ +

In this section we will learn how to modify the information + stored in the object model for our person records vocabulary. + The following application changes the contents of the + people.xml file:

+ + 
+#include <iostream>
+#include "people.hxx"
+
+using namespace std;
+
+int
+main ()
+{
+  unique_ptr<people_t> ppl (people ("people.xml"));
+
+  // Iterate over individual person records and increment
+  // the age.
+  //
+  people_t::person_sequence& ps (ppl->person ());
+
+  for (people_t::person_iterator i (ps.begin ()); i != ps.end (); ++i)
+  {
+    // Alternative way: i->age ()++;
+    //
+    i->age (i->age () + 1);
+  }
+
+  // Add middle-name to the first record and remove it from
+  // the second.
+  //
+  person_t& john (ps[0]);
+  person_t& jane (ps[1]);
+
+  john.middle_name ("Mary");
+  jane.middle_name ().reset ();
+
+  // Add another John record.
+  //
+  ps.push_back (john);
+
+  // Serialize the modified object model to XML.
+  //
+  xml_schema::namespace_infomap map;
+  map[""].name = "";
+  map[""].schema = "people.xsd";
+
+  people (cout, *ppl, map);
+}
+
+ +

The first modification the above application performs is iterating + over person records and incrementing the age value. This code + fragment shows how to modify the value of a required attribute + or element. The next modification shows how to set a new value + for the optional middle-name element as well + as clear its value. Finally the example adds a copy of the + John Doe record to the person element sequence.

+ +

Note that in this case using references for the ps, + john, and jane variables is no longer + a performance improvement but a requirement for the application + to function correctly. If we hadn't used references, all our changes + would have been made on copies without affecting the object model.

+ +

If we run the above application on our sample people.xml, + the output looks as follows:

+ + 
+<?xml version="1.0"?>
+<people xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+        xsi:noNamespaceSchemaLocation="people.xsd">
+
+  <person id="1">
+    <first-name>John</first-name>
+    <middle-name>Mary</middle-name>
+    <last-name>Doe</last-name>
+    <gender>male</gender>
+    <age>33</age>
+  </person>
+
+  <person id="2">
+    <first-name>Jane</first-name>
+    <last-name>Doe</last-name>
+    <gender>female</gender>
+    <age>29</age>
+  </person>
+
+  <person id="1">
+    <first-name>John</first-name>
+    <middle-name>Mary</middle-name>
+    <last-name>Doe</last-name>
+    <gender>male</gender>
+    <age>33</age>
+  </person>
+
+</people>
+
+ + +

4.4 Creating the Object Model from Scratch

+ +

In this section we will learn how to create a new object model + for our person records vocabulary. The following application + recreates the content of the original people.xml + file:

+ + 
+#include <iostream>
+#include "people.hxx"
+
+using namespace std;
+
+int
+main ()
+{
+  people_t ppl;
+  people_t::person_sequence& ps (ppl.person ());
+
+  // Add the John Doe record.
+  //
+  ps.push_back (
+    person_t ("John",         // first-name
+              "Doe",          // last-name
+              gender_t::male, // gender
+              32,             // age
+              1));
+
+  // Add the Jane Doe record.
+  //
+  ps.push_back (
+    person_t ("Jane",           // first-name
+              "Doe",            // last-name
+              gender_t::female, // gender
+              28,               // age
+              2));              // id
+
+  // Add middle name to the Jane Doe record.
+  //
+  person_t& jane (ps.back ());
+  jane.middle_name ("Mary");
+
+  // Serialize the object model to XML.
+  //
+  xml_schema::namespace_infomap map;
+  map[""].name = "";
+  map[""].schema = "people.xsd";
+
+  people (cout, ppl, map);
+}
+
+ +

The only new part in the above application is the calls + to the people_t and person_t + constructors. As a general rule, for each C++ class + XSD generates a constructor with initializers + for each element and attribute belonging to the one + cardinality class. For our vocabulary, the following + constructors are generated:

+ + 
+class person_t
+{
+  person_t (const first_name_type&,
+            const last_name_type&,
+            const gender_type&,
+            const age_type&,
+            const id_type&);
+};
+
+class people_t
+{
+  people_t ();
+};
+
+ +

Note also that we set the middle-name element + on the Jane Doe record by obtaining a reference to that record + in the object model and setting the middle-name + value on it. This is a general rule that should be followed + in order to obtain the best performance: if possible, + direct modifications to the object model should be preferred + to modifications on temporaries with subsequent copying. The + following code fragment shows a semantically equivalent but + slightly slower version:

+ + 
+// Add the Jane Doe record.
+//
+person_t jane ("Jane",           // first-name
+               "Doe",            // last-name
+               gender_t::female, // gender
+               28,               // age
+               2);               // id
+
+jane.middle_name ("Mary");
+
+ps.push_back (jane);
+
+ +

We can also go one step further to reduce copying and improve + the performance of our application by using the non-copying + push_back() function which assumes ownership + of the passed objects:

+ + 
+// Add the Jane Doe record. C++11 version
+//
+unique_ptr<person_t> jane_p (
+  new person_t ("Jane",           // first-name
+                "Doe",            // last-name
+                gender_t::female, // gender
+                28,               // age
+                2));              // id
+ps.push_back (std::move (jane_p)); // assumes ownership
+
+// Add the John Doe record. C++98 version.
+//
+auto_ptr<person_t> john_p (
+  new person_t ("John",           // first-name
+                "Doe",            // last-name
+                gender_t::male,   // gender
+                32,               // age
+                1));
+ps.push_back (john_p); // assumes ownership
+
+ +

For more information on the non-copying modifier functions refer to + Section + 2.8, "Mapping for Local Elements and Attributes" in the C++/Tree Mapping + User Manual. The above application produces the following output:

+ + 
+<?xml version="1.0" ?>
+<people xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+        xsi:noNamespaceSchemaLocation="people.xsd">
+
+  <person id="1">
+    <first-name>John</first-name>
+    <last-name>Doe</last-name>
+    <gender>male</gender>
+    <age>32</age>
+  </person>
+
+  <person id="2">
+    <first-name>Jane</first-name>
+    <middle-name>Mary</middle-name>
+    <last-name>Doe</last-name>
+    <gender>female</gender>
+    <age>28</age>
+  </person>
+
+</people>
+
+ +

4.5 Mapping for the Built-in XML Schema Types

+ +

Our person record vocabulary uses several built-in XML Schema + types: string, short, and + unsignedInt. Until now we haven't talked about + the mapping of built-in XML Schema types to C++ types and how + to work with them. This section provides an overview + of the built-in types. For more detailed information refer + to Section + 2.5, "Mapping for Built-in Data Types" in the C++/Tree Mapping + User Manual.

+ +

In XML Schema, built-in types are defined in the XML Schema namespace. + By default, the C++/Tree mapping maps this namespace to C++ + namespace xml_schema (this mapping can be altered + with the --namespace-map option). The following table + summarizes the mapping of XML Schema built-in types to C++ types:

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
XML Schema typeAlias in the xml_schema namespaceC++ type
fixed-length integral types
bytebytesigned char
unsignedByteunsigned_byteunsigned char
shortshort_short
unsignedShortunsigned_shortunsigned short
intint_int
unsignedIntunsigned_intunsigned int
longlong_long long
unsignedLongunsigned_longunsigned long long
arbitrary-length integral types
integerintegerlong long
nonPositiveIntegernon_positive_integerlong long
nonNegativeIntegernon_negative_integerunsigned long long
positiveIntegerpositive_integerunsigned long long
negativeIntegernegative_integerlong long
boolean types
booleanbooleanbool
fixed-precision floating-point types
floatfloat_float
doubledouble_double
arbitrary-precision floating-point types
decimaldecimaldouble
string types
stringstringtype derived from std::basic_string
normalizedStringnormalized_stringtype derived from string
tokentokentype derived from normalized_string
Namenametype derived from token
NMTOKENnmtokentype derived from token
NMTOKENSnmtokenstype derived from sequence<nmtoken>
NCNamencnametype derived from name
languagelanguagetype derived from token
qualified name
QNameqnamexml_schema::qname
ID/IDREF types
IDidtype derived from ncname
IDREFidreftype derived from ncname
IDREFSidrefstype derived from sequence<idref>
URI types
anyURIuritype derived from std::basic_string
binary types
base64Binarybase64_binaryxml_schema::base64_binary
hexBinaryhex_binaryxml_schema::hex_binary
date/time types
datedatexml_schema::date
dateTimedate_timexml_schema::date_time
durationdurationxml_schema::duration
gDaygdayxml_schema::gday
gMonthgmonthxml_schema::gmonth
gMonthDaygmonth_dayxml_schema::gmonth_day
gYeargyearxml_schema::gyear
gYearMonthgyear_monthxml_schema::gyear_month
timetimexml_schema::time
entity types
ENTITYentitytype derived from name
ENTITIESentitiestype derived from sequence<entity>
+ +

As you can see from the table above a number of built-in + XML Schema types are mapped to fundamental C++ types such + as int or bool. All string-based + XML Schema types are mapped to C++ types that are derived + from either std::string or + std::wstring, depending on the character + type selected. For access and modification purposes these + types can be treated as std::string. A number + of built-in types, such as qname, the binary + types, and the date/time types do not have suitable + fundamental or standard C++ types to map to. As a result, + these types are implemented from scratch in the XSD runtime. + For more information on their interfaces refer to + Section + 2.5, "Mapping for Built-in Data Types" in the C++/Tree Mapping + User Manual.

+ + + + + +

5 Parsing

+ +

We have already seen how to parse XML to an object model in this guide + before. In this chapter we will discuss the parsing topic in more + detail.

+ +

By default, the C++/Tree mapping provides a total of 14 overloaded + parsing functions. They differ in the input methods used to + read XML as well as the error reporting mechanisms. It is also possible + to generate types for root elements instead of parsing and serialization + functions. This may be useful if your XML vocabulary has multiple + root elements. For more information on element types refer to + Section + 2.9, "Mapping for Global Elements" in the C++/Tree Mapping User + Manual.

+ + +

In this section we will discuss the most commonly used versions of + the parsing functions. For a comprehensive description of parsing + refer to Chapter + 3, "Parsing" in the C++/Tree Mapping User Manual. For the people + global element from our person record vocabulary, we will concentrate + on the following three parsing functions:

+ + 
+std::[unique|auto]_ptr<people_t>
+people (const std::string& uri,
+	xml_schema::flags f = 0,
+	const xml_schema::properties& p = xml_schema::properties ());
+
+std::[unique|auto]_ptr<people_t>
+people (std::istream& is,
+        xml_schema::flags f = 0,
+        const xml_schema::properties& p = xml_schema::properties ());
+
+std::[unique|auto]_ptr<people_t>
+people (std::istream& is,
+        const std::string& resource_id,
+        xml_schema::flags f = 0,
+        const xml_schema::properties& p = ::xml_schema::properties ());
+
+ +

The first function parses a local file or a URI. We have already + used this parsing function in the previous chapters. The second + and third functions read XML from a standard input stream. The + last function also requires a resource id. This id is used to + identify the XML document being parser in diagnostics messages + as well as to resolve relative paths to other documents (for example, + schemas) that might be referenced from the XML document.

+ +

The last two arguments to all three parsing functions are parsing + flags and properties. The flags argument provides a number of ways + to fine-tune the parsing process. The properties argument allows + to pass additional information to the parsing functions. We will + use these two arguments in Section 5.1, "XML Schema + Validation and Searching" below. All three functions return + the object model as either std::unique_ptr (C++11) or + std::auto_ptr (C++98), depending on the C++ standard + selected (--std XSD compiler option). The following + example shows how we can use the above parsing functions:

+ + 
+using std::unique_ptr;
+
+// Parse a local file or URI.
+//
+unique_ptr<people_t> p1 (people ("people.xml"));
+unique_ptr<people_t> p2 (people ("http://example.com/people.xml"));
+
+// Parse a local file via ifstream.
+//
+std::ifstream ifs ("people.xml");
+unique_ptr<people_t> p3 (people (ifs, "people.xml"));
+
+// Parse an XML string.
+//
+std::string str ("..."); // XML in a string.
+std::istringstream iss (str);
+unique_ptr<people_t> p4 (people (iss));
+
+ + +

5.1 XML Schema Validation and Searching

+ +

The C++/Tree mapping relies on the underlying Xerces-C++ XML + parser for full XML document validation. The XML Schema + validation is enabled by default and can be disabled by + passing the xml_schema::flags::dont_validate + flag to the parsing functions, for example:

+ + 
+unique_ptr<people_t> p (
+  people ("people.xml", xml_schema::flags::dont_validate));
+
+ +

Even when XML Schema validation is disabled, the generated + code still performs a number of checks to prevent + construction of an inconsistent object model (for example, an + object model with missing required attributes or elements).

+ +

When XML Schema validation is enabled, the XML parser needs + to locate a schema to validate against. There are several + methods to provide the schema location information to the + parser. The easiest and most commonly used method is to + specify schema locations in the XML document itself + with the schemaLocation or + noNamespaceSchemaLocation attributes, for example:

+ + 
+<?xml version="1.0" ?>
+<people xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+        xsi:noNamespaceSchemaLocation="people.xsd"
+        xsi:schemaLocation="http://www.w3.org/XML/1998/namespace xml.xsd">
+
+ +

As you might have noticed, we used this method in all the sample XML + documents presented in this guide up until now. Note that the + schema locations specified with these two attributes are relative + to the document's path unless they are absolute URIs (that is + start with http://, file://, etc.). + In particular, if you specify just file names as your schema + locations, as we did above, then the schemas should reside in + the same directory as the XML document itself.

+ +

Another method of providing the schema location information + is via the xml_schema::properties argument, as + shown in the following example:

+ + 
+xml_schema::properties props;
+props.no_namespace_schema_location ("people.xsd");
+props.schema_location ("http://www.w3.org/XML/1998/namespace", "xml.xsd");
+
+unique_ptr<people_t> p (people ("people.xml", 0, props));
+
+ +

The schema locations provided with this method overrides + those specified in the XML document. As with the previous + method, the schema locations specified this way are + relative to the document's path unless they are absolute URIs. + In particular, if you want to use local schemas that are + not related to the document being parsed, then you will + need to use the file:// URI. The following + example shows how to use schemas that reside in the current + working directory:

+ + 
+#include <unistd.h> // getcwd
+#include <limits.h> // PATH_MAX
+
+char cwd[PATH_MAX];
+if (getcwd (cwd, PATH_MAX) == 0)
+{
+  // Buffer too small?
+}
+
+xml_schema::properties props;
+
+props.no_namespace_schema_location (
+  "file:///" + std::string (cwd) + "/people.xsd");
+
+props.schema_location (
+  "http://www.w3.org/XML/1998/namespace",
+  "file:///" + std::string (cwd) + "/xml.xsd");
+
+unique_ptr<people_t> p (people ("people.xml", 0, props));
+
+ +

A third method is the most useful if you are planning to parse + several XML documents of the same vocabulary. In that case + it may be beneficial to pre-parse and cache the schemas in + the XML parser which can then be used to parse all documents + without re-parsing the schemas. For more information on + this method refer to the caching example in the + cxx/tree/ directory in the + xsd-examples package. + It is also possible to convert the schemas into a pre-compiled + binary representation and embed this representation directly into + the application executable. With this approach your application can + perform XML Schema validation without depending on any external + schema files. For more information on how to achieve this refer to + the embedded example in the cxx/tree/ + directory in the xsd-examples + package.

+ +

When the XML parser cannot locate a schema for the + XML document, the validation fails and XML document + elements and attributes for which schema definitions could + not be located are reported in the diagnostics. For + example, if we remove the noNamespaceSchemaLocation + attribute in people.xml from the previous chapter, + then we will get the following diagnostics if we try to parse + this file with validation enabled:

+ + 
+people.xml:2:63 error: no declaration found for element 'people'
+people.xml:4:18 error: no declaration found for element 'person'
+people.xml:4:18 error: attribute 'id' is not declared for element 'person'
+people.xml:5:17 error: no declaration found for element 'first-name'
+people.xml:6:18 error: no declaration found for element 'middle-name'
+people.xml:7:16 error: no declaration found for element 'last-name'
+people.xml:8:13 error: no declaration found for element 'gender'
+people.xml:9:10 error: no declaration found for element 'age'
+
+ +

5.2 Error Handling

+ +

The parsing functions offer a number of ways to handle error conditions + with the C++ exceptions being the most commonly used mechanism. All + C++/Tree exceptions derive from common base xml_schema::exception + which in turn derives from std::exception. The easiest + way to uniformly handle all possible C++/Tree exceptions and print + detailed information about the error is to catch and print + xml_schema::exception, as shown in the following + example:

+ + 
+try
+{
+  unique_ptr<people_t> p (people ("people.xml"));
+}
+catch (const xml_schema::exception& e)
+{
+  cerr << e << endl;
+}
+
+ +

Each individual C++/Tree exception also allows you to obtain + error details programmatically. For example, the + xml_schema::parsing exception is thrown when + the XML parsing and validation in the underlying XML parser + fails. It encapsulates various diagnostics information + such as the file name, line and column numbers, as well as the + error or warning message for each entry. For more information + about this and other exceptions that can be thrown during + parsing, refer to + Section + 3.3, "Error Handling" in the C++/Tree Mapping + User Manual.

+ +

Note that if you are parsing std::istream on which + exceptions are not enabled, then you will need to check the + stream state after the call to the parsing function in order + to detect any possible stream failures, for example:

+ + 
+std::ifstream ifs ("people.xml");
+
+if (ifs.fail ())
+{
+  cerr << "people.xml: unable to open" << endl;
+  return 1;
+}
+
+unique_ptr<people_t> p (people (ifs, "people.xml"));
+
+if (ifs.fail ())
+{
+  cerr << "people.xml: read error" << endl;
+  return 1;
+}
+
+ +

The above example can be rewritten to use exceptions as + shown below:

+ + 
+try
+{
+  std::ifstream ifs;
+  ifs.exceptions (std::ifstream::badbit | std::ifstream::failbit);
+  ifs.open ("people.xml");
+
+  unique_ptr<people_t> p (people (ifs, "people.xml"));
+}
+catch (const std::ifstream::failure&)
+{
+  cerr << "people.xml: unable to open or read error" << endl;
+  return 1;
+}
+
+ + + + + +

6 Serialization

+ +

We have already seen how to serialize an object model back to XML + in this guide before. In this chapter we will discuss the + serialization topic in more detail.

+ +

By default, the C++/Tree mapping provides a total of 8 overloaded + serialization functions. They differ in the output methods used to write + XML as well as the error reporting mechanisms. It is also possible to + generate types for root elements instead of parsing and serialization + functions. This may be useful if your XML vocabulary has multiple + root elements. For more information on element types refer to + Section + 2.9, "Mapping for Global Elements" in the C++/Tree Mapping User + Manual.

+ + +

In this section we will discuss the most commonly + used version of serialization functions. For a comprehensive description + of serialization refer to + Chapter + 4, "Serialization" in the C++/Tree Mapping User Manual. For the + people global element from our person record vocabulary, + we will concentrate on the following serialization function:

+ + 
+void
+people (std::ostream& os,
+        const people_t& x,
+        const xml_schema::namespace_infomap& map =
+          xml_schema::namespace_infomap (),
+        const std::string& encoding = "UTF-8",
+        xml_schema::flags f = 0);
+
+ +

This function serializes the object model passed as the second + argument to the standard output stream passed as the first + argument. The third argument is a namespace information map + which we will discuss in more detail in the next section. + The fourth argument is a character encoding that the resulting + XML document should be in. Possible valid values for this + argument are "US-ASCII", "ISO8859-1", "UTF-8", "UTF-16BE", + "UTF-16LE", "UCS-4BE", and "UCS-4LE". Finally, the flags + argument allows fine-tuning of the serialization process. + The following example shows how we can use the above serialization + function:

+ + 
+people_t& p = ...
+
+xml_schema::namespace_infomap map;
+map[""].schema = "people.xsd";
+
+// Serialize to stdout.
+//
+people (std::cout, p, map);
+
+// Serialize to a file.
+//
+std::ofstream ofs ("people.xml");
+people (ofs, p, map);
+
+// Serialize to a string.
+//
+std::ostringstream oss;
+people (oss, p, map);
+std::string xml (oss.str ());
+
+ + +

6.1 Namespace and Schema Information

+ +

While XML serialization can be done just from the object + model alone, it is often desirable to assign meaningful + prefixes to XML namespaces used in the vocabulary as + well as to provide the schema location information. + This is accomplished by passing the namespace information + map to the serialization function. The key in this map is + a namespace prefix that should be assigned to an XML namespace + specified in the name variable of the + map value. You can also assign an optional schema location for + this namespace in the schema variable. Based + on each key-value entry in this map, the serialization + function adds two attributes to the resulting XML document: + the namespace-prefix mapping attribute and schema location + attribute. The empty prefix indicates that the namespace + should be mapped without a prefix. For example, the following + map:

+ + 
+xml_schema::namespace_infomap map;
+
+map[""].name = "http://www.example.com/example";
+map[""].schema = "example.xsd";
+
+map["x"].name = "http://www.w3.org/XML/1998/namespace";
+map["x"].schema = "xml.xsd";
+
+ +

Results in the following XML document:

+ + 
+<?xml version="1.0" ?>
+<example
+  xmlns="http://www.example.com/example"
+  xmlns:x="http://www.w3.org/XML/1998/namespace"
+  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xsi:schemaLocation="http://www.example.com/example example.xsd
+                      http://www.w3.org/XML/1998/namespace xml.xsd">
+
+ +

The empty namespace indicates that the vocabulary has no target + namespace. For example, the following map results in only the + noNamespaceSchemaLocation attribute being added:

+ + 
+xml_schema::namespace_infomap map;
+
+map[""].name = "";
+map[""].schema = "example.xsd";
+
+ +

6.2 Error Handling

+ +

Similar to the parsing functions, the serialization functions offer a + number of ways to handle error conditions with the C++ exceptions being + the most commonly used mechanisms. As with parsing, the easiest way to + uniformly handle all possible serialization exceptions and print + detailed information about the error is to catch and print + xml_schema::exception:

+ + 
+try
+{
+  people_t& p = ...
+
+  xml_schema::namespace_infomap map;
+  map[""].schema = "people.xsd";
+
+  people (std::cout, p, map));
+}
+catch (const xml_schema::exception& e)
+{
+  cerr << e << endl;
+}
+
+ +

The most commonly encountered serialization exception is + xml_schema::serialization. It is thrown + when the XML serialization in the underlying XML writer + fails. It encapsulates various diagnostics information + such as the file name, line and column numbers, as well as the + error or warning message for each entry. For more information + about this and other exceptions that can be thrown during + serialization, refer to + Section + 4.4, "Error Handling" in the C++/Tree Mapping + User Manual.

+ +

Note that if you are serializing to std::ostream on + which exceptions are not enabled, then you will need to check the + stream state after the call to the serialization function in order + to detect any possible stream failures, for example:

+ + 
+std::ofstream ofs ("people.xml");
+
+if (ofs.fail ())
+{
+  cerr << "people.xml: unable to open" << endl;
+  return 1;
+}
+
+people (ofs, p, map));
+
+if (ofs.fail ())
+{
+  cerr << "people.xml: write error" << endl;
+  return 1;
+}
+
+ +

The above example can be rewritten to use exceptions as + shown below:

+ + 
+try
+{
+  std::ofstream ofs;
+  ofs.exceptions (std::ofstream::badbit | std::ofstream::failbit);
+  ofs.open ("people.xml");
+
+  people (ofs, p, map));
+}
+catch (const std::ofstream::failure&)
+{
+  cerr << "people.xml: unable to open or write error" << endl;
+  return 1;
+}
+
+ +
+
+ + + diff --git a/doc/cxx/tree/manual/index.xhtml b/doc/cxx/tree/manual/index.xhtml new file mode 100644 index 0000000..f455bff --- /dev/null +++ b/doc/cxx/tree/manual/index.xhtml @@ -0,0 +1,6826 @@ + + + + + + C++/Tree Mapping User Manual + + + + + + + + + + + + + + +
+
+ +
+ +
+
C++/Tree Mapping User Manual
+ +

Copyright © 2005-2023 Code Synthesis.

+ +

Permission is granted to copy, distribute and/or modify this + document under the terms of the + GNU Free + Documentation License, version 1.2; with no Invariant Sections, + no Front-Cover Texts and no Back-Cover Texts. +

+ +

This document is available in the following formats: + XHTML, + PDF, and + PostScript.

+
+ +

Table of Contents

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Preface + + + +
About This Document
More Information
+
1Introduction
2C++/Tree Mapping + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
2.1Preliminary Information + + + + + + +
2.1.1C++ Standard
2.1.2Identifiers
2.1.3Character Type and Encoding
2.1.4XML Schema Namespace
2.1.5Anonymous Types
+
2.2Error Handling + + +
2.2.1xml_schema::duplicate_id
+
2.3Mapping for import and include + + + + +
2.3.1Import
2.3.2Inclusion with Target Namespace
2.3.3Inclusion without Target Namespace
+
2.4Mapping for Namespaces
2.5Mapping for Built-in Data Types + + + + + + + + + + + + + + + + + +
2.5.1Inheritance from Built-in Data Types
2.5.2Mapping for anyType
2.5.3Mapping for anySimpleType
2.5.4Mapping for QName
2.5.5Mapping for IDREF
2.5.6Mapping for base64Binary and hexBinary
2.5.7Time Zone Representation
2.5.8Mapping for date
2.5.9Mapping for dateTime
2.5.10Mapping for duration
2.5.11Mapping for gDay
2.5.12Mapping for gMonth
2.5.13Mapping for gMonthDay
2.5.14Mapping for gYear
2.5.15Mapping for gYearMonth
2.5.16Mapping for time
+
2.6Mapping for Simple Types + + + + + +
2.6.1Mapping for Derivation by Restriction
2.6.2Mapping for Enumerations
2.6.3Mapping for Derivation by List
2.6.4Mapping for Derivation by Union
+
2.7Mapping for Complex Types + + + +
2.7.1Mapping for Derivation by Extension
2.7.2Mapping for Derivation by Restriction
+
2.8Mapping for Local Elements and Attributes + + + + + +
2.8.1Mapping for Members with the One Cardinality Class
2.8.2Mapping for Members with the Optional Cardinality Class
2.8.3Mapping for Members with the Sequence Cardinality Class
2.8.4Element Order
+
2.9Mapping for Global Elements + + + +
2.9.1Element Types
2.9.2Element Map
+
2.10Mapping for Global Attributes
2.11Mapping for xsi:type and Substitution Groups
2.12Mapping for any and anyAttribute + + + + + + +
2.12.1Mapping for any with the One Cardinality Class
2.12.2Mapping for any with the Optional Cardinality Class
2.12.3Mapping for any with the Sequence Cardinality Class
2.12.4Element Wildcard Order
2.12.5Mapping for anyAttribute
+
2.13Mapping for Mixed Content Models
+
3Parsing + + + + + + + + + + + + + + + + + + + + + + +
3.1Initializing the Xerces-C++ Runtime
3.2Flags and Properties
3.3Error Handling + + + + + + + + + + +
3.3.1xml_schema::parsing
3.3.2xml_schema::expected_element
3.3.3xml_schema::unexpected_element
3.3.4xml_schema::expected_attribute
3.3.5xml_schema::unexpected_enumerator
3.3.6xml_schema::expected_text_content
3.3.7xml_schema::no_type_info
3.3.8xml_schema::not_derived
3.3.9xml_schema::not_prefix_mapping
+
3.4Reading from a Local File or URI
3.5Reading from std::istream
3.6Reading from xercesc::InputSource
3.7Reading from DOM
+
4Serialization + + + + + + + + + + + + + + + + + + + + + + +
4.1Initializing the Xerces-C++ Runtime
4.2Namespace Infomap and Character Encoding
4.3Flags
4.4Error Handling + + + + +
4.4.1xml_schema::serialization
4.4.2xml_schema::unexpected_element
4.4.3xml_schema::no_type_info
+
4.5Serializing to std::ostream
4.6Serializing to xercesc::XMLFormatTarget
4.7Serializing to DOM
+
5Additional Functionality + + + + + + + +
5.1DOM Association
5.2Binary Serialization
+
Appendix A — Default and Fixed Values
+
+ +

Preface

+ +

About This Document

+ +

This document describes the mapping of W3C XML Schema + to the C++ programming language as implemented by + CodeSynthesis + XSD - an XML Schema to C++ data binding compiler. The mapping + represents information stored in XML instance documents as a + statically-typed, tree-like in-memory data structure and is + called C++/Tree. +

+ +

Revision 4.1.0
+ This revision of the manual describes the C++/Tree + mapping as implemented by CodeSynthesis XSD version 4.1.0. +

+ +

This document is available in the following formats: + XHTML, + PDF, and + PostScript.

+ +

More Information

+ +

Beyond this manual, you may also find the following sources of + information useful:

+ + + + +

1 Introduction

+ +

C++/Tree is a W3C XML Schema to C++ mapping that represents the + data stored in XML as a statically-typed, vocabulary-specific + object model. Based on a formal description of an XML vocabulary + (schema), the C++/Tree mapping produces a tree-like data structure + suitable for in-memory processing as well as XML parsing and + serialization code.

+ +

A typical application that processes XML documents usually + performs the following three steps: it first reads (parses) an XML + instance document to an object model, it then performs + some useful computations on that model which may involve + modification of the model, and finally it may write (serialize) + the modified object model back to XML. +

+ +

The C++/Tree mapping consists of C++ types that represent the + given vocabulary (Chapter 2, "C++/Tree Mapping"), + a set of parsing functions that convert XML documents to + a tree-like in-memory data structure (Chapter 3, + "Parsing"), and a set of serialization functions that convert + the object model back to XML (Chapter 4, + "Serialization"). Furthermore, the mapping provides a number + of additional features, such as DOM association and binary + serialization, that can be useful in some applications + (Chapter 5, "Additional Functionality"). +

+ + + + + +

2 C++/Tree Mapping

+ +

2.1 Preliminary Information

+ +

2.1.1 C++ Standard

+ +

The C++/Tree mapping provides support for ISO/IEC C++ 2011 (C++11) + and ISO/IEC C++ 1998/2003 (C++98). To select the C++ standard for the + generated code we use the --std XSD compiler command + line option. While the majority of the examples in this guide use + C++11, the document explains the C++11/98 usage difference and so + they can easily be converted to C++98.

+ +

2.1.2 Identifiers

+ +

XML Schema names may happen to be reserved C++ keywords or contain + characters that are illegal in C++ identifiers. To avoid C++ compilation + problems, such names are changed (escaped) when mapped to C++. If an + XML Schema name is a C++ keyword, the "_" suffix is added to it. All + character of an XML Schema name that are not allowed in C++ identifiers + are replaced with "_". +

+ +

For example, XML Schema name try will be mapped to + C++ identifier try_. Similarly, XML Schema name + strange.na-me will be mapped to C++ identifier + strange_na_me. +

+ +

Furthermore, conflicts between type names and function names in the + same scope are resolved using name escaping. Such conflicts include + both a global element (which is mapped to a set of parsing and/or + serialization functions or element types, see Section + 2.9, "Mapping for Global Elements") and a global type sharing the + same name as well as a local element or attribute inside a type having + the same name as the type itself.

+ +

For example, if we had a global type catalog + and a global element with the same name then the type would be + mapped to a C++ class with name catalog while the + parsing functions corresponding to the global element would have + their names escaped as catalog_. +

+ +

By default the mapping uses the so-called K&R (Kernighan and + Ritchie) identifier naming convention which is also used throughout + this manual. In this convention both type and function names are in + lower case and words are separated by underscores. If your application + code or schemas use a different notation, you may want to change the + naming convention used by the mapping for consistency. + The compiler supports a set of widely-used naming conventions + that you can select with the --type-naming and + --function-naming options. You can also further + refine one of the predefined conventions or create a completely + custom naming scheme by using the --*-regex options. + For more detailed information on these options refer to the NAMING + CONVENTION section in the XSD + Compiler Command Line Manual.

+ +

2.1.3 Character Type and Encoding

+ +

The code that implements the mapping, depending on the + --char-type option, is generated using either + char or wchar_t as the character + type. In this document code samples use symbol C + to refer to the character type you have selected when translating + your schemas, for example std::basic_string<C>. +

+ +

Another aspect of the mapping that depends on the character type + is character encoding. For the char character type + the default encoding is UTF-8. Other supported encodings are + ISO-8859-1, Xerces-C++ Local Code Page (LPC), as well as + custom encodings and can be selected with the + --char-encoding command line option.

+ +

For the wchar_t character type the encoding is + automatically selected between UTF-16 and UTF-32/UCS-4 depending + on the size of the wchar_t type. On some platforms + (for example, Windows with Visual C++ and AIX with IBM XL C++) + wchar_t is 2 bytes long. For these platforms the + encoding is UTF-16. On other platforms wchar_t is 4 bytes + long and UTF-32/UCS-4 is used.

+ +

2.1.4 XML Schema Namespace

+ +

The mapping relies on some predefined types, classes, and functions + that are logically defined in the XML Schema namespace reserved for + the XML Schema language (http://www.w3.org/2001/XMLSchema). + By default, this namespace is mapped to C++ namespace + xml_schema. It is automatically accessible + from a C++ compilation unit that includes a header file generated + from an XML Schema definition. +

+ +

Note that, if desired, the default mapping of this namespace can be + changed as described in Section 2.4, "Mapping for + Namespaces". +

+ + +

2.1.5 Anonymous Types

+ +

For the purpose of code generation, anonymous types defined in + XML Schema are automatically assigned names that are derived + from enclosing attributes and elements. Otherwise, such types + follows standard mapping rules for simple and complex type + definitions (see Section 2.6, "Mapping for Simple Types" + and Section 2.7, "Mapping for Complex Types"). + For example, in the following schema fragment: +

+ + 
+<element name="object">
+  <complexType>
+    ...
+  </complexType>
+</element>
+
+ +

The anonymous type defined inside element object will + be given name object. The compiler has a number of + options that control the process of anonymous type naming. For more + information refer to the XSD + Compiler Command Line Manual.

+ + +

2.2 Error Handling

+ +

The mapping uses the C++ exception handling mechanism as a primary way + of reporting error conditions. All exceptions that are specified in + this mapping derive from xml_schema::exception which + itself is derived from std::exception: +

+ + 
+struct exception: virtual std::exception
+{
+  friend
+  std::basic_ostream<C>&
+  operator<< (std::basic_ostream<C>& os, const exception& e)
+  {
+    e.print (os);
+    return os;
+  }
+
+protected:
+  virtual void
+  print (std::basic_ostream<C>&) const = 0;
+};
+
+ +

The exception hierarchy supports "virtual" operator<< + which allows you to obtain diagnostics corresponding to the thrown + exception using the base exception interface. For example:

+ + 
+try
+{
+  ...
+}
+catch (const xml_schema::exception& e)
+{
+  cerr << e << endl;
+}
+
+ +

The following sub-sections describe exceptions thrown by the + types that constitute the object model. + Section 3.3, "Error Handling" of + Chapter 3, "Parsing" describes exceptions + and error handling mechanisms specific to the parsing functions. + Section 4.4, "Error Handling" of + Chapter 4, "Serialization" describes exceptions + and error handling mechanisms specific to the serialization functions. +

+ + +

2.2.1 xml_schema::duplicate_id

+ + 
+struct duplicate_id: virtual exception
+{
+  duplicate_id (const std::basic_string<C>& id);
+
+  const std::basic_string<C>&
+  id () const;
+
+  virtual const char*
+  what () const throw ();
+};
+
+ +

The xml_schema::duplicate_id is thrown when + a conflicting instance of xml_schema::id (see + Section 2.5, "Mapping for Built-in Data Types") + is added to a tree. The offending ID value can be obtained using + the id function. +

+ +

2.3 Mapping for import and include

+ +

2.3.1 Import

+ +

The XML Schema import element is mapped to the C++ + Preprocessor #include directive. The value of + the schemaLocation attribute is used to derive + the name of the header file that appears in the #include + directive. For instance: +

+ + 
+<import namespace="https://www.codesynthesis.com/test"
+        schemaLocation="test.xsd"/>
+
+ +

is mapped to:

+ + 
+#include "test.hxx"
+
+ +

Note that you will need to compile imported schemas separately + in order to produce corresponding header files.

+ +

2.3.2 Inclusion with Target Namespace

+ +

The XML Schema include element which refers to a schema + with a target namespace or appears in a schema without a target namespace + follows the same mapping rules as the import element, + see Section 2.3.1, "Import". +

+ +

2.3.3 Inclusion without Target Namespace

+ +

For the XML Schema include element which refers to a schema + without a target namespace and appears in a schema with a target + namespace (such inclusion sometimes called "chameleon inclusion"), + declarations and definitions from the included schema are generated + in-line in the namespace of the including schema as if they were + declared and defined there verbatim. For example, consider the + following two schemas: +

+ + 
+<-- common.xsd -->
+<schema>
+  <complexType name="type">
+  ...
+  </complexType>
+</schema>
+
+<-- test.xsd -->
+<schema targetNamespace="https://www.codesynthesis.com/test">
+  <include schemaLocation="common.xsd"/>
+</schema>
+
+ +

The fragment of interest from the generated header file for + text.xsd would look like this:

+ + 
+// test.hxx
+namespace test
+{
+  class type
+  {
+    ...
+  };
+}
+
+ +

2.4 Mapping for Namespaces

+ +

An XML Schema namespace is mapped to one or more nested C++ + namespaces. XML Schema namespaces are identified by URIs. + By default, a namespace URI is mapped to a sequence of + C++ namespace names by removing the protocol and host parts + and splitting the rest into a sequence of names with '/' + as the name separator. For instance: +

+ + 
+<schema targetNamespace="https://www.codesynthesis.com/system/test">
+  ...
+</schema>
+
+ +

is mapped to:

+ + 
+namespace system
+{
+  namespace test
+  {
+    ...
+  }
+}
+
+ +

The default mapping of namespace URIs to C++ namespace names can be + altered using the --namespace-map and + --namespace-regex options. See the + XSD + Compiler Command Line Manual for more information. +

+ +

2.5 Mapping for Built-in Data Types

+ +

The mapping of XML Schema built-in data types to C++ types is + summarized in the table below.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
XML Schema typeAlias in the xml_schema namespaceC++ type
anyType and anySimpleType types
anyTypetypeSection 2.5.2, "Mapping for anyType"
anySimpleTypesimple_typeSection 2.5.3, "Mapping for anySimpleType"
fixed-length integral types
bytebytesigned char
unsignedByteunsigned_byteunsigned char
shortshort_short
unsignedShortunsigned_shortunsigned short
intint_int
unsignedIntunsigned_intunsigned int
longlong_long long
unsignedLongunsigned_longunsigned long long
arbitrary-length integral types
integerintegerlong long
nonPositiveIntegernon_positive_integerlong long
nonNegativeIntegernon_negative_integerunsigned long long
positiveIntegerpositive_integerunsigned long long
negativeIntegernegative_integerlong long
boolean types
booleanbooleanbool
fixed-precision floating-point types
floatfloat_float
doubledouble_double
arbitrary-precision floating-point types
decimaldecimaldouble
string types
stringstringtype derived from std::basic_string
normalizedStringnormalized_stringtype derived from string
tokentokentype derived from normalized_string
Namenametype derived from token
NMTOKENnmtokentype derived from token
NMTOKENSnmtokenstype derived from sequence<nmtoken>
NCNamencnametype derived from name
languagelanguagetype derived from token
qualified name
QNameqnameSection 2.5.4, "Mapping for QName"
ID/IDREF types
IDidtype derived from ncname
IDREFidrefSection 2.5.5, "Mapping for IDREF"
IDREFSidrefstype derived from sequence<idref>
URI types
anyURIuritype derived from std::basic_string
binary types
base64Binarybase64_binarySection 2.5.6, "Mapping for + base64Binary and hexBinary"
hexBinaryhex_binary
date/time types
datedateSection 2.5.8, "Mapping for + date"
dateTimedate_timeSection 2.5.9, "Mapping for + dateTime"
durationdurationSection 2.5.10, "Mapping for + duration"
gDaygdaySection 2.5.11, "Mapping for + gDay"
gMonthgmonthSection 2.5.12, "Mapping for + gMonth"
gMonthDaygmonth_daySection 2.5.13, "Mapping for + gMonthDay"
gYeargyearSection 2.5.14, "Mapping for + gYear"
gYearMonthgyear_monthSection 2.5.15, "Mapping for + gYearMonth"
timetimeSection 2.5.16, "Mapping for + time"
entity types
ENTITYentitytype derived from name
ENTITIESentitiestype derived from sequence<entity>
+ +

All XML Schema built-in types are mapped to C++ classes that are + derived from the xml_schema::simple_type class except + where the mapping is to a fundamental C++ type.

+ +

The sequence class template is defined in an + implementation-specific namespace. It conforms to the + sequence interface as defined by the ISO/ANSI Standard for + C++ (ISO/IEC 14882:1998, Section 23.1.1, "Sequences"). + Practically, this means that you can treat such a sequence + as if it was std::vector. One notable extension + to the standard interface that is available only for + sequences of non-fundamental C++ types is the addition of + the overloaded push_back and insert + member functions which instead of the constant reference + to the element type accept automatic pointer (std::unique_ptr + or std::auto_ptr, depending on the C++ standard + selected) to the element type. These functions assume ownership + of the pointed to object and reset the passed automatic pointer. +

+ +

2.5.1 Inheritance from Built-in Data Types

+ +

In cases where the mapping calls for an inheritance from a built-in + type which is mapped to a fundamental C++ type, a proxy type is + used instead of the fundamental C++ type (C++ does not allow + inheritance from fundamental types). For instance:

+ + 
+<simpleType name="my_int">
+  <restriction base="int"/>
+</simpleType>
+
+ +

is mapped to:

+ + 
+class my_int: public fundamental_base<int>
+{
+  ...
+};
+
+ +

The fundamental_base class template provides a close + emulation (though not exact) of a fundamental C++ type. + It is defined in an implementation-specific namespace and has the + following interface:

+ + 
+template <typename X>
+class fundamental_base: public simple_type
+{
+public:
+  fundamental_base ();
+  fundamental_base (X)
+  fundamental_base (const fundamental_base&)
+
+public:
+  fundamental_base&
+  operator= (const X&);
+
+public:
+  operator const X & () const;
+  operator X& ();
+
+  template <typename Y>
+  operator Y () const;
+
+  template <typename Y>
+  operator Y ();
+};
+
+ +

2.5.2 Mapping for anyType

+ +

The XML Schema anyType built-in data type is mapped to the + xml_schema::type C++ class:

+ + 
+class type
+{
+public:
+  virtual
+  ~type ();
+
+  type ();
+  type (const type&);
+
+  type&
+  operator= (const type&);
+
+  virtual type*
+  _clone () const;
+
+  // anyType DOM content.
+  //
+public:
+  typedef element_optional dom_content_optional;
+
+  const dom_content_optional&
+  dom_content () const;
+
+  dom_content_optional&
+  dom_content ();
+
+  void
+  dom_content (const xercesc::DOMElement&);
+
+  void
+  dom_content (xercesc::DOMElement*);
+
+  void
+  dom_content (const dom_content_optional&);
+
+  const xercesc::DOMDocument&
+  dom_content_document () const;
+
+  xercesc::DOMDocument&
+  dom_content_document ();
+
+  bool
+  null_content () const;
+
+  // DOM association.
+  //
+public:
+  const xercesc::DOMNode*
+  _node () const;
+
+  xercesc::DOMNode*
+  _node ();
+};
+
+ +

When xml_schema::type is used to create an instance + (as opposed to being a base of a derived type), it represents + the XML Schema anyType type. anyType + allows any attributes and any content in any order. In the + C++/Tree mapping this content can be represented as a DOM + fragment, similar to XML Schema wildcards (Section + 2.12, "Mapping for any and + anyAttribute").

+ +

To enable automatic extraction of anyType content + during parsing, the --generate-any-type option must be + specified. Because the DOM API is used to access such content, the + Xerces-C++ runtime should be initialized by the application prior to + parsing and should remain initialized for the lifetime of objects + with the DOM content. For more information on the Xerces-C++ runtime + initialization see Section 3.1, "Initializing the + Xerces-C++ Runtime".

+ +

The DOM content is stored as the optional DOM element container + and the DOM content accessors and modifiers presented above are + identical to those generated for an optional element wildcard. + Refer to Section 2.12.2, "Mapping for any + with the Optional Cardinality Class" for details on their + semantics.

+ +

The dom_content_document() function returns the + DOM document used to store the raw XML content corresponding + to the anyType instance. It is equivalent to the + dom_document() function generated for types + with wildcards.

+ +

The null_content() accessor is an optimization function + that allows us to check for the lack of content without actually + creating its empty representation, that is, empty DOM document for + anyType or empty string for anySimpleType + (see the following section for details on anySimpleType).

+ +

For more information on DOM association refer to + Section 5.1, "DOM Association".

+ +

2.5.3 Mapping for anySimpleType

+ +

The XML Schema anySimpleType built-in data type is mapped + to the xml_schema::simple_type C++ class:

+ + 
+class simple_type: public type
+{
+public:
+  simple_type ();
+  simple_type (const C*);
+  simple_type (const std::basic_string<C>&);
+
+  simple_type (const simple_type&);
+
+  simple_type&
+  operator= (const simple_type&);
+
+  virtual simple_type*
+  _clone () const;
+
+  // anySimpleType text content.
+  //
+public:
+  const std::basic_string<C>&
+  text_content () const;
+
+  std::basic_string<C>&
+  text_content ();
+
+  void
+  text_content (const std::basic_string<C>&);
+};
+
+ +

When xml_schema::simple_type is used to create an instance + (as opposed to being a base of a derived type), it represents + the XML Schema anySimpleType type. anySimpleType + allows any simple content. In the C++/Tree mapping this content can + be represented as a string and accessed or modified with the + text_content() functions shown above.

+ +

2.5.4 Mapping for QName

+ +

The XML Schema QName built-in data type is mapped to the + xml_schema::qname C++ class:

+ + 
+class qname: public simple_type
+{
+public:
+  qname (const ncname&);
+  qname (const uri&, const ncname&);
+  qname (const qname&);
+
+public:
+  qname&
+  operator= (const qname&);
+
+public:
+  virtual qname*
+  _clone () const;
+
+public:
+  bool
+  qualified () const;
+
+  const uri&
+  namespace_ () const;
+
+  const ncname&
+  name () const;
+};
+
+ +

The qualified accessor function can be used to determine + if the name is qualified.

+ +

2.5.5 Mapping for IDREF

+ +

The XML Schema IDREF built-in data type is mapped to the + xml_schema::idref C++ class. This class implements the + smart pointer C++ idiom:

+ + 
+class idref: public ncname
+{
+public:
+  idref (const C* s);
+  idref (const C* s, std::size_t n);
+  idref (std::size_t n, C c);
+  idref (const std::basic_string<C>&);
+  idref (const std::basic_string<C>&,
+         std::size_t pos,
+         std::size_t n = npos);
+
+public:
+  idref (const idref&);
+
+public:
+  virtual idref*
+  _clone () const;
+
+public:
+  idref&
+  operator= (C c);
+
+  idref&
+  operator= (const C* s);
+
+  idref&
+  operator= (const std::basic_string<C>&)
+
+  idref&
+  operator= (const idref&);
+
+public:
+  const type*
+  operator-> () const;
+
+  type*
+  operator-> ();
+
+  const type&
+  operator* () const;
+
+  type&
+  operator* ();
+
+  const type*
+  get () const;
+
+  type*
+  get ();
+
+  // Conversion to bool.
+  //
+public:
+  typedef void (idref::*bool_convertible)();
+  operator bool_convertible () const;
+};
+
+ +

The object, idref instance refers to, is the immediate + container of the matching id instance. For example, + with the following instance document and schema: +

+ + + 
+<!-- test.xml -->
+<root>
+  <object id="obj-1" text="hello"/>
+  <reference>obj-1</reference>
+</root>
+
+<!-- test.xsd -->
+<schema>
+  <complexType name="object_type">
+    <attribute name="id" type="ID"/>
+    <attribute name="text" type="string"/>
+  </complexType>
+
+  <complexType name="root_type">
+    <sequence>
+      <element name="object" type="object_type"/>
+      <element name="reference" type="IDREF"/>
+    </sequence>
+  </complexType>
+
+  <element name="root" type="root_type"/>
+</schema>
+
+ +

The ref instance in the code below will refer to + an object of type object_type:

+ + 
+root_type& root = ...;
+xml_schema::idref& ref (root.reference ());
+object_type& obj (dynamic_cast<object_type&> (*ref));
+cout << obj.text () << endl;
+
+ +

The smart pointer interface of the idref class always + returns a pointer or reference to xml_schema::type. + This means that you will need to manually cast such pointer or + reference to its real (dynamic) type before you can use it (unless + all you need is the base interface provided by + xml_schema::type). As a special extension to the XML + Schema language, the mapping supports static typing of idref + references by employing the refType extension attribute. + The following example illustrates this mechanism: +

+ + 
+<!-- test.xsd -->
+<schema
+  xmlns:xse="https://www.codesynthesis.com/xmlns/xml-schema-extension">
+
+  ...
+
+      <element name="reference" type="IDREF" xse:refType="object_type"/>
+
+  ...
+
+</schema>
+
+ +

With this modification we do not need to do manual casting anymore: +

+ + 
+root_type& root = ...;
+root_type::reference_type& ref (root.reference ());
+object_type& obj (*ref);
+cout << ref->text () << endl;
+
+ + +

2.5.6 Mapping for base64Binary and + hexBinary

+ +

The XML Schema base64Binary and hexBinary + built-in data types are mapped to the + xml_schema::base64_binary and + xml_schema::hex_binary C++ classes, respectively. The + base64_binary and hex_binary classes + support a simple buffer abstraction by inheriting from the + xml_schema::buffer class: +

+ + 
+class bounds: public virtual exception
+{
+public:
+  virtual const char*
+  what () const throw ();
+};
+
+class buffer
+{
+public:
+  typedef std::size_t size_t;
+
+public:
+  buffer (size_t size = 0);
+  buffer (size_t size, size_t capacity);
+  buffer (const void* data, size_t size);
+  buffer (const void* data, size_t size, size_t capacity);
+  buffer (void* data,
+          size_t size,
+          size_t capacity,
+          bool assume_ownership);
+
+public:
+  buffer (const buffer&);
+
+  buffer&
+  operator= (const buffer&);
+
+  void
+  swap (buffer&);
+
+public:
+  size_t
+  capacity () const;
+
+  bool
+  capacity (size_t);
+
+public:
+  size_t
+  size () const;
+
+  bool
+  size (size_t);
+
+public:
+  const char*
+  data () const;
+
+  char*
+  data ();
+
+  const char*
+  begin () const;
+
+  char*
+  begin ();
+
+  const char*
+  end () const;
+
+  char*
+  end ();
+};
+
+ +

The last overloaded constructor reuses an existing data buffer instead + of making a copy. If the assume_ownership argument is + true, the instance assumes ownership of the + memory block pointed to by the data argument and will + eventually release it by calling operator delete. The + capacity and size modifier functions return + true if the underlying buffer has moved. +

+ +

The bounds exception is thrown if the constructor + arguments violate the (size <= capacity) + constraint.

+ +

The base64_binary and hex_binary classes + support the buffer interface and perform automatic + decoding/encoding from/to the Base64 and Hex formats, respectively: +

+ + 
+class base64_binary: public simple_type, public buffer
+{
+public:
+  base64_binary (size_t size = 0);
+  base64_binary (size_t size, size_t capacity);
+  base64_binary (const void* data, size_t size);
+  base64_binary (const void* data, size_t size, size_t capacity);
+  base64_binary (void* data,
+                 size_t size,
+                 size_t capacity,
+                 bool assume_ownership);
+
+public:
+  base64_binary (const base64_binary&);
+
+  base64_binary&
+  operator= (const base64_binary&);
+
+  virtual base64_binary*
+  _clone () const;
+
+public:
+  std::basic_string<C>
+  encode () const;
+};
+
+ + 
+class hex_binary: public simple_type, public buffer
+{
+public:
+  hex_binary (size_t size = 0);
+  hex_binary (size_t size, size_t capacity);
+  hex_binary (const void* data, size_t size);
+  hex_binary (const void* data, size_t size, size_t capacity);
+  hex_binary (void* data,
+              size_t size,
+              size_t capacity,
+              bool assume_ownership);
+
+public:
+  hex_binary (const hex_binary&);
+
+  hex_binary&
+  operator= (const hex_binary&);
+
+  virtual hex_binary*
+  _clone () const;
+
+public:
+  std::basic_string<C>
+  encode () const;
+};
+
+ + +

2.5.7 Time Zone Representation

+ +

The date, dateTime, gDay, + gMonth, gMonthDay, gYear, + gYearMonth, and time XML Schema built-in + types all include an optional time zone component. The following + xml_schema::time_zone base class is used to represent + this information:

+ + 
+class time_zone
+{
+public:
+  time_zone ();
+  time_zone (short hours, short minutes);
+
+  bool
+  zone_present () const;
+
+  void
+  zone_reset ();
+
+  short
+  zone_hours () const;
+
+  void
+  zone_hours (short);
+
+  short
+  zone_minutes () const;
+
+  void
+  zone_minutes (short);
+};
+
+bool
+operator== (const time_zone&, const time_zone&);
+
+bool
+operator!= (const time_zone&, const time_zone&);
+
+ +

The zone_present() accessor function returns true + if the time zone is specified. The zone_reset() modifier + function resets the time zone object to the not specified + state. If the time zone offset is negative then both hours and + minutes components are represented as negative integers.

+ + +

2.5.8 Mapping for date

+ +

The XML Schema date built-in data type is mapped to the + xml_schema::date C++ class which represents a year, a day, + and a month with an optional time zone. Its interface is presented + below. For more information on the base xml_schema::time_zone + class refer to Section 2.5.7, "Time Zone + Representation".

+ + 
+class date: public simple_type, public time_zone
+{
+public:
+  date (int year, unsigned short month, unsigned short day);
+  date (int year, unsigned short month, unsigned short day,
+        short zone_hours, short zone_minutes);
+
+public:
+  date (const date&);
+
+  date&
+  operator= (const date&);
+
+  virtual date*
+  _clone () const;
+
+public:
+  int
+  year () const;
+
+  void
+  year (int);
+
+  unsigned short
+  month () const;
+
+  void
+  month (unsigned short);
+
+  unsigned short
+  day () const;
+
+  void
+  day (unsigned short);
+};
+
+bool
+operator== (const date&, const date&);
+
+bool
+operator!= (const date&, const date&);
+
+ +

2.5.9 Mapping for dateTime

+ +

The XML Schema dateTime built-in data type is mapped to the + xml_schema::date_time C++ class which represents a year, a month, + a day, hours, minutes, and seconds with an optional time zone. Its interface + is presented below. For more information on the base + xml_schema::time_zone class refer to Section + 2.5.7, "Time Zone Representation".

+ + 
+class date_time: public simple_type, public time_zone
+{
+public:
+  date_time (int year, unsigned short month, unsigned short day,
+             unsigned short hours, unsigned short minutes,
+             double seconds);
+
+  date_time (int year, unsigned short month, unsigned short day,
+             unsigned short hours, unsigned short minutes,
+             double seconds, short zone_hours, short zone_minutes);
+public:
+  date_time (const date_time&);
+
+  date_time&
+  operator= (const date_time&);
+
+  virtual date_time*
+  _clone () const;
+
+public:
+  int
+  year () const;
+
+  void
+  year (int);
+
+  unsigned short
+  month () const;
+
+  void
+  month (unsigned short);
+
+  unsigned short
+  day () const;
+
+  void
+  day (unsigned short);
+
+  unsigned short
+  hours () const;
+
+  void
+  hours (unsigned short);
+
+  unsigned short
+  minutes () const;
+
+  void
+  minutes (unsigned short);
+
+  double
+  seconds () const;
+
+  void
+  seconds (double);
+};
+
+bool
+operator== (const date_time&, const date_time&);
+
+bool
+operator!= (const date_time&, const date_time&);
+
+ + +

2.5.10 Mapping for duration

+ +

The XML Schema duration built-in data type is mapped to the + xml_schema::duration C++ class which represents a potentially + negative duration in the form of years, months, days, hours, minutes, + and seconds. Its interface is presented below.

+ + 
+class duration: public simple_type
+{
+public:
+  duration (bool negative,
+            unsigned int years, unsigned int months, unsigned int days,
+            unsigned int hours, unsigned int minutes, double seconds);
+public:
+  duration (const duration&);
+
+  duration&
+  operator= (const duration&);
+
+  virtual duration*
+  _clone () const;
+
+public:
+  bool
+  negative () const;
+
+  void
+  negative (bool);
+
+  unsigned int
+  years () const;
+
+  void
+  years (unsigned int);
+
+  unsigned int
+  months () const;
+
+  void
+  months (unsigned int);
+
+  unsigned int
+  days () const;
+
+  void
+  days (unsigned int);
+
+  unsigned int
+  hours () const;
+
+  void
+  hours (unsigned int);
+
+  unsigned int
+  minutes () const;
+
+  void
+  minutes (unsigned int);
+
+  double
+  seconds () const;
+
+  void
+  seconds (double);
+};
+
+bool
+operator== (const duration&, const duration&);
+
+bool
+operator!= (const duration&, const duration&);
+
+ + +

2.5.11 Mapping for gDay

+ +

The XML Schema gDay built-in data type is mapped to the + xml_schema::gday C++ class which represents a day of the + month with an optional time zone. Its interface is presented below. + For more information on the base xml_schema::time_zone + class refer to Section 2.5.7, "Time Zone + Representation".

+ + 
+class gday: public simple_type, public time_zone
+{
+public:
+  explicit
+  gday (unsigned short day);
+  gday (unsigned short day, short zone_hours, short zone_minutes);
+
+public:
+  gday (const gday&);
+
+  gday&
+  operator= (const gday&);
+
+  virtual gday*
+  _clone () const;
+
+public:
+  unsigned short
+  day () const;
+
+  void
+  day (unsigned short);
+};
+
+bool
+operator== (const gday&, const gday&);
+
+bool
+operator!= (const gday&, const gday&);
+
+ + +

2.5.12 Mapping for gMonth

+ +

The XML Schema gMonth built-in data type is mapped to the + xml_schema::gmonth C++ class which represents a month of the + year with an optional time zone. Its interface is presented below. + For more information on the base xml_schema::time_zone + class refer to Section 2.5.7, "Time Zone + Representation".

+ + 
+class gmonth: public simple_type, public time_zone
+{
+public:
+  explicit
+  gmonth (unsigned short month);
+  gmonth (unsigned short month,
+          short zone_hours, short zone_minutes);
+
+public:
+  gmonth (const gmonth&);
+
+  gmonth&
+  operator= (const gmonth&);
+
+  virtual gmonth*
+  _clone () const;
+
+public:
+  unsigned short
+  month () const;
+
+  void
+  month (unsigned short);
+};
+
+bool
+operator== (const gmonth&, const gmonth&);
+
+bool
+operator!= (const gmonth&, const gmonth&);
+
+ + +

2.5.13 Mapping for gMonthDay

+ +

The XML Schema gMonthDay built-in data type is mapped to the + xml_schema::gmonth_day C++ class which represents a day and + a month of the year with an optional time zone. Its interface is presented + below. For more information on the base xml_schema::time_zone + class refer to Section 2.5.7, "Time Zone + Representation".

+ + 
+class gmonth_day: public simple_type, public time_zone
+{
+public:
+  gmonth_day (unsigned short month, unsigned short day);
+  gmonth_day (unsigned short month, unsigned short day,
+              short zone_hours, short zone_minutes);
+
+public:
+  gmonth_day (const gmonth_day&);
+
+  gmonth_day&
+  operator= (const gmonth_day&);
+
+  virtual gmonth_day*
+  _clone () const;
+
+public:
+  unsigned short
+  month () const;
+
+  void
+  month (unsigned short);
+
+  unsigned short
+  day () const;
+
+  void
+  day (unsigned short);
+};
+
+bool
+operator== (const gmonth_day&, const gmonth_day&);
+
+bool
+operator!= (const gmonth_day&, const gmonth_day&);
+
+ + +

2.5.14 Mapping for gYear

+ +

The XML Schema gYear built-in data type is mapped to the + xml_schema::gyear C++ class which represents a year with + an optional time zone. Its interface is presented below. For more + information on the base xml_schema::time_zone class refer + to Section 2.5.7, "Time Zone Representation".

+ + 
+class gyear: public simple_type, public time_zone
+{
+public:
+  explicit
+  gyear (int year);
+  gyear (int year, short zone_hours, short zone_minutes);
+
+public:
+  gyear (const gyear&);
+
+  gyear&
+  operator= (const gyear&);
+
+  virtual gyear*
+  _clone () const;
+
+public:
+  int
+  year () const;
+
+  void
+  year (int);
+};
+
+bool
+operator== (const gyear&, const gyear&);
+
+bool
+operator!= (const gyear&, const gyear&);
+
+ + +

2.5.15 Mapping for gYearMonth

+ +

The XML Schema gYearMonth built-in data type is mapped to + the xml_schema::gyear_month C++ class which represents + a year and a month with an optional time zone. Its interface is presented + below. For more information on the base xml_schema::time_zone + class refer to Section 2.5.7, "Time Zone + Representation".

+ + 
+class gyear_month: public simple_type, public time_zone
+{
+public:
+  gyear_month (int year, unsigned short month);
+  gyear_month (int year, unsigned short month,
+               short zone_hours, short zone_minutes);
+public:
+  gyear_month (const gyear_month&);
+
+  gyear_month&
+  operator= (const gyear_month&);
+
+  virtual gyear_month*
+  _clone () const;
+
+public:
+  int
+  year () const;
+
+  void
+  year (int);
+
+  unsigned short
+  month () const;
+
+  void
+  month (unsigned short);
+};
+
+bool
+operator== (const gyear_month&, const gyear_month&);
+
+bool
+operator!= (const gyear_month&, const gyear_month&);
+
+ + +

2.5.16 Mapping for time

+ +

The XML Schema time built-in data type is mapped to + the xml_schema::time C++ class which represents hours, + minutes, and seconds with an optional time zone. Its interface is + presented below. For more information on the base + xml_schema::time_zone class refer to + Section 2.5.7, "Time Zone Representation".

+ + 
+class time: public simple_type, public time_zone
+{
+public:
+  time (unsigned short hours, unsigned short minutes, double seconds);
+  time (unsigned short hours, unsigned short minutes, double seconds,
+        short zone_hours, short zone_minutes);
+
+public:
+  time (const time&);
+
+  time&
+  operator= (const time&);
+
+  virtual time*
+  _clone () const;
+
+public:
+  unsigned short
+  hours () const;
+
+  void
+  hours (unsigned short);
+
+  unsigned short
+  minutes () const;
+
+  void
+  minutes (unsigned short);
+
+  double
+  seconds () const;
+
+  void
+  seconds (double);
+};
+
+bool
+operator== (const time&, const time&);
+
+bool
+operator!= (const time&, const time&);
+
+ + + + +

2.6 Mapping for Simple Types

+ +

An XML Schema simple type is mapped to a C++ class with the same + name as the simple type. The class defines a public copy constructor, + a public copy assignment operator, and a public virtual + _clone function. The _clone function is + declared const, does not take any arguments, and returns + a pointer to a complete copy of the instance allocated in the free + store. The _clone function shall be used to make copies + when static type and dynamic type of the instance may differ (see + Section 2.11, "Mapping for xsi:type + and Substitution Groups"). For instance:

+ + 
+<simpleType name="object">
+  ...
+</simpleType>
+
+ +

is mapped to:

+ + 
+class object: ...
+{
+public:
+  object (const object&);
+
+public:
+  object&
+  operator= (const object&);
+
+public:
+  virtual object*
+  _clone () const;
+
+  ...
+
+};
+
+ +

The base class specification and the rest of the class definition + depend on the type of derivation used to define the simple type.

+ + +

2.6.1 Mapping for Derivation by Restriction

+ +

XML Schema derivation by restriction is mapped to C++ public + inheritance. The base type of the restriction becomes the base + type for the resulting C++ class. In addition to the members described + in Section 2.6, "Mapping for Simple Types", the + resulting C++ class defines a public constructor with the base type + as its single argument. For instance:

+ + 
+<simpleType name="object">
+  <restriction base="base">
+    ...
+  </restriction>
+</simpleType>
+
+ +

is mapped to:

+ + 
+class object: public base
+{
+public:
+  object (const base&);
+  object (const object&);
+
+public:
+  object&
+  operator= (const object&);
+
+public:
+  virtual object*
+  _clone () const;
+};
+
+ + +

2.6.2 Mapping for Enumerations

+ +

XML Schema restriction by enumeration is mapped to a C++ class + with semantics similar to C++ enum. Each XML Schema + enumeration element is mapped to a C++ enumerator with the + name derived from the value attribute and defined + in the class scope. In addition to the members + described in Section 2.6, "Mapping for Simple Types", + the resulting C++ class defines a public constructor that can be called + with one of the enumerators as its single argument, a public constructor + that can be called with enumeration's base value as its single + argument, a public assignment operator that can be used to assign the + value of one of the enumerators, and a public implicit conversion + operator to the underlying C++ enum type.

+ +

Furthermore, for string-based enumeration types, the resulting C++ + class defines a public constructor with a single argument of type + const C* and a public constructor with a single + argument of type const std::basic_string<C>&. + For instance:

+ + 
+<simpleType name="color">
+  <restriction base="string">
+    <enumeration value="red"/>
+    <enumeration value="green"/>
+    <enumeration value="blue"/>
+  </restriction>
+</simpleType>
+
+ +

is mapped to:

+ + 
+class color: public xml_schema::string
+{
+public:
+  enum value
+  {
+    red,
+    green,
+    blue
+  };
+
+public:
+  color (value);
+  color (const C*);
+  color (const std::basic_string<C>&);
+  color (const xml_schema::string&);
+  color (const color&);
+
+public:
+  color&
+  operator= (value);
+
+  color&
+  operator= (const color&);
+
+public:
+  virtual color*
+  _clone () const;
+
+public:
+  operator value () const;
+};
+
+ +

2.6.3 Mapping for Derivation by List

+ +

XML Schema derivation by list is mapped to C++ public + inheritance from xml_schema::simple_type + (Section 2.5.3, "Mapping for + anySimpleType") and a suitable sequence type. + The list item type becomes the element type of the sequence. + In addition to the members described in Section 2.6, + "Mapping for Simple Types", the resulting C++ class defines + a public default constructor, a public constructor + with the first argument of type size_type and + the second argument of list item type that creates + a list object with the specified number of copies of the specified + element value, and a public constructor with the two arguments + of an input iterator type that creates a list object from an + iterator range. For instance: +

+ + 
+<simpleType name="int_list">
+  <list itemType="int"/>
+</simpleType>
+
+ +

is mapped to:

+ + 
+class int_list: public simple_type,
+                public sequence<int>
+{
+public:
+  int_list ();
+  int_list (size_type n, int x);
+
+  template <typename I>
+  int_list (const I& begin, const I& end);
+  int_list (const int_list&);
+
+public:
+  int_list&
+  operator= (const int_list&);
+
+public:
+  virtual int_list*
+  _clone () const;
+};
+
+ +

The sequence class template is defined in an + implementation-specific namespace. It conforms to the + sequence interface as defined by the ISO/ANSI Standard for + C++ (ISO/IEC 14882:1998, Section 23.1.1, "Sequences"). + Practically, this means that you can treat such a sequence + as if it was std::vector. One notable extension + to the standard interface that is available only for + sequences of non-fundamental C++ types is the addition of + the overloaded push_back and insert + member functions which instead of the constant reference + to the element type accept automatic pointer (std::unique_ptr + or std::auto_ptr, depending on the C++ standard + selected) to the element type. These functions assume ownership + of the pointed to object and reset the passed automatic pointer. +

+ +

2.6.4 Mapping for Derivation by Union

+ +

XML Schema derivation by union is mapped to C++ public + inheritance from xml_schema::simple_type + (Section 2.5.3, "Mapping for + anySimpleType") and std::basic_string<C>. + In addition to the members described in Section 2.6, + "Mapping for Simple Types", the resulting C++ class defines a + public constructor with a single argument of type const C* + and a public constructor with a single argument of type + const std::basic_string<C>&. For instance: +

+ + 
+<simpleType name="int_string_union">
+  <xsd:union memberTypes="xsd:int xsd:string"/>
+</simpleType>
+
+ +

is mapped to:

+ + 
+class int_string_union: public simple_type,
+                        public std::basic_string<C>
+{
+public:
+  int_string_union (const C*);
+  int_string_union (const std::basic_string<C>&);
+  int_string_union (const int_string_union&);
+
+public:
+  int_string_union&
+  operator= (const int_string_union&);
+
+public:
+  virtual int_string_union*
+  _clone () const;
+};
+
+ +

2.7 Mapping for Complex Types

+ +

An XML Schema complex type is mapped to a C++ class with the same + name as the complex type. The class defines a public copy constructor, + a public copy assignment operator, and a public virtual + _clone function. The _clone function is + declared const, does not take any arguments, and returns + a pointer to a complete copy of the instance allocated in the free + store. The _clone function shall be used to make copies + when static type and dynamic type of the instance may differ (see + Section 2.11, "Mapping for xsi:type + and Substitution Groups").

+ +

Additionally, the resulting C++ class + defines two public constructors that take an initializer for each + member of the complex type and all its base types that belongs to + the One cardinality class (see Section 2.8, "Mapping + for Local Elements and Attributes"). In the first constructor, + the arguments are passed as constant references and the newly created + instance is initialized with copies of the passed objects. In the + second constructor, arguments that are complex types (that is, + they themselves contain elements or attributes) are passed as + either std::unique_ptr (C++11) or std::auto_ptr + (C++98), depending on the C++ standard selected. In this case the newly + created instance is directly initialized with and assumes ownership + of the pointed to objects and the std::[unique|auto]_ptr + arguments are reset to 0. For instance:

+ + 
+<complexType name="complex">
+  <sequence>
+    <element name="a" type="int"/>
+    <element name="b" type="string"/>
+  </sequence>
+</complexType>
+
+<complexType name="object">
+  <sequence>
+    <element name="s-one" type="boolean"/>
+    <element name="c-one" type="complex"/>
+    <element name="optional" type="int" minOccurs="0"/>
+    <element name="sequence" type="string" maxOccurs="unbounded"/>
+  </sequence>
+</complexType>
+
+ +

is mapped to:

+ + 
+class complex: public xml_schema::type
+{
+public:
+  object (const int& a, const xml_schema::string& b);
+  object (const complex&);
+
+public:
+  object&
+  operator= (const complex&);
+
+public:
+  virtual complex*
+  _clone () const;
+
+  ...
+
+};
+
+class object: public xml_schema::type
+{
+public:
+  object (const bool& s_one, const complex& c_one);
+  object (const bool& s_one, std::[unique|auto]_ptr<complex> c_one);
+  object (const object&);
+
+public:
+  object&
+  operator= (const object&);
+
+public:
+  virtual object*
+  _clone () const;
+
+  ...
+
+};
+
+ +

Notice that the generated complex class does not + have the second (std::[unique|auto]_ptr) version of the + constructor since all its required members are of simple types.

+ +

If an XML Schema complex type has an ultimate base which is an XML + Schema simple type then the resulting C++ class also defines a public + constructor that takes an initializer for the base type as well as + for each member of the complex type and all its base types that + belongs to the One cardinality class. For instance:

+ + 
+<complexType name="object">
+  <simpleContent>
+    <extension base="date">
+      <attribute name="lang" type="language" use="required"/>
+    </extension>
+  </simpleContent>
+</complexType>
+
+ +

is mapped to:

+ + 
+class object: public xml_schema::string
+{
+public:
+  object (const xml_schema::language& lang);
+
+  object (const xml_schema::date& base,
+          const xml_schema::language& lang);
+
+  ...
+
+};
+
+ +

Furthermore, for string-based XML Schema complex types, the resulting C++ + class also defines two public constructors with the first arguments + of type const C* and std::basic_string<C>&, + respectively, followed by arguments for each member of the complex + type and all its base types that belongs to the One cardinality + class. For enumeration-based complex types the resulting C++ + class also defines a public constructor with the first arguments + of the underlying enum type followed by arguments for each member + of the complex type and all its base types that belongs to the One + cardinality class. For instance:

+ + 
+<simpleType name="color">
+  <restriction base="string">
+    <enumeration value="red"/>
+    <enumeration value="green"/>
+    <enumeration value="blue"/>
+  </restriction>
+</simpleType>
+
+<complexType name="object">
+  <simpleContent>
+    <extension base="color">
+      <attribute name="lang" type="language" use="required"/>
+    </extension>
+  </simpleContent>
+</complexType>
+
+ +

is mapped to:

+ + 
+class color: public xml_schema::string
+{
+public:
+  enum value
+  {
+    red,
+    green,
+    blue
+  };
+
+public:
+  color (value);
+  color (const C*);
+  color (const std::basic_string<C>&);
+
+  ...
+
+};
+
+class object: color
+{
+public:
+  object (const color& base,
+          const xml_schema::language& lang);
+
+  object (const color::value& base,
+          const xml_schema::language& lang);
+
+  object (const C* base,
+          const xml_schema::language& lang);
+
+  object (const std::basic_string<C>& base,
+          const xml_schema::language& lang);
+
+  ...
+
+};
+
+ +

Additional constructors can be requested with the + --generate-default-ctor and + --generate-from-base-ctor options. See the + XSD + Compiler Command Line Manual for details.

+ +

If an XML Schema complex type is not explicitly derived from any type, + the resulting C++ class is derived from xml_schema::type. + In cases where an XML Schema complex type is defined using derivation + by extension or restriction, the resulting C++ base class specification + depends on the type of derivation and is described in the subsequent + sections. +

+ +

The mapping for elements and attributes that are defined in a complex + type is described in Section 2.8, "Mapping for Local + Elements and Attributes". +

+ +

2.7.1 Mapping for Derivation by Extension

+ +

XML Schema derivation by extension is mapped to C++ public + inheritance. The base type of the extension becomes the base + type for the resulting C++ class. +

+ +

2.7.2 Mapping for Derivation by Restriction

+ +

XML Schema derivation by restriction is mapped to C++ public + inheritance. The base type of the restriction becomes the base + type for the resulting C++ class. XML Schema elements and + attributes defined within restriction do not result in any + definitions in the resulting C++ class. Instead, corresponding + (unrestricted) definitions are inherited from the base class. + In the future versions of this mapping, such elements and + attributes may result in redefinitions of accessors and + modifiers to reflect their restricted semantics. +

+ + + +

2.8 Mapping for Local Elements and Attributes

+ +

XML Schema element and attribute definitions are called local + if they appear within a complex type definition, an element group + definition, or an attribute group definitions. +

+ +

Local XML Schema element and attribute definitions have the same + C++ mapping. Therefore, in this section, local elements and + attributes are collectively called members. +

+ +

While there are many different member cardinality combinations + (determined by the use attribute for attributes and + the minOccurs and maxOccurs attributes + for elements), the mapping divides all possible cardinality + combinations into three cardinality classes: +

+ +
+
one
+
attributes: use == "required"
+
attributes: use == "optional" and has default or fixed value
+
elements: minOccurs == "1" and maxOccurs == "1"
+ +
optional
+
attributes: use == "optional" and doesn't have default or fixed value
+
elements: minOccurs == "0" and maxOccurs == "1"
+ +
sequence
+
elements: maxOccurs > "1"
+
+ +

An optional attribute with a default or fixed value acquires this value + if the attribute hasn't been specified in an instance document (see + Appendix A, "Default and Fixed Values"). This + mapping places such optional attributes to the One cardinality + class.

+ +

A member is mapped to a set of public type definitions + (typedefs) and a set of public accessor and modifier + functions. Type definitions have names derived from the member's + name. The accessor and modifier functions have the same name as the + member. For example: +

+ + 
+<complexType name="object">
+  <sequence>
+    <element name="member" type="string"/>
+  </sequence>
+</complexType>
+
+ +

is mapped to:

+ + 
+class object: public xml_schema::type
+{
+public:
+  typedef xml_schema::string member_type;
+
+  const member_type&
+  member () const;
+
+  ...
+
+};
+
+ +

In addition, if a member has a default or fixed value, a static + accessor function is generated that returns this value. For + example:

+ +
+<complexType name="object">
+  <attribute name="data" type="string" default="test"/>
+</complexType>
+
+ +

is mapped to:

+ + 
+class object: public xml_schema::type
+{
+public:
+  typedef xml_schema::string data_type;
+
+  const data_type&
+  data () const;
+
+  static const data_type&
+  data_default_value ();
+
+  ...
+
+};
+
+ +

Names and semantics of type definitions for the member as well + as signatures of the accessor and modifier functions depend on + the member's cardinality class and are described in the following + sub-sections. +

+ + +

2.8.1 Mapping for Members with the One Cardinality Class

+ +

For the One cardinality class, the type definitions consist of + an alias for the member's type with the name created by appending + the _type suffix to the member's name. +

+ +

The accessor functions come in constant and non-constant versions. + The constant accessor function returns a constant reference to the + member and can be used for read-only access. The non-constant + version returns an unrestricted reference to the member and can + be used for read-write access. +

+ +

The first modifier function expects an argument of type reference to + constant of the member's type. It makes a deep copy of its argument. + Except for member's types that are mapped to fundamental C++ types, + the second modifier function is provided that expects an argument + of type automatic pointer (std::unique_ptr or + std::auto_ptr, depending on the C++ standard selected) + to the member's type. It assumes ownership of the pointed to object + and resets the passed automatic pointer. For instance:

+ + 
+<complexType name="object">
+  <sequence>
+    <element name="member" type="string"/>
+  </sequence>
+</complexType>
+
+ +

is mapped to:

+ + 
+class object: public xml_schema::type
+{
+public:
+  // Type definitions.
+  //
+  typedef xml_schema::string member_type;
+
+  // Accessors.
+  //
+  const member_type&
+  member () const;
+
+  member_type&
+  member ();
+
+  // Modifiers.
+  //
+  void
+  member (const member_type&);
+
+  void
+  member (std::[unique|auto]_ptr<member_type>);
+  ...
+
+};
+
+ +

In addition, if requested by specifying the --generate-detach + option and only for members of non-fundamental C++ types, the mapping + provides a detach function that returns an automatic pointer to the + member's type, for example:

+ + 
+class object: public xml_schema::type
+{
+public:
+  ...
+
+  std::[unique|auto]_ptr<member_type>
+  detach_member ();
+  ...
+
+};
+
+ +

This function detaches the value from the tree leaving the member + value uninitialized. Accessing such an uninitialized value prior to + re-initializing it results in undefined behavior.

+ +

The following code shows how one could use this mapping:

+ + 
+void
+f (object& o)
+{
+  using xml_schema::string;
+
+  string s (o.member ());                // get
+  object::member_type& sr (o.member ()); // get
+
+  o.member ("hello");           // set, deep copy
+  o.member () = "hello";        // set, deep copy
+
+  // C++11 version.
+  //
+  std::unique_ptr<string> p (new string ("hello"));
+  o.member (std::move (p));     // set, assumes ownership
+  p = o.detach_member ();       // detach, member is uninitialized
+  o.member (std::move (p));     // re-attach
+
+  // C++98 version.
+  //
+  std::auto_ptr<string> p (new string ("hello"));
+  o.member (p);                 // set, assumes ownership
+  p = o.detach_member ();       // detach, member is uninitialized
+  o.member (p);                 // re-attach
+}
+
+ + +

2.8.2 Mapping for Members with the Optional Cardinality Class

+ +

For the Optional cardinality class, the type definitions consist of + an alias for the member's type with the name created by appending + the _type suffix to the member's name and an alias for + the container type with the name created by appending the + _optional suffix to the member's name. +

+ +

Unlike accessor functions for the One cardinality class, accessor + functions for the Optional cardinality class return references to + corresponding containers rather than directly to members. The + accessor functions come in constant and non-constant versions. + The constant accessor function returns a constant reference to + the container and can be used for read-only access. The non-constant + version returns an unrestricted reference to the container + and can be used for read-write access. +

+ +

The modifier functions are overloaded for the member's + type and the container type. The first modifier function + expects an argument of type reference to constant of the + member's type. It makes a deep copy of its argument. + Except for member's types that are mapped to fundamental C++ types, + the second modifier function is provided that expects an argument + of type automatic pointer (std::unique_ptr or + std::auto_ptr, depending on the C++ standard selected) + to the member's type. It assumes ownership of the pointed to object + and resets the passed automatic pointer. The last modifier function + expects an argument of type reference to constant of the container + type. It makes a deep copy of its argument. For instance: +

+ + 
+<complexType name="object">
+  <sequence>
+    <element name="member" type="string" minOccurs="0"/>
+  </sequence>
+</complexType>
+
+ +

is mapped to:

+ + 
+class object: public xml_schema::type
+{
+public:
+  // Type definitions.
+  //
+  typedef xml_schema::string member_type;
+  typedef optional<member_type> member_optional;
+
+  // Accessors.
+  //
+  const member_optional&
+  member () const;
+
+  member_optional&
+  member ();
+
+  // Modifiers.
+  //
+  void
+  member (const member_type&);
+
+  void
+  member (std::[unique|auto]_ptr<member_type>);
+
+  void
+  member (const member_optional&);
+
+  ...
+
+};
+
+ + +

The optional class template is defined in an + implementation-specific namespace and has the following + interface. The [unique|auto]_ptr-based constructor + and modifier function are only available if the template + argument is not a fundamental C++ type. +

+ + 
+template <typename X>
+class optional
+{
+public:
+  optional ();
+
+  // Makes a deep copy.
+  //
+  explicit
+  optional (const X&);
+
+  // Assumes ownership.
+  //
+  explicit
+  optional (std::[unique|auto]_ptr<X>);
+
+  optional (const optional&);
+
+public:
+  optional&
+  operator= (const X&);
+
+  optional&
+  operator= (const optional&);
+
+  // Pointer-like interface.
+  //
+public:
+  const X*
+  operator-> () const;
+
+  X*
+  operator-> ();
+
+  const X&
+  operator* () const;
+
+  X&
+  operator* ();
+
+  typedef void (optional::*bool_convertible) ();
+  operator bool_convertible () const;
+
+  // Get/set interface.
+  //
+public:
+  bool
+  present () const;
+
+  const X&
+  get () const;
+
+  X&
+  get ();
+
+  // Makes a deep copy.
+  //
+  void
+  set (const X&);
+
+  // Assumes ownership.
+  //
+  void
+  set (std::[unique|auto]_ptr<X>);
+
+  // Detach and return the contained value.
+  //
+  std::[unique|auto]_ptr<X>
+  detach ();
+
+  void
+  reset ();
+};
+
+template <typename X>
+bool
+operator== (const optional<X>&, const optional<X>&);
+
+template <typename X>
+bool
+operator!= (const optional<X>&, const optional<X>&);
+
+template <typename X>
+bool
+operator< (const optional<X>&, const optional<X>&);
+
+template <typename X>
+bool
+operator> (const optional<X>&, const optional<X>&);
+
+template <typename X>
+bool
+operator<= (const optional<X>&, const optional<X>&);
+
+template <typename X>
+bool
+operator>= (const optional<X>&, const optional<X>&);
+
+ + +

The following code shows how one could use this mapping:

+ + 
+void
+f (object& o)
+{
+  using xml_schema::string;
+
+  if (o.member ().present ())       // test
+  {
+    string& s (o.member ().get ()); // get
+    o.member ("hello");             // set, deep copy
+    o.member ().set ("hello");      // set, deep copy
+    o.member ().reset ();           // reset
+  }
+
+  // Same as above but using pointer notation:
+  //
+  if (o.member ())                  // test
+  {
+    string& s (*o.member ());       // get
+    o.member ("hello");             // set, deep copy
+    *o.member () = "hello";         // set, deep copy
+    o.member ().reset ();           // reset
+  }
+
+  // C++11 version.
+  //
+  std::unique_ptr<string> p (new string ("hello"));
+  o.member (std::move (p));         // set, assumes ownership
+
+  p.reset (new string ("hello"));
+  o.member ().set (std::move (p));  // set, assumes ownership
+
+  p = o.member ().detach ();        // detach, member is reset
+  o.member ().set (std::move (p));  // re-attach
+
+  // C++98 version.
+  //
+  std::auto_ptr<string> p (new string ("hello"));
+  o.member (p);                     // set, assumes ownership
+
+  p = new string ("hello");
+  o.member ().set (p);              // set, assumes ownership
+
+  p = o.member ().detach ();        // detach, member is reset
+  o.member ().set (p);              // re-attach
+}
+
+ + +

2.8.3 Mapping for Members with the Sequence Cardinality Class

+ +

For the Sequence cardinality class, the type definitions consist of an + alias for the member's type with the name created by appending + the _type suffix to the member's name, an alias of + the container type with the name created by appending the + _sequence suffix to the member's name, an alias of + the iterator type with the name created by appending the + _iterator suffix to the member's name, and an alias + of the constant iterator type with the name created by appending the + _const_iterator suffix to the member's name. +

+ +

The accessor functions come in constant and non-constant versions. + The constant accessor function returns a constant reference to the + container and can be used for read-only access. The non-constant + version returns an unrestricted reference to the container and can + be used for read-write access. +

+ +

The modifier function expects an argument of type reference to + constant of the container type. The modifier function + makes a deep copy of its argument. For instance: +

+ + + 
+<complexType name="object">
+  <sequence>
+    <element name="member" type="string" minOccurs="unbounded"/>
+  </sequence>
+</complexType>
+
+ +

is mapped to:

+ + 
+class object: public xml_schema::type
+{
+public:
+  // Type definitions.
+  //
+  typedef xml_schema::string member_type;
+  typedef sequence<member_type> member_sequence;
+  typedef member_sequence::iterator member_iterator;
+  typedef member_sequence::const_iterator member_const_iterator;
+
+  // Accessors.
+  //
+  const member_sequence&
+  member () const;
+
+  member_sequence&
+  member ();
+
+  // Modifier.
+  //
+  void
+  member (const member_sequence&);
+
+  ...
+
+};
+
+ +

The sequence class template is defined in an + implementation-specific namespace. It conforms to the + sequence interface as defined by the ISO/ANSI Standard for + C++ (ISO/IEC 14882:1998, Section 23.1.1, "Sequences"). + Practically, this means that you can treat such a sequence + as if it was std::vector. Two notable extensions + to the standard interface that are available only for + sequences of non-fundamental C++ types are the addition of + the overloaded push_back and insert + as well as the detach_back and detach + member functions. The additional push_back and + insert functions accept an automatic pointer + (std::unique_ptr or std::auto_ptr, + depending on the C++ standard selected) to the + element type instead of the constant reference. They assume + ownership of the pointed to object and reset the passed + automatic pointer. The detach_back and + detach functions detach the element + value from the sequence container and, by default, remove + the element from the sequence. These additional functions + have the following signatures:

+ + 
+template <typename X>
+class sequence
+{
+public:
+  ...
+
+  void
+  push_back (std::[unique|auto]_ptr<X>)
+
+  iterator
+  insert (iterator position, std::[unique|auto]_ptr<X>)
+
+  std::[unique|auto]_ptr<X>
+  detach_back (bool pop = true);
+
+  iterator
+  detach (iterator position,
+          std::[unique|auto]_ptr<X>& result,
+          bool erase = true)
+
+  ...
+}
+
+ +

The following code shows how one could use this mapping:

+ + 
+void
+f (object& o)
+{
+  using xml_schema::string;
+
+  object::member_sequence& s (o.member ());
+
+  // Iteration.
+  //
+  for (object::member_iterator i (s.begin ()); i != s.end (); ++i)
+  {
+    string& value (*i);
+  }
+
+  // Modification.
+  //
+  s.push_back ("hello");  // deep copy
+
+  // C++11 version.
+  //
+  std::unique_ptr<string> p (new string ("hello"));
+  s.push_back (std::move (p)); // assumes ownership
+  p = s.detach_back ();        // detach and pop
+  s.push_back (std::move (p)); // re-append
+
+  // C++98 version.
+  //
+  std::auto_ptr<string> p (new string ("hello"));
+  s.push_back (p);        // assumes ownership
+  p = s.detach_back ();   // detach and pop
+  s.push_back (p);        // re-append
+
+  // Setting a new container.
+  //
+  object::member_sequence n;
+  n.push_back ("one");
+  n.push_back ("two");
+  o.member (n);           // deep copy
+}
+
+ +

2.8.4 Element Order

+ +

C++/Tree is a "flattening" mapping in a sense that many levels of + nested compositors (choice and sequence), + all potentially with their own cardinalities, are in the end mapped + to a flat set of elements with one of the three cardinality classes + discussed in the previous sections. While this results in a simple + and easy to use API for most types, in certain cases, the order of + elements in the actual XML documents is not preserved once parsed + into the object model. And sometimes such order has + application-specific significance. As an example, consider a schema + that defines a batch of bank transactions:

+ + 
+<complexType name="withdraw">
+  <sequence>
+    <element name="account" type="unsignedInt"/>
+    <element name="amount" type="unsignedInt"/>
+  </sequence>
+</complexType>
+
+<complexType name="deposit">
+  <sequence>
+    <element name="account" type="unsignedInt"/>
+    <element name="amount" type="unsignedInt"/>
+  </sequence>
+</complexType>
+
+<complexType name="batch">
+  <choice minOccurs="0" maxOccurs="unbounded">
+    <element name="withdraw" type="withdraw"/>
+    <element name="deposit" type="deposit"/>
+  </choice>
+</complexType>
+
+ +

The batch can contain any number of transactions in any order + but the order of transactions in each actual batch is significant. + For instance, consider what could happen if we reorder the + transactions and apply all the withdrawals before deposits.

+ +

For the batch schema type defined above the default + C++/Tree mapping will produce a C++ class that contains a pair of + sequence containers, one for each of the two elements. While this + will capture the content (transactions), the order of this content + as it appears in XML will be lost. Also, if we try to serialize the + batch we just loaded back to XML, all the withdrawal transactions + will appear before deposits.

+ +

To overcome this limitation of a flattening mapping, C++/Tree + allows us to mark certain XML Schema types, for which content + order is important, as ordered.

+ +

There are several command line options that control which + schema types are treated as ordered. To make an individual + type ordered, we use the --ordered-type option, + for example:

+ + 
+--ordered-type batch
+
+ +

To automatically treat all the types that are derived from an ordered + type also ordered, we use the --ordered-type-derived + option. This is primarily useful if you would like to iterate + over the complete hierarchy's content using the content order + sequence (discussed below).

+ +

Ordered types are also useful for handling mixed content. To + automatically mark all the types with mixed content as ordered + we use the --ordered-type-mixed option. For more + information on handling mixed content see Section + 2.13, "Mapping for Mixed Content Models".

+ +

Finally, we can mark all the types in the schema we are + compiling with the --ordered-type-all option. + You should only resort to this option if all the types in + your schema truly suffer from the loss of content + order since, as we will discuss shortly, ordered types + require extra effort to access and, especially, modify. + See the + XSD + Compiler Command Line Manual for more information on + these options.

+ +

Once a type is marked ordered, C++/Tree alters its mapping + in several ways. Firstly, for each local element, element + wildcard (Section 2.12.4, "Element Wildcard + Order"), and mixed content text (Section + 2.13, "Mapping for Mixed Content Models") in this type, a + content id constant is generated. Secondly, an addition sequence + is added to the class that captures the content order. Here + is how the mapping of our batch class changes + once we make it ordered:

+ + 
+class batch: public xml_schema::type
+{
+public:
+  // withdraw
+  //
+  typedef withdraw withdraw_type;
+  typedef sequence<withdraw_type> withdraw_sequence;
+  typedef withdraw_sequence::iterator withdraw_iterator;
+  typedef withdraw_sequence::const_iterator withdraw_const_iterator;
+
+  static const std::size_t withdraw_id = 1;
+
+  const withdraw_sequence&
+  withdraw () const;
+
+  withdraw_sequence&
+  withdraw ();
+
+  void
+  withdraw (const withdraw_sequence&);
+
+  // deposit
+  //
+  typedef deposit deposit_type;
+  typedef sequence<deposit_type> deposit_sequence;
+  typedef deposit_sequence::iterator deposit_iterator;
+  typedef deposit_sequence::const_iterator deposit_const_iterator;
+
+  static const std::size_t deposit_id = 2;
+
+  const deposit_sequence&
+  deposit () const;
+
+  deposit_sequence&
+  deposit ();
+
+  void
+  deposit (const deposit_sequence&);
+
+  // content_order
+  //
+  typedef xml_schema::content_order content_order_type;
+  typedef std::vector<content_order_type> content_order_sequence;
+  typedef content_order_sequence::iterator content_order_iterator;
+  typedef content_order_sequence::const_iterator content_order_const_iterator;
+
+  const content_order_sequence&
+  content_order () const;
+
+  content_order_sequence&
+  content_order ();
+
+  void
+  content_order (const content_order_sequence&);
+
+  ...
+};
+
+ +

Notice the withdraw_id and deposit_id + content ids as well as the extra content_order + sequence that does not correspond to any element in the + schema definition. The other changes to the mapping for ordered + types has to do with XML parsing and serialization code. During + parsing the content order is captured in the content_order + sequence while during serialization this sequence is used to + determine the order in which content is serialized. The + content_order sequence is also copied during + copy construction and assigned during copy assignment. It is also + taken into account during comparison.

+ +

The entry type of the content_order sequence is the + xml_schema::content_order type that has the following + interface:

+ + 
+namespace xml_schema
+{
+  struct content_order
+  {
+    content_order (std::size_t id, std::size_t index = 0);
+
+    std::size_t id;
+    std::size_t index;
+  };
+
+  bool
+  operator== (const content_order&, const content_order&);
+
+  bool
+  operator!= (const content_order&, const content_order&);
+
+  bool
+  operator< (const content_order&, const content_order&);
+}
+
+ +

The content_order sequence describes the order of + content (elements, including wildcards, as well as mixed content + text). Each entry in this sequence consists of the content id + (for example, withdraw_id or deposit_id + in our case) as well as, for elements of the sequence cardinality + class, an index into the corresponding sequence container (the + index is unused for the one and optional cardinality classes). + For example, in our case, if the content id is withdraw_id, + then the index will point into the withdraw element + sequence.

+ +

With all this information we can now examine how to iterate over + transaction in the batch in content order:

+ + 
+batch& b = ...
+
+for (batch::content_order_const_iterator i (b.content_order ().begin ());
+     i != b.content_order ().end ();
+     ++i)
+{
+  switch (i->id)
+  {
+  case batch::withdraw_id:
+    {
+      const withdraw& t (b.withdraw ()[i->index]);
+      cerr << t.account () << " withdraw " << t.amount () << endl;
+      break;
+    }
+  case batch::deposit_id:
+    {
+      const deposit& t (b.deposit ()[i->index]);
+      cerr << t.account () << " deposit " << t.amount () << endl;
+      break;
+    }
+  default:
+    {
+      assert (false); // Unknown content id.
+    }
+  }
+}
+
+ +

If we serialized our batch back to XML, we would also see that the + order of transactions in the output is exactly the same as in the + input rather than all the withdrawals first followed by all the + deposits.

+ +

The most complex aspect of working with ordered types is + modifications. Now we not only need to change the content, + but also remember to update the order information corresponding + to this change. As a first example, we add a deposit transaction + to the batch:

+ + 
+using xml_schema::content_order;
+
+batch::deposit_sequence& d (b.deposit ());
+batch::withdraw_sequence& w (b.withdraw ());
+batch::content_order_sequence& co (b.content_order ());
+
+d.push_back (deposit (123456789, 100000));
+co.push_back (content_order (batch::deposit_id, d.size () - 1));
+
+ +

In the above example we first added the content (deposit + transaction) and then updated the content order information + by adding an entry with deposit_id content + id and the index of the just added deposit transaction.

+ +

Removing the last transaction can be easy if we know which + transaction (deposit or withdrawal) is last:

+ + 
+d.pop_back ();
+co.pop_back ();
+
+ +

If, however, we do not know which transaction is last, then + things get a bit more complicated:

+ + 
+switch (co.back ().id)
+{
+case batch::withdraw_id:
+  {
+    d.pop_back ();
+    break;
+  }
+case batch::deposit_id:
+  {
+    w.pop_back ();
+    break;
+  }
+}
+
+co.pop_back ();
+
+ +

The following example shows how to add a transaction at the + beginning of the batch:

+ + 
+w.push_back (withdraw (123456789, 100000));
+co.insert (co.begin (),
+           content_order (batch::withdraw_id, w.size () - 1));
+
+ +

Note also that when we merely modify the content of one + of the elements in place, we do not need to update its + order since it doesn't change. For example, here is how + we can change the amount in the first withdrawal:

+ + 
+w[0].amount (10000);
+
+ +

For the complete working code shown in this section refer to the + order/element example in the + cxx/tree/ directory in the + xsd-examples + package.

+ +

If both the base and derived types are ordered, then the + content order sequence is only added to the base and the content + ids are unique within the whole hierarchy. In this case + the content order sequence for the derived type contains + ordering information for both base and derived content.

+ +

In some applications we may need to perform more complex + content processing. For example, in our case, we may need + to remove all the withdrawal transactions. The default + container, std::vector, is not particularly + suitable for such operations. What may be required by + some applications is a multi-index container that not + only allows us to iterate in content order similar to + std::vector but also search by the content + id as well as the content id and index pair.

+ +

While C++/Tree does not provide this functionality by + default, it allows us to specify a custom container + type for content order with the --order-container + command line option. The only requirement from the + generated code side for such a container is to provide + the vector-like push_back(), + size(), and const iteration interfaces.

+ +

As an example, here is how we can use the Boost Multi-Index + container for content order. First we create the + content-order-container.hxx header with the + following definition:

+ + 
+#ifndef CONTENT_ORDER_CONTAINER
+#define CONTENT_ORDER_CONTAINER
+
+#include <cstddef> // std::size_t
+
+#include <boost/multi_index_container.hpp>
+#include <boost/multi_index/member.hpp>
+#include <boost/multi_index/identity.hpp>
+#include <boost/multi_index/ordered_index.hpp>
+#include <boost/multi_index/random_access_index.hpp>
+
+struct by_id {};
+struct by_id_index {};
+
+template <typename T>
+using content_order_container =
+  boost::multi_index::multi_index_container<
+    T,
+    boost::multi_index::indexed_by<
+      boost::multi_index::random_access<>,
+      boost::multi_index::ordered_unique<
+        boost::multi_index::tag<by_id_index>,
+        boost::multi_index::identity<T>
+      >,
+      boost::multi_index::ordered_non_unique<
+        boost::multi_index::tag<by_id>,
+        boost::multi_index::member<T, std::size_t, &T::id>
+      >
+    >
+  >;
+
+#endif
+
+ +

Next we add the following two XSD compiler options to include + this header into every generated header file and to use the + custom container type (see the XSD compiler command line manual + for more information on shell quoting for the first option):

+ + 
+--hxx-prologue '#include "content-order-container.hxx"'
+--order-container content_order_container
+
+ +

With these changes we can now use the multi-index functionality, + for example, to search for a specific content id:

+ + 
+typedef batch::content_order_sequence::index<by_id>::type id_set;
+typedef id_set::iterator id_iterator;
+
+const id_set& ids (b.content_order ().get<by_id> ());
+
+std::pair<id_iterator, id_iterator> r (
+  ids.equal_range (std::size_t (batch::deposit_id));
+
+for (id_iterator i (r.first); i != r.second; ++i)
+{
+  const deposit& t (b.deposit ()[i->index]);
+  cerr << t.account () << " deposit " << t.amount () << endl;
+}
+
+ +

2.9 Mapping for Global Elements

+ +

An XML Schema element definition is called global if it appears + directly under the schema element. + A global element is a valid root of an instance document. By + default, a global element is mapped to a set of overloaded + parsing and, optionally, serialization functions with the + same name as the element. It is also possible to generate types + for root elements instead of parsing and serialization functions. + This is primarily useful to distinguish object models with the + same root type but with different root elements. See + Section 2.9.1, "Element Types" for details. + It is also possible to request the generation of an element map + which allows uniform parsing and serialization of multiple root + elements. See Section 2.9.2, "Element Map" + for details. +

+ +

The parsing functions read XML instance documents and return + corresponding object models as an automatic pointer + (std::unique_ptr or std::auto_ptr, + depending on the C++ standard selected). Their signatures + have the following pattern (type denotes + element's type and name denotes element's + name): +

+ + 
+std::[unique|auto]_ptr<type>
+name (....);
+
+ +

The process of parsing, including the exact signatures of the parsing + functions, is the subject of Chapter 3, "Parsing". +

+ +

The serialization functions write object models back to XML instance + documents. Their signatures have the following pattern: +

+ + 
+void
+name (<stream type>&, const type&, ....);
+
+ +

The process of serialization, including the exact signatures of the + serialization functions, is the subject of Chapter 4, + "Serialization". +

+ + +

2.9.1 Element Types

+ +

The generation of element types is requested with the + --generate-element-type option. With this option + each global element is mapped to a C++ class with the + same name as the element. Such a class is derived from + xml_schema::element_type and contains the same set + of type definitions, constructors, and member function as would a + type containing a single element with the One cardinality class + named "value". In addition, the element type also + contains a set of member functions for accessing the element + name and namespace as well as its value in a uniform manner. + For example:

+ + 
+<complexType name="type">
+  <sequence>
+    ...
+  </sequence>
+</complexType>
+
+<element name="root" type="type"/>
+
+ +

is mapped to:

+ + 
+class type
+{
+  ...
+};
+
+class root: public xml_schema::element_type
+{
+public:
+  // Element value.
+  //
+  typedef type value_type;
+
+  const value_type&
+  value () const;
+
+  value_type&
+  value ();
+
+  void
+  value (const value_type&);
+
+  void
+  value (std::[unique|auto]_ptr<value_type>);
+
+  // Constructors.
+  //
+  root (const value_type&);
+
+  root (std::[unique|auto]_ptr<value_type>);
+
+  root (const xercesc::DOMElement&, xml_schema::flags = 0);
+
+  root (const root&, xml_schema::flags = 0);
+
+  virtual root*
+  _clone (xml_schema::flags = 0) const;
+
+  // Element name and namespace.
+  //
+  static const std::string&
+  name ();
+
+  static const std::string&
+  namespace_ ();
+
+  virtual const std::string&
+  _name () const;
+
+  virtual const std::string&
+  _namespace () const;
+
+  // Element value as xml_schema::type.
+  //
+  virtual const xml_schema::type*
+  _value () const;
+
+  virtual xml_schema::type*
+  _value ();
+};
+
+void
+operator<< (xercesc::DOMElement&, const root&);
+
+ +

The xml_schema::element_type class is a common + base type for all element types and is defined as follows:

+ + 
+namespace xml_schema
+{
+  class element_type
+  {
+  public:
+    virtual
+    ~element_type ();
+
+    virtual element_type*
+    _clone (flags f = 0) const = 0;
+
+    virtual const std::basic_string<C>&
+    _name () const = 0;
+
+    virtual const std::basic_string<C>&
+    _namespace () const = 0;
+
+    virtual xml_schema::type*
+    _value () = 0;
+
+    virtual const xml_schema::type*
+    _value () const = 0;
+  };
+}
+
+ +

The _value() member function returns a pointer to + the element value or 0 if the element is of a fundamental C++ + type and therefore is not derived from xml_schema::type. +

+ +

Unlike parsing and serialization functions, element types + are only capable of parsing and serializing from/to a + DOMElement object. This means that the application + will need to perform its own XML-to-DOM parsing and DOM-to-XML + serialization. The following section describes a mechanism + provided by the mapping to uniformly parse and serialize + multiple root elements.

+ + +

2.9.2 Element Map

+ +

When element types are generated for root elements it is also + possible to request the generation of an element map with the + --generate-element-map option. The element map + allows uniform parsing and serialization of multiple root + elements via the common xml_schema::element_type + base type. The xml_schema::element_map class is + defined as follows:

+ + 
+namespace xml_schema
+{
+  class element_map
+  {
+  public:
+    static std::[unique|auto]_ptr<xml_schema::element_type>
+    parse (const xercesc::DOMElement&, flags = 0);
+
+    static void
+    serialize (xercesc::DOMElement&, const element_type&);
+  };
+}
+
+ +

The parse() function creates the corresponding + element type object based on the element name and namespace + and returns it as an automatic pointer (std::unique_ptr + or std::auto_ptr, depending on the C++ standard + selected) to xml_schema::element_type. + The serialize() function serializes the passed element + object to DOMElement. Note that in case of + serialize(), the DOMElement object + should have the correct name and namespace. If no element type is + available for an element, both functions throw the + xml_schema::no_element_info exception:

+ + 
+struct no_element_info: virtual exception
+{
+  no_element_info (const std::basic_string<C>& element_name,
+                   const std::basic_string<C>& element_namespace);
+
+  const std::basic_string<C>&
+  element_name () const;
+
+  const std::basic_string<C>&
+  element_namespace () const;
+
+  virtual const char*
+  what () const throw ();
+};
+
+ +

The application can discover the actual type of the element + object returned by parse() either using + dynamic_cast or by comparing element names and + namespaces. The following code fragments illustrate how the + element map can be used:

+ + 
+// Parsing.
+//
+DOMElement& e = ... // Parse XML to DOM.
+
+unique_ptr<xml_schema::element_type> r (
+  xml_schema::element_map::parse (e));
+
+if (root1 r1 = dynamic_cast<root1*> (r.get ()))
+{
+  ...
+}
+else if (r->_name == root2::name () &&
+         r->_namespace () == root2::namespace_ ())
+{
+  root2& r2 (static_cast<root2&> (*r));
+
+  ...
+}
+
+ + 
+// Serialization.
+//
+xml_schema::element_type& r = ...
+
+string name (r._name ());
+string ns (r._namespace ());
+
+DOMDocument& doc = ... // Create a new DOMDocument with name and ns.
+DOMElement& e (*doc->getDocumentElement ());
+
+xml_schema::element_map::serialize (e, r);
+
+// Serialize DOMDocument to XML.
+
+ + + +

2.10 Mapping for Global Attributes

+ +

An XML Schema attribute definition is called global if it appears + directly under the schema element. A global + attribute does not have any mapping. +

+ + + +

2.11 Mapping for xsi:type and Substitution + Groups

+ +

The mapping provides optional support for the XML Schema polymorphism + features (xsi:type and substitution groups) which can + be requested with the --generate-polymorphic option. + When used, the dynamic type of a member may be different from + its static type. Consider the following schema definition and + instance document: +

+ + 
+<!-- test.xsd -->
+<schema>
+  <complexType name="base">
+    <attribute name="text" type="string"/>
+  </complexType>
+
+  <complexType name="derived">
+    <complexContent>
+      <extension base="base">
+        <attribute name="extra-text" type="string"/>
+      </extension>
+    </complexContent>
+  </complexType>
+
+  <complexType name="root_type">
+    <sequence>
+      <element name="item" type="base" maxOccurs="unbounded"/>
+    </sequence>
+  </complexType>
+
+  <element name="root" type="root_type"/>
+</schema>
+
+<!-- test.xml -->
+<root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+  <item text="hello"/>
+  <item text="hello" extra-text="world" xsi:type="derived"/>
+</root>
+
+ +

In the resulting object model, the container for + the root::item member will have two elements: + the first element's type will be base while + the second element's (dynamic) type will be + derived. This can be discovered using the + dynamic_cast operator as shown in the following + example: +

+ + 
+void
+f (root& r)
+{
+  for (root::item_const_iterator i (r.item ().begin ());
+       i != r.item ().end ()
+       ++i)
+  {
+    if (derived* d = dynamic_cast<derived*> (&(*i)))
+    {
+      // derived
+    }
+    else
+    {
+      // base
+    }
+  }
+}
+
+ +

The _clone virtual function should be used instead of + copy constructors to make copies of members that might use + polymorphism: +

+ + 
+void
+f (root& r)
+{
+  for (root::item_const_iterator i (r.item ().begin ());
+       i != r.item ().end ()
+       ++i)
+  {
+    std::unique_ptr<base> c (i->_clone ());
+  }
+}
+
+ +

The mapping can often automatically determine which types are + polymorphic based on the substitution group declarations. However, + if your XML vocabulary is not using substitution groups or if + substitution groups are defined in a separate schema, then you will + need to use the --polymorphic-type option to specify + which types are polymorphic. When using this option you only need + to specify the root of a polymorphic type hierarchy and the mapping + will assume that all the derived types are also polymorphic. + Also note that you need to specify this option when compiling every + schema file that references the polymorphic type. Consider the following + two schemas as an example:

+ + 
+<!-- base.xsd -->
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+
+  <xs:complexType name="base">
+    <xs:sequence>
+      <xs:element name="b" type="xs:int"/>
+    </xs:sequence>
+  </xs:complexType>
+
+  <!-- substitution group root -->
+  <xs:element name="base" type="base"/>
+
+</xs:schema>
+
+ + 
+<!-- derived.xsd -->
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+
+  <include schemaLocation="base.xsd"/>
+
+  <xs:complexType name="derived">
+    <xs:complexContent>
+      <xs:extension base="base">
+        <xs:sequence>
+          <xs:element name="d" type="xs:string"/>
+        </xs:sequence>
+      </xs:extension>
+    </xs:complexContent>
+  </xs:complexType>
+
+  <xs:element name="derived" type="derived" substitutionGroup="base"/>
+
+</xs:schema>
+
+ +

In this example we need to specify "--polymorphic-type base" + when compiling both schemas because the substitution group is declared + in a schema other than the one defining type base.

+ +

You can also indicate that all types should be treated as polymorphic + with the --polymorphic-type-all. However, this may result + in slower generated code with a greater footprint.

+ + + + + +

2.12 Mapping for any and anyAttribute

+ +

For the XML Schema any and anyAttribute + wildcards an optional mapping can be requested with the + --generate-wildcard option. The mapping represents + the content matched by wildcards as DOM fragments. Because the + DOM API is used to access such content, the Xerces-C++ runtime + should be initialized by the application prior to parsing and + should remain initialized for the lifetime of objects with + the wildcard content. For more information on the Xerces-C++ + runtime initialization see Section 3.1, + "Initializing the Xerces-C++ Runtime". +

+ +

The mapping for any is similar to the mapping for + local elements (see Section 2.8, "Mapping for Local + Elements and Attributes") except that the type used in the + wildcard mapping is xercesc::DOMElement. As with local + elements, the mapping divides all possible cardinality combinations + into three cardinality classes: one, optional, and + sequence. +

+ +

The mapping for anyAttribute represents the attributes + matched by this wildcard as a set of xercesc::DOMAttr + objects with a key being the attribute's name and namespace.

+ +

Similar to local elements and attributes, the any and + anyAttribute wildcards are mapped to a set of public type + definitions (typedefs) and a set of public accessor and modifier + functions. Type definitions have names derived from "any" + for the any wildcard and "any_attribute" + for the anyAttribute wildcard. The accessor and modifier + functions are named "any" for the any wildcard + and "any_attribute" for the anyAttribute + wildcard. Subsequent wildcards in the same type have escaped names + such as "any1" or "any_attribute1". +

+ +

Because Xerces-C++ DOM nodes always belong to a DOMDocument, + each type with a wildcard has an associated DOMDocument + object. The reference to this object can be obtained using the accessor + function called dom_document. The access to the document + object from the application code may be necessary to create or modify + the wildcard content. For example: +

+ + 
+<complexType name="object">
+  <sequence>
+    <any namespace="##other"/>
+  </sequence>
+  <anyAttribute namespace="##other"/>
+</complexType>
+
+ +

is mapped to:

+ + 
+class object: public xml_schema::type
+{
+public:
+  // any
+  //
+  const xercesc::DOMElement&
+  any () const;
+
+  void
+  any (const xercesc::DOMElement&);
+
+  ...
+
+  // any_attribute
+  //
+  typedef attribute_set any_attribute_set;
+  typedef any_attribute_set::iterator any_attribute_iterator;
+  typedef any_attribute_set::const_iterator any_attribute_const_iterator;
+
+  const any_attribute_set&
+  any_attribute () const;
+
+  any_attribute_set&
+  any_attribute ();
+
+  ...
+
+  // DOMDocument object for wildcard content.
+  //
+  const xercesc::DOMDocument&
+  dom_document () const;
+
+  xercesc::DOMDocument&
+  dom_document ();
+
+  ...
+};
+
+ + +

Names and semantics of type definitions for the wildcards as well + as signatures of the accessor and modifier functions depend on the + wildcard type as well as the cardinality class for the any + wildcard. They are described in the following sub-sections. +

+ + +

2.12.1 Mapping for any with the One Cardinality Class

+ +

For any with the One cardinality class, + there are no type definitions. The accessor functions come in + constant and non-constant versions. The constant accessor function + returns a constant reference to xercesc::DOMElement and + can be used for read-only access. The non-constant version returns + an unrestricted reference to xercesc::DOMElement and can + be used for read-write access. +

+ +

The first modifier function expects an argument of type reference + to constant xercesc::DOMElement and makes a deep copy + of its argument. The second modifier function expects an argument of + type pointer to xercesc::DOMElement. This modifier + function assumes ownership of its argument and expects the element + object to be created using the DOM document associated with this + instance. For example: +

+ + 
+<complexType name="object">
+  <sequence>
+    <any namespace="##other"/>
+  </sequence>
+</complexType>
+
+ +

is mapped to:

+ + 
+class object: public xml_schema::type
+{
+public:
+  // Accessors.
+  //
+  const xercesc::DOMElement&
+  any () const;
+
+  xercesc::DOMElement&
+  any ();
+
+  // Modifiers.
+  //
+  void
+  any (const xercesc::DOMElement&);
+
+  void
+  any (xercesc::DOMElement*);
+
+  ...
+
+};
+
+ + +

The following code shows how one could use this mapping:

+ + 
+void
+f (object& o, const xercesc::DOMElement& e)
+{
+  using namespace xercesc;
+
+  DOMElement& e1 (o.any ());             // get
+  o.any (e)                              // set, deep copy
+  DOMDocument& doc (o.dom_document ());
+  o.any (doc.createElement (...));       // set, assumes ownership
+}
+
+ +

2.12.2 Mapping for any with the Optional Cardinality Class

+ +

For any with the Optional cardinality class, the type + definitions consist of an alias for the container type with name + any_optional (or any1_optional, etc., for + subsequent wildcards in the type definition). +

+ +

Unlike accessor functions for the One cardinality class, accessor + functions for the Optional cardinality class return references to + corresponding containers rather than directly to DOMElement. + The accessor functions come in constant and non-constant versions. + The constant accessor function returns a constant reference to + the container and can be used for read-only access. The non-constant + version returns an unrestricted reference to the container + and can be used for read-write access. +

+ +

The modifier functions are overloaded for xercesc::DOMElement + and the container type. The first modifier function expects an argument of + type reference to constant xercesc::DOMElement and + makes a deep copy of its argument. The second modifier function + expects an argument of type pointer to xercesc::DOMElement. + This modifier function assumes ownership of its argument and expects + the element object to be created using the DOM document associated + with this instance. The third modifier function expects an argument + of type reference to constant of the container type and makes a + deep copy of its argument. For instance: +

+ + 
+<complexType name="object">
+  <sequence>
+    <any namespace="##other" minOccurs="0"/>
+  </sequence>
+</complexType>
+
+ +

is mapped to:

+ + 
+class object: public xml_schema::type
+{
+public:
+  // Type definitions.
+  //
+  typedef element_optional any_optional;
+
+  // Accessors.
+  //
+  const any_optional&
+  any () const;
+
+  any_optional&
+  any ();
+
+  // Modifiers.
+  //
+  void
+  any (const xercesc::DOMElement&);
+
+  void
+  any (xercesc::DOMElement*);
+
+  void
+  any (const any_optional&);
+
+  ...
+
+};
+
+ + +

The element_optional container is a + specialization of the optional class template described + in Section 2.8.2, "Mapping for Members with the Optional + Cardinality Class". Its interface is presented below: +

+ + 
+class element_optional
+{
+public:
+  explicit
+  element_optional (xercesc::DOMDocument&);
+
+  // Makes a deep copy.
+  //
+  element_optional (const xercesc::DOMElement&, xercesc::DOMDocument&);
+
+  // Assumes ownership.
+  //
+  element_optional (xercesc::DOMElement*, xercesc::DOMDocument&);
+
+  element_optional (const element_optional&, xercesc::DOMDocument&);
+
+public:
+  element_optional&
+  operator= (const xercesc::DOMElement&);
+
+  element_optional&
+  operator= (const element_optional&);
+
+  // Pointer-like interface.
+  //
+public:
+  const xercesc::DOMElement*
+  operator-> () const;
+
+  xercesc::DOMElement*
+  operator-> ();
+
+  const xercesc::DOMElement&
+  operator* () const;
+
+  xercesc::DOMElement&
+  operator* ();
+
+  typedef void (element_optional::*bool_convertible) ();
+  operator bool_convertible () const;
+
+  // Get/set interface.
+  //
+public:
+  bool
+  present () const;
+
+  const xercesc::DOMElement&
+  get () const;
+
+  xercesc::DOMElement&
+  get ();
+
+  // Makes a deep copy.
+  //
+  void
+  set (const xercesc::DOMElement&);
+
+  // Assumes ownership.
+  //
+  void
+  set (xercesc::DOMElement*);
+
+  void
+  reset ();
+};
+
+bool
+operator== (const element_optional&, const element_optional&);
+
+bool
+operator!= (const element_optional&, const element_optional&);
+
+ + +

The following code shows how one could use this mapping:

+ + 
+void
+f (object& o, const xercesc::DOMElement& e)
+{
+  using namespace xercesc;
+
+  DOMDocument& doc (o.dom_document ());
+
+  if (o.any ().present ())                  // test
+  {
+    DOMElement& e1 (o.any ().get ());       // get
+    o.any ().set (e);                       // set, deep copy
+    o.any ().set (doc.createElement (...)); // set, assumes ownership
+    o.any ().reset ();                      // reset
+  }
+
+  // Same as above but using pointer notation:
+  //
+  if (o.member ())                          // test
+  {
+    DOMElement& e1 (*o.any ());             // get
+    o.any (e);                              // set, deep copy
+    o.any (doc.createElement (...));        // set, assumes ownership
+    o.any ().reset ();                      // reset
+  }
+}
+
+ + + +

2.12.3 Mapping for any with the Sequence Cardinality Class

+ +

For any with the Sequence cardinality class, the type + definitions consist of an alias of the container type with name + any_sequence (or any1_sequence, etc., for + subsequent wildcards in the type definition), an alias of the iterator + type with name any_iterator (or any1_iterator, + etc., for subsequent wildcards in the type definition), and an alias + of the constant iterator type with name any_const_iterator + (or any1_const_iterator, etc., for subsequent wildcards + in the type definition). +

+ +

The accessor functions come in constant and non-constant versions. + The constant accessor function returns a constant reference to the + container and can be used for read-only access. The non-constant + version returns an unrestricted reference to the container and can + be used for read-write access. +

+ +

The modifier function expects an argument of type reference to + constant of the container type. The modifier function makes + a deep copy of its argument. For instance: +

+ + + 
+<complexType name="object">
+  <sequence>
+    <any namespace="##other" minOccurs="unbounded"/>
+  </sequence>
+</complexType>
+
+ +

is mapped to:

+ + 
+class object: public xml_schema::type
+{
+public:
+  // Type definitions.
+  //
+  typedef element_sequence any_sequence;
+  typedef any_sequence::iterator any_iterator;
+  typedef any_sequence::const_iterator any_const_iterator;
+
+  // Accessors.
+  //
+  const any_sequence&
+  any () const;
+
+  any_sequence&
+  any ();
+
+  // Modifier.
+  //
+  void
+  any (const any_sequence&);
+
+  ...
+
+};
+
+ +

The element_sequence container is a + specialization of the sequence class template described + in Section 2.8.3, "Mapping for Members with the + Sequence Cardinality Class". Its interface is similar to + the sequence interface as defined by the ISO/ANSI Standard for + C++ (ISO/IEC 14882:1998, Section 23.1.1, "Sequences") and is + presented below: +

+ + 
+class element_sequence
+{
+public:
+  typedef xercesc::DOMElement        value_type;
+  typedef xercesc::DOMElement*       pointer;
+  typedef const xercesc::DOMElement* const_pointer;
+  typedef xercesc::DOMElement&       reference;
+  typedef const xercesc::DOMElement& const_reference;
+
+  typedef <implementation-defined>   iterator;
+  typedef <implementation-defined>   const_iterator;
+  typedef <implementation-defined>   reverse_iterator;
+  typedef <implementation-defined>   const_reverse_iterator;
+
+  typedef <implementation-defined>   size_type;
+  typedef <implementation-defined>   difference_type;
+  typedef <implementation-defined>   allocator_type;
+
+public:
+  explicit
+  element_sequence (xercesc::DOMDocument&);
+
+  // DOMElement cannot be default-constructed.
+  //
+  // explicit
+  // element_sequence (size_type n);
+
+  element_sequence (size_type n,
+                    const xercesc::DOMElement&,
+                    xercesc::DOMDocument&);
+
+  template <typename I>
+  element_sequence (const I& begin,
+                    const I& end,
+                    xercesc::DOMDocument&);
+
+  element_sequence (const element_sequence&, xercesc::DOMDocument&);
+
+  element_sequence&
+  operator= (const element_sequence&);
+
+public:
+  void
+  assign (size_type n, const xercesc::DOMElement&);
+
+  template <typename I>
+  void
+  assign (const I& begin, const I& end);
+
+public:
+  // This version of resize can only be used to shrink the
+  // sequence because DOMElement cannot be default-constructed.
+  //
+  void
+  resize (size_type);
+
+  void
+  resize (size_type, const xercesc::DOMElement&);
+
+public:
+  size_type
+  size () const;
+
+  size_type
+  max_size () const;
+
+  size_type
+  capacity () const;
+
+  bool
+  empty () const;
+
+  void
+  reserve (size_type);
+
+  void
+  clear ();
+
+public:
+  const_iterator
+  begin () const;
+
+  const_iterator
+  end () const;
+
+  iterator
+  begin ();
+
+  iterator
+  end ();
+
+  const_reverse_iterator
+  rbegin () const;
+
+  const_reverse_iterator
+  rend () const
+
+    reverse_iterator
+  rbegin ();
+
+  reverse_iterator
+  rend ();
+
+public:
+  xercesc::DOMElement&
+  operator[] (size_type);
+
+  const xercesc::DOMElement&
+  operator[] (size_type) const;
+
+  xercesc::DOMElement&
+  at (size_type);
+
+  const xercesc::DOMElement&
+  at (size_type) const;
+
+  xercesc::DOMElement&
+  front ();
+
+  const xercesc::DOMElement&
+  front () const;
+
+  xercesc::DOMElement&
+  back ();
+
+  const xercesc::DOMElement&
+  back () const;
+
+public:
+  // Makes a deep copy.
+  //
+  void
+  push_back (const xercesc::DOMElement&);
+
+  // Assumes ownership.
+  //
+  void
+  push_back (xercesc::DOMElement*);
+
+  void
+  pop_back ();
+
+  // Makes a deep copy.
+  //
+  iterator
+  insert (iterator position, const xercesc::DOMElement&);
+
+  // Assumes ownership.
+  //
+  iterator
+  insert (iterator position, xercesc::DOMElement*);
+
+  void
+  insert (iterator position, size_type n, const xercesc::DOMElement&);
+
+  template <typename I>
+  void
+  insert (iterator position, const I& begin, const I& end);
+
+  iterator
+  erase (iterator position);
+
+  iterator
+  erase (iterator begin, iterator end);
+
+public:
+  // Note that the DOMDocument object of the two sequences being
+  // swapped should be the same.
+  //
+  void
+  swap (sequence& x);
+};
+
+inline bool
+operator== (const element_sequence&, const element_sequence&);
+
+inline bool
+operator!= (const element_sequence&, const element_sequence&);
+
+ + +

The following code shows how one could use this mapping:

+ + 
+void
+f (object& o, const xercesc::DOMElement& e)
+{
+  using namespace xercesc;
+
+  object::any_sequence& s (o.any ());
+
+  // Iteration.
+  //
+  for (object::any_iterator i (s.begin ()); i != s.end (); ++i)
+  {
+    DOMElement& e (*i);
+  }
+
+  // Modification.
+  //
+  s.push_back (e);                       // deep copy
+  DOMDocument& doc (o.dom_document ());
+  s.push_back (doc.createElement (...)); // assumes ownership
+}
+
+ +

2.12.4 Element Wildcard Order

+ +

Similar to elements, element wildcards in ordered types + (Section 2.8.4, "Element Order") are assigned + content ids and are included in the content order sequence. + Continuing with the bank transactions example started in Section + 2.8.4, we can extend the batch by allowing custom transactions:

+ + 
+<complexType name="batch">
+  <choice minOccurs="0" maxOccurs="unbounded">
+    <element name="withdraw" type="withdraw"/>
+    <element name="deposit" type="deposit"/>
+    <any namespace="##other" processContents="lax"/>
+  </choice>
+</complexType>
+
+ +

This will lead to the following changes in the generated + batch C++ class:

+ + 
+class batch: public xml_schema::type
+{
+public:
+  ...
+
+  // any
+  //
+  typedef element_sequence any_sequence;
+  typedef any_sequence::iterator any_iterator;
+  typedef any_sequence::const_iterator any_const_iterator;
+
+  static const std::size_t any_id = 3UL;
+
+  const any_sequence&
+  any () const;
+
+  any_sequence&
+  any ();
+
+  void
+  any (const any_sequence&);
+
+  ...
+};
+
+ +

With this change we also need to update the iteration code to handle + the new content id:

+ + 
+for (batch::content_order_const_iterator i (b.content_order ().begin ());
+     i != b.content_order ().end ();
+     ++i)
+{
+  switch (i->id)
+  {
+    ...
+
+  case batch::any_id:
+    {
+      const DOMElement& e (b.any ()[i->index]);
+      ...
+      break;
+    }
+
+    ...
+  }
+}
+
+ +

For the complete working code that shows the use of wildcards in + ordered types refer to the order/element example in + the cxx/tree/ directory in the + xsd-examples + package.

+ +

2.12.5 Mapping for anyAttribute

+ +

For anyAttribute the type definitions consist of an alias + of the container type with name any_attribute_set + (or any1_attribute_set, etc., for subsequent wildcards + in the type definition), an alias of the iterator type with name + any_attribute_iterator (or any1_attribute_iterator, + etc., for subsequent wildcards in the type definition), and an alias + of the constant iterator type with name any_attribute_const_iterator + (or any1_attribute_const_iterator, etc., for subsequent + wildcards in the type definition). +

+ +

The accessor functions come in constant and non-constant versions. + The constant accessor function returns a constant reference to the + container and can be used for read-only access. The non-constant + version returns an unrestricted reference to the container and can + be used for read-write access. +

+ +

The modifier function expects an argument of type reference to + constant of the container type. The modifier function makes + a deep copy of its argument. For instance: +

+ + + 
+<complexType name="object">
+  <sequence>
+    ...
+  </sequence>
+  <anyAttribute namespace="##other"/>
+</complexType>
+
+ +

is mapped to:

+ + 
+class object: public xml_schema::type
+{
+public:
+  // Type definitions.
+  //
+  typedef attribute_set any_attribute_set;
+  typedef any_attribute_set::iterator any_attribute_iterator;
+  typedef any_attribute_set::const_iterator any_attribute_const_iterator;
+
+  // Accessors.
+  //
+  const any_attribute_set&
+  any_attribute () const;
+
+  any_attribute_set&
+  any_attribute ();
+
+  // Modifier.
+  //
+  void
+  any_attribute (const any_attribute_set&);
+
+  ...
+
+};
+
+ +

The attribute_set class is an associative container + similar to the std::set class template as defined by + the ISO/ANSI Standard for C++ (ISO/IEC 14882:1998, Section 23.3.3, + "Class template set") with the key being the attribute's name + and namespace. Unlike std::set, attribute_set + allows searching using names and namespaces instead of + xercesc::DOMAttr objects. It is defined in an + implementation-specific namespace and its interface is presented + below: +

+ + 
+class attribute_set
+{
+public:
+  typedef xercesc::DOMAttr         key_type;
+  typedef xercesc::DOMAttr         value_type;
+  typedef xercesc::DOMAttr*        pointer;
+  typedef const xercesc::DOMAttr*  const_pointer;
+  typedef xercesc::DOMAttr&        reference;
+  typedef const xercesc::DOMAttr&  const_reference;
+
+  typedef <implementation-defined> iterator;
+  typedef <implementation-defined> const_iterator;
+  typedef <implementation-defined> reverse_iterator;
+  typedef <implementation-defined> const_reverse_iterator;
+
+  typedef <implementation-defined> size_type;
+  typedef <implementation-defined> difference_type;
+  typedef <implementation-defined> allocator_type;
+
+public:
+  attribute_set (xercesc::DOMDocument&);
+
+  template <typename I>
+  attribute_set (const I& begin, const I& end, xercesc::DOMDocument&);
+
+  attribute_set (const attribute_set&, xercesc::DOMDocument&);
+
+  attribute_set&
+  operator= (const attribute_set&);
+
+public:
+  const_iterator
+  begin () const;
+
+  const_iterator
+  end () const;
+
+  iterator
+  begin ();
+
+  iterator
+  end ();
+
+  const_reverse_iterator
+  rbegin () const;
+
+  const_reverse_iterator
+  rend () const;
+
+  reverse_iterator
+  rbegin ();
+
+  reverse_iterator
+  rend ();
+
+public:
+  size_type
+  size () const;
+
+  size_type
+  max_size () const;
+
+  bool
+  empty () const;
+
+  void
+  clear ();
+
+public:
+  // Makes a deep copy.
+  //
+  std::pair<iterator, bool>
+  insert (const xercesc::DOMAttr&);
+
+  // Assumes ownership.
+  //
+  std::pair<iterator, bool>
+  insert (xercesc::DOMAttr*);
+
+  // Makes a deep copy.
+  //
+  iterator
+  insert (iterator position, const xercesc::DOMAttr&);
+
+  // Assumes ownership.
+  //
+  iterator
+  insert (iterator position, xercesc::DOMAttr*);
+
+  template <typename I>
+  void
+  insert (const I& begin, const I& end);
+
+public:
+  void
+  erase (iterator position);
+
+  size_type
+  erase (const std::basic_string<C>& name);
+
+  size_type
+  erase (const std::basic_string<C>& namespace_,
+         const std::basic_string<C>& name);
+
+  size_type
+  erase (const XMLCh* name);
+
+  size_type
+  erase (const XMLCh* namespace_, const XMLCh* name);
+
+  void
+  erase (iterator begin, iterator end);
+
+public:
+  size_type
+  count (const std::basic_string<C>& name) const;
+
+  size_type
+  count (const std::basic_string<C>& namespace_,
+         const std::basic_string<C>& name) const;
+
+  size_type
+  count (const XMLCh* name) const;
+
+  size_type
+  count (const XMLCh* namespace_, const XMLCh* name) const;
+
+  iterator
+  find (const std::basic_string<C>& name);
+
+  iterator
+  find (const std::basic_string<C>& namespace_,
+        const std::basic_string<C>& name);
+
+  iterator
+  find (const XMLCh* name);
+
+  iterator
+  find (const XMLCh* namespace_, const XMLCh* name);
+
+  const_iterator
+  find (const std::basic_string<C>& name) const;
+
+  const_iterator
+  find (const std::basic_string<C>& namespace_,
+        const std::basic_string<C>& name) const;
+
+  const_iterator
+  find (const XMLCh* name) const;
+
+  const_iterator
+  find (const XMLCh* namespace_, const XMLCh* name) const;
+
+public:
+  // Note that the DOMDocument object of the two sets being
+  // swapped should be the same.
+  //
+  void
+  swap (attribute_set&);
+};
+
+bool
+operator== (const attribute_set&, const attribute_set&);
+
+bool
+operator!= (const attribute_set&, const attribute_set&);
+
+ +

The following code shows how one could use this mapping:

+ + 
+void
+f (object& o, const xercesc::DOMAttr& a)
+{
+  using namespace xercesc;
+
+  object::any_attribute_set& s (o.any_attribute ());
+
+  // Iteration.
+  //
+  for (object::any_attribute_iterator i (s.begin ()); i != s.end (); ++i)
+  {
+    DOMAttr& a (*i);
+  }
+
+  // Modification.
+  //
+  s.insert (a);                         // deep copy
+  DOMDocument& doc (o.dom_document ());
+  s.insert (doc.createAttribute (...)); // assumes ownership
+
+  // Searching.
+  //
+  object::any_attribute_iterator i (s.find ("name"));
+  i = s.find ("http://www.w3.org/XML/1998/namespace", "lang");
+}
+
+ + + +

2.13 Mapping for Mixed Content Models

+ +

For XML Schema types with mixed content models C++/Tree provides + mapping support only if the type is marked as ordered + (Section 2.8.4, "Element Order"). Use the + --ordered-type-mixed XSD compiler option to + automatically mark all types with mixed content as ordered.

+ +

For an ordered type with mixed content, C++/Tree adds an extra + text content sequence that is used to store the text fragments. + This text content sequence is also assigned the content id and + its entries are included in the content order sequence, just + like elements. As a result, it is possible to capture the order + between elements and text fragments.

+ +

As an example, consider the following schema that describes text + with embedded links:

+ + 
+<complexType name="anchor">
+  <simpleContent>
+    <extension base="string">
+      <attribute name="href" type="anyURI" use="required"/>
+    </extension>
+  </simpleContent>
+</complexType>
+
+<complexType name="text" mixed="true">
+  <sequence>
+    <element name="a" type="anchor" minOccurs="0" maxOccurs="unbounded"/>
+  </sequence>
+</complexType>
+
+ +

The generated text C++ class will provide the following + API (assuming it is marked as ordered):

+ + 
+class text: public xml_schema::type
+{
+public:
+  // a
+  //
+  typedef anchor a_type;
+  typedef sequence<a_type> a_sequence;
+  typedef a_sequence::iterator a_iterator;
+  typedef a_sequence::const_iterator a_const_iterator;
+
+  static const std::size_t a_id = 1UL;
+
+  const a_sequence&
+  a () const;
+
+  a_sequence&
+  a ();
+
+  void
+  a (const a_sequence&);
+
+  // text_content
+  //
+  typedef xml_schema::string text_content_type;
+  typedef sequence<text_content_type> text_content_sequence;
+  typedef text_content_sequence::iterator text_content_iterator;
+  typedef text_content_sequence::const_iterator text_content_const_iterator;
+
+  static const std::size_t text_content_id = 2UL;
+
+  const text_content_sequence&
+  text_content () const;
+
+  text_content_sequence&
+  text_content ();
+
+  void
+  text_content (const text_content_sequence&);
+
+  // content_order
+  //
+  typedef xml_schema::content_order content_order_type;
+  typedef std::vector<content_order_type> content_order_sequence;
+  typedef content_order_sequence::iterator content_order_iterator;
+  typedef content_order_sequence::const_iterator content_order_const_iterator;
+
+  const content_order_sequence&
+  content_order () const;
+
+  content_order_sequence&
+  content_order ();
+
+  void
+  content_order (const content_order_sequence&);
+
+  ...
+};
+
+ +

Given this interface we can iterate over both link elements + and text in content order. The following code fragment converts + our format to plain text with references.

+ + 
+const text& t = ...
+
+for (text::content_order_const_iterator i (t.content_order ().begin ());
+     i != t.content_order ().end ();
+     ++i)
+{
+  switch (i->id)
+  {
+  case text::a_id:
+    {
+      const anchor& a (t.a ()[i->index]);
+      cerr << a << "[" << a.href () << "]";
+      break;
+    }
+  case text::text_content_id:
+    {
+      const xml_schema::string& s (t.text_content ()[i->index]);
+      cerr << s;
+      break;
+    }
+  default:
+    {
+      assert (false); // Unknown content id.
+    }
+  }
+}
+
+ +

For the complete working code that shows the use of mixed content + in ordered types refer to the order/mixed example in + the cxx/tree/ directory in the + xsd-examples + package.

+ + + + +

3 Parsing

+ +

This chapter covers various aspects of parsing XML instance + documents in order to obtain corresponding tree-like object + model. +

+ +

Each global XML Schema element in the form:

+ + 
+<element name="name" type="type"/>
+
+ +

is mapped to 14 overloaded C++ functions in the form:

+ + 
+// Read from a URI or a local file.
+//
+
+std::[unique|auto]_ptr<type>
+name (const std::basic_string<C>& uri,
+      xml_schema::flags = 0,
+      const xml_schema::properties& = xml_schema::properties ());
+
+std::[unique|auto]_ptr<type>
+name (const std::basic_string<C>& uri,
+      xml_schema::error_handler&,
+      xml_schema::flags = 0,
+      const xml_schema::properties& = xml_schema::properties ());
+
+std::[unique|auto]_ptr<type>
+name (const std::basic_string<C>& uri,
+      xercesc::DOMErrorHandler&,
+      xml_schema::flags = 0,
+      const xml_schema::properties& = xml_schema::properties ());
+
+
+// Read from std::istream.
+//
+
+std::[unique|auto]_ptr<type>
+name (std::istream&,
+      xml_schema::flags = 0,
+      const xml_schema::properties& = xml_schema::properties ());
+
+std::[unique|auto]_ptr<type>
+name (std::istream&,
+      xml_schema::error_handler&,
+      xml_schema::flags = 0,
+      const xml_schema::properties& = xml_schema::properties ());
+
+std::[unique|auto]_ptr<type>
+name (std::istream&,
+      xercesc::DOMErrorHandler&,
+      xml_schema::flags = 0,
+      const xml_schema::properties& = xml_schema::properties ());
+
+
+std::[unique|auto]_ptr<type>
+name (std::istream&,
+      const std::basic_string<C>& id,
+      xml_schema::flags = 0,
+      const xml_schema::properties& = xml_schema::properties ());
+
+std::[unique|auto]_ptr<type>
+name (std::istream&,
+      const std::basic_string<C>& id,
+      xml_schema::error_handler&,
+      xml_schema::flags = 0,
+      const xml_schema::properties& = xml_schema::properties ());
+
+std::[unique|auto]_ptr<type>
+name (std::istream&,
+      const std::basic_string<C>& id,
+      xercesc::DOMErrorHandler&,
+      xml_schema::flags = 0,
+      const xml_schema::properties& = xml_schema::properties ());
+
+
+// Read from InputSource.
+//
+
+std::[unique|auto]_ptr<type>
+name (xercesc::InputSource&,
+      xml_schema::flags = 0,
+      const xml_schema::properties& = xml_schema::properties ());
+
+std::[unique|auto]_ptr<type>
+name (xercesc::InputSource&,
+      xml_schema::error_handler&,
+      xml_schema::flags = 0,
+      const xml_schema::properties& = xml_schema::properties ());
+
+std::[unique|auto]_ptr<type>
+name (xercesc::InputSource&,
+      xercesc::DOMErrorHandler&,
+      xml_schema::flags = 0,
+      const xml_schema::properties& = xml_schema::properties ());
+
+
+// Read from DOM.
+//
+
+std::[unique|auto]_ptr<type>
+name (const xercesc::DOMDocument&,
+      xml_schema::flags = 0,
+      const xml_schema::properties& = xml_schema::properties ());
+
+std::[unique|auto]_ptr<type>
+name (xml_schema::dom::[unique|auto]_ptr<xercesc::DOMDocument>,
+      xml_schema::flags = 0,
+      const xml_schema::properties& = xml_schema::properties ());
+
+ +

You can choose between reading an XML instance from a local file, + URI, std::istream, xercesc::InputSource, + or a pre-parsed DOM instance in the form of + xercesc::DOMDocument. All the parsing functions + return a dynamically allocated object model as either + std::unique_ptr or std::auto_ptr, + depending on the C++ standard selected. Each of these parsing + functions is discussed in more detail in the following sections. +

+ +

3.1 Initializing the Xerces-C++ Runtime

+ +

Some parsing functions expect you to initialize the Xerces-C++ + runtime while others initialize and terminate it as part of their + work. The general rule is as follows: if a function has any arguments + or return a value that is an instance of a Xerces-C++ type, then + this function expects you to initialize the Xerces-C++ runtime. + Otherwise, the function initializes and terminates the runtime for + you. Note that it is legal to have nested calls to the Xerces-C++ + initialize and terminate functions as long as the calls are balanced. +

+ +

You can instruct parsing functions that initialize and terminate + the runtime not to do so by passing the + xml_schema::flags::dont_initialize flag (see + Section 3.2, "Flags and Properties"). +

+ + +

3.2 Flags and Properties

+ +

Parsing flags and properties are the last two arguments of every + parsing function. They allow you to fine-tune the process of + instance validation and parsing. Both arguments are optional. +

+ + +

The following flags are recognized by the parsing functions:

+ +
+
xml_schema::flags::keep_dom
+
Keep association between DOM nodes and the resulting + object model nodes. For more information about DOM association + refer to Section 5.1, "DOM Association".
+ +
xml_schema::flags::own_dom
+
Assume ownership of the DOM document passed. This flag only + makes sense together with the keep_dom flag in + the call to the parsing function with the + xml_schema::dom::[unique|auto]_ptr<DOMDocument> + argument.
+ +
xml_schema::flags::dont_validate
+
Do not validate instance documents against schemas.
+ +
xml_schema::flags::dont_initialize
+
Do not initialize the Xerces-C++ runtime.
+
+ +

You can pass several flags by combining them using the bit-wise OR + operator. For example:

+ + 
+using xml_schema::flags;
+
+std::unique_ptr<type> r (
+  name ("test.xml", flags::keep_dom | flags::dont_validate));
+
+ +

By default, validation of instance documents is turned on even + though parsers generated by XSD do not assume instance + documents are valid. They include a number of checks that prevent + construction of inconsistent object models. This, + however, does not mean that an instance document that was + successfully parsed by the XSD-generated parsers is + valid per the corresponding schema. If an instance document is not + "valid enough" for the generated parsers to construct consistent + object model, one of the exceptions defined in + xml_schema namespace is thrown (see + Section 3.3, "Error Handling"). +

+ +

For more information on the Xerces-C++ runtime initialization + refer to Section 3.1, "Initializing the Xerces-C++ + Runtime". +

+ +

The xml_schema::properties class allows you to + programmatically specify schema locations to be used instead + of those specified with the xsi::schemaLocation + and xsi::noNamespaceSchemaLocation attributes + in instance documents. The interface of the properties + class is presented below: +

+ + 
+class properties
+{
+public:
+  void
+  schema_location (const std::basic_string<C>& namespace_,
+                   const std::basic_string<C>& location);
+  void
+  no_namespace_schema_location (const std::basic_string<C>& location);
+};
+
+ +

Note that all locations are relative to an instance document unless + they are URIs. For example, if you want to use a local file as your + schema, then you will need to pass + file:///absolute/path/to/your/schema as the location + argument. +

+ +

3.3 Error Handling

+ +

As discussed in Section 2.2, "Error Handling", + the mapping uses the C++ exception handling mechanism as its primary + way of reporting error conditions. However, to handle recoverable + parsing and validation errors and warnings, a callback interface maybe + preferred by the application.

+ +

To better understand error handling and reporting strategies employed + by the parsing functions, it is useful to know that the + transformation of an XML instance document to a statically-typed + tree happens in two stages. The first stage, performed by Xerces-C++, + consists of parsing an XML document into a DOM instance. For short, + we will call this stage the XML-DOM stage. Validation, if not disabled, + happens during this stage. The second stage, + performed by the generated parsers, consist of parsing the DOM + instance into the statically-typed tree. We will call this stage + the DOM-Tree stage. Additional checks are performed during this + stage in order to prevent construction of inconsistent tree which + could otherwise happen when validation is disabled, for example.

+ +

All parsing functions except the one that operates on a DOM instance + come in overloaded triples. The first function in such a triple + reports error conditions exclusively by throwing exceptions. It + accumulates all the parsing and validation errors of the XML-DOM + stage and throws them in a single instance of the + xml_schema::parsing exception (described below). + The second and the third functions in the triple use callback + interfaces to report parsing and validation errors and warnings. + The two callback interfaces are xml_schema::error_handler + and xercesc::DOMErrorHandler. For more information + on the xercesc::DOMErrorHandler interface refer to + the Xerces-C++ documentation. The xml_schema::error_handler + interface is presented below: +

+ + 
+class error_handler
+{
+public:
+  struct severity
+  {
+    enum value
+    {
+      warning,
+      error,
+      fatal
+    };
+  };
+
+  virtual bool
+  handle (const std::basic_string<C>& id,
+          unsigned long line,
+          unsigned long column,
+          severity,
+          const std::basic_string<C>& message) = 0;
+
+  virtual
+  ~error_handler ();
+};
+
+ +

The id argument of the error_handler::handle + function identifies the resource being parsed (e.g., a file name or + URI). +

+ +

By returning true from the handle function + you instruct the parser to recover and continue parsing. Returning + false results in termination of the parsing process. + An error with the fatal severity level results in + termination of the parsing process no matter what is returned from + the handle function. It is safe to throw an exception + from the handle function. +

+ +

The DOM-Tree stage reports error conditions exclusively by throwing + exceptions. Individual exceptions thrown by the parsing functions + are described in the following sub-sections. +

+ + +

3.3.1 xml_schema::parsing

+ + 
+struct severity
+{
+  enum value
+  {
+    warning,
+    error
+  };
+
+  severity (value);
+  operator value () const;
+};
+
+struct error
+{
+  error (severity,
+         const std::basic_string<C>& id,
+         unsigned long line,
+         unsigned long column,
+         const std::basic_string<C>& message);
+
+  severity
+  severity () const;
+
+  const std::basic_string<C>&
+  id () const;
+
+  unsigned long
+  line () const;
+
+  unsigned long
+  column () const;
+
+  const std::basic_string<C>&
+  message () const;
+};
+
+std::basic_ostream<C>&
+operator<< (std::basic_ostream<C>&, const error&);
+
+struct diagnostics: std::vector<error>
+{
+};
+
+std::basic_ostream<C>&
+operator<< (std::basic_ostream<C>&, const diagnostics&);
+
+struct parsing: virtual exception
+{
+  parsing ();
+  parsing (const diagnostics&);
+
+  const diagnostics&
+  diagnostics () const;
+
+  virtual const char*
+  what () const throw ();
+};
+
+ +

The xml_schema::parsing exception is thrown if there + were parsing or validation errors reported during the XML-DOM stage. + If no callback interface was provided to the parsing function, the + exception contains a list of errors and warnings accessible using + the diagnostics function. The usual conditions when + this exception is thrown include malformed XML instances and, if + validation is turned on, invalid instance documents. +

+ +

3.3.2 xml_schema::expected_element

+ + 
+struct expected_element: virtual exception
+{
+  expected_element (const std::basic_string<C>& name,
+                    const std::basic_string<C>& namespace_);
+
+
+  const std::basic_string<C>&
+  name () const;
+
+  const std::basic_string<C>&
+  namespace_ () const;
+
+
+  virtual const char*
+  what () const throw ();
+};
+
+ +

The xml_schema::expected_element exception is thrown + when an expected element is not encountered by the DOM-Tree stage. + The name and namespace of the expected element can be obtained using + the name and namespace_ functions respectively. +

+ + +

3.3.3 xml_schema::unexpected_element

+ + 
+struct unexpected_element: virtual exception
+{
+  unexpected_element (const std::basic_string<C>& encountered_name,
+                      const std::basic_string<C>& encountered_namespace,
+                      const std::basic_string<C>& expected_name,
+                      const std::basic_string<C>& expected_namespace)
+
+
+  const std::basic_string<C>&
+  encountered_name () const;
+
+  const std::basic_string<C>&
+  encountered_namespace () const;
+
+
+  const std::basic_string<C>&
+  expected_name () const;
+
+  const std::basic_string<C>&
+  expected_namespace () const;
+
+
+  virtual const char*
+  what () const throw ();
+};
+
+ +

The xml_schema::unexpected_element exception is thrown + when an unexpected element is encountered by the DOM-Tree stage. + The name and namespace of the encountered element can be obtained + using the encountered_name and + encountered_namespace functions respectively. If an + element was expected instead of the encountered one, its name + and namespace can be obtained using the expected_name and + expected_namespace functions respectively. Otherwise + these functions return empty strings. +

+ +

3.3.4 xml_schema::expected_attribute

+ + 
+struct expected_attribute: virtual exception
+{
+  expected_attribute (const std::basic_string<C>& name,
+                      const std::basic_string<C>& namespace_);
+
+
+  const std::basic_string<C>&
+  name () const;
+
+  const std::basic_string<C>&
+  namespace_ () const;
+
+
+  virtual const char*
+  what () const throw ();
+};
+
+ +

The xml_schema::expected_attribute exception is thrown + when an expected attribute is not encountered by the DOM-Tree stage. + The name and namespace of the expected attribute can be obtained using + the name and namespace_ functions respectively. +

+ + +

3.3.5 xml_schema::unexpected_enumerator

+ + 
+struct unexpected_enumerator: virtual exception
+{
+  unexpected_enumerator (const std::basic_string<C>& enumerator);
+
+  const std::basic_string<C>&
+  enumerator () const;
+
+  virtual const char*
+  what () const throw ();
+};
+
+ +

The xml_schema::unexpected_enumerator exception is thrown + when an unexpected enumerator is encountered by the DOM-Tree stage. + The enumerator can be obtained using the enumerator + functions. +

+ +

3.3.6 xml_schema::expected_text_content

+ + 
+struct expected_text_content: virtual exception
+{
+  virtual const char*
+  what () const throw ();
+};
+
+ +

The xml_schema::expected_text_content exception is thrown + when a content other than text is encountered and the text content was + expected by the DOM-Tree stage. +

+ +

3.3.7 xml_schema::no_type_info

+ + 
+struct no_type_info: virtual exception
+{
+  no_type_info (const std::basic_string<C>& type_name,
+                const std::basic_string<C>& type_namespace);
+
+  const std::basic_string<C>&
+  type_name () const;
+
+  const std::basic_string<C>&
+  type_namespace () const;
+
+  virtual const char*
+  what () const throw ();
+};
+
+ +

The xml_schema::no_type_info exception is thrown + when there is no type information associated with a type specified + by the xsi:type attribute. This exception is thrown + by the DOM-Tree stage. The name and namespace of the type in question + can be obtained using the type_name and + type_namespace functions respectively. Usually, catching + this exception means that you haven't linked the code generated + from the schema defining the type in question with your application + or this schema has been compiled without the + --generate-polymorphic option. +

+ + +

3.3.8 xml_schema::not_derived

+ + 
+struct not_derived: virtual exception
+{
+  not_derived (const std::basic_string<C>& base_type_name,
+               const std::basic_string<C>& base_type_namespace,
+               const std::basic_string<C>& derived_type_name,
+               const std::basic_string<C>& derived_type_namespace);
+
+  const std::basic_string<C>&
+  base_type_name () const;
+
+  const std::basic_string<C>&
+  base_type_namespace () const;
+
+
+  const std::basic_string<C>&
+  derived_type_name () const;
+
+  const std::basic_string<C>&
+  derived_type_namespace () const;
+
+  virtual const char*
+  what () const throw ();
+};
+
+ +

The xml_schema::not_derived exception is thrown + when a type specified by the xsi:type attribute is + not derived from the expected base type. This exception is thrown + by the DOM-Tree stage. The name and namespace of the expected + base type can be obtained using the base_type_name and + base_type_namespace functions respectively. The name + and namespace of the offending type can be obtained using the + derived_type_name and + derived_type_namespace functions respectively. +

+ +

3.3.9 xml_schema::no_prefix_mapping

+ + 
+struct no_prefix_mapping: virtual exception
+{
+  no_prefix_mapping (const std::basic_string<C>& prefix);
+
+  const std::basic_string<C>&
+  prefix () const;
+
+  virtual const char*
+  what () const throw ();
+};
+
+ +

The xml_schema::no_prefix_mapping exception is thrown + during the DOM-Tree stage if a namespace prefix is encountered for + which a prefix-namespace mapping hasn't been provided. The namespace + prefix in question can be obtained using the prefix + function. +

+ +

3.4 Reading from a Local File or URI

+ +

Using a local file or URI is the simplest way to parse an XML instance. + For example:

+ + 
+using std::unique_ptr;
+
+unique_ptr<type> r1 (name ("test.xml"));
+unique_ptr<type> r2 (name ("https://www.codesynthesis.com/test.xml"));
+
+ +

Or, in the C++98 mode:

+ + 
+using std::auto_ptr;
+
+auto_ptr<type> r1 (name ("test.xml"));
+auto_ptr<type> r2 (name ("https://www.codesynthesis.com/test.xml"));
+
+ +

3.5 Reading from std::istream

+ +

When using an std::istream instance, you may also + pass an optional resource id. This id is used to identify the + resource (for example in error messages) as well as to resolve + relative paths. For instance:

+ + 
+using std::unique_ptr;
+
+{
+  std::ifstream ifs ("test.xml");
+  unique_ptr<type> r (name (ifs, "test.xml"));
+}
+
+{
+  std::string str ("..."); // Some XML fragment.
+  std::istringstream iss (str);
+  unique_ptr<type> r (name (iss));
+}
+
+ +

3.6 Reading from xercesc::InputSource

+ +

Reading from a xercesc::InputSource instance + is similar to the std::istream case except + the resource id is maintained by the InputSource + object. For instance:

+ + 
+xercesc::StdInInputSource is;
+std::unique_ptr<type> r (name (is));
+
+ +

3.7 Reading from DOM

+ +

Reading from a xercesc::DOMDocument instance allows + you to setup a custom XML-DOM stage. Things like DOM + parser reuse, schema pre-parsing, and schema caching can be achieved + with this approach. For more information on how to obtain DOM + representation from an XML instance refer to the Xerces-C++ + documentation. In addition, the + C++/Tree Mapping + FAQ shows how to parse an XML instance to a Xerces-C++ + DOM document using the XSD runtime utilities. +

+ +

The last parsing function is useful when you would like to perform + your own XML-to-DOM parsing and associate the resulting DOM document + with the object model nodes. The automatic DOMDocument + pointer is reset and the resulting object model assumes ownership + of the DOM document passed. For example:

+ + 
+// C++11 version.
+//
+xml_schema::dom::unique_ptr<xercesc::DOMDocument> doc = ...
+
+std::unique_ptr<type> r (
+  name (std::move (doc),
+        xml_schema::flags::keep_dom | xml_schema::flags::own_dom));
+
+// At this point doc is reset to 0.
+
+// C++98 version.
+//
+xml_schema::dom::auto_ptr<xercesc::DOMDocument> doc = ...
+
+std::auto_ptr<type> r (
+  name (doc, xml_schema::flags::keep_dom | xml_schema::flags::own_dom));
+
+// At this point doc is reset to 0.
+
+ +

4 Serialization

+ +

This chapter covers various aspects of serializing a + tree-like object model to DOM or XML. + In this regard, serialization is complimentary to the reverse + process of parsing a DOM or XML instance into an object model + which is discussed in Chapter 3, + "Parsing". Note that the generation of the serialization code + is optional and should be explicitly requested with the + --generate-serialization option. See the + XSD + Compiler Command Line Manual for more information. +

+ +

Each global XML Schema element in the form: +

+ + + 
+<xsd:element name="name" type="type"/>
+
+ +

is mapped to 8 overloaded C++ functions in the form:

+ + 
+// Serialize to std::ostream.
+//
+void
+name (std::ostream&,
+      const type&,
+      const xml_schema::namespace_fomap& =
+        xml_schema::namespace_infomap (),
+      const std::basic_string<C>& encoding = "UTF-8",
+      xml_schema::flags = 0);
+
+void
+name (std::ostream&,
+      const type&,
+      xml_schema::error_handler&,
+      const xml_schema::namespace_infomap& =
+        xml_schema::namespace_infomap (),
+      const std::basic_string<C>& encoding = "UTF-8",
+      xml_schema::flags = 0);
+
+void
+name (std::ostream&,
+      const type&,
+      xercesc::DOMErrorHandler&,
+      const xml_schema::namespace_infomap& =
+        xml_schema::namespace_infomap (),
+      const std::basic_string<C>& encoding = "UTF-8",
+      xml_schema::flags = 0);
+
+
+// Serialize to XMLFormatTarget.
+//
+void
+name (xercesc::XMLFormatTarget&,
+      const type&,
+      const xml_schema::namespace_infomap& =
+        xml_schema::namespace_infomap (),
+      const std::basic_string<C>& encoding = "UTF-8",
+      xml_schema::flags = 0);
+
+void
+name (xercesc::XMLFormatTarget&,
+      const type&,
+      xml_schema::error_handler&,
+      const xml_schema::namespace_infomap& =
+        xml_schema::namespace_infomap (),
+      const std::basic_string<C>& encoding = "UTF-8",
+      xml_schema::flags = 0);
+
+void
+name (xercesc::XMLFormatTarget&,
+      const type&,
+      xercesc::DOMErrorHandler&,
+      const xml_schema::namespace_infomap& =
+        xml_schema::namespace_infomap (),
+      const std::basic_string<C>& encoding = "UTF-8",
+      xml_schema::flags = 0);
+
+
+// Serialize to DOM.
+//
+xml_schema::dom::[unique|auto]_ptr<xercesc::DOMDocument>
+name (const type&,
+      const xml_schema::namespace_infomap&
+        xml_schema::namespace_infomap (),
+      xml_schema::flags = 0);
+
+void
+name (xercesc::DOMDocument&,
+      const type&,
+      xml_schema::flags = 0);
+
+ +

You can choose between writing XML to std::ostream or + xercesc::XMLFormatTarget and creating a DOM instance + in the form of xercesc::DOMDocument. Serialization + to ostream or XMLFormatTarget requires a + considerably less work while serialization to DOM provides + for greater flexibility. Each of these serialization functions + is discussed in more detail in the following sections. +

+ + +

4.1 Initializing the Xerces-C++ Runtime

+ +

Some serialization functions expect you to initialize the Xerces-C++ + runtime while others initialize and terminate it as part of their + work. The general rule is as follows: if a function has any arguments + or return a value that is an instance of a Xerces-C++ type, then + this function expects you to initialize the Xerces-C++ runtime. + Otherwise, the function initializes and terminates the runtime for + you. Note that it is legal to have nested calls to the Xerces-C++ + initialize and terminate functions as long as the calls are balanced. +

+ +

You can instruct serialization functions that initialize and terminate + the runtime not to do so by passing the + xml_schema::flags::dont_initialize flag (see + Section 4.3, "Flags"). +

+ +

4.2 Namespace Infomap and Character Encoding

+ +

When a document being serialized uses XML namespaces, custom + prefix-namespace associations can to be established. If custom + prefix-namespace mapping is not provided then generic prefixes + (p1, p2, etc) are automatically assigned + to namespaces as needed. Also, if + you would like the resulting instance document to contain the + schemaLocation or noNamespaceSchemaLocation + attributes, you will need to provide namespace-schema associations. + The xml_schema::namespace_infomap class is used + to capture this information:

+ + 
+struct namespace_info
+{
+  namespace_info ();
+  namespace_info (const std::basic_string<C>& name,
+                  const std::basic_string<C>& schema);
+
+  std::basic_string<C> name;
+  std::basic_string<C> schema;
+};
+
+// Map of namespace prefix to namespace_info.
+//
+struct namespace_infomap: public std::map<std::basic_string<C>,
+                                          namespace_info>
+{
+};
+
+ +

Consider the following associations as an example:

+ + 
+xml_schema::namespace_infomap map;
+
+map["t"].name = "https://www.codesynthesis.com/test";
+map["t"].schema = "test.xsd";
+
+ +

This map, if passed to one of the serialization functions, + could result in the following XML fragment:

+ + 
+<?xml version="1.0" ?>
+<t:name xmlns:t="https://www.codesynthesis.com/test"
+        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+        xsi:schemaLocation="https://www.codesynthesis.com/test test.xsd">
+
+ +

As you can see, the serialization function automatically added namespace + mapping for the xsi prefix. You can change this by + providing your own prefix:

+ + 
+xml_schema::namespace_infomap map;
+
+map["xsn"].name = "http://www.w3.org/2001/XMLSchema-instance";
+
+map["t"].name = "https://www.codesynthesis.com/test";
+map["t"].schema = "test.xsd";
+
+ +

This could result in the following XML fragment:

+ + 
+<?xml version="1.0" ?>
+<t:name xmlns:t="https://www.codesynthesis.com/test"
+        xmlns:xsn="http://www.w3.org/2001/XMLSchema-instance"
+        xsn:schemaLocation="https://www.codesynthesis.com/test test.xsd">
+
+ +

To specify the location of a schema without a namespace you can use + an empty prefix as in the example below:

+ + 
+xml_schema::namespace_infomap map;
+
+map[""].schema = "test.xsd";
+
+ +

This would result in the following XML fragment:

+ + 
+<?xml version="1.0" ?>
+<name xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+      xsi:noNamespaceSchemaLocation="test.xsd">
+
+ +

To make a particular namespace default you can use an empty + prefix, for example:

+ + 
+xml_schema::namespace_infomap map;
+
+map[""].name = "https://www.codesynthesis.com/test";
+map[""].schema = "test.xsd";
+
+ +

This could result in the following XML fragment:

+ + 
+<?xml version="1.0" ?>
+<name xmlns="https://www.codesynthesis.com/test"
+      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+      xsi:schemaLocation="https://www.codesynthesis.com/test test.xsd">
+
+ + +

Another bit of information that you can pass to the serialization + functions is the character encoding method that you would like to use. + Common values for this argument are "US-ASCII", + "ISO8859-1", "UTF-8", + "UTF-16BE", "UTF-16LE", + "UCS-4BE", and "UCS-4LE". The default + encoding is "UTF-8". For more information on + encoding methods see the + "Character + Encoding" article from Wikipedia. +

+ +

4.3 Flags

+ +

Serialization flags are the last argument of every serialization + function. They allow you to fine-tune the process of serialization. + The flags argument is optional. +

+ + +

The following flags are recognized by the serialization + functions:

+ +
+
xml_schema::flags::dont_initialize
+
Do not initialize the Xerces-C++ runtime.
+ +
xml_schema::flags::dont_pretty_print
+
Do not add extra spaces or new lines that make the resulting XML + slightly bigger but easier to read.
+ +
xml_schema::flags::no_xml_declaration
+
Do not write XML declaration (<?xml ... ?>).
+
+ +

You can pass several flags by combining them using the bit-wise OR + operator. For example:

+ + 
+std::unique_ptr<type> r = ...
+std::ofstream ofs ("test.xml");
+xml_schema::namespace_infomap map;
+name (ofs,
+      *r,
+      map,
+      "UTF-8",
+      xml_schema::flags::no_xml_declaration |
+      xml_schema::flags::dont_pretty_print);
+
+ +

For more information on the Xerces-C++ runtime initialization + refer to Section 4.1, "Initializing the Xerces-C++ + Runtime". +

+ +

4.4 Error Handling

+ +

As with the parsing functions (see Section 3.3, + "Error Handling"), to better understand error handling and + reporting strategies employed by the serialization functions, it + is useful to know that the transformation of a statically-typed + tree to an XML instance document happens in two stages. The first + stage, performed by the generated code, consist of building a DOM + instance from the statically-typed tree . For short, we will call + this stage the Tree-DOM stage. The second stage, performed by + Xerces-C++, consists of serializing the DOM instance into the XML + document. We will call this stage the DOM-XML stage. +

+ +

All serialization functions except the two that serialize into + a DOM instance come in overloaded triples. The first function + in such a triple reports error conditions exclusively by throwing + exceptions. It accumulates all the serialization errors of the + DOM-XML stage and throws them in a single instance of the + xml_schema::serialization exception (described below). + The second and the third functions in the triple use callback + interfaces to report serialization errors and warnings. The two + callback interfaces are xml_schema::error_handler and + xercesc::DOMErrorHandler. The + xml_schema::error_handler interface is described in + Section 3.3, "Error Handling". For more information + on the xercesc::DOMErrorHandler interface refer to the + Xerces-C++ documentation. +

+ +

The Tree-DOM stage reports error conditions exclusively by throwing + exceptions. Individual exceptions thrown by the serialization functions + are described in the following sub-sections. +

+ +

4.4.1 xml_schema::serialization

+ + 
+struct serialization: virtual exception
+{
+  serialization ();
+  serialization (const diagnostics&);
+
+  const diagnostics&
+  diagnostics () const;
+
+  virtual const char*
+  what () const throw ();
+};
+
+ +

The xml_schema::diagnostics class is described in + Section 3.3.1, "xml_schema::parsing". + The xml_schema::serialization exception is thrown if + there were serialization errors reported during the DOM-XML stage. + If no callback interface was provided to the serialization function, + the exception contains a list of errors and warnings accessible using + the diagnostics function. +

+ + +

4.4.2 xml_schema::unexpected_element

+ +

The xml_schema::unexpected_element exception is + described in Section 3.3.3, + "xml_schema::unexpected_element". It is thrown + by the serialization functions during the Tree-DOM stage if the + root element name of the provided DOM instance does not match with + the name of the element this serialization function is for. +

+ +

4.4.3 xml_schema::no_type_info

+ +

The xml_schema::no_type_info exception is + described in Section 3.3.7, + "xml_schema::no_type_info". It is thrown + by the serialization functions during the Tree-DOM stage when there + is no type information associated with a dynamic type of an + element. Usually, catching this exception means that you haven't + linked the code generated from the schema defining the type in + question with your application or this schema has been compiled + without the --generate-polymorphic option. +

+ +

4.5 Serializing to std::ostream

+ +

In order to serialize to std::ostream you will need + an object model, an output stream and, optionally, a namespace + infomap. For instance:

+ + 
+// Obtain the object model.
+//
+std::unique_ptr<type> r = ...
+
+// Prepare namespace mapping and schema location information.
+//
+xml_schema::namespace_infomap map;
+
+map["t"].name = "https://www.codesynthesis.com/test";
+map["t"].schema = "test.xsd";
+
+// Write it out.
+//
+name (std::cout, *r, map);
+
+ +

Note that the output stream is treated as a binary stream. This + becomes important when you use a character encoding that is wider + than 8-bit char, for instance UTF-16 or UCS-4. For + example, things will most likely break if you try to serialize + to std::ostringstream with UTF-16 or UCS-4 as an + encoding. This is due to the special value, + '\0', that will most likely occur as part of such + serialization and it won't have the special meaning assumed by + std::ostringstream. +

+ + +

4.6 Serializing to xercesc::XMLFormatTarget

+ +

Serializing to an xercesc::XMLFormatTarget instance + is similar the std::ostream case. For instance: +

+ + 
+using std::unique_ptr;
+
+// Obtain the object model.
+//
+unique_ptr<type> r = ...
+
+// Prepare namespace mapping and schema location information.
+//
+xml_schema::namespace_infomap map;
+
+map["t"].name = "https://www.codesynthesis.com/test";
+map["t"].schema = "test.xsd";
+
+using namespace xercesc;
+
+XMLPlatformUtils::Initialize ();
+
+{
+  // Choose a target.
+  //
+  unique_ptr<XMLFormatTarget> ft;
+
+  if (argc != 2)
+  {
+    ft = unique_ptr<XMLFormatTarget> (new StdOutFormatTarget ());
+  }
+  else
+  {
+    ft = unique_ptr<XMLFormatTarget> (
+      new LocalFileFormatTarget (argv[1]));
+  }
+
+  // Write it out.
+  //
+  name (*ft, *r, map);
+}
+
+XMLPlatformUtils::Terminate ();
+
+ +

Note that we had to initialize the Xerces-C++ runtime before we + could call this serialization function.

+ +

4.7 Serializing to DOM

+ +

The mapping provides two overloaded functions that implement + serialization to a DOM instance. The first creates a DOM instance + for you and the second serializes to an existing DOM instance. + While serializing to a new DOM instance is similar to serializing + to std::ostream or xercesc::XMLFormatTarget, + serializing to an existing DOM instance requires quite a bit of work + from your side. You will need to set all the custom namespace mapping + attributes as well as the schemaLocation and/or + noNamespaceSchemaLocation attributes. The following + listing should give you an idea about what needs to be done: +

+ + 
+// Obtain the object model.
+//
+std::unique_ptr<type> r = ...
+
+using namespace xercesc;
+
+XMLPlatformUtils::Initialize ();
+
+{
+  // Create a DOM instance. Set custom namespace mapping and schema
+  // location attributes.
+  //
+  DOMDocument& doc = ...
+
+  // Serialize to DOM.
+  //
+  name (doc, *r);
+
+  // Serialize the DOM document to XML.
+  //
+  ...
+}
+
+XMLPlatformUtils::Terminate ();
+
+ +

For more information on how to create and serialize a DOM instance + refer to the Xerces-C++ documentation. In addition, the + C++/Tree Mapping + FAQ shows how to implement these operations using the XSD + runtime utilities. +

+ +

5 Additional Functionality

+ +

The C++/Tree mapping provides a number of optional features + that can be useful in certain situations. They are described + in the following sections.

+ +

5.1 DOM Association

+ +

Normally, after parsing is complete, the DOM document which + was used to extract the data is discarded. However, the parsing + functions can be instructed to preserve the DOM document + and create an association between the DOM nodes and object model + nodes. When there is an association between the DOM and + object model nodes, you can obtain the corresponding DOM element + or attribute node from an object model node as well as perform + the reverse transition: obtain the corresponding object model + from a DOM element or attribute node.

+ +

Maintaining DOM association is normally useful when the application + needs access to XML constructs that are not preserved in the + object model, for example, XML comments. + Another useful aspect of DOM association is the ability of the + application to navigate the document tree using the generic DOM + interface (for example, with the help of an XPath processor) + and then move back to the statically-typed object model. Note + also that while you can change the underlying DOM document, + these changes are not reflected in the object model and will + be ignored during serialization. If you need to not only access + but also modify some aspects of XML that are not preserved in + the object model, then type customization with custom parsing + constructors and serialization operators should be used instead.

+ +

To request DOM association you will need to pass the + xml_schema::flags::keep_dom flag to one of the + parsing functions (see Section 3.2, + "Flags and Properties" for more information). In this case the + DOM document is retained and will be released when the object model + is deleted. Note that since DOM nodes "out-live" the parsing function + call, you need to initialize the Xerces-C++ runtime before calling + one of the parsing functions with the keep_dom flag and + terminate it after the object model is destroyed (see + Section 3.1, "Initializing the Xerces-C++ Runtime").

+ +

If the keep_dom flag is passed + as the second argument to the copy constructor and the copy + being made is of a complete tree, then the DOM association + is also maintained in the copy by cloning the underlying + DOM document and reestablishing the associations. For example:

+ + 
+using namespace xercesc;
+
+XMLPlatformUtils::Initialize ();
+
+{
+  // Parse XML to object model.
+  //
+  std::unique_ptr<type> r (root (
+    "root.xml",
+     xml_schema::flags::keep_dom |
+     xml_schema::flags::dont_initialize));
+
+   // Copy without DOM association.
+   //
+   type copy1 (*r);
+
+   // Copy with DOM association.
+   //
+   type copy2 (*r, xml_schema::flags::keep_dom);
+}
+
+XMLPlatformUtils::Terminate ();
+
+ + +

To obtain the corresponding DOM node from an object model node + you will need to call the _node accessor function + which returns a pointer to DOMNode. You can then query + this DOM node's type and cast it to either DOMAttr* + or DOMElement*. To obtain the corresponding object + model node from a DOM node, the DOM user data API is used. The + xml_schema::dom::tree_node_key variable contains + the key for object model nodes. The following schema and code + fragment show how to navigate from DOM to object model nodes + and in the opposite direction:

+ + 
+<complexType name="object">
+  <sequence>
+    <element name="a" type="string"/>
+  </sequence>
+</complexType>
+
+<element name="root" type="object"/>
+
+ + 
+using namespace xercesc;
+
+XMLPlatformUtils::Initialize ();
+
+{
+  // Parse XML to object model.
+  //
+  std::unique_ptr<type> r (root (
+    "root.xml",
+     xml_schema::flags::keep_dom |
+     xml_schema::flags::dont_initialize));
+
+  DOMNode* n = r->_node ();
+  assert (n->getNodeType () == DOMNode::ELEMENT_NODE);
+  DOMElement* re = static_cast<DOMElement*> (n);
+
+  // Get the 'a' element. Note that it is not necessarily the
+  // first child node of 'root' since there could be whitespace
+  // nodes before it.
+  //
+  DOMElement* ae;
+
+  for (n = re->getFirstChild (); n != 0; n = n->getNextSibling ())
+  {
+    if (n->getNodeType () == DOMNode::ELEMENT_NODE)
+    {
+      ae = static_cast<DOMElement*> (n);
+      break;
+    }
+  }
+
+  // Get from the 'a' DOM element to xml_schema::string object model
+  // node.
+  //
+  xml_schema::type& t (
+    *reinterpret_cast<xml_schema::type*> (
+       ae->getUserData (xml_schema::dom::tree_node_key)));
+
+  xml_schema::string& a (dynamic_cast<xml_schema::string&> (t));
+}
+
+XMLPlatformUtils::Terminate ();
+
+ +

The 'mixed' example which can be found in the XSD distribution + shows how to handle the mixed content using DOM association.

+ +

5.2 Binary Serialization

+ +

Besides reading from and writing to XML, the C++/Tree mapping + also allows you to save the object model to and load it from a + number of predefined as well as custom data representation + formats. The predefined binary formats are CDR (Common Data + Representation) and XDR (eXternal Data Representation). A + custom format can easily be supported by providing + insertion and extraction operators for basic types.

+ +

Binary serialization saves only the data without any meta + information or markup. As a result, saving to and loading + from a binary representation can be an order of magnitude + faster than parsing and serializing the same data in XML. + Furthermore, the resulting representation is normally several + times smaller than the equivalent XML representation. These + properties make binary serialization ideal for internal data + exchange and storage. A typical application that uses this + facility stores the data and communicates within the + system using a binary format and reads/writes the data + in XML when communicating with the outside world.

+ +

In order to request the generation of insertion operators and + extraction constructors for a specific predefined or custom + data representation stream, you will need to use the + --generate-insertion and --generate-extraction + compiler options. See the + XSD + Compiler Command Line Manual for more information.

+ +

Once the insertion operators and extraction constructors are + generated, you can use the xml_schema::istream + and xml_schema::ostream wrapper stream templates + to save the object model to and load it from a specific format. + The following code fragment shows how to do this using ACE + (Adaptive Communication Environment) CDR streams as an example:

+ + 
+<complexType name="object">
+  <sequence>
+    <element name="a" type="string"/>
+    <element name="b" type="int"/>
+  </sequence>
+</complexType>
+
+<element name="root" type="object"/>
+
+ + 
+// Parse XML to object model.
+//
+std::unique_ptr<type> r (root ("root.xml"));
+
+// Save to a CDR stream.
+//
+ACE_OutputCDR ace_ocdr;
+xml_schema::ostream<ACE_OutputCDR> ocdr (ace_ocdr);
+
+ocdr << *r;
+
+// Load from a CDR stream.
+//
+ACE_InputCDR ace_icdr (buf, size);
+xml_schema::istream<ACE_InputCDR> icdr (ace_icdr);
+
+std::unique_ptr<object> copy (new object (icdr));
+
+// Serialize to XML.
+//
+root (std::cout, *copy);
+
+ +

The XSD distribution contains a number of examples that + show how to save the object model to and load it from + CDR, XDR, and a custom format.

+ + + + +

Appendix A — Default and Fixed Values

+ +

The following table summarizes the effect of default and fixed + values (specified with the default and fixed + attributes, respectively) on attribute and element values. The + default and fixed attributes are mutually + exclusive. It is also worthwhile to note that the fixed value semantics + is a superset of the default value semantics. +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
defaultfixed
elementnot presentoptionalrequiredoptionalrequired
not presentinvalid instancenot presentinvalid instance
emptydefault value is usedfixed value is used
valuevalue is usedvalue is used provided it's the same as fixed
attributenot presentoptionalrequiredoptionalrequired
default value is usedinvalid schemafixed value is usedinvalid instance
emptyempty value is usedempty value is used provided it's the same as fixed
valuevalue is usedvalue is used provided it's the same as fixed
+ +
+
+ + + + diff --git a/doc/cxx/tree/manual/index.xhtml.in b/doc/cxx/tree/manual/index.xhtml.in new file mode 100644 index 0000000..5a7240a --- /dev/null +++ b/doc/cxx/tree/manual/index.xhtml.in @@ -0,0 +1,6826 @@ + + + + + + C++/Tree Mapping User Manual + + + + + + + + + + + + + + +
+
+ +
+ +
+
C++/Tree Mapping User Manual
+ +

Copyright © @copyright@.

+ +

Permission is granted to copy, distribute and/or modify this + document under the terms of the + GNU Free + Documentation License, version 1.2; with no Invariant Sections, + no Front-Cover Texts and no Back-Cover Texts. +

+ +

This document is available in the following formats: + XHTML, + PDF, and + PostScript.

+
+ +

Table of Contents

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Preface + + + +
About This Document
More Information
+
1Introduction
2C++/Tree Mapping + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
2.1Preliminary Information + + + + + + +
2.1.1C++ Standard
2.1.2Identifiers
2.1.3Character Type and Encoding
2.1.4XML Schema Namespace
2.1.5Anonymous Types
+
2.2Error Handling + + +
2.2.1xml_schema::duplicate_id
+
2.3Mapping for import and include + + + + +
2.3.1Import
2.3.2Inclusion with Target Namespace
2.3.3Inclusion without Target Namespace
+
2.4Mapping for Namespaces
2.5Mapping for Built-in Data Types + + + + + + + + + + + + + + + + + +
2.5.1Inheritance from Built-in Data Types
2.5.2Mapping for anyType
2.5.3Mapping for anySimpleType
2.5.4Mapping for QName
2.5.5Mapping for IDREF
2.5.6Mapping for base64Binary and hexBinary
2.5.7Time Zone Representation
2.5.8Mapping for date
2.5.9Mapping for dateTime
2.5.10Mapping for duration
2.5.11Mapping for gDay
2.5.12Mapping for gMonth
2.5.13Mapping for gMonthDay
2.5.14Mapping for gYear
2.5.15Mapping for gYearMonth
2.5.16Mapping for time
+
2.6Mapping for Simple Types + + + + + +
2.6.1Mapping for Derivation by Restriction
2.6.2Mapping for Enumerations
2.6.3Mapping for Derivation by List
2.6.4Mapping for Derivation by Union
+
2.7Mapping for Complex Types + + + +
2.7.1Mapping for Derivation by Extension
2.7.2Mapping for Derivation by Restriction
+
2.8Mapping for Local Elements and Attributes + + + + + +
2.8.1Mapping for Members with the One Cardinality Class
2.8.2Mapping for Members with the Optional Cardinality Class
2.8.3Mapping for Members with the Sequence Cardinality Class
2.8.4Element Order
+
2.9Mapping for Global Elements + + + +
2.9.1Element Types
2.9.2Element Map
+
2.10Mapping for Global Attributes
2.11Mapping for xsi:type and Substitution Groups
2.12Mapping for any and anyAttribute + + + + + + +
2.12.1Mapping for any with the One Cardinality Class
2.12.2Mapping for any with the Optional Cardinality Class
2.12.3Mapping for any with the Sequence Cardinality Class
2.12.4Element Wildcard Order
2.12.5Mapping for anyAttribute
+
2.13Mapping for Mixed Content Models
+
3Parsing + + + + + + + + + + + + + + + + + + + + + + +
3.1Initializing the Xerces-C++ Runtime
3.2Flags and Properties
3.3Error Handling + + + + + + + + + + +
3.3.1xml_schema::parsing
3.3.2xml_schema::expected_element
3.3.3xml_schema::unexpected_element
3.3.4xml_schema::expected_attribute
3.3.5xml_schema::unexpected_enumerator
3.3.6xml_schema::expected_text_content
3.3.7xml_schema::no_type_info
3.3.8xml_schema::not_derived
3.3.9xml_schema::not_prefix_mapping
+
3.4Reading from a Local File or URI
3.5Reading from std::istream
3.6Reading from xercesc::InputSource
3.7Reading from DOM
+
4Serialization + + + + + + + + + + + + + + + + + + + + + + +
4.1Initializing the Xerces-C++ Runtime
4.2Namespace Infomap and Character Encoding
4.3Flags
4.4Error Handling + + + + +
4.4.1xml_schema::serialization
4.4.2xml_schema::unexpected_element
4.4.3xml_schema::no_type_info
+
4.5Serializing to std::ostream
4.6Serializing to xercesc::XMLFormatTarget
4.7Serializing to DOM
+
5Additional Functionality + + + + + + + +
5.1DOM Association
5.2Binary Serialization
+
Appendix A — Default and Fixed Values
+
+ +

Preface

+ +

About This Document

+ +

This document describes the mapping of W3C XML Schema + to the C++ programming language as implemented by + CodeSynthesis + XSD - an XML Schema to C++ data binding compiler. The mapping + represents information stored in XML instance documents as a + statically-typed, tree-like in-memory data structure and is + called C++/Tree. +

+ +

Revision 4.1.0
+ This revision of the manual describes the C++/Tree + mapping as implemented by CodeSynthesis XSD version 4.1.0. +

+ +

This document is available in the following formats: + XHTML, + PDF, and + PostScript.

+ +

More Information

+ +

Beyond this manual, you may also find the following sources of + information useful:

+ + + + +

1 Introduction

+ +

C++/Tree is a W3C XML Schema to C++ mapping that represents the + data stored in XML as a statically-typed, vocabulary-specific + object model. Based on a formal description of an XML vocabulary + (schema), the C++/Tree mapping produces a tree-like data structure + suitable for in-memory processing as well as XML parsing and + serialization code.

+ +

A typical application that processes XML documents usually + performs the following three steps: it first reads (parses) an XML + instance document to an object model, it then performs + some useful computations on that model which may involve + modification of the model, and finally it may write (serialize) + the modified object model back to XML. +

+ +

The C++/Tree mapping consists of C++ types that represent the + given vocabulary (Chapter 2, "C++/Tree Mapping"), + a set of parsing functions that convert XML documents to + a tree-like in-memory data structure (Chapter 3, + "Parsing"), and a set of serialization functions that convert + the object model back to XML (Chapter 4, + "Serialization"). Furthermore, the mapping provides a number + of additional features, such as DOM association and binary + serialization, that can be useful in some applications + (Chapter 5, "Additional Functionality"). +

+ + + + + +

2 C++/Tree Mapping

+ +

2.1 Preliminary Information

+ +

2.1.1 C++ Standard

+ +

The C++/Tree mapping provides support for ISO/IEC C++ 2011 (C++11) + and ISO/IEC C++ 1998/2003 (C++98). To select the C++ standard for the + generated code we use the --std XSD compiler command + line option. While the majority of the examples in this guide use + C++11, the document explains the C++11/98 usage difference and so + they can easily be converted to C++98.

+ +

2.1.2 Identifiers

+ +

XML Schema names may happen to be reserved C++ keywords or contain + characters that are illegal in C++ identifiers. To avoid C++ compilation + problems, such names are changed (escaped) when mapped to C++. If an + XML Schema name is a C++ keyword, the "_" suffix is added to it. All + character of an XML Schema name that are not allowed in C++ identifiers + are replaced with "_". +

+ +

For example, XML Schema name try will be mapped to + C++ identifier try_. Similarly, XML Schema name + strange.na-me will be mapped to C++ identifier + strange_na_me. +

+ +

Furthermore, conflicts between type names and function names in the + same scope are resolved using name escaping. Such conflicts include + both a global element (which is mapped to a set of parsing and/or + serialization functions or element types, see Section + 2.9, "Mapping for Global Elements") and a global type sharing the + same name as well as a local element or attribute inside a type having + the same name as the type itself.

+ +

For example, if we had a global type catalog + and a global element with the same name then the type would be + mapped to a C++ class with name catalog while the + parsing functions corresponding to the global element would have + their names escaped as catalog_. +

+ +

By default the mapping uses the so-called K&R (Kernighan and + Ritchie) identifier naming convention which is also used throughout + this manual. In this convention both type and function names are in + lower case and words are separated by underscores. If your application + code or schemas use a different notation, you may want to change the + naming convention used by the mapping for consistency. + The compiler supports a set of widely-used naming conventions + that you can select with the --type-naming and + --function-naming options. You can also further + refine one of the predefined conventions or create a completely + custom naming scheme by using the --*-regex options. + For more detailed information on these options refer to the NAMING + CONVENTION section in the XSD + Compiler Command Line Manual.

+ +

2.1.3 Character Type and Encoding

+ +

The code that implements the mapping, depending on the + --char-type option, is generated using either + char or wchar_t as the character + type. In this document code samples use symbol C + to refer to the character type you have selected when translating + your schemas, for example std::basic_string<C>. +

+ +

Another aspect of the mapping that depends on the character type + is character encoding. For the char character type + the default encoding is UTF-8. Other supported encodings are + ISO-8859-1, Xerces-C++ Local Code Page (LPC), as well as + custom encodings and can be selected with the + --char-encoding command line option.

+ +

For the wchar_t character type the encoding is + automatically selected between UTF-16 and UTF-32/UCS-4 depending + on the size of the wchar_t type. On some platforms + (for example, Windows with Visual C++ and AIX with IBM XL C++) + wchar_t is 2 bytes long. For these platforms the + encoding is UTF-16. On other platforms wchar_t is 4 bytes + long and UTF-32/UCS-4 is used.

+ +

2.1.4 XML Schema Namespace

+ +

The mapping relies on some predefined types, classes, and functions + that are logically defined in the XML Schema namespace reserved for + the XML Schema language (http://www.w3.org/2001/XMLSchema). + By default, this namespace is mapped to C++ namespace + xml_schema. It is automatically accessible + from a C++ compilation unit that includes a header file generated + from an XML Schema definition. +

+ +

Note that, if desired, the default mapping of this namespace can be + changed as described in Section 2.4, "Mapping for + Namespaces". +

+ + +

2.1.5 Anonymous Types

+ +

For the purpose of code generation, anonymous types defined in + XML Schema are automatically assigned names that are derived + from enclosing attributes and elements. Otherwise, such types + follows standard mapping rules for simple and complex type + definitions (see Section 2.6, "Mapping for Simple Types" + and Section 2.7, "Mapping for Complex Types"). + For example, in the following schema fragment: +

+ + 
+<element name="object">
+  <complexType>
+    ...
+  </complexType>
+</element>
+
+ +

The anonymous type defined inside element object will + be given name object. The compiler has a number of + options that control the process of anonymous type naming. For more + information refer to the XSD + Compiler Command Line Manual.

+ + +

2.2 Error Handling

+ +

The mapping uses the C++ exception handling mechanism as a primary way + of reporting error conditions. All exceptions that are specified in + this mapping derive from xml_schema::exception which + itself is derived from std::exception: +

+ + 
+struct exception: virtual std::exception
+{
+  friend
+  std::basic_ostream<C>&
+  operator<< (std::basic_ostream<C>& os, const exception& e)
+  {
+    e.print (os);
+    return os;
+  }
+
+protected:
+  virtual void
+  print (std::basic_ostream<C>&) const = 0;
+};
+
+ +

The exception hierarchy supports "virtual" operator<< + which allows you to obtain diagnostics corresponding to the thrown + exception using the base exception interface. For example:

+ + 
+try
+{
+  ...
+}
+catch (const xml_schema::exception& e)
+{
+  cerr << e << endl;
+}
+
+ +

The following sub-sections describe exceptions thrown by the + types that constitute the object model. + Section 3.3, "Error Handling" of + Chapter 3, "Parsing" describes exceptions + and error handling mechanisms specific to the parsing functions. + Section 4.4, "Error Handling" of + Chapter 4, "Serialization" describes exceptions + and error handling mechanisms specific to the serialization functions. +

+ + +

2.2.1 xml_schema::duplicate_id

+ + 
+struct duplicate_id: virtual exception
+{
+  duplicate_id (const std::basic_string<C>& id);
+
+  const std::basic_string<C>&
+  id () const;
+
+  virtual const char*
+  what () const throw ();
+};
+
+ +

The xml_schema::duplicate_id is thrown when + a conflicting instance of xml_schema::id (see + Section 2.5, "Mapping for Built-in Data Types") + is added to a tree. The offending ID value can be obtained using + the id function. +

+ +

2.3 Mapping for import and include

+ +

2.3.1 Import

+ +

The XML Schema import element is mapped to the C++ + Preprocessor #include directive. The value of + the schemaLocation attribute is used to derive + the name of the header file that appears in the #include + directive. For instance: +

+ + 
+<import namespace="https://www.codesynthesis.com/test"
+        schemaLocation="test.xsd"/>
+
+ +

is mapped to:

+ + 
+#include "test.hxx"
+
+ +

Note that you will need to compile imported schemas separately + in order to produce corresponding header files.

+ +

2.3.2 Inclusion with Target Namespace

+ +

The XML Schema include element which refers to a schema + with a target namespace or appears in a schema without a target namespace + follows the same mapping rules as the import element, + see Section 2.3.1, "Import". +

+ +

2.3.3 Inclusion without Target Namespace

+ +

For the XML Schema include element which refers to a schema + without a target namespace and appears in a schema with a target + namespace (such inclusion sometimes called "chameleon inclusion"), + declarations and definitions from the included schema are generated + in-line in the namespace of the including schema as if they were + declared and defined there verbatim. For example, consider the + following two schemas: +

+ + 
+<-- common.xsd -->
+<schema>
+  <complexType name="type">
+  ...
+  </complexType>
+</schema>
+
+<-- test.xsd -->
+<schema targetNamespace="https://www.codesynthesis.com/test">
+  <include schemaLocation="common.xsd"/>
+</schema>
+
+ +

The fragment of interest from the generated header file for + text.xsd would look like this:

+ + 
+// test.hxx
+namespace test
+{
+  class type
+  {
+    ...
+  };
+}
+
+ +

2.4 Mapping for Namespaces

+ +

An XML Schema namespace is mapped to one or more nested C++ + namespaces. XML Schema namespaces are identified by URIs. + By default, a namespace URI is mapped to a sequence of + C++ namespace names by removing the protocol and host parts + and splitting the rest into a sequence of names with '/' + as the name separator. For instance: +

+ + 
+<schema targetNamespace="https://www.codesynthesis.com/system/test">
+  ...
+</schema>
+
+ +

is mapped to:

+ + 
+namespace system
+{
+  namespace test
+  {
+    ...
+  }
+}
+
+ +

The default mapping of namespace URIs to C++ namespace names can be + altered using the --namespace-map and + --namespace-regex options. See the + XSD + Compiler Command Line Manual for more information. +

+ +

2.5 Mapping for Built-in Data Types

+ +

The mapping of XML Schema built-in data types to C++ types is + summarized in the table below.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
XML Schema typeAlias in the xml_schema namespaceC++ type
anyType and anySimpleType types
anyTypetypeSection 2.5.2, "Mapping for anyType"
anySimpleTypesimple_typeSection 2.5.3, "Mapping for anySimpleType"
fixed-length integral types
bytebytesigned char
unsignedByteunsigned_byteunsigned char
shortshort_short
unsignedShortunsigned_shortunsigned short
intint_int
unsignedIntunsigned_intunsigned int
longlong_long long
unsignedLongunsigned_longunsigned long long
arbitrary-length integral types
integerintegerlong long
nonPositiveIntegernon_positive_integerlong long
nonNegativeIntegernon_negative_integerunsigned long long
positiveIntegerpositive_integerunsigned long long
negativeIntegernegative_integerlong long
boolean types
booleanbooleanbool
fixed-precision floating-point types
floatfloat_float
doubledouble_double
arbitrary-precision floating-point types
decimaldecimaldouble
string types
stringstringtype derived from std::basic_string
normalizedStringnormalized_stringtype derived from string
tokentokentype derived from normalized_string
Namenametype derived from token
NMTOKENnmtokentype derived from token
NMTOKENSnmtokenstype derived from sequence<nmtoken>
NCNamencnametype derived from name
languagelanguagetype derived from token
qualified name
QNameqnameSection 2.5.4, "Mapping for QName"
ID/IDREF types
IDidtype derived from ncname
IDREFidrefSection 2.5.5, "Mapping for IDREF"
IDREFSidrefstype derived from sequence<idref>
URI types
anyURIuritype derived from std::basic_string
binary types
base64Binarybase64_binarySection 2.5.6, "Mapping for + base64Binary and hexBinary"
hexBinaryhex_binary
date/time types
datedateSection 2.5.8, "Mapping for + date"
dateTimedate_timeSection 2.5.9, "Mapping for + dateTime"
durationdurationSection 2.5.10, "Mapping for + duration"
gDaygdaySection 2.5.11, "Mapping for + gDay"
gMonthgmonthSection 2.5.12, "Mapping for + gMonth"
gMonthDaygmonth_daySection 2.5.13, "Mapping for + gMonthDay"
gYeargyearSection 2.5.14, "Mapping for + gYear"
gYearMonthgyear_monthSection 2.5.15, "Mapping for + gYearMonth"
timetimeSection 2.5.16, "Mapping for + time"
entity types
ENTITYentitytype derived from name
ENTITIESentitiestype derived from sequence<entity>
+ +

All XML Schema built-in types are mapped to C++ classes that are + derived from the xml_schema::simple_type class except + where the mapping is to a fundamental C++ type.

+ +

The sequence class template is defined in an + implementation-specific namespace. It conforms to the + sequence interface as defined by the ISO/ANSI Standard for + C++ (ISO/IEC 14882:1998, Section 23.1.1, "Sequences"). + Practically, this means that you can treat such a sequence + as if it was std::vector. One notable extension + to the standard interface that is available only for + sequences of non-fundamental C++ types is the addition of + the overloaded push_back and insert + member functions which instead of the constant reference + to the element type accept automatic pointer (std::unique_ptr + or std::auto_ptr, depending on the C++ standard + selected) to the element type. These functions assume ownership + of the pointed to object and reset the passed automatic pointer. +

+ +

2.5.1 Inheritance from Built-in Data Types

+ +

In cases where the mapping calls for an inheritance from a built-in + type which is mapped to a fundamental C++ type, a proxy type is + used instead of the fundamental C++ type (C++ does not allow + inheritance from fundamental types). For instance:

+ + 
+<simpleType name="my_int">
+  <restriction base="int"/>
+</simpleType>
+
+ +

is mapped to:

+ + 
+class my_int: public fundamental_base<int>
+{
+  ...
+};
+
+ +

The fundamental_base class template provides a close + emulation (though not exact) of a fundamental C++ type. + It is defined in an implementation-specific namespace and has the + following interface:

+ + 
+template <typename X>
+class fundamental_base: public simple_type
+{
+public:
+  fundamental_base ();
+  fundamental_base (X)
+  fundamental_base (const fundamental_base&)
+
+public:
+  fundamental_base&
+  operator= (const X&);
+
+public:
+  operator const X & () const;
+  operator X& ();
+
+  template <typename Y>
+  operator Y () const;
+
+  template <typename Y>
+  operator Y ();
+};
+
+ +

2.5.2 Mapping for anyType

+ +

The XML Schema anyType built-in data type is mapped to the + xml_schema::type C++ class:

+ + 
+class type
+{
+public:
+  virtual
+  ~type ();
+
+  type ();
+  type (const type&);
+
+  type&
+  operator= (const type&);
+
+  virtual type*
+  _clone () const;
+
+  // anyType DOM content.
+  //
+public:
+  typedef element_optional dom_content_optional;
+
+  const dom_content_optional&
+  dom_content () const;
+
+  dom_content_optional&
+  dom_content ();
+
+  void
+  dom_content (const xercesc::DOMElement&);
+
+  void
+  dom_content (xercesc::DOMElement*);
+
+  void
+  dom_content (const dom_content_optional&);
+
+  const xercesc::DOMDocument&
+  dom_content_document () const;
+
+  xercesc::DOMDocument&
+  dom_content_document ();
+
+  bool
+  null_content () const;
+
+  // DOM association.
+  //
+public:
+  const xercesc::DOMNode*
+  _node () const;
+
+  xercesc::DOMNode*
+  _node ();
+};
+
+ +

When xml_schema::type is used to create an instance + (as opposed to being a base of a derived type), it represents + the XML Schema anyType type. anyType + allows any attributes and any content in any order. In the + C++/Tree mapping this content can be represented as a DOM + fragment, similar to XML Schema wildcards (Section + 2.12, "Mapping for any and + anyAttribute").

+ +

To enable automatic extraction of anyType content + during parsing, the --generate-any-type option must be + specified. Because the DOM API is used to access such content, the + Xerces-C++ runtime should be initialized by the application prior to + parsing and should remain initialized for the lifetime of objects + with the DOM content. For more information on the Xerces-C++ runtime + initialization see Section 3.1, "Initializing the + Xerces-C++ Runtime".

+ +

The DOM content is stored as the optional DOM element container + and the DOM content accessors and modifiers presented above are + identical to those generated for an optional element wildcard. + Refer to Section 2.12.2, "Mapping for any + with the Optional Cardinality Class" for details on their + semantics.

+ +

The dom_content_document() function returns the + DOM document used to store the raw XML content corresponding + to the anyType instance. It is equivalent to the + dom_document() function generated for types + with wildcards.

+ +

The null_content() accessor is an optimization function + that allows us to check for the lack of content without actually + creating its empty representation, that is, empty DOM document for + anyType or empty string for anySimpleType + (see the following section for details on anySimpleType).

+ +

For more information on DOM association refer to + Section 5.1, "DOM Association".

+ +

2.5.3 Mapping for anySimpleType

+ +

The XML Schema anySimpleType built-in data type is mapped + to the xml_schema::simple_type C++ class:

+ + 
+class simple_type: public type
+{
+public:
+  simple_type ();
+  simple_type (const C*);
+  simple_type (const std::basic_string<C>&);
+
+  simple_type (const simple_type&);
+
+  simple_type&
+  operator= (const simple_type&);
+
+  virtual simple_type*
+  _clone () const;
+
+  // anySimpleType text content.
+  //
+public:
+  const std::basic_string<C>&
+  text_content () const;
+
+  std::basic_string<C>&
+  text_content ();
+
+  void
+  text_content (const std::basic_string<C>&);
+};
+
+ +

When xml_schema::simple_type is used to create an instance + (as opposed to being a base of a derived type), it represents + the XML Schema anySimpleType type. anySimpleType + allows any simple content. In the C++/Tree mapping this content can + be represented as a string and accessed or modified with the + text_content() functions shown above.

+ +

2.5.4 Mapping for QName

+ +

The XML Schema QName built-in data type is mapped to the + xml_schema::qname C++ class:

+ + 
+class qname: public simple_type
+{
+public:
+  qname (const ncname&);
+  qname (const uri&, const ncname&);
+  qname (const qname&);
+
+public:
+  qname&
+  operator= (const qname&);
+
+public:
+  virtual qname*
+  _clone () const;
+
+public:
+  bool
+  qualified () const;
+
+  const uri&
+  namespace_ () const;
+
+  const ncname&
+  name () const;
+};
+
+ +

The qualified accessor function can be used to determine + if the name is qualified.

+ +

2.5.5 Mapping for IDREF

+ +

The XML Schema IDREF built-in data type is mapped to the + xml_schema::idref C++ class. This class implements the + smart pointer C++ idiom:

+ + 
+class idref: public ncname
+{
+public:
+  idref (const C* s);
+  idref (const C* s, std::size_t n);
+  idref (std::size_t n, C c);
+  idref (const std::basic_string<C>&);
+  idref (const std::basic_string<C>&,
+         std::size_t pos,
+         std::size_t n = npos);
+
+public:
+  idref (const idref&);
+
+public:
+  virtual idref*
+  _clone () const;
+
+public:
+  idref&
+  operator= (C c);
+
+  idref&
+  operator= (const C* s);
+
+  idref&
+  operator= (const std::basic_string<C>&)
+
+  idref&
+  operator= (const idref&);
+
+public:
+  const type*
+  operator-> () const;
+
+  type*
+  operator-> ();
+
+  const type&
+  operator* () const;
+
+  type&
+  operator* ();
+
+  const type*
+  get () const;
+
+  type*
+  get ();
+
+  // Conversion to bool.
+  //
+public:
+  typedef void (idref::*bool_convertible)();
+  operator bool_convertible () const;
+};
+
+ +

The object, idref instance refers to, is the immediate + container of the matching id instance. For example, + with the following instance document and schema: +

+ + + 
+<!-- test.xml -->
+<root>
+  <object id="obj-1" text="hello"/>
+  <reference>obj-1</reference>
+</root>
+
+<!-- test.xsd -->
+<schema>
+  <complexType name="object_type">
+    <attribute name="id" type="ID"/>
+    <attribute name="text" type="string"/>
+  </complexType>
+
+  <complexType name="root_type">
+    <sequence>
+      <element name="object" type="object_type"/>
+      <element name="reference" type="IDREF"/>
+    </sequence>
+  </complexType>
+
+  <element name="root" type="root_type"/>
+</schema>
+
+ +

The ref instance in the code below will refer to + an object of type object_type:

+ + 
+root_type& root = ...;
+xml_schema::idref& ref (root.reference ());
+object_type& obj (dynamic_cast<object_type&> (*ref));
+cout << obj.text () << endl;
+
+ +

The smart pointer interface of the idref class always + returns a pointer or reference to xml_schema::type. + This means that you will need to manually cast such pointer or + reference to its real (dynamic) type before you can use it (unless + all you need is the base interface provided by + xml_schema::type). As a special extension to the XML + Schema language, the mapping supports static typing of idref + references by employing the refType extension attribute. + The following example illustrates this mechanism: +

+ + 
+<!-- test.xsd -->
+<schema
+  xmlns:xse="https://www.codesynthesis.com/xmlns/xml-schema-extension">
+
+  ...
+
+      <element name="reference" type="IDREF" xse:refType="object_type"/>
+
+  ...
+
+</schema>
+
+ +

With this modification we do not need to do manual casting anymore: +

+ + 
+root_type& root = ...;
+root_type::reference_type& ref (root.reference ());
+object_type& obj (*ref);
+cout << ref->text () << endl;
+
+ + +

2.5.6 Mapping for base64Binary and + hexBinary

+ +

The XML Schema base64Binary and hexBinary + built-in data types are mapped to the + xml_schema::base64_binary and + xml_schema::hex_binary C++ classes, respectively. The + base64_binary and hex_binary classes + support a simple buffer abstraction by inheriting from the + xml_schema::buffer class: +

+ + 
+class bounds: public virtual exception
+{
+public:
+  virtual const char*
+  what () const throw ();
+};
+
+class buffer
+{
+public:
+  typedef std::size_t size_t;
+
+public:
+  buffer (size_t size = 0);
+  buffer (size_t size, size_t capacity);
+  buffer (const void* data, size_t size);
+  buffer (const void* data, size_t size, size_t capacity);
+  buffer (void* data,
+          size_t size,
+          size_t capacity,
+          bool assume_ownership);
+
+public:
+  buffer (const buffer&);
+
+  buffer&
+  operator= (const buffer&);
+
+  void
+  swap (buffer&);
+
+public:
+  size_t
+  capacity () const;
+
+  bool
+  capacity (size_t);
+
+public:
+  size_t
+  size () const;
+
+  bool
+  size (size_t);
+
+public:
+  const char*
+  data () const;
+
+  char*
+  data ();
+
+  const char*
+  begin () const;
+
+  char*
+  begin ();
+
+  const char*
+  end () const;
+
+  char*
+  end ();
+};
+
+ +

The last overloaded constructor reuses an existing data buffer instead + of making a copy. If the assume_ownership argument is + true, the instance assumes ownership of the + memory block pointed to by the data argument and will + eventually release it by calling operator delete. The + capacity and size modifier functions return + true if the underlying buffer has moved. +

+ +

The bounds exception is thrown if the constructor + arguments violate the (size <= capacity) + constraint.

+ +

The base64_binary and hex_binary classes + support the buffer interface and perform automatic + decoding/encoding from/to the Base64 and Hex formats, respectively: +

+ + 
+class base64_binary: public simple_type, public buffer
+{
+public:
+  base64_binary (size_t size = 0);
+  base64_binary (size_t size, size_t capacity);
+  base64_binary (const void* data, size_t size);
+  base64_binary (const void* data, size_t size, size_t capacity);
+  base64_binary (void* data,
+                 size_t size,
+                 size_t capacity,
+                 bool assume_ownership);
+
+public:
+  base64_binary (const base64_binary&);
+
+  base64_binary&
+  operator= (const base64_binary&);
+
+  virtual base64_binary*
+  _clone () const;
+
+public:
+  std::basic_string<C>
+  encode () const;
+};
+
+ + 
+class hex_binary: public simple_type, public buffer
+{
+public:
+  hex_binary (size_t size = 0);
+  hex_binary (size_t size, size_t capacity);
+  hex_binary (const void* data, size_t size);
+  hex_binary (const void* data, size_t size, size_t capacity);
+  hex_binary (void* data,
+              size_t size,
+              size_t capacity,
+              bool assume_ownership);
+
+public:
+  hex_binary (const hex_binary&);
+
+  hex_binary&
+  operator= (const hex_binary&);
+
+  virtual hex_binary*
+  _clone () const;
+
+public:
+  std::basic_string<C>
+  encode () const;
+};
+
+ + +

2.5.7 Time Zone Representation

+ +

The date, dateTime, gDay, + gMonth, gMonthDay, gYear, + gYearMonth, and time XML Schema built-in + types all include an optional time zone component. The following + xml_schema::time_zone base class is used to represent + this information:

+ + 
+class time_zone
+{
+public:
+  time_zone ();
+  time_zone (short hours, short minutes);
+
+  bool
+  zone_present () const;
+
+  void
+  zone_reset ();
+
+  short
+  zone_hours () const;
+
+  void
+  zone_hours (short);
+
+  short
+  zone_minutes () const;
+
+  void
+  zone_minutes (short);
+};
+
+bool
+operator== (const time_zone&, const time_zone&);
+
+bool
+operator!= (const time_zone&, const time_zone&);
+
+ +

The zone_present() accessor function returns true + if the time zone is specified. The zone_reset() modifier + function resets the time zone object to the not specified + state. If the time zone offset is negative then both hours and + minutes components are represented as negative integers.

+ + +

2.5.8 Mapping for date

+ +

The XML Schema date built-in data type is mapped to the + xml_schema::date C++ class which represents a year, a day, + and a month with an optional time zone. Its interface is presented + below. For more information on the base xml_schema::time_zone + class refer to Section 2.5.7, "Time Zone + Representation".

+ + 
+class date: public simple_type, public time_zone
+{
+public:
+  date (int year, unsigned short month, unsigned short day);
+  date (int year, unsigned short month, unsigned short day,
+        short zone_hours, short zone_minutes);
+
+public:
+  date (const date&);
+
+  date&
+  operator= (const date&);
+
+  virtual date*
+  _clone () const;
+
+public:
+  int
+  year () const;
+
+  void
+  year (int);
+
+  unsigned short
+  month () const;
+
+  void
+  month (unsigned short);
+
+  unsigned short
+  day () const;
+
+  void
+  day (unsigned short);
+};
+
+bool
+operator== (const date&, const date&);
+
+bool
+operator!= (const date&, const date&);
+
+ +

2.5.9 Mapping for dateTime

+ +

The XML Schema dateTime built-in data type is mapped to the + xml_schema::date_time C++ class which represents a year, a month, + a day, hours, minutes, and seconds with an optional time zone. Its interface + is presented below. For more information on the base + xml_schema::time_zone class refer to Section + 2.5.7, "Time Zone Representation".

+ + 
+class date_time: public simple_type, public time_zone
+{
+public:
+  date_time (int year, unsigned short month, unsigned short day,
+             unsigned short hours, unsigned short minutes,
+             double seconds);
+
+  date_time (int year, unsigned short month, unsigned short day,
+             unsigned short hours, unsigned short minutes,
+             double seconds, short zone_hours, short zone_minutes);
+public:
+  date_time (const date_time&);
+
+  date_time&
+  operator= (const date_time&);
+
+  virtual date_time*
+  _clone () const;
+
+public:
+  int
+  year () const;
+
+  void
+  year (int);
+
+  unsigned short
+  month () const;
+
+  void
+  month (unsigned short);
+
+  unsigned short
+  day () const;
+
+  void
+  day (unsigned short);
+
+  unsigned short
+  hours () const;
+
+  void
+  hours (unsigned short);
+
+  unsigned short
+  minutes () const;
+
+  void
+  minutes (unsigned short);
+
+  double
+  seconds () const;
+
+  void
+  seconds (double);
+};
+
+bool
+operator== (const date_time&, const date_time&);
+
+bool
+operator!= (const date_time&, const date_time&);
+
+ + +

2.5.10 Mapping for duration

+ +

The XML Schema duration built-in data type is mapped to the + xml_schema::duration C++ class which represents a potentially + negative duration in the form of years, months, days, hours, minutes, + and seconds. Its interface is presented below.

+ + 
+class duration: public simple_type
+{
+public:
+  duration (bool negative,
+            unsigned int years, unsigned int months, unsigned int days,
+            unsigned int hours, unsigned int minutes, double seconds);
+public:
+  duration (const duration&);
+
+  duration&
+  operator= (const duration&);
+
+  virtual duration*
+  _clone () const;
+
+public:
+  bool
+  negative () const;
+
+  void
+  negative (bool);
+
+  unsigned int
+  years () const;
+
+  void
+  years (unsigned int);
+
+  unsigned int
+  months () const;
+
+  void
+  months (unsigned int);
+
+  unsigned int
+  days () const;
+
+  void
+  days (unsigned int);
+
+  unsigned int
+  hours () const;
+
+  void
+  hours (unsigned int);
+
+  unsigned int
+  minutes () const;
+
+  void
+  minutes (unsigned int);
+
+  double
+  seconds () const;
+
+  void
+  seconds (double);
+};
+
+bool
+operator== (const duration&, const duration&);
+
+bool
+operator!= (const duration&, const duration&);
+
+ + +

2.5.11 Mapping for gDay

+ +

The XML Schema gDay built-in data type is mapped to the + xml_schema::gday C++ class which represents a day of the + month with an optional time zone. Its interface is presented below. + For more information on the base xml_schema::time_zone + class refer to Section 2.5.7, "Time Zone + Representation".

+ + 
+class gday: public simple_type, public time_zone
+{
+public:
+  explicit
+  gday (unsigned short day);
+  gday (unsigned short day, short zone_hours, short zone_minutes);
+
+public:
+  gday (const gday&);
+
+  gday&
+  operator= (const gday&);
+
+  virtual gday*
+  _clone () const;
+
+public:
+  unsigned short
+  day () const;
+
+  void
+  day (unsigned short);
+};
+
+bool
+operator== (const gday&, const gday&);
+
+bool
+operator!= (const gday&, const gday&);
+
+ + +

2.5.12 Mapping for gMonth

+ +

The XML Schema gMonth built-in data type is mapped to the + xml_schema::gmonth C++ class which represents a month of the + year with an optional time zone. Its interface is presented below. + For more information on the base xml_schema::time_zone + class refer to Section 2.5.7, "Time Zone + Representation".

+ + 
+class gmonth: public simple_type, public time_zone
+{
+public:
+  explicit
+  gmonth (unsigned short month);
+  gmonth (unsigned short month,
+          short zone_hours, short zone_minutes);
+
+public:
+  gmonth (const gmonth&);
+
+  gmonth&
+  operator= (const gmonth&);
+
+  virtual gmonth*
+  _clone () const;
+
+public:
+  unsigned short
+  month () const;
+
+  void
+  month (unsigned short);
+};
+
+bool
+operator== (const gmonth&, const gmonth&);
+
+bool
+operator!= (const gmonth&, const gmonth&);
+
+ + +

2.5.13 Mapping for gMonthDay

+ +

The XML Schema gMonthDay built-in data type is mapped to the + xml_schema::gmonth_day C++ class which represents a day and + a month of the year with an optional time zone. Its interface is presented + below. For more information on the base xml_schema::time_zone + class refer to Section 2.5.7, "Time Zone + Representation".

+ + 
+class gmonth_day: public simple_type, public time_zone
+{
+public:
+  gmonth_day (unsigned short month, unsigned short day);
+  gmonth_day (unsigned short month, unsigned short day,
+              short zone_hours, short zone_minutes);
+
+public:
+  gmonth_day (const gmonth_day&);
+
+  gmonth_day&
+  operator= (const gmonth_day&);
+
+  virtual gmonth_day*
+  _clone () const;
+
+public:
+  unsigned short
+  month () const;
+
+  void
+  month (unsigned short);
+
+  unsigned short
+  day () const;
+
+  void
+  day (unsigned short);
+};
+
+bool
+operator== (const gmonth_day&, const gmonth_day&);
+
+bool
+operator!= (const gmonth_day&, const gmonth_day&);
+
+ + +

2.5.14 Mapping for gYear

+ +

The XML Schema gYear built-in data type is mapped to the + xml_schema::gyear C++ class which represents a year with + an optional time zone. Its interface is presented below. For more + information on the base xml_schema::time_zone class refer + to Section 2.5.7, "Time Zone Representation".

+ + 
+class gyear: public simple_type, public time_zone
+{
+public:
+  explicit
+  gyear (int year);
+  gyear (int year, short zone_hours, short zone_minutes);
+
+public:
+  gyear (const gyear&);
+
+  gyear&
+  operator= (const gyear&);
+
+  virtual gyear*
+  _clone () const;
+
+public:
+  int
+  year () const;
+
+  void
+  year (int);
+};
+
+bool
+operator== (const gyear&, const gyear&);
+
+bool
+operator!= (const gyear&, const gyear&);
+
+ + +

2.5.15 Mapping for gYearMonth

+ +

The XML Schema gYearMonth built-in data type is mapped to + the xml_schema::gyear_month C++ class which represents + a year and a month with an optional time zone. Its interface is presented + below. For more information on the base xml_schema::time_zone + class refer to Section 2.5.7, "Time Zone + Representation".

+ + 
+class gyear_month: public simple_type, public time_zone
+{
+public:
+  gyear_month (int year, unsigned short month);
+  gyear_month (int year, unsigned short month,
+               short zone_hours, short zone_minutes);
+public:
+  gyear_month (const gyear_month&);
+
+  gyear_month&
+  operator= (const gyear_month&);
+
+  virtual gyear_month*
+  _clone () const;
+
+public:
+  int
+  year () const;
+
+  void
+  year (int);
+
+  unsigned short
+  month () const;
+
+  void
+  month (unsigned short);
+};
+
+bool
+operator== (const gyear_month&, const gyear_month&);
+
+bool
+operator!= (const gyear_month&, const gyear_month&);
+
+ + +

2.5.16 Mapping for time

+ +

The XML Schema time built-in data type is mapped to + the xml_schema::time C++ class which represents hours, + minutes, and seconds with an optional time zone. Its interface is + presented below. For more information on the base + xml_schema::time_zone class refer to + Section 2.5.7, "Time Zone Representation".

+ + 
+class time: public simple_type, public time_zone
+{
+public:
+  time (unsigned short hours, unsigned short minutes, double seconds);
+  time (unsigned short hours, unsigned short minutes, double seconds,
+        short zone_hours, short zone_minutes);
+
+public:
+  time (const time&);
+
+  time&
+  operator= (const time&);
+
+  virtual time*
+  _clone () const;
+
+public:
+  unsigned short
+  hours () const;
+
+  void
+  hours (unsigned short);
+
+  unsigned short
+  minutes () const;
+
+  void
+  minutes (unsigned short);
+
+  double
+  seconds () const;
+
+  void
+  seconds (double);
+};
+
+bool
+operator== (const time&, const time&);
+
+bool
+operator!= (const time&, const time&);
+
+ + + + +

2.6 Mapping for Simple Types

+ +

An XML Schema simple type is mapped to a C++ class with the same + name as the simple type. The class defines a public copy constructor, + a public copy assignment operator, and a public virtual + _clone function. The _clone function is + declared const, does not take any arguments, and returns + a pointer to a complete copy of the instance allocated in the free + store. The _clone function shall be used to make copies + when static type and dynamic type of the instance may differ (see + Section 2.11, "Mapping for xsi:type + and Substitution Groups"). For instance:

+ + 
+<simpleType name="object">
+  ...
+</simpleType>
+
+ +

is mapped to:

+ + 
+class object: ...
+{
+public:
+  object (const object&);
+
+public:
+  object&
+  operator= (const object&);
+
+public:
+  virtual object*
+  _clone () const;
+
+  ...
+
+};
+
+ +

The base class specification and the rest of the class definition + depend on the type of derivation used to define the simple type.

+ + +

2.6.1 Mapping for Derivation by Restriction

+ +

XML Schema derivation by restriction is mapped to C++ public + inheritance. The base type of the restriction becomes the base + type for the resulting C++ class. In addition to the members described + in Section 2.6, "Mapping for Simple Types", the + resulting C++ class defines a public constructor with the base type + as its single argument. For instance:

+ + 
+<simpleType name="object">
+  <restriction base="base">
+    ...
+  </restriction>
+</simpleType>
+
+ +

is mapped to:

+ + 
+class object: public base
+{
+public:
+  object (const base&);
+  object (const object&);
+
+public:
+  object&
+  operator= (const object&);
+
+public:
+  virtual object*
+  _clone () const;
+};
+
+ + +

2.6.2 Mapping for Enumerations

+ +

XML Schema restriction by enumeration is mapped to a C++ class + with semantics similar to C++ enum. Each XML Schema + enumeration element is mapped to a C++ enumerator with the + name derived from the value attribute and defined + in the class scope. In addition to the members + described in Section 2.6, "Mapping for Simple Types", + the resulting C++ class defines a public constructor that can be called + with one of the enumerators as its single argument, a public constructor + that can be called with enumeration's base value as its single + argument, a public assignment operator that can be used to assign the + value of one of the enumerators, and a public implicit conversion + operator to the underlying C++ enum type.

+ +

Furthermore, for string-based enumeration types, the resulting C++ + class defines a public constructor with a single argument of type + const C* and a public constructor with a single + argument of type const std::basic_string<C>&. + For instance:

+ + 
+<simpleType name="color">
+  <restriction base="string">
+    <enumeration value="red"/>
+    <enumeration value="green"/>
+    <enumeration value="blue"/>
+  </restriction>
+</simpleType>
+
+ +

is mapped to:

+ + 
+class color: public xml_schema::string
+{
+public:
+  enum value
+  {
+    red,
+    green,
+    blue
+  };
+
+public:
+  color (value);
+  color (const C*);
+  color (const std::basic_string<C>&);
+  color (const xml_schema::string&);
+  color (const color&);
+
+public:
+  color&
+  operator= (value);
+
+  color&
+  operator= (const color&);
+
+public:
+  virtual color*
+  _clone () const;
+
+public:
+  operator value () const;
+};
+
+ +

2.6.3 Mapping for Derivation by List

+ +

XML Schema derivation by list is mapped to C++ public + inheritance from xml_schema::simple_type + (Section 2.5.3, "Mapping for + anySimpleType") and a suitable sequence type. + The list item type becomes the element type of the sequence. + In addition to the members described in Section 2.6, + "Mapping for Simple Types", the resulting C++ class defines + a public default constructor, a public constructor + with the first argument of type size_type and + the second argument of list item type that creates + a list object with the specified number of copies of the specified + element value, and a public constructor with the two arguments + of an input iterator type that creates a list object from an + iterator range. For instance: +

+ + 
+<simpleType name="int_list">
+  <list itemType="int"/>
+</simpleType>
+
+ +

is mapped to:

+ + 
+class int_list: public simple_type,
+                public sequence<int>
+{
+public:
+  int_list ();
+  int_list (size_type n, int x);
+
+  template <typename I>
+  int_list (const I& begin, const I& end);
+  int_list (const int_list&);
+
+public:
+  int_list&
+  operator= (const int_list&);
+
+public:
+  virtual int_list*
+  _clone () const;
+};
+
+ +

The sequence class template is defined in an + implementation-specific namespace. It conforms to the + sequence interface as defined by the ISO/ANSI Standard for + C++ (ISO/IEC 14882:1998, Section 23.1.1, "Sequences"). + Practically, this means that you can treat such a sequence + as if it was std::vector. One notable extension + to the standard interface that is available only for + sequences of non-fundamental C++ types is the addition of + the overloaded push_back and insert + member functions which instead of the constant reference + to the element type accept automatic pointer (std::unique_ptr + or std::auto_ptr, depending on the C++ standard + selected) to the element type. These functions assume ownership + of the pointed to object and reset the passed automatic pointer. +

+ +

2.6.4 Mapping for Derivation by Union

+ +

XML Schema derivation by union is mapped to C++ public + inheritance from xml_schema::simple_type + (Section 2.5.3, "Mapping for + anySimpleType") and std::basic_string<C>. + In addition to the members described in Section 2.6, + "Mapping for Simple Types", the resulting C++ class defines a + public constructor with a single argument of type const C* + and a public constructor with a single argument of type + const std::basic_string<C>&. For instance: +

+ + 
+<simpleType name="int_string_union">
+  <xsd:union memberTypes="xsd:int xsd:string"/>
+</simpleType>
+
+ +

is mapped to:

+ + 
+class int_string_union: public simple_type,
+                        public std::basic_string<C>
+{
+public:
+  int_string_union (const C*);
+  int_string_union (const std::basic_string<C>&);
+  int_string_union (const int_string_union&);
+
+public:
+  int_string_union&
+  operator= (const int_string_union&);
+
+public:
+  virtual int_string_union*
+  _clone () const;
+};
+
+ +

2.7 Mapping for Complex Types

+ +

An XML Schema complex type is mapped to a C++ class with the same + name as the complex type. The class defines a public copy constructor, + a public copy assignment operator, and a public virtual + _clone function. The _clone function is + declared const, does not take any arguments, and returns + a pointer to a complete copy of the instance allocated in the free + store. The _clone function shall be used to make copies + when static type and dynamic type of the instance may differ (see + Section 2.11, "Mapping for xsi:type + and Substitution Groups").

+ +

Additionally, the resulting C++ class + defines two public constructors that take an initializer for each + member of the complex type and all its base types that belongs to + the One cardinality class (see Section 2.8, "Mapping + for Local Elements and Attributes"). In the first constructor, + the arguments are passed as constant references and the newly created + instance is initialized with copies of the passed objects. In the + second constructor, arguments that are complex types (that is, + they themselves contain elements or attributes) are passed as + either std::unique_ptr (C++11) or std::auto_ptr + (C++98), depending on the C++ standard selected. In this case the newly + created instance is directly initialized with and assumes ownership + of the pointed to objects and the std::[unique|auto]_ptr + arguments are reset to 0. For instance:

+ + 
+<complexType name="complex">
+  <sequence>
+    <element name="a" type="int"/>
+    <element name="b" type="string"/>
+  </sequence>
+</complexType>
+
+<complexType name="object">
+  <sequence>
+    <element name="s-one" type="boolean"/>
+    <element name="c-one" type="complex"/>
+    <element name="optional" type="int" minOccurs="0"/>
+    <element name="sequence" type="string" maxOccurs="unbounded"/>
+  </sequence>
+</complexType>
+
+ +

is mapped to:

+ + 
+class complex: public xml_schema::type
+{
+public:
+  object (const int& a, const xml_schema::string& b);
+  object (const complex&);
+
+public:
+  object&
+  operator= (const complex&);
+
+public:
+  virtual complex*
+  _clone () const;
+
+  ...
+
+};
+
+class object: public xml_schema::type
+{
+public:
+  object (const bool& s_one, const complex& c_one);
+  object (const bool& s_one, std::[unique|auto]_ptr<complex> c_one);
+  object (const object&);
+
+public:
+  object&
+  operator= (const object&);
+
+public:
+  virtual object*
+  _clone () const;
+
+  ...
+
+};
+
+ +

Notice that the generated complex class does not + have the second (std::[unique|auto]_ptr) version of the + constructor since all its required members are of simple types.

+ +

If an XML Schema complex type has an ultimate base which is an XML + Schema simple type then the resulting C++ class also defines a public + constructor that takes an initializer for the base type as well as + for each member of the complex type and all its base types that + belongs to the One cardinality class. For instance:

+ + 
+<complexType name="object">
+  <simpleContent>
+    <extension base="date">
+      <attribute name="lang" type="language" use="required"/>
+    </extension>
+  </simpleContent>
+</complexType>
+
+ +

is mapped to:

+ + 
+class object: public xml_schema::string
+{
+public:
+  object (const xml_schema::language& lang);
+
+  object (const xml_schema::date& base,
+          const xml_schema::language& lang);
+
+  ...
+
+};
+
+ +

Furthermore, for string-based XML Schema complex types, the resulting C++ + class also defines two public constructors with the first arguments + of type const C* and std::basic_string<C>&, + respectively, followed by arguments for each member of the complex + type and all its base types that belongs to the One cardinality + class. For enumeration-based complex types the resulting C++ + class also defines a public constructor with the first arguments + of the underlying enum type followed by arguments for each member + of the complex type and all its base types that belongs to the One + cardinality class. For instance:

+ + 
+<simpleType name="color">
+  <restriction base="string">
+    <enumeration value="red"/>
+    <enumeration value="green"/>
+    <enumeration value="blue"/>
+  </restriction>
+</simpleType>
+
+<complexType name="object">
+  <simpleContent>
+    <extension base="color">
+      <attribute name="lang" type="language" use="required"/>
+    </extension>
+  </simpleContent>
+</complexType>
+
+ +

is mapped to:

+ + 
+class color: public xml_schema::string
+{
+public:
+  enum value
+  {
+    red,
+    green,
+    blue
+  };
+
+public:
+  color (value);
+  color (const C*);
+  color (const std::basic_string<C>&);
+
+  ...
+
+};
+
+class object: color
+{
+public:
+  object (const color& base,
+          const xml_schema::language& lang);
+
+  object (const color::value& base,
+          const xml_schema::language& lang);
+
+  object (const C* base,
+          const xml_schema::language& lang);
+
+  object (const std::basic_string<C>& base,
+          const xml_schema::language& lang);
+
+  ...
+
+};
+
+ +

Additional constructors can be requested with the + --generate-default-ctor and + --generate-from-base-ctor options. See the + XSD + Compiler Command Line Manual for details.

+ +

If an XML Schema complex type is not explicitly derived from any type, + the resulting C++ class is derived from xml_schema::type. + In cases where an XML Schema complex type is defined using derivation + by extension or restriction, the resulting C++ base class specification + depends on the type of derivation and is described in the subsequent + sections. +

+ +

The mapping for elements and attributes that are defined in a complex + type is described in Section 2.8, "Mapping for Local + Elements and Attributes". +

+ +

2.7.1 Mapping for Derivation by Extension

+ +

XML Schema derivation by extension is mapped to C++ public + inheritance. The base type of the extension becomes the base + type for the resulting C++ class. +

+ +

2.7.2 Mapping for Derivation by Restriction

+ +

XML Schema derivation by restriction is mapped to C++ public + inheritance. The base type of the restriction becomes the base + type for the resulting C++ class. XML Schema elements and + attributes defined within restriction do not result in any + definitions in the resulting C++ class. Instead, corresponding + (unrestricted) definitions are inherited from the base class. + In the future versions of this mapping, such elements and + attributes may result in redefinitions of accessors and + modifiers to reflect their restricted semantics. +

+ + + +

2.8 Mapping for Local Elements and Attributes

+ +

XML Schema element and attribute definitions are called local + if they appear within a complex type definition, an element group + definition, or an attribute group definitions. +

+ +

Local XML Schema element and attribute definitions have the same + C++ mapping. Therefore, in this section, local elements and + attributes are collectively called members. +

+ +

While there are many different member cardinality combinations + (determined by the use attribute for attributes and + the minOccurs and maxOccurs attributes + for elements), the mapping divides all possible cardinality + combinations into three cardinality classes: +

+ +
+
one
+
attributes: use == "required"
+
attributes: use == "optional" and has default or fixed value
+
elements: minOccurs == "1" and maxOccurs == "1"
+ +
optional
+
attributes: use == "optional" and doesn't have default or fixed value
+
elements: minOccurs == "0" and maxOccurs == "1"
+ +
sequence
+
elements: maxOccurs > "1"
+
+ +

An optional attribute with a default or fixed value acquires this value + if the attribute hasn't been specified in an instance document (see + Appendix A, "Default and Fixed Values"). This + mapping places such optional attributes to the One cardinality + class.

+ +

A member is mapped to a set of public type definitions + (typedefs) and a set of public accessor and modifier + functions. Type definitions have names derived from the member's + name. The accessor and modifier functions have the same name as the + member. For example: +

+ + 
+<complexType name="object">
+  <sequence>
+    <element name="member" type="string"/>
+  </sequence>
+</complexType>
+
+ +

is mapped to:

+ + 
+class object: public xml_schema::type
+{
+public:
+  typedef xml_schema::string member_type;
+
+  const member_type&
+  member () const;
+
+  ...
+
+};
+
+ +

In addition, if a member has a default or fixed value, a static + accessor function is generated that returns this value. For + example:

+ +
+<complexType name="object">
+  <attribute name="data" type="string" default="test"/>
+</complexType>
+
+ +

is mapped to:

+ + 
+class object: public xml_schema::type
+{
+public:
+  typedef xml_schema::string data_type;
+
+  const data_type&
+  data () const;
+
+  static const data_type&
+  data_default_value ();
+
+  ...
+
+};
+
+ +

Names and semantics of type definitions for the member as well + as signatures of the accessor and modifier functions depend on + the member's cardinality class and are described in the following + sub-sections. +

+ + +

2.8.1 Mapping for Members with the One Cardinality Class

+ +

For the One cardinality class, the type definitions consist of + an alias for the member's type with the name created by appending + the _type suffix to the member's name. +

+ +

The accessor functions come in constant and non-constant versions. + The constant accessor function returns a constant reference to the + member and can be used for read-only access. The non-constant + version returns an unrestricted reference to the member and can + be used for read-write access. +

+ +

The first modifier function expects an argument of type reference to + constant of the member's type. It makes a deep copy of its argument. + Except for member's types that are mapped to fundamental C++ types, + the second modifier function is provided that expects an argument + of type automatic pointer (std::unique_ptr or + std::auto_ptr, depending on the C++ standard selected) + to the member's type. It assumes ownership of the pointed to object + and resets the passed automatic pointer. For instance:

+ + 
+<complexType name="object">
+  <sequence>
+    <element name="member" type="string"/>
+  </sequence>
+</complexType>
+
+ +

is mapped to:

+ + 
+class object: public xml_schema::type
+{
+public:
+  // Type definitions.
+  //
+  typedef xml_schema::string member_type;
+
+  // Accessors.
+  //
+  const member_type&
+  member () const;
+
+  member_type&
+  member ();
+
+  // Modifiers.
+  //
+  void
+  member (const member_type&);
+
+  void
+  member (std::[unique|auto]_ptr<member_type>);
+  ...
+
+};
+
+ +

In addition, if requested by specifying the --generate-detach + option and only for members of non-fundamental C++ types, the mapping + provides a detach function that returns an automatic pointer to the + member's type, for example:

+ + 
+class object: public xml_schema::type
+{
+public:
+  ...
+
+  std::[unique|auto]_ptr<member_type>
+  detach_member ();
+  ...
+
+};
+
+ +

This function detaches the value from the tree leaving the member + value uninitialized. Accessing such an uninitialized value prior to + re-initializing it results in undefined behavior.

+ +

The following code shows how one could use this mapping:

+ + 
+void
+f (object& o)
+{
+  using xml_schema::string;
+
+  string s (o.member ());                // get
+  object::member_type& sr (o.member ()); // get
+
+  o.member ("hello");           // set, deep copy
+  o.member () = "hello";        // set, deep copy
+
+  // C++11 version.
+  //
+  std::unique_ptr<string> p (new string ("hello"));
+  o.member (std::move (p));     // set, assumes ownership
+  p = o.detach_member ();       // detach, member is uninitialized
+  o.member (std::move (p));     // re-attach
+
+  // C++98 version.
+  //
+  std::auto_ptr<string> p (new string ("hello"));
+  o.member (p);                 // set, assumes ownership
+  p = o.detach_member ();       // detach, member is uninitialized
+  o.member (p);                 // re-attach
+}
+
+ + +

2.8.2 Mapping for Members with the Optional Cardinality Class

+ +

For the Optional cardinality class, the type definitions consist of + an alias for the member's type with the name created by appending + the _type suffix to the member's name and an alias for + the container type with the name created by appending the + _optional suffix to the member's name. +

+ +

Unlike accessor functions for the One cardinality class, accessor + functions for the Optional cardinality class return references to + corresponding containers rather than directly to members. The + accessor functions come in constant and non-constant versions. + The constant accessor function returns a constant reference to + the container and can be used for read-only access. The non-constant + version returns an unrestricted reference to the container + and can be used for read-write access. +

+ +

The modifier functions are overloaded for the member's + type and the container type. The first modifier function + expects an argument of type reference to constant of the + member's type. It makes a deep copy of its argument. + Except for member's types that are mapped to fundamental C++ types, + the second modifier function is provided that expects an argument + of type automatic pointer (std::unique_ptr or + std::auto_ptr, depending on the C++ standard selected) + to the member's type. It assumes ownership of the pointed to object + and resets the passed automatic pointer. The last modifier function + expects an argument of type reference to constant of the container + type. It makes a deep copy of its argument. For instance: +

+ + 
+<complexType name="object">
+  <sequence>
+    <element name="member" type="string" minOccurs="0"/>
+  </sequence>
+</complexType>
+
+ +

is mapped to:

+ + 
+class object: public xml_schema::type
+{
+public:
+  // Type definitions.
+  //
+  typedef xml_schema::string member_type;
+  typedef optional<member_type> member_optional;
+
+  // Accessors.
+  //
+  const member_optional&
+  member () const;
+
+  member_optional&
+  member ();
+
+  // Modifiers.
+  //
+  void
+  member (const member_type&);
+
+  void
+  member (std::[unique|auto]_ptr<member_type>);
+
+  void
+  member (const member_optional&);
+
+  ...
+
+};
+
+ + +

The optional class template is defined in an + implementation-specific namespace and has the following + interface. The [unique|auto]_ptr-based constructor + and modifier function are only available if the template + argument is not a fundamental C++ type. +

+ + 
+template <typename X>
+class optional
+{
+public:
+  optional ();
+
+  // Makes a deep copy.
+  //
+  explicit
+  optional (const X&);
+
+  // Assumes ownership.
+  //
+  explicit
+  optional (std::[unique|auto]_ptr<X>);
+
+  optional (const optional&);
+
+public:
+  optional&
+  operator= (const X&);
+
+  optional&
+  operator= (const optional&);
+
+  // Pointer-like interface.
+  //
+public:
+  const X*
+  operator-> () const;
+
+  X*
+  operator-> ();
+
+  const X&
+  operator* () const;
+
+  X&
+  operator* ();
+
+  typedef void (optional::*bool_convertible) ();
+  operator bool_convertible () const;
+
+  // Get/set interface.
+  //
+public:
+  bool
+  present () const;
+
+  const X&
+  get () const;
+
+  X&
+  get ();
+
+  // Makes a deep copy.
+  //
+  void
+  set (const X&);
+
+  // Assumes ownership.
+  //
+  void
+  set (std::[unique|auto]_ptr<X>);
+
+  // Detach and return the contained value.
+  //
+  std::[unique|auto]_ptr<X>
+  detach ();
+
+  void
+  reset ();
+};
+
+template <typename X>
+bool
+operator== (const optional<X>&, const optional<X>&);
+
+template <typename X>
+bool
+operator!= (const optional<X>&, const optional<X>&);
+
+template <typename X>
+bool
+operator< (const optional<X>&, const optional<X>&);
+
+template <typename X>
+bool
+operator> (const optional<X>&, const optional<X>&);
+
+template <typename X>
+bool
+operator<= (const optional<X>&, const optional<X>&);
+
+template <typename X>
+bool
+operator>= (const optional<X>&, const optional<X>&);
+
+ + +

The following code shows how one could use this mapping:

+ + 
+void
+f (object& o)
+{
+  using xml_schema::string;
+
+  if (o.member ().present ())       // test
+  {
+    string& s (o.member ().get ()); // get
+    o.member ("hello");             // set, deep copy
+    o.member ().set ("hello");      // set, deep copy
+    o.member ().reset ();           // reset
+  }
+
+  // Same as above but using pointer notation:
+  //
+  if (o.member ())                  // test
+  {
+    string& s (*o.member ());       // get
+    o.member ("hello");             // set, deep copy
+    *o.member () = "hello";         // set, deep copy
+    o.member ().reset ();           // reset
+  }
+
+  // C++11 version.
+  //
+  std::unique_ptr<string> p (new string ("hello"));
+  o.member (std::move (p));         // set, assumes ownership
+
+  p.reset (new string ("hello"));
+  o.member ().set (std::move (p));  // set, assumes ownership
+
+  p = o.member ().detach ();        // detach, member is reset
+  o.member ().set (std::move (p));  // re-attach
+
+  // C++98 version.
+  //
+  std::auto_ptr<string> p (new string ("hello"));
+  o.member (p);                     // set, assumes ownership
+
+  p = new string ("hello");
+  o.member ().set (p);              // set, assumes ownership
+
+  p = o.member ().detach ();        // detach, member is reset
+  o.member ().set (p);              // re-attach
+}
+
+ + +

2.8.3 Mapping for Members with the Sequence Cardinality Class

+ +

For the Sequence cardinality class, the type definitions consist of an + alias for the member's type with the name created by appending + the _type suffix to the member's name, an alias of + the container type with the name created by appending the + _sequence suffix to the member's name, an alias of + the iterator type with the name created by appending the + _iterator suffix to the member's name, and an alias + of the constant iterator type with the name created by appending the + _const_iterator suffix to the member's name. +

+ +

The accessor functions come in constant and non-constant versions. + The constant accessor function returns a constant reference to the + container and can be used for read-only access. The non-constant + version returns an unrestricted reference to the container and can + be used for read-write access. +

+ +

The modifier function expects an argument of type reference to + constant of the container type. The modifier function + makes a deep copy of its argument. For instance: +

+ + + 
+<complexType name="object">
+  <sequence>
+    <element name="member" type="string" minOccurs="unbounded"/>
+  </sequence>
+</complexType>
+
+ +

is mapped to:

+ + 
+class object: public xml_schema::type
+{
+public:
+  // Type definitions.
+  //
+  typedef xml_schema::string member_type;
+  typedef sequence<member_type> member_sequence;
+  typedef member_sequence::iterator member_iterator;
+  typedef member_sequence::const_iterator member_const_iterator;
+
+  // Accessors.
+  //
+  const member_sequence&
+  member () const;
+
+  member_sequence&
+  member ();
+
+  // Modifier.
+  //
+  void
+  member (const member_sequence&);
+
+  ...
+
+};
+
+ +

The sequence class template is defined in an + implementation-specific namespace. It conforms to the + sequence interface as defined by the ISO/ANSI Standard for + C++ (ISO/IEC 14882:1998, Section 23.1.1, "Sequences"). + Practically, this means that you can treat such a sequence + as if it was std::vector. Two notable extensions + to the standard interface that are available only for + sequences of non-fundamental C++ types are the addition of + the overloaded push_back and insert + as well as the detach_back and detach + member functions. The additional push_back and + insert functions accept an automatic pointer + (std::unique_ptr or std::auto_ptr, + depending on the C++ standard selected) to the + element type instead of the constant reference. They assume + ownership of the pointed to object and reset the passed + automatic pointer. The detach_back and + detach functions detach the element + value from the sequence container and, by default, remove + the element from the sequence. These additional functions + have the following signatures:

+ + 
+template <typename X>
+class sequence
+{
+public:
+  ...
+
+  void
+  push_back (std::[unique|auto]_ptr<X>)
+
+  iterator
+  insert (iterator position, std::[unique|auto]_ptr<X>)
+
+  std::[unique|auto]_ptr<X>
+  detach_back (bool pop = true);
+
+  iterator
+  detach (iterator position,
+          std::[unique|auto]_ptr<X>& result,
+          bool erase = true)
+
+  ...
+}
+
+ +

The following code shows how one could use this mapping:

+ + 
+void
+f (object& o)
+{
+  using xml_schema::string;
+
+  object::member_sequence& s (o.member ());
+
+  // Iteration.
+  //
+  for (object::member_iterator i (s.begin ()); i != s.end (); ++i)
+  {
+    string& value (*i);
+  }
+
+  // Modification.
+  //
+  s.push_back ("hello");  // deep copy
+
+  // C++11 version.
+  //
+  std::unique_ptr<string> p (new string ("hello"));
+  s.push_back (std::move (p)); // assumes ownership
+  p = s.detach_back ();        // detach and pop
+  s.push_back (std::move (p)); // re-append
+
+  // C++98 version.
+  //
+  std::auto_ptr<string> p (new string ("hello"));
+  s.push_back (p);        // assumes ownership
+  p = s.detach_back ();   // detach and pop
+  s.push_back (p);        // re-append
+
+  // Setting a new container.
+  //
+  object::member_sequence n;
+  n.push_back ("one");
+  n.push_back ("two");
+  o.member (n);           // deep copy
+}
+
+ +

2.8.4 Element Order

+ +

C++/Tree is a "flattening" mapping in a sense that many levels of + nested compositors (choice and sequence), + all potentially with their own cardinalities, are in the end mapped + to a flat set of elements with one of the three cardinality classes + discussed in the previous sections. While this results in a simple + and easy to use API for most types, in certain cases, the order of + elements in the actual XML documents is not preserved once parsed + into the object model. And sometimes such order has + application-specific significance. As an example, consider a schema + that defines a batch of bank transactions:

+ + 
+<complexType name="withdraw">
+  <sequence>
+    <element name="account" type="unsignedInt"/>
+    <element name="amount" type="unsignedInt"/>
+  </sequence>
+</complexType>
+
+<complexType name="deposit">
+  <sequence>
+    <element name="account" type="unsignedInt"/>
+    <element name="amount" type="unsignedInt"/>
+  </sequence>
+</complexType>
+
+<complexType name="batch">
+  <choice minOccurs="0" maxOccurs="unbounded">
+    <element name="withdraw" type="withdraw"/>
+    <element name="deposit" type="deposit"/>
+  </choice>
+</complexType>
+
+ +

The batch can contain any number of transactions in any order + but the order of transactions in each actual batch is significant. + For instance, consider what could happen if we reorder the + transactions and apply all the withdrawals before deposits.

+ +

For the batch schema type defined above the default + C++/Tree mapping will produce a C++ class that contains a pair of + sequence containers, one for each of the two elements. While this + will capture the content (transactions), the order of this content + as it appears in XML will be lost. Also, if we try to serialize the + batch we just loaded back to XML, all the withdrawal transactions + will appear before deposits.

+ +

To overcome this limitation of a flattening mapping, C++/Tree + allows us to mark certain XML Schema types, for which content + order is important, as ordered.

+ +

There are several command line options that control which + schema types are treated as ordered. To make an individual + type ordered, we use the --ordered-type option, + for example:

+ + 
+--ordered-type batch
+
+ +

To automatically treat all the types that are derived from an ordered + type also ordered, we use the --ordered-type-derived + option. This is primarily useful if you would like to iterate + over the complete hierarchy's content using the content order + sequence (discussed below).

+ +

Ordered types are also useful for handling mixed content. To + automatically mark all the types with mixed content as ordered + we use the --ordered-type-mixed option. For more + information on handling mixed content see Section + 2.13, "Mapping for Mixed Content Models".

+ +

Finally, we can mark all the types in the schema we are + compiling with the --ordered-type-all option. + You should only resort to this option if all the types in + your schema truly suffer from the loss of content + order since, as we will discuss shortly, ordered types + require extra effort to access and, especially, modify. + See the + XSD + Compiler Command Line Manual for more information on + these options.

+ +

Once a type is marked ordered, C++/Tree alters its mapping + in several ways. Firstly, for each local element, element + wildcard (Section 2.12.4, "Element Wildcard + Order"), and mixed content text (Section + 2.13, "Mapping for Mixed Content Models") in this type, a + content id constant is generated. Secondly, an addition sequence + is added to the class that captures the content order. Here + is how the mapping of our batch class changes + once we make it ordered:

+ + 
+class batch: public xml_schema::type
+{
+public:
+  // withdraw
+  //
+  typedef withdraw withdraw_type;
+  typedef sequence<withdraw_type> withdraw_sequence;
+  typedef withdraw_sequence::iterator withdraw_iterator;
+  typedef withdraw_sequence::const_iterator withdraw_const_iterator;
+
+  static const std::size_t withdraw_id = 1;
+
+  const withdraw_sequence&
+  withdraw () const;
+
+  withdraw_sequence&
+  withdraw ();
+
+  void
+  withdraw (const withdraw_sequence&);
+
+  // deposit
+  //
+  typedef deposit deposit_type;
+  typedef sequence<deposit_type> deposit_sequence;
+  typedef deposit_sequence::iterator deposit_iterator;
+  typedef deposit_sequence::const_iterator deposit_const_iterator;
+
+  static const std::size_t deposit_id = 2;
+
+  const deposit_sequence&
+  deposit () const;
+
+  deposit_sequence&
+  deposit ();
+
+  void
+  deposit (const deposit_sequence&);
+
+  // content_order
+  //
+  typedef xml_schema::content_order content_order_type;
+  typedef std::vector<content_order_type> content_order_sequence;
+  typedef content_order_sequence::iterator content_order_iterator;
+  typedef content_order_sequence::const_iterator content_order_const_iterator;
+
+  const content_order_sequence&
+  content_order () const;
+
+  content_order_sequence&
+  content_order ();
+
+  void
+  content_order (const content_order_sequence&);
+
+  ...
+};
+
+ +

Notice the withdraw_id and deposit_id + content ids as well as the extra content_order + sequence that does not correspond to any element in the + schema definition. The other changes to the mapping for ordered + types has to do with XML parsing and serialization code. During + parsing the content order is captured in the content_order + sequence while during serialization this sequence is used to + determine the order in which content is serialized. The + content_order sequence is also copied during + copy construction and assigned during copy assignment. It is also + taken into account during comparison.

+ +

The entry type of the content_order sequence is the + xml_schema::content_order type that has the following + interface:

+ + 
+namespace xml_schema
+{
+  struct content_order
+  {
+    content_order (std::size_t id, std::size_t index = 0);
+
+    std::size_t id;
+    std::size_t index;
+  };
+
+  bool
+  operator== (const content_order&, const content_order&);
+
+  bool
+  operator!= (const content_order&, const content_order&);
+
+  bool
+  operator< (const content_order&, const content_order&);
+}
+
+ +

The content_order sequence describes the order of + content (elements, including wildcards, as well as mixed content + text). Each entry in this sequence consists of the content id + (for example, withdraw_id or deposit_id + in our case) as well as, for elements of the sequence cardinality + class, an index into the corresponding sequence container (the + index is unused for the one and optional cardinality classes). + For example, in our case, if the content id is withdraw_id, + then the index will point into the withdraw element + sequence.

+ +

With all this information we can now examine how to iterate over + transaction in the batch in content order:

+ + 
+batch& b = ...
+
+for (batch::content_order_const_iterator i (b.content_order ().begin ());
+     i != b.content_order ().end ();
+     ++i)
+{
+  switch (i->id)
+  {
+  case batch::withdraw_id:
+    {
+      const withdraw& t (b.withdraw ()[i->index]);
+      cerr << t.account () << " withdraw " << t.amount () << endl;
+      break;
+    }
+  case batch::deposit_id:
+    {
+      const deposit& t (b.deposit ()[i->index]);
+      cerr << t.account () << " deposit " << t.amount () << endl;
+      break;
+    }
+  default:
+    {
+      assert (false); // Unknown content id.
+    }
+  }
+}
+
+ +

If we serialized our batch back to XML, we would also see that the + order of transactions in the output is exactly the same as in the + input rather than all the withdrawals first followed by all the + deposits.

+ +

The most complex aspect of working with ordered types is + modifications. Now we not only need to change the content, + but also remember to update the order information corresponding + to this change. As a first example, we add a deposit transaction + to the batch:

+ + 
+using xml_schema::content_order;
+
+batch::deposit_sequence& d (b.deposit ());
+batch::withdraw_sequence& w (b.withdraw ());
+batch::content_order_sequence& co (b.content_order ());
+
+d.push_back (deposit (123456789, 100000));
+co.push_back (content_order (batch::deposit_id, d.size () - 1));
+
+ +

In the above example we first added the content (deposit + transaction) and then updated the content order information + by adding an entry with deposit_id content + id and the index of the just added deposit transaction.

+ +

Removing the last transaction can be easy if we know which + transaction (deposit or withdrawal) is last:

+ + 
+d.pop_back ();
+co.pop_back ();
+
+ +

If, however, we do not know which transaction is last, then + things get a bit more complicated:

+ + 
+switch (co.back ().id)
+{
+case batch::withdraw_id:
+  {
+    d.pop_back ();
+    break;
+  }
+case batch::deposit_id:
+  {
+    w.pop_back ();
+    break;
+  }
+}
+
+co.pop_back ();
+
+ +

The following example shows how to add a transaction at the + beginning of the batch:

+ + 
+w.push_back (withdraw (123456789, 100000));
+co.insert (co.begin (),
+           content_order (batch::withdraw_id, w.size () - 1));
+
+ +

Note also that when we merely modify the content of one + of the elements in place, we do not need to update its + order since it doesn't change. For example, here is how + we can change the amount in the first withdrawal:

+ + 
+w[0].amount (10000);
+
+ +

For the complete working code shown in this section refer to the + order/element example in the + cxx/tree/ directory in the + xsd-examples + package.

+ +

If both the base and derived types are ordered, then the + content order sequence is only added to the base and the content + ids are unique within the whole hierarchy. In this case + the content order sequence for the derived type contains + ordering information for both base and derived content.

+ +

In some applications we may need to perform more complex + content processing. For example, in our case, we may need + to remove all the withdrawal transactions. The default + container, std::vector, is not particularly + suitable for such operations. What may be required by + some applications is a multi-index container that not + only allows us to iterate in content order similar to + std::vector but also search by the content + id as well as the content id and index pair.

+ +

While C++/Tree does not provide this functionality by + default, it allows us to specify a custom container + type for content order with the --order-container + command line option. The only requirement from the + generated code side for such a container is to provide + the vector-like push_back(), + size(), and const iteration interfaces.

+ +

As an example, here is how we can use the Boost Multi-Index + container for content order. First we create the + content-order-container.hxx header with the + following definition:

+ + 
+#ifndef CONTENT_ORDER_CONTAINER
+#define CONTENT_ORDER_CONTAINER
+
+#include <cstddef> // std::size_t
+
+#include <boost/multi_index_container.hpp>
+#include <boost/multi_index/member.hpp>
+#include <boost/multi_index/identity.hpp>
+#include <boost/multi_index/ordered_index.hpp>
+#include <boost/multi_index/random_access_index.hpp>
+
+struct by_id {};
+struct by_id_index {};
+
+template <typename T>
+using content_order_container =
+  boost::multi_index::multi_index_container<
+    T,
+    boost::multi_index::indexed_by<
+      boost::multi_index::random_access<>,
+      boost::multi_index::ordered_unique<
+        boost::multi_index::tag<by_id_index>,
+        boost::multi_index::identity<T>
+      >,
+      boost::multi_index::ordered_non_unique<
+        boost::multi_index::tag<by_id>,
+        boost::multi_index::member<T, std::size_t, &T::id>
+      >
+    >
+  >;
+
+#endif
+
+ +

Next we add the following two XSD compiler options to include + this header into every generated header file and to use the + custom container type (see the XSD compiler command line manual + for more information on shell quoting for the first option):

+ + 
+--hxx-prologue '#include "content-order-container.hxx"'
+--order-container content_order_container
+
+ +

With these changes we can now use the multi-index functionality, + for example, to search for a specific content id:

+ + 
+typedef batch::content_order_sequence::index<by_id>::type id_set;
+typedef id_set::iterator id_iterator;
+
+const id_set& ids (b.content_order ().get<by_id> ());
+
+std::pair<id_iterator, id_iterator> r (
+  ids.equal_range (std::size_t (batch::deposit_id));
+
+for (id_iterator i (r.first); i != r.second; ++i)
+{
+  const deposit& t (b.deposit ()[i->index]);
+  cerr << t.account () << " deposit " << t.amount () << endl;
+}
+
+ +

2.9 Mapping for Global Elements

+ +

An XML Schema element definition is called global if it appears + directly under the schema element. + A global element is a valid root of an instance document. By + default, a global element is mapped to a set of overloaded + parsing and, optionally, serialization functions with the + same name as the element. It is also possible to generate types + for root elements instead of parsing and serialization functions. + This is primarily useful to distinguish object models with the + same root type but with different root elements. See + Section 2.9.1, "Element Types" for details. + It is also possible to request the generation of an element map + which allows uniform parsing and serialization of multiple root + elements. See Section 2.9.2, "Element Map" + for details. +

+ +

The parsing functions read XML instance documents and return + corresponding object models as an automatic pointer + (std::unique_ptr or std::auto_ptr, + depending on the C++ standard selected). Their signatures + have the following pattern (type denotes + element's type and name denotes element's + name): +

+ + 
+std::[unique|auto]_ptr<type>
+name (....);
+
+ +

The process of parsing, including the exact signatures of the parsing + functions, is the subject of Chapter 3, "Parsing". +

+ +

The serialization functions write object models back to XML instance + documents. Their signatures have the following pattern: +

+ + 
+void
+name (<stream type>&, const type&, ....);
+
+ +

The process of serialization, including the exact signatures of the + serialization functions, is the subject of Chapter 4, + "Serialization". +

+ + +

2.9.1 Element Types

+ +

The generation of element types is requested with the + --generate-element-type option. With this option + each global element is mapped to a C++ class with the + same name as the element. Such a class is derived from + xml_schema::element_type and contains the same set + of type definitions, constructors, and member function as would a + type containing a single element with the One cardinality class + named "value". In addition, the element type also + contains a set of member functions for accessing the element + name and namespace as well as its value in a uniform manner. + For example:

+ + 
+<complexType name="type">
+  <sequence>
+    ...
+  </sequence>
+</complexType>
+
+<element name="root" type="type"/>
+
+ +

is mapped to:

+ + 
+class type
+{
+  ...
+};
+
+class root: public xml_schema::element_type
+{
+public:
+  // Element value.
+  //
+  typedef type value_type;
+
+  const value_type&
+  value () const;
+
+  value_type&
+  value ();
+
+  void
+  value (const value_type&);
+
+  void
+  value (std::[unique|auto]_ptr<value_type>);
+
+  // Constructors.
+  //
+  root (const value_type&);
+
+  root (std::[unique|auto]_ptr<value_type>);
+
+  root (const xercesc::DOMElement&, xml_schema::flags = 0);
+
+  root (const root&, xml_schema::flags = 0);
+
+  virtual root*
+  _clone (xml_schema::flags = 0) const;
+
+  // Element name and namespace.
+  //
+  static const std::string&
+  name ();
+
+  static const std::string&
+  namespace_ ();
+
+  virtual const std::string&
+  _name () const;
+
+  virtual const std::string&
+  _namespace () const;
+
+  // Element value as xml_schema::type.
+  //
+  virtual const xml_schema::type*
+  _value () const;
+
+  virtual xml_schema::type*
+  _value ();
+};
+
+void
+operator<< (xercesc::DOMElement&, const root&);
+
+ +

The xml_schema::element_type class is a common + base type for all element types and is defined as follows:

+ + 
+namespace xml_schema
+{
+  class element_type
+  {
+  public:
+    virtual
+    ~element_type ();
+
+    virtual element_type*
+    _clone (flags f = 0) const = 0;
+
+    virtual const std::basic_string<C>&
+    _name () const = 0;
+
+    virtual const std::basic_string<C>&
+    _namespace () const = 0;
+
+    virtual xml_schema::type*
+    _value () = 0;
+
+    virtual const xml_schema::type*
+    _value () const = 0;
+  };
+}
+
+ +

The _value() member function returns a pointer to + the element value or 0 if the element is of a fundamental C++ + type and therefore is not derived from xml_schema::type. +

+ +

Unlike parsing and serialization functions, element types + are only capable of parsing and serializing from/to a + DOMElement object. This means that the application + will need to perform its own XML-to-DOM parsing and DOM-to-XML + serialization. The following section describes a mechanism + provided by the mapping to uniformly parse and serialize + multiple root elements.

+ + +

2.9.2 Element Map

+ +

When element types are generated for root elements it is also + possible to request the generation of an element map with the + --generate-element-map option. The element map + allows uniform parsing and serialization of multiple root + elements via the common xml_schema::element_type + base type. The xml_schema::element_map class is + defined as follows:

+ + 
+namespace xml_schema
+{
+  class element_map
+  {
+  public:
+    static std::[unique|auto]_ptr<xml_schema::element_type>
+    parse (const xercesc::DOMElement&, flags = 0);
+
+    static void
+    serialize (xercesc::DOMElement&, const element_type&);
+  };
+}
+
+ +

The parse() function creates the corresponding + element type object based on the element name and namespace + and returns it as an automatic pointer (std::unique_ptr + or std::auto_ptr, depending on the C++ standard + selected) to xml_schema::element_type. + The serialize() function serializes the passed element + object to DOMElement. Note that in case of + serialize(), the DOMElement object + should have the correct name and namespace. If no element type is + available for an element, both functions throw the + xml_schema::no_element_info exception:

+ + 
+struct no_element_info: virtual exception
+{
+  no_element_info (const std::basic_string<C>& element_name,
+                   const std::basic_string<C>& element_namespace);
+
+  const std::basic_string<C>&
+  element_name () const;
+
+  const std::basic_string<C>&
+  element_namespace () const;
+
+  virtual const char*
+  what () const throw ();
+};
+
+ +

The application can discover the actual type of the element + object returned by parse() either using + dynamic_cast or by comparing element names and + namespaces. The following code fragments illustrate how the + element map can be used:

+ + 
+// Parsing.
+//
+DOMElement& e = ... // Parse XML to DOM.
+
+unique_ptr<xml_schema::element_type> r (
+  xml_schema::element_map::parse (e));
+
+if (root1 r1 = dynamic_cast<root1*> (r.get ()))
+{
+  ...
+}
+else if (r->_name == root2::name () &&
+         r->_namespace () == root2::namespace_ ())
+{
+  root2& r2 (static_cast<root2&> (*r));
+
+  ...
+}
+
+ + 
+// Serialization.
+//
+xml_schema::element_type& r = ...
+
+string name (r._name ());
+string ns (r._namespace ());
+
+DOMDocument& doc = ... // Create a new DOMDocument with name and ns.
+DOMElement& e (*doc->getDocumentElement ());
+
+xml_schema::element_map::serialize (e, r);
+
+// Serialize DOMDocument to XML.
+
+ + + +

2.10 Mapping for Global Attributes

+ +

An XML Schema attribute definition is called global if it appears + directly under the schema element. A global + attribute does not have any mapping. +

+ + + +

2.11 Mapping for xsi:type and Substitution + Groups

+ +

The mapping provides optional support for the XML Schema polymorphism + features (xsi:type and substitution groups) which can + be requested with the --generate-polymorphic option. + When used, the dynamic type of a member may be different from + its static type. Consider the following schema definition and + instance document: +

+ + 
+<!-- test.xsd -->
+<schema>
+  <complexType name="base">
+    <attribute name="text" type="string"/>
+  </complexType>
+
+  <complexType name="derived">
+    <complexContent>
+      <extension base="base">
+        <attribute name="extra-text" type="string"/>
+      </extension>
+    </complexContent>
+  </complexType>
+
+  <complexType name="root_type">
+    <sequence>
+      <element name="item" type="base" maxOccurs="unbounded"/>
+    </sequence>
+  </complexType>
+
+  <element name="root" type="root_type"/>
+</schema>
+
+<!-- test.xml -->
+<root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+  <item text="hello"/>
+  <item text="hello" extra-text="world" xsi:type="derived"/>
+</root>
+
+ +

In the resulting object model, the container for + the root::item member will have two elements: + the first element's type will be base while + the second element's (dynamic) type will be + derived. This can be discovered using the + dynamic_cast operator as shown in the following + example: +

+ + 
+void
+f (root& r)
+{
+  for (root::item_const_iterator i (r.item ().begin ());
+       i != r.item ().end ()
+       ++i)
+  {
+    if (derived* d = dynamic_cast<derived*> (&(*i)))
+    {
+      // derived
+    }
+    else
+    {
+      // base
+    }
+  }
+}
+
+ +

The _clone virtual function should be used instead of + copy constructors to make copies of members that might use + polymorphism: +

+ + 
+void
+f (root& r)
+{
+  for (root::item_const_iterator i (r.item ().begin ());
+       i != r.item ().end ()
+       ++i)
+  {
+    std::unique_ptr<base> c (i->_clone ());
+  }
+}
+
+ +

The mapping can often automatically determine which types are + polymorphic based on the substitution group declarations. However, + if your XML vocabulary is not using substitution groups or if + substitution groups are defined in a separate schema, then you will + need to use the --polymorphic-type option to specify + which types are polymorphic. When using this option you only need + to specify the root of a polymorphic type hierarchy and the mapping + will assume that all the derived types are also polymorphic. + Also note that you need to specify this option when compiling every + schema file that references the polymorphic type. Consider the following + two schemas as an example:

+ + 
+<!-- base.xsd -->
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+
+  <xs:complexType name="base">
+    <xs:sequence>
+      <xs:element name="b" type="xs:int"/>
+    </xs:sequence>
+  </xs:complexType>
+
+  <!-- substitution group root -->
+  <xs:element name="base" type="base"/>
+
+</xs:schema>
+
+ + 
+<!-- derived.xsd -->
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+
+  <include schemaLocation="base.xsd"/>
+
+  <xs:complexType name="derived">
+    <xs:complexContent>
+      <xs:extension base="base">
+        <xs:sequence>
+          <xs:element name="d" type="xs:string"/>
+        </xs:sequence>
+      </xs:extension>
+    </xs:complexContent>
+  </xs:complexType>
+
+  <xs:element name="derived" type="derived" substitutionGroup="base"/>
+
+</xs:schema>
+
+ +

In this example we need to specify "--polymorphic-type base" + when compiling both schemas because the substitution group is declared + in a schema other than the one defining type base.

+ +

You can also indicate that all types should be treated as polymorphic + with the --polymorphic-type-all. However, this may result + in slower generated code with a greater footprint.

+ + + + + +

2.12 Mapping for any and anyAttribute

+ +

For the XML Schema any and anyAttribute + wildcards an optional mapping can be requested with the + --generate-wildcard option. The mapping represents + the content matched by wildcards as DOM fragments. Because the + DOM API is used to access such content, the Xerces-C++ runtime + should be initialized by the application prior to parsing and + should remain initialized for the lifetime of objects with + the wildcard content. For more information on the Xerces-C++ + runtime initialization see Section 3.1, + "Initializing the Xerces-C++ Runtime". +

+ +

The mapping for any is similar to the mapping for + local elements (see Section 2.8, "Mapping for Local + Elements and Attributes") except that the type used in the + wildcard mapping is xercesc::DOMElement. As with local + elements, the mapping divides all possible cardinality combinations + into three cardinality classes: one, optional, and + sequence. +

+ +

The mapping for anyAttribute represents the attributes + matched by this wildcard as a set of xercesc::DOMAttr + objects with a key being the attribute's name and namespace.

+ +

Similar to local elements and attributes, the any and + anyAttribute wildcards are mapped to a set of public type + definitions (typedefs) and a set of public accessor and modifier + functions. Type definitions have names derived from "any" + for the any wildcard and "any_attribute" + for the anyAttribute wildcard. The accessor and modifier + functions are named "any" for the any wildcard + and "any_attribute" for the anyAttribute + wildcard. Subsequent wildcards in the same type have escaped names + such as "any1" or "any_attribute1". +

+ +

Because Xerces-C++ DOM nodes always belong to a DOMDocument, + each type with a wildcard has an associated DOMDocument + object. The reference to this object can be obtained using the accessor + function called dom_document. The access to the document + object from the application code may be necessary to create or modify + the wildcard content. For example: +

+ + 
+<complexType name="object">
+  <sequence>
+    <any namespace="##other"/>
+  </sequence>
+  <anyAttribute namespace="##other"/>
+</complexType>
+
+ +

is mapped to:

+ + 
+class object: public xml_schema::type
+{
+public:
+  // any
+  //
+  const xercesc::DOMElement&
+  any () const;
+
+  void
+  any (const xercesc::DOMElement&);
+
+  ...
+
+  // any_attribute
+  //
+  typedef attribute_set any_attribute_set;
+  typedef any_attribute_set::iterator any_attribute_iterator;
+  typedef any_attribute_set::const_iterator any_attribute_const_iterator;
+
+  const any_attribute_set&
+  any_attribute () const;
+
+  any_attribute_set&
+  any_attribute ();
+
+  ...
+
+  // DOMDocument object for wildcard content.
+  //
+  const xercesc::DOMDocument&
+  dom_document () const;
+
+  xercesc::DOMDocument&
+  dom_document ();
+
+  ...
+};
+
+ + +

Names and semantics of type definitions for the wildcards as well + as signatures of the accessor and modifier functions depend on the + wildcard type as well as the cardinality class for the any + wildcard. They are described in the following sub-sections. +

+ + +

2.12.1 Mapping for any with the One Cardinality Class

+ +

For any with the One cardinality class, + there are no type definitions. The accessor functions come in + constant and non-constant versions. The constant accessor function + returns a constant reference to xercesc::DOMElement and + can be used for read-only access. The non-constant version returns + an unrestricted reference to xercesc::DOMElement and can + be used for read-write access. +

+ +

The first modifier function expects an argument of type reference + to constant xercesc::DOMElement and makes a deep copy + of its argument. The second modifier function expects an argument of + type pointer to xercesc::DOMElement. This modifier + function assumes ownership of its argument and expects the element + object to be created using the DOM document associated with this + instance. For example: +

+ + 
+<complexType name="object">
+  <sequence>
+    <any namespace="##other"/>
+  </sequence>
+</complexType>
+
+ +

is mapped to:

+ + 
+class object: public xml_schema::type
+{
+public:
+  // Accessors.
+  //
+  const xercesc::DOMElement&
+  any () const;
+
+  xercesc::DOMElement&
+  any ();
+
+  // Modifiers.
+  //
+  void
+  any (const xercesc::DOMElement&);
+
+  void
+  any (xercesc::DOMElement*);
+
+  ...
+
+};
+
+ + +

The following code shows how one could use this mapping:

+ + 
+void
+f (object& o, const xercesc::DOMElement& e)
+{
+  using namespace xercesc;
+
+  DOMElement& e1 (o.any ());             // get
+  o.any (e)                              // set, deep copy
+  DOMDocument& doc (o.dom_document ());
+  o.any (doc.createElement (...));       // set, assumes ownership
+}
+
+ +

2.12.2 Mapping for any with the Optional Cardinality Class

+ +

For any with the Optional cardinality class, the type + definitions consist of an alias for the container type with name + any_optional (or any1_optional, etc., for + subsequent wildcards in the type definition). +

+ +

Unlike accessor functions for the One cardinality class, accessor + functions for the Optional cardinality class return references to + corresponding containers rather than directly to DOMElement. + The accessor functions come in constant and non-constant versions. + The constant accessor function returns a constant reference to + the container and can be used for read-only access. The non-constant + version returns an unrestricted reference to the container + and can be used for read-write access. +

+ +

The modifier functions are overloaded for xercesc::DOMElement + and the container type. The first modifier function expects an argument of + type reference to constant xercesc::DOMElement and + makes a deep copy of its argument. The second modifier function + expects an argument of type pointer to xercesc::DOMElement. + This modifier function assumes ownership of its argument and expects + the element object to be created using the DOM document associated + with this instance. The third modifier function expects an argument + of type reference to constant of the container type and makes a + deep copy of its argument. For instance: +

+ + 
+<complexType name="object">
+  <sequence>
+    <any namespace="##other" minOccurs="0"/>
+  </sequence>
+</complexType>
+
+ +

is mapped to:

+ + 
+class object: public xml_schema::type
+{
+public:
+  // Type definitions.
+  //
+  typedef element_optional any_optional;
+
+  // Accessors.
+  //
+  const any_optional&
+  any () const;
+
+  any_optional&
+  any ();
+
+  // Modifiers.
+  //
+  void
+  any (const xercesc::DOMElement&);
+
+  void
+  any (xercesc::DOMElement*);
+
+  void
+  any (const any_optional&);
+
+  ...
+
+};
+
+ + +

The element_optional container is a + specialization of the optional class template described + in Section 2.8.2, "Mapping for Members with the Optional + Cardinality Class". Its interface is presented below: +

+ + 
+class element_optional
+{
+public:
+  explicit
+  element_optional (xercesc::DOMDocument&);
+
+  // Makes a deep copy.
+  //
+  element_optional (const xercesc::DOMElement&, xercesc::DOMDocument&);
+
+  // Assumes ownership.
+  //
+  element_optional (xercesc::DOMElement*, xercesc::DOMDocument&);
+
+  element_optional (const element_optional&, xercesc::DOMDocument&);
+
+public:
+  element_optional&
+  operator= (const xercesc::DOMElement&);
+
+  element_optional&
+  operator= (const element_optional&);
+
+  // Pointer-like interface.
+  //
+public:
+  const xercesc::DOMElement*
+  operator-> () const;
+
+  xercesc::DOMElement*
+  operator-> ();
+
+  const xercesc::DOMElement&
+  operator* () const;
+
+  xercesc::DOMElement&
+  operator* ();
+
+  typedef void (element_optional::*bool_convertible) ();
+  operator bool_convertible () const;
+
+  // Get/set interface.
+  //
+public:
+  bool
+  present () const;
+
+  const xercesc::DOMElement&
+  get () const;
+
+  xercesc::DOMElement&
+  get ();
+
+  // Makes a deep copy.
+  //
+  void
+  set (const xercesc::DOMElement&);
+
+  // Assumes ownership.
+  //
+  void
+  set (xercesc::DOMElement*);
+
+  void
+  reset ();
+};
+
+bool
+operator== (const element_optional&, const element_optional&);
+
+bool
+operator!= (const element_optional&, const element_optional&);
+
+ + +

The following code shows how one could use this mapping:

+ + 
+void
+f (object& o, const xercesc::DOMElement& e)
+{
+  using namespace xercesc;
+
+  DOMDocument& doc (o.dom_document ());
+
+  if (o.any ().present ())                  // test
+  {
+    DOMElement& e1 (o.any ().get ());       // get
+    o.any ().set (e);                       // set, deep copy
+    o.any ().set (doc.createElement (...)); // set, assumes ownership
+    o.any ().reset ();                      // reset
+  }
+
+  // Same as above but using pointer notation:
+  //
+  if (o.member ())                          // test
+  {
+    DOMElement& e1 (*o.any ());             // get
+    o.any (e);                              // set, deep copy
+    o.any (doc.createElement (...));        // set, assumes ownership
+    o.any ().reset ();                      // reset
+  }
+}
+
+ + + +

2.12.3 Mapping for any with the Sequence Cardinality Class

+ +

For any with the Sequence cardinality class, the type + definitions consist of an alias of the container type with name + any_sequence (or any1_sequence, etc., for + subsequent wildcards in the type definition), an alias of the iterator + type with name any_iterator (or any1_iterator, + etc., for subsequent wildcards in the type definition), and an alias + of the constant iterator type with name any_const_iterator + (or any1_const_iterator, etc., for subsequent wildcards + in the type definition). +

+ +

The accessor functions come in constant and non-constant versions. + The constant accessor function returns a constant reference to the + container and can be used for read-only access. The non-constant + version returns an unrestricted reference to the container and can + be used for read-write access. +

+ +

The modifier function expects an argument of type reference to + constant of the container type. The modifier function makes + a deep copy of its argument. For instance: +

+ + + 
+<complexType name="object">
+  <sequence>
+    <any namespace="##other" minOccurs="unbounded"/>
+  </sequence>
+</complexType>
+
+ +

is mapped to:

+ + 
+class object: public xml_schema::type
+{
+public:
+  // Type definitions.
+  //
+  typedef element_sequence any_sequence;
+  typedef any_sequence::iterator any_iterator;
+  typedef any_sequence::const_iterator any_const_iterator;
+
+  // Accessors.
+  //
+  const any_sequence&
+  any () const;
+
+  any_sequence&
+  any ();
+
+  // Modifier.
+  //
+  void
+  any (const any_sequence&);
+
+  ...
+
+};
+
+ +

The element_sequence container is a + specialization of the sequence class template described + in Section 2.8.3, "Mapping for Members with the + Sequence Cardinality Class". Its interface is similar to + the sequence interface as defined by the ISO/ANSI Standard for + C++ (ISO/IEC 14882:1998, Section 23.1.1, "Sequences") and is + presented below: +

+ + 
+class element_sequence
+{
+public:
+  typedef xercesc::DOMElement        value_type;
+  typedef xercesc::DOMElement*       pointer;
+  typedef const xercesc::DOMElement* const_pointer;
+  typedef xercesc::DOMElement&       reference;
+  typedef const xercesc::DOMElement& const_reference;
+
+  typedef <implementation-defined>   iterator;
+  typedef <implementation-defined>   const_iterator;
+  typedef <implementation-defined>   reverse_iterator;
+  typedef <implementation-defined>   const_reverse_iterator;
+
+  typedef <implementation-defined>   size_type;
+  typedef <implementation-defined>   difference_type;
+  typedef <implementation-defined>   allocator_type;
+
+public:
+  explicit
+  element_sequence (xercesc::DOMDocument&);
+
+  // DOMElement cannot be default-constructed.
+  //
+  // explicit
+  // element_sequence (size_type n);
+
+  element_sequence (size_type n,
+                    const xercesc::DOMElement&,
+                    xercesc::DOMDocument&);
+
+  template <typename I>
+  element_sequence (const I& begin,
+                    const I& end,
+                    xercesc::DOMDocument&);
+
+  element_sequence (const element_sequence&, xercesc::DOMDocument&);
+
+  element_sequence&
+  operator= (const element_sequence&);
+
+public:
+  void
+  assign (size_type n, const xercesc::DOMElement&);
+
+  template <typename I>
+  void
+  assign (const I& begin, const I& end);
+
+public:
+  // This version of resize can only be used to shrink the
+  // sequence because DOMElement cannot be default-constructed.
+  //
+  void
+  resize (size_type);
+
+  void
+  resize (size_type, const xercesc::DOMElement&);
+
+public:
+  size_type
+  size () const;
+
+  size_type
+  max_size () const;
+
+  size_type
+  capacity () const;
+
+  bool
+  empty () const;
+
+  void
+  reserve (size_type);
+
+  void
+  clear ();
+
+public:
+  const_iterator
+  begin () const;
+
+  const_iterator
+  end () const;
+
+  iterator
+  begin ();
+
+  iterator
+  end ();
+
+  const_reverse_iterator
+  rbegin () const;
+
+  const_reverse_iterator
+  rend () const
+
+    reverse_iterator
+  rbegin ();
+
+  reverse_iterator
+  rend ();
+
+public:
+  xercesc::DOMElement&
+  operator[] (size_type);
+
+  const xercesc::DOMElement&
+  operator[] (size_type) const;
+
+  xercesc::DOMElement&
+  at (size_type);
+
+  const xercesc::DOMElement&
+  at (size_type) const;
+
+  xercesc::DOMElement&
+  front ();
+
+  const xercesc::DOMElement&
+  front () const;
+
+  xercesc::DOMElement&
+  back ();
+
+  const xercesc::DOMElement&
+  back () const;
+
+public:
+  // Makes a deep copy.
+  //
+  void
+  push_back (const xercesc::DOMElement&);
+
+  // Assumes ownership.
+  //
+  void
+  push_back (xercesc::DOMElement*);
+
+  void
+  pop_back ();
+
+  // Makes a deep copy.
+  //
+  iterator
+  insert (iterator position, const xercesc::DOMElement&);
+
+  // Assumes ownership.
+  //
+  iterator
+  insert (iterator position, xercesc::DOMElement*);
+
+  void
+  insert (iterator position, size_type n, const xercesc::DOMElement&);
+
+  template <typename I>
+  void
+  insert (iterator position, const I& begin, const I& end);
+
+  iterator
+  erase (iterator position);
+
+  iterator
+  erase (iterator begin, iterator end);
+
+public:
+  // Note that the DOMDocument object of the two sequences being
+  // swapped should be the same.
+  //
+  void
+  swap (sequence& x);
+};
+
+inline bool
+operator== (const element_sequence&, const element_sequence&);
+
+inline bool
+operator!= (const element_sequence&, const element_sequence&);
+
+ + +

The following code shows how one could use this mapping:

+ + 
+void
+f (object& o, const xercesc::DOMElement& e)
+{
+  using namespace xercesc;
+
+  object::any_sequence& s (o.any ());
+
+  // Iteration.
+  //
+  for (object::any_iterator i (s.begin ()); i != s.end (); ++i)
+  {
+    DOMElement& e (*i);
+  }
+
+  // Modification.
+  //
+  s.push_back (e);                       // deep copy
+  DOMDocument& doc (o.dom_document ());
+  s.push_back (doc.createElement (...)); // assumes ownership
+}
+
+ +

2.12.4 Element Wildcard Order

+ +

Similar to elements, element wildcards in ordered types + (Section 2.8.4, "Element Order") are assigned + content ids and are included in the content order sequence. + Continuing with the bank transactions example started in Section + 2.8.4, we can extend the batch by allowing custom transactions:

+ + 
+<complexType name="batch">
+  <choice minOccurs="0" maxOccurs="unbounded">
+    <element name="withdraw" type="withdraw"/>
+    <element name="deposit" type="deposit"/>
+    <any namespace="##other" processContents="lax"/>
+  </choice>
+</complexType>
+
+ +

This will lead to the following changes in the generated + batch C++ class:

+ + 
+class batch: public xml_schema::type
+{
+public:
+  ...
+
+  // any
+  //
+  typedef element_sequence any_sequence;
+  typedef any_sequence::iterator any_iterator;
+  typedef any_sequence::const_iterator any_const_iterator;
+
+  static const std::size_t any_id = 3UL;
+
+  const any_sequence&
+  any () const;
+
+  any_sequence&
+  any ();
+
+  void
+  any (const any_sequence&);
+
+  ...
+};
+
+ +

With this change we also need to update the iteration code to handle + the new content id:

+ + 
+for (batch::content_order_const_iterator i (b.content_order ().begin ());
+     i != b.content_order ().end ();
+     ++i)
+{
+  switch (i->id)
+  {
+    ...
+
+  case batch::any_id:
+    {
+      const DOMElement& e (b.any ()[i->index]);
+      ...
+      break;
+    }
+
+    ...
+  }
+}
+
+ +

For the complete working code that shows the use of wildcards in + ordered types refer to the order/element example in + the cxx/tree/ directory in the + xsd-examples + package.

+ +

2.12.5 Mapping for anyAttribute

+ +

For anyAttribute the type definitions consist of an alias + of the container type with name any_attribute_set + (or any1_attribute_set, etc., for subsequent wildcards + in the type definition), an alias of the iterator type with name + any_attribute_iterator (or any1_attribute_iterator, + etc., for subsequent wildcards in the type definition), and an alias + of the constant iterator type with name any_attribute_const_iterator + (or any1_attribute_const_iterator, etc., for subsequent + wildcards in the type definition). +

+ +

The accessor functions come in constant and non-constant versions. + The constant accessor function returns a constant reference to the + container and can be used for read-only access. The non-constant + version returns an unrestricted reference to the container and can + be used for read-write access. +

+ +

The modifier function expects an argument of type reference to + constant of the container type. The modifier function makes + a deep copy of its argument. For instance: +

+ + + 
+<complexType name="object">
+  <sequence>
+    ...
+  </sequence>
+  <anyAttribute namespace="##other"/>
+</complexType>
+
+ +

is mapped to:

+ + 
+class object: public xml_schema::type
+{
+public:
+  // Type definitions.
+  //
+  typedef attribute_set any_attribute_set;
+  typedef any_attribute_set::iterator any_attribute_iterator;
+  typedef any_attribute_set::const_iterator any_attribute_const_iterator;
+
+  // Accessors.
+  //
+  const any_attribute_set&
+  any_attribute () const;
+
+  any_attribute_set&
+  any_attribute ();
+
+  // Modifier.
+  //
+  void
+  any_attribute (const any_attribute_set&);
+
+  ...
+
+};
+
+ +

The attribute_set class is an associative container + similar to the std::set class template as defined by + the ISO/ANSI Standard for C++ (ISO/IEC 14882:1998, Section 23.3.3, + "Class template set") with the key being the attribute's name + and namespace. Unlike std::set, attribute_set + allows searching using names and namespaces instead of + xercesc::DOMAttr objects. It is defined in an + implementation-specific namespace and its interface is presented + below: +

+ + 
+class attribute_set
+{
+public:
+  typedef xercesc::DOMAttr         key_type;
+  typedef xercesc::DOMAttr         value_type;
+  typedef xercesc::DOMAttr*        pointer;
+  typedef const xercesc::DOMAttr*  const_pointer;
+  typedef xercesc::DOMAttr&        reference;
+  typedef const xercesc::DOMAttr&  const_reference;
+
+  typedef <implementation-defined> iterator;
+  typedef <implementation-defined> const_iterator;
+  typedef <implementation-defined> reverse_iterator;
+  typedef <implementation-defined> const_reverse_iterator;
+
+  typedef <implementation-defined> size_type;
+  typedef <implementation-defined> difference_type;
+  typedef <implementation-defined> allocator_type;
+
+public:
+  attribute_set (xercesc::DOMDocument&);
+
+  template <typename I>
+  attribute_set (const I& begin, const I& end, xercesc::DOMDocument&);
+
+  attribute_set (const attribute_set&, xercesc::DOMDocument&);
+
+  attribute_set&
+  operator= (const attribute_set&);
+
+public:
+  const_iterator
+  begin () const;
+
+  const_iterator
+  end () const;
+
+  iterator
+  begin ();
+
+  iterator
+  end ();
+
+  const_reverse_iterator
+  rbegin () const;
+
+  const_reverse_iterator
+  rend () const;
+
+  reverse_iterator
+  rbegin ();
+
+  reverse_iterator
+  rend ();
+
+public:
+  size_type
+  size () const;
+
+  size_type
+  max_size () const;
+
+  bool
+  empty () const;
+
+  void
+  clear ();
+
+public:
+  // Makes a deep copy.
+  //
+  std::pair<iterator, bool>
+  insert (const xercesc::DOMAttr&);
+
+  // Assumes ownership.
+  //
+  std::pair<iterator, bool>
+  insert (xercesc::DOMAttr*);
+
+  // Makes a deep copy.
+  //
+  iterator
+  insert (iterator position, const xercesc::DOMAttr&);
+
+  // Assumes ownership.
+  //
+  iterator
+  insert (iterator position, xercesc::DOMAttr*);
+
+  template <typename I>
+  void
+  insert (const I& begin, const I& end);
+
+public:
+  void
+  erase (iterator position);
+
+  size_type
+  erase (const std::basic_string<C>& name);
+
+  size_type
+  erase (const std::basic_string<C>& namespace_,
+         const std::basic_string<C>& name);
+
+  size_type
+  erase (const XMLCh* name);
+
+  size_type
+  erase (const XMLCh* namespace_, const XMLCh* name);
+
+  void
+  erase (iterator begin, iterator end);
+
+public:
+  size_type
+  count (const std::basic_string<C>& name) const;
+
+  size_type
+  count (const std::basic_string<C>& namespace_,
+         const std::basic_string<C>& name) const;
+
+  size_type
+  count (const XMLCh* name) const;
+
+  size_type
+  count (const XMLCh* namespace_, const XMLCh* name) const;
+
+  iterator
+  find (const std::basic_string<C>& name);
+
+  iterator
+  find (const std::basic_string<C>& namespace_,
+        const std::basic_string<C>& name);
+
+  iterator
+  find (const XMLCh* name);
+
+  iterator
+  find (const XMLCh* namespace_, const XMLCh* name);
+
+  const_iterator
+  find (const std::basic_string<C>& name) const;
+
+  const_iterator
+  find (const std::basic_string<C>& namespace_,
+        const std::basic_string<C>& name) const;
+
+  const_iterator
+  find (const XMLCh* name) const;
+
+  const_iterator
+  find (const XMLCh* namespace_, const XMLCh* name) const;
+
+public:
+  // Note that the DOMDocument object of the two sets being
+  // swapped should be the same.
+  //
+  void
+  swap (attribute_set&);
+};
+
+bool
+operator== (const attribute_set&, const attribute_set&);
+
+bool
+operator!= (const attribute_set&, const attribute_set&);
+
+ +

The following code shows how one could use this mapping:

+ + 
+void
+f (object& o, const xercesc::DOMAttr& a)
+{
+  using namespace xercesc;
+
+  object::any_attribute_set& s (o.any_attribute ());
+
+  // Iteration.
+  //
+  for (object::any_attribute_iterator i (s.begin ()); i != s.end (); ++i)
+  {
+    DOMAttr& a (*i);
+  }
+
+  // Modification.
+  //
+  s.insert (a);                         // deep copy
+  DOMDocument& doc (o.dom_document ());
+  s.insert (doc.createAttribute (...)); // assumes ownership
+
+  // Searching.
+  //
+  object::any_attribute_iterator i (s.find ("name"));
+  i = s.find ("http://www.w3.org/XML/1998/namespace", "lang");
+}
+
+ + + +

2.13 Mapping for Mixed Content Models

+ +

For XML Schema types with mixed content models C++/Tree provides + mapping support only if the type is marked as ordered + (Section 2.8.4, "Element Order"). Use the + --ordered-type-mixed XSD compiler option to + automatically mark all types with mixed content as ordered.

+ +

For an ordered type with mixed content, C++/Tree adds an extra + text content sequence that is used to store the text fragments. + This text content sequence is also assigned the content id and + its entries are included in the content order sequence, just + like elements. As a result, it is possible to capture the order + between elements and text fragments.

+ +

As an example, consider the following schema that describes text + with embedded links:

+ + 
+<complexType name="anchor">
+  <simpleContent>
+    <extension base="string">
+      <attribute name="href" type="anyURI" use="required"/>
+    </extension>
+  </simpleContent>
+</complexType>
+
+<complexType name="text" mixed="true">
+  <sequence>
+    <element name="a" type="anchor" minOccurs="0" maxOccurs="unbounded"/>
+  </sequence>
+</complexType>
+
+ +

The generated text C++ class will provide the following + API (assuming it is marked as ordered):

+ + 
+class text: public xml_schema::type
+{
+public:
+  // a
+  //
+  typedef anchor a_type;
+  typedef sequence<a_type> a_sequence;
+  typedef a_sequence::iterator a_iterator;
+  typedef a_sequence::const_iterator a_const_iterator;
+
+  static const std::size_t a_id = 1UL;
+
+  const a_sequence&
+  a () const;
+
+  a_sequence&
+  a ();
+
+  void
+  a (const a_sequence&);
+
+  // text_content
+  //
+  typedef xml_schema::string text_content_type;
+  typedef sequence<text_content_type> text_content_sequence;
+  typedef text_content_sequence::iterator text_content_iterator;
+  typedef text_content_sequence::const_iterator text_content_const_iterator;
+
+  static const std::size_t text_content_id = 2UL;
+
+  const text_content_sequence&
+  text_content () const;
+
+  text_content_sequence&
+  text_content ();
+
+  void
+  text_content (const text_content_sequence&);
+
+  // content_order
+  //
+  typedef xml_schema::content_order content_order_type;
+  typedef std::vector<content_order_type> content_order_sequence;
+  typedef content_order_sequence::iterator content_order_iterator;
+  typedef content_order_sequence::const_iterator content_order_const_iterator;
+
+  const content_order_sequence&
+  content_order () const;
+
+  content_order_sequence&
+  content_order ();
+
+  void
+  content_order (const content_order_sequence&);
+
+  ...
+};
+
+ +

Given this interface we can iterate over both link elements + and text in content order. The following code fragment converts + our format to plain text with references.

+ + 
+const text& t = ...
+
+for (text::content_order_const_iterator i (t.content_order ().begin ());
+     i != t.content_order ().end ();
+     ++i)
+{
+  switch (i->id)
+  {
+  case text::a_id:
+    {
+      const anchor& a (t.a ()[i->index]);
+      cerr << a << "[" << a.href () << "]";
+      break;
+    }
+  case text::text_content_id:
+    {
+      const xml_schema::string& s (t.text_content ()[i->index]);
+      cerr << s;
+      break;
+    }
+  default:
+    {
+      assert (false); // Unknown content id.
+    }
+  }
+}
+
+ +

For the complete working code that shows the use of mixed content + in ordered types refer to the order/mixed example in + the cxx/tree/ directory in the + xsd-examples + package.

+ + + + +

3 Parsing

+ +

This chapter covers various aspects of parsing XML instance + documents in order to obtain corresponding tree-like object + model. +

+ +

Each global XML Schema element in the form:

+ + 
+<element name="name" type="type"/>
+
+ +

is mapped to 14 overloaded C++ functions in the form:

+ + 
+// Read from a URI or a local file.
+//
+
+std::[unique|auto]_ptr<type>
+name (const std::basic_string<C>& uri,
+      xml_schema::flags = 0,
+      const xml_schema::properties& = xml_schema::properties ());
+
+std::[unique|auto]_ptr<type>
+name (const std::basic_string<C>& uri,
+      xml_schema::error_handler&,
+      xml_schema::flags = 0,
+      const xml_schema::properties& = xml_schema::properties ());
+
+std::[unique|auto]_ptr<type>
+name (const std::basic_string<C>& uri,
+      xercesc::DOMErrorHandler&,
+      xml_schema::flags = 0,
+      const xml_schema::properties& = xml_schema::properties ());
+
+
+// Read from std::istream.
+//
+
+std::[unique|auto]_ptr<type>
+name (std::istream&,
+      xml_schema::flags = 0,
+      const xml_schema::properties& = xml_schema::properties ());
+
+std::[unique|auto]_ptr<type>
+name (std::istream&,
+      xml_schema::error_handler&,
+      xml_schema::flags = 0,
+      const xml_schema::properties& = xml_schema::properties ());
+
+std::[unique|auto]_ptr<type>
+name (std::istream&,
+      xercesc::DOMErrorHandler&,
+      xml_schema::flags = 0,
+      const xml_schema::properties& = xml_schema::properties ());
+
+
+std::[unique|auto]_ptr<type>
+name (std::istream&,
+      const std::basic_string<C>& id,
+      xml_schema::flags = 0,
+      const xml_schema::properties& = xml_schema::properties ());
+
+std::[unique|auto]_ptr<type>
+name (std::istream&,
+      const std::basic_string<C>& id,
+      xml_schema::error_handler&,
+      xml_schema::flags = 0,
+      const xml_schema::properties& = xml_schema::properties ());
+
+std::[unique|auto]_ptr<type>
+name (std::istream&,
+      const std::basic_string<C>& id,
+      xercesc::DOMErrorHandler&,
+      xml_schema::flags = 0,
+      const xml_schema::properties& = xml_schema::properties ());
+
+
+// Read from InputSource.
+//
+
+std::[unique|auto]_ptr<type>
+name (xercesc::InputSource&,
+      xml_schema::flags = 0,
+      const xml_schema::properties& = xml_schema::properties ());
+
+std::[unique|auto]_ptr<type>
+name (xercesc::InputSource&,
+      xml_schema::error_handler&,
+      xml_schema::flags = 0,
+      const xml_schema::properties& = xml_schema::properties ());
+
+std::[unique|auto]_ptr<type>
+name (xercesc::InputSource&,
+      xercesc::DOMErrorHandler&,
+      xml_schema::flags = 0,
+      const xml_schema::properties& = xml_schema::properties ());
+
+
+// Read from DOM.
+//
+
+std::[unique|auto]_ptr<type>
+name (const xercesc::DOMDocument&,
+      xml_schema::flags = 0,
+      const xml_schema::properties& = xml_schema::properties ());
+
+std::[unique|auto]_ptr<type>
+name (xml_schema::dom::[unique|auto]_ptr<xercesc::DOMDocument>,
+      xml_schema::flags = 0,
+      const xml_schema::properties& = xml_schema::properties ());
+
+ +

You can choose between reading an XML instance from a local file, + URI, std::istream, xercesc::InputSource, + or a pre-parsed DOM instance in the form of + xercesc::DOMDocument. All the parsing functions + return a dynamically allocated object model as either + std::unique_ptr or std::auto_ptr, + depending on the C++ standard selected. Each of these parsing + functions is discussed in more detail in the following sections. +

+ +

3.1 Initializing the Xerces-C++ Runtime

+ +

Some parsing functions expect you to initialize the Xerces-C++ + runtime while others initialize and terminate it as part of their + work. The general rule is as follows: if a function has any arguments + or return a value that is an instance of a Xerces-C++ type, then + this function expects you to initialize the Xerces-C++ runtime. + Otherwise, the function initializes and terminates the runtime for + you. Note that it is legal to have nested calls to the Xerces-C++ + initialize and terminate functions as long as the calls are balanced. +

+ +

You can instruct parsing functions that initialize and terminate + the runtime not to do so by passing the + xml_schema::flags::dont_initialize flag (see + Section 3.2, "Flags and Properties"). +

+ + +

3.2 Flags and Properties

+ +

Parsing flags and properties are the last two arguments of every + parsing function. They allow you to fine-tune the process of + instance validation and parsing. Both arguments are optional. +

+ + +

The following flags are recognized by the parsing functions:

+ +
+
xml_schema::flags::keep_dom
+
Keep association between DOM nodes and the resulting + object model nodes. For more information about DOM association + refer to Section 5.1, "DOM Association".
+ +
xml_schema::flags::own_dom
+
Assume ownership of the DOM document passed. This flag only + makes sense together with the keep_dom flag in + the call to the parsing function with the + xml_schema::dom::[unique|auto]_ptr<DOMDocument> + argument.
+ +
xml_schema::flags::dont_validate
+
Do not validate instance documents against schemas.
+ +
xml_schema::flags::dont_initialize
+
Do not initialize the Xerces-C++ runtime.
+
+ +

You can pass several flags by combining them using the bit-wise OR + operator. For example:

+ + 
+using xml_schema::flags;
+
+std::unique_ptr<type> r (
+  name ("test.xml", flags::keep_dom | flags::dont_validate));
+
+ +

By default, validation of instance documents is turned on even + though parsers generated by XSD do not assume instance + documents are valid. They include a number of checks that prevent + construction of inconsistent object models. This, + however, does not mean that an instance document that was + successfully parsed by the XSD-generated parsers is + valid per the corresponding schema. If an instance document is not + "valid enough" for the generated parsers to construct consistent + object model, one of the exceptions defined in + xml_schema namespace is thrown (see + Section 3.3, "Error Handling"). +

+ +

For more information on the Xerces-C++ runtime initialization + refer to Section 3.1, "Initializing the Xerces-C++ + Runtime". +

+ +

The xml_schema::properties class allows you to + programmatically specify schema locations to be used instead + of those specified with the xsi::schemaLocation + and xsi::noNamespaceSchemaLocation attributes + in instance documents. The interface of the properties + class is presented below: +

+ + 
+class properties
+{
+public:
+  void
+  schema_location (const std::basic_string<C>& namespace_,
+                   const std::basic_string<C>& location);
+  void
+  no_namespace_schema_location (const std::basic_string<C>& location);
+};
+
+ +

Note that all locations are relative to an instance document unless + they are URIs. For example, if you want to use a local file as your + schema, then you will need to pass + file:///absolute/path/to/your/schema as the location + argument. +

+ +

3.3 Error Handling

+ +

As discussed in Section 2.2, "Error Handling", + the mapping uses the C++ exception handling mechanism as its primary + way of reporting error conditions. However, to handle recoverable + parsing and validation errors and warnings, a callback interface maybe + preferred by the application.

+ +

To better understand error handling and reporting strategies employed + by the parsing functions, it is useful to know that the + transformation of an XML instance document to a statically-typed + tree happens in two stages. The first stage, performed by Xerces-C++, + consists of parsing an XML document into a DOM instance. For short, + we will call this stage the XML-DOM stage. Validation, if not disabled, + happens during this stage. The second stage, + performed by the generated parsers, consist of parsing the DOM + instance into the statically-typed tree. We will call this stage + the DOM-Tree stage. Additional checks are performed during this + stage in order to prevent construction of inconsistent tree which + could otherwise happen when validation is disabled, for example.

+ +

All parsing functions except the one that operates on a DOM instance + come in overloaded triples. The first function in such a triple + reports error conditions exclusively by throwing exceptions. It + accumulates all the parsing and validation errors of the XML-DOM + stage and throws them in a single instance of the + xml_schema::parsing exception (described below). + The second and the third functions in the triple use callback + interfaces to report parsing and validation errors and warnings. + The two callback interfaces are xml_schema::error_handler + and xercesc::DOMErrorHandler. For more information + on the xercesc::DOMErrorHandler interface refer to + the Xerces-C++ documentation. The xml_schema::error_handler + interface is presented below: +

+ + 
+class error_handler
+{
+public:
+  struct severity
+  {
+    enum value
+    {
+      warning,
+      error,
+      fatal
+    };
+  };
+
+  virtual bool
+  handle (const std::basic_string<C>& id,
+          unsigned long line,
+          unsigned long column,
+          severity,
+          const std::basic_string<C>& message) = 0;
+
+  virtual
+  ~error_handler ();
+};
+
+ +

The id argument of the error_handler::handle + function identifies the resource being parsed (e.g., a file name or + URI). +

+ +

By returning true from the handle function + you instruct the parser to recover and continue parsing. Returning + false results in termination of the parsing process. + An error with the fatal severity level results in + termination of the parsing process no matter what is returned from + the handle function. It is safe to throw an exception + from the handle function. +

+ +

The DOM-Tree stage reports error conditions exclusively by throwing + exceptions. Individual exceptions thrown by the parsing functions + are described in the following sub-sections. +

+ + +

3.3.1 xml_schema::parsing

+ + 
+struct severity
+{
+  enum value
+  {
+    warning,
+    error
+  };
+
+  severity (value);
+  operator value () const;
+};
+
+struct error
+{
+  error (severity,
+         const std::basic_string<C>& id,
+         unsigned long line,
+         unsigned long column,
+         const std::basic_string<C>& message);
+
+  severity
+  severity () const;
+
+  const std::basic_string<C>&
+  id () const;
+
+  unsigned long
+  line () const;
+
+  unsigned long
+  column () const;
+
+  const std::basic_string<C>&
+  message () const;
+};
+
+std::basic_ostream<C>&
+operator<< (std::basic_ostream<C>&, const error&);
+
+struct diagnostics: std::vector<error>
+{
+};
+
+std::basic_ostream<C>&
+operator<< (std::basic_ostream<C>&, const diagnostics&);
+
+struct parsing: virtual exception
+{
+  parsing ();
+  parsing (const diagnostics&);
+
+  const diagnostics&
+  diagnostics () const;
+
+  virtual const char*
+  what () const throw ();
+};
+
+ +

The xml_schema::parsing exception is thrown if there + were parsing or validation errors reported during the XML-DOM stage. + If no callback interface was provided to the parsing function, the + exception contains a list of errors and warnings accessible using + the diagnostics function. The usual conditions when + this exception is thrown include malformed XML instances and, if + validation is turned on, invalid instance documents. +

+ +

3.3.2 xml_schema::expected_element

+ + 
+struct expected_element: virtual exception
+{
+  expected_element (const std::basic_string<C>& name,
+                    const std::basic_string<C>& namespace_);
+
+
+  const std::basic_string<C>&
+  name () const;
+
+  const std::basic_string<C>&
+  namespace_ () const;
+
+
+  virtual const char*
+  what () const throw ();
+};
+
+ +

The xml_schema::expected_element exception is thrown + when an expected element is not encountered by the DOM-Tree stage. + The name and namespace of the expected element can be obtained using + the name and namespace_ functions respectively. +

+ + +

3.3.3 xml_schema::unexpected_element

+ + 
+struct unexpected_element: virtual exception
+{
+  unexpected_element (const std::basic_string<C>& encountered_name,
+                      const std::basic_string<C>& encountered_namespace,
+                      const std::basic_string<C>& expected_name,
+                      const std::basic_string<C>& expected_namespace)
+
+
+  const std::basic_string<C>&
+  encountered_name () const;
+
+  const std::basic_string<C>&
+  encountered_namespace () const;
+
+
+  const std::basic_string<C>&
+  expected_name () const;
+
+  const std::basic_string<C>&
+  expected_namespace () const;
+
+
+  virtual const char*
+  what () const throw ();
+};
+
+ +

The xml_schema::unexpected_element exception is thrown + when an unexpected element is encountered by the DOM-Tree stage. + The name and namespace of the encountered element can be obtained + using the encountered_name and + encountered_namespace functions respectively. If an + element was expected instead of the encountered one, its name + and namespace can be obtained using the expected_name and + expected_namespace functions respectively. Otherwise + these functions return empty strings. +

+ +

3.3.4 xml_schema::expected_attribute

+ + 
+struct expected_attribute: virtual exception
+{
+  expected_attribute (const std::basic_string<C>& name,
+                      const std::basic_string<C>& namespace_);
+
+
+  const std::basic_string<C>&
+  name () const;
+
+  const std::basic_string<C>&
+  namespace_ () const;
+
+
+  virtual const char*
+  what () const throw ();
+};
+
+ +

The xml_schema::expected_attribute exception is thrown + when an expected attribute is not encountered by the DOM-Tree stage. + The name and namespace of the expected attribute can be obtained using + the name and namespace_ functions respectively. +

+ + +

3.3.5 xml_schema::unexpected_enumerator

+ + 
+struct unexpected_enumerator: virtual exception
+{
+  unexpected_enumerator (const std::basic_string<C>& enumerator);
+
+  const std::basic_string<C>&
+  enumerator () const;
+
+  virtual const char*
+  what () const throw ();
+};
+
+ +

The xml_schema::unexpected_enumerator exception is thrown + when an unexpected enumerator is encountered by the DOM-Tree stage. + The enumerator can be obtained using the enumerator + functions. +

+ +

3.3.6 xml_schema::expected_text_content

+ + 
+struct expected_text_content: virtual exception
+{
+  virtual const char*
+  what () const throw ();
+};
+
+ +

The xml_schema::expected_text_content exception is thrown + when a content other than text is encountered and the text content was + expected by the DOM-Tree stage. +

+ +

3.3.7 xml_schema::no_type_info

+ + 
+struct no_type_info: virtual exception
+{
+  no_type_info (const std::basic_string<C>& type_name,
+                const std::basic_string<C>& type_namespace);
+
+  const std::basic_string<C>&
+  type_name () const;
+
+  const std::basic_string<C>&
+  type_namespace () const;
+
+  virtual const char*
+  what () const throw ();
+};
+
+ +

The xml_schema::no_type_info exception is thrown + when there is no type information associated with a type specified + by the xsi:type attribute. This exception is thrown + by the DOM-Tree stage. The name and namespace of the type in question + can be obtained using the type_name and + type_namespace functions respectively. Usually, catching + this exception means that you haven't linked the code generated + from the schema defining the type in question with your application + or this schema has been compiled without the + --generate-polymorphic option. +

+ + +

3.3.8 xml_schema::not_derived

+ + 
+struct not_derived: virtual exception
+{
+  not_derived (const std::basic_string<C>& base_type_name,
+               const std::basic_string<C>& base_type_namespace,
+               const std::basic_string<C>& derived_type_name,
+               const std::basic_string<C>& derived_type_namespace);
+
+  const std::basic_string<C>&
+  base_type_name () const;
+
+  const std::basic_string<C>&
+  base_type_namespace () const;
+
+
+  const std::basic_string<C>&
+  derived_type_name () const;
+
+  const std::basic_string<C>&
+  derived_type_namespace () const;
+
+  virtual const char*
+  what () const throw ();
+};
+
+ +

The xml_schema::not_derived exception is thrown + when a type specified by the xsi:type attribute is + not derived from the expected base type. This exception is thrown + by the DOM-Tree stage. The name and namespace of the expected + base type can be obtained using the base_type_name and + base_type_namespace functions respectively. The name + and namespace of the offending type can be obtained using the + derived_type_name and + derived_type_namespace functions respectively. +

+ +

3.3.9 xml_schema::no_prefix_mapping

+ + 
+struct no_prefix_mapping: virtual exception
+{
+  no_prefix_mapping (const std::basic_string<C>& prefix);
+
+  const std::basic_string<C>&
+  prefix () const;
+
+  virtual const char*
+  what () const throw ();
+};
+
+ +

The xml_schema::no_prefix_mapping exception is thrown + during the DOM-Tree stage if a namespace prefix is encountered for + which a prefix-namespace mapping hasn't been provided. The namespace + prefix in question can be obtained using the prefix + function. +

+ +

3.4 Reading from a Local File or URI

+ +

Using a local file or URI is the simplest way to parse an XML instance. + For example:

+ + 
+using std::unique_ptr;
+
+unique_ptr<type> r1 (name ("test.xml"));
+unique_ptr<type> r2 (name ("https://www.codesynthesis.com/test.xml"));
+
+ +

Or, in the C++98 mode:

+ + 
+using std::auto_ptr;
+
+auto_ptr<type> r1 (name ("test.xml"));
+auto_ptr<type> r2 (name ("https://www.codesynthesis.com/test.xml"));
+
+ +

3.5 Reading from std::istream

+ +

When using an std::istream instance, you may also + pass an optional resource id. This id is used to identify the + resource (for example in error messages) as well as to resolve + relative paths. For instance:

+ + 
+using std::unique_ptr;
+
+{
+  std::ifstream ifs ("test.xml");
+  unique_ptr<type> r (name (ifs, "test.xml"));
+}
+
+{
+  std::string str ("..."); // Some XML fragment.
+  std::istringstream iss (str);
+  unique_ptr<type> r (name (iss));
+}
+
+ +

3.6 Reading from xercesc::InputSource

+ +

Reading from a xercesc::InputSource instance + is similar to the std::istream case except + the resource id is maintained by the InputSource + object. For instance:

+ + 
+xercesc::StdInInputSource is;
+std::unique_ptr<type> r (name (is));
+
+ +

3.7 Reading from DOM

+ +

Reading from a xercesc::DOMDocument instance allows + you to setup a custom XML-DOM stage. Things like DOM + parser reuse, schema pre-parsing, and schema caching can be achieved + with this approach. For more information on how to obtain DOM + representation from an XML instance refer to the Xerces-C++ + documentation. In addition, the + C++/Tree Mapping + FAQ shows how to parse an XML instance to a Xerces-C++ + DOM document using the XSD runtime utilities. +

+ +

The last parsing function is useful when you would like to perform + your own XML-to-DOM parsing and associate the resulting DOM document + with the object model nodes. The automatic DOMDocument + pointer is reset and the resulting object model assumes ownership + of the DOM document passed. For example:

+ + 
+// C++11 version.
+//
+xml_schema::dom::unique_ptr<xercesc::DOMDocument> doc = ...
+
+std::unique_ptr<type> r (
+  name (std::move (doc),
+        xml_schema::flags::keep_dom | xml_schema::flags::own_dom));
+
+// At this point doc is reset to 0.
+
+// C++98 version.
+//
+xml_schema::dom::auto_ptr<xercesc::DOMDocument> doc = ...
+
+std::auto_ptr<type> r (
+  name (doc, xml_schema::flags::keep_dom | xml_schema::flags::own_dom));
+
+// At this point doc is reset to 0.
+
+ +

4 Serialization

+ +

This chapter covers various aspects of serializing a + tree-like object model to DOM or XML. + In this regard, serialization is complimentary to the reverse + process of parsing a DOM or XML instance into an object model + which is discussed in Chapter 3, + "Parsing". Note that the generation of the serialization code + is optional and should be explicitly requested with the + --generate-serialization option. See the + XSD + Compiler Command Line Manual for more information. +

+ +

Each global XML Schema element in the form: +

+ + + 
+<xsd:element name="name" type="type"/>
+
+ +

is mapped to 8 overloaded C++ functions in the form:

+ + 
+// Serialize to std::ostream.
+//
+void
+name (std::ostream&,
+      const type&,
+      const xml_schema::namespace_fomap& =
+        xml_schema::namespace_infomap (),
+      const std::basic_string<C>& encoding = "UTF-8",
+      xml_schema::flags = 0);
+
+void
+name (std::ostream&,
+      const type&,
+      xml_schema::error_handler&,
+      const xml_schema::namespace_infomap& =
+        xml_schema::namespace_infomap (),
+      const std::basic_string<C>& encoding = "UTF-8",
+      xml_schema::flags = 0);
+
+void
+name (std::ostream&,
+      const type&,
+      xercesc::DOMErrorHandler&,
+      const xml_schema::namespace_infomap& =
+        xml_schema::namespace_infomap (),
+      const std::basic_string<C>& encoding = "UTF-8",
+      xml_schema::flags = 0);
+
+
+// Serialize to XMLFormatTarget.
+//
+void
+name (xercesc::XMLFormatTarget&,
+      const type&,
+      const xml_schema::namespace_infomap& =
+        xml_schema::namespace_infomap (),
+      const std::basic_string<C>& encoding = "UTF-8",
+      xml_schema::flags = 0);
+
+void
+name (xercesc::XMLFormatTarget&,
+      const type&,
+      xml_schema::error_handler&,
+      const xml_schema::namespace_infomap& =
+        xml_schema::namespace_infomap (),
+      const std::basic_string<C>& encoding = "UTF-8",
+      xml_schema::flags = 0);
+
+void
+name (xercesc::XMLFormatTarget&,
+      const type&,
+      xercesc::DOMErrorHandler&,
+      const xml_schema::namespace_infomap& =
+        xml_schema::namespace_infomap (),
+      const std::basic_string<C>& encoding = "UTF-8",
+      xml_schema::flags = 0);
+
+
+// Serialize to DOM.
+//
+xml_schema::dom::[unique|auto]_ptr<xercesc::DOMDocument>
+name (const type&,
+      const xml_schema::namespace_infomap&
+        xml_schema::namespace_infomap (),
+      xml_schema::flags = 0);
+
+void
+name (xercesc::DOMDocument&,
+      const type&,
+      xml_schema::flags = 0);
+
+ +

You can choose between writing XML to std::ostream or + xercesc::XMLFormatTarget and creating a DOM instance + in the form of xercesc::DOMDocument. Serialization + to ostream or XMLFormatTarget requires a + considerably less work while serialization to DOM provides + for greater flexibility. Each of these serialization functions + is discussed in more detail in the following sections. +

+ + +

4.1 Initializing the Xerces-C++ Runtime

+ +

Some serialization functions expect you to initialize the Xerces-C++ + runtime while others initialize and terminate it as part of their + work. The general rule is as follows: if a function has any arguments + or return a value that is an instance of a Xerces-C++ type, then + this function expects you to initialize the Xerces-C++ runtime. + Otherwise, the function initializes and terminates the runtime for + you. Note that it is legal to have nested calls to the Xerces-C++ + initialize and terminate functions as long as the calls are balanced. +

+ +

You can instruct serialization functions that initialize and terminate + the runtime not to do so by passing the + xml_schema::flags::dont_initialize flag (see + Section 4.3, "Flags"). +

+ +

4.2 Namespace Infomap and Character Encoding

+ +

When a document being serialized uses XML namespaces, custom + prefix-namespace associations can to be established. If custom + prefix-namespace mapping is not provided then generic prefixes + (p1, p2, etc) are automatically assigned + to namespaces as needed. Also, if + you would like the resulting instance document to contain the + schemaLocation or noNamespaceSchemaLocation + attributes, you will need to provide namespace-schema associations. + The xml_schema::namespace_infomap class is used + to capture this information:

+ + 
+struct namespace_info
+{
+  namespace_info ();
+  namespace_info (const std::basic_string<C>& name,
+                  const std::basic_string<C>& schema);
+
+  std::basic_string<C> name;
+  std::basic_string<C> schema;
+};
+
+// Map of namespace prefix to namespace_info.
+//
+struct namespace_infomap: public std::map<std::basic_string<C>,
+                                          namespace_info>
+{
+};
+
+ +

Consider the following associations as an example:

+ + 
+xml_schema::namespace_infomap map;
+
+map["t"].name = "https://www.codesynthesis.com/test";
+map["t"].schema = "test.xsd";
+
+ +

This map, if passed to one of the serialization functions, + could result in the following XML fragment:

+ + 
+<?xml version="1.0" ?>
+<t:name xmlns:t="https://www.codesynthesis.com/test"
+        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+        xsi:schemaLocation="https://www.codesynthesis.com/test test.xsd">
+
+ +

As you can see, the serialization function automatically added namespace + mapping for the xsi prefix. You can change this by + providing your own prefix:

+ + 
+xml_schema::namespace_infomap map;
+
+map["xsn"].name = "http://www.w3.org/2001/XMLSchema-instance";
+
+map["t"].name = "https://www.codesynthesis.com/test";
+map["t"].schema = "test.xsd";
+
+ +

This could result in the following XML fragment:

+ + 
+<?xml version="1.0" ?>
+<t:name xmlns:t="https://www.codesynthesis.com/test"
+        xmlns:xsn="http://www.w3.org/2001/XMLSchema-instance"
+        xsn:schemaLocation="https://www.codesynthesis.com/test test.xsd">
+
+ +

To specify the location of a schema without a namespace you can use + an empty prefix as in the example below:

+ + 
+xml_schema::namespace_infomap map;
+
+map[""].schema = "test.xsd";
+
+ +

This would result in the following XML fragment:

+ + 
+<?xml version="1.0" ?>
+<name xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+      xsi:noNamespaceSchemaLocation="test.xsd">
+
+ +

To make a particular namespace default you can use an empty + prefix, for example:

+ + 
+xml_schema::namespace_infomap map;
+
+map[""].name = "https://www.codesynthesis.com/test";
+map[""].schema = "test.xsd";
+
+ +

This could result in the following XML fragment:

+ + 
+<?xml version="1.0" ?>
+<name xmlns="https://www.codesynthesis.com/test"
+      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+      xsi:schemaLocation="https://www.codesynthesis.com/test test.xsd">
+
+ + +

Another bit of information that you can pass to the serialization + functions is the character encoding method that you would like to use. + Common values for this argument are "US-ASCII", + "ISO8859-1", "UTF-8", + "UTF-16BE", "UTF-16LE", + "UCS-4BE", and "UCS-4LE". The default + encoding is "UTF-8". For more information on + encoding methods see the + "Character + Encoding" article from Wikipedia. +

+ +

4.3 Flags

+ +

Serialization flags are the last argument of every serialization + function. They allow you to fine-tune the process of serialization. + The flags argument is optional. +

+ + +

The following flags are recognized by the serialization + functions:

+ +
+
xml_schema::flags::dont_initialize
+
Do not initialize the Xerces-C++ runtime.
+ +
xml_schema::flags::dont_pretty_print
+
Do not add extra spaces or new lines that make the resulting XML + slightly bigger but easier to read.
+ +
xml_schema::flags::no_xml_declaration
+
Do not write XML declaration (<?xml ... ?>).
+
+ +

You can pass several flags by combining them using the bit-wise OR + operator. For example:

+ + 
+std::unique_ptr<type> r = ...
+std::ofstream ofs ("test.xml");
+xml_schema::namespace_infomap map;
+name (ofs,
+      *r,
+      map,
+      "UTF-8",
+      xml_schema::flags::no_xml_declaration |
+      xml_schema::flags::dont_pretty_print);
+
+ +

For more information on the Xerces-C++ runtime initialization + refer to Section 4.1, "Initializing the Xerces-C++ + Runtime". +

+ +

4.4 Error Handling

+ +

As with the parsing functions (see Section 3.3, + "Error Handling"), to better understand error handling and + reporting strategies employed by the serialization functions, it + is useful to know that the transformation of a statically-typed + tree to an XML instance document happens in two stages. The first + stage, performed by the generated code, consist of building a DOM + instance from the statically-typed tree . For short, we will call + this stage the Tree-DOM stage. The second stage, performed by + Xerces-C++, consists of serializing the DOM instance into the XML + document. We will call this stage the DOM-XML stage. +

+ +

All serialization functions except the two that serialize into + a DOM instance come in overloaded triples. The first function + in such a triple reports error conditions exclusively by throwing + exceptions. It accumulates all the serialization errors of the + DOM-XML stage and throws them in a single instance of the + xml_schema::serialization exception (described below). + The second and the third functions in the triple use callback + interfaces to report serialization errors and warnings. The two + callback interfaces are xml_schema::error_handler and + xercesc::DOMErrorHandler. The + xml_schema::error_handler interface is described in + Section 3.3, "Error Handling". For more information + on the xercesc::DOMErrorHandler interface refer to the + Xerces-C++ documentation. +

+ +

The Tree-DOM stage reports error conditions exclusively by throwing + exceptions. Individual exceptions thrown by the serialization functions + are described in the following sub-sections. +

+ +

4.4.1 xml_schema::serialization

+ + 
+struct serialization: virtual exception
+{
+  serialization ();
+  serialization (const diagnostics&);
+
+  const diagnostics&
+  diagnostics () const;
+
+  virtual const char*
+  what () const throw ();
+};
+
+ +

The xml_schema::diagnostics class is described in + Section 3.3.1, "xml_schema::parsing". + The xml_schema::serialization exception is thrown if + there were serialization errors reported during the DOM-XML stage. + If no callback interface was provided to the serialization function, + the exception contains a list of errors and warnings accessible using + the diagnostics function. +

+ + +

4.4.2 xml_schema::unexpected_element

+ +

The xml_schema::unexpected_element exception is + described in Section 3.3.3, + "xml_schema::unexpected_element". It is thrown + by the serialization functions during the Tree-DOM stage if the + root element name of the provided DOM instance does not match with + the name of the element this serialization function is for. +

+ +

4.4.3 xml_schema::no_type_info

+ +

The xml_schema::no_type_info exception is + described in Section 3.3.7, + "xml_schema::no_type_info". It is thrown + by the serialization functions during the Tree-DOM stage when there + is no type information associated with a dynamic type of an + element. Usually, catching this exception means that you haven't + linked the code generated from the schema defining the type in + question with your application or this schema has been compiled + without the --generate-polymorphic option. +

+ +

4.5 Serializing to std::ostream

+ +

In order to serialize to std::ostream you will need + an object model, an output stream and, optionally, a namespace + infomap. For instance:

+ + 
+// Obtain the object model.
+//
+std::unique_ptr<type> r = ...
+
+// Prepare namespace mapping and schema location information.
+//
+xml_schema::namespace_infomap map;
+
+map["t"].name = "https://www.codesynthesis.com/test";
+map["t"].schema = "test.xsd";
+
+// Write it out.
+//
+name (std::cout, *r, map);
+
+ +

Note that the output stream is treated as a binary stream. This + becomes important when you use a character encoding that is wider + than 8-bit char, for instance UTF-16 or UCS-4. For + example, things will most likely break if you try to serialize + to std::ostringstream with UTF-16 or UCS-4 as an + encoding. This is due to the special value, + '\0', that will most likely occur as part of such + serialization and it won't have the special meaning assumed by + std::ostringstream. +

+ + +

4.6 Serializing to xercesc::XMLFormatTarget

+ +

Serializing to an xercesc::XMLFormatTarget instance + is similar the std::ostream case. For instance: +

+ + 
+using std::unique_ptr;
+
+// Obtain the object model.
+//
+unique_ptr<type> r = ...
+
+// Prepare namespace mapping and schema location information.
+//
+xml_schema::namespace_infomap map;
+
+map["t"].name = "https://www.codesynthesis.com/test";
+map["t"].schema = "test.xsd";
+
+using namespace xercesc;
+
+XMLPlatformUtils::Initialize ();
+
+{
+  // Choose a target.
+  //
+  unique_ptr<XMLFormatTarget> ft;
+
+  if (argc != 2)
+  {
+    ft = unique_ptr<XMLFormatTarget> (new StdOutFormatTarget ());
+  }
+  else
+  {
+    ft = unique_ptr<XMLFormatTarget> (
+      new LocalFileFormatTarget (argv[1]));
+  }
+
+  // Write it out.
+  //
+  name (*ft, *r, map);
+}
+
+XMLPlatformUtils::Terminate ();
+
+ +

Note that we had to initialize the Xerces-C++ runtime before we + could call this serialization function.

+ +

4.7 Serializing to DOM

+ +

The mapping provides two overloaded functions that implement + serialization to a DOM instance. The first creates a DOM instance + for you and the second serializes to an existing DOM instance. + While serializing to a new DOM instance is similar to serializing + to std::ostream or xercesc::XMLFormatTarget, + serializing to an existing DOM instance requires quite a bit of work + from your side. You will need to set all the custom namespace mapping + attributes as well as the schemaLocation and/or + noNamespaceSchemaLocation attributes. The following + listing should give you an idea about what needs to be done: +

+ + 
+// Obtain the object model.
+//
+std::unique_ptr<type> r = ...
+
+using namespace xercesc;
+
+XMLPlatformUtils::Initialize ();
+
+{
+  // Create a DOM instance. Set custom namespace mapping and schema
+  // location attributes.
+  //
+  DOMDocument& doc = ...
+
+  // Serialize to DOM.
+  //
+  name (doc, *r);
+
+  // Serialize the DOM document to XML.
+  //
+  ...
+}
+
+XMLPlatformUtils::Terminate ();
+
+ +

For more information on how to create and serialize a DOM instance + refer to the Xerces-C++ documentation. In addition, the + C++/Tree Mapping + FAQ shows how to implement these operations using the XSD + runtime utilities. +

+ +

5 Additional Functionality

+ +

The C++/Tree mapping provides a number of optional features + that can be useful in certain situations. They are described + in the following sections.

+ +

5.1 DOM Association

+ +

Normally, after parsing is complete, the DOM document which + was used to extract the data is discarded. However, the parsing + functions can be instructed to preserve the DOM document + and create an association between the DOM nodes and object model + nodes. When there is an association between the DOM and + object model nodes, you can obtain the corresponding DOM element + or attribute node from an object model node as well as perform + the reverse transition: obtain the corresponding object model + from a DOM element or attribute node.

+ +

Maintaining DOM association is normally useful when the application + needs access to XML constructs that are not preserved in the + object model, for example, XML comments. + Another useful aspect of DOM association is the ability of the + application to navigate the document tree using the generic DOM + interface (for example, with the help of an XPath processor) + and then move back to the statically-typed object model. Note + also that while you can change the underlying DOM document, + these changes are not reflected in the object model and will + be ignored during serialization. If you need to not only access + but also modify some aspects of XML that are not preserved in + the object model, then type customization with custom parsing + constructors and serialization operators should be used instead.

+ +

To request DOM association you will need to pass the + xml_schema::flags::keep_dom flag to one of the + parsing functions (see Section 3.2, + "Flags and Properties" for more information). In this case the + DOM document is retained and will be released when the object model + is deleted. Note that since DOM nodes "out-live" the parsing function + call, you need to initialize the Xerces-C++ runtime before calling + one of the parsing functions with the keep_dom flag and + terminate it after the object model is destroyed (see + Section 3.1, "Initializing the Xerces-C++ Runtime").

+ +

If the keep_dom flag is passed + as the second argument to the copy constructor and the copy + being made is of a complete tree, then the DOM association + is also maintained in the copy by cloning the underlying + DOM document and reestablishing the associations. For example:

+ + 
+using namespace xercesc;
+
+XMLPlatformUtils::Initialize ();
+
+{
+  // Parse XML to object model.
+  //
+  std::unique_ptr<type> r (root (
+    "root.xml",
+     xml_schema::flags::keep_dom |
+     xml_schema::flags::dont_initialize));
+
+   // Copy without DOM association.
+   //
+   type copy1 (*r);
+
+   // Copy with DOM association.
+   //
+   type copy2 (*r, xml_schema::flags::keep_dom);
+}
+
+XMLPlatformUtils::Terminate ();
+
+ + +

To obtain the corresponding DOM node from an object model node + you will need to call the _node accessor function + which returns a pointer to DOMNode. You can then query + this DOM node's type and cast it to either DOMAttr* + or DOMElement*. To obtain the corresponding object + model node from a DOM node, the DOM user data API is used. The + xml_schema::dom::tree_node_key variable contains + the key for object model nodes. The following schema and code + fragment show how to navigate from DOM to object model nodes + and in the opposite direction:

+ + 
+<complexType name="object">
+  <sequence>
+    <element name="a" type="string"/>
+  </sequence>
+</complexType>
+
+<element name="root" type="object"/>
+
+ + 
+using namespace xercesc;
+
+XMLPlatformUtils::Initialize ();
+
+{
+  // Parse XML to object model.
+  //
+  std::unique_ptr<type> r (root (
+    "root.xml",
+     xml_schema::flags::keep_dom |
+     xml_schema::flags::dont_initialize));
+
+  DOMNode* n = r->_node ();
+  assert (n->getNodeType () == DOMNode::ELEMENT_NODE);
+  DOMElement* re = static_cast<DOMElement*> (n);
+
+  // Get the 'a' element. Note that it is not necessarily the
+  // first child node of 'root' since there could be whitespace
+  // nodes before it.
+  //
+  DOMElement* ae;
+
+  for (n = re->getFirstChild (); n != 0; n = n->getNextSibling ())
+  {
+    if (n->getNodeType () == DOMNode::ELEMENT_NODE)
+    {
+      ae = static_cast<DOMElement*> (n);
+      break;
+    }
+  }
+
+  // Get from the 'a' DOM element to xml_schema::string object model
+  // node.
+  //
+  xml_schema::type& t (
+    *reinterpret_cast<xml_schema::type*> (
+       ae->getUserData (xml_schema::dom::tree_node_key)));
+
+  xml_schema::string& a (dynamic_cast<xml_schema::string&> (t));
+}
+
+XMLPlatformUtils::Terminate ();
+
+ +

The 'mixed' example which can be found in the XSD distribution + shows how to handle the mixed content using DOM association.

+ +

5.2 Binary Serialization

+ +

Besides reading from and writing to XML, the C++/Tree mapping + also allows you to save the object model to and load it from a + number of predefined as well as custom data representation + formats. The predefined binary formats are CDR (Common Data + Representation) and XDR (eXternal Data Representation). A + custom format can easily be supported by providing + insertion and extraction operators for basic types.

+ +

Binary serialization saves only the data without any meta + information or markup. As a result, saving to and loading + from a binary representation can be an order of magnitude + faster than parsing and serializing the same data in XML. + Furthermore, the resulting representation is normally several + times smaller than the equivalent XML representation. These + properties make binary serialization ideal for internal data + exchange and storage. A typical application that uses this + facility stores the data and communicates within the + system using a binary format and reads/writes the data + in XML when communicating with the outside world.

+ +

In order to request the generation of insertion operators and + extraction constructors for a specific predefined or custom + data representation stream, you will need to use the + --generate-insertion and --generate-extraction + compiler options. See the + XSD + Compiler Command Line Manual for more information.

+ +

Once the insertion operators and extraction constructors are + generated, you can use the xml_schema::istream + and xml_schema::ostream wrapper stream templates + to save the object model to and load it from a specific format. + The following code fragment shows how to do this using ACE + (Adaptive Communication Environment) CDR streams as an example:

+ + 
+<complexType name="object">
+  <sequence>
+    <element name="a" type="string"/>
+    <element name="b" type="int"/>
+  </sequence>
+</complexType>
+
+<element name="root" type="object"/>
+
+ + 
+// Parse XML to object model.
+//
+std::unique_ptr<type> r (root ("root.xml"));
+
+// Save to a CDR stream.
+//
+ACE_OutputCDR ace_ocdr;
+xml_schema::ostream<ACE_OutputCDR> ocdr (ace_ocdr);
+
+ocdr << *r;
+
+// Load from a CDR stream.
+//
+ACE_InputCDR ace_icdr (buf, size);
+xml_schema::istream<ACE_InputCDR> icdr (ace_icdr);
+
+std::unique_ptr<object> copy (new object (icdr));
+
+// Serialize to XML.
+//
+root (std::cout, *copy);
+
+ +

The XSD distribution contains a number of examples that + show how to save the object model to and load it from + CDR, XDR, and a custom format.

+ + + + +

Appendix A — Default and Fixed Values

+ +

The following table summarizes the effect of default and fixed + values (specified with the default and fixed + attributes, respectively) on attribute and element values. The + default and fixed attributes are mutually + exclusive. It is also worthwhile to note that the fixed value semantics + is a superset of the default value semantics. +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
defaultfixed
elementnot presentoptionalrequiredoptionalrequired
not presentinvalid instancenot presentinvalid instance
emptydefault value is usedfixed value is used
valuevalue is usedvalue is used provided it's the same as fixed
attributenot presentoptionalrequiredoptionalrequired
default value is usedinvalid schemafixed value is usedinvalid instance
emptyempty value is usedempty value is used provided it's the same as fixed
valuevalue is usedvalue is used provided it's the same as fixed
+ +
+
+ + + + diff --git a/doc/cxx/tree/manual/manual.html2ps.in b/doc/cxx/tree/manual/manual.html2ps.in new file mode 100644 index 0000000..5629122 --- /dev/null +++ b/doc/cxx/tree/manual/manual.html2ps.in @@ -0,0 +1,66 @@ +@@html2ps { + option { + toc: hb; + colour: 1; + hyphenate: 1; + titlepage: 1; + } + + datefmt: "%B %Y"; + + titlepage { + content: " +
+

C++/Tree Mapping User Manual

+

 

+

 

+

 

+

 

+

 

+

 

+

 

+
+

Revision $[revision]     $D

+

Copyright © @copyright@.

+ +

Permission is granted to copy, distribute and/or modify this + document under the terms of the + GNU Free + Documentation License, version 1.2; with no Invariant Sections, + no Front-Cover Texts and no Back-Cover Texts. +

+ +

This document is available in the following formats: + XHTML, + PDF, and + PostScript.

"; + } + + toc { + indent: 2em; + } + + header { + odd-right: $H; + even-left: $H; + } + + footer { + odd-left: $D; + odd-center: $T, v$[revision]; + odd-right: $N; + + even-left: $N; + even-center: $T, v$[revision]; + even-right: $D; + } +} + +body { + font-size: 12pt; + text-align: justify; +} + +pre { + font-size: 10pt; +} diff --git a/doc/default.css b/doc/default.css new file mode 100644 index 0000000..bb3805b --- /dev/null +++ b/doc/default.css @@ -0,0 +1,319 @@ +html { + margin : 0; + padding : 0; + background : white; +} + +body { + font-family : "Lucida Grande", Verdana, "Bitstream Vera Sans", sans-serif; + font-weight : normal; + font-size : 13px; + line-height : 19px; + + color : black; + + margin : 0 2em 0 2em; + padding : 0; +} + + +body { + min-width: 40em; +} + +#container { + max-width : 46em; + margin : 0 auto; + padding : 0 1em 0 1em; +} + + + +/* + * Footer + * + */ +#footer { + color : #3a84a7; + + padding : 1em 0 0.5em 0; + + font-size : 10px; + line-height : 15px; + + text-align: center; +} + +#footer a:link, #footer a:visited { + + color:#1d6699; + text-decoration: underline; +} + +#footer a { + margin-left: 0.7em; + margin-right: 0.7em; +} + +#footer p { + padding: 0; + margin: 0.3em 0 0 0; +} + +/* Distribution terms. */ +#footer #terms { + text-align: justify; + + font-size : 110%; + font-family : monospace; + + padding : 1em 0 0.5em 0; +} + + +/* + * Content + * + */ + +#content { + padding : 0em 0.1em 0 1.3em; + margin : 1.4em 0 0 0; +} + +#content p, +#content ol, +#content ul, +#content dl { + text-align: justify; +} + +#content h1 { + margin-left: -0.89em; +} + +a:link { + color:#0536d2; +} + + +/* + * Headings + * + */ + +h1, h2, h3, h4, h5, h6 { + font-weight : 500; +} + +h1 { font-size : 155%; } +h2 { font-size : 130%; } +h3 { font-size : 125%; } +h4 { font-size : 110%; } +h5 { font-size : 106%; } +h6 { font-size : 100%; } + +h1 { margin : 1.8em 0 0.8em 0;} +h2 { margin-top : 1.4em;} +h3 { margin-top : 1em;} + +p.indent { + margin-left : 1.5em; +} + + +/* + * Fix for IE 5.5 table font problem + * + */ + +table { + font-size : 13px; +} + + +/* + * table of content + * + */ + +ul.toc li { + padding : .4em 0em 0em 0em; +} + + +/* Toc links don't need to show when they are visited. */ +.toc a:visited { + color:#0536d2; +} + + +/* + * lists + * + */ + + +/* list of links */ +ul.menu { + list-style-type : none; +} + +ul.menu li { + padding-top : 0.3em; + padding-bottom : 0.3em; +} + + + +/* @@ I should probably use child selector here */ +/* list with multiline list-elements */ +ul.multiline li, ol.multiline li, dl.multiline dd { + padding-top : 0.16em; + padding-bottom : 0.16em; + + font-size : 11px; + line-height : 15px; +} + + + +/* C++ code snippet */ +pre.cxx { + margin-top : 0em; + margin-bottom : 2em; + + margin-left : 1em; +} + + + +/* make code snippet */ +pre.make { + margin-top : 0em; + margin-bottom : 2em; + + margin-left : 1em; +} + + + +/* terminal output */ +pre.term { + margin-top : 0em; + margin-bottom : 2em; + + margin-left : 1em; +} + + +/* Images */ +div.center { + text-align: center; +} + +/* Document info. */ +#docinfo { + margin-top: 4em; + border-top: 1px dashed #000000; + font-size: 70%; +} + + +/* Footnote */ + +#footnote { + margin-top : 2.5em; +} + +#footnote hr, hr.footnote { + margin-left: 0; + margin-bottom: 0.6em; + width: 8em; + border-top: 1px solid #000000; + border-right: none; + border-bottom: none; + border-left: none; + +} + +#footnote ol { + margin-left: 0; + padding-left: 1.45em; +} + +#footnote li { + text-align : left; + font-size : 11px; + line-height : 15px; + + padding : .4em 0 .4em 0; +} + + +/* Normal table with borders, etc. */ + +table.std { + margin: 2em 0 2em 0; + + border-collapse : collapse; + border : 1px solid; + border-color : #000000; + + font-size : 11px; + line-height : 14px; +} + +table.std th, table.std td { + border : 1px solid; + padding : 0.6em 0.8em 0.6em 0.8em; +} + +table.std th { + background : #cde8f6; +} + +table.std td { + text-align: left; +} + + +/* + * "item | description" table. + * + */ + +table.description { + border-style : none; + border-collapse : separate; + border-spacing : 0; + + font-size : 13px; + + margin : 0.6em 0 0.6em 0; + padding : 0 0 0 0; +} + +table.description tr { + padding : 0 0 0 0; + margin : 0 0 0 0; +} + +table.description * td, table.description * th { + border-style : none; + margin : 0 0 0 0; + vertical-align : top; +} + +table.description * th { + font-weight : normal; + padding : 0.4em 1em 0.4em 0; + text-align : left; + white-space : nowrap; + background : none; +} + +table.description * td { + padding : 0.4em 0 0.4em 1em; + text-align : justify; +} diff --git a/doc/pregenerated/cxx/parser/guide/cxx-parser-guide.pdf b/doc/pregenerated/cxx/parser/guide/cxx-parser-guide.pdf new file mode 100644 index 0000000..6440573 Binary files /dev/null and b/doc/pregenerated/cxx/parser/guide/cxx-parser-guide.pdf differ diff --git a/doc/pregenerated/cxx/parser/guide/cxx-parser-guide.ps b/doc/pregenerated/cxx/parser/guide/cxx-parser-guide.ps new file mode 100644 index 0000000..81f6b44 --- /dev/null +++ b/doc/pregenerated/cxx/parser/guide/cxx-parser-guide.ps @@ -0,0 +1,20741 @@ +%!PS +%%Title: C++/Parser Mapping Getting Started Guide +%%Creator: html2ps version 1.0 beta7 +%%EndComments +save +2000 dict begin +/d {bind def} bind def +/D {def} d +/t true D +/f false D +/FL [/Times-Roman +/Times-Italic +/Times-Bold +/Times-BoldItalic +/Courier +/Courier-Oblique +/Courier-Bold +/Courier-BoldOblique +/Helvetica +/Helvetica-Oblique +/Helvetica-Bold +/Helvetica-BoldOblique] D +/WF t D +/WI 0 D +/F 1 D +/IW 471 F div D +/IL 621 F div D +/PS 791 D +/EF [0 1 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 2 2] D +/EZ [12 10 19 17 15 13 12 11 12 12 12 12 12 12 12 12 12 12 12 12 12 12 8 8] D +/Ey [0 0 2 2 2 2 2 2 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0] D +/EG [-1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1] D +/Tm [1 1 0.8 0.8 0.8 0.8 0.8 0.8 0 0 0 0 0 0 0.5 1 1 1 1 0 0 1.3 0 0] D +/Bm [1 1 0.5 0.5 0.5 0.5 0.5 0.5 0 0 0 0 0 0 0.5 1 1 1 1 0 0 1 0 0] D +/Lm [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 2 2 0 0 2 0 0 0] D +/Rm [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0] D +/EU [-1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 0 0] D +/NO f D +/YY [[{()}{ h }][{ h }{()}][{()}{()}]] D +/ZZ [[{ (September 2023) }{ Pn }][{ Pn }{ (September 2023) }][{ Ti }{ Ti }]] D +/Ts EZ 0 get D +/TU f D +/Xp t D +/AU f D +/SN 0 D +/Cf t D +/Tp t D +/Fe f D +/TI 2 Ts mul D +/Fm 14 D +/xL 71 D +/xR 71 D +/yL 706 D +/yR 706 D +/Wl 471 F div D +/Wr 471 F div D +/hL 621 F div D +/hR 621 F div D +/FE {newpath Fm neg Fm M CP BB IW Fm add Fm L IW Fm add IL Fm add neg L CP BB + Fm neg IL Fm add neg L closepath} D +/LA {PM 0 eq{/IW Wl D /IL hL D}{/IW Wr D /IL hR D}ie /W IW D /LL W D /LS W D + TU PM 0 eq and{IW 56 F div add SA{Sf div}if 0 translate} + {PM 0 eq{xL yL}{xR yR}ie translate F SA{Sf mul}if dup scale + CS CF FS Cf{CA CL get VC}if /Bb f D}ie 0 0 M + TF not Tc or {Cf{gsave SA{1 Sf div dup scale}if Cb VC FE fill grestore}if}if}D +/Pi 0 Ts mul D +/SG [0.8 1 1] D +/Ab 15 D +/J 0 D +/Tc t D +/NH 6 D +/Nf f D +/Pa f D +/LH 1.2 D +/XR f D +/Xr {/pN E D ( [p ) WB pN WB (] )WB} D +/Db [16#FF 16#FF 16#FF] D +/Dt [16#00 16#00 16#00] D +/eA f D +/Fi f D +/bT f D +/Lc t D +/Dl [16#00 16#00 16#00] D +/LX f D +/Br 0.25 D +/IA ([IMAGE]) D +/DS {/PF f D()WB NL NP()pop RC ZF} D +/Gb f D +/Mb t D +/Hc [16#00 16#00 16#00] D +/Bl 3 D +/MI -15.6 D +/DX (DRAFT) D +/Di 0 D +/Tt 113.385826771654 D +/Th { ( +) 2 Al()BR ( + ) 0 1 -1 H()4 FZ (C++/Parser Mapping) ES()EH ( + ) 0 1 -1 H()4 FZ (Getting Started Guide) ES()EH ( + ) 0 1 -1 H ( ) EH ( + ) 0 1 -1 H ( ) EH ( + ) 0 1 -1 H ( ) EH ( + ) 0 1 -1 H ( ) EH ( + ) 0 1 -1 H ( ) EH ( + ) 0 1 -1 H ( ) EH ( +) Ea()BR ( + ) 0 P (Copyright © 2005-2023 Code Synthesis.) EP ( + + ) 0 P (Permission is granted to copy, distribute and/or modify this + document under the terms of the + ) R0 2 A (GNU Free + Documentation License, version 1.2) EA (; with no Invariant Sections, + no Front-Cover Texts and no Back-Cover Texts. + ) EP ( + + ) 0 P (This document is available in the following formats: + ) R1 2 A (XHTML) EA (, + ) R2 2 A (PDF) EA (, and + ) R3 2 A (PostScript) EA (.) EP()} D +/tH {()0 1 -1 H (Table of Contents) EH()} D +/FD 2 D +/Dy 2 D +/cD [16#F0 16#F0 16#F0] D +/FW 0.6 D +/FU [16#00 16#00 16#00] D +/ET {/RM f D /A0 3 D /PN SN D /OU t D /Ou t D /W IW D /LL W D D1 + Ms not TP and{Ip}if /TF f D} D + +%-- End of variable part -- +/MySymbol 10 dict dup begin + /FontType 3 D /FontMatrix [.001 0 0 .001 0 0 ] D /FontBBox [25 -10 600 600] D + /Encoding 256 array D 0 1 255{Encoding exch /.notdef put}for + Encoding (e) 0 get /euro put + /Metrics 2 dict D Metrics begin + /.notdef 0 D + /euro 651 D + end + /BBox 2 dict D BBox begin + /.notdef [0 0 0 0] D + /euro [25 -10 600 600] D + end + /CharacterDefs 2 dict D CharacterDefs begin + /.notdef {} D + /euro{newpath 114 600 moveto 631 600 lineto 464 200 lineto 573 200 lineto + 573 0 lineto -94 0 lineto 31 300 lineto -10 300 lineto closepath clip + 50 setlinewidth newpath 656 300 moveto 381 300 275 0 360 arc stroke + -19 350 moveto 600 0 rlineto -19 250 moveto 600 0 rlineto stroke}d + end + /BuildChar{0 begin + /char E D /fontdict E D /charname fontdict /Encoding get char get D + fontdict begin + Metrics charname get 0 BBox charname get aload pop setcachedevice + CharacterDefs charname get exec + end + end}D + /BuildChar load 0 3 dict put /UniqueID 1 D +end +definefont pop + +/Cd {aload length 2 idiv dup dict begin {D} repeat currentdict end} D +/EX {EC cvx exec} D +/DU {} d +/BB {pop pop}d +/ie {ifelse} d +/E {exch} d +/M {moveto} d +/R {rmoveto} d +/L {lineto} d +/RL {rlineto} d +/CP {currentpoint} d +/SW {stringwidth} d +/GI {getinterval} d +/PI {putinterval} d +/Sg {setgray} d +/LW {setlinewidth} d +/S {dup () ne OU and{0 Co R AT 3 eq LB and HF not and A1 0 ne A2 0 ne or and + {A2 0 32 A1 0 6 -1 roll awidthshow}{show}ie 0 Co neg R}{pop}ie + OU PH 3 eq or{/Ms t D}if} D +/U {OU{gsave CP currentfont /FontInfo get /UnderlinePosition get + 0 E currentfont /FontMatrix get dtransform E pop add newpath M dup SW pop + CJ 0 RL stroke grestore}if} D +/B {OU Br 0 gt and{CP Ts neg Ts .33 mul R gsave 0 Sg + CP newpath Ts Br mul 0 360 arc closepath UI 2 mod 0 eq{stroke}{fill}ie + grestore M CP E Ts Br 1 add mul sub E BB /Ms t D}if}D +/NP {Ms TP not or PA and OU and{TP{OR}if f1{mF k2 /mF E D /YC 0 D}if + TP TU not PM 0 eq or and{showpage}if DU Ip TE not{LA}if 0.6 LW + /CI 0 D /TP t D /Hs f D /hl 6 D /Hv 6 D /HI hi D /Ms f D}if Bs XO BO M} D +/Np {LE sub CP E pop gt PL 0 eq and{NP}if}D +/Ip {/PN PN 1 add D /Pn RM{1}{4}ie PN Ns D /PM PN SN sub 2 mod D} D +/GP {E dup 3 -1 roll get PN 1 add 2 mod get dup type /integertype eq + {get 0 get}{E pop}ie}d +/Fc {dup 2 GP exec SW pop /S1 E D dup 1 GP exec SW pop /S2 E D 0 GP exec SW + pop /S3 E D S1 0 gt{S2 2 mul S1 add S3 2 mul S1 add 2 copy lt{E}if pop}{0}ie + S2 S3 add 2 copy lt{E}if pop IW .9 mul div dup 1 gt{1 E div}{pop 1}ie}D +/OR {Df{Sd}if tp not{gsave SA{1 Sf div dup scale}if Fe{Cf{FU VC}if FW LW + 1 setlinejoin FE stroke}if /YO {60 F div dup 40 gt{pop 40}if}D /cs CS D + /cf CF D /CF 0 D /pf PF D /PF f D /Fn FN D /At AT D /AT 0 D /FN EF Hf 1 add + get D Fz Fs FS ZZ Fc Fz mul Fs FS EU Hf 1 add get dup type /arraytype eq + Cf and{VC}{pop 0 Sg}ie IW IL neg YO sub M ZZ 1 GP exec dup SW pop neg 0 R Sh + 0 IL neg YO sub M ZZ 0 GP exec Sh ZZ 2 GP exec dup SW pop IW E sub 2 div + IL neg YO sub M Sh Fz Fs FS NO{/AW IW Pn SW pop sub D AW 2 div IL neg YO sub + S1 0 gt S2 AW .45 mul gt or S3 AW .45 mul gt or{Fz 2 mul sub}if M Pn Sh}if + EU Hf get dup type /arraytype eq Cf and{VC}{pop 0 Sg}ie YY Fc /FN EF Hf get D + Hz mul HS FS IW YO M YY 1 GP exec dup SW pop neg 0 R Sh 0 YO M YY 0 GP exec Sh + YY 2 GP exec dup SW pop IW E sub 2 div YO M Sh /FN Fn D /AT At D t Pb XO SZ + SL get neg R /PF pf D grestore /CF 0 D cs cf FS}if}D +/Sh {dup () ne{CP Hz 4 div sub BB show CP CS add BB}{pop}ie}D +/Pb {/OU E D /Ou OU D /PB t D 0 0 M Ba{/Sa save D /BP t D /Fl t D RC /PL 0 D + /PH 0 D /W IW D /LE IL .7 mul D /EO 0 D SI ZF /YA 0 D /BO 0 D /C1 () D + BA 0 Ts neg R Bb{Xl Yl Xh Yh}if Bb CP Sa restore M + {/Yh E D /Xh E D /Yl E D /Xl E D}if /Fl t D}if + BL /OU t D /HM f D /Ou t D /PB f D} D +/Bs {/BP Ba not D}D +/reencodeISO { + dup dup findfont dup length dict begin{1 index /FID ne{D}{pop pop}ie}forall + /Encoding ISOLatin1Encoding D currentdict end definefont} D +/ISOLatin1Encoding [ +/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef +/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef +/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef +/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef +/space/exclam/quotedbl/numbersign/dollar/percent/ampersand/quoteright +/parenleft/parenright/asterisk/plus/comma/hyphen/period/slash +/zero/one/two/three/four/five/six/seven/eight/nine/colon/semicolon +/less/equal/greater/question/at/A/B/C/D/E/F/G/H/I/J/K/L/M/N +/O/P/Q/R/S/T/U/V/W/X/Y/Z/bracketleft/backslash/bracketright +/asciicircum/underscore/quoteleft/a/b/c/d/e/f/g/h/i/j/k/l/m +/n/o/p/q/r/s/t/u/v/w/x/y/z/braceleft/bar/braceright/asciitilde +/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef +/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef +/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef +/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef +/.notdef/space/exclamdown/cent/sterling/currency/yen/brokenbar +/section/dieresis/copyright/ordfeminine/guillemotleft/logicalnot +/hyphen/registered/macron/degree/plusminus/twosuperior/threesuperior +/acute/mu/paragraph/periodcentered/cedilla/onesuperior/ordmasculine +/guillemotright/onequarter/onehalf/threequarters/questiondown +/Agrave/Aacute/Acircumflex/Atilde/Adieresis/Aring/AE/Ccedilla +/Egrave/Eacute/Ecircumflex/Edieresis/Igrave/Iacute/Icircumflex +/Idieresis/Eth/Ntilde/Ograve/Oacute/Ocircumflex/Otilde/Odieresis +/multiply/Oslash/Ugrave/Uacute/Ucircumflex/Udieresis/Yacute +/Thorn/germandbls/agrave/aacute/acircumflex/atilde/adieresis +/aring/ae/ccedilla/egrave/eacute/ecircumflex/edieresis/igrave +/iacute/icircumflex/idieresis/eth/ntilde/ograve/oacute/ocircumflex +/otilde/odieresis/divide/oslash/ugrave/uacute/ucircumflex/udieresis +/yacute/thorn/ydieresis +] D +[128/backslash 129/parenleft 130/parenright 141/circumflex 142/tilde +143/perthousand 144/dagger 145/daggerdbl 146/Ydieresis 147/scaron 148/Scaron +149/oe 150/OE 151/guilsinglleft 152/guilsinglright 153/quotesinglbase +154/quotedblbase 155/quotedblleft 156/quotedblright 157/endash 158/emdash +159/trademark] +aload length 2 idiv 1 1 3 -1 roll{pop ISOLatin1Encoding 3 1 roll put}for +/colorimage where{pop}{ + /colorimage { + pop pop /Pr E D {/Cv Pr D /Gr Cv length 3 idiv string D 0 1 Gr length 1 sub + {Gr E dup /i E 3 mul D Cv i get 0.299 mul Cv i 1 add get 0.587 mul add + Cv i 2 add get 0.114 mul add cvi put}for Gr} image} D +}ie +/pdfmark where{pop}{userdict /pdfmark /cleartomark load put}ie +WF{FL{reencodeISO D}forall}{4 1 FL length 1 sub{FL E get reencodeISO D}for}ie +/Symbol dup dup findfont dup length dict begin + {1 index /FID ne{D}{pop pop}ie}forall /Encoding [Encoding aload pop] + dup 128 /therefore put D currentdict end definefont D + +/SF {/CS E D SZ SL CS put FO SL FN put /YI CS LH neg mul D dup ST cvs ( ) join + CS ST cvs join C1 E join ( NF ) join /C1 E D CS NF /Wf WF FN 0 gt or D + /BW Wf{( ) SW pop}{0}ie D}D +/NF {/cS E D /cF E D cF 0 ge{FL cF get}{cF -1 eq{/Symbol}{/MySymbol}ie}ie + findfont cS scalefont setfont} D +/FS {CF or /CF E D FR SL CF put CF CF 0 ge{FN 4 mul add}if E SF} D +/PC {SH /BP f D fin not GL not and{NL}if /HM t D /LL LS D} D +/BS {/TX E D Wf{/fin f D /CW 0 D /LK 0 D /SC 0 D + /RT TX D {RT ( ) search{/NW E D pop /RT E D /WH NW SW pop D CW WH add LL gt + {TX SC LK SC sub 1 sub NN GI GL{SH cF cS OC + 2 copy cS ne E cF ne or{NF}{pop pop}ie}{PC /CW WH BW add D}ie + /SC LK D} + {GL{JC}if + /CW CW WH add BW add D /HM t D}ie /GL f D /Ph f D + /LK LK NW length 1 add add D}{pop exit}ie}loop + /fin t D TX SC LK SC sub GI SH RT () ne{GL not{CC}if}if + /LC TX length D /WH RT SW pop D CW WH add Hy{HC SW pop add}if LL gt + {RT GL{SH cF cS OC 2 copy cS ne E cF ne or{NF}{pop pop}ie + Hy{/Ph t D}if /LL LS D}{NL /LL LS D SH}ie} + {RT PC Hy{CC}if /Ph Ph Hy or D}ie RT () ne{/GL t D /HM t D}if} + {TX SW pop LL le{TX SH}{/NW () D 0 2 TX length 1 sub + {/CW E D TX 0 CW GI dup SW pop LL gt{pop NW SH /HM t D NL/LL W XO sub MR sub D + /CW CW 2 sub NN D /TX TX CW TX length CW sub GI D TX BS exit} + {/NW E D}ie}for}ie}ie /HM t D}D +/CC {C0 length 0 gt{JC}if /C0 [C1 L1 YA YB Mf NS NB TB AF Bw] D + /C1 () D /L0 L1 D /YA 0 D /YB 0 D /Mf 0 D /NS 0 D /NB 0 D}D +/JC {C0 aload length 0 gt{pop pop pop NB add /NB E D NS add /NS E D + dup Mf gt{/Mf E D}{pop}ie dup YB gt{/YB E D}{pop}ie + dup YA gt{/YA E D}{pop}ie pop C1 join /C1 E D /C0 [] D}if}D +/OC {C0 length 0 gt{C1 L1 L0 sub YA YB Mf NS NB TB AF Bw GL C0 aload pop + /Bw E D /AF E D /TB E D /NB E D /NS E D /Mf E D /YB E D /YA E D /C0 [] D + /L1 E D /C1 E D Ph{HC SH}if NL /GL E D /Bw E D /AF E D /TB E D /NB E D /NS E D + /Mf E D /YB E D /YA E D /L1 E D /LL W L1 sub XO sub MR sub WH sub D /CW 0 D + C1 E join /C1 E D}if}D +/BT {/LB t D dup length string copy RS dup dup () ne E ( ) ne and + {/CI 0 D /LS LL D /LL W L1 sub XO sub MR sub D BS} + {dup ( ) eq{/GL f D}if dup () eq L1 0 eq or{pop}{SH /BP f D /Ph f D}ie}ie + /LB f D} D +/BL {CP E pop XO E M} D +/NL {JC /GL f D /SK W XO sub MR sub L1 sub TB{Bw add}if D + /YA LF{Mf HM Fl not and PF or{LH mul}if}{0 /LF t D}ie YA 2 copy lt{E}if pop D + C1 () ne{/FB YB Mf SA{Sf mul}if 4 div 2 copy lt{E}if pop D}if Fl{/Ya YA D}if + CP E pop YA sub YB sub LE neg lt Fl not and PB not and{NP}if NT TL BL + OU PF not and PB or{/RE L1 TB{Bw sub}if + W XO sub MR sub div YA YB add LE BO add div 2 copy lt{E}if pop D + RE 1 gt{BL 1 RE div dup scale}if}if + AT 2 le{SK AT mul 2 div YA neg R}if + AT 3 eq{0 YA neg R TB{/NB NB 1 sub D /NS NS 1 sub D}if /NB NB 1 sub NN D + /A3 NS 6 mul NB add D NS NB add 0 eq + {/A1 0 D /A2 0 D} + {NS 0 eq{/A1 SK NB div dup J gt{pop 0}if D /A2 0 D}{J A3 mul SK lt + {/A1 J D /A2 SK J NB mul sub NS div dup Ab gt{/A1 0 D pop 0}if D} + {/A1 SK A3 div D /A2 A1 6 mul D}ie}ie}ie /A1 A1 NN D /A2 A2 NN D}if + AT 4 eq{0 YA neg R PH 2 le{PD 0 lt{/PD L1 D}if PD M1 gt{/M1 PD D}if + L1 PD sub M2 gt{/M2 L1 PD sub D}if}{DV ID 1 sub get 0 ge{Lo 0 R}if}ie}if + F0 cF ne Cs cS ne or{F0 Cs NF}if + /ms Ms D /Ms f D CP FB sub + C1 cvx exec XO EO sub L1 add TB{BW sub}if dup LM gt{/LM E D}{pop}ie + PH 0 eq PH 4 eq or Ms and{HF not{/PO t D /AH t D}if + BB CP YA add E AT 3 eq LB and{A1 sub}if TB{BW sub}if E BB} + {pop pop}ie Ms HM PH 3 eq and or{/BP f D /Fl f D}if + /Lo 0 D /L1 0 D /F0 cF D /Cs cS D BP not{0 YB NN neg R}if + OU f1 and mF not and{k2 /f1 f D}if + OU PF not and PB or{RE 1 gt{RE dup scale}if}if /Ms ms Ms or D + /C1 AF{(Cp )}{()}ie D /YA 0 D /YB 0 D BL + AT 4 eq LB not and PH 3 ge and + {ID DV length lt{DV ID get dup 0 ge{DO E sub /Lo E D /L1 Lo D}{pop}ie + /ID ID 1 add D}if}if /T t D CD{/LN LN 1 add D PD}if + /PD -1 D /NS 0 D /NB 0 D /TB f D /Ph f D /Mf 0 D /HM f D} D +/RS {/TM E D /CN 0 D TM{10 eq{TM CN ( ) PI}if /CN CN 1 add D}forall + /CN 0 D /BK HM EN and{0}{1}ie D TM + {dup 32 ne{TM CN 3 2 roll put /CN CN 1 add D /BK 0 D} + {pop BK 0 eq{TM CN 32 put /CN CN 1 add D}if /BK 1 D}ie}forall + TM 0 CN GI dup dup () ne E ( ) ne and + {dup CN 1 sub get 32 eq{/EN f D}{/EN t D}ie}if} D +/join {2 copy length E length add string dup 4 2 roll 2 index 0 3 index + PI E length E PI}d +/WR {(\n) search{dup () ne BP not or + {Li 4 le CP E pop YI Li mul add LE add 0 lt and PL 0 eq and{NP}if + SH NL pop /Li Li 1 sub D WR}{pop pop WR}ie}{SH}ie /CI 0 D /BP f D} D +/SH {dup dup () ne E ( ) ne and PF or CS Mf gt and{/Mf CS D}if + T not Wf and{( ) E join /T t D}if dup BP{/MF CS D}if + AT 3 eq{2 copy length dup 0 gt{/NB E NB add D + {( ) search{/NS NS 1 add D pop pop}{pop exit}ie}loop}{pop pop}ie}if + CD PD 0 lt and{dup DC search{SW pop /PD E L1 add D pop pop}{pop}ie}if + 0 Np dup SW pop L1 add /L1 E D dup () ne + {C1 (\() join E join (\)) join AU AF and UF or Wf and{( U ) join}if + sF{( s ) join}if ( S ) join + /C1 E D dup length 1 sub get 32 eq /TB E D /Bw BW D}{pop pop}ie} D +/BG {AI LG BC add add 0 eq} D +/ON {OU{Ty AR AI NN get dup 1 add Ln Ns Ty 2 mod 0 eq{(. )}{(\) )}ie join + dup SW pop neg 0 R CP E 0 lt{0 E M}{pop}ie CP BB show /Ms t D}if} D +/Ln {AR AI 3 -1 roll put}D +/SP {dup CI lt BP not and{dup CI sub 0 E R /CI E D}{pop}ie} D +/BN {PF{WR /HM f D}{BT NL}ie} D +/NN {dup 0 lt{pop 0}if} D +/h {(h) HI ST cvs join cvx exec dup 1 get E Nf{0 get E join}{pop}ie} D +/H {/fn FN D /Hi E 1 add D 1 sub /HL E D /H2 HL 2 add D /GS EZ H2 get D + E Tm H2 get GS mul BE dup 0 gt{1 sub}{pop EG H2 get dup 0 lt{pop AT}if}ie NA + WW Np /SL SL 1 add D /FN EF H2 get D GS Ey H2 get FS + EU H2 get Sc Hs not HL Hl lt and Hs HL hl lt and or Hi 0 eq or + {/HI Hi D /Hs t D /hl HL D /Hv HL D}if HL Hl lt{/hi Hi D}if + Nf HI 0 gt and{(h) Hi ST cvs join cvx exec 0 get WB}if + /HF t D /AH f D /PO f D} D +/EH {Bm H2 get GS mul BE OA /SL SL 1 sub NN D /CF 0 D /FN fn D + SZ SL get FR SL get FS /HF f D /GS Ts D ()Ec} D +/P {E PF{WR}{PO{EP}{BN}ie Ts 4 mul Np AE not{Tm 0 get Ts mul neg SP}if + dup 0 ge AH and{Pi Pd}if}ie 1 sub dup 0 lt{pop AV AL get}if /AT E D /PO t D} D +/EP {PF{WR}{BN Ts 4 mul Np}ie AE not{Bm 0 get Ts mul neg SP}if + /AT AV AL get D /PO f D} D +/BE {E PO{EP}{BN}ie Ts 4 mul Np neg SP} D +/HR {/Aw W EO sub D /RW E dup 0 gt{Aw mul}{neg}ie dup Aw gt{pop Aw}if D /RZ E D + E BN Ts neg SP 1 sub 2 div Aw RW sub mul EO add CP E pop M PF{0 Ps neg R}if + 0 Np OU{gsave RZ LW Cf{Hc VC}{0 Sg}ie CP BB RW 0 RL CP BB stroke grestore}if + /CI 0 D /BP f D PF not{Ts neg SP}if /Ms t D} D +/AD {I NL EG 14 get dup 0 lt{pop AT}if NA /AE t D Tm 14 get Ts mul neg SP + Cf{EU 14 get dup -1 eq{pop CA CL get}if Sc}if} D +/DA {BN ()ES OA /AE f D ()Ec Bm 14 get Ts mul neg SP} D +/PR {/MW E D /Li E D Tm 1 get Ps mul BE 0 NA /FN Fp D /PF t D SI /SL SL 1 add D + /CF 0 D Ps CS mul Ts div MW WC mul CS mul Ts div dup LL gt PL 0 eq and + {LL div div}{pop}ie Ey 1 get FS CP E pop LE add YI neg div cvi dup Li lt + AH and{4 lt YI Li mul 5 mul LE add 0 gt or PL 0 eq and{NP}if}{pop}ie + EU 1 get Sc /GS Ps D}D +/RP {WR NL () /PF f D SI /FN 0 D ES Bm 1 get Ps mul neg SP OA /GS Ts D} D +/SI {/XO Lm 15 get BC NN mul Lm 16 get AI UI sub NN mul add + Lm 17 get UI NN mul add Lm 20 get LG NN mul add Ts mul + PF{Lm 1 get Ps mul add}if EO add D + /MR Rm 15 get BC NN mul Rm 16 get AI UI sub NN mul add + Rm 17 get UI NN mul add Rm 20 get LG NN mul add Ts mul + PF{Rm 1 get Ps mul add}if D /LL W XO sub MR sub D} D +/DT {/cC E D BN /LG LG 1 sub D SI /LG LG 1 add D WW 2 div Np BL} D +/DD {WB Cc 0 eq cC 0 eq and L1 0 eq or Lm 20 get Ts mul L1 sub TB{BW add}if + Ts 2 div lt or NL /LF E D SI BL /cC 0 D} D +/DL {Dc LG Cc put /Cc E D BG{Tm 18 get Ts mul BE}{BN}ie /LG LG 1 add D BL} D +/LD {BN LG 0 gt{/LG LG 1 sub D}if /Cc Dc LG get D SI + BG{()Bm 18 get Ts mul BE}if BL} D +/UL {BG{Tm 17 get Ts mul BE}{BN}ie NR AI NN 0 put /UI UI 1 add D + /AI AI 1 add D SI BL} D +/LU {BN /UI UI 1 sub D /AI AI 1 sub D SI BG{()Bm 17 get Ts mul BE}if BL} D +/OL {E BG{Tm 16 get Ts mul BE}{BN}ie TR AI NN Ty put /Ty E D NR AI NN 1 put + /AI AI 1 add D SI BL 1 Ln} D +/LO {BN /AI AI 1 sub D /Ty TR AI get D SI BG{()Bm 16 get Ts mul BE}if BL} D +/LI {E BN -1 SP /BP f D /CI 0 D 0 Np NR AI 1 sub NN get 1 eq + {dup dup 0 gt E 4 le and{/Ty E D}{pop}ie + /L1 L1 Ty AR AI NN get Ns SW pop XO sub dup 0 lt{pop 0}if add D ( ON )} + {pop ( B )}ie C1 E join /C1 E D CS Mf gt{/Mf CS D}if BL} D +/BQ {Tm 15 get Ts mul BE /BC BC 1 add D SI BL} D +/QB {Bm 15 get Ts mul BE /BC BC 1 sub D SI BL} D +/Al {E EP 1 sub dup 0 lt{pop AV AL get}if NA} D +/Ea {EP OA} D +/WB {PF{WR}{BT}ie} D +/F1 {WB /FN 0 D CS 0 FS} D +/F2 {WB /FN WI D CS 0 FS} D +/HY {/Hy t D WB /Hy f D} D +/YH {WB} D +/A {/LT E D LT 1 eq{/RN E D}if /Lh E D WB /C1 C1 ( Cp ) join D + Lc AF not and{Cl Sc}if /AF t D} D +/EA {Lc AF and{Ec}{WB}ie TL Pa AF and Lh 0 ne and + {( \() Lh join (\)) join /AF f D WB}if /AF f D} D +/TL {C1 ( Tl ) apa /C1 E D} d +/apa {AF OU and Lh 0 ne LT 1 eq or and{LT 1 eq{RN ( /) E ST cvs join} + {(\() Lh join (\)) join}ie E join join}{pop}ie} d +/Cp {/Xc CP /Yc E D D} D +/SS {Cf{dup 0 ge{EU E get dup -1 eq{pop CA CL get}if}{pop CA CL get}ie Sc} + {pop}ie SZ SL get /SL SL 1 add D} D +/I {WB 8 SS 1 FS} D +/EM {WB 8 SS /CF CF 1 xor D 0 FS} D +/BD {WB 9 SS 2 FS} D +/TT {WB 10 SS /FN Fp D 0 FS} D +/KB {WB 11 SS /FN Fp D 2 FS} D +/CT {WB 12 SS 1 FS} D +/SM {WB 13 SS /FN Fp D 0 FS} D +/Q {/QL QL 1 add D QO QL 2 mod get La get join WB} D +/EQ {QC QL 2 mod get La get join WB /QL QL 1 sub D} D +/RO {WB -1 SS /CF 0 D 0 FS} D +/SY {WB -1 SS -1 FS} D +/MY {WB -1 SS -2 FS} D +/ES {WB /SL SL 1 sub NN D /CF 0 D /FN FO SL get D SZ SL get FR SL get FS ()Ec}D +/FZ {3 sub 1.2 E exp GS mul E WB TL /C1 C1 ( Cp ) join D /SL SL 1 add D 0 FS} D +/Ef {WB TL ()ES /C1 C1 ( Cp ) join D} D +/BZ {dup /Bf E D FZ}D +/Sc {dup -1 ne Cf and{/CL CL 1 add D dup 0 eq{pop [0 0 0]}if + dup CA E CL E put VS ( VC ) join C1 E join /C1 E D}{pop}ie} D +/Ec {WB Cf{/CL CL 1 sub NN D CA CL get VS ( VC ) join C1 E join /C1 E D}if} D +/VS {dup type /arraytype eq{([) E {ST cvs join ( ) join}forall (]) join}if} D +/VC {{255 div}forall setrgbcolor} D +/Sl {dup type /integertype ne{Ds}if /La E D WB}d +/UN {WB /UF t D} D +/NU {WB /UF f D} D +/SE {WB /sF t D} D +/XE {WB /sF f D} D +/sM {/C1 C1 ( k1 ) join D}d +/eM {/C1 C1 ( k2 ) join D}d +/k1 {/YC CP E pop Ts add D /mF t D /f1 t D}d +/k2 {gsave 3 LW -9 CP E pop Ts 0.2 mul sub M -9 YC L stroke grestore /mF f D}d +/Ac {/AC E D WB}d +/Ca {eA{( \()join AC join(\) )join}if WB}d +/s {OU{gsave 0 CS .25 mul R dup SW pop CJ 0 RL stroke grestore}if}D +/CJ {AT 3 eq LB and{E dup dup length 1 sub A1 mul E + {( ) search{pop pop E A2 add E}{pop exit}ie}loop 3 -1 roll add + W CP pop sub 2 copy gt{E}if pop}if}D +/So {/Co E D} D +/SO {C1 Yo ST cvs join ( So ) join /C1 E D (j) SW pop 2 div Pd} D +/Se {E WB CS E div Pd}D +/Pd {dup type /stringtype eq{SW pop}if dup /L1 E L1 add D + ST cvs ( 0 R ) join C1 E join /C1 E D} D +/Sp {0.35 CO} D +/Sb {-0.2 CO} D +/CO {OV Io Yo put /Yo E CS mul Yo add D /Io Io 1 add D -1.5 Io mul 3 add FZ SO + CS Yo add dup YA gt{/YA E D}{pop}ie + Yo neg dup YB gt{/YB E D}{pop}ie} D +/Es {ES /Io Io 1 sub NN D /Yo OV Io get D SO} D +/SB {/N2 0 D 0 1 NI{/N E D{IX N2 get 0 lt{/N2 N2 1 add D}{exit}ie}loop + /K WS N get FC N get mul D /NY AY N2 get D /BV NY array D + 0 1 NY 1 sub{/TM K string D currentfile TM readhexstring pop pop BV E TM put} + for BM N BV put /N2 N2 1 add D}for} D +/IC [{/MA E D /MB 0 D}{2 div /MA E D /MB MA D}{/MB E CS sub D /MA CS D} + {pop /MA YS AB mul D /MB 1 AB sub YS mul D}{pop /MA 0 D /MB 0 D}] D +/IP {BV N get /N N 1 add D} D +/II {/K E D IX K get 0 lt{/EC E D}if /TY E D + TY 4 eq{/Y E D /X E D}if TY 3 eq{/AB E D}if + /XW AX K get D /YW AY K get D /IS SG IT K get get D /XS XW IS mul D + /YS YW IS mul D YS IC TY get exec /MA MA Fl not{3 add}if D} D +/IM {II /ty TY D /xs XS D /ys YS D /ya YA D /yb YB D /ma MA D /mb MB D /k K D + /ec EC D /BP f D /CI 0 D WB TL L1 xs add dup XO add MR add W gt + {pop /ma ma Fl{3 add}if D NL /YA ma D /YB mb D /YS ys D /L1 xs D} + {/L1 E D ma YA gt{/YA ma D}if mb YB gt{/YB mb D}if}ie /TB f D + OU{CP E pop YS sub LE neg lt Fl not and PB not and{NP /YA ma D /YB mb D}if + /BP f D ty ST cvs ( ) join IX k get 0 lt{(\() join ec join (\) ) join}if + k ST cvs join ty 3 eq{AB ST cvs ( ) join E join}if + ty 4 eq{X ST cvs ( ) join Y ST cvs join ( ) join E join}if C1 E join + ( DI ) join FP 2 eq FP 1 eq AF and or{( FM ) join}if + ( Il Cp ) apa /C1 E D /EN f D}if /HM t D /T f D} D +/DI {II /Xc CP /Yc E D D /YN YW neg D /HM t D /CI 0 D /K2 IX K get D gsave + TY 4 eq{OX X IS mul add OY FY add YS sub Y IS mul sub} + {/FY YS D CP MB sub 2 copy /OY E D /OX E D}ie + translate K2 0 ge{/DP AZ K2 get D /BV BM K2 get D XS YS scale /N 0 D XW YW DP + [XW 0 0 YN 0 YW] {IP} FC K2 get 1 eq{image}{f 3 colorimage}ie} + {EX}ie grestore XS 0 R /Ms t D} D +/FM {gsave 0 Sg CP MB sub translate XS neg 0 M 0 YS RL XS 0 RL 0 YS neg RL + XS neg 0 RL stroke grestore} D +/NA {/AT E D /AL AL 1 add D AV AL AT put} D +/OA {AL 0 gt{/AL AL 1 sub D /AT AV AL get D}if} D +/D1 {/BR {CP E pop E BN Mb{CP E pop eq{0 YI R}if}{pop}ie} D + /Sn {OU{C1 E ST cvs join ( Ld ) join /C1 E D}{pop}ie} D} D +/D1 {/BR {BN} D /Sn {OU {C1 E ST cvs join ( Ld ) join /C1 E D} {pop} ie} D} D +/TC {/TF t D /ML 0 D HN{SW pop dup ML gt{/ML E D}{pop}ie}forall NP /RM RM not D + RC /OU Tc D Ep /PN 0 D Ms not TP and{Ip}if /W IW ML sub Ts sub D + /A0 0 D TH{/BR {( ) join BT} D /Sn {pop} D /Au () D}if} D +/TN {0 eq{E EA PF HF or not XR and{HN E get Xr}{pop}ie} + {OU{Tn 0 ge{() BN}if /Tn E D}{pop}ie WB}ie} D +/NT {OU LB not and Tn 0 ge and{PL 0 eq{Ms not{CS CF FS}if CP dup + /y E YA sub D W 9 sub CS -1.8 mul XO L1 add 2 add{y M (.) show}for + HN Tn get dup SW pop IW E sub y M show CP BB M}if /Tn -1 D}if} D +/Ld {/DN E D HN DN Pn put [/View [/XYZ -4 Fl{PS}{CP YA add US E pop}ie null] + /Dest DN ST cvs cvn /DEST pdfmark} D +/C {ND 1 eq{1 sub}if TI mul /XO E D NL Nf not{pop()}if 0 3 -1 roll 1 A} D +/OP {BP not{NP}if PN 2 mod 0 eq{/Ms t D NP}if}D +/Ep {Xp PN 2 mod 0 eq and OU and{/Pn (-) D showpage /PM 1 D LA}if}D +/Dg [73 86 88 76 67 68 77] D +/Rd [0 [1 1 0][2 1 0][3 1 0][2 1 1][1 1 1][2 2 1][3 3 1][4 4 1][2 1 2]] D +/Ns {/m E D /c E 32 mul D /j m 1000 idiv D /p j 12 add string D + c 96 le m 0 gt and{c 32 le {/i 0 D /d 77 D /l 100 D /m m j 1000 mul sub D + j -1 1 {pop p i d c add put /i i 1 add D}for + 4 -2 0 {/j E D /n m l idiv D /m m n l mul sub D /d Dg j get D + n 0 gt {/x Rd n get D x 0 get -1 1 {pop p i d c add put /i i 1 add D}for + p i x 1 get sub Dg x 2 get j add get c add put}if /l l 10 idiv D + }for p 0 i GI} + {/i ST length 1 sub D m {1 sub dup 0 ge{dup 26 mod c add 1 add + ST i 3 -1 roll put 26 idiv dup 0 eq{pop exit}if}if /i i 1 sub D}loop + ST i ST length i sub GI}ie} + {m p cvs}ie} D +/US {matrix currentmatrix matrix defaultmatrix matrix invertmatrix + matrix concatmatrix transform} D +/GB {Gb{US}if}D +/Tl {/Rn E D Xc CP pop ne{ + [/Rect [Xc 1 sub Yc cS 0.25 mul sub GB CP E 1 add E cS 0.85 mul add GB] + /Subtype /Link /Border [0 0 Cf Lc and LX and AU or{0}{1}ie] Rn type + /nametype eq {/Dest Rn}{/Action [/Subtype /URI /URI Rn] Cd}ie + /ANN pdfmark}if} D +/Il {/Rn E D [/Rect [Xc Yc GB Xc XS add Yc YS add GB] /Subtype /Link + /Border [0 0 0] Rn type /nametype eq{/Dest Rn} + {/Action [/Subtype /URI /URI Rn] Cd}ie /ANN pdfmark} D +/XP {[{/Z Bz 2 div D Z 0 R Z Z RL Z neg Z RL Z neg Z neg RL Z Z neg RL + Fi cH 1 eq and{fill}if} {Bz 0 RL 0 Bz RL Bz neg 0 RL 0 Bz neg RL + Fi cH 1 eq and{fill}if} {0 -5 R Bz 0 RL 0 21 RL Bz neg 0 RL 0 -21 RL}]} D +/MS {/Sm E D WB}D +/O {BN()0 Sm BX} D +/BX {/Bt E D Bt 2 lt{/Ch E D CS 0.8 mul}{11 mul}ie W XO sub MR sub + 2 copy gt{E}if pop /HZ E D Bt 2 eq{Fi not{pop()}if ( )E join /Ft E D TT + /PF t D /MW 1 D /Li 1 D /Fw Ft SW pop D Fw HZ gt{/HZ Fw 8 add D}if + HZ ST cvs( )join}{WB Ch ST cvs( )join}ie L1 HZ add XO add MR add W gt{NL}if + Bt 2 eq{Ft ES Fw neg HM{CS sub}if Pd}if Bt ST cvs join( Bx )join + Bt 2 eq HM and{CS Pd}if C1 E join /C1 E D /L1 L1 HZ add D /T f D + ( ) Pd /PF f D Bt 2 lt{YA CS .8 mul lt{/YA CS .8 mul D}if} + {YB 5 lt{/YB 5 D}if YA 21 lt{/YA 21 D}if}ie /CI 0 D} D +/Bx {dup 2 eq{E /Bz E D}{E /cH E D /Bz CS .8 mul D}ie + OU {gsave 0 Sg XP E get exec stroke grestore}{pop}ie Bz 0 R /Ms t D}D +/SD {FD 4 mul Dy add DZ NF newpath 0 0 M DX t charpath pathbbox + 3 -1 roll sub /DY E D E dup /X1 E D sub WM mul WX DY mul add WM DG mul E div + /DF E D /DR WX DF mul DY mul WM div 2 div D} d +/Sd {gsave 0 IL Di mul neg translate IL IW atan Di 0 eq{neg}if rotate + FD 4 mul Dy add DZ NF DR X1 sub DY 2 div neg M cD VC DX show grestore} d +/Pt {/tp t D Tp{NP /Pn (TP) D 0 Tt neg R Th BN NP Ep ET RC ZF}if /tp f D} D +/RC {/AI 0 D /LG 0 D /BC 0 D /UI 0 D /PF f D /Cc 0 D /cC 0 D /Dc 10 array D + /NR [0 1 9{pop 0}for] D /La Ds D /AR 10 array D /TR 10 array D /AV 30 array D + SI /AL -1 D /AT A0 D AT NA /OV 9 array D /Yo 0 D /Co 0 D /Io 0 D /Hy f D + /Ph f D /CL -1 D Ct Sc}D +/ZF {/FR [0 1 30{pop 0}for] D /SZ [0 1 30{pop 0}for] D /FO [0 1 30{pop 0}for] D + /SL 0 D /CF 0 D /FN 0 D 0 Ts SF}D +/QO [[(\233)(\253)(\253\240)(\273)(\234)(\232)][(`)(\253)(\253\240)(\273)(')(\231)]] D +/QC [[(\234)(\273)(\240\273)(\253)(\234)(\233)][(')(\273)(\240\273)(\253)(')(`)]] D +/Hf EF length 2 sub D +/Hz EZ Hf get D +/HS Ey Hf get D +/Fz EZ Hf 1 add get D +/Fs Ey Hf 1 add get D +/LE IL D +/Ps EZ 1 get D +/Fp EF 1 get D +/XO 0 D +/YI 0 D +/CI 0 D +/FP 0 D +/WW Ts 7 mul D +/Mf 0 D +/YA 0 D +/YB 0 D +/Cs Ts D +/GS Ts D +/F0 0 D +/NS 0 D +/NB 0 D +/N 0 D +/C0 [] D +/C1 () D +/Lo 0 D +/L1 0 D +/LM 0 D +/PH 0 D +/EC 0 D +/Lh 0 D +/LT 0 D +/CH 1 string D +/ST 16 string D +/CA 9 array D +/HC (\255) D +/HM f D +/PF f D +/EN f D +/TB f D +/UF f D +/sF f D +/AE f D +/AF f D +/BP t D +/CD f D +/PA t D +/GL f D +/T t D +/HF f D +/AH f D +/SA f D +/PB f D +/f1 f D +/mF f D +/OX 0 D +/OY 0 D +/FY 0 D +/EO 0 D +/FB 0 D +/PL 0 D +/Bw 0 D +/PD -1 D +/TP f D +/tp f D +/TH t D +/Ty 4 D +/Tn -1 D +/Fl t D +/LB t D +/PM 1 D +/Ms f D +/Ba f D +/Bb f D +/Hl 3 D +/hl 6 D +/Hv 6 D +/Hs f D +/HI 0 D +/hi 0 D +/PO t D +/TE f D +/LF t D +/BO 0 D +/Sm 1 D +/Bf 3 D +/A1 0 D +/A2 0 D +/Ds 0 D +/QL -1 D +/Cb Db D +/Ct Dt D +/Cl Dl D +/AX [541] D +/AY [291] D +/IX [0] D +/IT [0] D +/AZ [8] D +/WS [541] D +/FC [3] D +/NI 0 D +/BM 1 array D +SB +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffffffffffffffffffffffffffffcfdffe1edfb +c9e0f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c7def8d9e9fa +f8fbfeffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffe4effc +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8dceafbffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +d2e4fac5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c7def8ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffd0e3f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffd0e3f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffd0e3f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffd0e3f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffd0e3f9c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffd0e3f9c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffd0e3f9c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffd0e3f9c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffd0e3f9 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +d0e3f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf88495a77482928798abc5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf88b9caf +b5cbe4c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf894a6baacc1d8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +8393a57482928a9baec5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffd0e3f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf88ea0b3626e7c2e343ac5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf86c7a898fa1b4c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +3d454d9fb3c9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8525c688b9cafc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf88d9eb15f6a77333a41c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffd0e3f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c4dcf7afc4dcb9d0e9c5ddf8c5ddf8c5ddf896a9bd2e343ac5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8b3c9e1b3c9e1c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8bdd4eeb0c6dec5ddf8c5ddf8c5ddf8c5ddf8c5ddf8b2c8e0bad0ea +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8b9d0e9b4c9e2c5ddf8c5ddf8c4dcf7bed6f047505a768595bed6f0 +c1d8f3c5ddf8c5ddf8c3dbf6c1d8f3c5ddf8b2c8e0bfd6f1c5ddf8c3dbf6 +bed6f0bed6f0c4dcf7c5ddf8c5ddf8c5ddf8bfd6f1c5ddf8b6cce5c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8b7cde6c4dcf7c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c4dcf7c0d7f2c4dcf7b7cde6c5ddf8 +c5ddf8c5ddf8c4dcf7bed6f0bed6f0c3dbf6c5ddf8c5ddf8c3dbf6c1d9f4 +b4c9e2c5ddf8b8cfe8c4dcf7c5ddf8c3dbf6c1d8f3c1d9f4b9d0e9c5ddf8 +c5ddf8c5ddf8c5ddf891a2b6333a41c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffd0e3f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf895a7bb131518252a2f2024288494a6c5ddf8c5ddf896a9bd2e343a +c5ddf8c5ddf8c5ddf8c5ddf82d33392d3339282d3325292eaec3dbc5ddf8 +c5ddf847505a2f343b373e463d454dc5ddf8c5ddf8a9bdd4282d33373e46 +282d337d8d9ec5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c2daf5363c44323940323940525c68c5ddf8a5b9d030363d1214171e2125 +30363d687583c5ddf8c5ddf87b8a9b4149522c3137212529262b30c5ddf8 +96a9bd30363d0a0b0c9aadc2c5ddf8c5ddf8c5ddf8050606454e57272c31 +22272bafc4dcc5ddf8b7cee7464e5821252925292e181b1fa6bbd2c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8a5b9d014171a252a2f22272b +48515bb8cfe8c5ddf8a8bcd430363d1012148393a5c5ddf8c5ddf87f8fa0 +1d202420242832383f292e34353b43c5ddf88b9cb021262a1e2125212529 +545f6ac1d9f4c5ddf8c5ddf891a2b6333a41c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffd0e3f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c0d7f214171a8797aac5ddf8c4dcf7b3c9e1c5ddf8c5ddf896a9bd +2e343ac5ddf8c5ddf8c5ddf8c5ddf8b7cde6c5ddf8c5ddf85a65715c6874 +c5ddf8a6bbd21e2125c5ddf8c5ddf8bfd6f1c5ddf8c5ddf85c6874687583 +c5ddf8c5ddf8bfd6f1c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf88d9eb1373e46c5ddf8c5ddf8bfd6f1c5ddf8c5ddf8c5ddf84a535d +7a899ac5ddf8c5ddf8c5ddf8c5ddf87b8a9b0303039cafc4c5ddf8bcd3ed +c5ddf8c5ddf8c5ddf82a2f359aadc2c5ddf8c5ddf8c5ddf80000008b9cb0 +c5ddf8505a65778696c5ddf8798898454e57c4dcf7a0b4ca000000a6bbd2 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8a5b9d0000000a0b4ca +c5ddf847505a7d8c9dc5ddf8c5ddf8c5ddf84149528393a5c5ddf8c5ddf8 +7f8fa049525ca2b6cc0b0d0ec5ddf8212529c0d7f28b9cb0040505b5cbe4 +c1d9f430363d96a9bdc5ddf8c5ddf891a2b6333a41c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffd0e3f9c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8a4b8cf0d0f11c2daf5c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +96a9bd2e343ac5ddf8c5ddf8c5ddf8c5ddf890a2b5505a652b30361b1e22 +4a535dc5ddf8c0d7f21e22263d454d768494bcd3edc5ddf8c5ddf88c9db1 +171a1e535d6992a3b7c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8b2c8e0171a1e454e577e8e9fc1d8f3c5ddf8c5ddf8c5ddf8 +4a535d7a899ac5ddf8c5ddf8c5ddf8c5ddf87b8a9b2b3036c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf82a2f359aadc2c5ddf8c5ddf8c5ddf8020202 +bfd6f1c5ddf8738190525c68c5ddf8424a537a899ac5ddf8c5ddf8101315 +a6bbd2c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8a5b9d00d0e10 +c5ddf8c5ddf879889847505ac5ddf8c5ddf8c5ddf84149528393a5c5ddf8 +c5ddf87f8fa05b6672b4c9e21d2024c5ddf82c3238abc0d78b9cb0252a2f +c5ddf8c5ddf85f6a77626e7bc5ddf8c5ddf891a2b6333a41c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffd0e3f9c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8a4b8cf0d0f11c2daf5c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf897a9be2d3339c5ddf8c5ddf8c5ddf8b9d0e916191ca0b4cac4dcf7 +69768547505ac5ddf8c5ddf8c2daf58a9bae1e222621262ac5ddf8c5ddf8 +c5ddf8b4cae36774820506066c7988c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8bfd6f17f8fa01416193b424ac5ddf8c5ddf8 +c5ddf84a535d7a899ac5ddf8c5ddf8c5ddf8c5ddf87b8a9b49525cc5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf82a2f359aadc2c5ddf8c5ddf8c5ddf8 +060607c5ddf8c5ddf8748292505a65c5ddf849525c758393c5ddf8c4dcf7 +0c0d0fa6bbd2c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8a5b9d0 +0c0d0fc5ddf8c5ddf8788797454e57c5ddf8c5ddf8c5ddf84149528393a5 +c5ddf8c5ddf87f8fa05e6976b7cde6202428c5ddf82f343ba8bcd48b9cb0 +252a2fc5ddf8c5ddf85f6a775f6a77c5ddf8c5ddf892a4b8323940c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffd0e3f9c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c0d7f214171a8797aac5ddf8c4dcf7b4c9e2 +c5ddf8c5ddf8bad1eb131518bdd4eec5ddf8c5ddf89cafc4272c31c5ddf8 +bed6f02a2f3547505ac5ddf8bad1ebc1d8f3c5ddf8b4c9e20e1012c0d7f2 +c5ddf8b6cce5c5ddf8c5ddf86c7988505a65c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8b7cee7c3dbf6c5ddf89cafc51f2327c5ddf8 +c5ddf8c5ddf86673815f6b78c5ddf8c5ddf8c5ddf8c5ddf87b8a9b49525c +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf82a2f359aadc2c5ddf8c5ddf8 +c5ddf8060607c5ddf8c5ddf8748292505a65c5ddf8808fa1394047bed6f0 +90a2b5000000a6bbd2c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +a5b9d00000009db0c6c4dcf7454e577b8a9bc5ddf8c5ddf8c5ddf8414952 +8393a5c5ddf8c5ddf87f8fa05e6976b7cde6202428c5ddf82f343ba8bcd4 +8b9cb0030404b2c8e0c1d8f32f343b95a7bbc5ddf8c5ddf8b7cee715181b +bed6f0c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffd0e3f9c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf895a8bc171a1d262b3022272b +8495a7c5ddf8c5ddf8c5ddf86976851d202431373ec5ddf8c5ddf83d444c +2a2f351b1e2247505a47505ac5ddf899acc1181b1f394047282d326d7b8a +c5ddf8c5ddf856616c24282d363d452b3036a5b9d0c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf88393a51b1e22394047272c318191a3 +c5ddf8c5ddf8c5ddf8a9bed5323940272c3164707ec5ddf8c5ddf87b8a9b +49525cc5ddf8c5ddf8c5ddf8c5ddf856616c2a2f35090a0b2125292a2f35 +a8bcd4c5ddf8060607c5ddf8c5ddf8748292505a65c5ddf8bdd4ee5f6a77 +1d20243e464e1d2024abc0d7c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8a5b9d014171a22272b21252948515bb8cfe8c5ddf86875832a2f35 +0d0f111c20232a2f3596a9bd7f8fa05e6976b7cde6202428c5ddf82f343b +a8bcd48b9cb021262a1b1e22202428545f6ac1d8f3c5ddf8c5ddf8c5ddf8 +6572801c2023353b43c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffd0e3f9 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8b0c6de +bcd3edc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8b7cde6c1d9f4c5ddf8c5ddf8c5ddf8c5ddf8c1d8f3adc3dac3dbf6 +c5ddf8c5ddf8c5ddf8c5ddf8b9d0e9b4c9e2c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8bed6f0aec3dbc5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8bcd3ed1b1f23c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8a5b9d01f2327c4dcf7b7cde6c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf88b9cb0394047c1d9f4b9d0e9c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +d0e3f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +b4c9e240485165717f31373e697584c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8a5b9d01f2327c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf88b9cb0394047c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffd0e3f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c4dcf79cafc48494a6b6cce5c5ddf8c5ddf87e8e9f6e7b8b6e7b8b +6e7b8b6e7b8b8a9baec5ddf8bcd3ed96a9bdc5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8b4cae39eb1c7c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffd0e3f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffd0e3f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffd0e3f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c4dcf78494a658626eb4c9e2c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffd0e3f9c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf89eb1c721262a97a9bec1d8f3c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffd0e3f9c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf86f7c8c55606bc5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffd0e3f9c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf86875835b6672c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffd0e3f9c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8bdd4ee3940477a8899c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffd0e3f9 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8b4c9e2131518212529bcd3ed +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +d0e3f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c3dbf63f474f +738190c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffd0e3f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +6976855a6571c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffd0e3f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8707e8d545e6ac5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffd0e3f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8a2b6cc1d20248b9cafbfd6f1c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffd0e3f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf892a3b7697685b7cde6c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffd0e3f9c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffff9fcfee6f0fce2eefbe2eefbe2eefbe2eefbe2eefbe2eefb +e2eefbe2eefbe2eefbe2eefbe2eefbe2eefbe2eefbe2eefbe2eefbe2eefb +e2eefbe2eefbe2eefbe2eefbe2eefbe2eefbe2eefbe2eefbe2eefbe2eefb +e2eefbe2eefbe2eefbe2eefbe2eefbe2eefbe2eefbe2eefbe2eefbe2eefb +e2eefbe2eefbe2eefbe2eefbe2eefbe2eefbe2eefbe2eefbe2eefbe2eefb +e2eefbe2eefbe2eefbe2eefbe2eefbe2eefbe2eefbe2eefbe2eefbe2eefb +e2eefbe2eefbe2eefbe2eefbe2eefbe2eefbe2eefbe2eefbe2eefbe2eefb +e2eefbe2eefbe2eefbe2eefbe2eefbe2eefbe2eefbe2eefbe2eefbe2eefb +e2eefbe2eefbe2eefbe2eefbe2eefbe2eefbe2eefbe2eefbe2eefbe2eefb +e2eefbe2eefbe2eefbe2eefbe2eefbe2eefbe2eefbe2eefbe2eefbe2eefb +e2eefbe2eefbe2eefbe2eefbe2eefbe2eefbe2eefbe2eefbe2eefbe2eefb +e2eefbe2eefbe2eefbe2eefbe2eefbe2eefbe2eefbe2eefbe2eefbe2eefb +e2eefbe2eefbe2eefbe2eefbe2eefbe2eefbe2eefbe2eefbe2eefbe2eefb +e2eefbe2eefbe2eefbe2eefbe2eefbe2eefbe2eefbe2eefbe2eefbe2eefb +e2eefbe2eefbe2eefbe2eefbe2eefbe2eefbe2eefbe2eefbe2eefbe2eefb +e2eefbe2eefbe2eefbe2eefbe2eefbe2eefbe8f2fcfdfeffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffd0e3f9c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffbfcfed6e7fac6ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8cae0f9e6f0fc +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffd0e3f9c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1eefbc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8f3f8feffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffd0e3f9c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c0d7f29fb2c8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +95a8bc47505ac5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffcfdffc9dff8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8ddebfbffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffd0e3f9 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8aec3db16191cc5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8b0c6de8fa1b4c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffeff6fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8cae0f9ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +d0e3f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8b6cce57482924b545f636f7dbad0eac5ddf87a899a515b670a0b0c +5b67735b6773b7cde6c5ddf8c5ddf86a7786a8bcd465717f505a65a6bbd2 +c5ddf8707e8d5b6773798898c5ddf8c5ddf8c5ddf891a2b690a2b5697685 +5c6874acc1d8c5ddf8c5ddf8c1d9f478879758626e92a4b88494a6c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffd0e3f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf84e57625e69769db0c67a899ab0c6dec5ddf8a2b6cc8292a4 +10131593a5b993a5b9bed6f0c5ddf8c5ddf81a1d2132383f6673818191a3 +93a5b9c5ddf89db0c66b7887363c44c5ddf8c5ddf8c5ddf8636f7d191c20 +7988986572802c3238c5ddf8c5ddf83940474e58637f8fa01c2023434b54 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffd0e3f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf830363d707e8dbed5efc5ddf8c5ddf8c5ddf8c5ddf8 +aec3db16191cc5ddf8c5ddf8c5ddf8c5ddf8c5ddf81a1d216f7c8cc5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf88ea0b3363c44c5ddf8c5ddf8c5ddf8636f7d +48515bc5ddf8c2daf50b0d0ebdd4eebcd3ed0a0c0dc0d7f2c5ddf85f6a77 +434b54c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffeff5fdc5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffd0e3f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8a3b7ce434c550c0d0f454e57b9d0e9c5ddf8 +c5ddf8aec3db16191cc5ddf8c5ddf8c5ddf8c5ddf8c5ddf81a1d21a3b7ce +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf88ea0b3363c44c5ddf8c5ddf8c5ddf8 +636f7d677482c5ddf8c5ddf8131518b1c7df9cafc41e2226c5ddf8c5ddf8 +7d8c9d434b54c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffeff5fdc5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffd0e3f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8a6bbd22024287c8b9c +c5ddf8c5ddf8b4cae3101315c5ddf8c5ddf8c5ddf8c5ddf8c5ddf81a1d21 +aabfd6c5ddf8c5ddf8c5ddf8c5ddf8c5ddf88ea0b3363c44c5ddf8c5ddf8 +c5ddf8636f7d677482c5ddf8c5ddf8131518b1c7dfc0d7f20b0d0ebed5ef +c5ddf8596470434b54c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffeff5fdc5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffd0e3f9c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8616d7a92a3b790a2b51e2226 +a6bbd2c5ddf8c5ddf8c5ddf823272c6774828d9eb1bed5efc5ddf8c5ddf8 +1a1d21aabfd6c5ddf8c5ddf8c5ddf8b9d0e98d9eb1667381262b308d9eb1 +9fb2c8c5ddf8636f7d677482c5ddf8c5ddf8131518b1c7dfc5ddf84a535d +3941486c7988202428434b54c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffeff5fd +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffd0e3f9c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf87e8e9f4f59645b6672 +95a8bcc5ddf8c5ddf8c5ddf8c5ddf8b1c7df7a8899626e7bb7cee7c5ddf8 +c5ddf8707d8db7cee7c5ddf8c5ddf8c5ddf8b0c5dd626e7b626e7b626e7b +626e7b8190a2c5ddf894a6ba96a9bdc5ddf8c5ddf86c7988bbd2ecc5ddf8 +c5ddf891a2b6738190707d8d5a6571c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +eff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c8dff8ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffd0e3f9c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8a3b7cebdd4eeb4c9e2343a4296a9bdc5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c8dff8ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffd0e3f9c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf87a899a282d33363c447d8d9ec3dbf6c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c8dff8ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffd0e3f9 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c8dff8ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +d0e3f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +b4cae3a6bad1a6bad1c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8bbd2ecb6cce5 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8b4c9e2a6bad1a6bbd2c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffd0e3f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c1d8f3b0c6dec5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8b8cfe8c2daf5c5ddf8c5ddf8c4dcf7b6cce5 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf88595a84f5964010101c1d8f3c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8758393 +4f5964c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf88292a44f5964000000 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffd0e3f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8748292b9d0e9c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8697584c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8a6bad11e2226c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8bdd4ee24282dc1d8f3c5ddf8c5ddf8c5ddf8 +2b3036b1c7dfc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffeff5fdc5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8030404c1d8f3c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +bbd2ecb6cce5c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c4dcf7 +000000c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffd0e3f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8191c20abc0d7c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8000000c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c1d8f3b0c6de +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf86c798865717fc5ddf8c5ddf8c5ddf8 +c5ddf87a899a57616dc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffeff5fdc5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c0d7f25b677321262a +202428768494c5ddf8c5ddf8c5ddf8030404c1d8f3c5ddf8c5ddf8c5ddf8 +7a899a262b301e21253d454dadc2d9c5ddf8c5ddf893a5b93c434b23272c +373e46bfd6f1c5ddf8c5ddf86673812c323824282d6d7b8ac5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf89cafc44c5560444d562c3137 +8494a6c5ddf8c5ddf8bed5ef59647021262a4b545fa3b7cec5ddf8c5ddf8 +b3c9e13d444c8190a2262b302a2f35b2c8e0c5ddf875839330363d23272c +5b6773c5ddf8c5ddf8b1c7df3e464e1c20233d444cb0c5ddc5ddf8b3c9e1 +424a53626e7b22272b5c6874c2daf5c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf839414866738123272c606c79b7cee7c5ddf8c5ddf8 +343a422a2f35697685c5ddf8c5ddf8b6cce53d444c2c32384d5661434c55 +3e464ebad1ebc0d7f22f353c626e7b24282d6d7b8abed5efc5ddf8c5ddf8 +c4dcf7000000c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffd0e3f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf88fa1b44b555f444d568190a2c4dcf7 +c5ddf8c5ddf8c5ddf8c5ddf8c1d9f42d333964707e24282d6c7988bdd4ee +c5ddf8c4dcf7657280212529272c318696a9c5ddf8c5ddf8b7cee7505a65 +262b30292e3492a4b8c5ddf87d8d9e2a2f3505060625292e2a2f358a9bae +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8acc1d849525c +25292e2d3339a3b7cec5ddf86976852a2f350000002a2f352a2f359eb1c7 +c5ddf8c5ddf8515b668696a93941481b1f238190a2c5ddf85b66722a2f35 +434b54c5ddf8c5ddf8c5ddf88b9caf606c79434b54272c317d8c9dc5ddf8 +c5ddf8b0c5dd525c6824282d697584515b67c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8171a1dafc4dcc5ddf8c5ddf8 +c5ddf8c5ddf8bfd6f10c0d0fc0d7f2c5ddf8c5ddf8c5ddf8c5ddf88495a7 +899aadc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffeff5fdc5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf85c6874373e46 +a8bcd4bdd4ee92a3b7c5ddf8c5ddf8c5ddf8030404c1d8f3c5ddf8c5ddf8 +c5ddf898aabfb7cee7c1d9f46c7988363d45c5ddf8c5ddf82125299fb3c9 +c5ddf8a3b7cec1d9f4c5ddf89cafc52b3036bfd6f1c2daf5a3b6cdc5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf890a2b50000008b9caf +abc0d721262a9fb2c8c5ddf8545e6a434b54b5cbe496a9bd24282dc5ddf8 +c5ddf8aec3db0607084a545eaabfd6a4b8cfb7cde6b0c5dd1b1e22bbd2ec +c4dcf7a1b5cbc5ddf8c5ddf83a414955606bb7cee75b6773373e46c5ddf8 +adc3da0000007a8899b7cde6252a2f9baec3c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf81214174b545fb6cce556616c57616dc5ddf8 +c5ddf8c5ddf87583934f5964c5ddf8c5ddf8b2c8e00e1012b7cde60a0b0c +8ea0b3464e5896a9bdbed6f0000000616d7ab5cbe4424a53707e8dc5ddf8 +c5ddf8c4dcf7000000c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffd0e3f9c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8454e580c0d0f0000000000000b0c0e +2d3238c1d9f4c5ddf8c5ddf8c5ddf8c1d8f30000005e6976b6cce5434c55 +6d7b8ac5ddf88495a71f2327a9bdd496a9bd0d0f11adc3dac5ddf8697584 +596470c4dcf7bad0eaabc0d7c5ddf8c5ddf8c5ddf8191c20abc0d7c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf84f5964 +72808fc5ddf8b3c9e1b2c8e0c5ddf8c5ddf8c5ddf8000000c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf830363d282d328ea0b3b7cee7a3b6cdc5ddf8c5ddf8 +a6bad11e2226c5ddf8c5ddf8c5ddf87a899a0d0e109fb3c9a8bcd40f1113 +c2daf5c5ddf83c434b677482b4cae33941482c3137c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8b7cde6090a0bc5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf81e2125a1b5cbc5ddf8c5ddf8c5ddf8c5ddf8 +3b424a454e57c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffeff5fd +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8191c20 +8fa1b4c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8030404c1d8f3c5ddf8 +c5ddf8c5ddf8bed5ef8ea0b35f6a774a535d191c20c5ddf8c5ddf8292e34 +545f6a98aabfc4dcf7c5ddf8c5ddf8a5b9d0121417768494adc3dac5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf890a2b5171a1d +c5ddf8c5ddf85a6571697685c5ddf8101315707e8d8b9caf899aad1c2023 +a9bed5c5ddf8aec3db000000aec3dbc5ddf8c5ddf8c5ddf8b7cde60d0f11 +6f7c8ca7bcd3c5ddf8c5ddf8c5ddf8060607a7bcd3c5ddf8adc2d9030303 +c1d9f4adc3da0d0e10c3dbf6c5ddf856616c6e7b8bc5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf812141795a7bbc5ddf8a2b6cc21262a +c5ddf8c5ddf8c5ddf87583934f5964c5ddf8c5ddf8b2c8e024282dc5ddf8 +1e2125acc1d85d68757d8c9dbed6f0000000afc4dcc5ddf88899ac3c434b +c5ddf8c5ddf8c4dcf7000000c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffd0e3f9c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf88595a80c0d0f000000000000000000 +000000090a0c63707dc5ddf8c5ddf8c5ddf8c1d8f3000000acc1d8c5ddf8 +8b9cb0394047c5ddf8505a655c6874c5ddf8c5ddf832383f7a899ac5ddf8 +72808f2a2f358495a7b8cfe8c5ddf8c5ddf8c5ddf8c5ddf8191c20abc0d7 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +58636f3940478b9cb0bdd4eec5ddf8c5ddf8c5ddf8c5ddf8000000c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf830363d677482c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8a6bad11e2226c5ddf8c5ddf8c5ddf87a899a3d454dc5ddf8c5ddf8 +23272ca2b6ccc1d8f30a0c0db9d0e9c5ddf88190a22c3137c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf897a9be23272cc5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8383f468191a3c5ddf8c5ddf8c5ddf8 +c5ddf8b0c5ddb1c7dfc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +eff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +0d0e10a8bcd4c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8030404c1d8f3 +c5ddf8c5ddf8c5ddf8454e57515b6790a2b5808fa114171ac5ddf8c5ddf8 +b8cfe86c7a89171a1d212529bad1ebc5ddf8c5ddf89fb3c94e5863040505 +5f6a77c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf890a2b5 +282d32c5ddf8c5ddf86b7887515b66c5ddf80506065f6a77687583687583 +687583a9bed5c5ddf8aec3db14171ac5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +a9bdd458636f0607084a535dc5ddf8c0d7f2000000bad1ebc5ddf8bed5ef +000000bad0eaadc3da1d2024c5ddf8c5ddf85d6875677482c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8121417a6bad1c5ddf8b3c9e1 +0a0b0cc4dcf7c5ddf8c5ddf87583934f5964c5ddf8c5ddf8b2c8e02b3036 +c5ddf824282db3c9e1626e7b758393bed6f0000000bed6f0c5ddf899acc1 +22272bc5ddf8c5ddf8c4dcf7000000c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c8dff8ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffffffffffffffffffffffffffff9f9f9e7e7e7 +e6e6e6e5e5e5e4e4e4e2e2e2e1e1e1e0e0e0dfdfdfdedededddddddbdbdb +dadadad9d9d9d8d8d8d7d7d7d5d5d5d4d4d4d3d3d3d2d2d2d1d1d1d0d0d0 +cecececdcdcdcccccccbcbcbcacacac9c9c9c7c7c7a1b0c198aabf97a9be +96a9bd95a7bb94a6ba93a5b992a4b892a3b72b3036000000000000000000 +0000000000000000001f2327c5ddf8c5ddf8c5ddf8c1d8f3000000bcd3ed +c5ddf89cafc41f2327c5ddf8464e58707e8dc5ddf8c5ddf8444d566f7c8c +c5ddf8c4dcf7899aad363d450a0b0c8a9baec5ddf8c5ddf8c5ddf8191c20 +abc0d7c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c1d8f37e8e9f2b30361013159cafc5c5ddf8c5ddf8c5ddf8000000 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf830363d92a3b7c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8a6bad11e2226c5ddf8c5ddf8c5ddf87a899a505a65c5ddf8 +c5ddf82a2f359aadc2b7cde608090ac2daf5c5ddf88fa1b42c3137c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8a3b7ce181b1f +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf82d33398ea0b3c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf82f353c72808fc5ddf8c5ddf8c4dcf7c5ddf8c5ddf8c5ddf81e2226 +abc0d7c5ddf8c5ddf8c2daf50a0c0dbdd4eec5ddf8717f8e14171ac5ddf8 +c5ddf8c5ddf8c5ddf8b8cfe81f232791a2b6c5ddf8c5ddf8c5ddf8c5ddf8 +8e9fb216191cc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +90a2b5060607c1d9f4c5ddf8464e588393a5c5ddf8272c317e8e9fc5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8aec3db16191cc5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8a2b6cc060708c0d7f2c5ddf8171a1e8fa1b4c5ddf8 +96a9bd141619c5ddf8adc3da1d2024c5ddf8c5ddf85d6875677482c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf81214178190a2c5ddf8 +8e9fb23b424ac5ddf8c5ddf8c5ddf87583934f5964c5ddf8c5ddf8b2c8e0 +2b3036c5ddf824282db3c9e1626e7b758393bed6f00000009aadc2c5ddf8 +748292545f6ac5ddf8c5ddf8c5ddf8191c20b0c5ddc5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c8dff8ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffc0c0c0 +1a1a1a4141414242424343434444444545454747474848484949494a4a4a +4b4b4b4c4c4c4e4e4e4f4f4f505050515151525252545454555555565656 +5757575858585a5a5a5b5b5b5c5c5c5d5d5d5e5e5e5f5f5f4e565e4b545f +4c55604d56614e57624f5964505a65515b66515b67131518000000000000 +00000000000000000000000016191cc5ddf8c5ddf8c5ddf8c1d8f3000000 +97a9bec5ddf8768595515b67c5ddf8626e7b444d56c5ddf8c5ddf81b1f23 +8ea0b3c5ddf8c5ddf8c5ddf8c5ddf85b667249525cc5ddf8c5ddf8c5ddf8 +282d339db0c6c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c2daf5434c55626e7cc5ddf8c5ddf8c5ddf8 +0f1113b7cde6c5ddf8c5ddf8c5ddf8c5ddf830363d94a6bac5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8a6bad11e2226c5ddf8c5ddf8c5ddf87a899a505a65 +c5ddf8c5ddf82a2f359aadc2c5ddf8282d329cafc5c5ddf8636f7d2c3137 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c1d8f3 +050606c0d7f2c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8111316afc4dcc5ddf8 +c5ddf8c5ddf8c5ddf895a8bc8ea0b3c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf89aadc2131518474f595c6874515b67c5ddf8c5ddf8c5ddf8 +6c7a8925292e4f5964b4c9e2c5ddf8404851404851525c6830363d14171a +c5ddf8c2daf5292e3465717f5964701c2023c1d8f3c5ddf87e8e9f454e57 +6a7786363d455d6875c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf890a2b51214172c313748515b25292eb7cee7c5ddf894a6ba16191c +4b545f5f6a77272c31b7cee7c5ddf8aec3db16191cc5ddf8c5ddf8c5ddf8 +c5ddf892a4b83d454d6a7786424a53464e58c5ddf8c5ddf8788797101315 +545f6a131518768494c5ddf8adc3da1d2024c5ddf8c5ddf85d6875677482 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf812141723272c +545e6a1c20238797aac5ddf8a1b5cb5b6773363d4525292e5b67738a9bae +b2c8e02b3036c5ddf824282db3c9e1626e7b758393bed6f0030303282d32 +525c681c202399acc1c5ddf8c5ddf8c5ddf8687583262b304f5964b7cde6 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c8dff8ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +c1c1c1676767ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffd0e3f9 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8667281060708 +00000000000000000000000002030349525cc5ddf8c5ddf8c5ddf8c1d8f3 +010101282d33535d691b1f2398aabfc5ddf8b1c7df14171a454e5730363d +2e343ac4dcf7c5ddf856616c545f6a6774822125298ea0b3c5ddf8c5ddf8 +c5ddf86c7a89252a2f5a65719db0c6c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8434c555b6672636f7d191c20a6bad1c5ddf8c5ddf8 +c5ddf8545e6a2e343a5b6773aabfd6c5ddf8c5ddf830363d94a6bac5ddf8 +c5ddf8c5ddf8bbd2ec5b67734e57620d0f115b6773707d8dc5ddf87a899a +505a65c5ddf8c5ddf82a2f359aadc2c5ddf88393a51d20243f474f2f343b +2c3137c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8333a4196a9bdc5ddf8c5ddf8c5ddf8c5ddf8a9bed51e2226c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8454e57373e46c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8b5cbe48696a98495a7bad0eac5ddf8c5ddf8 +c5ddf8c5ddf8b0c6de93a5b9bed5efc5ddf8c4dcf793a5b98c9db1bad0ea +98abc0c5ddf8c5ddf8a4b8cf7e8e9f93a5b9c1d8f3c5ddf8c5ddf8bed6f0 +92a3b77d8c9da8bcd4c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf890a2b5343a42a1b5cb8d9eb1c4dcf7c5ddf8c5ddf8c5ddf8 +b4cae38595a88191a3adc3dac5ddf8c5ddf8bfd6f199acc1c5ddf8c5ddf8 +c5ddf8c5ddf8c1d9f497a9be7c8b9ca1b5cbc5ddf8c5ddf8c5ddf8c5ddf8 +9fb3c97d8c9d9fb2c8c5ddf8c5ddf8bfd6f19baec3c5ddf8c5ddf8abc0d7 +adc3dac5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8121417 +a3b6cd8494a6b8cfe8c5ddf8c5ddf8b4cae393a5b993a5b993a5b993a5b9 +a9bdd4c0d7f29fb2c8c5ddf89cafc5c1d8f3acc1d8b1c7dfbed6f0060607 +afc4dc8595a8bed5efc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8b0c5dd93a5b9 +bfd6f1c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c8dff8ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffc2c2c2656565ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +d0e3f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8bfd6f1 +1c2024040505000000000000020202121416b6cce5c5ddf8c5ddf8c5ddf8 +c1d8f3030404b0c5dd8495a7bdd4eec5ddf8c5ddf8c5ddf8b5cbe48292a4 +8a9baec0d7f2c5ddf8c5ddf8b6cce58899ac8292a4b4cae3c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8b6cce594a6bab2c8e0c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8b0c6de8494a68798abbad0eac5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8b0c6de94a6bab8cfe8c5ddf8c5ddf89fb3c9b9d0e9 +c5ddf8c5ddf8c5ddf8c0d7f293a5b993a5b993a5b993a5b99db0c6c5ddf8 +b2c8e0a8bcd4c5ddf8c5ddf89eb1c7bad1ebc5ddf8c5ddf8bdd4eea0b4ca +8292a4515b67c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf893a5b9424a53c5ddf8c5ddf8c5ddf8c5ddf856616c7e8e9f +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf81f23278292a4c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf890a2b5343a42c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +121417b2c8e0c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8bed6f0 +060607c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffc4c4c4646464ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffd0e3f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8bad0ea49525c131618111416404851b3c9e1c5ddf8c5ddf8c5ddf8 +c5ddf8c1d8f3030404c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf890a2b58899ac +8b9cb02a2f3590a2b5c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf857616dbed5efc5ddf8c5ddf8c4dcf7535d69 +c2daf5c5ddf8c5ddf8c5ddf8c5ddf8bad1eb3f474fc4dcf7c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8bfd6f1bbd2ec +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8a9bdd4788797c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf895a7bb6e7b8b6e7b8b6e7b8b6e7b8b738291c5ddf8 +c5ddf8657280bbd2ecc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c1d9f45f6b78c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffc5c5c5636363ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffd0e3f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c3dbf65e6976c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf895a7bb6e7b8b +6e7b8b6e7b8b6e7b8b738291c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8a2b6cc +5c68745e6976a6bad1c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffeff5fdc5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8434b542e343a +92a3b7c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffc6c6c6616161ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffd0e3f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffeff5fdc5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8b3c9e1141619 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffc8c8c8606060ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffd0e3f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffeff5fdc5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf89eb1c7 +262b30c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffc9c9c95f5f5fffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffd0e3f9c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8bdd4ee8899acb4c9e2c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffeff5fd +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +8d9eb1323940c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffcacaca5d5d5dffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffd0e3f9c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8bcd3ed677482141619a9bdd4c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +eff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +7482922c31377d8d9ec5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c8dff8ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffcbcbcb5c5c5c +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffd0e3f9c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8545f6a768595c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf88393a530363d717f8ec5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c8dff8ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffcdcdcd +5b5b5bffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffd0e3f9c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf85f6a776c7988c5ddf8 +c5ddf8c5ddf8c5ddf8bed5ef363d459baec3c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf88fa1b42f353cc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c8dff8ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +cecece5a5a5affffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffd0e3f9 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf87482924b545f +c5ddf8c5ddf8c5ddf8c5ddf8bcd3ed11131690a2b5c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf89eb1c7262b30c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c8dff8ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffcfcfcf585858ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +d0e3f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8b6cce5 +282d322c3137b2c8e0c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8b6cce5121417c4dcf7c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffd1d1d1575757ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffd0e3f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +8e9fb2272c319fb3c9c2daf5c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf84f59642d33398c9db1 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffd2d2d2565656ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffd0e3f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8636f7d64707ec5ddf8c5ddf8c5ddf8c5ddf8c5ddf84b545f95a7bb +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffeff5fdc5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8b5cbe4bcd3edc5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8bed5efb4cae3c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffd3d3d3545454ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffd0e3f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf85e69766c7a89c5ddf8c5ddf8c5ddf8c5ddf8bfd6f1000000 +8797aac5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffeff5fdc5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8474f597d8d9ec5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf88a9bae404851c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffd4d4d4535353ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffd0e3f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8bbd2ec333a4191a2b6c5ddf8c5ddf8c5ddf8c5ddf893a5b9 +1e2125c2daf5c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffeff5fdc5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8b5cbe4bcd3edc5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf88a9bae404851c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffd6d6d6525252ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffd0e3f9c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8b4cae33940475f6b78bfd6f1c5ddf8c5ddf8c5ddf8c5ddf8 +95a8bc95a7bbc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffeff5fd +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8b2c8e0394148c5ddf8c5ddf8c5ddf83f474facc1d8c5ddf88a9bae +282d32202428626e7cc4dcf7c5ddf8aabfd62a2f352a2f358e9fb2c5ddf8 +c5ddf8c5ddf8a9bdd44a535d262b3057616d404851c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffd7d7d7505050ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffd0e3f9c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +eff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8262b309baec3c5ddf8a3b6cd1e2226c5ddf8b1c7df +0a0c0d92a3b7abc0d7262b307f8fa0c5ddf8c5ddf8c5ddf8474f597d8d9e +c5ddf8c5ddf8c5ddf8282d327f8fa0afc4dc2a2f35404851c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c8dff8ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffd8d8d84f4f4f +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffd0e3f9c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf86c7a8957616dc5ddf85f6a7765717fc5ddf8 +8393a5292e34c5ddf8c5ddf865717f47505ac5ddf8c5ddf8c5ddf8474f59 +7d8d9ec5ddf8c5ddf8b6cce50d0e10c4dcf7c5ddf86a7786404851c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c8dff8ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffdadada +4e4e4effffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffd0e3f9c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8b1c7df16191cc3dbf61b1f23abc0d7 +c5ddf87988983d454dc5ddf8c5ddf87786963c434bc5ddf8c5ddf8c5ddf8 +474f597d8d9ec5ddf8c5ddf8a2b6cc1b1f23c5ddf8c5ddf87d8c9d404851 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c8dff8ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +dbdbdb4d4d4dffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffd0e3f9 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8343a426a77862c3238 +c5ddf8c5ddf895a7bb121417c5ddf8c5ddf84e58635b6773c5ddf8c5ddf8 +c5ddf8474f597d8d9ec5ddf8c5ddf8c4dcf7101315bad1ebc5ddf8545e6a +404851c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c8dff8ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffdcdcdc4b4b4bffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +d0e3f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf87b8a9b050606 +738291c5ddf8c5ddf8c5ddf83239402c313748515b141619adc3dac5ddf8 +8899ac5b67732125293a41495b6773a3b6cdc5ddf8616d7a25292e4c5560 +1c2023404851c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffdedede4a4a4affffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffd0e3f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8bed5ef +93a5b9bbd2ecc5ddf8c5ddf8c5ddf8c1d8f38b9caf8191a3b4c9e2c5ddf8 +c5ddf8a9bdd493a5b993a5b993a5b993a5b9b4cae3c5ddf8c5ddf8a9bed5 +8899acb2c8e0a4b8cfc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffdfdfdf494949ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffd0e3f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffeff5fdc5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffe0e0e0474747ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffd0e3f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffeff5fdc5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8bad0eaaec3dbc5ddf8c5ddf8c5ddf8bed6f0b3c9e1 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c4dcf7b6cce5c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8b7cee7bad0eac5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +b8cfe8c1d9f4c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffe1e1e1464646ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffd1e4f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c6ddf8ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffeff5fdc5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf84e5762282d32414952c5ddf8c5ddf8c5ddf891a2b6 +333a41c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8697685 +c4dcf7c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf88595a857616dc5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8a2b6cc8b9cb0 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf85b6672697685c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf86e7b8b6e7b8bc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffff +fffffffffffffffffffffffffffffffffffff6f6f6f1f1f1ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffd7d7d7353535ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffe3effcc5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8d6e7faffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffeff5fd +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8bad0ea131518c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +bed6f0b3c9e1c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +020202c2daf5c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c4dcf7262b30abc0d7c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf87a899a +4a535dc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8b7cee7bad0eac5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8bad0ea1e2125bed6f0c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8 +ffffffffffffffffffffffffe7e7e7999999404040646464fcfcfcffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffc3c3c3151515ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffffffffffffffffbfdffd6e7fac5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8d3e5faf4f8feffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +eff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8545e6a25292e0506062a2f35363c44c5ddf8c5ddf8 +4a545e2a2f35535d69c5ddf8c5ddf8c5ddf8c5ddf86774827d8d9e434c55 +1b1e226a7786c5ddf8adc2d94a535d25292e2c3238a2b6ccc5ddf86b7887 +2a2f350000002a2f352a2f359cafc5c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf82f353c74829223272c515b66bad0eac5ddf8a8bcd4 +363c441d20242b30368494a6c5ddf8a4b8cf424a53252a2f596470363c44 +4a545ec3dbf6c5ddf895a8bc32383f292e34768595c1d8f3c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf894a6ba31373ec5ddf8 +c5ddf8c5ddf8c5ddf88393a5363c4423272c49525cc5ddf8c5ddf82f343b +1a1d211012142a2f353e464ec5ddf8c5ddf8b1c7df3e464e7f8fa0252a2f +2a2f35b4c9e2bad1eb2a2f352a2f357d8d9ec5ddf8c5ddf8c5ddf8505a65 +7482922b30363d444ca6bad1c5ddf8c5ddf890a2b531373e363d455f6a77 +8a9baec5ddf8c5ddf8c5ddf848515b7d8c9dc5ddf8c5ddf8c5ddf8c5ddf8 +a7bcd3687583c3dbf6c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c8dff8ffffffd2d2d27c7c7c242424121212030303434343fcfcfcffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffc6c6c6131313 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffffffffffffffffffffffffffffffffffafcfe +f6fafef6fafef6fafef6fafef6fafef6fafef6fafef6fafef6fafef6fafe +f6fafef6fafef6fafef6fafef6fafef6fafef6fafef6fafef6fafef6fafe +f6fafef6fafef6fafef6fafef6fafef6fafef6fafef6fafef6fafef6fafe +f6fafef6fafef6fafef6fafef6fafef6fafef6fafef6fafef6fafef6fafe +f6fafef6fafef6fafef6fafef6fafef6fafef6fafef6fafef6fafef6fafe +f6fafef6fafef6fafef6fafef6fafef6fafef6fafef6fafef6fafef6fafe +f6fafef6fafef6fafef6fafef6fafef6fafef6fafef6fafef6fafef6fafe +f6fafef6fafef6fafef6fafef6fafef6fafef6fafef6fafef6fafef6fafe +f6fafef6fafef6fafef6fafef6fafef6fafef6fafef6fafef6fafef6fafe +f6fafef6fafef6fafef6fafef6fafef6fafef6fafef6fafef6fafef6fafe +f6fafef6fafef6fafef6fafef6fafef6fafef6fafef6fafef6fafef6fafe +f6fafef6fafef6fafef6fafef6fafef6fafef6fafef6fafef6fafef6fafe +f6fafef6fafef6fafef6fafef6fafef6fafef6fafef8fbfeffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8a9bed51b1e22c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf891a2b6333a41c5ddf8c5ddf8c5ddf8c5ddf84d56611a1d21 +8292a4b9d0e99eb1c7c5ddf8515b67707d8dc5ddf8b4c9e2b1c7dfc5ddf8 +c5ddf8c5ddf8020202c2daf5c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf802020264707ebad0ea3a41498191a3c5ddf8 +adc3daa3b6cdc5ddf8a8bcd40a0b0cb1c7df9baec321262aaec3db000000 +a5b9d02f353cadc3daadc3da0d0e1092a4b8b8cfe84048518595a8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf86e7b8b515b66 +c5ddf8c5ddf8c5ddf8bdd4ee16191cb3c9e1c5ddf8a0b4cac5ddf8c5ddf8 +c5ddf87a899a4a535dc5ddf8c5ddf8c5ddf8c5ddf8acc1d80708094b545f +abc0d7a3b7ceb8cfe8c5ddf8c5ddf85b6672697685c5ddf8c5ddf8c5ddf8 +2f353c3f474fb7cde6626e7c535d69c5ddf8b5cbe41013159fb2c89cafc4 +0a0c0d768595c5ddf8c5ddf8c5ddf868758357616dc5ddf8c5ddf8c5ddf8 +c5ddf88595a8000000c1d8f3c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c1d8f3 +91a2b64b545d1717171313130303030000000808083a3a3af9f9f9ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffc9c9c9 +131313ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8a9bed51b1e22c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf891a2b6333a41c5ddf8c5ddf8c5ddf8c5ddf84d5661 +4a545ec5ddf8c5ddf8c5ddf8c5ddf85b6672373e468b9cafbdd4eec5ddf8 +c5ddf8c5ddf8c5ddf8020202c2daf5c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8020202b6cce5c5ddf8707e8d545f6a +c5ddf8c5ddf8a2b6cc6d7b8a55606b13151897a9be9baec33b424ac5ddf8 +08090ac1d9f4464e5893a5b972808f2b30368b9cb08a9bae5f6b7848515b +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf84e5863 +6b7887c5ddf8c5ddf8c5ddf8c1d9f4121417657280a0b4cac5ddf8c5ddf8 +c5ddf8c5ddf87a899a4a535dc5ddf8c5ddf8c5ddf8c5ddf8acc1d8000000 +b0c6dec5ddf8c5ddf8c5ddf8c5ddf8c5ddf85b6672697685c5ddf8c5ddf8 +c5ddf82f353c8899acc5ddf89fb2c8262b30c5ddf8808fa13f474fc5ddf8 +c5ddf8363c44768595c5ddf8c5ddf8c5ddf88292a4373e46c5ddf8c5ddf8 +c5ddf8c5ddf8bbd2eca6bad1c5ddf8c5ddf8c5ddf8b8cfe8667381282d32 +0a0b0c090a0b0000000000000000000000000404041e1e1e909090909090 +8b8b8b8686868282827d7d7d7878787373736e6e6e6969696464645f5f5f +5a5a5a5555555151514c4c4c4747474242423d3d3d3838383333332e2e2e +222222121212ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8a9bed51b1e22c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf891a2b6333a41c5ddf8c5ddf8c5ddf8c5ddf8 +4d5661768494c5ddf8c5ddf8c5ddf8c5ddf8c1d9f47f8fa02c3137101214 +9baec3c5ddf8c5ddf8c5ddf8020202c2daf5c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8050606c5ddf8c5ddf8768595 +4e5762c5ddf88d9eb1272c318292a499acc11e212592a3b79baec3424a53 +c5ddf8111316c5ddf84a545e8c9db16572802b3036687583687583687583 +7c8b9cc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +5b6773606c79c5ddf8c5ddf8c5ddf8c5ddf8b0c6de626e7b0d0e10333a41 +c5ddf8c5ddf8c5ddf87a899a4a535dc5ddf8c5ddf8c5ddf8c5ddf8acc1d8 +171a1dc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf85b6672697685c5ddf8 +c5ddf8c5ddf82f353c9baec3c5ddf8a5b9d01f2327c5ddf86d7b8a4e5863 +c5ddf8c5ddf8454e57768595c5ddf8c5ddf8c5ddf8778696444d56c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8bed6f072808f171a1d +0202030506060000000000000000000000000000000505051e1e1e8c8c8c +9696969b9b9ba0a0a0a5a5a5a9a9a9aeaeaeb3b3b3b8b8b8bdbdbdc2c2c2 +c6c6c6cbcbcbd0d0d0d5d5d5dadadadfdfdfe3e3e3e8e8e8edededf2f2f2 +f7f7f7e0e0e0444444ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8a9bed51b1e22 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf891a2b6333a41c5ddf8c5ddf8c5ddf8 +c5ddf84d5661778696c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c3dbf6 +454e57606c79c5ddf8c5ddf8c5ddf8111316b4cae3c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8050606c5ddf8c5ddf8 +7685954e5762c5ddf84d5661778696c5ddf8b7cde602020292a3b79baec3 +424a53c5ddf8111316c5ddf84a545e8c9db1899aad1d2024c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf87c8b9c454e57c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8aec3db +0d0e10adc3dac5ddf8c5ddf88a9bae3c434bc5ddf8c5ddf8c5ddf8c5ddf8 +acc1d8181b1fc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf85b6672697685 +c5ddf8c5ddf8c5ddf82f353c9baec3c5ddf8a5b9d01f2327c5ddf8a3b6cd +22272bc4dcf7c4dcf71a1d21768595c5ddf8c5ddf8c5ddf85b677365717f +c5ddf8c5ddf8c5ddf8c5ddf8b1c7df7a899abdd4eec5ddf8c5ddf8c5ddf8 +c5ddf8c1d8f396a9bd5964701d21251313130e0e0e000000000000080808 +323232f3f3f3ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe5e5e5424242ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8a9bed5 +1b1e22c5ddf8c5ddf8c5ddf8b0c5dd5b6773434c55171a1e5b67737b8a9b +c5ddf8c5ddf84d5661778696c5ddf8c5ddf8c5ddf8c5ddf8454e575a6571 +64707e191c20a4b8cfc5ddf8c5ddf8c5ddf856616c2d33395b6773a9bed5 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8050606c5ddf8 +c5ddf87685954e5762c5ddf88798ab1e2226616d7a2a2f351a1d2192a3b7 +9baec3424a53c5ddf8111316c5ddf84a545e8c9db1c4dcf73d454d272c31 +626e7b48515b5f6b78c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8adc3da1e2125c4dcf7c5ddf8c5ddf8a7bcd3343a42687583 +4e58632f343bc5ddf8c5ddf8c5ddf8bdd4ee181b1f4a535d697685c5ddf8 +c5ddf8acc1d8181b1fc5ddf8c5ddf8c5ddf8c5ddf893a5b95b67732a2f35 +31373e5b677398aabfc5ddf82f353c9baec3c5ddf8a5b9d01f2327c5ddf8 +c5ddf847505a282d332c3137282d32768595c5ddf8c5ddf8c5ddf82e343a +99acc1c5ddf8c5ddf8c5ddf8c5ddf88fa1b4000000b2c8e0c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8f1f1f1b0b0b05d5d5d1b1b1b +1515150404042b2b2bf1f1f1ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffe8e8e83f3f3fffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffeff5fdc5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +bed6f09aadc2c5ddf8c5ddf8c5ddf8bbd2ec93a5b993a5b993a5b993a5b9 +a2b6ccc5ddf8c5ddf8a7bcd3b1c7dfc5ddf8c5ddf8c5ddf8c5ddf8b0c6de +8495a78797aab9d0e9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8b1c7df94a6ba +b8cfe8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf895a7bb +c5ddf8c5ddf8b1c7dfa7bcd3c5ddf8c5ddf8acc1d88292a4afc4dca0b4ca +b8cfe8bad1eba4b8cfc5ddf898aabfc5ddf8a6bbd2b7cde6c5ddf8c5ddf8 +98abc07c8b9c93a5b9c1d8f3c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf84b545f8b9cafc5ddf8c5ddf8c3dbf69cafc5 +7d8c9d9baec3c3dbf6c5ddf8c5ddf8c5ddf8c5ddf8c3dbf69fb3c99aadc2 +c5ddf8c5ddf8bed6f09aadc2c5ddf8c5ddf8c5ddf8c5ddf8adc3da93a5b9 +93a5b993a5b993a5b9b0c5ddc5ddf89fb3c9bad1ebc5ddf8bdd4ee9cafc4 +c5ddf8c5ddf8c5ddf8aabfd6b1c7df3941489cafc5c5ddf8c5ddf8a0b4ca +343a42c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8697685383f46c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffffffffffffffff +ffffffe3e3e39d9d9d4a4a4a4c4c4cedededffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffeaeaea3d3d3dffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffeff5fdc5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8a9bed56b7887c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf873829196a9bd7381901e2226c4dcf7c5ddf8c5ddf8 +7a899a9aadc2c5ddf8c5ddf8c5ddf8c5ddf8c5ddf85a65719eb1c7c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffffffffff +fffffffffffffffffffffffffffffffffffff3f3f3ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffededed3b3b3bffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffeff5fdc5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf88b9caf6e7b8b6e7b8b6e7b8b6e7b8b7d8d9ec5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf87e8e9f525c68778696bad1ebc5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffefefef383838ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffeff5fd +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffffffffffffffffffffff1f1f1363636ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffffffffffffffffffffffffffffffffff9fcfe +e0edfbcde2f9cce1f9cce1f9cce1f9cce1f9cce1f9cce1f9cce1f9cce1f9 +cce1f9cce1f9cce1f9cce1f9cce1f9cce1f9cce1f9cce1f9cce1f9cce1f9 +cce1f9cce1f9cce1f9cce1f9cce1f9cce1f9cce1f9cce1f9cce1f9cce1f9 +cce1f9cce1f9cce1f9cce1f9cce1f9cce1f9cce1f9cce1f9cce1f9cce1f9 +cce1f9cce1f9cce1f9cce1f9cce1f9cce1f9cce1f9cce1f9cce1f9cce1f9 +cce1f9cce1f9cce1f9cce1f9cce1f9cce1f9cce1f9cce1f9cce1f9cce1f9 +cce1f9cce1f9cce1f9cce1f9cce1f9cce1f9cce1f9cce1f9cce1f9cce1f9 +cce1f9cce1f9cce1f9cce1f9cce1f9cce1f9cce1f9cce1f9cce1f9cce1f9 +cce1f9cce1f9cce1f9cce1f9cce1f9cce1f9cce1f9cce1f9cce1f9cce1f9 +cce1f9cce1f9cce1f9cce1f9cce1f9cce1f9cce1f9cce1f9cce1f9cce1f9 +cce1f9cce1f9cce1f9cce1f9cce1f9cce1f9cce1f9cce1f9cce1f9cce1f9 +cce1f9cce1f9cce1f9cce1f9cce1f9cce1f9cce1f9cce1f9cce1f9cce1f9 +cce1f9cce1f9cce1f9cce1f9cce1f9cce1f9cce1f9cce1f9d7e8faf2f7fd +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +eff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c8dff8ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffffffffffffffffffffffffffff4f4f4333333 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +d8e8fac5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +cce1f9feffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c8dff8ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffffffffffffffffffffffffffffffffff6f6f6 +313131ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fafcfefafcfefafcfefafcfefafcfefafcfefafcfefafcfefafcfefafcfe +fafcfefafcfefafcfefafcfefafcfefafcfefafcfefafcfefafcfefafcfe +fafcfefafcfefafcfefafcfefafcfefafcfefafcfefafcfefafcfefafcfe +fafcfefafcfefafcfefafcfefafcfefafcfefafcfefafcfefafcfefafcfe +fafcfefafcfefafcfefafcfefafcfefafcfefafcfefafcfefafcfefafcfe +fafcfefafcfefafcfefafcfefafcfefafcfefafcfefafcfefafcfefafcfe +fafcfefafcfefafcfefafcfefafcfefafcfefafcfefafcfefafcfefafcfe +fafcfefafcfefafcfefafcfefafcfefafcfefafcfefafcfefafcfefafcfe +fafcfefafcfefafcfefafcfefafcfefafcfefafcfefafcfefafcfefafcfe +fafcfefafcfefafcfefafcfefafcfefafcfefafcfefafcfefafcfefafcfe +fafcfefafcfefafcfefafcfefafcfefafcfefafcfefafcfefafcfefafcfe +fafcfefafcfefafcfefafcfefafcfefafcfefafcfefafcfefafcfefafcfe +fafcfefafcfefafcfefafcfefafcfefafcfefafcfefafcfefefeffffffff +ffffffc6def8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8f1f7fdffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c8dff8ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +f9f9f92f2f2fffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffeff5fd +d1e4f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c9e0f9 +e2eefbffffffc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8eff5fdffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c8dff8ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffbfbfb2c2c2cffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffffffffffffffffffffffffffffffffffefeff +cae0f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8f3f8fec5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8eff5fdffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffdfdfd2a2a2affffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +f2f7fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8e0edfbc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8eff5fdffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff282828ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffff0f6fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8deecfbc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8eff5fdffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffeff5fdc5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff282828ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffff0f6fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8deecfbc5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8eff5fdffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffeff5fdc5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffff282828ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffff0f6fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8deecfbc5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8eff5fdffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffeff5fdc5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff282828ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffff0f6fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8deecfbc5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8eff5fd +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffeff5fd +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8b5cbe4bcd3edc5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8bed5efb4cae3c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff282828ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffffffffff0f6fdc5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8deecfbc5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +eff5fdffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +eff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8474f597d8d9e +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf88a9bae404851c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c8dff8ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff282828 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffffffffffffffff0f6fdc5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8deecfb +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8eff5fdffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8b5cbe4 +bcd3edc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf88a9bae404851c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c8dff8ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +282828ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffffffffffffffffffffff0f6fdc5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +deecfbc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8eff5fdffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8b2c8e0394148c5ddf8c5ddf8c5ddf83f474f +acc1d8c5ddf88a9bae282d32202428626e7cc4dcf7c5ddf8aabfd62a2f35 +2a2f358e9fb2c5ddf8c5ddf8c5ddf8a9bdd44a535d262b3057616d404851 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c8dff8ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffff282828ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffffffffffffffffffffffffffff0f6fdc5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8bed5efa6bad1a6bad1bad1ebc5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8b9d0e9 +b9d0e9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c3dbf6aec3dbc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8bdd4eea6bad1 +a6bad1bbd2ecc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8deecfbc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8eff5fdffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8262b309baec3c5ddf8a3b6cd +1e2226c5ddf8b1c7df0a0c0d92a3b7abc0d7262b307f8fa0c5ddf8c5ddf8 +c5ddf8474f597d8d9ec5ddf8c5ddf8c5ddf8282d327f8fa0afc4dc2a2f35 +404851c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c8dff8ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff282828ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffffffffffffffffffffffffffffffffff0f6fd +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8aabfd64f59641a1d218393a5c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +64707e667381c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8b3c9e1111316c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8a7bcd3 +4f5964181b1f8798abc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8deecfbc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8eff5fdffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf86c7a8957616dc5ddf8 +5f6a7765717fc5ddf88393a5292e34c5ddf8c5ddf865717f47505ac5ddf8 +c5ddf8c5ddf8474f597d8d9ec5ddf8c5ddf8b6cce50d0e10c4dcf7c5ddf8 +6a7786404851c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff282828ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +f0f6fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf84149528393a5c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf864707e667381c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c3dbf6aec3dbc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf83d444c8798abc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8deecfbc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf88899ac7482928494a6 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8bad0ea748292748292a3b7ce +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf897a9bea9bdd4c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf88797aa7482928696a9c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8eff5fdffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8b1c7df16191c +c3dbf61b1f23abc0d7c5ddf87988983d454dc5ddf8c5ddf87786963c434b +c5ddf8c5ddf8c5ddf8474f597d8d9ec5ddf8c5ddf8a2b6cc1b1f23c5ddf8 +c5ddf87d8c9d404851c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff282828ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffff0f6fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +8494a62a2f351b1f23444d56c5ddf8c5ddf8c5ddf84149528393a5c5ddf8 +c5ddf8c5ddf8a2b6cc333a411d20242c32388b9cafc5ddf8c5ddf8b3c9e1 +4d5661252a2f2b303698abc0c5ddf8c5ddf88c9db139404723272c3c434b +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8a3b7ce +414952292e346774826b7887c5ddf8c5ddf87f8fa02a2f35333a418797aa +c5ddf8c5ddf85c687472808f2e343a363d459eb1c7c5ddf8c5ddf898abc0 +383f4630363d49525c667381c5ddf8c4dcf76e7b8b262b303d444c93a5b9 +c5ddf8c5ddf8c5ddf8353b438d9eb12f353c2125299baec3c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8697685626e7b2b3036424a53a3b6cd +c5ddf8c5ddf865717f2a2f35394047c5ddf8c5ddf8c5ddf84c5560454e57 +282d33626e7b2c32389cafc4c5ddf855606b64707e252a2f4e5863adc2d9 +c5ddf8c5ddf8c5ddf83d444c8798abc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8deecfbc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf892a3b7697584 +25292ec5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8bbd2ec8190a2363d45 +717f8ec5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf85b66728292a4c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf890a2b5657280292e34c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8eff5fdffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffeff5fdc5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +343a426a77862c3238c5ddf8c5ddf895a7bb121417c5ddf8c5ddf84e5863 +5b6773c5ddf8c5ddf8c5ddf8474f597d8d9ec5ddf8c5ddf8c4dcf7101315 +bad1ebc5ddf8545e6a404851c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff282828ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffff0f6fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +99acc11416198fa1b4c2daf58b9cafc5ddf8c5ddf8c5ddf84149528393a5 +c5ddf8c5ddf8c5ddf8a9bed5a6bad1c5ddf8a2b6cc090a0bb8cfe8c5ddf8 +5f6a77626e7cc4dcf7b7cee7adc3dac5ddf8c2daf5191c20a9bed5c5ddf8 +9fb3c9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +1b1e228595a8adc2d922272b4d5661c5ddf892a3b7181b1fa2b6ccb0c5dd +262b30a9bdd4c5ddf83f474f333a41b4c9e2717f8e434c55c5ddf8bfd6f1 +1113169aadc2a1b5cb131518667381c5ddf8788797282d33abc0d7a7bcd3 +1b1f23bcd3edc5ddf8c5ddf80d0e103b424a9db0c6b0c5ddabc0d7c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8505a651f2327aabfd68d9eb1 +191c20c5ddf8c5ddf8c5ddf8b3c9e1111316c5ddf8c5ddf8c5ddf82a2f35 +8fa1b4414952515b668494a658626ec5ddf8363d4530363db1c7df768494 +323940c5ddf8c5ddf8c5ddf83d444c8798abc5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8deecfbc5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c4dcf7b0c5ddb8cfe8c5ddf8c5ddf8c5ddf8 +9fb3c925292ec5ddf8c5ddf8c5ddf8c5ddf8c5ddf8b4cae3b1c7dfc5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8bed5efafc4dcc4dcf7c5ddf8c5ddf8c5ddf8 +c5ddf8b4c9e2b9d0e9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c2daf5c1d9f4bed5efbdd4eec5ddf8c5ddf8c5ddf8c5ddf8 +c4dcf7b4c9e2c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8b8cfe8b5cbe4c5ddf8 +c5ddf8c5ddf8c1d9f4c2daf5bad1ebc1d8f3c5ddf8c5ddf8c5ddf8c5ddf8 +535d69717f8ec5ddf8c5ddf8c5ddf8c5ddf8c5ddf8bbd2ecbcd3edc5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8bfd6f1 +c4dcf7b7cde6c5ddf8c5ddf8c5ddf8c4dcf7bed6f0bed6f0c2daf5c5ddf8 +c5ddf8c3dbf6c1d9f4b4cae3c4dcf7b9d0e9c3dbf6c5ddf8c4dcf7c0d7f2 +c2daf5b8cfe8c5ddf8c5ddf8c5ddf8c5ddf89baec3292e34c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8eff5fdffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffeff5fdc5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf87b8a9b050606738291c5ddf8c5ddf8c5ddf83239402c313748515b +141619adc3dac5ddf88899ac5b67732125293a41495b6773a3b6cdc5ddf8 +616d7a25292e4c55601c2023404851c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffff282828ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffff0f6fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf857616d515b66c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8414952 +8393a5c5ddf8c5ddf8c5ddf8c4dcf79fb2c86b788755606b0e1012a1b5cb +c5ddf86875832f353c8798abbad1ebc5ddf8c5ddf8c5ddf81e21255c6874 +9baec3c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +a9bed516191cc5ddf8c5ddf85f6b784d5661c5ddf84e5863444d568b9cb0 +899aad474f596c7988c5ddf83f474f788797c5ddf8aec3db171a1dc5ddf8 +91a2b630363dc5ddf8c5ddf8444d56667381c5ddf8353b4357616d8b9caf +899aad353b438595a8c5ddf8c5ddf80d0e108b9cafc5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8505a6557616dc5ddf8 +c5ddf81b1e22a9bed5c5ddf8c5ddf8b3c9e1111316c5ddf8c5ddf8c5ddf8 +2a2f35acc1d85b67736e7b8b9baec33e464ec5ddf8363d45707e8dc5ddf8 +c1d8f30a0c0dbed5efc5ddf8c5ddf83d444c8798abc5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8deecfbc5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf89baec3171a1d23272c21262a7b8a9bc5ddf8 +c5ddf89fb3c925292ec5ddf8c5ddf8c5ddf8c5ddf8363c442c31372b3036 +212529a9bdd4c5ddf8c5ddf8505a652d3339383f46363c44c5ddf8c5ddf8 +b0c5dd2a2f35363d452b3036758393c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf86673812f343b1b1f231f23276c7a89c5ddf8c5ddf8 +96a9bd171a1d282d3331373e99acc1c5ddf8c5ddf84e576210121416191c +3d444cc1d9f4c5ddf84d5661333a411e21252024287e8e9fc5ddf8c5ddf8 +c5ddf8535d69717f8ec5ddf8c5ddf8c5ddf8c1d9f44a535d14171a282d32 +58636fc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8aec3db +0f11132a2f3522272b434c55b4cae3c5ddf8afc4dc30363d121417798898 +c5ddf8c5ddf8899aad1b1e2221262a2f353c2b30362c3137c5ddf895a7bb +1d202420242821262a505a65bed5efc5ddf8c5ddf89baec3292e34c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8eff5fdffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffeff5fdc5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8bed5ef93a5b9bbd2ecc5ddf8c5ddf8c5ddf8c1d8f38b9caf +8191a3b4c9e2c5ddf8c5ddf8a9bdd493a5b993a5b993a5b993a5b9b4cae3 +c5ddf8c5ddf8a9bed58899acb2c8e0a4b8cfc5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff282828ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffff0f6fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf84a545e6a7786c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +4149528393a5c5ddf8c5ddf8c5ddf88494a62c32388495a799acc116191c +9cafc4c5ddf8c3dbf68495a732383f0c0d0f92a3b7c5ddf8c5ddf8b5cbe4 +687583111316282d32c0d7f2c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf897a9be25292ec5ddf8c5ddf86e7b8b4d5661c5ddf8424a533d454d +6875836875836875838d9eb1c5ddf83f474f8b9cb0c5ddf8b4cae3101214 +c5ddf87b8a9b414952c5ddf8c5ddf857616d667381c5ddf8282d334b545f +68758368758368758398abc0c5ddf8c5ddf80d0e10b5cbe4c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8505a65687583 +c5ddf8c5ddf82b303690a2b5c5ddf8c5ddf8b3c9e1111316c5ddf8c5ddf8 +c5ddf82a2f35b2c8e0626e7b7482929fb3c9363d45c5ddf8363d458191a3 +c5ddf8c5ddf8111316aabfd6c5ddf8c5ddf83d444c8798abc5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8deecfbc5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c4dcf71b1f237d8c9dc5ddf8c5ddf8b3c9e1 +c5ddf8c5ddf89fb3c925292ec5ddf8c5ddf8c5ddf8c5ddf8b7cde6c5ddf8 +c5ddf864707e535d69c5ddf8afc4dc15181bc5ddf8c5ddf8bfd6f1c5ddf8 +c5ddf86572805f6a77c5ddf8c5ddf8bfd6f1c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf86673811e2226bed6f0bbd2ec14171ab8cfe8 +c1d8f316191c8ea0b3c5ddf89baec33b424ac5ddf891a2b6171a1ebcd3ed +c1d8f32c31377d8c9dc5ddf84d5661353b43c2daf5b2c8e0121417c4dcf7 +c5ddf8c5ddf8535d69717f8ec5ddf8c5ddf8c5ddf873819030363dc1d9f4 +c4dcf7373e469fb3c9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +aec3db00000096a9bdc5ddf8515b66738190c5ddf8c5ddf8c5ddf84b545f +798898c5ddf8c5ddf8899aad3f474facc1d8030303c3dbf6282d32b9d0e9 +95a7bb000000afc4dcc3dbf63940478c9db1c5ddf8c5ddf89baec3292e34 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8eff5fd +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffeff5fd +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff282828ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffffffffff0f6fdc5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf86d7b8a343a42c5ddf8c5ddf8c4dcf7c5ddf8c5ddf8 +c5ddf85c68746d7b8ac5ddf8c5ddf8c5ddf8434b548191a3c5ddf8afc4dc +0000009cafc4c5ddf8c5ddf8c5ddf8c4dcf7515b67535d69c5ddf8c5ddf8 +c5ddf8c5ddf8b4cae3171a1d9db0c6c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c1d9f40d0f11bad1ebc5ddf8424a534d5661c5ddf8657280 +404750c5ddf8c5ddf8c5ddf8c5ddf8c5ddf83f474f8b9cb0c5ddf8b4cae3 +101214c5ddf8adc3da1c2023c5ddf8c5ddf82e343a667381c5ddf84b545f +5a6571c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf80d0e10b7cee7c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8505a65 +424a53c5ddf8c3dbf60d0f11bdd4eec5ddf8c5ddf8b3c9e1111316c5ddf8 +c5ddf8c5ddf82a2f35b2c8e0626e7b7482929fb3c9363d45c5ddf8363d45 +5c6874c5ddf8b2c8e0171a1dc5ddf8c5ddf8c5ddf857616d72808fc5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8deecfbc5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8aec3db070809bed6f0c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf89fb3c925292ec5ddf8c5ddf8c5ddf8c5ddf895a7bb +525c682c31371d2024404750c5ddf8c3dbf624282d3a4149738190bad1eb +c5ddf8c5ddf895a7bb171a1d515b668d9eb1c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf86673814a545ec5ddf8c5ddf83a4149 +8696a9a6bad10606075b667258636f57616d0a0c0dbed6f06b788747505a +c5ddf8c5ddf85d6875535d69c5ddf84d566164707ec5ddf8c5ddf8212529 +9fb3c9c5ddf8c5ddf8535d69717f8ec5ddf8c5ddf8c5ddf8424a53343a42 +5a657158626e2e343a64707ec5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8aec3db060607c1d9f4c5ddf88292a43e464ec5ddf8c5ddf8c5ddf8 +4b545f798898c5ddf8c5ddf8899aad515b66bed5ef131518c5ddf8363c44 +a2b6cc95a7bb1c2023c5ddf8c5ddf869758458626ec5ddf8c5ddf89baec3 +292e34c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +eff5fdffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +eff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8a9bdd4a6bad1b1c7dfc5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8b8cfe8c1d9f4c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c1d8f3b0c6dec5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8bfd6f1bad1ebc5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c8dff8ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff282828 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffffffffffffffff0f6fdc5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8bdd4ee282d332c3238626e7c2d3339c5ddf8 +c5ddf8c5ddf89fb2c81b1f234b545f8fa1b4c5ddf87e8e9f22272b606c79 +2b303616191c9cafc4c5ddf84e586357616d6572801e212598aabfc5ddf8 +b6cce52e343a66738155606b22272bc4dcf7c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf86a77861e2226373e462c32384d5661c5ddf8 +bad0ea252a2f343a42636f7d3d454d7d8d9ec5ddf83f474f8b9cb0c5ddf8 +b4cae3101214c5ddf8c5ddf83e464e353b433d444c181b1f667381c5ddf8 +acc1d81c20233e464e626e7c343a4295a7bbc5ddf8c5ddf80d0e10b7cee7 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +505a65171a1e474f592a2f35535d69c5ddf8c1d9f45b6773535d6908090a +5b6773697584c5ddf82a2f35b2c8e0626e7b7482929fb3c9363d45c5ddf8 +363d451b1f234e586322272b697685c5ddf8c5ddf8c5ddf89baec31b1f23 +4c556092a3b7c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8deecfb +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8aec3db070809bed6f0c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8a1b5cb23272cc5ddf8c5ddf8c5ddf8bed5ef +171a1d9cafc5c3dbf67382913d454dc5ddf8c5ddf8c3dbf68ea0b323272c +191c20c4dcf7c5ddf8c5ddf8b7cde66c7a89070809626e7cc5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf86673814a535dc5ddf8c5ddf8 +3a41498494a6a6bad10b0d0e98abc099acc199acc199acc1c1d9f46b7887 +474f59c5ddf8c5ddf85d6875535d69c5ddf84d5661636f7dc5ddf8c5ddf8 +2125299db0c6c5ddf8c5ddf8545e6a707e8dc5ddf8c5ddf8c5ddf8424a53 +58636f99acc199acc199acc1acc1d8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8aec3db060607c1d9f4c5ddf88292a43b424ac5ddf8c5ddf8 +c5ddf84b545f798898c5ddf8c5ddf8899aad545e6ac1d8f316191cc5ddf8 +3940479eb1c795a7bb1b1f23c5ddf8c5ddf869758455606bc5ddf8c5ddf8 +9cafc4282d33c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8eff5fdffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8596470333a41464e58c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf88c9db1a1b5cbc5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8bed5ef24282dc0d7f2c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8697584c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8a6bad11e2226 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8b4c9e22a2f35c4dcf7 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c8dff8fffffff5f5f5ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +282828ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffffffffffffffffffffff0f6fdc5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c1d9f491a2b67d8d9ea9bdd4 +c5ddf8c5ddf8c5ddf8c5ddf8bed6f095a8bcaec3dbc5ddf8c5ddf8a9bdd4 +8393a5b1c7df9eb1c7bad1ebc5ddf8b4c9e28797aa8495a7b7cde6c5ddf8 +c5ddf8c5ddf8a0b4ca7d8c9d96a9bdc1d9f4c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8b4cae3a7bcd3626e7c738190 +c5ddf8c5ddf8c1d8f390a2b57c8b9c9cafc4c4dcf7c5ddf8a3b7ceb7cde6 +c5ddf8c1d8f398aabfc5ddf8c5ddf8c5ddf89baec393a5b9adc2d9adc3da +c5ddf8c5ddf8bcd3ed8b9cb07d8d9ea3b6cdc5ddf8c5ddf8c5ddf897a9be +c1d9f4c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8505a6572808f8b9cb0a3b7cec5ddf8c5ddf8c4dcf793a5b993a5b9 +93a5b993a5b999acc1c5ddf89eb1c7c0d7f2acc1d8b0c6debbd2eca1b5cb +c5ddf8363d458797aa8797aaadc3dac5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +bed5ef95a7bbb0c5ddc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +deecfbc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c4dcf71b1f237d8c9d +c5ddf8c5ddf8b3c9e1c5ddf8c5ddf8bfd6f1111316bad0eac5ddf8c5ddf8 +a5b9d01e2125c5ddf8c0d7f232383f3d454dc5ddf8bcd3edbfd6f1c5ddf8 +bad0ea0d0f11bad1ebc5ddf8b6cce5c5ddf8c5ddf8768494474f59c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf86673811e2125bdd4ee +bad0ea141619b7cee7c1d8f316191c8b9cb0c5ddf8c5ddf8b1c7dfc5ddf8 +92a4b816191cbad0eabfd6f12a2f357e8e9fc5ddf84d5661323940c1d9f4 +b0c5dd111316c4dcf7c5ddf8c5ddf87d8c9d49525cc5ddf8c5ddf8c5ddf8 +73819030363dbed6f0c5ddf8c0d7f2b6cce5c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8aec3db00000093a5b9c5ddf84e586372808fc5ddf8 +c5ddf8c5ddf84b545f798898c5ddf8c5ddf8899aad545e6ac1d8f316191c +c5ddf83940479eb1c795a7bb000000acc1d8c2daf5363d458b9cb0c5ddf8 +c5ddf8bdd4ee111316bcd3edc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8eff5fdffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf87e8e9f464e58c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf84c5560788797c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf86e7b8b626e7cc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8000000c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c1d8f3 +b0c6dec5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf849525c +8798abc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +bed5ef8b9caf485059555555f0f0f0ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffff292929ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffffffffffffffffffffffffffff0f6fdc5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf88292a48fa1b48292a41c2023 +afc4dcc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8505a65748292c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8363d458e9fb2c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8deecfbc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf89cafc4 +1b1e2223272c24282d7c8b9cc5ddf8c5ddf8c5ddf8707e8d1e2226282d33 +c5ddf8c5ddf8454e57282d321b1f234a535d3d454dc5ddf8a1b5cb171a1e +383f46282d33657280c5ddf8c5ddf85f6b7821262a373e46292e349eb1c7 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf86673812d3339 +191c201e22266c7a89c5ddf8c5ddf897a9be191c20262b30252a2f394148 +c5ddf8c5ddf84e57620f111315181b3d444cc1d9f4c5ddf84d566131373e +1c20231f23277e8e9fc5ddf8c5ddf8c5ddf8b8cfe84047501b1e22697685 +c5ddf8c1d9f44e57620e101232383f1b1f2390a2b5c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8aec3db0e1012272c3121262a434c55b4cae3 +c5ddf8707d8d2a2f351012141a1d212a2f358ea0b3899aad545e6ac1d8f3 +16191cc5ddf83940479eb1c795a7bb1d20241d2024202428505a65bed5ef +c5ddf8c5ddf8c5ddf86c7a891e21252d3339c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8eff5fdffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf87e8e9f464e58c5ddf8 +c5ddf8c5ddf8c4dcf7444d561e222624282d616d7ac2daf5c5ddf8c5ddf8 +6673812c323824282d6d7b8ac5ddf8a6bad12a2f351012141a1d212a2f35 +626e7cc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8667381 +707d8d32383f32383f98aabfc5ddf8c5ddf855606b20242821262a545f6a +bed6f0c5ddf8434c55444d562c32385f6a772f343ba1b5cbc5ddf8b7cde6 +4d566121252956616cadc3dac5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8191c20adc2d9c5ddf8c5ddf8c5ddf8acc1d8 +49525c25292e2d3339a3b7cec5ddf86976852a2f350000002a2f352a2f35 +9eb1c7c5ddf8c5ddf8515b668696a93941481b1f238190a2c5ddf85a6571 +2a2f35434b54c5ddf8c5ddf8c5ddf88b9caf606c79434b54272c317d8c9d +c5ddf8c5ddf8b0c5dd525c6824282d697584525c68c5ddf8c5ddf8c5ddf8 +93a5b9323940c5ddf8c5ddf8c5ddf8c5ddf8c5ddf86d7b8aa0b4cac5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8adc2d9707d8d +292f340c0e0f0304041e2225f0f0f0ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff2b2b2bfdfdfdffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffffffffffffffffffffffffffffffffff0f6fd +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf893a5b957616d687583 +b0c6dec5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8b0c5dd6e7b8b6e7b8b6e7b8b6e7b8b +6e7b8bafc4dcc5ddf88797aa9aadc2c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf87a8899a7bcd3c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8deecfbc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8b1c7dfbbd2ecc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8b7cee7c1d8f3c5ddf8c5ddf8c5ddf8c5ddf8 +c1d9f4adc3dac2daf5c5ddf8c5ddf8c5ddf8c5ddf8bad0eab2c8e0c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8667381 +5e6976bed5efbdd4eec5ddf8c5ddf8c5ddf8c5ddf8c5ddf8b1c7dfb8cfe8 +c5ddf8c5ddf8c5ddf8c5ddf8b8cfe8b5cbe4c5ddf8c5ddf8c5ddf84d5661 +778696bad0eac1d8f3c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8bed6f0aec3dbc2daf5c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8aec3db16191cc4dcf7b7cde6c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf895a7bb2f353cc2daf5b8cfe8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8eff5fdffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf87e8e9f464e58 +c5ddf8c5ddf8c5ddf8c4dcf78ea0b3c2daf5b6cce52c32388190a2c5ddf8 +9cafc52b3036bfd6f1c2daf5a3b6cdc5ddf8c5ddf8c5ddf84c5560788797 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +4b545f2a2f35b0c6de7d8c9d373e46c5ddf8c5ddf88fa1b4c0d7f2bad1eb +3f474f697685c5ddf820242899acc1363d455b6773798898626e7cc5ddf8 +3a414956616cbad0ea8190a23a4149c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8b8cfe8070809c4dcf7c5ddf8c5ddf8c5ddf8 +4f596472808fc5ddf8b3c9e1b2c8e0c5ddf8c5ddf8c5ddf8000000c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf830363d282d328ea0b3b7cee7a3b6cdc5ddf8 +c5ddf8a6bad11e2226c5ddf8c5ddf8c5ddf87a88990d0e109fb3c9a7bcd3 +0f1113c2daf5c5ddf83c434b677482b4cae33941482c3137c5ddf8c5ddf8 +c5ddf8b2c8e00d0e10c5ddf8c5ddf8c5ddf8c5ddf8c5ddf80a0b0c768595 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c2daf595a8bc535d6815181b0e1011 +0505060000000202021f2327bcd2e9ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff2d2d2dfbfbfbffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +f0f6fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8deecfbc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +6673815e6976c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +4d5661778696c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8aec3db16191cc5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf895a7bb2f353cc5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8eff5fdffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf87e8e9f +464e58c5ddf8c5ddf8c5ddf8c5ddf8b0c5dd7a899a57616d292e3464707e +c5ddf8a5b9d0121417768494adc3dac5ddf8c5ddf8c5ddf8c5ddf84c5560 +788797c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf84b545f6c7988c5ddf8bad1eb0a0c0dc5ddf8c5ddf8b4cae38190a2 +58636f333a414d5661c5ddf8202428b7cde6515b6679889890a2b549525c +bcd3ed0202028190a28b9caf8899ac111316bdd4eec5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf899acc1212529c5ddf8c5ddf8c5ddf8 +c5ddf858626e3940478b9cb0bdd4eec5ddf8c5ddf8c5ddf8c5ddf8000000 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf830363d677482c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8a6bad11e2226c5ddf8c5ddf8c5ddf87a88993d454dc5ddf8 +c5ddf823272ca2b6ccc1d8f30a0c0db9d0e9c5ddf88190a22c3137c5ddf8 +c5ddf8c5ddf8c5ddf8070809b3c9e1c5ddf8c5ddf8c5ddf8c5ddf8a8bcd4 +b9d0e9c5ddf8c5ddf8b5cbe4616d7a252a2f090a0b090a0b000000000000 +000000000000010101141619778696808f9fa1a1a1a0a0a09e9e9e9c9c9c +9a9a9a9898989797979595959393939191918f8f8f8e8e8e8c8c8c8a8a8a +8888888686868585858383838181817f7f7f7d7d7d7c7c7c7a7a7a787878 +767676747474737373717171141414f8f8f8ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffff0f6fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8deecfbc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8aabfd6a8bcd4c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8a3b7ceafc4dcc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +8292a46e7b8b6e7b8b6e7b8b6e7b8b8696a9c5ddf8bed6f094a6bac5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8b7cee79baec3c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8eff5fdffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffeff5fdc5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +7e8e9f464e58c5ddf8c5ddf8c5ddf8b8cfe816191c76849498aabf464e58 +5f6a77c5ddf8c5ddf89fb3c94e58630405055f6a77c5ddf8c5ddf8c5ddf8 +4c5560788797c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf84b545f7f8fa0c5ddf8c1d8f3030404c5ddf8c1d9f4191c20 +6f7c8c96a9bd58626e47505ac5ddf8202428bdd4ee58626e7f8fa095a8bc +414952b0c6de040505677482687583687583687583b6cce5c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8a6bad116191cc5ddf8c5ddf8 +c5ddf8c5ddf8c1d8f37d8d9e2a2f351013159cafc5c5ddf8c5ddf8c5ddf8 +000000c5ddf8c5ddf8c5ddf8c5ddf8c5ddf830363d92a3b7c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8a6bad11e2226c5ddf8c5ddf8c5ddf87a8899515b66 +c5ddf8c5ddf8292e349baec3b7cde608090ac2daf5c5ddf88fa1b42c3137 +c5ddf8c5ddf8c5ddf8c0d7f2030404bed5efc5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8bfd6f17a899a1f2328030304060708000000000000 +000000000000000000020303171a1d616d7b677480858585878787898989 +8b8b8b8c8c8c8e8e8e9090909292929494949595959797979999999b9b9b +9d9d9d9e9e9ea0a0a0a2a2a2a4a4a4a5a5a5a7a7a7a9a9a9abababadadad +aeaeaeb0b0b0b2b2b2b4b4b4b5b5b5b7b7b7fdfdfdffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffff0f6fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c3dbf6a2b6cc93a5b9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8deecfbc5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8eff5fdffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffeff5fdc5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf899acc12f353cc5ddf8c5ddf8c5ddf8808fa1444d56c5ddf8c5ddf8 +262b305f6a77c5ddf8c5ddf8c5ddf8c5ddf88e9fb216191cc5ddf8c5ddf8 +c5ddf85b67736a7786c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf84b545f7f8fa0c5ddf8c1d8f3030404c5ddf897a9be +2d3339c5ddf8c5ddf83d454d47505ac5ddf8202428bdd4ee58626e7f8fa0 +95a8bc414952c4dcf70f111398aabfc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c1d9f4060607bed6f0 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c2daf5434b54626e7cc5ddf8c5ddf8 +c5ddf80f1113b7cde6c5ddf8c5ddf8c5ddf8c5ddf830363d94a6bac5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8a6bad11e2226c5ddf8c5ddf8c5ddf87a8899 +515b66c5ddf8c5ddf8292e349baec3c5ddf8272c319cafc5c5ddf8626e7c +2c3137c5ddf8c5ddf8c5ddf8a6bad11b1e22c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf88494a6a0b4cac5ddf8c5ddf8c5ddf8c5ddf8c2daf59aadc25c6874 +1e22260e10120a0b0d0000000000000607082d3339c3d8f1ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffff0f6fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf858636f373e46899aadc5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8deecfbc5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8eff5fdffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffeff5fdc5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c4dcf7282d333d454d6b7887c5ddf8b4c9e21214175e6976 +323940272c315f6a77c5ddf87e8e9f454e576a7786363d455d6875c5ddf8 +c5ddf8c5ddf899acc1191c20545e6a8292a4c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf84b545f7f8fa0c5ddf8c1d8f3030404c5ddf8 +c0d7f2171a1d5964703d444c292e3447505ac5ddf8202428bdd4ee58626e +7f8fa095a8bc414952c5ddf88190a215181b545e6a5a6571292e34c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8363c44 +94a6bac5ddf8c5ddf8c5ddf8434c555b6672636f7d191c20a6bad1c5ddf8 +c5ddf8c5ddf8545e6a2f343b5b6773aabfd6c5ddf8c5ddf830363d94a6ba +c5ddf8c5ddf8c5ddf8bad1eb5b67734d56610e10125b6773707d8dc5ddf8 +7a8899515b66c5ddf8c5ddf8292e349baec3c5ddf88393a51d20243f474f +2f343b2c3238c5ddf8c5ddf8c5ddf87988984f5964c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8141619687583c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8b8cfe88595a8424a531113150f11130202032c3036f8f8f8 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffff0f6fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf821262aa3b7cec5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8deecfbc5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf88798ab596470adc3da +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8eff5fd +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffeff5fd +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf89fb2c89fb2c8c5ddf8c5ddf8b9d0e9 +8494a6a0b4caadc3daabc0d7c5ddf8bed6f092a3b77d8c9da8bcd4c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8bfd6f198abc0a6bad1c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8a6bbd2b4c9e2c5ddf8c4dcf795a7bb +c5ddf8c5ddf8bed5ef8797aa99acc1b3c9e1a6bad1c5ddf89cafc4c3dbf6 +a9bed5b4c9e2b9d0e9a4b8cfc5ddf8c5ddf8aec3db8191a38595a8b4c9e2 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +95a8bc404750c5ddf8c5ddf8c5ddf8b0c6de8494a68798abbad0eac5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8b0c6de94a6bab8cfe8c5ddf8c5ddf89fb3c9 +b9d0e9c5ddf8c5ddf8c5ddf8c0d7f293a5b993a5b993a5b993a5b99db0c6 +c5ddf8b2c8e0a8bcd4c5ddf8c5ddf89eb1c7bad1ebc5ddf8c5ddf8bdd4ee +a0b4ca8292a4515b67c5ddf8c5ddf8c5ddf8282d33acc1d8c5ddf8c5ddf8 +c5ddf8c5ddf8b4c9e2060607aec3dbc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8a6bbd26d7a892e3339 +515151f5f5f5ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffffffffff0f6fdc5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf816191cadc3dac5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8deecfbc5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8a8bcd41b1f2395a8bc +bfd6f1c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +eff5fdffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +eff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf858626ebdd4eec5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf890a2b5 +8899ac8b9cb02a2f3590a2b5c5ddf8c5ddf8adc3da677482c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf894a6ba64707ec5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c8dff8f9f9f9ecececffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffffffffffffffff0f6fdc5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8bbd2ec070809bfd6f1c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8deecfb +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf87988984c5560 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8eff5fdffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8abc0d7 +6e7b8b6e7b8b6e7b8b6e7b8b6e7b8bb4c9e2c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +a2b6cc5c68745e6976a6bad1c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c8dff8ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffffffffffffffffffffff0f6fdc5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf87a899a171a1e64707ec5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +deecfbc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf872808f +515b66c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8eff5fdffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c8dff8ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffffffffffffffffffffffffffff0f6fdc5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8bad0ea7f8fa0141619c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8deecfbc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8bed6f0 +414952707d8dc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8eff5fdffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c8dff8ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffffffffffffffffffffffffffffffffff0f6fd +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8101214 +b1c7dfc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8deecfbc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8bbd2ec +14171a1b1e22b8cfe8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8eff5fdffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +f0f6fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +171a1eadc2d9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8deecfbc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c4dcf748515b697584c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8eff5fdffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffff0f6fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf83e464e7a899ac4dcf7c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8deecfbc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8738190505a65c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8eff5fdffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffeff5fdc5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffff0f6fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf89cafc44e58635c6874c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8deecfbc5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf87a899a4a535dc5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8eff5fdffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffeff5fdc5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffff0f6fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8deecfbc5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8abc0d7171a1e899aadbdd4eec5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8eff5fdffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffeff5fdc5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffff0f6fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8deecfbc5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf895a8bc6b7887b1c7df +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8eff5fd +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffeff5fd +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffffffffff0f6fdc5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8deecfbc5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +eff5fdffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +eff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c8dff8ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffffffffffffffff0f6fdc5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf89cafc572808fc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf84d5661c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8deecfb +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8eff5fdffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c8dff8ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffffffffffffffffffffff0f6fdc5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf89cafc572808fc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8050606c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +deecfbc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8eff5fdffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +b5cbe4bcd3edc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8bed5efb4cae3 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c8dff8ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffffffffffffffffffffffffffff0f6fdc5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf893a5b9 +bed5efc5ddf8c5ddf8abc0d7a6bad1c5ddf8c5ddf89cafc57d8d9ea2b6cc +c5ddf8c5ddf8c5ddf895a8bc8d9eb19fb3c9c5ddf8c5ddf8c5ddf8c5ddf8 +bcd3ed8495a7b1c7df050606c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8deecfbc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf832383fabc0d7c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf86d7b8a758393c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8eff5fdffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8474f597d8d9ec5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf88a9bae +404851c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c8dff8ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffffffffffffffffffffffffffffffffff0f6fd +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +4048517f8fa0c5ddf8c5ddf83d454d8393a5c5ddf86f7c8c16191c56616c +1416197e8e9fc5ddf8c5ddf8707e8d424a53404750c5ddf8c5ddf8c5ddf8 +92a4b81e2125545f6a2a2f35030404c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8deecfbc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf88696a9bad0ea +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8616d7a697685c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8eff5fdffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8b5cbe4bcd3edc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +8a9bae404851c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +f0f6fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf88798ab3b424ac5ddf8b9d0e9101214bed6f0c5ddf80d0e109aadc2 +c5ddf88e9fb21c2023c5ddf8c5ddf8c5ddf88495a7404750c5ddf8c5ddf8 +c5ddf84a545e7f8fa0c5ddf893a5b9020202c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8deecfbc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf89db0c68190a2c5ddf8c5ddf8c1d8f35f6b78c2daf5 +c5ddf899acc1525c6856616ca6bbd2c5ddf8c5ddf89db0c65b67735b6773 +b5cbe4c5ddf8c5ddf8c5ddf8bad1eb687583626e7b5a6571697685c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8eff5fdffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8b2c8e0394148c5ddf8 +c5ddf8c5ddf83f474facc1d8c5ddf88a9bae282d32202428626e7cc4dcf7 +c5ddf8aabfd62a2f352a2f358e9fb2c5ddf8c5ddf8c5ddf8a9bdd44a535d +262b3057616d404851c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffff0f6fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c0d7f2121417b7cee77a899a4a545ec5ddf8b7cee7030404 +c1d8f3c5ddf8b5cbe4010101c1d9f4c5ddf8c5ddf88495a7404750c5ddf8 +c5ddf8c5ddf8181b1fa3b7cec5ddf8bad1eb030303c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8deecfbc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8afc4dc141619c3dbf6c5ddf88b9caf363c44 +c5ddf8a5b9d0101214748292697685121417b7cde6c5ddf8b2c8e093a5b9 +15181ba7bcd3c5ddf8c5ddf8c3dbf6191c206a7786707d8d0d0e10697685 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8eff5fdffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffeff5fdc5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8262b30 +9baec3c5ddf8a3b6cd1e2226c5ddf8b1c7df0a0c0d92a3b7abc0d7262b30 +7f8fa0c5ddf8c5ddf8c5ddf8474f597d8d9ec5ddf8c5ddf8c5ddf8282d32 +7f8fa0afc4dc2a2f35404851c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffff0f6fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf84f5964788797363c4491a2b6c5ddf8c0d7f2 +000000b0c6dec5ddf8a3b6cd0a0c0dc5ddf8c5ddf8c5ddf88495a7404750 +c5ddf8c5ddf8c5ddf832383f92a3b7c5ddf8a8bcd4020202c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8deecfbc5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf832383f91a2b6c5ddf8464e58 +7d8c9dc5ddf85f6b7847505ac5ddf8c5ddf831373e788797c5ddf8c5ddf8 +c5ddf81d2024a7bcd3c5ddf8c5ddf89cafc42a2f35c5ddf8c5ddf8363d45 +697685c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8eff5fdffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffeff5fdc5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +6c7a8957616dc5ddf85f6a7765717fc5ddf88393a5292e34c5ddf8c5ddf8 +65717f47505ac5ddf8c5ddf8c5ddf8474f597d8d9ec5ddf8c5ddf8b6cce5 +0d0e10c4dcf7c5ddf86a7786404851c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffff0f6fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf895a8bc262b30171a1dc3dbf6c5ddf8 +c5ddf832383f596470b6cce5505a65434b54c5ddf8c3dbf6bed6f08190a2 +3d454dbed6f0c1d8f3c5ddf8667381464e58b5cbe455606b020202c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8deecfbc5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf87887974d5661bed5ef +111316bbd2ecc5ddf84e5863697685c5ddf8c5ddf8515b66636f7dc5ddf8 +c5ddf8c5ddf81d2024a7bcd3c5ddf8c5ddf874829247505ac5ddf8c5ddf8 +56616c697685c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8eff5fdffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffeff5fdc5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8b1c7df16191cc3dbf61b1f23abc0d7c5ddf87988983d454dc5ddf8 +c5ddf87786963c434bc5ddf8c5ddf8c5ddf8474f597d8d9ec5ddf8c5ddf8 +a2b6cc1b1f23c5ddf8c5ddf87d8c9d404851c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffff0f6fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c4dcf73d444c6d7b8ac5ddf8 +c5ddf8c5ddf8adc2d93a41491b1f23414952b4c9e2c5ddf89eb1c730363d +30363d30363d30363d657280c5ddf8bbd2ec68758323272c677482353b43 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8deecfbc5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8b9d0e9131518 +7e8e9f444d56c5ddf8c5ddf8616d7a474f59c5ddf8c5ddf830363d798898 +c5ddf8c5ddf8c5ddf81d2024a7bcd3c5ddf8c5ddf89db0c6292e34c5ddf8 +c5ddf8363c44697685c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8eff5fd +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffeff5fd +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8343a426a77862c3238c5ddf8c5ddf895a7bb121417 +c5ddf8c5ddf84e58635b6773c5ddf8c5ddf8c5ddf8474f597d8d9ec5ddf8 +c5ddf8c4dcf7101315bad1ebc5ddf8545e6a404851c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffffffffff0f6fdc5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8deecfbc5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +4047501214178b9cafc5ddf8c5ddf8a6bbd20e101272808f667381111316 +b7cee7c5ddf899acc18d9eb114171a7887978d9eb1bed6f0c3dbf6181b1f +6875836c7a890c0d0f697685c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +eff5fdffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +eff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf87b8a9b050606738291c5ddf8c5ddf8c5ddf8 +3239402c313748515b141619adc3dac5ddf88899ac5b67732125293a4149 +5b6773a3b6cdc5ddf8616d7a25292e4c55601c2023404851c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c8dff8ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffffffffffffffff0f6fdc5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8deecfb +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf89db0c6636f7dc1d9f4c5ddf8c5ddf8c5ddf899acc1525c6856616c +a6bbd2c5ddf8c5ddf8778696626e7b626e7b626e7b626e7bb9d0e9c5ddf8 +bad1eb687583636f7d8d9eb197a9bec5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8eff5fdffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8bed5ef93a5b9bbd2ecc5ddf8c5ddf8 +c5ddf8c1d8f38b9caf8191a3b4c9e2c5ddf8c5ddf8a9bdd493a5b993a5b9 +93a5b993a5b9b4cae3c5ddf8c5ddf8a9bed58899acb2c8e0a4b8cfc5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c8dff8ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffffffffffffffffffffff0f6fdc5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +deecfbc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8eff5fdffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c8dff8ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffffffffffffffffffffffffffff0f6fdc5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8deecfbc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8eff5fdffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8bed5ef +b4cae3c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8bad1ebbfd6f1c5ddf8c5ddf8c5ddf8 +b5cbe4c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c8dff8ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffffffffffffffffffffffffffffffffff0f6fd +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8deecfbc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8eff5fdffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +8a9bae404851c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c4dcf72a2f35b4c9e2c5ddf8c5ddf8 +c5ddf84048519cafc4c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +f0f6fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8b8cfe8a6bbd2c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf82f343bb4c9e2 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf893a5b9667381c5ddf8c5ddf8c5ddf890a2b5697584 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8deecfbc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8eff5fdffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf88a9bae404851c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf88798ab49525cc5ddf8c5ddf8 +c5ddf8c5ddf896a9bd3a4149c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8a2b6ccafc4dcc5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffff0f6fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c3dbf6c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf88b9caf394148c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf81a1d21 +b0c6dec5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf830363da3b7cec5ddf8c5ddf8c5ddf8c1d8f3 +1f2327b8cfe8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8deecfbc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8b7cde6c3dbf6c5ddf8c5ddf8c3dbf6b7cee7 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8eff5fdffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffeff5fdc5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8b1c7df +545f6a23272c6975844e5863c5ddf8c5ddf897a9be323940282d33768494 +c0d7f2c5ddf87a899a6975843a41492b3036899aadc5ddf8c5ddf8a9bdd4 +4a535d262b3057616d404851c5ddf8c5ddf88798ab2c32382f353c8190a2 +c4dcf7c5ddf8c5ddf8535d698595a83a41491b1f237f8fa0c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf832394093a5b9c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf81b1e22abc0d7c5ddf8c5ddf8c5ddf8c5ddf8 +92a3b77c8b9cc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8b9d0e98495a73f474f0d0f11515b66c4dcf7 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffff0f6fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8a5b9d0262b300d0f110d0e10383f46b4cae3c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf896a9bd8797aa65717f677482bad0eac5ddf8c5ddf8 +c1d8f36c79884c5560738190c3dbf6c5ddf8c5ddf8abc0d76a77864a545e +6c7a89c5ddf8c5ddf86774824048511b1e225b6773616d7ac5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8adc2d958636f778696 +7c8b9caec3dbc5ddf8c5ddf88495a7515b668292a4c1d9f4c5ddf8bfd6f1 +65717f95a8bc525c688798abc4dcf7c5ddf8c5ddf8a3b7ce55606b8495a7 +1a1d21b0c6dec5ddf8c3dbf6798898515b668d9eb1c4dcf7c5ddf8c5ddf8 +a5b9d07c8b9c92a4b8515b66697584c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf898abc02f353cc5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8626e7b667381c5ddf8c5ddf8c5ddf8c5ddf8bfd6f199acc1bbd2ec +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8deecfbc5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8b6cce5272c31c4dcf7c5ddf8c5ddf8c3dbf6 +252a2fb9d0e9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8bdd4ee899aad6a7786bed6f0 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8eff5fdffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffeff5fdc5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +404851626e7cb4cae33d444c272c31c5ddf8afc4dc0d0e1091a2b6b8cfe8 +434b548393a5c5ddf8657280191c20a8bcd496a9bd1d2024c5ddf8c5ddf8 +282d327f8fa0afc4dc2a2f35404851c5ddf89cafc51214179db0c6b3c9e1 +2f353c9cafc5c5ddf8c5ddf8323940262b308d9eb1b7cee7a2b6ccc5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf80d0e10b2c8e0 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf83941488595a8c5ddf8c5ddf8c5ddf8 +c5ddf857616d292e34c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf89fb3c9626e7b2125290e10120a0b0c04050549525cc4dcf7 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffff0f6fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8aabfd60e101200000000000000000002020216191cbdd4ee +c5ddf8c5ddf8c5ddf8c5ddf86c7a890c0d0f6e7b8b6c7988171a1ec2daf5 +c5ddf84a545e383f468798ab31373e5c6874c5ddf8c5ddf82a2f35798898 +9db0c66f7c8cc5ddf8c5ddf899acc16875832b303693a5b995a8bcc5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8a6bad116191c7c8b9c +56616c06070897a9bec5ddf86875832c31378899ac5b6773404750c5ddf8 +bad1eb0506064c5560899aad1d20249aadc2c5ddf88fa1b42125298494a6 +444d56040505b0c6dec5ddf84e58633941488b9cb04a545e596470c5ddf8 +c5ddf88899ac1b1f233941488292a4687583c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf86a778656616cc5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf88798ab394047c5ddf8c5ddf8c5ddf8c5ddf8acc1d8000000 +9aadc2c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8deecfbc5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf85f6a77738190c5ddf8c5ddf8c5ddf8 +c5ddf86d7b8a64707ec5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8a9bdd46c7a89272c31030303101315acc1d8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8eff5fdffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffeff5fdc5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c2daf50d0e10b5cbe4c5ddf88595a8272c31c5ddf8748292292e348b9cb0 +8a9bae616d7a454e57c5ddf8657280525c68c5ddf8c5ddf80f1113b6cce5 +b6cce50d0e10c4dcf7c5ddf86a7786404851c5ddf85b66723c434b8b9cb0 +899aad4f59645f6b78c5ddf8c5ddf832394065717fc5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8b3c9e1070809 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8545e6a657280c5ddf8c5ddf8 +c5ddf8c5ddf8b4c9e2adc2d9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8b8cfe8 +8393a53d454d0f11130f11130202020000000000000a0c0d4a545ec5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffff0f6fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8394148000000000000000000000000000000050606 +677482c5ddf8c5ddf8c5ddf8c5ddf86c7a8931373ec5ddf8c5ddf82d3339 +9baec3c3dbf6030404a6bad1c5ddf898abc0101315c5ddf8c2daf5101315 +8e9fb2c2daf5c5ddf8c5ddf8c5ddf8c5ddf88b9caf394148c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf86c7a8955606b +c5ddf8c4dcf70b0d0e97a9bec5ddf80d0e109aadc2bcd3edb9d0e91b1f23 +bed5efbad1eb000000b5cbe4c5ddf85c6874697685c5ddf8545e6a717f8e +c5ddf8b4cae3000000b0c6deb7cee7060607adc3dabbd2ecb0c5dd1e2226 +c5ddf8c5ddf88899ac070809bed6f0c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf849525c72808fc5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8a3b7ce171a1dc5ddf8c5ddf8c5ddf8c5ddf8bad1eb +748292b4c9e2c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8deecfbc5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf82f343b677482 +23272c677482bbd2ecc5ddf8c5ddf87d8c9d292e34353b438899acc5ddf8 +c5ddf8c5ddf8474f59899aad363d451d20248b9cafc5ddf898aabf3e464e +23272c363c44bbd2ecc5ddf8c1d9f45b67731f23272a2f3591a2b6c5ddf8 +c5ddf8464e58758393282d32434b54acc1d8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c3dbf60d0e10bad1ebc5ddf8c5ddf8 +c5ddf8c5ddf8b7cde6101214c5ddf8c5ddf8c5ddf8c5ddf8c5ddf87e8e9f +8fa1b4c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c0d7f28fa1b44c55601315180e101203040400000014171aacc1d8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8eff5fd +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffeff5fd +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8bad1eb060708c0d7f2c5ddf895a7bb272c31c5ddf8687583292e34 +6875836875836875837b8a9bc5ddf865728065717fc5ddf8c5ddf815181b +afc4dca2b6cc1b1f23c5ddf8c5ddf87d8c9d404851c5ddf84e5863373e46 +6875836875836875838797aac5ddf8c5ddf83239408fa1b4c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8bed5ef +030404c0d7f2c5ddf8c5ddf8c5ddf8c5ddf8c5ddf849525c72808fc5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8bfd6f1707d8d131518 +00000003030300000000000000000000000000000002020216191c434b54 +434b54434b54434b54434b54434b54434b54434b54434b54434b54434b54 +434b54434b54434b54434b54434b54434b54434b54434b54434b54434b54 +434b54434b54434b54434b54434b54434b54434b54434b54434b54434b54 +434b54434b54434b54434b54434b54434b54434b54434b54434b54434b54 +434b54434b54434b54434b54434b54434b54434b54434b54434b54434b54 +434b54434b54434b54434b54434b54434b54434b54434b54434b54444c54 +575757575757575757575757575757575757575757575757575757575757 +575757575757575757575757575757575757575757575757575757575757 +575757575757575757575757575757575757575757575757575757575757 +575757575757575757575757575757575757575757575757575757575757 +575757575757575757575757575757575757575757575757575757575757 +575757575757575757575757575757515456434b54434b54434b54434b54 +434b54434b54434b54434b54060607000000000000000000000000000000 +000000323940c5ddf8c5ddf8c5ddf8c5ddf86c7a894e5762c5ddf8c5ddf8 +4a535d717f8eb6cce5040505c4dcf7c5ddf8b8cfe8000000c1d9f4c5ddf8 +92a4b8363d450c0d0f58636fc5ddf8c5ddf8c5ddf88b9caf394148c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf847505a +738291c5ddf8c5ddf8282d3297a9bebcd3ed000000363d45363d45363d45 +363d45a6bbd2bad1eb101214c5ddf8c5ddf86a77865a6571c5ddf82d3339 +8ea0b3c5ddf8c5ddf80f1113b0c6dea2b6cc070809363d45363d45363d45 +363d45b9d0e9c5ddf88899ac353b43c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8474f59738291c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8a6bad115181bc5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8deecfbc5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8050606 +56616cb6cce54b545f64707ec5ddf88ea0b31a1d21a3b7ceaec3db25292e +acc1d8c5ddf8c5ddf823272c2f343b94a6bab5cbe4a5b9d0c5ddf8282d33 +98abc0c5ddf8a6bbd2bed6f0c5ddf87583932a2f35aec3db8e9fb20d0e10 +b7cee7c5ddf822272b49525cb9d0e956616c606c79c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8a9bdd416191cc5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8101214afc4dcc5ddf8c5ddf8c5ddf8c5ddf8 +2d3339535d69c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8afc4dc +7482922d33390d0e100c0d0f00000000000000000000000014171aacc1d8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c4dcf7c3dbf6 +c2daf5c1d9f4c1d8f3c0d7f2bfd6f1bed6f0bed5efbed5efbdd4eebcd3ed +bbd2ecbad1ebbad0eab9d0e9b8cfe8b7cee7b7cde6b6cce5b6cce5b5cbe4 +dbe1e8e9e9e9e8e8e8e7e7e7e6e6e6e5e5e5e4e4e4e3e3e3e2e2e2e2e2e2 +e1e1e1e0e0e0dfdfdfdedededddddddcdcdcdbdbdbdadadad9d9d9d8d8d8 +d8d8d8d7d7d7d6d6d6d5d5d5d4d4d4d3d3d3d2d2d2d1d1d1d0d0d0dbdbdb +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +eff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf82c323898aabfc5ddf8687583272c31c5ddf88b9cb0 +1b1e22c5ddf8c5ddf8c5ddf8c5ddf8c5ddf865728065717fc5ddf8c5ddf8 +15181bafc4dcc4dcf7101315bad1ebc5ddf8545e6a404851c5ddf872808f +333a41c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf832394092a3b7c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf81b1e22a6bbd2c5ddf8c5ddf8c5ddf8c5ddf8c5ddf82d333993a5b9 +c5ddf8c5ddf8c5ddf8c5ddf8a0b4ca8494a6c5ddf8c5ddf8c5ddf8c0d7f2 +7c8b9c3f474f1013150c0d0f0405050000000000000000000000000d0e10 +8797aa9fb3c99fb3c99fb3c99fb3c99fb3c99fb3c99fb3c99fb3c99fb3c9 +9fb3c99fb3c99fb3c99fb3c99fb3c99fb3c99fb3c99fb3c99fb3c99fb3c9 +9fb3c99fb3c99fb3c99fb3c99fb3c99fb3c99fb3c99fb3c99fb3c99fb3c9 +9fb3c99fb3c99fb3c99fb3c99fb3c99fb3c99fb3c99fb3c99fb3c99fb3c9 +9fb3c99fb3c99fb3c99fb3c99fb3c99fb3c99fb3c99fb3c99fb3c99fb3c9 +9fb3c99fb3c99fb3c99fb3c99fb3c99fb3c99fb3c99fb3c99fb3c99fb3c9 +a3b5c9cfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcf +cfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcf +cfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcf +cfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcf +cfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcf +cfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfc3c8cd9fb3c99fb3c99fb3c9 +9fb3c99fb3c99fb3c99fb3c99fb3c9181b1f000000000000000000000000 +00000000000047505ac5ddf8c5ddf8c5ddf8c5ddf86c7a8930363dc5ddf8 +c5ddf82c323898abc0c3dbf6040505a5b9d0c5ddf898aabf111316c5ddf8 +c5ddf8c5ddf8c5ddf893a5b90f11139fb3c9c5ddf8c5ddf891a2b6343a42 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +738291505a65c5ddf8c1d9f407080997a9bec5ddf80d0e109cafc4c5ddf8 +c5ddf8c5ddf8c5ddf8bad1eb101214c5ddf8c5ddf86a77865a6571c5ddf8 +56616c707e8dc5ddf8b4c9e2000000b0c6deb7cee7030303b3c9e1c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf88899ac3c434bc5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf868758358636f +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8899aad363c44c5ddf8c5ddf8c5ddf8 +c5ddf8c3dbf6acc1d8bed5efc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8deecfb +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +050606a2b6ccc5ddf895a7bb2f343bc5ddf84b545f474f598b9cb0899aad +444d566f7c8cc5ddf8c5ddf823272c748292c5ddf8c5ddf8c5ddf8c5ddf8 +31373e505a6595a8bcc3dbf6c5ddf8c5ddf84047506c7a89c5ddf8c5ddf8 +21262a8b9cafc5ddf822272b95a8bcc5ddf892a3b7333a41c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8899aad30363dc5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf82b30368fa1b4c5ddf8c5ddf8c5ddf8 +c5ddf8adc3dab3c9e1c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8b5cbe4515b67 +000000000000000000000000000000000000000000000000010101141719 +1e22261e22261e22261e22261e22261e22261e22261e22261e22261f2327 +20242821252921262a22272b23272c24282d25292e252a2f262b30272c31 +272c31282d32282d33292e342a2f352b30362c31372c32382d33392e343a +2f343b393b3d3e3e3e3f3f3f404040414141424242434343444444454545 +4646464747474848484848484949494a4a4a4b4b4b4c4c4c4d4d4d4e4e4e +4f4f4f5050505151515252525353535353535454545555555656564c4c4c +484848ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf88797aa1d20244047502f353c272c31c5ddf8 +c5ddf8404750262b30626e7b49525c5d6875c5ddf865728065717fc5ddf8 +c5ddf815181bafc4dcc5ddf8616d7a25292e4c55601c2023404851c5ddf8 +bed6f02c32382f353c636f7d414952738190c5ddf8c5ddf832394092a3b7 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf84f59647a899ac5ddf8c5ddf8c5ddf8c5ddf8bbd2ec171a1d +bbd2ecc5ddf8c5ddf8c5ddf8c5ddf8616d7a1b1e22c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8acc1d8707e8d2b30360d0f110d0e10000000 +000000101214a6bad1c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c8dff8ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffffffffffffffffffffff0f6fdc5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf86a77860a0b0c000000000000 +0000000000000d0e1094a6bac5ddf8c5ddf8c5ddf8c5ddf86c7a890b0d0e +6b7887697685171a1dc2daf5c5ddf84c5560353b438696a92e343a5d6875 +c5ddf8bad0ea5f6b7898aabf8797aa171a1ebdd4eec5ddf8c5ddf8bed5ef +10121477869690a2b5c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8adc2d9181b1f657280454e5710121497a9bec5ddf8687583282d33 +8191a38e9fb2535d69c3dbf6bad1eb101214c5ddf8c5ddf86a77865a6571 +c5ddf88fa1b41e21258292a4414952040505b0c6dec5ddf84e5863363c44 +8899ac899aad5b6773c5ddf8c5ddf88899ac3c434bc5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf892a3b7 +363c44c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8657280606c79c5ddf8c5ddf8 +c5ddf8c5ddf8b8cfe80000008798abc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +deecfbc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8050606b3c9e1c5ddf8a6bad116191cc5ddf83f474f3f474f687583 +6875836875838ea0b3c5ddf8c5ddf823272c9fb2c8c5ddf8c5ddf8c5ddf8 +c5ddf8bad0ea6f7c8c1a1d211e2125b6cce5c5ddf8363d458190a2c5ddf8 +c5ddf8343a427f8fa0c5ddf822272ba8bcd4c5ddf898aabf2c3238c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf896a9bd252a2f +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf82024289cafc4c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8b9d0e98595a8414952101315101214030303000000000000000000 +0d0f119cafc5c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8eff5fdffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +dfdfdf494949ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8bed5ef9fb3c98797aa4d5661 +c5ddf8c5ddf8c5ddf899acc17c8b9c92a4b8c1d8f3c5ddf8adc3daadc2d9 +c5ddf8c5ddf899acc1bfd6f1c5ddf8c5ddf8a9bed58899acb2c8e0a4b8cf +c5ddf8c5ddf8c3dbf693a5b97c8b9c98abc0c3dbf6c5ddf8c5ddf8a0b4ca +b8cfe8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8acc1d82a2f35c5ddf8c5ddf8c5ddf8c5ddf872808f +626e7cc5ddf8c5ddf8c5ddf8c5ddf8c5ddf83b424a667381c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8bfd6f18ea0b3 +4b545f1416190506060a0c0da6bad1c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c8dff8ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffffffffffffffffffffffffffff0f6fdc5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c3dbf63a41490d0e10 +0000000101010e10125e6976c5ddf8c5ddf8c5ddf8c5ddf8c5ddf86c7a89 +525c68626e7c677482bad0eac5ddf8c5ddf8c1d8f36c79884c5560738190 +c3dbf6c5ddf8c1d8f36f7c8c4b545f65717fa3b6cdc5ddf8c5ddf8c5ddf8 +c5ddf8a8bcd4717f8e667381c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8bad1eb72808f93a5b925292eaec3dbc5ddf8c5ddf8 +899aad515b67515b67808fa1c5ddf8c0d7f26a7786c5ddf8c5ddf898aabf +8fa1b4c5ddf8c5ddf8a3b7ce55606b8797aa707d8dbad1ebc5ddf8c4dcf7 +7d8d9e4e586355606b8c9db1c5ddf8c5ddf8a6bbd28190a2c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8282d33aabfd6c5ddf8c5ddf8c5ddf8c3dbf6202428b3c9e1c5ddf8 +c5ddf8c5ddf8c5ddf89db0c6090a0bb4cae3c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8deecfbc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf80506068e9fb2c5ddf88190a247505ac5ddf8626e7b434c55 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf823272ca1b5cbc5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8bad1eb25292e899aadc5ddf8525c68545f6a +c5ddf8c4dcf70d0e109fb2c8c5ddf822272ba8bcd4c5ddf898aabf2c3238 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8b7cde6 +0a0c0dc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c4dcf7060708bbd2ecc5ddf8 +c5ddf8c5ddf8c5ddf891a2b693a5b9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8a3b7ce68758325292e0e1012 +0c0d0f0000000a0b0c9cafc4c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8eff5fdffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffdddddd4a4a4affffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf892a4b88797aa8c9db12d3339 +8b9cb0c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8677482adc3dac5ddf8c5ddf8c5ddf8 +5c6874b8cfe8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf83d444cbbd2ecc5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8a9bed56e7b8b4c5560aec3dbc5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c8dff8ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffffffffffffffffffffffffffffffffff0f6fd +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +90a2b55b667264707e9fb2c8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +6c7a8958626ec5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c4dcf79db0c6c4dcf794a6ba262b30c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8899aad5f6b78c5ddf8c5ddf8c5ddf88e9fb25a6571c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf86a77865e6976c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8deecfbc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8050606272c31545e6a1b1f2391a2b6c5ddf8b8cfe8 +24282d363c44636f7d3c434b808fa1c5ddf8c5ddf823272ca1b5cbc5ddf8 +c5ddf8c5ddf8c5ddf82b3036636f7d5b66721a1d21bed5efc5ddf8a6bbd2 +1013154a545e282d333d444cc5ddf8c5ddf822272ba8bcd4c5ddf898aabf +2c3238c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8262b30a4b8cfc5ddf8c5ddf8c5ddf8c5ddf89cafc52c3137c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8383f46444d56c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +bdd4ee8b9caf48515b10121408090a9aadc2c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8eff5fdffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffdcdcdc4b4b4bffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8a4b8cf5d68755d6875 +a4b8cfc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +f0f6fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8808fa1707d8dc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf88292a48190a28190a2 +8190a28190a2a2b6ccc5ddf8c3dbf63d444c25292e525c68a3b7cec5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c1d9f4c3dbf6c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8deecfbc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8050606adc2d98495a7bbd2ecc5ddf8c5ddf8 +c5ddf8c1d8f38fa1b47d8c9d9cafc5c4dcf7c5ddf8c5ddf89cafc5bcd3ed +c5ddf8c5ddf8c5ddf8c5ddf8a6bad17f8fa091a2b6c0d7f2c5ddf8c5ddf8 +c5ddf8b0c6de8190a28d9eb1c2daf5c5ddf8c5ddf89cafc5bed5efc5ddf8 +bad0ea9fb2c8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf88696a94f5964c5ddf8c5ddf8c5ddf8c5ddf849525c8b9cb0 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf812141790a2b5c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8a9bed57d8c9dbdd4eec5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8eff5fdffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffdbdbdb4c4c4cffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffff0f6fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8deecfbc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8050606bfd6f1c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c4dcf7535d69c2daf5c5ddf8c5ddf8c1d8f3545e6a +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8b0c6de48515bc5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8eff5fdffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffdadada4e4e4effffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffeff5fdc5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffff0f6fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8deecfbc5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf85f6a77c2daf5c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8eff5fdffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffd9d9d94f4f4fffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffeff5fdc5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffff0f6fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8b8cfe8c2daf5c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8deecfbc5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8eff5fdffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffd8d8d8505050ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffeff5fdc5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffff0f6fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf87e8e9f282d335b6773c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8deecfbc5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8eff5fd +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffd7d7d7515151ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffeff5fd +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffffffffff0f6fdc5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8bad0ea131518c4dcf7c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8deecfbc5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c1d8f38797aab1c7dfc5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +eff5fdffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffd5d5d5525252 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +eff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c8dff8ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffffffffffffffff0f6fdc5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf80a0c0dc0d7f2c5ddf8c5ddf8 +c5ddf8c5ddf898abc0758393c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8deecfb +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c0d7f2697584171a1e9fb3c9 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8eff5fdffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffd4d4d4 +535353ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c8dff8ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffffffffffffffffffffff0f6fdc5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8171a1dadc2d9c5ddf8 +c5ddf8c5ddf8c5ddf86673811a1d21c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +deecfbc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf85f6a77 +6c7a89c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8eff5fdffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +d3d3d3545454ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c8dff8ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffffffffffffffffffffffffffff0f6fdc5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8657280333a41 +8494a6c5ddf8c5ddf8c5ddf8b6cce5aabfd6c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8deecfbc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +697584626e7bc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8363d4594a6bac5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8eff5fdffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffd2d2d2555555ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c8dff8ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffffffffffffffffffffffffffffffffff0f6fd +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf85c6874 +3d454d91a2b6c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8deecfbc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf87e8e9f414952c5ddf8c5ddf8c5ddf8c5ddf8c5ddf81113168798ab +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8eff5fdffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffd1d1d1575757ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +f0f6fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +14171ab0c5ddc5ddf8c5ddf8c5ddf8c5ddf8a6bbd27d8d9ec5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8deecfbc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8b9d0e92d33392a2f35abc0d7c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8eff5fdffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffd0d0d0585858ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8b5cbe4bcd3edc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8bed5efb4cae3c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffff0f6fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf80a0c0dc0d7f2c5ddf8c5ddf8c5ddf8c5ddf8717f8e0b0d0ec5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8deecfbc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf896a9bd21262a9db0c6c1d9f4c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8eff5fdffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffcfcfcf595959ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffeff5fdc5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8474f597d8d9ec5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf88a9bae404851c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffff0f6fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8b7cee714171ac5ddf8c5ddf8c5ddf8c5ddf8c5ddf84b545f57616d +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8deecfbc5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf86d7b8a5a6571c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8515b668fa1b4c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8eff5fdffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffcdcdcd5a5a5affffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffeff5fdc5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8b5cbe4bcd3edc5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf88a9bae404851c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffff0f6fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf87887972c3137667381c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8444d56 +b4c9e2c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8deecfbc5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8677482626e7cc5ddf8c5ddf8c5ddf8 +c5ddf8c3dbf60607087d8c9dc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8eff5fdffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffcccccc5b5b5bffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffeff5fdc5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +b2c8e0394148c5ddf8c5ddf8c5ddf83f474facc1d8c5ddf88a9bae282d32 +202428626e7cc4dcf7c5ddf8aabfd62a2f352a2f358e9fb2c5ddf8c5ddf8 +c5ddf8a9bdd44a535d262b3057616d404851c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffff0f6fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8deecfbc5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8bdd4ee3c434b8798abc5ddf8c5ddf8 +c5ddf8c5ddf89cafc5171a1dc0d7f2c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8eff5fd +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffcbcbcb5c5c5cffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffeff5fd +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8262b309baec3c5ddf8a3b6cd1e2226c5ddf8b1c7df0a0c0d +92a3b7abc0d7262b307f8fa0c5ddf8c5ddf8c5ddf8474f597d8d9ec5ddf8 +c5ddf8c5ddf8282d327f8fa0afc4dc2a2f35404851c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffffffffff0f6fdc5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8deecfbc5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8bcd3ed373e465d6875bbd2ecc5ddf8 +c5ddf8c5ddf8c5ddf89baec38fa1b4c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +eff5fdffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffcacaca5d5d5d +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +eff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf86c7a8957616dc5ddf85f6a7765717fc5ddf88393a5 +292e34c5ddf8c5ddf865717f47505ac5ddf8c5ddf8c5ddf8474f597d8d9e +c5ddf8c5ddf8b6cce50d0e10c4dcf7c5ddf86a7786404851c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c8dff8ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffffffffffffffff0f6fdc5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8deecfb +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8eff5fdffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffc9c9c9 +5f5f5fffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8b1c7df16191cc3dbf61b1f23abc0d7c5ddf8 +7988983d454dc5ddf8c5ddf87786963c434bc5ddf8c5ddf8c5ddf8474f59 +7d8d9ec5ddf8c5ddf8a2b6cc1b1f23c5ddf8c5ddf87d8c9d404851c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c8dff8ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffffffffffffffffffffff0f6fdc5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +deecfbc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8eff5fdffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +c8c8c8606060ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8343a426a77862c3238c5ddf8 +c5ddf895a7bb121417c5ddf8c5ddf84e58635b6773c5ddf8c5ddf8c5ddf8 +474f597d8d9ec5ddf8c5ddf8c4dcf7101315bad1ebc5ddf8545e6a404851 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c8dff8ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffffffffffffffffffffffffffff0f6fdc5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8deecfbc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8eff5fdffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffc7c7c7616161ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf87b8a9b050606738291 +c5ddf8c5ddf8c5ddf83239402c313748515b141619adc3dac5ddf88899ac +5b67732125293a41495b6773a3b6cdc5ddf8616d7a25292e4c55601c2023 +404851c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c8dff8ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffffffffffffffffffffffffffffffffff0f6fd +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8deecfbc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8eff5fdffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffc5c5c5626262ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8bed5ef93a5b9 +bbd2ecc5ddf8c5ddf8c5ddf8c1d8f38b9caf8191a3b4c9e2c5ddf8c5ddf8 +a9bdd493a5b993a5b993a5b993a5b9b4cae3c5ddf8c5ddf8a9bed58899ac +b2c8e0a4b8cfc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +f0f6fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8deecfbc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8eff5fdffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffc4c4c4636363ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffff0f6fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8deecfbc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8eff5fdffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffc3c3c3646464ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffeff5fdc5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8bed5efbdd4ee +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8adc2d9 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8b9d0e9c1d9f4c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffff0f6fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8deecfbc5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8eff5fdffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffc2c2c2656565ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffeff5fdc5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf83d454d +9fb2c8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +050606c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8748292b9d0e9c5ddf8c5ddf8c5ddf8c5ddf8717f8e6c7988c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffff0f6fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8deecfbc5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8eff5fdffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffc1c1c1676767ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffeff5fdc5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8a0b4ca +30363dc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8050606c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8191c20abc0d7c5ddf8c5ddf8c5ddf8c5ddf8bbd2ec1d2024 +bed5efc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8a0b4ca64707e56616cbbd2ecc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffff2f7fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8e0edfbc5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8eff5fd +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffc0c0c0686868ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffeff5fd +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf87a899a262b301e21253d454dadc2d9c5ddf8c5ddf893a5b9 +323940343a42606c798696a9c5ddf8c2daf568758325292e40485198abc0 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +4c5560798898c5ddf8c5ddf8c5ddf8c1d9f458636f292e34262b308190a2 +c5ddf8c5ddf805060674829223272c515b66bad0eac5ddf8c4dcf7657280 +212529272c318797aac5ddf8c5ddf8c5ddf83f474f8b9caf333a411e2226 +92a4b87d8d9e2a2f3505060625292e2a2f358a9baec5ddf8c5ddf8c5ddf8 +4b545f7a899ac5ddf8c5ddf8c5ddf8c5ddf8a8bcd4687583c2daf5c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8bad0ea8495a7 +3e464f1012140304041b1f22b7cde6c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffcde1f9c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8f1f7fdc5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +eff5fdffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffbfbfbf696969 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +eff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf898aabfb7cee7c1d9f46c7988363d45c5ddf8b9d0e9 +1012149cafc59eb1c70d0e10717f8ec5ddf86d7b8a30363daec3dba3b7ce +1b1e22c1d8f3c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8262b3098abc0c5ddf8c5ddf8c5ddf88292a4414952c1d9f4bed6f0 +a6bbd2c5ddf8c5ddf802020264707ebad0ea3a41498191a3c5ddf88495a7 +202428a9bdd496a9bd0d0f11adc3dac5ddf8c5ddf8191c20343a4298aabf +b3c9e1a7bcd3c5ddf8c5ddf8191c20abc0d7c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf86a7786545f6ac5ddf8c5ddf8c5ddf8c5ddf88798ab000000bed6f0 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8a2b6cc63707d21252a0e0f11 +090a0c0000000203031d2125b7cde6c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c8dff8ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffeef5fdd0e3f9c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8cbe1f9e4effcffffff +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8eff5fdffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffbebebe +6a6a6affffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8bed5ef8ea0b35f6a774a535d191c20c5ddf8 +8595a83a4149c5ddf8c5ddf83b424a717f8ec5ddf82a2f355f6a778b9caf +899aad2d333990a2b5c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8070809b3c9e1c5ddf8c5ddf8c5ddf88b9cb01e21257d8d9e +b3c9e1c5ddf8c5ddf8c5ddf8020202b6cce5c5ddf8707e8d545f6ac5ddf8 +4f59645d6875c5ddf8c5ddf831373e7b8a9bc5ddf8c5ddf8191c207e8e9f +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8191c20abc0d7c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf88495a7353b43c5ddf8c5ddf8c5ddf8c5ddf8bbd2eca6bad1 +c4dcf7c5ddf8c5ddf8bbd2ec728090373d450d0f110c0e0f010202000000 +000000000000020202171a1e95a8bca0b4caa0b4ca9fb3c99fb2c89fb2c8 +9eb1c79db0c69db0c69cafc59cafc49cafc49baec39aadc29aadc299acc1 +98abc098abc098aabf98aabf97a9be96a9bd96a9bd95a8bc95a7bb95a7bb +94a6ba93a5b993a5b992a4b892a3b792a3b791a2b691a2b690a2b58fa1b4 +8fa1b48ea0b38e9fb28e9fb28d9eb18c9db18c9db18b9cb08b9caf8b9caf +8a9bae8c9caeb2b2b2b1b1b1b1b1b1b0b0b0afafafafafafaeaeaeadadad +adadadacacacababababababaaaaaaaaaaaaa9a9a9a8a8a8a8a8a8a7a7a7 +a6a6a6a6a6a6a5a5a5a4a4a4a4a4a4a3a3a3a2a2a2a2a2a2a1a1a1a1a1a1 +a0a0a0cdcdcdffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fcfdfffbfdfffbfdfffbfdfffbfdfffbfdfffbfdfffbfdfffbfdfffbfdff +fbfdfffbfdfffbfdfffbfdfffbfdfffbfdfffbfdfffbfdfffbfdfffbfdff +fbfdfffbfdfffbfdfffbfdfffbfdfffbfdfffbfdfffbfdfffbfdfffbfdff +fbfdfffbfdfffbfdfffbfdfffbfdfffbfdfffbfdfffbfdfffbfdfffbfdff +fbfdfffbfdfffbfdfffbfdfffbfdfffbfdfffbfdfffbfdfffbfdfffbfdff +fbfdfffbfdfffbfdfffbfdfffbfdfffbfdfffbfdfffbfdfffbfdfffbfdff +fbfdfffbfdfffbfdfffbfdfffbfdfffbfdfffbfdfffbfdfffbfdfffbfdff +fbfdfffbfdfffbfdfffbfdfffbfdfffbfdfffbfdfffbfdfffbfdfffbfdff +fbfdfffbfdfffbfdfffbfdfffbfdfffbfdfffbfdfffbfdfffbfdfffbfdff +fbfdfffbfdfffbfdfffbfdfffbfdfffbfdfffbfdfffbfdfffbfdfffbfdff +fbfdfffbfdfffbfdfffbfdfffbfdfffbfdfffbfdfffbfdfffbfdfffbfdff +fbfdfffbfdfffbfdfffbfdfffbfdfffbfdfffbfdfffbfdfffbfdfffbfdff +fbfdfffbfdfffbfdfffbfdfffbfdfffbfdfffbfdfffbfdfffeffffffffff +ffffffcae0f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8f4f8feffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +bcbcbc6b6b6bffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8454e57515b6790a2b5808fa114171a +c5ddf873819049525cc5ddf8c5ddf84a535d717f8ec5ddf81e2125515b66 +6875836875836875839eb1c7c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8141619a9bdd4c5ddf8c5ddf8c5ddf8c5ddf895a7bb +434b54050606758393c5ddf8c5ddf8050606c5ddf8c5ddf87685954e5762 +c5ddf8464e58717f8ec5ddf8c5ddf8434c55707d8dc5ddf8c5ddf8191c20 +a9bdd4c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8191c20abc0d7c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf87a8899414952c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8b8cfe8616d7a090b0c010101010102000000000000 +000000000000000000030304202428424a53434b54434c55434c55444d56 +444d56454e57464e58464e58474f5947505a47505a48515b49525c49525c +4a535d4a545e4a545e4b545f4c55604c55604d56614d56614e57624e5863 +4e58634f5964505a65505a65515b66515b67515b67525c68535d69535d69 +545e6a545f6a545f6a55606b55606b56616c57616d57616d58626e58636f +58636f5964705c6672757575767676777777777777787878797979797979 +7a7a7a7a7a7a7b7b7b7c7c7c7c7c7c7d7d7d7e7e7e7e7e7e7f7f7f808080 +808080818181828282828282838383838383848484858585858585868686 +8787875d5d5d787878ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe3effcc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8d0e4f9ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffbbbbbb6c6c6cffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c2daf50a0c0dbdd4eec5ddf8717f8e +14171ac5ddf8a7bcd31e2125c4dcf7c4dcf71e2226717f8ec5ddf8404851 +65717fc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8343a428d9eb1c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf87382912f353cc5ddf8c5ddf8050606c5ddf8c5ddf8768595 +4e5762c5ddf8626e7b454e57c5ddf8c5ddf81b1f238fa1b4c5ddf8c5ddf8 +191c20abc0d7c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8282d339db0c6c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf85e6976626e7cc5ddf8c5ddf8c5ddf8c5ddf8 +b3c9e17a899abbd2ecc5ddf8c5ddf8c5ddf8c5ddf8b2c8e0798899333a41 +0e10120e10120000000000000000000c0e106c7988c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c8dff8ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffafafaf787878ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffeffffeef5fdddebfbdcebfbdcebfbdcebfbdcebfb +dcebfbdcebfbdcebfbdcebfbdcebfbdcebfbdcebfbdcebfbdcebfbdcebfb +dcebfbdcebfbdcebfbdcebfbdcebfbdcebfbdcebfbdcebfbdcebfbdcebfb +dcebfbdcebfbdcebfbdcebfbdcebfbdcebfbdcebfbdcebfbdcebfbdcebfb +dcebfbdcebfbdcebfbdcebfbdcebfbdcebfbdcebfbdcebfbdcebfbdcebfb +dcebfbdcebfbdcebfbdcebfbdcebfbdcebfbdcebfbdcebfbdcebfbdcebfb +dcebfbdcebfbdcebfbdcebfbdcebfbdcebfbdcebfbdcebfbdcebfbdcebfb +dcebfbdcebfbdcebfbdcebfbdcebfbdcebfbdcebfbdcebfbdcebfbdcebfb +dcebfbdcebfbdcebfbdcebfbdcebfbdcebfbdcebfbdcebfbdcebfbdcebfb +dcebfbdcebfbdcebfbdcebfbdcebfbdcebfbdcebfbdcebfbdcebfbdcebfb +dcebfbdcebfbdcebfbdcebfbdcebfbdcebfbdcebfbdcebfbdcebfbdcebfb +dcebfbdcebfbdcebfbdcebfbdcebfbdcebfbdcebfbdcebfbdcebfbdcebfb +dcebfbdcebfbdcebfbdcebfbdcebfbdcebfbdcebfbdcebfbdcebfbdcebfb +dcebfbdcebfbe9f2fcfefeffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffbababa6d6d6dffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8404851404851525c68 +30363d14171ac5ddf8c5ddf84c5560272c312c3238282d3372808fc5ddf8 +a6bad11a1d21424a53626e7b30363d9fb2c8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8697584616d7ac5ddf8c5ddf8c5ddf8 +6976854d56616976852b3036768494c5ddf8c5ddf8050606c5ddf8c5ddf8 +7685954e5762c5ddf8b0c6de14171a454e572f353c2e343ac4dcf7c5ddf8 +c5ddf8191c20abc0d7c5ddf8c5ddf8c5ddf8c5ddf8c5ddf86c7988252a2f +5a65719db0c6c5ddf8c5ddf8c5ddf831373e97a9bec5ddf8c5ddf8c5ddf8 +c5ddf892a3b7000000b0c5ddc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c2daf598aabf57616d191d200f11130607080404056a7786c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffaeaeae797979ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffb9b9b96f6f6fffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c4dcf793a5b9 +8c9db1bad0ea98abc0c5ddf8c5ddf8c5ddf8abc0d7b0c6de3e464e97a9be +c5ddf8c5ddf8bad0ea8a9bae7e8e9fa6bad1c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8bad1eb202428c0d7f2c5ddf8 +c5ddf8bad1eb8d9eb17f8fa0afc4dcc5ddf8c5ddf8c5ddf895a7bbc5ddf8 +c5ddf8b1c7dfa7bcd3c5ddf8c5ddf8b5cbe48292a48a9baec0d7f2c5ddf8 +c5ddf8c5ddf89aadc2bed6f0c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +b6cce594a6bab2c8e0c5ddf8c5ddf8a3b6cd32383fc5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf86c7988363c44c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8b3c9e17a899a343b420a0b0c +6e7b8bc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffadadad7a7a7affffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffb8b8b8707070ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffeff5fdc5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf875839395a8bc7583931c2023 +c3dbf6c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf87887979cafc5 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf87c8b9c98abc0c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf85c68749cafc4c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c2daf59aadc2b9d0e9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffadadad7b7b7bffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffb7b7b7717171ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffeff5fdc5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf88191a3535d69758393 +b9d0e9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffacacac7b7b7bffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffb6b6b6727272ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffeff5fdc5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffababab7c7c7cffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffb4b4b4737373ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffeff5fd +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffababab7d7d7d +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffb3b3b3747474 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +eff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c8dff8ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffaaaaaa +7d7d7dffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffb2b2b2 +757575ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c8dff8ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +a9a9a97e7e7effffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +b1b1b1767676ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c8dff8ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffa9a9a97f7f7fffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffafcfef6fafef6fafef6fafef6fafef6fafef6fafef6fafef6fafe +f6fafef6fafef6fafef6fafef6fafef6fafef6fafef6fafef6fafef6fafe +f6fafef6fafef6fafef6fafef6fafef6fafef6fafef6fafef6fafef6fafe +f6fafef6fafef6fafef6fafef6fafef6fafef6fafef6fafef6fafef6fafe +f6fafef6fafef6fafef6fafef6fafef6fafef6fafef6fafef6fafef6fafe +f6fafef6fafef6fafef6fafef6fafef6fafef6fafef6fafef6fafef6fafe +f6fafef6fafef6fafef6fafef6fafef6fafef6fafef6fafef6fafef6fafe +f6fafef6fafef6fafef6fafef6fafef6fafef6fafef6fafef6fafef6fafe +f6fafef6fafef6fafef6fafef6fafef6fafef6fafef6fafef6fafef6fafe +f6fafef6fafef6fafef6fafef6fafef6fafef6fafef6fafef6fafef6fafe +f6fafef6fafef6fafef6fafef6fafef6fafef6fafef6fafef6fafef6fafe +f6fafef6fafef6fafef6fafef6fafef6fafef6fafef6fafef6fafef6fafe +f6fafef6fafef6fafef6fafef6fafef6fafef6fafef6fafef6fafef8fbfe +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffb0b0b0787878ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c8dff8ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffa8a8a87f7f7fffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +f9fcfed8e8fac6ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8d1e4f9f5f9feffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffafafaf797979ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffa7a7a7808080ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffe1edfbc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8d8e8faffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffaeaeae7a7a7affffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffa7a7a7818181ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffd1e4f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c6ddf8ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffacacac7b7b7bffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffeff5fdc5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffa6a6a6818181ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffd0e3f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffababab7c7c7cffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffeff5fdc5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffa5a5a5828282ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffd0e3f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffaaaaaa7d7d7dffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffeff5fdc5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8b5cbe4bcd3edc5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8bed5efb4cae3c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffa5a5a5838383ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffd0e3f9c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffa9a9a97e7e7effffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffeff5fd +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8474f597d8d9ec5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf88a9bae404851c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffa4a4a4838383 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffd0e3f9c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffa8a8a8808080 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +eff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8b5cbe4bcd3ed +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf88a9bae404851c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c8dff8ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffa3a3a3 +848484ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffd0e3f9c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffa7a7a7 +818181ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8b2c8e0394148c5ddf8c5ddf8c5ddf83f474facc1d8 +c5ddf88a9bae282d32202428626e7cc4dcf7c5ddf8aabfd62a2f352a2f35 +8e9fb2c5ddf8c5ddf8c5ddf8a9bdd44a535d262b3057616d404851c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c8dff8ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +a3a3a3858585ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffd0e3f9c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +a6a6a6828282ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8262b309baec3c5ddf8a3b6cd1e2226 +c5ddf8b1c7df0a0c0d92a3b7abc0d7262b307f8fa0c5ddf8c5ddf8c5ddf8 +474f597d8d9ec5ddf8c5ddf8c5ddf8282d327f8fa0afc4dc2a2f35404851 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c8dff8ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffa2a2a2858585ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffd0e3f9 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffa4a4a4838383ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf86c7a8957616dc5ddf85f6a77 +65717fc5ddf88393a5292e34c5ddf8c5ddf865717f47505ac5ddf8c5ddf8 +c5ddf8474f597d8d9ec5ddf8c5ddf8b6cce50d0e10c4dcf7c5ddf86a7786 +404851c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c8dff8ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffa1a1a1868686ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +d0e3f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffa3a3a3848484ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8b1c7df16191cc3dbf6 +1b1f23abc0d7c5ddf87988983d454dc5ddf8c5ddf87786963c434bc5ddf8 +c5ddf8c5ddf8474f597d8d9ec5ddf8c5ddf8a2b6cc1b1f23c5ddf8c5ddf8 +7d8c9d404851c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffa0a0a0878787ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffd0e3f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffa2a2a2858585ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8343a42 +6a77862c3238c5ddf8c5ddf895a7bb121417c5ddf8c5ddf84e58635b6773 +c5ddf8c5ddf8c5ddf8474f597d8d9ec5ddf8c5ddf8c4dcf7101315bad1eb +c5ddf8545e6a404851c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffa0a0a0878787ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffd0e3f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf88495a77482928798abc5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf88495a7bed5efc5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8b0c5dd90a2b5c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8a1b5cb748292748292bcd3edc5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffa1a1a1868686ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffeff5fdc5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +7b8a9b050606738291c5ddf8c5ddf8c5ddf83239402c313748515b141619 +adc3dac5ddf88899ac5b67732125293a41495b6773a3b6cdc5ddf8616d7a +25292e4c55601c2023404851c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff9f9f9f888888ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffd0e3f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf88ea0b3626e7c2e343a +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8181b1fb2c8e0c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf85a6571a2b6cc +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf893a5b94a535d +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8a6bbd28190a20e1012aec3db +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffa0a0a0888888ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffeff5fdc5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8bed5ef93a5b9bbd2ecc5ddf8c5ddf8c5ddf8c1d8f38b9caf8191a3 +b4c9e2c5ddf8c5ddf8a9bdd493a5b993a5b993a5b993a5b9b4cae3c5ddf8 +c5ddf8a9bed58899acb2c8e0a4b8cfc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffff9e9e9e898989ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffd0e3f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c4dcf7afc4dcb9d0e9c5ddf8c5ddf8c5ddf896a9bd +2e343ac5ddf8c5ddf8c5ddf8c5ddf8c5ddf8b3c9e1b3c9e1c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8bdd4eeb0c6dec5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +b2c8e0bad0eac5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8b9d0e9b4c9e2c5ddf8c5ddf8c5ddf8181b1fb2c8e0 +b7cee7c2daf5c5ddf8c5ddf8c5ddf8c5ddf8b7cde6b7cde6c5ddf8c5ddf8 +c5ddf8c5ddf8c0d7f2c4dcf7c1d9f4b0c5ddc5ddf8c3dbf6bed6f02f343b +8fa1b4bed6f0c2daf5c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c0d7f2c4dcf7b7cde6c5ddf8c5ddf8c5ddf8c5ddf8c0d7f2bed6f0 +c1d8f3c5ddf8c5ddf8c5ddf8bfd6f1bad1ebbed5efc1d9f4bbd2ecc5ddf8 +c5ddf8bfd6f1c5ddf8b6cce5c5ddf8c5ddf8c5ddf8c5ddf8c5ddf816191c +aec3dbc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffff9f9f9f898989ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffeff5fdc5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff9e9e9e8a8a8affffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffd0e3f9c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf895a7bb131518252a2f2024288494a6c5ddf8c5ddf8 +96a9bd2e343ac5ddf8c5ddf8c5ddf8c5ddf82d33392d3339282d3325292e +aec3dbc5ddf8c5ddf847505a2f343b373e463d454dc5ddf8c5ddf8a9bdd4 +282d33373e46282d337d8d9ec5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c2daf5363c44323940323940525c68c5ddf8c5ddf8181b1f +47505a282d321b1f239eb1c7c5ddf8c4dcf7454e57131518131518444d56 +c4dcf7c5ddf8c5ddf830363d616d7a14161923272c67748292a3b730363d +0b0d0e25292e30363d7b8a9bc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8292e34353b4321262a282d3295a7bbc5ddf8c5ddf84b545f +22272b383f46c5ddf8c5ddf8c5ddf80d0e1032383f15181b3941481e2125 +a1b5cbc5ddf8101214363c4424282d31373ea3b6cdc5ddf8c5ddf8c5ddf8 +16191caec3dbc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff9e9e9e8a8a8affffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffeff5fd +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8bdd4eebdd4eec5ddf8c5ddf8c5ddf8b6cce5 +c4dcf7c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff9d9d9d8a8a8a +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffd0e3f9c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c0d7f214171a8797aac5ddf8c4dcf7b3c9e1c5ddf8 +c5ddf896a9bd2e343ac5ddf8c5ddf8c5ddf8c5ddf8b7cde6c5ddf8c5ddf8 +5a65715c6874c5ddf8a6bbd21e2125c5ddf8c5ddf8bfd6f1c5ddf8c5ddf8 +5c6874687583c5ddf8c5ddf8bfd6f1c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf88d9eb1373e46c5ddf8c5ddf8bfd6f1c5ddf8c5ddf8 +181b1f72808fc5ddf86976855e6976c5ddf88798ab1f2327bed5efbfd6f1 +24282d8696a9c5ddf8c5ddf830363d31373eb7cee7c5ddf8bcd3edc5ddf8 +c5ddf830363d94a6bac5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8292e3455606bc5ddf892a3b732383fc5ddf8c5ddf8 +c5ddf88c9db1383f46c5ddf8c5ddf8c5ddf8060607c2daf5272c318696a9 +697584788797c5ddf8101214707d8dc5ddf87887974c5560c5ddf8c5ddf8 +c5ddf816191caec3dbc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff9c9c9c8b8b8b +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +eff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf88c9db1a1b5cbc5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf83b424aa1b5cbc5ddf8c5ddf8c5ddf8 +57616d8595a8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c8dff8ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff9c9c9c +8b8b8bffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffd0e3f9c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8a4b8cf0d0f11c2daf5c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf896a9bd2e343ac5ddf8c5ddf8c5ddf8c5ddf890a2b5505a65 +2b30361b1e224a535dc5ddf8c0d7f21e22263d454d768494bcd3edc5ddf8 +c5ddf88c9db1171a1e535d6992a3b7c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8b2c8e0171a1e454e577e8e9fc1d8f3c5ddf8 +c5ddf8181b1fa9bdd4c5ddf88c9db1383f46c5ddf8616d7a515b66c5ddf8 +c5ddf8535d695d6875c5ddf8c5ddf830363d768494c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf830363d94a6bac5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8292e348798abc5ddf8bfd6f1090a0bbed5ef +c5ddf8c5ddf88c9db1383f46c5ddf8c5ddf8c5ddf814171ac5ddf8383f46 +98abc0768595616d7ac5ddf8101214a1b5cbc5ddf8a9bed5171a1dc5ddf8 +c5ddf8c5ddf816191caec3dbc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff9b9b9b +8c8c8cffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf88899ac4e576258636f9baec3c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf84c5560788797c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf89eb1c7323940c5ddf8c5ddf8c5ddf8 +c5ddf8abc0d7262b30c4dcf7c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c8dff8ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +9c9c9c8c8c8cffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffd0e3f9c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8a4b8cf0d0f11c2daf5c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf897a9be2d3339c5ddf8c5ddf8c5ddf8b9d0e916191c +a0b4cac4dcf769768547505ac5ddf8c5ddf8c2daf58a9bae1e222621262a +c5ddf8c5ddf8c5ddf8b4cae36774820506066c7988c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8bfd6f17f8fa01416193b424a +c5ddf8c5ddf8181b1fb2c8e0c5ddf88e9fb2363d45c5ddf8626e7b515b66 +c5ddf8c5ddf8535d695d6875c5ddf8c5ddf830363d94a6bac5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf830363d94a6bac5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8292e348797aac5ddf8bfd6f108090a +bcd3edc5ddf8c5ddf88c9db1383f46c5ddf8c5ddf8c5ddf8171a1ec5ddf8 +3b424a9cafc47988985e6976c5ddf8101214a0b4cac5ddf8a9bdd414171a +c5ddf8c5ddf8c5ddf8171a1dadc3dac5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +9a9a9a8d8d8dffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c1d8f32d33390b0d0e0000000000000b0d0e +5b6672c5ddf8c5ddf8c5ddf8c5ddf84f596465717f25292e525c68afc4dc +c5ddf8c5ddf88a9bae282d32202428626e7cc4dcf7c5ddf8c5ddf8667381 +2c323824282d6d7b8ac5ddf8a6bad12a2f351012141a1d212a2f35626e7c +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8626e7b636f7d +282d3347505aa7bcd3c5ddf8c5ddf8a3b7ce39414825292e6c7988bbd2ec +c5ddf8c5ddf87988987381904f59641b1f2357616dc5ddf8b7cee7505a65 +262b30292e3492a4b8c5ddf8c5ddf88899ac272c3121252964707ec4dcf7 +c5ddf87887976976853941482b30368b9cafc5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf84a535d7c8b9cc5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf831373e94a6bac5ddf8c5ddf8c5ddf8c5ddf89cafc5 +717f8ec5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c8dff8ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffff9b9b9b8c8c8cffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffd0e3f9 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c0d7f214171a8797aac5ddf8 +c4dcf7b4c9e2c5ddf8c5ddf8bad1eb131518bdd4eec5ddf8c5ddf89cafc4 +272c31c5ddf8bed6f02a2f3547505ac5ddf8bad1ebc1d8f3c5ddf8b4c9e2 +0e1012c0d7f2c5ddf8b6cce5c5ddf8c5ddf86c7988505a65c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8b7cee7c3dbf6c5ddf89cafc5 +1f2327c5ddf8c5ddf8181b1fb2c8e0c5ddf88e9fb2363d45c5ddf8899aad +1e2125bcd3edbed5ef22272b8899acc5ddf8c5ddf830363d94a6bac5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf84d5661798898c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8292e34535d69c5ddf88ea0b3 +31373ec5ddf8c5ddf8c5ddf88c9db1383f46c5ddf8c5ddf8c5ddf8171a1e +c5ddf83b424a9cafc47988985e6976c5ddf81012146c7a89c5ddf8758393 +4a545ec5ddf8c5ddf8c5ddf84047508696a9c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffff9999998e8e8effffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf85c6874070809000000000000000000 +0000000d0f1197a9bec5ddf8c5ddf8c5ddf82e343a363d45b4c9e26e7b8b +3a4149c5ddf8b1c7df0a0c0d92a3b7abc0d7262b307f8fa0c5ddf89cafc5 +2b3036bfd6f1c2daf5a3b6cdc5ddf8c5ddf8c5ddf84c5560788797c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8454e57 +262b30adc3da8494a623272cc5ddf8bbd2ec141619808fa1bbd2ec55606b +6c7988c5ddf8c5ddf864707e101214798898b8cfe89cafc4c5ddf8697584 +596470c4dcf7bad0eaabc0d7c5ddf8b0c5dd0a0c0d93a5b9aabfd625292e +8292a4c5ddf8626e7c1b1f23a9bdd494a6ba202428c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf824282d9baec3c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8515b666e7b8bc5ddf8c5ddf8c5ddf8c5ddf8 +6e7b8b121417c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c8dff8ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff9a9a9a8d8d8dffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +d0e3f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf895a8bc171a1d +262b3022272b8495a7c5ddf8c5ddf8c5ddf86976851d202431373ec5ddf8 +c5ddf83d444c2a2f351b1e2247505a47505ac5ddf899acc1181b1f394047 +282d326d7b8ac5ddf8c5ddf856616c24282d363d452b3036a5b9d0c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf88393a51b1e22394047 +272c318191a3c5ddf8c5ddf8181b1fb2c8e0c5ddf88e9fb2363d45c5ddf8 +c4dcf7454e57111316121417444d56c4dcf7c5ddf8c5ddf830363d94a6ba +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf899acc12d3339282d33788797c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8292e34323940202428 +272c3195a7bbc5ddf8a2b6cc2a2f351e21250c0d0f2a2f355b6773c5ddf8 +171a1ec5ddf83b424a9cafc47988985e6976c5ddf8101214333a4122272b +30363da2b6ccc5ddf8c5ddf8c5ddf898aabf292e341e21259db0c6c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff9898984343437979797b7b7b7c7c7c7e7e7e7f7f7f818181 +8282828484848686868787878989898a8a8a8c8c8c8d8d8d8f8f8f909090 +9292929494949595959797979898989a9a9a9b9b9b9d9d9d9e9e9ea0a0a0 +a1a1a1a3a3a3a5a5a5a6a6a69da1a78292a48494a68495a78696a98797aa +8899ac8a9bae8b9caf8c9db18d9eb18ea0b3101215000000000000000000 +0000000000000000004e5762c5ddf8c5ddf8c5ddf82e343a798898c5ddf8 +bcd3ed0b0d0ec1d9f48393a5292e34c5ddf8c5ddf865717f47505ac5ddf8 +a5b9d0121417768494adc3dac5ddf8c5ddf8c5ddf8c5ddf84c5560788797 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +454e57626e7bc5ddf8c5ddf8101315b4c9e28b9cb0181b1f8b9cb08a9bae +717f8e2f343bc5ddf8c5ddf864707e333a41c5ddf8c5ddf8c5ddf8c5ddf8 +72808f2b30368495a7b8cfe8c5ddf8c5ddf88190a22c3238c5ddf8c5ddf8 +626e7c4a535dc5ddf8626e7c545f6ac5ddf8c5ddf80d0e10b8cfe8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c4dcf7050606b6cce5 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf86b78874e5863c5ddf8c5ddf8c5ddf8 +c5ddf8b7cee7a9bdd4c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff9a9a9a8e8e8effffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffd0e3f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8b0c6debcd3edc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8b7cde6c1d9f4c5ddf8c5ddf8c5ddf8c5ddf8c1d8f3 +adc3dac3dbf6c5ddf8c5ddf8c5ddf8c5ddf8b9d0e9b4c9e2c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8bed6f0 +aec3dbc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8b7cde6b7cde6c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8292e349baec3 +b6cce5c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8101214b4cae3 +b5cbe4c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffdfdfdfafafafadadadabababaaaaaaa8a8a8a6a6a6 +a4a4a4a3a3a3a1a1a19f9f9f9e9e9e9c9c9c9a9a9a989898979797959595 +9393939292929090908e8e8e8c8c8c8b8b8b898989878787868686848484 +8282828181817f7f7f7d7d7d7b7b7b7275795c68745b66725a657158636f +57616d55606b545f6a535d69515b67515b664f5964060607000000000000 +0000000000000000000000003a4149c5ddf8c5ddf8c5ddf82e343a8a9bae +c5ddf8c5ddf80a0c0db2c8e07988983d454dc5ddf8c5ddf87786963c434b +c5ddf8c5ddf89fb3c94e58630405055f6a77c5ddf8c5ddf8c5ddf84c5560 +788797c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8454e57738190c5ddf8c5ddf82024289baec37f8fa01d2024687583 +687583687583707e8dc5ddf8c5ddf864707e5f6a77c5ddf8c5ddf8c5ddf8 +c5ddf8c4dcf7899aad363d450a0b0c8a9baec5ddf8768595404750c5ddf8 +c5ddf87482923e464ec5ddf8626e7c687583c5ddf8c5ddf8121417b2c8e0 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8101315 +abc0d7c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8606c795b6773c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff9999998e8e8effffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffd0e3f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8292e34 +9baec3c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8101214 +b4cae3c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffeff5fdc5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8343a42000000 +000000000000000000000000060708707e8dc5ddf8c5ddf8c5ddf82e343a +64707ec5ddf8a9bed51e2226c5ddf895a7bb121417c5ddf8c5ddf84e5863 +5b6773c5ddf8c5ddf8c5ddf8c5ddf88e9fb216191cc5ddf8c5ddf8c5ddf8 +5b67736a7786c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8454e574d5661c5ddf8bed5ef0d0f11c1d9f4a2b6cc0a0c0d +bed6f0c5ddf8c5ddf8c5ddf8c5ddf8c5ddf864707e606c79c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf85b667249525cc5ddf892a4b814171a +c5ddf8c5ddf84c55605e6976c5ddf8626e7c687583c5ddf8c5ddf8121417 +b2c8e0c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +32383f8fa1b4c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8444d567c8b9cc5ddf8 +c5ddf8c5ddf8c5ddf8a9bdd47b8a9bc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff9898988f8f8fffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffd0e3f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf89fb2c86e7b8b6e7b8b6e7b8b6e7b8b6e7b8bc0d7f2c5ddf8 +99acc1b9d0e9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +92a4b8c0d7f2c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffeff5fdc5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8a8bcd4 +0f11130000000000000000000506061d2024c0d7f2c5ddf8c5ddf8c5ddf8 +2e343a1d2024505a65202428707e8dc5ddf8c5ddf83239402c313748515b +141619adc3dac5ddf87e8e9f454e576a7786363d455d6875c5ddf8c5ddf8 +c5ddf899acc1191c20545e6a8292a4c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8454e57191c204a545e262b305c6874c5ddf8c5ddf8 +56616c1e21255f6a774f59644b545fc5ddf8c5ddf864707e606c79c5ddf8 +c5ddf8c5ddf8c5ddf855606b545f6a6774822125298ea0b3c5ddf8c4dcf7 +30363d2d333947505a14171aafc4dcc5ddf8626e7c687583c5ddf8c5ddf8 +121417b2c8e0c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8667381636f7dc5ddf8c5ddf8c5ddf8c5ddf8c3dbf61d2024adc3da +c5ddf8c5ddf8c5ddf8c5ddf8788797030404c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffff989898909090ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffd0e3f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffeff5fdc5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8a8bcd42c32380b0d0e10131549525cbad1ebc5ddf8c5ddf8c5ddf8 +c5ddf82e343a8d9eb18595a8b0c5ddc5ddf8c5ddf8c5ddf8c1d8f38b9caf +8191a3b4c9e2c5ddf8c5ddf8bed6f092a3b77d8c9da8bcd4c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8bfd6f198abc0a6bad1c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8454e577b8a9b899aada8bcd4c5ddf8c5ddf8 +c5ddf8c5ddf8a0b4ca7d8c9d8e9fb2bed5efc5ddf8c5ddf8adc2d9acc1d8 +c5ddf8c5ddf8c5ddf8c5ddf8b6cce58899ac8393a5b4cae3c5ddf8c5ddf8 +c5ddf8c0d7f28a9bae8191a3b4cae3c5ddf8c5ddf8adc2d9adc3dac5ddf8 +c5ddf898abc0c0d7f2c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8bad0ea202428c1d8f3c5ddf8c5ddf8c5ddf8899aad4b545f +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8525c684f5964c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff979797909090ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffd0e3f9c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffeff5fd +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf82e343a96a9bdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8454e577f8fa0c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf87685959eb1c7c5ddf8c5ddf8c5ddf86a7786 +a9bed5c5ddf8c5ddf8c5ddf8c5ddf8c5ddf849525cafc4dcc5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff969696919191 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffd0e3f9c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c4dcf78494a658626eb4c9e2c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +eff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +b6cce5c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8758393acc1d8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8abc0d76e7b8b +6e7b8b6e7b8b6e7b8b6e7b8bb4c9e2c5ddf88191a39fb3c9c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c8dff8ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff969696 +929292ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffd0e3f9c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf89eb1c721262a97a9bec1d8f3 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8515b6623272c8ea0b3c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c8dff8ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +959595929292ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffd0e3f9c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf86f7c8c55606bc5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf87e8e9f4e5762c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c8dff8ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffff949494939393ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffd0e3f9 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf86875835b6672 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf892a3b7394047c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf87c8b9c92a3b7c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c8dff8ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff949494949494ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +d0e3f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8bdd4ee394047 +7a8899c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf89eb1c725292ec5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8282d3358626ec5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff939393949494ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffd0e3f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8b4c9e2131518 +212529bcd3edc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c1d8f32f343b515b66a3b6cd +c5ddf8c5ddf8c5ddf8adc2d9b4c9e2c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff929292959595ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffd0e3f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c3dbf63f474f738190c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffeff5fdc5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8bfd6f1262b305f6b78 +a9bed5c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff919191969696ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffd0e3f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf86976855a6571c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffeff5fdc5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf89cafc5282d32 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf88fa1b495a7bbc5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffff919191979797ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffd0e3f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8707e8d545e6ac5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffeff5fdc5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf892a3b7 +394047c5ddf8c5ddf8c5ddf8c5ddf8c5ddf832394049525cc5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff909090979797ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffd0e3f9c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8a2b6cc1d20248b9cafbfd6f1c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffeff5fd +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +7a899a515b66c5ddf8c5ddf8c5ddf8c5ddf8c4dcf70e101295a7bbc5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff8f8f8f989898 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffd0e3f9c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf892a3b7697685b7cde6c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +eff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +49525c2c323895a7bbc5ddf8c5ddf8c5ddf8c5ddf8adc2d94c5560c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c8dff8ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff8f8f8f +999999ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffd0e3f9c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c2daf5c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c8dff8ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +8e8e8e999999ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffd0e3f9c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c8dff8ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffff8d8d8d9a9a9affffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffd0e3f9 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c8dff8ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff8d8d8d9b9b9bffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +d0e3f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf88696a95c6874c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8bad1eba4b8cf +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff8c8c8c9b9b9bffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffd0e3f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf87d8c9d4e5762 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf895a7bb +2f353cc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffeff5fdc5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff8b8b8b9c9c9cffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffd0e3f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8b6cce57482924b545f636f7dbad0eac5ddf87d8c9d +4e576275839357616da3b6cdc5ddf8c5ddf8c2daf5707d8d4b545f6e7b8b +c1d9f4c5ddf8c5ddf8abc0d776849498abc0535d69626e7cc3dbf66c7a89 +454e5716191c5b67735b6773c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffeff5fdc5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff8b8b8b9d9d9dffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffd0e3f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf84e57625e69769db0c67a899ab0c6dec5ddf8 +7d8c9d1012146d7b8a798898141619c5ddf8c5ddf855606b32383f8798ab +363d45515b67c5ddf8c5ddf895a7bb171a1e373e467f8fa0697685c0d7f2 +9cafc46f7c8c24282d93a5b993a5b9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffeff5fdc5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffff8a8a8a9d9d9dffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffd0e3f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf830363d707e8dbed5efc5ddf8c5ddf8 +c5ddf87d8c9d2f343bc5ddf8c5ddf81e2226a7bcd3c5ddf80b0d0e9cafc4 +c5ddf8a3b6cd070809c4dcf7c5ddf895a7bb020202b7cde6c5ddf8c5ddf8 +c5ddf8c5ddf895a7bb2f353cc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffeff5fdc5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff8989899e9e9effffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffd0e3f9c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8a3b7ce434c550c0d0f454e57 +b9d0e9c5ddf87d8c9d4e5762c5ddf8c5ddf82c323898aabfc0d7f2000000 +bed5efc5ddf8c1d8f3000000b7cee7c5ddf895a7bb282d32c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf895a7bb2f353cc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffeff5fd +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c8dff8 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff8989899f9f9f +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffd0e3f9c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8a6bbd2 +2024287c8b9cc5ddf87d8c9d4e5762c5ddf8c5ddf82c323898aabfc5ddf8 +0c0d0f9baec3c5ddf8a2b6cc08090ac5ddf8c5ddf895a7bb2f353cc5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf89baec32a2f35c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +eff5fdc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c8dff8ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff888888 +9f9f9fffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffd0e3f9c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8616d7a92a3b7 +90a2b51e2226a6bbd2c5ddf87d8c9d4e5762c5ddf8c5ddf82c323898aabf +c5ddf856616c2f343b8696a9333a41535d69c5ddf8c5ddf895a7bb2f353c +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c1d9f41113167583938d9eb1c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffff3f8fec5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8cbe0f9ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +878787a0a0a0ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffd0e3f9c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf87e8e9f +4f59645b667295a8bcc5ddf8c5ddf8a1b5cb899aadc5ddf8c5ddf8798898 +aec3dbc5ddf8c2daf5707d8d4b545f6e7b8bc1d9f4c5ddf8c5ddf8adc2d9 +7a899ac5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8aabfd6738291626e7b +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffcfe3f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8e2eefbffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffff878787a1a1a1ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffd0e3f9 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffe6f0fcc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c8dff8fbfdffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff868686a1a1a1ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +d0e3f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffebf3fdcfe3f9c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c6def8d8e8faf1f7fdffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff858585a2a2a2ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffd0e3f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffffffffffffffffffffffffffffffffff3f8fe +f2f8fdf2f8fdf2f8fdf2f8fdf2f8fdf2f8fdf2f8fdf2f8fdf2f8fdf2f8fd +f2f8fdf2f8fdf2f8fdf2f8fdf2f8fdf2f8fdf2f8fdf2f8fdf2f8fdf2f8fd +f2f8fdf2f8fdf2f8fdf2f8fdf2f8fdf2f8fdf2f8fdf2f8fdf2f8fdf2f8fd +f2f8fdf2f8fdf2f8fdf2f8fdf2f8fdf2f8fdf2f8fdf2f8fdf2f8fdf2f8fd +f2f8fdf2f8fdf2f8fdf2f8fdf2f8fdf2f8fdf2f8fdf2f8fdf2f8fdf2f8fd +f2f8fdf2f8fdf2f8fdf2f8fdf2f8fdf2f8fdf2f8fdf2f8fdf2f8fdf2f8fd +f2f8fdf2f8fdf2f8fdf2f8fdf2f8fdf2f8fdf2f8fdf2f8fdf2f8fdf2f8fd +f2f8fdf2f8fdf2f8fdf2f8fdf2f8fdf2f8fdf2f8fdf2f8fdf2f8fdf2f8fd +f2f8fdf2f8fdf2f8fdf2f8fdf2f8fdf2f8fdf2f8fdf2f8fdf2f8fdf2f8fd +f2f8fdf2f8fdf2f8fdf2f8fdf2f8fdf2f8fdf2f8fdf2f8fdf2f8fdf2f8fd +f2f8fdf2f8fdf2f8fdf2f8fdf2f8fdf2f8fdf2f8fdf2f8fdf2f8fdf2f8fd +f2f8fdf2f8fdf2f8fdf2f8fdf2f8fdf2f8fdf2f8fdf2f8fdf2f8fdf2f8fd +f2f8fdf2f8fdf2f8fdf2f8fdf2f8fdf2f8fdf2f8fdf2f8fdf2f8fdf2f8fd +f2f8fdf2f8fdf2f8fdf2f8fdf2f8fdf2f8fdf2f8fdf2f8fdf2f8fdf2f8fd +f2f8fdf2f8fdf2f8fdf2f8fdf2f8fdf2f8fdf2f8fdf2f8fdf2f8fdf2f8fd +f2f8fdf2f8fdfbfcfeffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff848484a3a3a3ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffd0e3f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff848484a3a3a3ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffd0e3f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8bfd6f1b3c9e1c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8bfd6f1 +bbd2ecc5ddf8c5ddf8c5ddf8b8cfe8c1d9f4c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffff838383a4a4a4ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffd0e3f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8748292b9d0e9c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf894a6ba363d45c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8b9d0e9748292c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +525c688a9baec5ddf8c5ddf8c5ddf86f7c8c6e7b8bc5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff828282a5a5a5ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffd0e3f9c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8a6bbd27d8c9d8ea0b3bbd2ec +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8191c20abc0d7c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf894a6ba363d45c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8acc1d8181b1fc5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +b0c6de22272bc4dcf7c5ddf8c5ddf8c5ddf8bad0ea1e2125bed6f0c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff828282a6a6a6 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffd0e3f9c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c1d9f4444c560d0f110606070c0d0f +12151792a4b9c5ddf8c5ddf8c5ddf8c5ddf8c1d9f42d333964707e24282d +6c7988bdd4eec5ddf8c4dcf7657280212529272c318696a9c5ddf8c5ddf8 +b7cee7505a65262b30292e3492a4b8c5ddf87d8d9e2a2f3505060625292e +2a2f358a9baec5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +acc1d849525c25292e2d3339a3b7cec5ddf894a6ba333a41515b6624282d +6c7988c5ddf8c5ddf8b9d0e948515b1c2023343a42a5b9d0c5ddf8c5ddf8 +b1c7df3e464e7f8fa0262b302a2f35b4c9e255606b25292e0506062a2f35 +2a2f35b2c8e0c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8616d7a64707ec5ddf8c5ddf8c5ddf8c5ddf8c5ddf849525c7d8c9d +c5ddf8c5ddf8c5ddf8c5ddf8a7bcd3687583c3dbf6c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff818181 +a6a6a6ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffd0e3f9c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8606b7808090a000000000000 +0000000000000f1113b4cae3c5ddf8c5ddf8c5ddf8c1d8f30000005e6976 +b6cce5434c556d7b8ac5ddf88495a71f2327a9bdd496a9bd0d0f11adc3da +c5ddf8697584596470c4dcf7bad0eaabc0d7c5ddf8c5ddf8c5ddf8191c20 +abc0d7c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf84f596472808fc5ddf8b3c9e1b2c8e0c5ddf894a6ba02020291a2b6 +b1c7df141619b4c9e2c5ddf8515b67434b54b6cce56f7c8c212529c4dcf7 +c5ddf8acc1d80708094b545fabc0d7a3b7ceb8cfe8c5ddf8acc1d8181b1f +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf83b424a8494a6c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8687583 +57616dc5ddf8c5ddf8c5ddf8c5ddf88595a8000000c1d8f3c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +808080a7a7a7ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffd0e3f9c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8121517000000000000 +000000000000000000030404738292c5ddf8c5ddf8c5ddf8c1d8f3000000 +acc1d8c5ddf88b9cb0394047c5ddf8505a655c6874c5ddf8c5ddf832383f +7a899ac5ddf872808f2a2f358495a7b8cfe8c5ddf8c5ddf8c5ddf8c5ddf8 +191c20abc0d7c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf858636f3940478b9cb0bdd4eec5ddf8c5ddf894a6ba24282d +c5ddf8c5ddf83d454d8798abc5ddf81c202390a2b5c5ddf8bfd6f1040505 +aec3dbc5ddf8acc1d8000000b0c6dec5ddf8c5ddf8c5ddf8c5ddf8acc1d8 +181b1fc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf81b1f239eb1c7c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +8393a5373e46c5ddf8c5ddf8c5ddf8c5ddf8bbd2eca6bad1c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffff7f7f7f4343436464646161615f5f5f5c5c5c595959565656535353 +5050504d4d4d4b4b4b4848484545454242423f3f3f3c3c3c3a3a3a373737 +3434343131312e2e2e2b2b2b2929292828282828282828282828281f2326 +1e22261e22261e22261e22261e22261e22261e22261d2125010202000000 +000000000000000000000000000000525d68c5ddf8c5ddf8c5ddf8c1d8f3 +000000bcd3edc5ddf89cafc41f2327c5ddf8464e58707e8dc5ddf8c5ddf8 +444d566f7c8cc5ddf8c4dcf7899aad363d450a0b0c8a9baec5ddf8c5ddf8 +c5ddf8191c20abc0d7c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c1d8f37e8e9f2b30361013159cafc5c5ddf894a6ba +363d45c5ddf8c5ddf8434c558190a2c5ddf8131518a4b8cfc5ddf8c5ddf8 +101315a3b6cdc5ddf8acc1d8171a1dc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +acc1d8181b1fc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8282d3394a6bac5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8778696434c55c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffdededec1c1c1c4c4c4c7c7c7cacacacccccccfcfcfd2d2d2 +d5d5d5d8d8d8dbdbdbdddddde0e0e0e3e3e3e6e6e6e9e9e9ebebebeeeeee +f1f1f1f4f4f4f7f7f7f9f9f9fcfcfcffffffffffffffffffffffffffffff +d0e3f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8171a1d +0000000000000000000000000000000608097f8fa0c5ddf8c5ddf8c5ddf8 +c1d8f300000097a9bec5ddf8768595515b67c5ddf8626e7b444d56c5ddf8 +c5ddf81b1f238ea0b3c5ddf8c5ddf8c5ddf8c5ddf85b667249525cc5ddf8 +c5ddf8c5ddf8282d339db0c6c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c2daf5434c55626e7cc5ddf8 +94a6ba363d45c5ddf8c5ddf8434c558190a2c5ddf82f343b788797c5ddf8 +adc3da050606bcd3edc5ddf8acc1d8181b1fc5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8b8cfe80f1113c3dbf6c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf849525c788797c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf85b677365717fc5ddf8c5ddf8c5ddf8c5ddf8b2c8e07a899a +bcd3edc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffd0e3f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +7f8fa10a0c0d000000000000000000000000171a1ec0d7f2c5ddf8c5ddf8 +c5ddf8c1d8f3010101282d33535d691b1f2398aabfc5ddf8b1c7df14171a +454e5730363d2e343ac4dcf7c5ddf856616c545f6a6774822125298ea0b3 +c5ddf8c5ddf8c5ddf86c7a89252a2f5a65719db0c6c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8434c555b6672636f7d191c20a6bad1 +c5ddf894a6ba363d45c5ddf8c5ddf8434c558190a2c5ddf88c9db10e1012 +535d691a1d215f6b78c5ddf8c5ddf8acc1d8181b1fc5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf83b424a3941485b6773b8cfe8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf87d8d9e4c5560c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf82f343b99acc1c5ddf8c5ddf8c5ddf8c5ddf88fa1b4 +000000b2c8e0c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffd0e3f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf87583940d0f110f11130f11132b3036b0c6dec5ddf8c5ddf8 +c5ddf8c5ddf8c1d8f3030404b0c5dd8495a7bdd4eec5ddf8c5ddf8c5ddf8 +b5cbe48292a48a9baec0d7f2c5ddf8c5ddf8b6cce58899ac8292a4b4cae3 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8b6cce594a6bab2c8e0c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8b0c6de8494a68798abbad0ea +c5ddf8c5ddf8b9d0e9a1b5cbc5ddf8c5ddf8a5b9d0b4c9e2c5ddf8c5ddf8 +a6bbd27d8d9e97a9bec5ddf8c5ddf8c5ddf8bed6f09aadc2c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8aabfd693a5b9bfd6f1c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c2daf522272bb6cce5 +c5ddf8c5ddf8c5ddf8a0b4ca343a42c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +697685383f46c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffd0e3f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c4dcf7a9bed5b9d0e9c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c1d8f3030404c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf88797aa +8e9fb2c5ddf8c5ddf8c5ddf87a899a9aadc2c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf85a65719eb1c7c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffd0e3f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c3dbf65e6976c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +95a7bb6e7b8b6e7b8b6e7b8b6e7b8b738291c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffd0e3f9c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffd0e3f9c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffd0e3f9c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8bdd4ee8899acb4c9e2c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffd0e3f9c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8bcd3ed677482141619a9bdd4c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffd0e3f9 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8545f6a768595 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +d0e3f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf85f6a77 +6c7988c5ddf8c5ddf8c5ddf8c5ddf8bed5ef363d459baec3c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffd0e3f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +7482924b545fc5ddf8c5ddf8c5ddf8c5ddf8bcd3ed11131690a2b5c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffd0e3f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8b6cce5282d322c3137b2c8e0c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffd0e3f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf88e9fb2272c319fb3c9c2daf5c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffd0e3f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8636f7d64707ec5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +4b545f95a7bbc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffd0e3f9c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf85e69766c7a89c5ddf8c5ddf8c5ddf8c5ddf8 +bfd6f10000008797aac5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffd0e3f9c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8bbd2ec333a4191a2b6c5ddf8c5ddf8c5ddf8 +c5ddf893a5b91e2125c2daf5c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffd0e3f9c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8b4cae33940475f6b78bfd6f1c5ddf8c5ddf8 +c5ddf8c5ddf895a8bc95a7bbc5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffd0e3f9c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffd0e3f9 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +d0e3f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffd0e3f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffd0e3f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffd0e3f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffd0e3f9c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffd0e3f9c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffd2e5fac5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c7def8ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe7f1fcc5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8d9e9fa +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffffffffffffffffffffffffffffdfeffddebfb +c9dff8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8 +c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c5ddf8c7def8dceafb +f8fbfe + +[/Creator (html2ps version 1.0 beta7) /Author () /Keywords (xsd, xml, schema, c++, mapping, data, binding, parser, validation) /Subject () + /Title (C++/Parser Mapping Getting Started Guide) /DOCINFO pdfmark +/ND 1 D +/HN [(1) (1) (1) (1) (1) (1) (1) (1) (2) (3) (3) (4) (6) (8) (8) (9) (12) (13) +(14) (18) (18) (21) (24) (27) (27) (28) (28) (28) (29) (35) (??) (38) (39) +(39) (41) (42) (43) (44) (45) (46) (47) (47) (48) (49) (50) (50) (55) (59) +(63) (??) (??) (??) (??) (??) (??) (??) (??) (??) (??) (??) (??) (??) (??) +(??) (??) (??) (??) (??) (??) (??) (??) (1) (1) (1) (1) (1) (2) (3) (3) +(4) (6) (8) (8) (9) (12) (13) (14) (18) (18) (21) (24) (27) (27) (28) (28) +(28) (29) (35) (38) (39) (39) (41) (42) (43) (44) (45) (46) (47) (47) (48) +(49) (50) (50) (55) (59) (63)] D +/h0 [()(Table of Contents)] D +/h1 [(1\240\240)(Preface)] D +/h2 [(1.1\240\240)(About This Document)] D +/h3 [(1.2\240\240)(More Information)] D +/h4 [(2\240\240)(1 Introduction)] D +/h5 [(2.1\240\240)(1.1 Mapping Overview)] D +/h6 [(2.2\240\240)(1.2 Benefits)] D +/h7 [(3\240\240)(2 Hello World Example)] D +/h8 [(3.1\240\240)(2.1 Writing XML Document and Schema)] D +/h9 [(3.2\240\240)(2.2 Translating Schema to C++)] D +/h10 [(3.3\240\240)(2.3 Implementing Application Logic)] D +/h11 [(3.4\240\240)(2.4 Compiling and Running)] D +/h12 [(4\240\240)(3 Parser Skeletons)] D +/h13 [(4.1\240\240)(3.1 Implementing the Gender Parser)] D +/h14 [(4.2\240\240)(3.2 Implementing the Person Parser)] D +/h15 [(4.3\240\240)(3.3 Implementing the People Parser)] D +/h16 [(4.4\240\240)(3.4 Connecting the Parsers Together)] D +/h17 [(5\240\240)(4 Type Maps)] D +/h18 [(5.1\240\240)(4.1 Object Model)] D +/h19 [(5.2\240\240)(4.2 Type Map File Format)] D +/h20 [(5.3\240\240)(4.3 Parser Implementations)] D +/h21 [(6\240\240)(5 Mapping Configuration)] D +/h22 [(6.1\240\240)(5.1 C++ Standard)] D +/h23 [(6.2\240\240)(5.2 Character Type and Encoding)] D +/h24 [(6.3\240\240)(5.3 Underlying XML Parser)] D +/h25 [(6.4\240\240)(5.4 XML Schema Validation)] D +/h26 [(6.5\240\240)(5.5 Support for Polymorphism)] D +/h27 [(7\240\240)(6 Built-In XML Schema Type Parsers)] D +/h28 [(7.1\240\240)(6.1 QName Parser)] D +/h29 [(7.2\240\240)(6.2 NMTOKENS and IDREFS Parsers)] D +/h30 [(7.3\240\240)(6.3 base64Binary and hexBinary Parsers)] D +/h31 [(7.4\240\240)(6.4 Time Zone Representation)] D +/h32 [(7.5\240\240)(6.5 date Parser)] D +/h33 [(7.6\240\240)(6.6 dateTime Parser)] D +/h34 [(7.7\240\240)(6.7 duration Parser)] D +/h35 [(7.8\240\240)(6.8 gDay Parser)] D +/h36 [(7.9\240\240)(6.9 gMonth Parser)] D +/h37 [(7.10\240\240)(6.10 gMonthDay Parser)] D +/h38 [(7.11\240\240)(6.11 gYear Parser)] D +/h39 [(7.12\240\240)(6.12 gYearMonth Parser)] D +/h40 [(7.13\240\240)(6.13 time Parser)] D +/h41 [(8\240\240)(7 Document Parser and Error Handling)] D +/h42 [(8.1\240\240)(7.1 Xerces-C++ Document Parser)] D +/h43 [(8.2\240\240)(7.2 Expat Document Parser)] D +/h44 [(8.3\240\240)(7.3 Error Handling)] D +/h45 [(9\240\240)(Appendix A \236 Supported XML Schema Constructs)] D +/Hr [71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 +93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 +113 114 115]D +/HV [1 2 2 1 2 2 1 2 2 2 2 1 2 2 2 2 1 2 2 2 1 2 2 2 2 2 1 2 2 2 2 2 2 +2 2 2 2 2 2 2 1 2 2 2 1]D +/Cn [2 0 0 2 0 0 4 0 0 0 0 4 0 0 0 0 3 0 0 0 5 0 0 0 0 0 13 0 0 0 0 0 0 +0 0 0 0 0 0 0 3 0 0 0 0]D +Hr length 0 gt{[/PageMode /UseOutlines /DOCVIEW pdfmark}if +/Hn 1 D +0 1 Hr length 1 sub{ + /Bn E D [Cn Bn get dup 0 gt{/Count E HV Bn get Bl ge{neg}if}{pop}ie + /Dest Hr Bn get dup abs ST cvs cvn E 0 ge{(h)Hn ST cvs join cvx exec + dup 1 get E Nf{0 get E join}{pop}ie /Hn Hn 1 add D}{()}ie + /Title E dup length 255 gt{0 255 getinterval}if /OUT pdfmark}for +ZF /FN Fp D Ps 0 FS /WC Wf{( )}{}ie SW pop D +ET RC ZF +/Df f D +/R0 (https://www.codesynthesis.com/licenses/fdl-1.2.txt) D +/R1 (https://www.codesynthesis.com/projects/xsd/documentation/cxx/parser/guide/index.xhtml) D +/R2 (https://www.codesynthesis.com/projects/xsd/documentation/cxx/parser/guide/cxx-parser-guide.pdf) D +/R3 (https://www.codesynthesis.com/projects/xsd/documentation/cxx/parser/guide/cxx-parser-guide.ps) D +/R1 (https://www.codesynthesis.com/projects/xsd/documentation/xsd.xhtml) D +/R2 (https://cppget.org/xsd-examples) D +/R3 (https://www.codesynthesis.com/mailman/listinfo/xsd-users) D +/R4 (https://www.codesynthesis.com/pipermail/xsd-users/) D +/R5 (http://www.w3.org/TR/xmlschema-0/) D +/R6 (https://cppget.org/libxsd) D +/TS { + tables E get /table E D + table aload pop /rdesc E D /cdesc E D /tdesc E D + tdesc aload pop /capalg E D /caption E D /rules E D /frame E D /nfoot E D + /nhead E D /ncol E D /nrow E D /border E D /twid E D /units E D /talign E D + /flow E D /clear E D /tclass E D pop pop + /w W D /eps 0.1 D /OU f D /PL 1 D + /FN EF 21 get D EZ 21 get Ey 21 get FS + 0 1 1{ + /pass E D + 0 1 nrow{ + /irow E D + /cells rdesc irow get 6 get D + 0 1 ncol{ + /icol E D + /cell cells icol get D + cell 0 ne{ + cell aload pop /ang E D /CB E D pop pop pop + /DV E D /bot E D /top E D /right E D /left E D /nowrap E D /valign E D + /dp E D /align E D /rspan E D /cspan E D /cclass E D /ctype E D /cmax E D + /cmin E D /proc E D + rspan 0 eq{/rspan nrow irow sub 1 add D}if + cspan 0 eq{/cspan ncol icol sub 1 add D}if + pass 0 eq cspan 1 eq and pass 1 eq cspan 1 gt and or{ + /W 1e5 D /LL W D /PH 1 D + ctype 1 eq{() BD}if + RC align NA + AT 4 eq{/CD t D /DC dp D /LN 0 D /M1 0 D /M2 0 D}{/CD f D}ie + 0 0 M /LM 0 D proc exec BN + AT 4 eq{ + LN array astore cell 15 3 -1 roll put + cdesc icol get dup dup 5 get M1 lt{5 M1 put}{5 get /M1 E D}ie + dup 6 get M2 lt{6 M2 put}{6 get /M2 E D}ie + /LM M1 M2 add D + }if + /CD f D + ang 0 ne{/LM CP E pop neg D}if + /thiswid LM left add right add eps add D + /oldmin 0 D /oldmax 0 D + 0 1 cspan 1 sub{ + icol add cdesc E get dup 2 get /oldmax E oldmax add D + 1 get /oldmin E oldmin add D + }for + thiswid oldmax ge{ + 0 1 cspan 1 sub{ + icol add cdesc E get dup 2 E 2 get oldmax 0 eq + {pop thiswid cspan div}{thiswid mul oldmax div}ie + put + }for + }if + nowrap 1 eq{ + thiswid oldmin ge{ + 0 1 cspan 1 sub{ + icol add cdesc E get dup 1 E 1 get oldmin 0 eq + {pop thiswid cspan div}{thiswid mul oldmin div}ie + put + }for + }if + }{ + /W 0 D /LL W D /PH 2 D + ctype 1 eq{() ES () BD}if + 0 0 M /LM 0 D RC proc exec BN + /thiswid LM left add right add eps add D + thiswid oldmin ge{ + 0 1 cspan 1 sub{ + icol add cdesc E get dup 1 E 1 get oldmin 0 eq + {pop thiswid cspan div}{thiswid mul oldmin div}ie + put + }for + }if + }ie + ctype 1 eq{() ES}if + }if + }if + }for + }for + }for + /tmin 0 D /tmax 0 D + 0 1 ncol{ + cdesc E get dup 1 get E 2 get 2 copy gt{pop dup}if + tmax add /tmax E D tmin add /tmin E D + }for + twid 0 lt{twid neg IW gt{IW neg}{twid}ie /twid E D}if + tdesc 0 twid neg tmin 2 copy lt{E}if pop put + tdesc 1 twid neg tmax 2 copy lt{E}if pop put + /W w D /LL W D /OU t D /PH 0 D /PL 0 D +} D +/PT { + /PL PL 1 add D + tables E get /table E D Tm 21 get Ts mul BE + PL 2 ge{save}if + /SL SL 1 add D /FN EF 21 get D EZ 21 get Ey 21 get FS + table aload pop /rdesc E D /cdesc E D /tdesc E D + tdesc aload pop /capalg E D /caption E D /rules E D /frame E D /nfoot E D + /nhead E D /ncol E D /nrow E D /border E D /twid E D /units E D /talign E D + /flow E D /clear E D /tclass E D /tmax E D /tmin E D + /w W D /xo XO D /mr MR D /ll LL D /lg LG D /ai AI D /bc BC D /nr NR D /ar AR D + /tr TR D /ui UI D /ph PH D /a0 A0 D /pf PF D /at AT D /av AV D /al AL D + /Le LE D /la La D + talign 0 lt{/talign AL 0 gt{AV AL get}{A0 2 le{A0}{0}ie}ie D}if + ph 1 eq ph 2 eq or{ + NL ph 1 eq{tmax}{tmin}ie dup XO add LM gt{/LM E XO add D}{pop}ie LM E + }{ + /PH 3 D /LE 1e5 D RC %ZF + border 0 gt{/border 1 D}if + /twidth 0 D /avail W xo sub D + twid 0 eq{0 1 ncol{cdesc E get dup 2 get E 3 get dup 0 gt{div neg dup twid lt + {/twid E D}{pop}ie}{pop pop}ie}for}if + /twid twid dup 0 lt{neg avail 2 copy gt{E}if pop}{avail mul}ie D + /OK t D 0 1 ncol{cdesc E get dup 1 get E 3 get twid mul gt{/OK f D}if}for + 0 1 ncol{ + cdesc E get dup 1 get /colmin E D dup 3 get /cwid E twid mul D dup + tmax avail le{2 get}if + tmin avail le tmax avail gt and{ + dup 2 get E 1 get dup 3 1 roll sub avail tmin sub mul tmax tmin sub div add + }if + tmin avail gt{1 get}if + 0 E colmin cwid lt OK and{pop cwid}if dup /twidth E twidth add D put + }for + /OU f D CP + tmin twid le{ + 0 1 ncol{cdesc E get dup 0 get twidth div twid mul 0 E put}for + /twidth twid D + }if + CP printcap CP E pop sub /caphig E D pop + 0 1 1{ + /pass E D + 0 1 nrow{ + /irow E D + /cells rdesc irow get 6 get D + 0 1 ncol{ + /icol E D + /cell cells icol get D + cell 0 ne{ + cell aload pop /ang E D /CB E D pop pop pop + /DV E D /bot E D /top E D /right E D /left E D /nowrap E D /valign E D + /dp E D /align E D /rspan E D /cspan E D /cclass E D /ctype E D /cmax E D + /cmin E D /proc E D + rspan 0 eq{/rspan nrow irow sub 1 add D}if + cspan 0 eq{/cspan ncol icol sub 1 add D}if + /W 0 D + 0 1 cspan 1 sub{icol add cdesc E get 0 get /W E W add D}for + pass 0 eq rspan 1 eq and pass 1 eq rspan 1 gt and or{ + ctype 1 eq{() BD}if + /W W left sub right sub D /XO 0 D /EO 0 D SI + /A0 align D RC align NA + AT 4 eq{ + /DC dp D /DO 0 D /ID 1 D + 0 1 DV length 1 sub{DV E get dup DO gt{/DO E D}{pop}ie}for + /Lo DO DV 0 get sub D /L1 Lo D + }if + 0 0 M /BP t D /Fl t D /MF 0 D /FB 0 D + proc exec T not{/CI 0 D}if BN 0 FB neg R MF 0 eq{/MF CS D}if + CP /thishig E neg bot add top add CI add D pop + ang 0 ne{/thishig LM bot add top add D}if + cell 16 MF put cell 17 Ya put cell 18 thishig put + valign 4 eq{ + /below thishig Ya sub D + rdesc irow get dup dup 4 get Ya lt + {4 Ya put}{4 get /Ya E D}ie + dup 5 get below lt{5 below put}{5 get /below E D}ie + /thishig Ya below add D + }if + ctype 1 eq{()ES}if + /oldhig 0 D + 0 1 rspan 1 sub{ + irow add rdesc E get 0 get /oldhig E oldhig add D + }for + thishig oldhig ge{ + 0 1 rspan 1 sub{ + irow add rdesc E get dup 0 E 0 get oldhig 0 eq + {pop thishig rspan div}{thishig mul oldhig div}ie + put + }for + }if + }if + }if + }for + }for + }for M RC %ZF + /thight 0 D /racc 0 D /maxh 0 D /brk 0 D /rbeg nhead nfoot add D + 0 1 nrow{ + rdesc E get dup 0 get dup /thight E thight add D + brk 0 eq{/racc E D}{/racc E racc add D}ie + racc maxh gt{/maxh racc D}if 2 get /brk E D + }for + ph 3 ge{thight caphig add E}if + ph 0 eq ph 4 eq or{ + /PH 4 D /LE Le D /OU Ou D /yoff 0 D /headsz 0 D + 0 1 nhead 1 sub{rdesc E get 0 get headsz add /headsz E D}for + /footsz 0 D + 0 1 nfoot 1 sub{rdesc E nhead add get 0 get footsz add /footsz E D}for + /ahig LE BO add MI add D /maxh maxh headsz add footsz add D + /thight thight headsz add footsz add D + tmin avail gt maxh ahig gt or + {/Sf avail tmin div dup ahig maxh div gt{pop ahig maxh div}if D /SA t D} + {/Sf 1 D}ie + tclass 1 eq thight LE 15 sub gt and + {/SA t D LE 15 sub thight div dup Sf lt{/Sf E D}{pop}ie}if + SA{Sf Sf scale /ll ll Sf div D /xo xo Sf div D /LE LE Sf div D + /mr mr Sf div D /BO BO Sf div D /ahig ahig Sf div D}if + nhead nfoot add getwid + LE CP E pop add capalg 0 eq{caphig sub}if + bT{f}{dup thight lt thight ahig lt and}ie + E headsz sub footsz sub rwid lt or{NP}if + capalg 0 eq{printcap -8 SP}if + CP /ycur E D pop + printhead + rbeg 1 nrow{/row E D row + getwid + ycur yoff add rwid sub footsz sub LE add 0 lt + {nfoot 0 gt{printfoot}if Tf NP /rbeg irow1 D + Ba{MI /MI MI SA{Sf div}if D MI SP /MI E D}if + CP /ycur E D pop /yoff 0 D printhead}if + irow1 printrow + }for + printfoot /row row 1 add D Tf + 0 ycur yoff add M + capalg 1 eq{/EO 0 D SI -3 SP printcap}if + Sf 1 lt{1 Sf div dup scale /ll ll Sf mul D /xo xo Sf mul D /LE LE Sf mul D + /mr mr Sf mul D /BO BO Sf mul D /SA f D}if + /EO 0 D + }if + }ie + /W w D /XO xo D /MR mr D /LL ll D /LG lg D /AI ai D /BC bc D /NR nr D /AR ar D + /TR tr D /UI ui D /PH ph D /A0 a0 D /PF pf D /AT at D /AV av D /AL al D + /La la D + /SL SL 1 sub NN D /CF 0 D /FN 0 D SZ SL get FR SL get FS Wf not{()F2}if + PL 2 ge{Ms E restore Ms or /Ms E D PH 1 eq PH 2 eq or + {/LM E D}if PH 3 ge{/CI 0 D NL 0 E neg R}if + }if + /PL PL 1 sub D /CI 0 D /BP f D /PO f D () Bm 21 get Ts mul BE BL %CF CS SF +} D +/printcap{ + capalg 0 ge{ + SA{/W w Sf div D} + {talign 1 eq{/XO xo ll twidth sub 2 div add D}if + talign 2 eq{/XO xo ll twidth sub add D}if + /W XO twidth add D + }ie /XO xo D /LL W XO sub MR sub D + /PA f D /Fl capalg 0 eq D + 1 NA BL caption exec BN OA /PA t D + }if +} D +/getwid{ + /irow1 E D + /irow2 irow1 D + /rwid 0 D + {rdesc irow2 get dup 0 get rwid add /rwid E D 2 get 0 eq + {exit}{/irow2 irow2 1 add D}ie + }loop +} D +/printrow{ + /xoff ll twidth PL 2 ge{Sf div}if sub talign mul 2 div D + /xleft xoff xo add D + /irow E D + /cells rdesc irow get 6 get D + 0 1 ncol{ + /icol E D + /cell cells icol get D + cell 0 ne{ + cell aload pop /ang E D /CB E D /cvsize E D /above E D /fontsz E D + /DV E D /bot E D /top E D /right E D /left E D /nowrap E D /valign E D + /dp E D /align E D /rspan E D /cspan E D /cclass E D /ctype E D /cmax E D + /cmin E D /proc E D + rspan 0 eq{/rspan nrow irow sub 1 add D}if + cspan 0 eq{/cspan ncol icol sub 1 add D}if + /width 0 D + 0 1 cspan 1 sub{icol add cdesc E get 0 get /width E width add D}for + /rhight rdesc irow get 0 get D + /hight rhight D + 1 1 rspan 1 sub{irow add rdesc E get 0 get /hight E hight add D}for + /W xo xoff add width add right sub D + ang 0 ne{/W xo xoff add hight add right sub D}if + /EO xo xoff add left add D SI + Cf{ + gsave CB VC xo xoff add ycur yoff add M + 0 hight neg RL width 0 RL 0 hight RL width neg 0 RL fill + grestore + }if + ctype 1 eq{() BD}if + /A0 align D RC + AT 4 eq{ + /DC dp D /ID 1 D /DO cdesc icol get 5 get D /Lo DO DV 0 get sub D /L1 Lo D + }if + ang 0 ne{ + gsave ang 90 eq + {xoff ycur add hight cvsize sub 2 div sub ycur hight sub xoff sub} + {xoff ycur sub width add hight cvsize sub 2 div add ycur xoff add}ie + translate ang rotate + }if + valign 3 le{0 ycur yoff add top sub + hight cvsize sub valign 1 sub mul 2 div sub M} + {0 ycur yoff add top sub above add rdesc irow get 4 get sub M}ie + /PA f D /BP t D /Fl t D + BL proc exec BN + ang 0 ne{grestore}if + /PA t D + ctype 1 eq{() ES}if + }if + /xoff xoff cdesc icol get 0 get add D + }for + /yoff yoff rhight sub D +} D +/printhead {0 1 nhead 1 sub{printrow}for} D +/printfoot {nhead 1 nhead nfoot add 1 sub{printrow}for} D +/Tf { + OU{rules 2 ge{/yoff 0 D + gsave 0 Sg + [0 1 nhead 1 sub{}for rbeg 1 row 1 sub{}for nhead 1 nhead nfoot add 1 sub{}for]{ + /irow E D + /xoff ll twidth PL 2 ge{Sf div}if sub talign mul 2 div D + /cells rdesc irow get 6 get D + 0 1 ncol{ + /icol E D + /cell cells icol get D + cell 0 ne{ + /rspan cell 6 get D + /cspan cell 5 get D + rspan 0 eq{/rspan nrow irow sub 1 add D}if + cspan 0 eq{/cspan ncol icol sub 1 add D}if + /width 0 D + 0 1 cspan 1 sub{icol add cdesc E get 0 get /width E width add D}for + /rhight rdesc irow get 0 get D + /hight rhight D + 1 1 rspan 1 sub{irow add rdesc E get 0 get /hight E hight add D}for + xo xoff add width add ycur yoff add M + 0 hight neg icol cspan add 1 sub ncol lt + {cdesc icol 1 add get 4 get dup rules 3 le{1 eq}{pop t}ie + {1 eq{0.8}{0.3}ie + LW RL CP stroke M}{pop R}ie}{R}ie + irow nhead nfoot add 1 sub ne nfoot 0 eq or + {irow rspan add 1 sub nrow lt + {rdesc irow rspan add get 3 get}{nfoot 0 eq{0}{1}ie}ie + dup rules 2 mod 0 eq{1 eq}{pop t}ie + {1 eq irow rspan add nhead eq or irow rspan add row eq nfoot 0 gt and or + {0.8}{0.3}ie LW width neg 0 RL CP stroke M}{pop}ie}if + }if + /xoff xoff cdesc icol get 0 get add D + }for + /yoff yoff rhight sub D + }forall + grestore + /Ms t D + }if + frame 1 gt{ + gsave + 1 LW 0 Sg + xleft ycur M CP BB + 0 yoff frame 5 eq frame 7 ge or{RL}{R}ie + twidth 0 frame 3 eq frame 4 eq or frame 8 ge or{RL}{R}ie CP BB + 0 yoff neg frame 6 ge{RL}{R}ie + twidth neg 0 frame 2 eq frame 4 eq or frame 8 ge or{RL}{R}ie + closepath stroke + grestore + /Ms t D + }if + }if +} D +/tables [[[0 0 0 0 0 -1 0 0 1 56 2 0 0 9 5 {()} -1] + [[0 0 0 0 0 0 0][0 0 0 0 0 0 0][0 0 0 0 0 0 0]] + [[0 0 0 0 0 0 [[{()0 Sl()WB(XML Schema type)} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB(Parser imple)HY(men)HY(ta)HY(tion)YH( in the )SM(xml_schema)ES( names)HY(pace)YH()} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB(Parser return type + )} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB(anyType and anySim)HY(ple)HY(Type)YH( types + )} 0 0 1 0 3 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +0 +0 +]] +[0 0 0 0 0 0 [[{()0 Sl()WB()SM(anyType)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(any_type_pimpl)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(void)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB()SM(anySim)HY(ple)HY(Type)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(any_simple_type_pimpl)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(void)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB(fixed-length inte)HY(gral)YH( types + )} 0 0 1 0 3 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +0 +0 +]] +[0 0 0 0 0 0 [[{()0 Sl()WB()SM(byte)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(byte_pimpl)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(signed\240char)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB()SM(unsigned)HY(Byte)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(unsigned_byte_pimpl)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(unsigned\240char)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB()SM(short)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(short_pimpl)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(short)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB()SM(unsigned)HY(Short)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(unsigned_short_pimpl)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(unsigned\240short)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB()SM(int)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(int_pimpl)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(int)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB()SM(unsignedInt)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(unsigned_int_pimpl)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(unsigned\240int)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB()SM(long)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(long_pimpl)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(long\240long)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB()SM(unsigned)HY(Long)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(unsigned_long_pimpl)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(unsigned\240long\240long)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB(arbi)HY(trary)YH(-length inte)HY(gral)YH( types + )} 0 0 1 0 3 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +0 +0 +]] +[0 0 0 0 0 0 [[{()0 Sl()WB()SM(integer)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(integer_pimpl)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(long\240long)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB()SM(nonPos)HY(i)HY(tiveIn)HY(te)HY(ger)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(non_posi)HY(tive)YH(_integer_pimpl)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(long\240long)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB()SM(nonNeg)HY(a)HY(tiveIn)HY(te)HY(ger)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(non_nega)HY(tive)YH(_integer_pimpl)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(unsigned long\240long)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB()SM(posi)HY(tiveIn)HY(te)HY(ger)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(posi)HY(tive)YH(_integer_pimpl)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(unsigned long\240long)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB()SM(nega)HY(tiveIn)HY(te)HY(ger)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(nega)HY(tive)YH(_integer_pimpl)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(long\240long)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB(boolean types + )} 0 0 1 0 3 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +0 +0 +]] +[0 0 0 0 0 0 [[{()0 Sl()WB()SM(boolean)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(boolean_pimpl)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(bool)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB(fixed-preci)HY(sion)YH( float)HY(ing)YH(-point types + )} 0 0 1 0 3 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +0 +0 +]] +[0 0 0 0 0 0 [[{()0 Sl()WB()SM(float)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(float_pimpl)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(float)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB()SM(double)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(double_pimpl)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(double)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB(arbi)HY(trary)YH(-preci)HY(sion)YH( float)HY(ing)YH(-point types + )} 0 0 1 0 3 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +0 +0 +]] +[0 0 0 0 0 0 [[{()0 Sl()WB()SM(decimal)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(decimal_pimpl)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(double)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB(string-based types + )} 0 0 1 0 3 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +0 +0 +]] +[0 0 0 0 0 0 [[{()0 Sl()WB()SM(string)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(string_pimpl)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(std::string)ES( or )SM(std::wstring)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB()SM(normal)HY(ized)HY(String)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(normal)HY(ized)YH(_string_pimpl)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(std::string)ES( or )SM(std::wstring)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB()SM(token)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(token_pimpl)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(std::string)ES( or )SM(std::wstring)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB()SM(Name)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(name_pimpl)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(std::string)ES( or )SM(std::wstring)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB()SM(NMTOKEN)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(nmtoken_pimpl)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(std::string)ES( or )SM(std::wstring)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB()SM(NCName)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(ncname_pimpl)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(std::string)ES( or )SM(std::wstring)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB()SM(language)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(language_pimpl)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(std::string)ES( or )SM(std::wstring)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB(qual)HY(i)HY(fied)YH( name + )} 0 0 1 0 3 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +0 +0 +]] +[0 0 0 0 0 0 [[{()0 Sl()WB()SM(QName)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(qname_pimpl)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(xml_schema::qname)ES()BR()0 55 1 A(Section 6.1, + ")SM(QName)ES( Parser")55 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB(ID/IDREF types + )} 0 0 1 0 3 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +0 +0 +]] +[0 0 0 0 0 0 [[{()0 Sl()WB()SM(ID)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(id_pimpl)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(std::string)ES( or )SM(std::wstring)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB()SM(IDREF)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(idref_pimpl)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(std::string)ES( or )SM(std::wstring)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB(list types + )} 0 0 1 0 3 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +0 +0 +]] +[0 0 0 0 0 0 [[{()0 Sl()WB()SM(NMTO)HY(KENS)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(nmto)HY(kens)YH(_pimpl)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(xml_schema::string_sequence)ES()BR()0 56 1 A(Section + 6.2, ")SM(NMTO)HY(KENS)YH()ES( and )SM(IDREFS)ES( Parsers")56 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB()SM(IDREFS)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(idrefs_pimpl)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(xml_schema::string_sequence)ES()BR()0 56 1 A(Section + 6.2, ")SM(NMTO)HY(KENS)YH()ES( and )SM(IDREFS)ES( Parsers")56 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB(URI types + )} 0 0 1 0 3 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +0 +0 +]] +[0 0 0 0 0 0 [[{()0 Sl()WB()SM(anyURI)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(uri_pimpl)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(std::string)ES( or )SM(std::wstring)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB(binary types + )} 0 0 1 0 3 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +0 +0 +]] +[0 0 0 0 0 0 [[{()0 Sl()WB()SM(base64Binary)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(base64_binary_pimpl)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(std::[unique|auto]_ptr< xml_schema::buffer>)ES()BR( )0 57 1 A(Section 6.3, ")SM(base64Binary)ES( and + )SM(hexBi)HY(nary)YH()ES( Parsers")57 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB()SM(hexBi)HY(nary)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(hex_binary_pimpl)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(std::[unique|auto]_ptr< xml_schema::buffer>)ES()BR( )0 57 1 A(Section 6.3, ")SM(base64Binary)ES( and + )SM(hexBi)HY(nary)YH()ES( Parsers")57 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB(date/time types + )} 0 0 1 0 3 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +0 +0 +]] +[0 0 0 0 0 0 [[{()0 Sl()WB()SM(date)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(date_pimpl)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(xml_schema::date)ES()BR()0 58 1 A(Section 6.5, + ")SM(date)ES( Parser")58 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB()SM(date)HY(Time)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(date_time_pimpl)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(xml_schema::date_time)ES()BR()0 59 1 A(Section 6.6, + ")SM(date)HY(Time)YH()ES( Parser")59 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB()SM(dura)HY(tion)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(dura)HY(tion)YH(_pimpl)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(xml_schema::dura)HY(tion)YH()ES()BR()0 60 1 A(Section 6.7, + ")SM(dura)HY(tion)YH()ES( Parser")60 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB()SM(gDay)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(gday_pimpl)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(xml_schema::gday)ES()BR()0 61 1 A(Section 6.8, + ")SM(gDay)ES( Parser")61 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB()SM(gMonth)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(gmonth_pimpl)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(xml_schema::gmonth)ES()BR()0 62 1 A(Section 6.9, + ")SM(gMonth)ES( Parser")62 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB()SM(gMon)HY(th)HY(Day)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(gmonth_day_pimpl)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(xml_schema::gmonth_day)ES()BR()0 63 1 A(Section 6.10, + ")SM(gMon)HY(th)HY(Day)YH()ES( Parser")63 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB()SM(gYear)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(gyear_pimpl)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(xml_schema::gyear)ES()BR()0 64 1 A(Section 6.11, + ")SM(gYear)ES( Parser")64 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB()SM(gYear)HY(Month)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(gyear_month_pimpl)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(xml_schema::gyear_month)ES()BR()0 65 1 A(Section + 6.12, ")SM(gYear)HY(Month)YH()ES( Parser")65 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB()SM(time)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(time_pimpl)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(xml_schema::time)ES()BR()0 66 1 A(Section 6.13, + ")SM(time)ES( Parser")66 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +]] +[[0 0 0 0 0 -1 0 0 1 57 1 0 0 9 5 {()} -1] + [[0 0 0 0 0 0 0][0 0 0 0 0 0 0]] + [[0 0 0 0 0 0 [[{()0 Sl()WB(Construct)} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB(Notes)} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB(Struc)HY(ture)YH()} 0 0 1 0 2 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +0 +]] +[0 0 0 0 0 0 [[{()0 Sl()WB(element)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB(attribute)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB(any)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB(anyAt)HY(tribute)YH()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB(all)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB(sequence)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB(choice)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB(complex type, empty content)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB(complex type, mixed content)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB(complex type, simple content exten)HY(sion)YH()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB(complex type, simple content restric)HY(tion)YH()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB(Simple type facets are not vali)HY(dated)YH(.)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB(complex type, complex content exten)HY(sion)YH()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB(complex type, complex content restric)HY(tion)YH()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB(list)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB(Datatypes)} 0 0 1 0 2 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +0 +]] +[0 0 0 0 0 0 [[{()0 Sl()WB(byte)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB(unsigned)HY(Byte)YH()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB(short)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB(unsigned)HY(Short)YH()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB(int)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB(unsignedInt)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB(long)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB(unsigned)HY(Long)YH()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB(integer)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB(nonPos)HY(i)HY(tiveIn)HY(te)HY(ger)YH()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB(nonNeg)HY(a)HY(tiveIn)HY(te)HY(ger)YH()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB(posi)HY(tiveIn)HY(te)HY(ger)YH()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB(nega)HY(tiveIn)HY(te)HY(ger)YH()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB(boolean)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB(float)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB(double)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB(decimal)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB(string)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB(normal)HY(ized)HY(String)YH()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB(token)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB(Name)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB(NMTOKEN)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB(NCName)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB(language)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB(anyURI)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB(ID)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB(Iden)HY(tity)YH( constraint is not enforced.)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB(IDREF)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB(Iden)HY(tity)YH( constraint is not enforced.)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB(NMTO)HY(KENS)YH()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB(IDREFS)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB(Iden)HY(tity)YH( constraint is not enforced.)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB(QName)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB(base64Binary)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB(hexBi)HY(nary)YH()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB(date)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB(date)HY(Time)YH()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB(dura)HY(tion)YH()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB(gDay)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB(gMonth)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB(gMon)HY(th)HY(Day)YH()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB(gYear)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB(gYear)HY(Month)YH()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB(time)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +]] +] D +0 1 1{TS}for RC ZF +/Ba f D /BO 0 D Bs +/UR (/home/boris/work/xsd/builds/gcc8-host/xsd/doc/cxx/parser/guide/index.xhtml) D +/Ti (C++/Parser Mapping Getting Started Guide) D +/Au () D +/Df f D +/ME [] D +Pt +/BO 0 D TC /Ba f D Bs /AU f D /UR () D RC ZF + tH WB +ND 1 gt{Ts 3 mul Np 0()0 C()BD(C++/Parser Mapping Getting Started Guide)ES()0 1 TN()EA()BN}if +1 NH le{71(1\240\240)1 C(Preface)WB 3 Sn()71 1 TN()EA()BN}if +2 NH le{72(1.1\240\240)2 C(About)WB 4 Sn( This Docu)HY(ment)YH()72 1 TN()EA()BN}if +2 NH le{73(1.2\240\240)2 C(More)WB 5 Sn( Infor)HY(ma)HY(tion)YH()73 1 TN()EA()BN}if +1 NH le{74(2\240\240)1 C(1)WB 6 Sn( Intro)HY(duc)HY(tion)YH()74 1 TN()EA()BN}if +2 NH le{75(2.1\240\240)2 C(1.1)WB 7 Sn( Mapping Overview)75 1 TN()EA()BN}if +2 NH le{76(2.2\240\240)2 C(1.2)WB 8 Sn( Bene)HY(fits)YH()76 1 TN()EA()BN}if +1 NH le{77(3\240\240)1 C(2)WB 9 Sn( Hello World Example)77 1 TN()EA()BN}if +2 NH le{78(3.1\240\240)2 C(2.1)WB 10 Sn( Writing XML Docu)HY(ment)YH( and Schema)78 1 TN()EA()BN}if +2 NH le{79(3.2\240\240)2 C(2.2)WB 11 Sn( Trans)HY(lat)HY(ing)YH( Schema to C++)79 1 TN()EA()BN}if +2 NH le{80(3.3\240\240)2 C(2.3)WB 12 Sn( Imple)HY(ment)HY(ing)YH( Appli)HY(ca)HY(tion)YH( Logic)80 1 TN()EA()BN}if +2 NH le{81(3.4\240\240)2 C(2.4)WB 13 Sn( Compil)HY(ing)YH( and Running)81 1 TN()EA()BN}if +1 NH le{82(4\240\240)1 C(3)WB 14 Sn( Parser Skele)HY(tons)YH()82 1 TN()EA()BN}if +2 NH le{83(4.1\240\240)2 C(3.1)WB 15 Sn( Imple)HY(ment)HY(ing)YH( the Gender Parser)83 1 TN()EA()BN}if +2 NH le{84(4.2\240\240)2 C(3.2)WB 16 Sn( Imple)HY(ment)HY(ing)YH( the Person Parser)84 1 TN()EA()BN}if +2 NH le{85(4.3\240\240)2 C(3.3)WB 17 Sn( Imple)HY(ment)HY(ing)YH( the People Parser)85 1 TN()EA()BN}if +2 NH le{86(4.4\240\240)2 C(3.4)WB 18 Sn( Connect)HY(ing)YH( the Parsers Together)86 1 TN()EA()BN}if +1 NH le{87(5\240\240)1 C(4)WB 19 Sn( Type Maps)87 1 TN()EA()BN}if +2 NH le{88(5.1\240\240)2 C(4.1)WB 20 Sn( Object Model)88 1 TN()EA()BN}if +2 NH le{89(5.2\240\240)2 C(4.2)WB 21 Sn( Type Map File Format)89 1 TN()EA()BN}if +2 NH le{90(5.3\240\240)2 C(4.3)WB 22 Sn( Parser Imple)HY(men)HY(ta)HY(tions)YH()90 1 TN()EA()BN}if +1 NH le{91(6\240\240)1 C(5)WB 23 Sn( Mapping Config)HY(u)HY(ra)HY(tion)YH()91 1 TN()EA()BN}if +2 NH le{92(6.1\240\240)2 C(5.1)WB 24 Sn( C++ Stan)HY(dard)YH()92 1 TN()EA()BN}if +2 NH le{93(6.2\240\240)2 C(5.2)WB 25 Sn( Char)HY(ac)HY(ter)YH( Type and Encod)HY(ing)YH()93 1 TN()EA()BN}if +2 NH le{94(6.3\240\240)2 C(5.3)WB 26 Sn( Under)HY(ly)HY(ing)YH( XML Parser)94 1 TN()EA()BN}if +2 NH le{95(6.4\240\240)2 C(5.4)WB 27 Sn( XML Schema Vali)HY(da)HY(tion)YH()95 1 TN()EA()BN}if +2 NH le{96(6.5\240\240)2 C(5.5)WB 28 Sn( Support for Poly)HY(mor)HY(phism)YH()96 1 TN()EA()BN}if +1 NH le{97(7\240\240)1 C(6)WB 29 Sn( Built-In XML Schema Type Parsers)97 1 TN()EA()BN}if +2 NH le{98(7.1\240\240)2 C(6.1)WB 31 Sn( )SM(QName)ES( Parser)98 1 TN()EA()BN}if +2 NH le{99(7.2\240\240)2 C(6.2)WB 32 Sn( )SM(NMTO)HY(KENS)YH()ES( and )SM(IDREFS)ES( Parsers)99 1 TN()EA()BN}if +2 NH le{100(7.3\240\240)2 C(6.3)WB 33 Sn( )SM(base64Binary)ES( and )SM(hexBi)HY(nary)YH()ES( Parsers)100 1 TN()EA()BN}if +2 NH le{101(7.4\240\240)2 C(6.4)WB 34 Sn( Time Zone Repre)HY(sen)HY(ta)HY(tion)YH()101 1 TN()EA()BN}if +2 NH le{102(7.5\240\240)2 C(6.5)WB 35 Sn( )SM(date)ES( Parser)102 1 TN()EA()BN}if +2 NH le{103(7.6\240\240)2 C(6.6)WB 36 Sn( )SM(date)HY(Time)YH()ES( Parser)103 1 TN()EA()BN}if +2 NH le{104(7.7\240\240)2 C(6.7)WB 37 Sn( )SM(dura)HY(tion)YH()ES( Parser)104 1 TN()EA()BN}if +2 NH le{105(7.8\240\240)2 C(6.8)WB 38 Sn( )SM(gDay)ES( Parser)105 1 TN()EA()BN}if +2 NH le{106(7.9\240\240)2 C(6.9)WB 39 Sn( )SM(gMonth)ES( Parser)106 1 TN()EA()BN}if +2 NH le{107(7.10\240\240)2 C(6.10)WB 40 Sn( )SM(gMon)HY(th)HY(Day)YH()ES( Parser)107 1 TN()EA()BN}if +2 NH le{108(7.11\240\240)2 C(6.11)WB 41 Sn( )SM(gYear)ES( Parser)108 1 TN()EA()BN}if +2 NH le{109(7.12\240\240)2 C(6.12)WB 42 Sn( )SM(gYear)HY(Month)YH()ES( Parser)109 1 TN()EA()BN}if +2 NH le{110(7.13\240\240)2 C(6.13)WB 43 Sn( )SM(time)ES( Parser)110 1 TN()EA()BN}if +1 NH le{111(8\240\240)1 C(7)WB 44 Sn( Docu)HY(ment)YH( Parser and Error Handling)111 1 TN()EA()BN}if +2 NH le{112(8.1\240\240)2 C(7.1)WB 45 Sn( Xerces-C++ Docu)HY(ment)YH( Parser)112 1 TN()EA()BN}if +2 NH le{113(8.2\240\240)2 C(7.2)WB 46 Sn( Expat Docu)HY(ment)YH( Parser)113 1 TN()EA()BN}if +2 NH le{114(8.3\240\240)2 C(7.3)WB 47 Sn( Error Handling)114 1 TN()EA()BN}if +1 NH le{115(9\240\240)1 C(Appendix)WB 48 Sn( A \236 Supported XML Schema Constructs)115 1 TN()EA()BN}if +/OU t D /Cb Db D NP Ep ET +/Cb Db D /Ct [16#00 16#00 16#00] D /Cl [16#00 16#00 16#00] D /CL -1 D Ct Sc + +/Ba f D /BO 0 D Bs +/UR (/home/boris/work/xsd/builds/gcc8-host/xsd/doc/cxx/parser/guide/index.xhtml) D +/Ti (C++/Parser Mapping Getting Started Guide) D +/Au () D +/Df f D +/ME [] D + +NP RC ZF +()0 Sl()WB 0 Sn( + +)BR()WB 1 Sn( )BR()WB 2 Sn( + + + )0 1 0 H(Preface)WB 71 Sn()WB 3 Sn()EA()EH( + + )0 2 1 H(About)WB 72 Sn()WB 4 Sn( This Docu)HY(ment)YH()EA()EH( + + )0 P(The goal of this docu)HY(ment)YH( is to provide you with an under)HY(stand)HY(ing)YH( of + the C++/Parser program)HY(ming)YH( model and allow you to effi)HY(ciently)YH( eval)HY(u)HY(ate)YH( + XSD against your project's tech)HY(ni)HY(cal)YH( require)HY(ments)YH(. As such, this + docu)HY(ment)YH( is intended for C++ devel)HY(op)HY(ers)YH( and soft)HY(ware)YH( archi)HY(tects)YH( + who are looking for an XML process)HY(ing)YH( solu)HY(tion)YH(. Prior expe)HY(ri)HY(ence)YH( + with XML and C++ is required to under)HY(stand)YH( this docu)HY(ment)YH(. Basic + under)HY(stand)HY(ing)YH( of XML Schema is advan)HY(ta)HY(geous)YH( but not expected + or required. + )EP( + + + )0 2 2 H(More)WB 73 Sn()WB 5 Sn( Infor)HY(ma)HY(tion)YH()EA()EH( + + )0 P(Beyond this guide, you may also find the follow)HY(ing)YH( sources of + infor)HY(ma)HY(tion)YH( useful:)EP( + + )UL( )-1 LI()R1 2 A(XSD + Compiler Command Line Manual)EA( + + )-1 LI(The )SM(cxx/parser/)ES( direc)HY(tory)YH( in the + )R2 2 A(xsd-exam)HY(ples)YH()EA( package + contains a collec)HY(tion)YH( of exam)HY(ples)YH( and a README file with an overview + of each example. + + )-1 LI(The )SM(README)ES( file in the + )R2 2 A(xsd-exam)HY(ples)YH()EA( package + explains how to build the exam)HY(ples)YH(. + + )-1 LI(The )R3 2 A(xsd-users)EA( + mailing list is the place to ask tech)HY(ni)HY(cal)YH( ques)HY(tions)YH( about XSD and the C++/Parser mapping. + Further)HY(more)YH(, the )R4 2 A(archives)EA( + may already have answers to some of your ques)HY(tions)YH(. + + )LU( + + + + )0 1 3 H(1)WB 74 Sn()WB 6 Sn( Intro)HY(duc)HY(tion)YH()EA()EH( + + )0 P(Welcome to CodeSyn)HY(the)HY(sis)YH( XSD and the C++/Parser mapping. XSD is a + cross-plat)HY(form)YH( W3C XML Schema to C++ data binding compiler. C++/Parser + is a W3C XML Schema to C++ mapping that repre)HY(sents)YH( an XML vocab)HY(u)HY(lary)YH( + as a set of parser skele)HY(tons)YH( which you can imple)HY(ment)YH( to perform XML + process)HY(ing)YH( as required by your appli)HY(ca)HY(tion)YH( logic. + )EP( + + )0 2 4 H(1.1)WB 75 Sn()WB 7 Sn( Mapping Overview)EA()EH( + + )0 P(The C++/Parser mapping provides event-driven, stream-oriented + XML parsing, XML Schema vali)HY(da)HY(tion)YH(, and C++ data binding. It was + specif)HY(i)HY(cally)YH( designed and opti)HY(mized)YH( for high perfor)HY(mance)YH( and + small foot)HY(print)YH(. Based on the static anal)HY(y)HY(sis)YH( of the schemas, XSD + gener)HY(ates)YH( compact, highly-opti)HY(mized)YH( hier)HY(ar)HY(chi)HY(cal)YH( state machines + that combine data extrac)HY(tion)YH(, vali)HY(da)HY(tion)YH(, and even dispatch)HY(ing)YH( + in a single step. As a result, the gener)HY(ated)YH( code is typi)HY(cally)YH( + 2-10 times faster than general-purpose vali)HY(dat)HY(ing)YH( XML parsers + while main)HY(tain)HY(ing)YH( the lowest static and dynamic memory foot)HY(prints)YH(. + )EP( + + )0 P(To speed up appli)HY(ca)HY(tion)YH( devel)HY(op)HY(ment)YH(, the C++/Parser mapping + can be instructed to gener)HY(ate)YH( sample parser imple)HY(men)HY(ta)HY(tions)YH( + and a test driver which can then be filled with the appli)HY(ca)HY(tion)YH( + logic code. The mapping also provides a wide range of + mech)HY(a)HY(nisms)YH( for control)HY(ling)YH( and customiz)HY(ing)YH( the gener)HY(ated)YH( code.)EP( + + )0 P(The next chapter shows how to create a simple appli)HY(ca)HY(tion)YH( that uses + the C++/Parser mapping to parse, vali)HY(date)YH(, and extract data from a + simple XML docu)HY(ment)YH(. The follow)HY(ing)YH( chap)HY(ters)YH( show how to + use the C++/Parser mapping in more detail.)EP( + + )0 2 5 H(1.2)WB 76 Sn()WB 8 Sn( Bene)HY(fits)YH()EA()EH( + + )0 P(Tradi)HY(tional)YH( XML access APIs such as Docu)HY(ment)YH( Object Model \201DOM\202 + or Simple API for XML \201SAX\202 have a number of draw)HY(backs)YH( that + make them less suit)HY(able)YH( for creat)HY(ing)YH( robust and main)HY(tain)HY(able)YH( + XML process)HY(ing)YH( appli)HY(ca)HY(tions)YH(. These draw)HY(backs)YH( include: + )EP( + + )UL( )-1 LI(Generic repre)HY(sen)HY(ta)HY(tion)YH( of XML in terms of elements, attributes, + and text forces an appli)HY(ca)HY(tion)YH( devel)HY(oper)YH( to write a substan)HY(tial)YH( + amount of bridg)HY(ing)YH( code that iden)HY(ti)HY(fies)YH( and trans)HY(forms)YH( pieces + of infor)HY(ma)HY(tion)YH( encoded in XML to a repre)HY(sen)HY(ta)HY(tion)YH( more suit)HY(able)YH( + for consump)HY(tion)YH( by the appli)HY(ca)HY(tion)YH( logic. + + )-1 LI(String-based flow control defers error detec)HY(tion)YH( to runtime. + It also reduces code read)HY(abil)HY(ity)YH( and main)HY(tain)HY(abil)HY(ity)YH(. + + )-1 LI(Lack of type safety because the data is repre)HY(sented)YH( + as text. + + )-1 LI(Result)HY(ing)YH( appli)HY(ca)HY(tions)YH( are hard to debug, change, and + main)HY(tain)YH(. + )LU( + + )0 P(In contrast, stat)HY(i)HY(cally)YH(-typed, vocab)HY(u)HY(lary)YH(-specific parser + skele)HY(tons)YH( produced by the C++/Parser mapping allow you to + operate in your domain terms instead of the generic elements, + attributes, and text. Static typing helps catch errors at + compile-time rather than at run-time. Auto)HY(matic)YH( code gener)HY(a)HY(tion)YH( + frees you for more inter)HY(est)HY(ing)YH( tasks \201such as doing some)HY(thing)YH( + useful with the infor)HY(ma)HY(tion)YH( stored in the XML docu)HY(ments)YH(\202 and + mini)HY(mizes)YH( the effort needed to adapt your appli)HY(ca)HY(tions)YH( to + changes in the docu)HY(ment)YH( struc)HY(ture)YH(. To summa)HY(rize)YH(, the C++/Parser + mapping has the follow)HY(ing)YH( key advan)HY(tages)YH( over generic XML + access APIs:)EP( + + )UL( )-1 LI()BD(Ease of use.)ES( The gener)HY(ated)YH( code hides all the complex)HY(ity)YH( + asso)HY(ci)HY(ated)YH( with recre)HY(at)HY(ing)YH( the docu)HY(ment)YH( struc)HY(ture)YH(, main)HY(tain)HY(ing)YH( the + dispatch state, and convert)HY(ing)YH( the data from the text repre)HY(sen)HY(ta)HY(tion)YH( + to data types suit)HY(able)YH( for manip)HY(u)HY(la)HY(tion)YH( by the appli)HY(ca)HY(tion)YH( logic. + Parser skele)HY(tons)YH( also provide a conve)HY(nient)YH( mech)HY(a)HY(nism)YH( for build)HY(ing)YH( + custom in-memory repre)HY(sen)HY(ta)HY(tions)YH(. + + )-1 LI()BD(Natural repre)HY(sen)HY(ta)HY(tion)YH(.)ES( The gener)HY(ated)YH( parser skele)HY(tons)YH( + imple)HY(ment)YH( parser call)HY(backs)YH( as virtual func)HY(tions)YH( with names + corre)HY(spond)HY(ing)YH( to elements and attributes in XML. As a result, + you process the XML data using your domain vocab)HY(u)HY(lary)YH( instead + of generic elements, attributes, and text. + + + )-1 LI()BD(Concise code.)ES( With a sepa)HY(rate)YH( parser skele)HY(ton)YH( for each + XML Schema type, the appli)HY(ca)HY(tion)YH( imple)HY(men)HY(ta)HY(tion)YH( is + simpler and thus easier to read and under)HY(stand)YH(. + + )-1 LI()BD(Safety.)ES( The XML data is deliv)HY(ered)YH( to parser call)HY(backs)YH( as + stat)HY(i)HY(cally)YH( typed objects. The parser call)HY(backs)YH( them)HY(selves)YH( are virtual + func)HY(tions)YH(. This helps catch program)HY(ming)YH( errors at compile-time + rather than at runtime. + + )-1 LI()BD(Main)HY(tain)HY(abil)HY(ity)YH(.)ES( Auto)HY(matic)YH( code gener)HY(a)HY(tion)YH( mini)HY(mizes)YH( the + effort needed to adapt the appli)HY(ca)HY(tion)YH( to changes in the + docu)HY(ment)YH( struc)HY(ture)YH(. With static typing, the C++ compiler + can pin-point the places in the appli)HY(ca)HY(tion)YH( code that need to be + changed. + + )-1 LI()BD(Effi)HY(ciency)YH(.)ES( The gener)HY(ated)YH( parser skele)HY(tons)YH( combine + data extrac)HY(tion)YH(, vali)HY(da)HY(tion)YH(, and even dispatch)HY(ing)YH( in a single + step. This makes them much more effi)HY(cient)YH( than tradi)HY(tional)YH( + archi)HY(tec)HY(tures)YH( with sepa)HY(rate)YH( stages for vali)HY(da)HY(tion)YH( and data + extrac)HY(tion)YH(/dispatch. + )LU( + + + + + )0 1 6 H(2)WB 77 Sn()WB 9 Sn( Hello World Example)EA()EH( + + )0 P(In this chapter we will examine how to parse a very simple XML + docu)HY(ment)YH( using the XSD-gener)HY(ated)YH( C++/Parser skele)HY(tons)YH(. + The code presented in this chapter is based on the )SM(hello)ES( + example which can be found in the )SM(cxx/parser/)ES( direc)HY(tory)YH( in + the )R2 2 A(xsd-exam)HY(ples)YH()EA( + package.)EP( + + )0 2 7 H(2.1)WB 78 Sn()WB 10 Sn( Writing XML Docu)HY(ment)YH( and Schema)EA()EH( + + )0 P(First, we need to get an idea about the struc)HY(ture)YH( + of the XML docu)HY(ments)YH( we are going to process. Our + )SM(hello.xml)ES(, for example, could look like this:)EP( + + ) 10 28 PR( + + + Hello + + sun + moon + world + +)RP( + + )0 P(Then we can write a descrip)HY(tion)YH( of the above XML in the + XML Schema language and save it into )SM(hello.xsd)ES(:)EP( + + ) 13 70 PR( + + + + + + + + + + + +)RP( + + )0 P(Even if you are not famil)HY(iar)YH( with XML Schema, it + should be easy to connect decla)HY(ra)HY(tions)YH( in )SM(hello.xsd)ES( + to elements in )SM(hello.xml)ES(. The )SM(hello)ES( type + is defined as a sequence of the nested )SM(greet)HY(ing)YH()ES( and + )SM(name)ES( elements. Note that the term sequence in XML + Schema means that elements should appear in a partic)HY(u)HY(lar)YH( order + as opposed to appear)HY(ing)YH( multi)HY(ple)YH( times. The )SM(name)ES( + element has its )SM(maxOc)HY(curs)YH()ES( prop)HY(erty)YH( set to + )SM(unbounded)ES( which means it can appear multi)HY(ple)YH( times + in an XML docu)HY(ment)YH(. Finally, the glob)HY(ally)YH(-defined )SM(hello)ES( + element prescribes the root element for our vocab)HY(u)HY(lary)YH(. For an + easily-approach)HY(able)YH( intro)HY(duc)HY(tion)YH( to XML Schema refer to + )R5 2 A(XML Schema Part 0: + Primer)EA(.)EP( + + )0 P(The above schema is a spec)HY(i)HY(fi)HY(ca)HY(tion)YH( of our XML vocab)HY(u)HY(lary)YH(; it tells + every)HY(body)YH( what valid docu)HY(ments)YH( of our XML-based language should look + like. The next step is to compile this schema to gener)HY(ate)YH( + the object model and parsing func)HY(tions)YH(.)EP( + + )0 2 8 H(2.2)WB 79 Sn()WB 11 Sn( Trans)HY(lat)HY(ing)YH( Schema to C++)EA()EH( + + )0 P(Now we are ready to trans)HY(late)YH( our )SM(hello.xsd)ES( to C++ parser + skele)HY(tons)YH(. To do this we invoke the XSD compiler from a termi)HY(nal)YH( + \201UNIX\202 or a command prompt \201Windows\202: + )EP( + + ) 1 45 PR($ xsd cxx-parser --xml-parser expat hello.xsd)RP( + + )0 P(The )SM(--xml-parser)ES( option indi)HY(cates)YH( that we want to + use Expat as the under)HY(ly)HY(ing)YH( XML parser \201see )0 50 1 A(Section + 5.3, "Under)HY(ly)HY(ing)YH( XML Parser")50 0 TN TL()Ec /AF f D(\202. The XSD compiler produces two + C++ files: )SM(hello-pskel.hxx)ES( and )SM(hello-pskel.cxx)ES(. + The follow)HY(ing)YH( code frag)HY(ment)YH( is taken from )SM(hello-pskel.hxx)ES(; + it should give you an idea about what gets gener)HY(ated)YH(: + )EP( + + ) 32 60 PR(class hello_pskel +{ +public: + // Parser callbacks. Override them in your implementation. + // + virtual void + pre \201\202; + + virtual void + greeting \201const std::string&\202; + + virtual void + name \201const std::string&\202; + + virtual void + post_hello \201\202; + + // Parser construction API. + // + void + greeting_parser \201xml_schema::string_pskel&\202; + + void + name_parser \201xml_schema::string_pskel&\202; + + void + parsers \201xml_schema::string_pskel& /* greeting */, + xml_schema::string_pskel& /* name */\202; + +private: + ...)WR( +};)RP( + + )0 P(The first four member func)HY(tions)YH( shown above are called parser + call)HY(backs)YH(. You would normally over)HY(ride)YH( them in your imple)HY(men)HY(ta)HY(tion)YH( + of the parser to do some)HY(thing)YH( useful. Let's go through all of + them one by one.)EP( + + )0 P(The )SM(pre\201\202)ES( func)HY(tion)YH( is an initial)HY(iza)HY(tion)YH( call)HY(back)YH(. It is + called when a new element of type )SM(hello)ES( is about + to be parsed. You would normally use this func)HY(tion)YH( to allo)HY(cate)YH( a new + instance of the result)HY(ing)YH( type or clear accu)HY(mu)HY(la)HY(tors)YH( that are used + to gather infor)HY(ma)HY(tion)YH( during parsing. The default imple)HY(men)HY(ta)HY(tion)YH( + of this func)HY(tion)YH( does nothing.)EP( + + )0 P(The )SM(post_hello\201\202)ES( func)HY(tion)YH( is a final)HY(iza)HY(tion)YH( call)HY(back)YH(. Its + name is constructed by adding the parser skele)HY(ton)YH( name to the + )SM(post_)ES( prefix. The final)HY(iza)HY(tion)YH( call)HY(back)YH( is called when + parsing of the element is complete and the result, if any, should + be returned. Note that in our case the return type of + )SM(post_hello\201\202)ES( is )SM(void)ES( which means there + is nothing to return. More on parser return types later. + )EP( + + )0 P(You may be wonder)HY(ing)YH( why the final)HY(iza)HY(tion)YH( call)HY(back)YH( is called + )SM(post_hello\201\202)ES( instead of )SM(post\201\202)ES( just + like )SM(pre\201\202)ES(. The reason for this is that + final)HY(iza)HY(tion)YH( call)HY(backs)YH( can have differ)HY(ent)YH( return types and + result in func)HY(tion)YH( signa)HY(ture)YH( clashes across inher)HY(i)HY(tance)YH( + hier)HY(ar)HY(chies)YH(. To prevent this the signa)HY(tures)YH( of final)HY(iza)HY(tion)YH( + call)HY(backs)YH( are made unique by adding the type name to their names.)EP( + + )0 P(The )SM(greet)HY(ing)YH(\201\202)ES( and )SM(name\201\202)ES( func)HY(tions)YH( are + called when the )SM(greet)HY(ing)YH()ES( and )SM(name)ES( elements + have been parsed, respec)HY(tively)YH(. Their argu)HY(ments)YH( are of type + )SM(std::string)ES( and contain the data extracted from XML.)EP( + + )0 P(The last three func)HY(tions)YH( are for connect)HY(ing)YH( parsers to each other. + For example, there is a prede)HY(fined)YH( parser for built-in XML Schema type + )SM(string)ES( in the XSD runtime. We will be using + it to parse the contents of )SM(greet)HY(ing)YH()ES( and + )SM(name)ES( elements, as shown in the next section.)EP( + + )0 2 9 H(2.3)WB 80 Sn()WB 12 Sn( Imple)HY(ment)HY(ing)YH( Appli)HY(ca)HY(tion)YH( Logic)EA()EH( + + )0 P(At this point we have all the parts we need to do some)HY(thing)YH( useful + with the infor)HY(ma)HY(tion)YH( stored in our XML docu)HY(ment)YH(. The first step is + to imple)HY(ment)YH( the parser: + )EP( + + ) 21 60 PR(#include +#include "hello-pskel.hxx" + +class hello_pimpl: public hello_pskel +{ +public: + virtual void + greeting \201const std::string& g\202 + { + greeting_ = g; + } + + virtual void + name \201const std::string& n\202 + { + std::cout << greeting_ << ", " << n << "!" << std::endl; + } + +private: + std::string greeting_; +};)RP( + + )0 P(We left both )SM(pre\201\202)ES( and )SM(post_hello\201\202)ES( with the + default imple)HY(men)HY(ta)HY(tions)YH(; we don't have anything to initial)HY(ize)YH( or + return. The rest is pretty straight)HY(for)HY(ward)YH(: we store the greet)HY(ing)YH( + in a member vari)HY(able)YH( and later, when parsing names, use it to + say hello.)EP( + + )0 P(An obser)HY(vant)YH( reader my ask what happens if the )SM(name)ES( + element comes before )SM(greet)HY(ing)YH()ES(? Don't we need to + make sure )SM(greet)HY(ing)YH(_)ES( was initial)HY(ized)YH( and report + an error other)HY(wise)YH(? The answer is no, we don't have to do + any of this. The )SM(hello_pskel)ES( parser skele)HY(ton)YH( + performs vali)HY(da)HY(tion)YH( of XML accord)HY(ing)YH( to the schema from which + it was gener)HY(ated)YH(. As a result, it will check the order + of the )SM(greet)HY(ing)YH()ES( and )SM(name)ES( elements + and report an error if it is violated.)EP( + + )0 P(Now it is time to put this parser imple)HY(men)HY(ta)HY(tion)YH( to work:)EP( + + ) 29 50 PR(using namespace std; + +int +main \201int argc, char* argv[]\202 +{ + try + { + // Construct the parser. + // + xml_schema::string_pimpl string_p; + hello_pimpl hello_p; + + hello_p.greeting_parser \201string_p\202; + hello_p.name_parser \201string_p\202; + + // Parse the XML instance. + // + xml_schema::document doc_p \201hello_p, "hello"\202; + + hello_p.pre \201\202; + doc_p.parse \201argv[1]\202; + hello_p.post_hello \201\202; + } + catch \201const xml_schema::exception& e\202 + { + cerr << e << endl; + return 1; + } +})RP( + + )0 P(The first part of this code snippet instan)HY(ti)HY(ates)YH( indi)HY(vid)HY(ual)YH( parsers + and assem)HY(bles)YH( them into a complete vocab)HY(u)HY(lary)YH( parser. + )SM(xml_schema::string_pimpl)ES( is an imple)HY(men)HY(ta)HY(tion)YH( of a parser + for built-in XML Schema type )SM(string)ES(. It is provided by + the XSD runtime along with parsers for other built-in types \201for + more infor)HY(ma)HY(tion)YH( on the built-in parsers see )0 51 1 A(Chapter 6, + "Built-In XML Schema Type Parsers")51 0 TN TL()Ec /AF f D(\202. We use )SM(string_pimpl)ES( + to parse the )SM(greet)HY(ing)YH()ES( and )SM(name)ES( elements as + indi)HY(cated)YH( by the calls to )SM(greet)HY(ing)YH(_parser\201\202)ES( and + )SM(name_parser\201\202)ES(. + )EP( + + )0 P(Then we instan)HY(ti)HY(ate)YH( a docu)HY(ment)YH( parser \201)SM(doc_p)ES(\202. The + first argu)HY(ment)YH( to its construc)HY(tor)YH( is the parser for + the root element \201)SM(hello_p)ES( in our case\202. The + second argu)HY(ment)YH( is the root element name. + )EP( + + )0 P(The final piece is the calls to )SM(pre\201\202)ES(, )SM(parse\201\202)ES(, + and )SM(post_hello\201\202)ES(. The call to )SM(parse\201\202)ES( + perform the actual XML parsing while the calls to )SM(pre\201\202)ES( and + )SM(post_hello\201\202)ES( make sure that the parser for the root + element can perform proper initial)HY(iza)HY(tion)YH( and cleanup.)EP( + + )0 P(While our parser imple)HY(men)HY(ta)HY(tion)YH( and test driver are pretty small and + easy to write by hand, for bigger XML vocab)HY(u)HY(lar)HY(ies)YH( it can be a + substan)HY(tial)YH( effort. To help with this task XSD can auto)HY(mat)HY(i)HY(cally)YH( + gener)HY(ate)YH( sample parser imple)HY(men)HY(ta)HY(tions)YH( and a test driver from your + schemas. You can request the gener)HY(a)HY(tion)YH( of a sample imple)HY(men)HY(ta)HY(tion)YH( with + empty func)HY(tion)YH( bodies by spec)HY(i)HY(fy)HY(ing)YH( the )SM(--gener)HY(ate)YH(-noop-impl)ES( + option. Or you can gener)HY(ate)YH( a sample imple)HY(men)HY(ta)HY(tion)YH( that prints the + data store in XML by using the )SM(--gener)HY(ate)YH(-print-impl)ES( + option. To request the gener)HY(a)HY(tion)YH( of a test driver you can use the + )SM(--gener)HY(ate)YH(-test-driver)ES( option. For more infor)HY(ma)HY(tion)YH( + on these options refer to the + )R1 2 A(XSD + Compiler Command Line Manual)EA(. The )SM('gener)HY(ated)YH(')ES( example + in the )R2 2 A(xsd-exam)HY(ples)YH()EA( package + shows the sample imple)HY(men)HY(ta)HY(tion)YH( gener)HY(a)HY(tion)YH( feature in action.)EP( + + + )0 2 10 H(2.4)WB 81 Sn()WB 13 Sn( Compil)HY(ing)YH( and Running)EA()EH( + + )0 P(After saving all the parts from the previ)HY(ous)YH( section in + )SM(driver.cxx)ES(, we are ready to compile our first + appli)HY(ca)HY(tion)YH( and run it on the test XML docu)HY(ment)YH(. On a UNIX + system this can be done with the follow)HY(ing)YH( commands: + )EP( + + ) 6 59 PR($ c++ -std=c++11 -I.../libxsd -c driver.cxx hello-pskel.cxx +$ c++ -std=c++11 -o driver driver.o hello-pskel.o -lexpat +$ ./driver hello.xml +Hello, sun! +Hello, moon! +Hello, world!)RP( + + )0 P(Here )SM(.../libxsd)ES( repre)HY(sents)YH( the path to the + )R6 2 A(libxsd)EA( package root + direc)HY(tory)YH(. We can also test the error handling. To test XML + well-formed)HY(ness)YH( check)HY(ing)YH(, we can try to parse + )SM(hello-pskel.hxx)ES(:)EP( + + ) 2 52 PR($ ./driver hello-pskel.hxx +hello-pskel.hxx:1:0: not well-formed \201invalid token\202)RP( + + )0 P(We can also try to parse a valid XML but not from our + vocab)HY(u)HY(lary)YH(, for example )SM(hello.xsd)ES(:)EP( + + ) 3 50 PR($ ./driver hello.xsd +hello.xsd:2:0: expected element 'hello' instead of +'http://www.w3.org/2001/XMLSchema#schema')RP( + + + + + + )0 1 11 H(3)WB 82 Sn()WB 14 Sn( Parser Skele)HY(tons)YH()EA()EH( + + )0 P(As we have seen in the previ)HY(ous)YH( chapter, the XSD compiler gener)HY(ates)YH( + a parser skele)HY(ton)YH( class for each type defined in XML Schema. In + this chapter we will take a closer look at differ)HY(ent)YH( func)HY(tions)YH( + that comprise a parser skele)HY(ton)YH( as well as the way to connect + our imple)HY(men)HY(ta)HY(tions)YH( of these parser skele)HY(tons)YH( to create a complete + parser.)EP( + + )0 P(In this and subse)HY(quent)YH( chap)HY(ters)YH( we will use the follow)HY(ing)YH( schema + that describes a collec)HY(tion)YH( of person records. We save it in + )SM(people.xsd)ES(:)EP( + + ) 28 69 PR( + + + + + + + + + + + + + + + + + + + + + + + + + + +)RP( + + )0 P(A sample XML instance to go along with this schema is saved + in )SM(people.xml)ES(:)EP( + + ) 15 33 PR( + + + John + Doe + male + 32 + + + Jane + Doe + female + 28 + +)RP( + + )0 P(Compil)HY(ing)YH( )SM(people.xsd)ES( with the XSD compiler results + in three parser skele)HY(tons)YH( being gener)HY(ated)YH(: )SM(gender_pskel)ES(, + )SM(person_pskel)ES(, and )SM(people_pskel)ES(. We are going + to examine and imple)HY(ment)YH( each of them in the subse)HY(quent)YH( sections.)EP( + + )0 2 12 H(3.1)WB 83 Sn()WB 15 Sn( Imple)HY(ment)HY(ing)YH( the Gender Parser)EA()EH( + + )0 P(The gener)HY(ated)YH( )SM(gender_pskel)ES( parser skele)HY(ton)YH( looks like + this:)EP( + + ) 11 60 PR(class gender_pskel: public virtual xml_schema::string_pskel +{ +public: + // Parser callbacks. Override them in your implementation. + // + virtual void + pre \201\202; + + virtual void + post_gender \201\202; +};)RP( + + )0 P(Notice that )SM(gender_pskel)ES( inher)HY(its)YH( from + )SM(xml_schema::string_skel)ES( which is a parser skele)HY(ton)YH( + for built-in XML Schema type )SM(string)ES( and is + prede)HY(fined)YH( in the XSD runtime library. This is an example + of the general rule that parser skele)HY(tons)YH( follow: if a type + in XML Schema inher)HY(its)YH( from another then there will be an + equiv)HY(a)HY(lent)YH( inher)HY(i)HY(tance)YH( between the corre)HY(spond)HY(ing)YH( parser + skele)HY(ton)YH( classes.)EP( + + )0 P(The )SM(pre\201\202)ES( and )SM(post_gender\201\202)ES( call)HY(backs)YH( + should look famil)HY(iar)YH( from the previ)HY(ous)YH( chapter. Let's now + imple)HY(ment)YH( the parser. Our imple)HY(men)HY(ta)HY(tion)YH( will simply print + the gender to )SM(cout)ES(:)EP( + + + ) 11 51 PR(class gender_pimpl: public gender_pskel, + public xml_schema::string_pimpl +{ +public: + virtual void + post_gender \201\202 + { + std::string s = post_string \201\202; + cout << "gender: " << s << endl; + } +};)RP( + + )0 P(While the code is quite short, there is a lot going on. First, + notice that we are inher)HY(it)HY(ing)YH( from )SM(gender_pskel)ES( )EM(and)ES( + from )SM(xml_schema::string_pimpl)ES(. We've encoun)HY(tered)YH( + )SM(xml_schema::string_pimpl)ES( already; it is an + imple)HY(men)HY(ta)HY(tion)YH( of the )SM(xml_schema::string_pskel)ES( parser + skele)HY(ton)YH( for built-in XML Schema type )SM(string)ES(.)EP( + + )0 P(This is another common theme in the C++/Parser program)HY(ming)YH( model: + reusing imple)HY(men)HY(ta)HY(tions)YH( of the base parsers in the derived ones with + the C++ mixin idiom. In our case, )SM(string_pimpl)ES( will + do all the dirty work of extract)HY(ing)YH( the data and we can just get + it at the end with the call to )SM(post_string\201\202)ES(.)EP( + + )0 P(In case you are curious, here is what + )SM(xml_schema::string_pskel)ES( and + )SM(xml_schema::string_pimpl)ES( look like:)EP( + + ) 25 49 PR(namespace xml_schema +{ + class string_pskel: public simple_content + { + public: + virtual std::string + post_string \201\202 = 0; + }; + + class string_pimpl: public virtual string_pskel + { + public: + virtual void + _pre \201\202; + + virtual void + _characters \201const xml_schema::ro_string&\202; + + virtual std::string + post_string \201\202; + + protected: + std::string str_; + }; +})RP( + + )0 P(There are three new pieces in this code that we haven't seen yet. + They are the )SM(simple_content)ES( class as well as + the )SM(_pre\201\202)ES( and )SM(_char)HY(ac)HY(ters)YH(\201\202)ES( func)HY(tions)YH(. + The )SM(simple_content)ES( class is defined in the XSD + runtime and is a base class for all parser skele)HY(tons)YH( that conform + to the simple content model in XML Schema. Types with the + simple content model cannot have nested elements\236only text + and attributes. There is also the )SM(complex_content)ES( + class which corre)HY(sponds)YH( to the complex content mode \201types with + nested elements, for example, )SM(person)ES( from + )SM(people.xsd)ES(\202.)EP( + + )0 P(The )SM(_pre\201\202)ES( func)HY(tion)YH( is a parser call)HY(back)YH(. Remem)HY(ber)YH( we + talked about the )SM(pre\201\202)ES( and )SM(post_*\201\202)ES( call)HY(backs)YH( + in the previ)HY(ous)YH( chapter? There are actu)HY(ally)YH( two more call)HY(backs)YH( + with similar roles: )SM(_pre\201\202)ES( and )SM(_post \201\202)ES(. + As a result, each parser skele)HY(ton)YH( has four special call)HY(backs)YH(:)EP( + + ) 11 15 PR( virtual void + pre \201\202; + + virtual void + _pre \201\202; + + virtual void + _post \201\202; + + virtual void + post_name \201\202;)RP( + + )0 P()SM(pre\201\202)ES( and )SM(_pre\201\202)ES( are initial)HY(iza)HY(tion)YH( + call)HY(backs)YH(. They get called in that order before a new instance of the type + is about to be parsed. The differ)HY(ence)YH( between )SM(pre\201\202)ES( and + )SM(_pre\201\202)ES( is conven)HY(tional)YH(: )SM(pre\201\202)ES( can + be completely over)HY(rid)HY(den)YH( by a derived parser. The derived + parser can also over)HY(ride)YH( )SM(_pre\201\202)ES( but has to always call + the orig)HY(i)HY(nal)YH( version. This allows you to parti)HY(tion)YH( initial)HY(iza)HY(tion)YH( + into customiz)HY(able)YH( and required parts.)EP( + + )0 P(Simi)HY(larly)YH(, )SM(_post\201\202)ES( and )SM(post_name\201\202)ES( are + final)HY(iza)HY(tion)YH( call)HY(backs)YH( with exactly the same seman)HY(tics)YH(: + )SM(post_name\201\202)ES( can be completely over)HY(rid)HY(den)YH( by the derived + parser while the orig)HY(i)HY(nal)YH( )SM(_post\201\202)ES( should always be called. + )EP( + + )0 P(The final bit we need to discuss in this section is the + )SM(_char)HY(ac)HY(ters)YH(\201\202)ES( func)HY(tion)YH(. As you might have guessed, it + is also a call)HY(back)YH(. A low-level one that deliv)HY(ers)YH( raw char)HY(ac)HY(ter)YH( content + for the type being parsed. You will seldom need to use this call)HY(back)YH( + directly. Using imple)HY(men)HY(ta)HY(tions)YH( for the built-in parsers provided by + the XSD runtime is usually a simpler and more conve)HY(nient)YH( + alter)HY(na)HY(tive)YH(.)EP( + + )0 P(At this point you might be wonder)HY(ing)YH( why some )SM(post_*\201\202)ES( + call)HY(backs)YH(, for example )SM(post_string\201\202)ES(, return some data + while others, for example )SM(post_gender\201\202)ES(, have + )SM(void)ES( as a return type. This is a valid concern + and it will be addressed in the next chapter.)EP( + + )0 2 13 H(3.2)WB 84 Sn()WB 16 Sn( Imple)HY(ment)HY(ing)YH( the Person Parser)EA()EH( + + )0 P(The gener)HY(ated)YH( )SM(person_pskel)ES( parser skele)HY(ton)YH( looks like + this:)EP( + + ) 43 60 PR(class person_pskel: public xml_schema::complex_content +{ +public: + // Parser callbacks. Override them in your implementation. + // + virtual void + pre \201\202; + + virtual void + first_name \201const std::string&\202; + + virtual void + last_name \201const std::string&\202; + + virtual void + gender \201\202; + + virtual void + age \201short\202; + + virtual void + post_person \201\202; + + // Parser construction API. + // + void + first_name_parser \201xml_schema::string_pskel&\202; + + void + last_name_parser \201xml_schema::string_pskel&\202; +)WR( + void + gender_parser \201gender_pskel&\202; + + void + age_parser \201xml_schema::short_pskel&\202; + + void + parsers \201xml_schema::string_pskel& /* first-name */, + xml_schema::string_pskel& /* last-name */, + gender_pskel& /* gender */, + xml_schema::short_pskel& /* age */\202; +};)RP( + + + )0 P(As you can see, we have a parser call)HY(back)YH( for each of the nested + elements found in the )SM(person)ES( XML Schema type. + The imple)HY(men)HY(ta)HY(tion)YH( of this parser is straight)HY(for)HY(ward)YH(:)EP( + + ) 21 39 PR(class person_pimpl: public person_pskel +{ +public: + virtual void + first_name \201const std::string& n\202 + { + cout << "first: " << f << endl; + } + + virtual void + last_name \201const std::string& l\202 + { + cout << "last: " << l << endl; + } + + virtual void + age \201short a\202 + { + cout << "age: " << a << endl; + } +};)RP( + + )0 P(Notice that we didn't over)HY(ride)YH( the )SM(gender\201\202)ES( call)HY(back)YH( + because all the print)HY(ing)YH( is done by )SM(gender_pimpl)ES(.)EP( + + + )0 2 14 H(3.3)WB 85 Sn()WB 17 Sn( Imple)HY(ment)HY(ing)YH( the People Parser)EA()EH( + + )0 P(The gener)HY(ated)YH( )SM(people_pskel)ES( parser skele)HY(ton)YH( looks like + this:)EP( + + ) 22 60 PR(class people_pskel: public xml_schema::complex_content +{ +public: + // Parser callbacks. Override them in your implementation. + // + virtual void + pre \201\202; + + virtual void + person \201\202; + + virtual void + post_people \201\202; + + // Parser construction API. + // + void + person_parser \201person_pskel&\202; + + void + parsers \201person_pskel& /* person */\202; +};)RP( + + )0 P(The )SM(person\201\202)ES( call)HY(back)YH( will be called after parsing each + )SM(person)ES( element. While )SM(person_pimpl)ES( does + all the print)HY(ing)YH(, one useful thing we can do in this call)HY(back)YH( is to + print an extra newline after each person record so that our + output is more read)HY(able)YH(:)EP( + + ) 9 39 PR(class people_pimpl: public people_pskel +{ +public: + virtual void + person \201\202 + { + cout << endl; + } +};)RP( + + )0 P(Now it is time to put every)HY(thing)YH( together.)EP( + + + )0 2 15 H(3.4)WB 86 Sn()WB 18 Sn( Connect)HY(ing)YH( the Parsers Together)EA()EH( + + )0 P(At this point we have all the indi)HY(vid)HY(ual)YH( parsers imple)HY(mented)YH( + and can proceed to assem)HY(ble)YH( them into a complete parser + for our XML vocab)HY(u)HY(lary)YH(. The first step is to instan)HY(ti)HY(ate)YH( + all the indi)HY(vid)HY(ual)YH( parsers that we will need:)EP( + + ) 6 34 PR(xml_schema::short_pimpl short_p; +xml_schema::string_pimpl string_p; + +gender_pimpl gender_p; +person_pimpl person_p; +people_pimpl people_p;)RP( + + )0 P(Notice that our schema uses two built-in XML Schema types: + )SM(string)ES( for the )SM(first-name)ES( and + )SM(last-name)ES( elements as well as )SM(short)ES( + for )SM(age)ES(. We will use prede)HY(fined)YH( parsers that + come with the XSD runtime to handle these types. The next + step is to connect all the indi)HY(vid)HY(ual)YH( parsers. We do this + with the help of func)HY(tions)YH( defined in the parser + skele)HY(tons)YH( and marked with the "Parser Construc)HY(tion)YH( API" + comment. One way to do it is to connect each indi)HY(vid)HY(ual)YH( + parser by calling the )SM(*_parser\201\202)ES( func)HY(tions)YH(:)EP( + + ) 6 38 PR(person_p.first_name_parser \201string_p\202; +person_p.last_name_parser \201string_p\202; +person_p.gender_parser \201gender_p\202; +person_p.age_parser \201short_p\202; + +people_p.person_parser \201person_p\202;)RP( + + )0 P(You might be wonder)HY(ing)YH( what happens if you do not provide + a parser by not calling one of the )SM(*_parser\201\202)ES( func)HY(tions)YH(. + In that case the corre)HY(spond)HY(ing)YH( XML content will be skipped, + includ)HY(ing)YH( vali)HY(da)HY(tion)YH(. This is an effi)HY(cient)YH( way to ignore parts + of the docu)HY(ment)YH( that you are not inter)HY(ested)YH( in.)EP( + + + )0 P(An alter)HY(na)HY(tive)YH(, shorter, way to connect the parsers is by using + the )SM(parsers\201\202)ES( func)HY(tions)YH( which connects all the parsers + for a given type at once:)EP( + + ) 2 57 PR(person_p.parsers \201string_p, string_p, gender_p, short_p\202; +people_p.parsers \201person_p\202;)RP( + + )0 P(The follow)HY(ing)YH( figure illus)HY(trates)YH( the result)HY(ing)YH( connec)HY(tions)YH(. Notice + the corre)HY(spon)HY(dence)YH( between return types of the )SM(post_*\201\202)ES( + func)HY(tions)YH( and argu)HY(ment)YH( types of element call)HY(backs)YH( that are connected + by the arrows.)EP( + + + )2 Al()BR()0 0 IM()Ea()BR( + + )0 P(The last step is the construc)HY(tion)YH( of the docu)HY(ment)YH( parser and + invo)HY(ca)HY(tion)YH( of the complete parser on our sample XML instance:)EP( + + ) 5 48 PR(xml_schema::document doc_p \201people_p, "people"\202; + +people_p.pre \201\202; +doc_p.parse \201"people.xml"\202; +people_p.post_people \201\202;)RP( + + )0 P(Let's consider )SM(xml_schema::docu)HY(ment)YH()ES( in + more detail. While the exact defi)HY(ni)HY(tion)YH( of this class + varies depend)HY(ing)YH( on the under)HY(ly)HY(ing)YH( parser selected, + here is the common part:)EP( + + ) 24 56 PR(namespace xml_schema +{ + class document + { + public: + document \201xml_schema::parser_base&, + const std::string& root_element_name, + bool polymorphic = false\202; + + document \201xml_schema::parser_base&, + const std::string& root_element_namespace, + const std::string& root_element_name, + bool polymorphic = false\202; + + void + parse \201const std::string& file\202; + + void + parse \201std::istream&\202; + + ... + + }; +})RP( + + )0 P()SM(xml_schema::docu)HY(ment)YH()ES( is a root parser for + the vocab)HY(u)HY(lary)YH(. The first argu)HY(ment)YH( to its construc)HY(tors)YH( is the + parser for the type of the root element \201)SM(people_impl)ES( + in our case\202. Because a type parser is only concerned with + the element's content and not with the element's name, we need + to specify the root element's name some)HY(where)YH(. That's + what is passed as the second and third argu)HY(ments)YH( to the + )SM(docu)HY(ment)YH()ES('s construc)HY(tors)YH(.)EP( + + )0 P(There are also two over)HY(loaded)YH( )SM(parse\201\202)ES( func)HY(tions)YH( + defined in the )SM(docu)HY(ment)YH()ES( class \201there are actu)HY(ally)YH( + more but the others are specific to the under)HY(ly)HY(ing)YH( XML parser\202. + The first version parses a local file iden)HY(ti)HY(fied)YH( by a name. The + second version reads the data from an input stream. For more + infor)HY(ma)HY(tion)YH( on the )SM(xml_schema::docu)HY(ment)YH()ES( class + refer to )0 52 1 A(Chapter 7, "Docu)HY(ment)YH( Parser and Error + Handling")52 0 TN TL()Ec /AF f D(.)EP( + + )0 P(Let's now consider a step-by-step list of actions that happen + as we parse through )SM(people.xml)ES(. The content of + )SM(people.xml)ES( is repeated below for conve)HY(nience)YH(.)EP( + + ) 15 33 PR( + + + John + Doe + male + 32 + + + Jane + Doe + female + 28 + +)RP( + + + )4 OL( )-1 LI()SM(people_p.pre\201\202)ES( is called from + )SM(main\201\202)ES(. We did not provide any imple)HY(men)HY(ta)HY(tion)YH( + for this call)HY(back)YH( so this call is a no-op. + + )-1 LI()SM(doc_p.parse\201"people.xml"\202)ES( is called from + )SM(main\201\202)ES(. The parser opens the file and starts + parsing its content. + + )-1 LI(The parser encoun)HY(ters)YH( the root element. )SM(doc_p)ES( + veri)HY(fies)YH( that the root element is correct and calls + )SM(_pre\201\202)ES( on )SM(people_p)ES( which is also + a no-op. Parsing is now dele)HY(gated)YH( to )SM(people_p)ES(. + + )-1 LI(The parser encoun)HY(ters)YH( the )SM(person)ES( element. + )SM(people_p)ES( deter)HY(mines)YH( that )SM(person_p)ES( + is respon)HY(si)HY(ble)YH( for parsing this element. )SM(pre\201\202)ES( + and )SM(_pre\201\202)ES( call)HY(backs)YH( are called on )SM(person_p)ES(. + Parsing is now dele)HY(gated)YH( to )SM(person_p)ES(. + + )-1 LI(The parser encoun)HY(ters)YH( the )SM(first-name)ES( element. + )SM(person_p)ES( deter)HY(mines)YH( that )SM(string_p)ES( + is respon)HY(si)HY(ble)YH( for parsing this element. )SM(pre\201\202)ES( + and )SM(_pre\201\202)ES( call)HY(backs)YH( are called on )SM(string_p)ES(. + Parsing is now dele)HY(gated)YH( to )SM(string_p)ES(. + + )-1 LI(The parser encoun)HY(ters)YH( char)HY(ac)HY(ter)YH( content consist)HY(ing)YH( of + )SM("John")ES(. The )SM(_char)HY(ac)HY(ters)YH(\201\202)ES( call)HY(back)YH( is + called on )SM(string_p)ES(. + + )-1 LI(The parser encoun)HY(ters)YH( the end of )SM(first-name)ES( + element. The )SM(_post\201\202)ES( and )SM(post_string\201\202)ES( + call)HY(backs)YH( are called on )SM(string_p)ES(. The + )SM(first_name\201\202)ES( call)HY(back)YH( is called on )SM(person_p)ES( + with the return value of )SM(post_string\201\202)ES(. The + )SM(first_name\201\202)ES( imple)HY(men)HY(ta)HY(tion)YH( prints + )SM("first: John")ES( to )SM(cout)ES(. + Parsing is now returned to )SM(person_p)ES(. + + )-1 LI(Steps anal)HY(o)HY(gous)YH( to 5-7 are performed for the )SM(last-name)ES(, + )SM(gender)ES(, and )SM(age)ES( elements. + + )-1 LI(The parser encoun)HY(ters)YH( the end of )SM(person)ES( + element. The )SM(_post\201\202)ES( and )SM(post_person\201\202)ES( + call)HY(backs)YH( are called on )SM(person_p)ES(. The + )SM(person\201\202)ES( call)HY(back)YH( is called on )SM(people_p)ES(. + The )SM(person\201\202)ES( imple)HY(men)HY(ta)HY(tion)YH( prints a new line + to )SM(cout)ES(. Parsing is now returned to + )SM(people_p)ES(. + + )-1 LI(Steps 4-9 are performed for the second )SM(person)ES( + element. + + )-1 LI(The parser encoun)HY(ters)YH( the end of )SM(people)ES( + element. The )SM(_post\201\202)ES( call)HY(back)YH( is called on + )SM(people_p)ES(. The )SM(doc_p.parse\201"people.xml"\202)ES( + call returns to )SM(main\201\202)ES(. + + )-1 LI()SM(people_p.post_people\201\202)ES( is called from + )SM(main\201\202)ES( which is a no-op. + + )LO( + + + + + + )0 1 16 H(4)WB 87 Sn()WB 19 Sn( Type Maps)EA()EH( + + )0 P(There are many useful things you can do inside parser call)HY(backs)YH( as they + are right now. There are, however, times when you want to prop)HY(a)HY(gate)YH( + some infor)HY(ma)HY(tion)YH( from one parser to another or to the caller of the + parser. One common task that would greatly benefit from such a + possi)HY(bil)HY(ity)YH( is build)HY(ing)YH( a tree-like in-memory object model of the + data stored in XML. During execu)HY(tion)YH(, each indi)HY(vid)HY(ual)YH( sub-parser + would create a sub-tree and return it to its )EM(parent)ES( parser + which can then incor)HY(po)HY(rate)YH( this sub-tree into the whole tree.)EP( + + )0 P(In this chapter we will discuss the mech)HY(a)HY(nisms)YH( offered by the + C++/Parser mapping for return)HY(ing)YH( infor)HY(ma)HY(tion)YH( from indi)HY(vid)HY(ual)YH( + parsers and see how to use them to build an object model + of our people vocab)HY(u)HY(lary)YH(.)EP( + + )0 2 17 H(4.1)WB 88 Sn()WB 20 Sn( Object Model)EA()EH( + + )0 P(An object model for our person record example could + look like this \201saved in the )SM(people.hxx)ES( file\202:)EP( + + ) 53 35 PR(#include +#include + +enum gender +{ + male, + female +}; + +class person +{ +public: + person \201const std::string& first, + const std::string& last, + ::gender gender, + short age\202 + : first_ \201first\202, last_ \201last\202, + gender_ \201gender\202, age_ \201age\202 + { + } + + const std::string& + first \201\202 const + { + return first_; + } + + const std::string& + last \201\202 const + { + return last_;)WR( + } + + ::gender + gender \201\202 const + { + return gender_; + } + + short + age \201\202 const + { + return age_; + } + +private: + std::string first_; + std::string last_; + ::gender gender_; + short age_; +}; + +typedef std::vector people;)RP( + + )0 P(While it is clear which parser is respon)HY(si)HY(ble)YH( for which part of + the object model, it is not exactly clear how, for + example, )SM(gender_pimpl)ES( will deliver )SM(gender)ES( + to )SM(person_pimpl)ES(. You might have noticed that + )SM(string_pimpl)ES( manages to deliver its value to the + )SM(first_name\201\202)ES( call)HY(back)YH( of )SM(person_pimpl)ES(. Let's + see how we can utilize the same mech)HY(a)HY(nism)YH( to prop)HY(a)HY(gate)YH( our + own data.)EP( + + )0 P(There is a way to tell the XSD compiler that you want to + exchange data between parsers. More precisely, for each + type defined in XML Schema, you can tell the compiler two things. + First, the return type of the )SM(post_*\201\202)ES( call)HY(back)YH( + in the parser skele)HY(ton)YH( gener)HY(ated)YH( for this type. And, second, + the argu)HY(ment)YH( type for call)HY(backs)YH( corre)HY(spond)HY(ing)YH( to elements and + attributes of this type. For example, for XML Schema type + )SM(gender)ES( we can specify the return type for + )SM(post_gender\201\202)ES( in the )SM(gender_pskel)ES( + skele)HY(ton)YH( and the argu)HY(ment)YH( type for the )SM(gender\201\202)ES( call)HY(back)YH( + in the )SM(person_pskel)ES( skele)HY(ton)YH(. As you might have guessed, + the gener)HY(ated)YH( code will then pass the return value from the + )SM(post_*\201\202)ES( call)HY(back)YH( as an argu)HY(ment)YH( to the element or + attribute call)HY(back)YH(.)EP( + + )0 P(The way to tell the XSD compiler about these XML Schema to + C++ mappings is with type map files. Here is a simple type + map for the )SM(gender)ES( type from the previ)HY(ous)YH( para)HY(graph)YH(:)EP( + + ) 2 25 PR(include "people.hxx"; +gender ::gender ::gender;)RP( + + )0 P(The first line indi)HY(cates)YH( that the gener)HY(ated)YH( code must include + )SM(people.hxx)ES( in order to get the defi)HY(ni)HY(tion)YH( for the + )SM(gender)ES( type. The second line spec)HY(i)HY(fies)YH( that both + argu)HY(ment)YH( and return types for the )SM(gender)ES( + XML Schema type should be the )SM(::gender)ES( C++ enum + \201we use fully-qual)HY(i)HY(fied)YH( C++ names to avoid name clashes\202. + The next section will describe the type map format in detail. + We save this type map in )SM(people.map)ES( and + then trans)HY(late)YH( our schemas with the )SM(--type-map)ES( + option to let the XSD compiler know about our type map:)EP( + + ) 1 49 PR($ xsd cxx-parser --type-map people.map people.xsd)RP( + + )0 P(If we now look at the gener)HY(ated)YH( )SM(people-pskel.hxx)ES(, + we will see the follow)HY(ing)YH( changes in the )SM(gender_pskel)ES( and + )SM(person_pskel)ES( skele)HY(tons)YH(:)EP( + + ) 17 59 PR(#include "people.hxx" + +class gender_pskel: public virtual xml_schema::string_pskel +{ + virtual ::gender + post_gender \201\202 = 0; + + ... +}; + +class person_pskel: public xml_schema::complex_content +{ + virtual void + gender \201::gender\202; + + ... +};)RP( + + )0 P(Notice that )SM(#include "people.hxx")ES( was added to + the gener)HY(ated)YH( header file from the type map to provide the + defi)HY(ni)HY(tion)YH( for the )SM(gender)ES( enum.)EP( + + )0 2 18 H(4.2)WB 89 Sn()WB 21 Sn( Type Map File Format)EA()EH( + + )0 P(Type map files are used to define a mapping between XML Schema + and C++ types. The compiler uses this infor)HY(ma)HY(tion)YH( + to deter)HY(mine)YH( return types of )SM(post_*\201\202)ES( + call)HY(backs)YH( in parser skele)HY(tons)YH( corre)HY(spond)HY(ing)YH( to XML Schema + types as well as argu)HY(ment)YH( types for call)HY(backs)YH( corre)HY(spond)HY(ing)YH( + to elements and attributes of these types.)EP( + + )0 P(The compiler has a set of prede)HY(fined)YH( mapping rules that map + the built-in XML Schema types to suit)HY(able)YH( C++ types \201discussed + below\202 and all other types to )SM(void)ES(. + By provid)HY(ing)YH( your own type maps you can over)HY(ride)YH( these prede)HY(fined)YH( + rules. The format of the type map file is presented below: + )EP( + + ) 5 58 PR(namespace [] +{ + \201include ;\202* + \201[type] [];\202* +})RP( + + )0 P(Both )SM()I()ES()ES( and + )SM()I()ES()ES( are regex patterns while + )SM()I()ES()ES(, + )SM()I()ES()ES(, and + )SM()I()ES()ES( are regex pattern + substi)HY(tu)HY(tions)YH(. All names can be option)HY(ally)YH( enclosed in + )SM(" ")ES(, for example, to include white-spaces.)EP( + + )0 P()SM()I()ES()ES( deter)HY(mines)YH( XML + Schema names)HY(pace)YH(. Optional )SM()I()ES()ES( + is prefixed to every C++ type name in this names)HY(pace)YH( decla)HY(ra)HY(tion)YH(. + )SM()I()ES()ES( is a C++ type name that is + used as a return type for the )SM(post_*\201\202)ES( call)HY(back)YH(. + Optional )SM()I()ES()ES( is an argu)HY(ment)YH( + type for call)HY(backs)YH( corre)HY(spond)HY(ing)YH( to elements and attributes + of this type. If )SM()I()ES()ES( is not + spec)HY(i)HY(fied)YH(, it defaults to )SM()I()ES()ES( + if )SM()I()ES()ES( ends with )SM(*)ES( or + )SM(&)ES( \201that is, it is a pointer or a refer)HY(ence)YH(\202 and + )SM(const\240)I()ES(&)ES( + other)HY(wise)YH(. + )SM()I()ES()ES( is a file name either in the + )SM(" ")ES( or )SM(< >)ES( format + and is added with the )SM(#include)ES( direc)HY(tive)YH( to + the gener)HY(ated)YH( code.)EP( + + )0 P(The )SM()BD(#)ES()ES( char)HY(ac)HY(ter)YH( starts a comment that ends + with a new line or end of file. To specify a name that contains + )SM()BD(#)ES()ES( enclose it in )SM()BD(" ")ES()ES(. + For example:)EP( + + ) 12 44 PR(namespace http://www.example.com/xmlns/my my +{ + include "my.hxx"; + + # Pass apples by value. + # + apple apple; + + # Pass oranges as pointers. + # + orange orange_t*; +})RP( + + )0 P(In the example above, for the + )SM(http://www.example.com/xmlns/my#orange)ES( + XML Schema type, the )SM(my::orange_t*)ES( C++ type will + be used as both return and argu)HY(ment)YH( types.)EP( + + )0 P(Several names)HY(pace)YH( decla)HY(ra)HY(tions)YH( can be spec)HY(i)HY(fied)YH( in a single + file. The names)HY(pace)YH( decla)HY(ra)HY(tion)YH( can also be completely + omitted to map types in a schema without a names)HY(pace)YH(. For + instance:)EP( + + ) 7 41 PR(include "my.hxx"; +apple apple; + +namespace http://www.example.com/xmlns/my +{ + orange "const orange_t*"; +})RP( + + )0 P(The compiler has a number of prede)HY(fined)YH( mapping rules for + the built-in XML Schema types which can be presented as the + follow)HY(ing)YH( map files. The string-based XML Schema types are + mapped to either )SM(std::string)ES( or + )SM(std::wstring)ES( depend)HY(ing)YH( on the char)HY(ac)HY(ter)YH( type + selected \201see )0 53 1 A( Section 5.2, "Char)HY(ac)HY(ter)YH( Type and + Encod)HY(ing)YH(")53 0 TN TL()Ec /AF f D( for more infor)HY(ma)HY(tion)YH(\202. The binary XML Schema + types are mapped to either )SM(std::unique_ptr)ES( + or )SM(std::auto_ptr)ES( + depend)HY(ing)YH( on the C++ stan)HY(dard)YH( selected \201C++11 or C++98, + respec)HY(tively)YH(; refer to the )SM(--std)ES( XSD compiler + command line option for details\202.)EP( + + ) 59 63 PR(namespace http://www.w3.org/2001/XMLSchema +{ + boolean bool bool; + + byte "signed char" "signed char"; + unsignedByte "unsigned char" "unsigned char"; + + short short short; + unsignedShort "unsigned short" "unsigned short"; + + int int int; + unsignedInt "unsigned int" "unsigned int"; + + long "long long" "long long"; + unsignedLong "unsigned long long" "unsigned long long"; + + integer "long long" "long long"; + + negativeInteger "long long" "long long"; + nonPositiveInteger "long long" "long long"; + + positiveInteger "unsigned long long" "unsigned long long"; + nonNegativeInteger "unsigned long long" "unsigned long long"; + + float float float; + double double double; + decimal double double; + + string std::string; + normalizedString std::string; + token std::string;)WR( + Name std::string; + NMTOKEN std::string; + NCName std::string; + ID std::string; + IDREF std::string; + language std::string; + anyURI std::string; + + NMTOKENS xml_schema::string_sequence; + IDREFS xml_schema::string_sequence; + + QName xml_schema::qname; + + base64Binary std::[unique|auto]_ptr + std::[unique|auto]_ptr; + hexBinary std::[unique|auto]_ptr + std::[unique|auto]_ptr; + + date xml_schema::date; + dateTime xml_schema::date_time; + duration xml_schema::duration; + gDay xml_schema::gday; + gMonth xml_schema::gmonth; + gMonthDay xml_schema::gmonth_day; + gYear xml_schema::gyear; + gYearMonth xml_schema::gyear_month; + time xml_schema::time; +})RP( + + )0 P(For more infor)HY(ma)HY(tion)YH( about the mapping of the built-in XML Schema types + to C++ types refer to )0 51 1 A(Chapter 6, "Built-In XML Schema Type + Parsers")51 0 TN TL()Ec /AF f D(. The last prede)HY(fined)YH( rule maps anything that wasn't + mapped by previ)HY(ous)YH( rules to )SM(void)ES(:)EP( + + ) 4 15 PR(namespace .* +{ + .* void void; +})RP( + + + )0 P(When you provide your own type maps with the + )SM(--type-map)ES( option, they are eval)HY(u)HY(ated)YH( first. This + allows you to selec)HY(tively)YH( over)HY(ride)YH( any of the prede)HY(fined)YH( rules. + Note also that if you change the mapping + of a built-in XML Schema type then it becomes your respon)HY(si)HY(bil)HY(ity)YH( + to provide the corre)HY(spond)HY(ing)YH( parser skele)HY(ton)YH( and imple)HY(men)HY(ta)HY(tion)YH( + in the )SM(xml_schema)ES( names)HY(pace)YH(. You can include the + custom defi)HY(ni)HY(tions)YH( into the gener)HY(ated)YH( header file using the + )SM(--hxx-prologue-*)ES( options.)EP( + + )0 2 19 H(4.3)WB 90 Sn()WB 22 Sn( Parser Imple)HY(men)HY(ta)HY(tions)YH()EA()EH( + + )0 P(With the knowl)HY(edge)YH( from the previ)HY(ous)YH( section, we can proceed + with creat)HY(ing)YH( a type map that maps types in the )SM(people.xsd)ES( + schema to our object model classes in + )SM(people.hxx)ES(. In fact, we already have the begin)HY(ning)YH( + of our type map file in )SM(people.map)ES(. Let's extend + it with the rest of the types:)EP( + + ) 5 25 PR(include "people.hxx"; + +gender ::gender ::gender; +person ::person; +people ::people;)RP( + + )0 P(There are a few things to note about this type map. We did not + provide the argu)HY(ment)YH( types for )SM(person)ES( and + )SM(people)ES( because the default constant refer)HY(ence)YH( is + exactly what we need. We also did not provide any mappings + for built-in XML Schema types )SM(string)ES( and + )SM(short)ES( because they are handled by the prede)HY(fined)YH( + rules and we are happy with the result. Note also that + all C++ types are fully qual)HY(i)HY(fied)YH(. This is done to avoid + poten)HY(tial)YH( name conflicts in the gener)HY(ated)YH( code. Now we can + recom)HY(pile)YH( our schema and move on to imple)HY(ment)HY(ing)YH( the parsers:)EP( + + ) 1 68 PR($ xsd cxx-parser --xml-parser expat --type-map people.map people.xsd)RP( + + )0 P(Here is the imple)HY(men)HY(ta)HY(tion)YH( of our three parsers in full. One + way to save typing when imple)HY(ment)HY(ing)YH( your own parsers is + to open the gener)HY(ated)YH( code and copy the signa)HY(tures)YH( of parser + call)HY(backs)YH( into your code. Or you could always auto gener)HY(ate)YH( the + sample imple)HY(men)HY(ta)HY(tions)YH( and fill them with your code.)EP( + + + ) 73 52 PR(#include "people-pskel.hxx" + +class gender_pimpl: public gender_pskel, + public xml_schema::string_pimpl +{ +public: + virtual ::gender + post_gender \201\202 + { + return post_string \201\202 == "male" ? male : female; + } +}; + +class person_pimpl: public person_pskel +{ +public: + virtual void + first_name \201const std::string& f\202 + { + first_ = f; + } + + virtual void + last_name \201const std::string& l\202 + { + last_ = l; + } + + virtual void + gender \201::gender g\202 + {)WR( + gender_ = g; + } + + virtual void + age \201short a\202 + { + age_ = a; + } + + virtual ::person + post_person \201\202 + { + return ::person \201first_, last_, gender_, age_\202; + } + +private: + std::string first_; + std::string last_; + ::gender gender_; + short age_; +}; + +class people_pimpl: public people_pskel +{ +public: + virtual void + person \201const ::person& p\202 + { + people_.push_back \201p\202; + })WR( + + virtual ::people + post_people \201\202 + { + ::people r; + r.swap \201people_\202; + return r; + } + +private: + ::people people_; +};)RP( + + )0 P(This code frag)HY(ment)YH( should look famil)HY(iar)YH( by now. Just note that + all the )SM(post_*\201\202)ES( call)HY(backs)YH( now have return types instead + of )SM(void)ES(. Here is the imple)HY(men)HY(ta)HY(tion)YH( of the test + driver for this example:)EP( + + ) 38 76 PR(#include + +using namespace std; + +int +main \201int argc, char* argv[]\202 +{ + // Construct the parser. + // + xml_schema::short_pimpl short_p; + xml_schema::string_pimpl string_p; + + gender_pimpl gender_p; + person_pimpl person_p; + people_pimpl people_p; + + person_p.parsers \201string_p, string_p, gender_p, short_p\202; + people_p.parsers \201person_p\202; + + // Parse the document to obtain the object model. + // + xml_schema::document doc_p \201people_p, "people"\202; + + people_p.pre \201\202; + doc_p.parse \201argv[1]\202; + people ppl = people_p.post_people \201\202; + + // Print the object model. + // + for \201people::iterator i \201ppl.begin \201\202\202; i != ppl.end \201\202; ++i\202 + {)WR( + cout << "first: " << i->first \201\202 << endl + << "last: " << i->last \201\202 << endl + << "gender: " << \201i->gender \201\202 == male ? "male" : "female"\202 << endl + << "age: " << i->age \201\202 << endl + << endl; + } +})RP( + + )0 P(The parser creation and assem)HY(bly)YH( part is exactly the same as in + the previ)HY(ous)YH( chapter. The parsing part is a bit differ)HY(ent)YH(: + )SM(post_people\201\202)ES( now has a return value which is the + complete object model. We store it in the + )SM(ppl)ES( vari)HY(able)YH(. The last bit of the code simply iter)HY(ates)YH( + over the )SM(people)ES( vector and prints the infor)HY(ma)HY(tion)YH( + for each person. We save the last two code frag)HY(ments)YH( to + )SM(driver.cxx)ES( and proceed to compile and test + our new appli)HY(ca)HY(tion)YH(:)EP( + + + ) 12 60 PR($ c++ -std=c++11 -I.../libxsd -c driver.cxx people-pskel.cxx +$ c++ -std=c++11 -o driver driver.o people-pskel.o -lexpat +$ ./driver people.xml +first: John +last: Doe +gender: male +age: 32 + +first: Jane +last: Doe +gender: female +age: 28)RP( + + + + + + )0 1 20 H(5)WB 91 Sn()WB 23 Sn( Mapping Config)HY(u)HY(ra)HY(tion)YH()EA()EH( + + )0 P(The C++/Parser mapping has a number of config)HY(u)HY(ra)HY(tion)YH( param)HY(e)HY(ters)YH( that + deter)HY(mine)YH( the overall prop)HY(er)HY(ties)YH( and behav)HY(ior)YH( of the gener)HY(ated)YH( code. + Config)HY(u)HY(ra)HY(tion)YH( param)HY(e)HY(ters)YH( are spec)HY(i)HY(fied)YH( with the XSD command line + options and include the C++ stan)HY(dard)YH(, the char)HY(ac)HY(ter)YH( type that is used + by the gener)HY(ated)YH( code, the under)HY(ly)HY(ing)YH( XML parser, whether the XML Schema + vali)HY(da)HY(tion)YH( is performed in the gener)HY(ated)YH( code, and support for XML Schema + poly)HY(mor)HY(phism)YH(. This chapter describes these config)HY(u)HY(ra)HY(tion)YH( + param)HY(e)HY(ters)YH( in more detail. For more ways to config)HY(ure)YH( the gener)HY(ated)YH( + code refer to the + )R1 2 A(XSD + Compiler Command Line Manual)EA(. + )EP( + + )0 2 21 H(5.1)WB 92 Sn()WB 24 Sn( C++ Stan)HY(dard)YH()EA()EH( + + )0 P(The C++/Parser mapping provides support for ISO/IEC C++ 2011 \201C++11\202 + and ISO/IEC C++ 1998/2003 \201C++98\202. To select the C++ stan)HY(dard)YH( for the + gener)HY(ated)YH( code we use the )SM(--std)ES( XSD compiler command + line option. While the major)HY(ity)YH( of the exam)HY(ples)YH( in this guide use + C++11, the docu)HY(ment)YH( explains the C++11/98 usage differ)HY(ence)YH( and so + they can easily be converted to C++98.)EP( + + )0 2 22 H(5.2)WB 93 Sn()WB 25 Sn( Char)HY(ac)HY(ter)YH( Type and Encod)HY(ing)YH()EA()EH( + + )0 P(The C++/Parser mapping has built-in support for two char)HY(ac)HY(ter)YH( types: + )SM(char)ES( and )SM(wchar_t)ES(. You can select the + char)HY(ac)HY(ter)YH( type with the )SM(--char-type)ES( command line + option. The default char)HY(ac)HY(ter)YH( type is )SM(char)ES(. The + string-based built-in XML Schema types are returned as either + )SM(std::string)ES( or )SM(std::wstring)ES( depend)HY(ing)YH( + on the char)HY(ac)HY(ter)YH( type selected.)EP( + + )0 P(Another aspect of the mapping that depends on the char)HY(ac)HY(ter)YH( type + is char)HY(ac)HY(ter)YH( encod)HY(ing)YH(. For the )SM(char)ES( char)HY(ac)HY(ter)YH( type + the default encod)HY(ing)YH( is UTF-8. Other supported encod)HY(ings)YH( are + ISO-8859-1, Xerces-C++ Local Code Page \201LPC\202, as well as + custom encod)HY(ings)YH(. You can select which encod)HY(ing)YH( should be used + in the object model with the )SM(--char-encod)HY(ing)YH()ES( command + line option.)EP( + + )0 P(For the )SM(wchar_t)ES( char)HY(ac)HY(ter)YH( type the encod)HY(ing)YH( is + auto)HY(mat)HY(i)HY(cally)YH( selected between UTF-16 and UTF-32/UCS-4 depend)HY(ing)YH( + on the size of the )SM(wchar_t)ES( type. On some plat)HY(forms)YH( + \201for example, Windows with Visual C++ and AIX with IBM XL C++\202 + )SM(wchar_t)ES( is 2 bytes long. For these plat)HY(forms)YH( the + encod)HY(ing)YH( is UTF-16. On other plat)HY(forms)YH( )SM(wchar_t)ES( is 4 bytes + long and UTF-32/UCS-4 is used.)EP( + + )0 P(Note also that the char)HY(ac)HY(ter)YH( encod)HY(ing)YH( that is used in the object model + is inde)HY(pen)HY(dent)YH( of the encod)HY(ings)YH( used in input and output XML. In fact, + all three \201object mode, input XML, and output XML\202 can have differ)HY(ent)YH( + encod)HY(ings)YH(.)EP( + + )0 2 23 H(5.3)WB 94 Sn()WB 26 Sn( Under)HY(ly)HY(ing)YH( XML Parser)EA()EH( + + )0 P(The C++/Parser mapping can be used with either Xerces-C++ or Expat + as the under)HY(ly)HY(ing)YH( XML parser. You can select the XML parser with + the )SM(--xml-parser)ES( command line option. Valid values + for this option are )SM(xerces)ES( and )SM(expat)ES(. + The default XML parser is Xerces-C++.)EP( + + )0 P(The gener)HY(ated)YH( code is iden)HY(ti)HY(cal)YH( for both parsers except for the + )SM(xml_schema::docu)HY(ment)YH()ES( class in which some of the + )SM(parse\201\202)ES( func)HY(tions)YH( are parser-specific as described + in )0 52 1 A(Chapter 7, "Docu)HY(ment)YH( Parser and Error Handling")52 0 TN TL()Ec /AF f D(.)EP( + + + )0 2 24 H(5.4)WB 95 Sn()WB 27 Sn( XML Schema Vali)HY(da)HY(tion)YH()EA()EH( + + )0 P(The C++/Parser mapping provides support for vali)HY(dat)HY(ing)YH( a + commonly-used subset of W3C XML Schema in the gener)HY(ated)YH( code. + For the list of supported XML Schema constructs refer to + )0 54 1 A(Appendix A, "Supported XML Schema Constructs")54 0 TN TL()Ec /AF f D(.)EP( + + )0 P(By default vali)HY(da)HY(tion)YH( in the gener)HY(ated)YH( code is disabled if + the under)HY(ly)HY(ing)YH( XML parser is vali)HY(dat)HY(ing)YH( \201Xerces-C++\202 and + enabled other)HY(wise)YH( \201Expat\202. See )0 50 1 A(Section 5.3, + "Under)HY(ly)HY(ing)YH( XML Parser")50 0 TN TL()Ec /AF f D( for more infor)HY(ma)HY(tion)YH( about + the under)HY(ly)HY(ing)YH( XML parser. You can over)HY(ride)YH( the default + behav)HY(ior)YH( with the )SM(--gener)HY(ate)YH(-vali)HY(da)HY(tion)YH()ES( + and )SM(--suppress-vali)HY(da)HY(tion)YH()ES( command line options.)EP( + + + )0 2 25 H(5.5)WB 96 Sn()WB 28 Sn( Support for Poly)HY(mor)HY(phism)YH()EA()EH( + + )0 P(By default the XSD compiler gener)HY(ates)YH( non-poly)HY(mor)HY(phic)YH( code. If your + vocab)HY(u)HY(lary)YH( uses XML Schema poly)HY(mor)HY(phism)YH( in the form of )SM(xsi:type)ES( + and/or substi)HY(tu)HY(tion)YH( groups, then you will need to compile your schemas + with the )SM(--gener)HY(ate)YH(-poly)HY(mor)HY(phic)YH()ES( option to produce + poly)HY(mor)HY(phism)YH(-aware code as well as pass )SM(true)ES( as the last + argu)HY(ment)YH( to the )SM(xml_schema::docu)HY(ment)YH()ES('s construc)HY(tors)YH(.)EP( + + )0 P(When using the poly)HY(mor)HY(phism)YH(-aware gener)HY(ated)YH( code, you can specify + several parsers for a single element by passing a parser map + instead of an indi)HY(vid)HY(ual)YH( parser to the parser connec)HY(tion)YH( func)HY(tion)YH( + for the element. One of the parsers will then be looked up and used + depend)HY(ing)YH( on the )SM(xsi:type)ES( attribute value or an element + name from a substi)HY(tu)HY(tion)YH( group. Consider the follow)HY(ing)YH( schema as an + example:)EP( + + ) 44 62 PR( + + + + + + + + + + + + + + + + + + + + + + + + + + + +)WR( + + + + + + + + + + +)RP( + + )0 P(Conform)HY(ing)YH( XML docu)HY(ments)YH( can use the )SM(super)HY(man)YH()ES( + and )SM(batman)ES( types in place of the )SM(person)ES( + type either by spec)HY(i)HY(fy)HY(ing)YH( the type with the )SM(xsi:type)ES( + attributes or by using the elements from the substi)HY(tu)HY(tion)YH( + group, for instance:)EP( + + + ) 15 64 PR( + + + John Doe + + + + James "007" Bond + + + + Bruce Wayne + + +)RP( + + )0 P(To print the data stored in such XML docu)HY(ments)YH( we can imple)HY(ment)YH( + the parsers as follows:)EP( + + ) 79 52 PR(class person_pimpl: public virtual person_pskel +{ +public: + virtual void + pre \201\202 + { + cout << "starting to parse person" << endl; + } + + virtual void + name \201const std::string& v\202 + { + cout << "name: " << v << endl; + } + + virtual void + post_person \201\202 + { + cout << "finished parsing person" << endl; + } +}; + +class superman_pimpl: public virtual superman_pskel, + public person_pimpl +{ +public: + virtual void + pre \201\202 + { + cout << "starting to parse superman" << endl; + })WR( + + virtual void + can_fly \201bool v\202 + { + cout << "can-fly: " << v << endl; + } + + virtual void + post_person \201\202 + { + post_superman \201\202; + } + + virtual void + post_superman \201\202 + { + cout << "finished parsing superman" << endl + } +}; + +class batman_pimpl: public virtual batman_pskel, + public superman_pimpl +{ +public: + virtual void + pre \201\202 + { + cout << "starting to parse batman" << endl; + } +)WR( + virtual void + wing_span \201unsigned int v\202 + { + cout << "wing-span: " << v << endl; + } + + virtual void + post_superman \201\202 + { + post_batman \201\202; + } + + virtual void + post_batman \201\202 + { + cout << "finished parsing batman" << endl; + } +};)RP( + + )0 P(Note that because the derived type parsers \201)SM(super)HY(man)YH(_pskel)ES( + and )SM(batman_pskel)ES(\202 are called via the )SM(person_pskel)ES( + inter)HY(face)YH(, we have to over)HY(ride)YH( the )SM(post_person\201\202)ES( + virtual func)HY(tion)YH( in )SM(super)HY(man)YH(_pimpl)ES( to call + )SM(post_super)HY(man)YH(\201\202)ES( and the )SM(post_super)HY(man)YH(\201\202)ES( + virtual func)HY(tion)YH( in )SM(batman_pimpl)ES( to call + )SM(post_batman\201\202)ES(.)EP( + + )0 P(The follow)HY(ing)YH( code frag)HY(ment)YH( shows how to connect the parsers together. + Notice that for the )SM(person)ES( element in the )SM(super)HY(men)YH(_p)ES( + parser we specify a parser map instead of a specific parser and we pass + )SM(true)ES( as the last argu)HY(ment)YH( to the docu)HY(ment)YH( parser construc)HY(tor)YH( + to indi)HY(cate)YH( that we are parsing poten)HY(tially)YH(-poly)HY(mor)HY(phic)YH( XML docu)HY(ments)YH(:)EP( + + ) 39 64 PR(int +main \201int argc, char* argv[]\202 +{ + // Construct the parser. + // + xml_schema::string_pimpl string_p; + xml_schema::boolean_pimpl boolean_p; + xml_schema::unsigned_int_pimpl unsigned_int_p; + + person_pimpl person_p; + superman_pimpl superman_p; + batman_pimpl batman_p; + + xml_schema::parser_map_impl person_map; + supermen_pimpl supermen_p; + + person_p.parsers \201string_p\202; + superman_p.parsers \201string_p, boolean_p\202; + batman_p.parsers \201string_p, boolean_p, unsigned_int_p\202; + + // Here we are specifying a parser map which containes several + // parsers that can be used to parse the person element. + // + person_map.insert \201person_p\202; + person_map.insert \201superman_p\202; + person_map.insert \201batman_p\202; + + supermen_p.person_parser \201person_map\202; + + // Parse the XML document. The last argument to the document's + // constructor indicates that we are parsing polymorphic XML)WR( + // documents. + // + xml_schema::document doc_p \201supermen_p, "supermen", true\202; + + supermen_p.pre \201\202; + doc_p.parse \201argv[1]\202; + supermen_p.post_supermen \201\202; +})RP( + + )0 P(When poly)HY(mor)HY(phism)YH(-aware code is gener)HY(ated)YH(, each element's + )SM(*_parser\201\202)ES( func)HY(tion)YH( is over)HY(loaded)YH( to also accept + an object of the )SM(xml_schema::parser_map)ES( type. + For example, the )SM(super)HY(men)YH(_pskel)ES( class from the + above example looks like this:)EP( + + ) 21 63 PR(class supermen_pskel: public xml_schema::parser_complex_content +{ +public: + + ... + + // Parser construction API. + // + void + parsers \201person_pskel&\202; + + // Individual element parsers. + // + void + person_parser \201person_pskel&\202; + + void + person_parser \201const xml_schema::parser_map&\202; + + ... +};)RP( + + )0 P(Note that you can specify both the indi)HY(vid)HY(ual)YH( \201static\202 parser and + the parser map. The indi)HY(vid)HY(ual)YH( parser will be used when the static + element type and the dynamic type of the object being parsed are + the same. This is the case, for example, when there is no + )SM(xsi:type)ES( attribute and the element hasn't been + substi)HY(tuted)YH(. Because the indi)HY(vid)HY(ual)YH( parser for an element is + cached and no map lookup is neces)HY(sary)YH(, it makes sense to specify + both the indi)HY(vid)HY(ual)YH( parser and the parser map when most of the + objects being parsed are of the static type and optimal + perfor)HY(mance)YH( is impor)HY(tant)YH(. The follow)HY(ing)YH( code frag)HY(ment)YH( shows + how to change the above example to set both the indi)HY(vid)HY(ual)YH( + parser and the parser map:)EP( + + ) 13 40 PR(int +main \201int argc, char* argv[]\202 +{ + ... + + person_map.insert \201superman_p\202; + person_map.insert \201batman_p\202; + + supermen_p.person_parser \201person_p\202; + supermen_p.person_parser \201person_map\202; + + ... +})RP( + + + )0 P(The )SM(xml_schema::parser_map)ES( inter)HY(face)YH( and the + )SM(xml_schema::parser_map_impl)ES( default imple)HY(men)HY(ta)HY(tion)YH( + are presented below:)EP( + + ) 27 45 PR(namespace xml_schema +{ + class parser_map + { + public: + virtual parser_base* + find \201const ro_string* type\202 const = 0; + }; + + class parser_map_impl: public parser_map + { + public: + void + insert \201parser_base&\202; + + virtual parser_base* + find \201const ro_string* type\202 const; + + private: + parser_map_impl \201const parser_map_impl&\202; + + parser_map_impl& + operator= \201const parser_map_impl&\202; + + ... + }; +})RP( + + )0 P(The )SM(type)ES( argu)HY(ment)YH( in the )SM(find\201\202)ES( virtual + func)HY(tion)YH( is the type name and names)HY(pace)YH( from the xsi:type attribute + \201the names)HY(pace)YH( prefix is resolved to the actual XML names)HY(pace)YH(\202 + or the type of an element from the substi)HY(tu)HY(tion)YH( group in the form + )SM("\240")ES( with the space and the + names)HY(pace)YH( part absent if the type does not have a names)HY(pace)YH(. + You can obtain a parser's dynamic type in the same format + using the )SM(_dynamic_type\201\202)ES( func)HY(tion)YH(. The static + type can be obtained by calling the static )SM(_static_type\201\202)ES( + func)HY(tion)YH(, for example )SM(person_pskel::_static_type\201\202)ES(. + Both func)HY(tions)YH( return a C string \201)SM(const char*)ES( or + )SM(const wchar_t*)ES(, depend)HY(ing)YH( on the char)HY(ac)HY(ter)YH( type + used\202 which is valid for as long as the appli)HY(ca)HY(tion)YH( is running. + The follow)HY(ing)YH( example shows how we can imple)HY(ment)YH( our own parser + map using )SM(std::map)ES(:)EP( + + + ) 23 62 PR(#include +#include + +class parser_map: public xml_schema::parser_map +{ +public: + void + insert \201xml_schema::parser_base& p\202 + { + map_[p._dynamic_type \201\202] = &p; + } + + virtual xml_schema::parser_base* + find \201const xml_schema::ro_string* type\202 const + { + map::const_iterator i = map_.find \201type\202; + return i != map_.end \201\202 ? i->second : 0; + } + +private: + typedef std::map map; + map map_; +};)RP( + + )0 P(Most of code presented in this section is taken from the + )SM(poly)HY(mor)HY(phism)YH()ES( example which can be found in the + )SM(cxx/parser/)ES( direc)HY(tory)YH( in the + )R2 2 A(xsd-exam)HY(ples)YH()EA( package. + Handling of )SM(xsi:type)ES( and substi)HY(tu)HY(tion)YH( groups when used on + root elements requires a number of special actions as shown in + the )SM(poly)HY(root)YH()ES( example.)EP( + + + + + + )0 1 26 H(6)WB 97 Sn()WB 29 Sn( Built-In XML Schema Type Parsers)EA()EH( + + )0 P(The XSD runtime provides parser imple)HY(men)HY(ta)HY(tions)YH( for all built-in + XML Schema types as summa)HY(rized)YH( in the follow)HY(ing)YH( table. Decla)HY(ra)HY(tions)YH( + for these types are auto)HY(mat)HY(i)HY(cally)YH( included into each gener)HY(ated)YH( + header file. As a result you don't need to include any headers + to gain access to these parser imple)HY(men)HY(ta)HY(tions)YH(. Note that some + parsers return either )SM(std::string)ES( or + )SM(std::wstring)ES( depend)HY(ing)YH( on the char)HY(ac)HY(ter)YH( type selected.)EP( + + + )0 PT( + + )0 2 27 H(6.1)WB 98 Sn()WB 31 Sn( )SM(QName)ES( Parser)EA()EH( + + )0 P(The return type of the )SM(qname_pimpl)ES( parser imple)HY(men)HY(ta)HY(tion)YH( + is )SM(xml_schema::qname)ES( which repre)HY(sents)YH( an XML qual)HY(i)HY(fied)YH( + name. Its inter)HY(face)YH( is presented below. + Note that the )SM(std::string)ES( type in the inter)HY(face)YH( becomes + )SM(std::wstring)ES( if the selected char)HY(ac)HY(ter)YH( type is + )SM(wchar_t)ES(.)EP( + + ) 28 63 PR(namespace xml_schema +{ + class qname + { + public: + explicit + qname \201const std::string& name\202; + qname \201const std::string& prefix, const std::string& name\202; + + const std::string& + prefix \201\202 const; + + void + prefix \201const std::string&\202; + + const std::string& + name \201\202 const; + + void + name \201const std::string&\202; + }; + + bool + operator== \201const qname&, const qname&\202; + + bool + operator!= \201const qname&, const qname&\202; +})RP( + + + )0 2 28 H(6.2)WB 99 Sn()WB 32 Sn( )SM(NMTO)HY(KENS)YH()ES( and )SM(IDREFS)ES( Parsers)EA()EH( + + )0 P(The return type of the )SM(nmto)HY(kens)YH(_pimpl)ES( and + )SM(idrefs_pimpl)ES( parser imple)HY(men)HY(ta)HY(tions)YH( is + )SM(xml_schema::string_sequence)ES( which repre)HY(sents)YH( a + sequence of strings. Its inter)HY(face)YH( is presented below. + Note that the )SM(std::string)ES( type in the inter)HY(face)YH( becomes + )SM(std::wstring)ES( if the selected char)HY(ac)HY(ter)YH( type is + )SM(wchar_t)ES(.)EP( + + ) 21 62 PR(namespace xml_schema +{ + class string_sequence: public std::vector + { + public: + string_sequence \201\202; + + explicit + string_sequence \201std::vector::size_type n, + const std::string& x = std::string \201\202\202; + + template + string_sequence \201const I& begin, const I& end\202; + }; + + bool + operator== \201const string_sequence&, const string_sequence&\202; + + bool + operator!= \201const string_sequence&, const string_sequence&\202; +})RP( + + + )0 2 29 H(6.3)WB 100 Sn()WB 33 Sn( )SM(base64Binary)ES( and )SM(hexBi)HY(nary)YH()ES( Parsers)EA()EH( + + )0 P(The return type of the )SM(base64_binary_pimpl)ES( and + )SM(hex_binary_pimpl)ES( parser imple)HY(men)HY(ta)HY(tions)YH( is either + )SM(std::unique_ptr)ES( \201C++11\202 or + )SM(std::auto_ptr)ES( \201C++98\202, + depend)HY(ing)YH( on the C++ stan)HY(dard)YH( selected \201)SM(--std)ES( XSD + compiler option\202. The )SM(xml_schema::buffer)ES( type + repre)HY(sents)YH( a binary buffer and its inter)HY(face)YH( is presented below.)EP( + + ) 69 60 PR(namespace xml_schema +{ + class buffer + { + public: + typedef std::size_t size_t; + + class bounds {}; // Out of bounds exception. + + public: + explicit + buffer \201size_t size = 0\202; + buffer \201size_t size, size_t capacity\202; + buffer \201const void* data, size_t size\202; + buffer \201const void* data, size_t size, size_t capacity\202; + buffer \201void* data, + size_t size, + size_t capacity, + bool assume_ownership\202; + + public: + buffer \201const buffer&\202; + + buffer& + operator= \201const buffer&\202; + + void + swap \201buffer&\202; + + public: + size_t)WR( + capacity \201\202 const; + + bool + capacity \201size_t\202; + + public: + size_t + size \201\202 const; + + bool + size \201size_t\202; + + public: + const char* + data \201\202 const; + + char* + data \201\202; + + const char* + begin \201\202 const; + + char* + begin \201\202; + + const char* + end \201\202 const; + + char* + end \201\202;)WR( + }; + + bool + operator== \201const buffer&, const buffer&\202; + + bool + operator!= \201const buffer&, const buffer&\202; +})RP( + + )0 P(If the )SM(assume_owner)HY(ship)YH()ES( argu)HY(ment)YH( to the construc)HY(tor)YH( + is )SM(true)ES(, the instance assumes the owner)HY(ship)YH( of the + memory block pointed to by the )SM(data)ES( argu)HY(ment)YH( and will + even)HY(tu)HY(ally)YH( release it by calling )SM(oper)HY(a)HY(tor)YH( delete\201\202)ES(. The + )SM(capac)HY(ity)YH(\201\202)ES( and )SM(size\201\202)ES( modi)HY(fier)YH( func)HY(tions)YH( + return )SM(true)ES( if the under)HY(ly)HY(ing)YH( buffer has moved. + )EP( + + )0 P(The )SM(bounds)ES( excep)HY(tion)YH( is thrown if the construc)HY(tor)YH( + argu)HY(ments)YH( violate the )SM(\201size\240<=\240capac)HY(ity)YH(\202)ES( + constraint.)EP( + + + )0 2 30 H(6.4)WB 101 Sn()WB 34 Sn( Time Zone Repre)HY(sen)HY(ta)HY(tion)YH()EA()EH( + + )0 P(The )SM(date)ES(, )SM(date)HY(Time)YH()ES(, )SM(gDay)ES(, + )SM(gMonth)ES(, )SM(gMon)HY(th)HY(Day)YH()ES(, )SM(gYear)ES(, + )SM(gYear)HY(Month)YH()ES(, and )SM(time)ES( XML Schema built-in + types all include an optional time zone compo)HY(nent)YH(. The follow)HY(ing)YH( + )SM(xml_schema::time_zone)ES( base class is used to repre)HY(sent)YH( + this infor)HY(ma)HY(tion)YH(:)EP( + + ) 33 50 PR(namespace xml_schema +{ + class time_zone + { + public: + time_zone \201\202; + time_zone \201short hours, short minutes\202; + + bool + zone_present \201\202 const; + + void + zone_reset \201\202; + + short + zone_hours \201\202 const; + + void + zone_hours \201short\202; + + short + zone_minutes \201\202 const; + + void + zone_minutes \201short\202; + }; + + bool + operator== \201const time_zone&, const time_zone&\202; + + bool)WR( + operator!= \201const time_zone&, const time_zone&\202; +})RP( + + )0 P(The )SM(zone_present\201\202)ES( acces)HY(sor)YH( func)HY(tion)YH( returns )SM(true)ES( + if the time zone is spec)HY(i)HY(fied)YH(. The )SM(zone_reset\201\202)ES( modi)HY(fier)YH( + func)HY(tion)YH( resets the time zone object to the )EM(not spec)HY(i)HY(fied)YH()ES( + state. If the time zone offset is nega)HY(tive)YH( then both hours and + minutes compo)HY(nents)YH( are repre)HY(sented)YH( as nega)HY(tive)YH( inte)HY(gers)YH(.)EP( + + + )0 2 31 H(6.5)WB 102 Sn()WB 35 Sn( )SM(date)ES( Parser)EA()EH( + + )0 P(The return type of the )SM(date_pimpl)ES( parser imple)HY(men)HY(ta)HY(tion)YH( + is )SM(xml_schema::date)ES( which repre)HY(sents)YH( a year, a day, and a month + with an optional time zone. Its inter)HY(face)YH( is presented below. + For more infor)HY(ma)HY(tion)YH( on the base )SM(xml_schema::time_zone)ES( + class refer to )0 67 1 A(Section 6.4, "Time Zone + Repre)HY(sen)HY(ta)HY(tion)YH(")67 0 TN TL()Ec /AF f D(.)EP( + + ) 34 62 PR(namespace xml_schema +{ + class date + { + public: + date \201int year, unsigned short month, unsigned short day\202; + date \201int year, unsigned short month, unsigned short day, + short zone_hours, short zone_minutes\202; + + int + year \201\202 const; + + void + year \201int\202; + + unsigned short + month \201\202 const; + + void + month \201unsigned short\202; + + unsigned short + day \201\202 const; + + void + day \201unsigned short\202; + }; + + bool + operator== \201const date&, const date&\202; +)WR( + bool + operator!= \201const date&, const date&\202; +})RP( + + )0 2 32 H(6.6)WB 103 Sn()WB 36 Sn( )SM(date)HY(Time)YH()ES( Parser)EA()EH( + + )0 P(The return type of the )SM(date_time_pimpl)ES( parser imple)HY(men)HY(ta)HY(tion)YH( + is )SM(xml_schema::date_time)ES( which repre)HY(sents)YH( a year, a month, a day, + hours, minutes, and seconds with an optional time zone. Its inter)HY(face)YH( + is presented below. + For more infor)HY(ma)HY(tion)YH( on the base )SM(xml_schema::time_zone)ES( + class refer to )0 67 1 A(Section 6.4, "Time Zone + Repre)HY(sen)HY(ta)HY(tion)YH(")67 0 TN TL()Ec /AF f D(.)EP( + + ) 56 69 PR(namespace xml_schema +{ + class date_time + { + public: + date_time \201int year, unsigned short month, unsigned short day, + unsigned short hours, unsigned short minutes, + double seconds\202; + + date_time \201int year, unsigned short month, unsigned short day, + unsigned short hours, unsigned short minutes, + double seconds, short zone_hours, short zone_minutes\202; + + int + year \201\202 const; + + void + year \201int\202; + + unsigned short + month \201\202 const; + + void + month \201unsigned short\202; + + unsigned short + day \201\202 const; + + void + day \201unsigned short\202; +)WR( + unsigned short + hours \201\202 const; + + void + hours \201unsigned short\202; + + unsigned short + minutes \201\202 const; + + void + minutes \201unsigned short\202; + + double + seconds \201\202 const; + + void + seconds \201double\202; + }; + + bool + operator== \201const date_time&, const date_time&\202; + + bool + operator!= \201const date_time&, const date_time&\202; +})RP( + + )0 2 33 H(6.7)WB 104 Sn()WB 37 Sn( )SM(dura)HY(tion)YH()ES( Parser)EA()EH( + + )0 P(The return type of the )SM(dura)HY(tion)YH(_pimpl)ES( parser imple)HY(men)HY(ta)HY(tion)YH( + is )SM(xml_schema::dura)HY(tion)YH()ES( which repre)HY(sents)YH( a poten)HY(tially)YH( + nega)HY(tive)YH( dura)HY(tion)YH( in the form of years, months, days, hours, minutes, + and seconds. Its inter)HY(face)YH( is presented below.)EP( + + ) 58 73 PR(namespace xml_schema +{ + class duration + { + public: + duration \201bool negative, + unsigned int years, unsigned int months, unsigned int days, + unsigned int hours, unsigned int minutes, double seconds\202; + + bool + negative \201\202 const; + + void + negative \201bool\202; + + unsigned int + years \201\202 const; + + void + years \201unsigned int\202; + + unsigned int + months \201\202 const; + + void + months \201unsigned int\202; + + unsigned int + days \201\202 const; + + void)WR( + days \201unsigned int\202; + + unsigned int + hours \201\202 const; + + void + hours \201unsigned int\202; + + unsigned int + minutes \201\202 const; + + void + minutes \201unsigned int\202; + + double + seconds \201\202 const; + + void + seconds \201double\202; + }; + + bool + operator== \201const duration&, const duration&\202; + + bool + operator!= \201const duration&, const duration&\202; +})RP( + + + )0 2 34 H(6.8)WB 105 Sn()WB 38 Sn( )SM(gDay)ES( Parser)EA()EH( + + )0 P(The return type of the )SM(gday_pimpl)ES( parser imple)HY(men)HY(ta)HY(tion)YH( + is )SM(xml_schema::gday)ES( which repre)HY(sents)YH( a day of the month with + an optional time zone. Its inter)HY(face)YH( is presented below. + For more infor)HY(ma)HY(tion)YH( on the base )SM(xml_schema::time_zone)ES( + class refer to )0 67 1 A(Section 6.4, "Time Zone + Repre)HY(sen)HY(ta)HY(tion)YH(")67 0 TN TL()Ec /AF f D(.)EP( + + ) 22 68 PR(namespace xml_schema +{ + class gday + { + public: + explicit + gday \201unsigned short day\202; + gday \201unsigned short day, short zone_hours, short zone_minutes\202; + + unsigned short + day \201\202 const; + + void + day \201unsigned short\202; + }; + + bool + operator== \201const gday&, const gday&\202; + + bool + operator!= \201const gday&, const gday&\202; +})RP( + + )0 2 35 H(6.9)WB 106 Sn()WB 39 Sn( )SM(gMonth)ES( Parser)EA()EH( + + )0 P(The return type of the )SM(gmonth_pimpl)ES( parser imple)HY(men)HY(ta)HY(tion)YH( + is )SM(xml_schema::gmonth)ES( which repre)HY(sents)YH( a month of the year + with an optional time zone. Its inter)HY(face)YH( is presented below. + For more infor)HY(ma)HY(tion)YH( on the base )SM(xml_schema::time_zone)ES( + class refer to )0 67 1 A(Section 6.4, "Time Zone + Repre)HY(sen)HY(ta)HY(tion)YH(")67 0 TN TL()Ec /AF f D(.)EP( + + ) 22 72 PR(namespace xml_schema +{ + class gmonth + { + public: + explicit + gmonth \201unsigned short month\202; + gmonth \201unsigned short month, short zone_hours, short zone_minutes\202; + + unsigned short + month \201\202 const; + + void + month \201unsigned short\202; + }; + + bool + operator== \201const gmonth&, const gmonth&\202; + + bool + operator!= \201const gmonth&, const gmonth&\202; +})RP( + + )0 2 36 H(6.10)WB 107 Sn()WB 40 Sn( )SM(gMon)HY(th)HY(Day)YH()ES( Parser)EA()EH( + + )0 P(The return type of the )SM(gmonth_day_pimpl)ES( parser imple)HY(men)HY(ta)HY(tion)YH( + is )SM(xml_schema::gmonth_day)ES( which repre)HY(sents)YH( a day and a month + of the year with an optional time zone. Its inter)HY(face)YH( is presented below. + For more infor)HY(ma)HY(tion)YH( on the base )SM(xml_schema::time_zone)ES( + class refer to )0 67 1 A(Section 6.4, "Time Zone + Repre)HY(sen)HY(ta)HY(tion)YH(")67 0 TN TL()Ec /AF f D(.)EP( + + ) 28 58 PR(namespace xml_schema +{ + class gmonth_day + { + public: + gmonth_day \201unsigned short month, unsigned short day\202; + gmonth_day \201unsigned short month, unsigned short day, + short zone_hours, short zone_minutes\202; + + unsigned short + month \201\202 const; + + void + month \201unsigned short\202; + + unsigned short + day \201\202 const; + + void + day \201unsigned short\202; + }; + + bool + operator== \201const gmonth_day&, const gmonth_day&\202; + + bool + operator!= \201const gmonth_day&, const gmonth_day&\202; +})RP( + + )0 2 37 H(6.11)WB 108 Sn()WB 41 Sn( )SM(gYear)ES( Parser)EA()EH( + + )0 P(The return type of the )SM(gyear_pimpl)ES( parser imple)HY(men)HY(ta)HY(tion)YH( + is )SM(xml_schema::gyear)ES( which repre)HY(sents)YH( a year with + an optional time zone. Its inter)HY(face)YH( is presented below. + For more infor)HY(ma)HY(tion)YH( on the base )SM(xml_schema::time_zone)ES( + class refer to )0 67 1 A(Section 6.4, "Time Zone + Repre)HY(sen)HY(ta)HY(tion)YH(")67 0 TN TL()Ec /AF f D(.)EP( + + ) 22 59 PR(namespace xml_schema +{ + class gyear + { + public: + explicit + gyear \201int year\202; + gyear \201int year, short zone_hours, short zone_minutes\202; + + int + year \201\202 const; + + void + year \201int\202; + }; + + bool + operator== \201const gyear&, const gyear&\202; + + bool + operator!= \201const gyear&, const gyear&\202; +})RP( + + )0 2 38 H(6.12)WB 109 Sn()WB 42 Sn( )SM(gYear)HY(Month)YH()ES( Parser)EA()EH( + + )0 P(The return type of the )SM(gyear_month_pimpl)ES( parser imple)HY(men)HY(ta)HY(tion)YH( + is )SM(xml_schema::gyear_month)ES( which repre)HY(sents)YH( a year and a month + with an optional time zone. Its inter)HY(face)YH( is presented below. + For more infor)HY(ma)HY(tion)YH( on the base )SM(xml_schema::time_zone)ES( + class refer to )0 67 1 A(Section 6.4, "Time Zone + Repre)HY(sen)HY(ta)HY(tion)YH(")67 0 TN TL()Ec /AF f D(.)EP( + + ) 28 55 PR(namespace xml_schema +{ + class gyear_month + { + public: + gyear_month \201int year, unsigned short month\202; + gyear_month \201int year, unsigned short month, + short zone_hours, short zone_minutes\202; + + int + year \201\202 const; + + void + year \201int\202; + + unsigned short + month \201\202 const; + + void + month \201unsigned short\202; + }; + + bool + operator== \201const gyear_month&, const gyear_month&\202; + + bool + operator!= \201const gyear_month&, const gyear_month&\202; +})RP( + + + )0 2 39 H(6.13)WB 110 Sn()WB 43 Sn( )SM(time)ES( Parser)EA()EH( + + )0 P(The return type of the )SM(time_pimpl)ES( parser imple)HY(men)HY(ta)HY(tion)YH( + is )SM(xml_schema::time)ES( which repre)HY(sents)YH( hours, minutes, + and seconds with an optional time zone. Its inter)HY(face)YH( is presented below. + For more infor)HY(ma)HY(tion)YH( on the base )SM(xml_schema::time_zone)ES( + class refer to )0 67 1 A(Section 6.4, "Time Zone + Repre)HY(sen)HY(ta)HY(tion)YH(")67 0 TN TL()Ec /AF f D(.)EP( + + ) 34 72 PR(namespace xml_schema +{ + class time + { + public: + time \201unsigned short hours, unsigned short minutes, double seconds\202; + time \201unsigned short hours, unsigned short minutes, double seconds, + short zone_hours, short zone_minutes\202; + + unsigned short + hours \201\202 const; + + void + hours \201unsigned short\202; + + unsigned short + minutes \201\202 const; + + void + minutes \201unsigned short\202; + + double + seconds \201\202 const; + + void + seconds \201double\202; + }; + + bool + operator== \201const time&, const time&\202; +)WR( + bool + operator!= \201const time&, const time&\202; +})RP( + + + + + + )0 1 40 H(7)WB 111 Sn()WB 44 Sn( Docu)HY(ment)YH( Parser and Error Handling)EA()EH( + + )0 P(In this chapter we will discuss the )SM(xml_schema::docu)HY(ment)YH()ES( + type as well as the error handling mech)HY(a)HY(nisms)YH( provided by the mapping + in more detail. As mentioned in )0 68 1 A(Section 3.4, + "Connect)HY(ing)YH( the Parsers Together")68 0 TN TL()Ec /AF f D(, the inter)HY(face)YH( of + )SM(xml_schema::docu)HY(ment)YH()ES( depends on the under)HY(ly)HY(ing)YH( XML + parser selected \201)0 50 1 A(Section 5.3, "Under)HY(ly)HY(ing)YH( XML + Parser")50 0 TN TL()Ec /AF f D(\202. The follow)HY(ing)YH( sections describe the + )SM(docu)HY(ment)YH()ES( type inter)HY(face)YH( for Xerces-C++ and + Expat as under)HY(ly)HY(ing)YH( parsers.)EP( + + )0 2 41 H(7.1)WB 112 Sn()WB 45 Sn( Xerces-C++ Docu)HY(ment)YH( Parser)EA()EH( + + )0 P(When Xerces-C++ is used as the under)HY(ly)HY(ing)YH( XML parser, the + )SM(docu)HY(ment)YH()ES( type has the follow)HY(ing)YH( inter)HY(face)YH(. Note that + if the char)HY(ac)HY(ter)YH( type is )SM(wchar_t)ES(, then the string type + in the inter)HY(face)YH( becomes )SM(std::wstring)ES( + \201see )0 53 1 A(Section 5.2, "Char)HY(ac)HY(ter)YH( Type and Encod)HY(ing)YH(")53 0 TN TL()Ec /AF f D(\202.)EP( + + ) 248 72 PR(namespace xml_schema +{ + class parser_base; + class error_handler; + + class flags + { + public: + // Do not validate XML documents with the Xerces-C++ validator. + // + static const unsigned long dont_validate; + + // Do not initialize the Xerces-C++ runtime. + // + static const unsigned long dont_initialize; + + // Disable handling of subsequent imports for the same namespace + // in Xerces-C++ 3.1.0 and later. + // + static const unsigned long no_multiple_imports; + }; + + class properties + { + public: + // Add a location for a schema with a target namespace. + // + void + schema_location \201const std::string& namespace_, + const std::string& location\202; +)WR( + // Add a location for a schema without a target namespace. + // + void + no_namespace_schema_location \201const std::string& location\202; + }; + + class document + { + public: + document \201parser_base& root, + const std::string& root_element_name, + bool polymorphic = false\202; + + document \201parser_base& root, + const std::string& root_element_namespace, + const std::string& root_element_name, + bool polymorphic = false\202; + + public: + // Parse URI or a local file. + // + void + parse \201const std::string& uri, + flags = 0, + const properties& = properties \201\202\202; + + // Parse URI or a local file with a user-provided error_handler + // object. + // + void)WR( + parse \201const std::string& uri, + error_handler&, + flags = 0, + const properties& = properties \201\202\202; + + // Parse URI or a local file with a user-provided ErrorHandler + // object. Note that you must initialize the Xerces-C++ runtime + // before calling this function. + // + void + parse \201const std::string& uri, + xercesc::ErrorHandler&, + flags = 0, + const properties& = properties \201\202\202; + + // Parse URI or a local file using a user-provided SAX2XMLReader + // object. Note that you must initialize the Xerces-C++ runtime + // before calling this function. + // + void + parse \201const std::string& uri, + xercesc::SAX2XMLReader&, + flags = 0, + const properties& = properties \201\202\202; + + public: + // Parse std::istream. + // + void + parse \201std::istream&,)WR( + flags = 0, + const properties& = properties \201\202\202; + + // Parse std::istream with a user-provided error_handler object. + // + void + parse \201std::istream&, + error_handler&, + flags = 0, + const properties& = properties \201\202\202; + + // Parse std::istream with a user-provided ErrorHandler object. + // Note that you must initialize the Xerces-C++ runtime before + // calling this function. + // + void + parse \201std::istream&, + xercesc::ErrorHandler&, + flags = 0, + const properties& = properties \201\202\202; + + // Parse std::istream using a user-provided SAX2XMLReader object. + // Note that you must initialize the Xerces-C++ runtime before + // calling this function. + // + void + parse \201std::istream&, + xercesc::SAX2XMLReader&, + flags = 0, + const properties& = properties \201\202\202;)WR( + + public: + // Parse std::istream with a system id. + // + void + parse \201std::istream&, + const std::string& system_id, + flags = 0, + const properties& = properties \201\202\202; + + // Parse std::istream with a system id and a user-provided + // error_handler object. + // + void + parse \201std::istream&, + const std::string& system_id, + error_handler&, + flags = 0, + const properties& = properties \201\202\202; + + // Parse std::istream with a system id and a user-provided + // ErrorHandler object. Note that you must initialize the + // Xerces-C++ runtime before calling this function. + // + void + parse \201std::istream&, + const std::string& system_id, + xercesc::ErrorHandler&, + flags = 0, + const properties& = properties \201\202\202;)WR( + + // Parse std::istream with a system id using a user-provided + // SAX2XMLReader object. Note that you must initialize the + // Xerces-C++ runtime before calling this function. + // + void + parse \201std::istream&, + const std::string& system_id, + xercesc::SAX2XMLReader&, + flags = 0, + const properties& = properties \201\202\202; + + public: + // Parse std::istream with system and public ids. + // + void + parse \201std::istream&, + const std::string& system_id, + const std::string& public_id, + flags = 0, + const properties& = properties \201\202\202; + + // Parse std::istream with system and public ids and a user-provided + // error_handler object. + // + void + parse \201std::istream&, + const std::string& system_id, + const std::string& public_id, + error_handler&,)WR( + flags = 0, + const properties& = properties \201\202\202; + + // Parse std::istream with system and public ids and a user-provided + // ErrorHandler object. Note that you must initialize the Xerces-C++ + // runtime before calling this function. + // + void + parse \201std::istream&, + const std::string& system_id, + const std::string& public_id, + xercesc::ErrorHandler&, + flags = 0, + const properties& = properties \201\202\202; + + // Parse std::istream with system and public ids using a user- + // provided SAX2XMLReader object. Note that you must initialize + // the Xerces-C++ runtime before calling this function. + // + void + parse \201std::istream&, + const std::string& system_id, + const std::string& public_id, + xercesc::SAX2XMLReader&, + flags = 0, + const properties& = properties \201\202\202; + + public: + // Parse InputSource. Note that you must initialize the Xerces-C++ + // runtime before calling this function.)WR( + // + void + parse \201const xercesc::InputSource&, + flags = 0, + const properties& = properties \201\202\202; + + // Parse InputSource with a user-provided error_handler object. + // Note that you must initialize the Xerces-C++ runtime before + // calling this function. + // + void + parse \201const xercesc::InputSource&, + error_handler&, + flags = 0, + const properties& = properties \201\202\202; + + // Parse InputSource with a user-provided ErrorHandler object. + // Note that you must initialize the Xerces-C++ runtime before + // calling this function. + // + void + parse \201const xercesc::InputSource&, + xercesc::ErrorHandler&, + flags = 0, + const properties& = properties \201\202\202; + + // Parse InputSource using a user-provided SAX2XMLReader object. + // Note that you must initialize the Xerces-C++ runtime before + // calling this function. + //)WR( + void + parse \201const xercesc::InputSource&, + xercesc::SAX2XMLReader&, + flags = 0, + const properties& = properties \201\202\202; + }; +})RP( + + )0 P(The )SM(docu)HY(ment)YH()ES( class is a root parser for + the vocab)HY(u)HY(lary)YH(. The first argu)HY(ment)YH( to its construc)HY(tors)YH( is the + parser for the type of the root element. The )SM(parser_base)ES( + class is the base type for all parser skele)HY(tons)YH(. The second and + third argu)HY(ments)YH( to the )SM(docu)HY(ment)YH()ES('s construc)HY(tors)YH( are + the root element's name and names)HY(pace)YH(. The last argu)HY(ment)YH(, + )SM(poly)HY(mor)HY(phic)YH()ES(, spec)HY(i)HY(fies)YH( whether the XML docu)HY(ments)YH( + being parsed use poly)HY(mor)HY(phism)YH(. For more infor)HY(ma)HY(tion)YH( on support + for XML Schema poly)HY(mor)HY(phism)YH( in the C++/Parser mapping refer + to )0 69 1 A(Section 5.5, "Support for Poly)HY(mor)HY(phism)YH(")69 0 TN TL()Ec /AF f D(.)EP( + + )0 P(The rest of the )SM(docu)HY(ment)YH()ES( inter)HY(face)YH( consists of over)HY(loaded)YH( + )SM(parse\201\202)ES( func)HY(tions)YH(. The last two argu)HY(ments)YH( in each of these + func)HY(tions)YH( are )SM(flags)ES( and )SM(prop)HY(er)HY(ties)YH()ES(. The + )SM(flags)ES( argu)HY(ment)YH( allows you to modify the default behav)HY(ior)YH( + of the parsing func)HY(tions)YH(. The )SM(prop)HY(er)HY(ties)YH()ES( argu)HY(ment)YH( allows + you to over)HY(ride)YH( the schema loca)HY(tion)YH( attributes spec)HY(i)HY(fied)YH( in XML + docu)HY(ments)YH(. Note that the schema loca)HY(tion)YH( paths are rela)HY(tive)YH( to an + XML docu)HY(ment)YH( unless they are complete URIs. For example if you want + to use a local schema file then you will need to use a URI in the + form )SM(file:///abso)HY(lute)YH(/path/to/your/schema)ES(.)EP( + + )0 P(A number of over)HY(loaded)YH( )SM(parse\201\202)ES( func)HY(tions)YH( have the + )SM(system_id)ES( and )SM(public_id)ES( argu)HY(ments)YH(. The + system id is a )EM(system)ES( iden)HY(ti)HY(fier)YH( of the resources being + parsed \201for example, URI or a full file path\202. The public id is a + )EM(public)ES( iden)HY(ti)HY(fier)YH( of the resource \201for example, an + appli)HY(ca)HY(tion)YH(-specific name or a rela)HY(tive)YH( file path\202. The system id + is used to resolve rela)HY(tive)YH( paths \201for example, schema paths\202. In + diag)HY(nos)HY(tics)YH( messages the public id is used if it is avail)HY(able)YH(. + Other)HY(wise)YH( the system id is used.)EP( + + )0 P(The error handling mech)HY(a)HY(nisms)YH( employed by the )SM(docu)HY(ment)YH()ES( + parser are described in )0 70 1 A(Section 7.3, "Error + Handling")70 0 TN TL()Ec /AF f D(.)EP( + + )0 2 42 H(7.2)WB 113 Sn()WB 46 Sn( Expat Docu)HY(ment)YH( Parser)EA()EH( + + )0 P(When Expat is used as the under)HY(ly)HY(ing)YH( XML parser, the + )SM(docu)HY(ment)YH()ES( type has the follow)HY(ing)YH( inter)HY(face)YH(. Note that + if the char)HY(ac)HY(ter)YH( type is )SM(wchar_t)ES(, then the string type + in the inter)HY(face)YH( becomes )SM(std::wstring)ES( + \201see )0 53 1 A(Section 5.2, "Char)HY(ac)HY(ter)YH( Type and Encod)HY(ing)YH(")53 0 TN TL()Ec /AF f D(\202.)EP( + + ) 123 72 PR(namespace xml_schema +{ + class parser_base; + class error_handler; + + class document + { + public: + document \201parser_base&, + const std::string& root_element_name, + bool polymorphic = false\202; + + document \201parser_base&, + const std::string& root_element_namespace, + const std::string& root_element_name, + bool polymorphic = false\202; + + public: + // Parse a local file. The file is accessed with std::ifstream + // in binary mode. The std::ios_base::failure exception is used + // to report io errors \201badbit and failbit\202. + void + parse \201const std::string& file\202; + + // Parse a local file with a user-provided error_handler + // object. The file is accessed with std::ifstream in binary + // mode. The std::ios_base::failure exception is used to report + // io errors \201badbit and failbit\202. + // + void + parse \201const std::string& file, error_handler&\202;)WR( + + public: + // Parse std::istream. + // + void + parse \201std::istream&\202; + + // Parse std::istream with a user-provided error_handler object. + // + void + parse \201std::istream&, error_handler&\202; + + // Parse std::istream with a system id. + // + void + parse \201std::istream&, const std::string& system_id\202; + + // Parse std::istream with a system id and a user-provided + // error_handler object. + // + void + parse \201std::istream&, + const std::string& system_id, + error_handler&\202; + + // Parse std::istream with system and public ids. + // + void + parse \201std::istream&, + const std::string& system_id,)WR( + const std::string& public_id\202; + + // Parse std::istream with system and public ids and a user-provided + // error_handler object. + // + void + parse \201std::istream&, + const std::string& system_id, + const std::string& public_id, + error_handler&\202; + + public: + // Parse a chunk of input. You can call these functions multiple + // times with the last call having the last argument true. + // + void + parse \201const void* data, std::size_t size, bool last\202; + + void + parse \201const void* data, std::size_t size, bool last, + error_handler&\202; + + void + parse \201const void* data, std::size_t size, bool last, + const std::string& system_id\202; + + void + parse \201const void* data, std::size_t size, bool last, + const std::string& system_id, + error_handler&\202;)WR( + + void + parse \201const void* data, std::size_t size, bool last, + const std::string& system_id, + const std::string& public_id\202; + + void + parse \201const void* data, std::size_t size, bool last, + const std::string& system_id, + const std::string& public_id, + error_handler&\202; + + public: + // Low-level Expat-specific parsing API. + // + void + parse_begin \201XML_Parser\202; + + void + parse_begin \201XML_Parser, const std::string& public_id\202; + + void + parse_begin \201XML_Parser, error_handler&\202; + + void + parse_begin \201XML_Parser, + const std::string& public_id, + error_handler&\202; + void + parse_end \201\202;)WR( + }; +})RP( + + )0 P(The )SM(docu)HY(ment)YH()ES( class is a root parser for + the vocab)HY(u)HY(lary)YH(. The first argu)HY(ment)YH( to its construc)HY(tors)YH( is the + parser for the type of the root element. The )SM(parser_base)ES( + class is the base type for all parser skele)HY(tons)YH(. The second and + third argu)HY(ments)YH( to the )SM(docu)HY(ment)YH()ES('s construc)HY(tors)YH( are + the root element's name and names)HY(pace)YH(. The last argu)HY(ment)YH(, + )SM(poly)HY(mor)HY(phic)YH()ES(, spec)HY(i)HY(fies)YH( whether the XML docu)HY(ments)YH( + being parsed use poly)HY(mor)HY(phism)YH(. For more infor)HY(ma)HY(tion)YH( on support + for XML Schema poly)HY(mor)HY(phism)YH( in the C++/Parser mapping refer + to )0 69 1 A(Section 5.5, "Support for Poly)HY(mor)HY(phism)YH(")69 0 TN TL()Ec /AF f D(.)EP( + + )0 P(A number of over)HY(loaded)YH( )SM(parse\201\202)ES( func)HY(tions)YH( have the + )SM(system_id)ES( and )SM(public_id)ES( argu)HY(ments)YH(. The + system id is a )EM(system)ES( iden)HY(ti)HY(fier)YH( of the resources being + parsed \201for example, URI or a full file path\202. The public id is a + )EM(public)ES( iden)HY(ti)HY(fier)YH( of the resource \201for example, an + appli)HY(ca)HY(tion)YH(-specific name or a rela)HY(tive)YH( file path\202. The system id + is used to resolve rela)HY(tive)YH( paths. In diag)HY(nos)HY(tics)YH( messages the + public id is used if it is avail)HY(able)YH(. Other)HY(wise)YH( the system id + is used.)EP( + + )0 P(The )SM(parse_begin\201\202)ES( and )SM(parse_end\201\202)ES( func)HY(tions)YH( + present a low-level, Expat-specific parsing API for maximum control. + A typical use-case would look like this \201pseudo-code\202:)EP( + + ) 20 55 PR(xxx_pimpl root_p; +document doc_p \201root_p, "root"\202; + +root_p.pre \201\202; +doc_p.parse_begin \201xml_parser, "file.xml"\202; + +while \201more_data_to_parse\202 +{ + // Call XML_Parse or XML_ParseBuffer. + + if \201status == XML_STATUS_ERROR\202 + break; +} + +// Call parse_end even in case of an error to translate +// XML and Schema errors to exceptions or error_handler +// calls. +// +doc.parse_end \201\202; +result_type result \201root_p.post_xxx \201\202\202;)RP( + + )0 P(Note that if your vocab)HY(u)HY(lary)YH( uses XML names)HY(paces)YH(, the + )SM(XML_Parser)HY(Cre)HY(at)HY(eNS)YH(\201\202)ES( func)HY(tions)YH( should be used to create + the XML parser. Space \201)SM(XML_Char \201' '\202)ES(\202 should be used + as a sepa)HY(ra)HY(tor)YH( \201the second argu)HY(ment)YH( to )SM(XML_Parser)HY(Cre)HY(at)HY(eNS)YH(\201\202)ES(\202. + )EP( + + )0 P(The error handling mech)HY(a)HY(nisms)YH( employed by the )SM(docu)HY(ment)YH()ES( + parser are described in )0 70 1 A(Section 7.3, "Error + Handling")70 0 TN TL()Ec /AF f D(.)EP( + + + )0 2 43 H(7.3)WB 114 Sn()WB 47 Sn( Error Handling)EA()EH( + + )0 P(There are three cate)HY(gories)YH( of errors that can result from running + a parser on an XML docu)HY(ment)YH(: System, XML, and Appli)HY(ca)HY(tion)YH(. + The System cate)HY(gory)YH( contains memory allo)HY(ca)HY(tion)YH( and file/stream + oper)HY(a)HY(tion)YH( errors. The XML cate)HY(gory)YH( covers XML parsing and + well-formed)HY(ness)YH( check)HY(ing)YH( as well as XML Schema vali)HY(da)HY(tion)YH( errors. + Finally, the Appli)HY(ca)HY(tion)YH( cate)HY(gory)YH( is for appli)HY(ca)HY(tion)YH( logic errors + that you may want to prop)HY(a)HY(gate)YH( from parser imple)HY(men)HY(ta)HY(tions)YH( to the + caller of the parser. + )EP( + + )0 P(The System errors are mapped to the stan)HY(dard)YH( excep)HY(tions)YH(. The + out of memory condi)HY(tion)YH( is indi)HY(cated)YH( by throw)HY(ing)YH( an instance + of )SM(std::bad_alloc)ES(. The stream oper)HY(a)HY(tion)YH( errors + are reported either by throw)HY(ing)YH( an instance of + )SM(std::ios_base::failure)ES( if excep)HY(tions)YH( are enabled + or by setting the stream state.)EP( + + )0 P(Note that if you are parsing )SM(std::istream)ES( on + which excep)HY(tions)YH( are not enabled, then you will need to + check the stream state before calling the )SM(post\201\202)ES( + call)HY(back)YH(, as shown in the follow)HY(ing)YH( example:)EP( + + ) 24 50 PR(int +main \201int argc, char* argv[]\202 +{ + ... + + std::ifstream ifs \201argv[1]\202; + + if \201ifs.fail \201\202\202 + { + cerr << argv[1] << ": unable to open" << endl; + return 1; + } + + root_p.pre \201\202; + doc_p.parse \201ifs\202; + + if \201ifs.fail \201\202\202 + { + cerr << argv[1] << ": io failure" << endl; + return 1; + } + + result_type result \201root_p.post_xxx \201\202\202; +})RP( + + )0 P(The above example can be rewrit)HY(ten)YH( to use excep)HY(tions)YH( + as shown below:)EP( + + ) 21 68 PR(int +main \201int argc, char* argv[]\202 +{ + try + { + ... + + std::ifstream ifs; + ifs.exceptions \201std::ifstream::badbit | std::ifstream::failbit\202; + ifs.open \201argv[1]\202; + + root_p.pre \201\202; + doc_p.parse \201ifs\202; + result_type result \201root_p.post_xxx \201\202\202; + } + catch \201const std::ifstream::failure&\202 + { + cerr << argv[1] << ": unable to open or io failure" << endl; + return 1; + } +})RP( + + + )0 P(For report)HY(ing)YH( appli)HY(ca)HY(tion)YH( errors from parsing call)HY(backs)YH(, you + can throw any excep)HY(tions)YH( of your choice. They are prop)HY(a)HY(gated)YH( to + the caller of the parser without any alter)HY(ations)YH(.)EP( + + )0 P(The XML errors can be reported either by throw)HY(ing)YH( the + )SM(xml_schema::parsing)ES( excep)HY(tion)YH( or by a call)HY(back)YH( + to the )SM(xml_schema::error_handler)ES( object \201and + )SM(xercesc::ErrorHan)HY(dler)YH()ES( object in case of Xerces-C++\202.)EP( + + )0 P(The )SM(xml_schema::parsing)ES( excep)HY(tion)YH( contains + a list of warn)HY(ings)YH( and errors that were accu)HY(mu)HY(lated)YH( during + parsing. Note that this excep)HY(tion)YH( is thrown only if there + was an error. This makes it impos)HY(si)HY(ble)YH( to obtain warn)HY(ings)YH( + from an other)HY(wise)YH( success)HY(ful)YH( parsing using this mech)HY(a)HY(nism)YH(. + The follow)HY(ing)YH( listing shows the defi)HY(ni)HY(tion)YH( of + )SM(xml_schema::parsing)ES( excep)HY(tion)YH(. Note that if the + char)HY(ac)HY(ter)YH( type is )SM(wchar_t)ES(, then the string type + and output stream type in the defi)HY(ni)HY(tion)YH( become + )SM(std::wstring)ES( and )SM(std::wostream)ES(, + respec)HY(tively)YH( \201see )0 53 1 A(Section 5.2, "Char)HY(ac)HY(ter)YH( Type + and Encod)HY(ing)YH(")53 0 TN TL()Ec /AF f D(\202.)EP( + + ) 82 51 PR(namespace xml_schema +{ + class exception: public std::exception + { + protected: + virtual void + print \201std::ostream&\202 const = 0; + }; + + inline std::ostream& + operator<< \201std::ostream& os, const exception& e\202 + { + e.print \201os\202; + return os; + } + + + class severity + { + public: + enum value + { + warning, + error + }; + }; + + + class error + { + public:)WR( + error \201xml_schema::severity, + const std::string& id, + unsigned long line, + unsigned long column, + const std::string& message\202; + + xml_schema::severity + severity \201\202 const; + + const std::string& + id \201\202 const; + + unsigned long + line \201\202 const; + + unsigned long + column \201\202 const; + + const std::string& + message \201\202 const; + }; + + std::ostream& + operator<< \201std::ostream&, const error&\202; + + + class diagnostics: public std::vector + { + }; +)WR( + std::ostream& + operator<< \201std::ostream&, const diagnostics&\202; + + + class parsing: public exception + { + public: + parsing \201\202; + parsing \201const xml_schema::diagnostics&\202; + + const xml_schema::diagnostics& + diagnostics \201\202 const; + + virtual const char* + what \201\202 const throw \201\202; + + protected: + virtual void + print \201std::ostream&\202 const; + }; +})RP( + + )0 P(The follow)HY(ing)YH( example shows how we can catch and print this + excep)HY(tion)YH(. The code will print diag)HY(nos)HY(tics)YH( messages one per line + in case of an error.)EP( + + ) 13 38 PR(int +main \201int argc, char* argv[]\202 +{ + try + { + // Parse. + } + catch \201const xml_schema::parsing& e\202 + { + cerr << e << endl; + return 1; + } +})RP( + + )0 P(With the )SM(error_handler)ES( approach the diag)HY(nos)HY(tics)YH( + messages are deliv)HY(ered)YH( as parsing progresses. The follow)HY(ing)YH( + listing presents the defi)HY(ni)HY(tion)YH( of the )SM(error_handler)ES( + inter)HY(face)YH(. Note that if the char)HY(ac)HY(ter)YH( type is )SM(wchar_t)ES(, + then the string type in the inter)HY(face)YH( becomes )SM(std::wstring)ES( + \201see )0 53 1 A(Section 5.2, "Char)HY(ac)HY(ter)YH( Type and Encod)HY(ing)YH(")53 0 TN TL()Ec /AF f D(\202.)EP( + + ) 24 44 PR(namespace xml_schema +{ + class error_handler + { + public: + class severity + { + public: + enum value + { + warning, + error, + fatal + }; + }; + + virtual bool + handle \201const std::string& id, + unsigned long line, + unsigned long column, + severity, + const std::string& message\202 = 0; + }; +})RP( + + )0 P(The return value of the )SM(handle\201\202)ES( func)HY(tion)YH( indi)HY(cates)YH( whether + parsing should continue if possi)HY(ble)YH(. The error with the fatal sever)HY(ity)YH( + level termi)HY(nates)YH( the parsing process regard)HY(less)YH( of the returned value. + At the end of the parsing process with an error that was reported via + the )SM(error_handler)ES( object, an empty + )SM(xml_schema::parsing)ES( excep)HY(tion)YH( is thrown to indi)HY(cate)YH( + the failure to the caller. You can alter this behav)HY(ior)YH( by throw)HY(ing)YH( + your own excep)HY(tion)YH( from the )SM(handle\201\202)ES( func)HY(tion)YH(.)EP( + + + + + + )0 1 44 H(Appendix)WB 115 Sn()WB 48 Sn( A \236 Supported XML Schema Constructs)EA()EH( + + )0 P(The C++/Parser mapping supports vali)HY(da)HY(tion)YH( of the follow)HY(ing)YH( W3C XML + Schema constructs in the gener)HY(ated)YH( code.)EP( + + + )1 PT( + + + )BR( +)BR( + +)WB NL +/TE t D NP /OU t D TU PM 1 eq and{/Pn () D showpage}if end restore diff --git a/doc/pregenerated/cxx/tree/guide/cxx-tree-guide.pdf b/doc/pregenerated/cxx/tree/guide/cxx-tree-guide.pdf new file mode 100644 index 0000000..3d011f3 Binary files /dev/null and b/doc/pregenerated/cxx/tree/guide/cxx-tree-guide.pdf differ diff --git a/doc/pregenerated/cxx/tree/guide/cxx-tree-guide.ps b/doc/pregenerated/cxx/tree/guide/cxx-tree-guide.ps new file mode 100644 index 0000000..4af12ad --- /dev/null +++ b/doc/pregenerated/cxx/tree/guide/cxx-tree-guide.ps @@ -0,0 +1,3515 @@ +%!PS +%%Title: C++/Tree Mapping Getting Started Guide +%%Creator: html2ps version 1.0 beta7 +%%EndComments +save +2000 dict begin +/d {bind def} bind def +/D {def} d +/t true D +/f false D +/FL [/Times-Roman +/Times-Italic +/Times-Bold +/Times-BoldItalic +/Courier +/Courier-Oblique +/Courier-Bold +/Courier-BoldOblique +/Helvetica +/Helvetica-Oblique +/Helvetica-Bold +/Helvetica-BoldOblique] D +/WF t D +/WI 0 D +/F 1 D +/IW 471 F div D +/IL 621 F div D +/PS 791 D +/EF [0 1 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 2 2] D +/EZ [12 10 19 17 15 13 12 11 12 12 12 12 12 12 12 12 12 12 12 12 12 12 8 8] D +/Ey [0 0 2 2 2 2 2 2 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0] D +/EG [-1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1] D +/Tm [1 1 0.8 0.8 0.8 0.8 0.8 0.8 0 0 0 0 0 0 0.5 1 1 1 1 0 0 1.3 0 0] D +/Bm [1 1 0.5 0.5 0.5 0.5 0.5 0.5 0 0 0 0 0 0 0.5 1 1 1 1 0 0 1 0 0] D +/Lm [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 2 2 0 0 2 0 0 0] D +/Rm [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0] D +/EU [-1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 0 0] D +/NO f D +/YY [[{()}{ h }][{ h }{()}][{()}{()}]] D +/ZZ [[{ (September 2023) }{ Pn }][{ Pn }{ (September 2023) }][{ Ti }{ Ti }]] D +/Ts EZ 0 get D +/TU f D +/Xp t D +/AU f D +/SN 0 D +/Cf t D +/Tp t D +/Fe f D +/TI 2 Ts mul D +/Fm 14 D +/xL 71 D +/xR 71 D +/yL 706 D +/yR 706 D +/Wl 471 F div D +/Wr 471 F div D +/hL 621 F div D +/hR 621 F div D +/FE {newpath Fm neg Fm M CP BB IW Fm add Fm L IW Fm add IL Fm add neg L CP BB + Fm neg IL Fm add neg L closepath} D +/LA {PM 0 eq{/IW Wl D /IL hL D}{/IW Wr D /IL hR D}ie /W IW D /LL W D /LS W D + TU PM 0 eq and{IW 56 F div add SA{Sf div}if 0 translate} + {PM 0 eq{xL yL}{xR yR}ie translate F SA{Sf mul}if dup scale + CS CF FS Cf{CA CL get VC}if /Bb f D}ie 0 0 M + TF not Tc or {Cf{gsave SA{1 Sf div dup scale}if Cb VC FE fill grestore}if}if}D +/Pi 0 Ts mul D +/SG [0.8 1 1] D +/Ab 15 D +/J 0 D +/Tc t D +/NH 6 D +/Nf f D +/Pa f D +/LH 1.2 D +/XR f D +/Xr {/pN E D ( [p ) WB pN WB (] )WB} D +/Db [16#FF 16#FF 16#FF] D +/Dt [16#00 16#00 16#00] D +/eA f D +/Fi f D +/bT f D +/Lc t D +/Dl [16#00 16#00 16#00] D +/LX f D +/Br 0.25 D +/IA ([IMAGE]) D +/DS {/PF f D()WB NL NP()pop RC ZF} D +/Gb f D +/Mb t D +/Hc [16#00 16#00 16#00] D +/Bl 3 D +/MI -15.6 D +/DX (DRAFT) D +/Di 0 D +/Tt 113.385826771654 D +/Th { ( +) 2 Al()BR ( + ) 0 1 -1 H()4 FZ (C++/Tree Mapping) ES()EH ( + ) 0 1 -1 H()4 FZ (Getting Started Guide) ES()EH ( + ) 0 1 -1 H ( ) EH ( + ) 0 1 -1 H ( ) EH ( + ) 0 1 -1 H ( ) EH ( + ) 0 1 -1 H ( ) EH ( + ) 0 1 -1 H ( ) EH ( + ) 0 1 -1 H ( ) EH ( +) Ea()BR ( + ) 0 P (Copyright © 2005-2023 Code Synthesis.) EP ( + + ) 0 P (Permission is granted to copy, distribute and/or modify this + document under the terms of the + ) R0 2 A (GNU Free + Documentation License, version 1.2) EA (; with no Invariant Sections, + no Front-Cover Texts and no Back-Cover Texts. + ) EP ( + + ) 0 P (This document is available in the following formats: + ) R1 2 A (XHTML) EA (, + ) R2 2 A (PDF) EA (, and + ) R3 2 A (PostScript) EA (.) EP()} D +/tH {()0 1 -1 H (Table of Contents) EH()} D +/FD 2 D +/Dy 2 D +/cD [16#F0 16#F0 16#F0] D +/FW 0.6 D +/FU [16#00 16#00 16#00] D +/ET {/RM f D /A0 3 D /PN SN D /OU t D /Ou t D /W IW D /LL W D D1 + Ms not TP and{Ip}if /TF f D} D + +%-- End of variable part -- +/MySymbol 10 dict dup begin + /FontType 3 D /FontMatrix [.001 0 0 .001 0 0 ] D /FontBBox [25 -10 600 600] D + /Encoding 256 array D 0 1 255{Encoding exch /.notdef put}for + Encoding (e) 0 get /euro put + /Metrics 2 dict D Metrics begin + /.notdef 0 D + /euro 651 D + end + /BBox 2 dict D BBox begin + /.notdef [0 0 0 0] D + /euro [25 -10 600 600] D + end + /CharacterDefs 2 dict D CharacterDefs begin + /.notdef {} D + /euro{newpath 114 600 moveto 631 600 lineto 464 200 lineto 573 200 lineto + 573 0 lineto -94 0 lineto 31 300 lineto -10 300 lineto closepath clip + 50 setlinewidth newpath 656 300 moveto 381 300 275 0 360 arc stroke + -19 350 moveto 600 0 rlineto -19 250 moveto 600 0 rlineto stroke}d + end + /BuildChar{0 begin + /char E D /fontdict E D /charname fontdict /Encoding get char get D + fontdict begin + Metrics charname get 0 BBox charname get aload pop setcachedevice + CharacterDefs charname get exec + end + end}D + /BuildChar load 0 3 dict put /UniqueID 1 D +end +definefont pop + +/Cd {aload length 2 idiv dup dict begin {D} repeat currentdict end} D +/EX {EC cvx exec} D +/DU {} d +/BB {pop pop}d +/ie {ifelse} d +/E {exch} d +/M {moveto} d +/R {rmoveto} d +/L {lineto} d +/RL {rlineto} d +/CP {currentpoint} d +/SW {stringwidth} d +/GI {getinterval} d +/PI {putinterval} d +/Sg {setgray} d +/LW {setlinewidth} d +/S {dup () ne OU and{0 Co R AT 3 eq LB and HF not and A1 0 ne A2 0 ne or and + {A2 0 32 A1 0 6 -1 roll awidthshow}{show}ie 0 Co neg R}{pop}ie + OU PH 3 eq or{/Ms t D}if} D +/U {OU{gsave CP currentfont /FontInfo get /UnderlinePosition get + 0 E currentfont /FontMatrix get dtransform E pop add newpath M dup SW pop + CJ 0 RL stroke grestore}if} D +/B {OU Br 0 gt and{CP Ts neg Ts .33 mul R gsave 0 Sg + CP newpath Ts Br mul 0 360 arc closepath UI 2 mod 0 eq{stroke}{fill}ie + grestore M CP E Ts Br 1 add mul sub E BB /Ms t D}if}D +/NP {Ms TP not or PA and OU and{TP{OR}if f1{mF k2 /mF E D /YC 0 D}if + TP TU not PM 0 eq or and{showpage}if DU Ip TE not{LA}if 0.6 LW + /CI 0 D /TP t D /Hs f D /hl 6 D /Hv 6 D /HI hi D /Ms f D}if Bs XO BO M} D +/Np {LE sub CP E pop gt PL 0 eq and{NP}if}D +/Ip {/PN PN 1 add D /Pn RM{1}{4}ie PN Ns D /PM PN SN sub 2 mod D} D +/GP {E dup 3 -1 roll get PN 1 add 2 mod get dup type /integertype eq + {get 0 get}{E pop}ie}d +/Fc {dup 2 GP exec SW pop /S1 E D dup 1 GP exec SW pop /S2 E D 0 GP exec SW + pop /S3 E D S1 0 gt{S2 2 mul S1 add S3 2 mul S1 add 2 copy lt{E}if pop}{0}ie + S2 S3 add 2 copy lt{E}if pop IW .9 mul div dup 1 gt{1 E div}{pop 1}ie}D +/OR {Df{Sd}if tp not{gsave SA{1 Sf div dup scale}if Fe{Cf{FU VC}if FW LW + 1 setlinejoin FE stroke}if /YO {60 F div dup 40 gt{pop 40}if}D /cs CS D + /cf CF D /CF 0 D /pf PF D /PF f D /Fn FN D /At AT D /AT 0 D /FN EF Hf 1 add + get D Fz Fs FS ZZ Fc Fz mul Fs FS EU Hf 1 add get dup type /arraytype eq + Cf and{VC}{pop 0 Sg}ie IW IL neg YO sub M ZZ 1 GP exec dup SW pop neg 0 R Sh + 0 IL neg YO sub M ZZ 0 GP exec Sh ZZ 2 GP exec dup SW pop IW E sub 2 div + IL neg YO sub M Sh Fz Fs FS NO{/AW IW Pn SW pop sub D AW 2 div IL neg YO sub + S1 0 gt S2 AW .45 mul gt or S3 AW .45 mul gt or{Fz 2 mul sub}if M Pn Sh}if + EU Hf get dup type /arraytype eq Cf and{VC}{pop 0 Sg}ie YY Fc /FN EF Hf get D + Hz mul HS FS IW YO M YY 1 GP exec dup SW pop neg 0 R Sh 0 YO M YY 0 GP exec Sh + YY 2 GP exec dup SW pop IW E sub 2 div YO M Sh /FN Fn D /AT At D t Pb XO SZ + SL get neg R /PF pf D grestore /CF 0 D cs cf FS}if}D +/Sh {dup () ne{CP Hz 4 div sub BB show CP CS add BB}{pop}ie}D +/Pb {/OU E D /Ou OU D /PB t D 0 0 M Ba{/Sa save D /BP t D /Fl t D RC /PL 0 D + /PH 0 D /W IW D /LE IL .7 mul D /EO 0 D SI ZF /YA 0 D /BO 0 D /C1 () D + BA 0 Ts neg R Bb{Xl Yl Xh Yh}if Bb CP Sa restore M + {/Yh E D /Xh E D /Yl E D /Xl E D}if /Fl t D}if + BL /OU t D /HM f D /Ou t D /PB f D} D +/Bs {/BP Ba not D}D +/reencodeISO { + dup dup findfont dup length dict begin{1 index /FID ne{D}{pop pop}ie}forall + /Encoding ISOLatin1Encoding D currentdict end definefont} D +/ISOLatin1Encoding [ +/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef +/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef +/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef +/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef +/space/exclam/quotedbl/numbersign/dollar/percent/ampersand/quoteright +/parenleft/parenright/asterisk/plus/comma/hyphen/period/slash +/zero/one/two/three/four/five/six/seven/eight/nine/colon/semicolon +/less/equal/greater/question/at/A/B/C/D/E/F/G/H/I/J/K/L/M/N +/O/P/Q/R/S/T/U/V/W/X/Y/Z/bracketleft/backslash/bracketright +/asciicircum/underscore/quoteleft/a/b/c/d/e/f/g/h/i/j/k/l/m +/n/o/p/q/r/s/t/u/v/w/x/y/z/braceleft/bar/braceright/asciitilde +/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef +/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef +/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef +/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef +/.notdef/space/exclamdown/cent/sterling/currency/yen/brokenbar +/section/dieresis/copyright/ordfeminine/guillemotleft/logicalnot +/hyphen/registered/macron/degree/plusminus/twosuperior/threesuperior +/acute/mu/paragraph/periodcentered/cedilla/onesuperior/ordmasculine +/guillemotright/onequarter/onehalf/threequarters/questiondown +/Agrave/Aacute/Acircumflex/Atilde/Adieresis/Aring/AE/Ccedilla +/Egrave/Eacute/Ecircumflex/Edieresis/Igrave/Iacute/Icircumflex +/Idieresis/Eth/Ntilde/Ograve/Oacute/Ocircumflex/Otilde/Odieresis +/multiply/Oslash/Ugrave/Uacute/Ucircumflex/Udieresis/Yacute +/Thorn/germandbls/agrave/aacute/acircumflex/atilde/adieresis +/aring/ae/ccedilla/egrave/eacute/ecircumflex/edieresis/igrave +/iacute/icircumflex/idieresis/eth/ntilde/ograve/oacute/ocircumflex +/otilde/odieresis/divide/oslash/ugrave/uacute/ucircumflex/udieresis +/yacute/thorn/ydieresis +] D +[128/backslash 129/parenleft 130/parenright 141/circumflex 142/tilde +143/perthousand 144/dagger 145/daggerdbl 146/Ydieresis 147/scaron 148/Scaron +149/oe 150/OE 151/guilsinglleft 152/guilsinglright 153/quotesinglbase +154/quotedblbase 155/quotedblleft 156/quotedblright 157/endash 158/emdash +159/trademark] +aload length 2 idiv 1 1 3 -1 roll{pop ISOLatin1Encoding 3 1 roll put}for +/colorimage where{pop}{ + /colorimage { + pop pop /Pr E D {/Cv Pr D /Gr Cv length 3 idiv string D 0 1 Gr length 1 sub + {Gr E dup /i E 3 mul D Cv i get 0.299 mul Cv i 1 add get 0.587 mul add + Cv i 2 add get 0.114 mul add cvi put}for Gr} image} D +}ie +/pdfmark where{pop}{userdict /pdfmark /cleartomark load put}ie +WF{FL{reencodeISO D}forall}{4 1 FL length 1 sub{FL E get reencodeISO D}for}ie +/Symbol dup dup findfont dup length dict begin + {1 index /FID ne{D}{pop pop}ie}forall /Encoding [Encoding aload pop] + dup 128 /therefore put D currentdict end definefont D + +/SF {/CS E D SZ SL CS put FO SL FN put /YI CS LH neg mul D dup ST cvs ( ) join + CS ST cvs join C1 E join ( NF ) join /C1 E D CS NF /Wf WF FN 0 gt or D + /BW Wf{( ) SW pop}{0}ie D}D +/NF {/cS E D /cF E D cF 0 ge{FL cF get}{cF -1 eq{/Symbol}{/MySymbol}ie}ie + findfont cS scalefont setfont} D +/FS {CF or /CF E D FR SL CF put CF CF 0 ge{FN 4 mul add}if E SF} D +/PC {SH /BP f D fin not GL not and{NL}if /HM t D /LL LS D} D +/BS {/TX E D Wf{/fin f D /CW 0 D /LK 0 D /SC 0 D + /RT TX D {RT ( ) search{/NW E D pop /RT E D /WH NW SW pop D CW WH add LL gt + {TX SC LK SC sub 1 sub NN GI GL{SH cF cS OC + 2 copy cS ne E cF ne or{NF}{pop pop}ie}{PC /CW WH BW add D}ie + /SC LK D} + {GL{JC}if + /CW CW WH add BW add D /HM t D}ie /GL f D /Ph f D + /LK LK NW length 1 add add D}{pop exit}ie}loop + /fin t D TX SC LK SC sub GI SH RT () ne{GL not{CC}if}if + /LC TX length D /WH RT SW pop D CW WH add Hy{HC SW pop add}if LL gt + {RT GL{SH cF cS OC 2 copy cS ne E cF ne or{NF}{pop pop}ie + Hy{/Ph t D}if /LL LS D}{NL /LL LS D SH}ie} + {RT PC Hy{CC}if /Ph Ph Hy or D}ie RT () ne{/GL t D /HM t D}if} + {TX SW pop LL le{TX SH}{/NW () D 0 2 TX length 1 sub + {/CW E D TX 0 CW GI dup SW pop LL gt{pop NW SH /HM t D NL/LL W XO sub MR sub D + /CW CW 2 sub NN D /TX TX CW TX length CW sub GI D TX BS exit} + {/NW E D}ie}for}ie}ie /HM t D}D +/CC {C0 length 0 gt{JC}if /C0 [C1 L1 YA YB Mf NS NB TB AF Bw] D + /C1 () D /L0 L1 D /YA 0 D /YB 0 D /Mf 0 D /NS 0 D /NB 0 D}D +/JC {C0 aload length 0 gt{pop pop pop NB add /NB E D NS add /NS E D + dup Mf gt{/Mf E D}{pop}ie dup YB gt{/YB E D}{pop}ie + dup YA gt{/YA E D}{pop}ie pop C1 join /C1 E D /C0 [] D}if}D +/OC {C0 length 0 gt{C1 L1 L0 sub YA YB Mf NS NB TB AF Bw GL C0 aload pop + /Bw E D /AF E D /TB E D /NB E D /NS E D /Mf E D /YB E D /YA E D /C0 [] D + /L1 E D /C1 E D Ph{HC SH}if NL /GL E D /Bw E D /AF E D /TB E D /NB E D /NS E D + /Mf E D /YB E D /YA E D /L1 E D /LL W L1 sub XO sub MR sub WH sub D /CW 0 D + C1 E join /C1 E D}if}D +/BT {/LB t D dup length string copy RS dup dup () ne E ( ) ne and + {/CI 0 D /LS LL D /LL W L1 sub XO sub MR sub D BS} + {dup ( ) eq{/GL f D}if dup () eq L1 0 eq or{pop}{SH /BP f D /Ph f D}ie}ie + /LB f D} D +/BL {CP E pop XO E M} D +/NL {JC /GL f D /SK W XO sub MR sub L1 sub TB{Bw add}if D + /YA LF{Mf HM Fl not and PF or{LH mul}if}{0 /LF t D}ie YA 2 copy lt{E}if pop D + C1 () ne{/FB YB Mf SA{Sf mul}if 4 div 2 copy lt{E}if pop D}if Fl{/Ya YA D}if + CP E pop YA sub YB sub LE neg lt Fl not and PB not and{NP}if NT TL BL + OU PF not and PB or{/RE L1 TB{Bw sub}if + W XO sub MR sub div YA YB add LE BO add div 2 copy lt{E}if pop D + RE 1 gt{BL 1 RE div dup scale}if}if + AT 2 le{SK AT mul 2 div YA neg R}if + AT 3 eq{0 YA neg R TB{/NB NB 1 sub D /NS NS 1 sub D}if /NB NB 1 sub NN D + /A3 NS 6 mul NB add D NS NB add 0 eq + {/A1 0 D /A2 0 D} + {NS 0 eq{/A1 SK NB div dup J gt{pop 0}if D /A2 0 D}{J A3 mul SK lt + {/A1 J D /A2 SK J NB mul sub NS div dup Ab gt{/A1 0 D pop 0}if D} + {/A1 SK A3 div D /A2 A1 6 mul D}ie}ie}ie /A1 A1 NN D /A2 A2 NN D}if + AT 4 eq{0 YA neg R PH 2 le{PD 0 lt{/PD L1 D}if PD M1 gt{/M1 PD D}if + L1 PD sub M2 gt{/M2 L1 PD sub D}if}{DV ID 1 sub get 0 ge{Lo 0 R}if}ie}if + F0 cF ne Cs cS ne or{F0 Cs NF}if + /ms Ms D /Ms f D CP FB sub + C1 cvx exec XO EO sub L1 add TB{BW sub}if dup LM gt{/LM E D}{pop}ie + PH 0 eq PH 4 eq or Ms and{HF not{/PO t D /AH t D}if + BB CP YA add E AT 3 eq LB and{A1 sub}if TB{BW sub}if E BB} + {pop pop}ie Ms HM PH 3 eq and or{/BP f D /Fl f D}if + /Lo 0 D /L1 0 D /F0 cF D /Cs cS D BP not{0 YB NN neg R}if + OU f1 and mF not and{k2 /f1 f D}if + OU PF not and PB or{RE 1 gt{RE dup scale}if}if /Ms ms Ms or D + /C1 AF{(Cp )}{()}ie D /YA 0 D /YB 0 D BL + AT 4 eq LB not and PH 3 ge and + {ID DV length lt{DV ID get dup 0 ge{DO E sub /Lo E D /L1 Lo D}{pop}ie + /ID ID 1 add D}if}if /T t D CD{/LN LN 1 add D PD}if + /PD -1 D /NS 0 D /NB 0 D /TB f D /Ph f D /Mf 0 D /HM f D} D +/RS {/TM E D /CN 0 D TM{10 eq{TM CN ( ) PI}if /CN CN 1 add D}forall + /CN 0 D /BK HM EN and{0}{1}ie D TM + {dup 32 ne{TM CN 3 2 roll put /CN CN 1 add D /BK 0 D} + {pop BK 0 eq{TM CN 32 put /CN CN 1 add D}if /BK 1 D}ie}forall + TM 0 CN GI dup dup () ne E ( ) ne and + {dup CN 1 sub get 32 eq{/EN f D}{/EN t D}ie}if} D +/join {2 copy length E length add string dup 4 2 roll 2 index 0 3 index + PI E length E PI}d +/WR {(\n) search{dup () ne BP not or + {Li 4 le CP E pop YI Li mul add LE add 0 lt and PL 0 eq and{NP}if + SH NL pop /Li Li 1 sub D WR}{pop pop WR}ie}{SH}ie /CI 0 D /BP f D} D +/SH {dup dup () ne E ( ) ne and PF or CS Mf gt and{/Mf CS D}if + T not Wf and{( ) E join /T t D}if dup BP{/MF CS D}if + AT 3 eq{2 copy length dup 0 gt{/NB E NB add D + {( ) search{/NS NS 1 add D pop pop}{pop exit}ie}loop}{pop pop}ie}if + CD PD 0 lt and{dup DC search{SW pop /PD E L1 add D pop pop}{pop}ie}if + 0 Np dup SW pop L1 add /L1 E D dup () ne + {C1 (\() join E join (\)) join AU AF and UF or Wf and{( U ) join}if + sF{( s ) join}if ( S ) join + /C1 E D dup length 1 sub get 32 eq /TB E D /Bw BW D}{pop pop}ie} D +/BG {AI LG BC add add 0 eq} D +/ON {OU{Ty AR AI NN get dup 1 add Ln Ns Ty 2 mod 0 eq{(. )}{(\) )}ie join + dup SW pop neg 0 R CP E 0 lt{0 E M}{pop}ie CP BB show /Ms t D}if} D +/Ln {AR AI 3 -1 roll put}D +/SP {dup CI lt BP not and{dup CI sub 0 E R /CI E D}{pop}ie} D +/BN {PF{WR /HM f D}{BT NL}ie} D +/NN {dup 0 lt{pop 0}if} D +/h {(h) HI ST cvs join cvx exec dup 1 get E Nf{0 get E join}{pop}ie} D +/H {/fn FN D /Hi E 1 add D 1 sub /HL E D /H2 HL 2 add D /GS EZ H2 get D + E Tm H2 get GS mul BE dup 0 gt{1 sub}{pop EG H2 get dup 0 lt{pop AT}if}ie NA + WW Np /SL SL 1 add D /FN EF H2 get D GS Ey H2 get FS + EU H2 get Sc Hs not HL Hl lt and Hs HL hl lt and or Hi 0 eq or + {/HI Hi D /Hs t D /hl HL D /Hv HL D}if HL Hl lt{/hi Hi D}if + Nf HI 0 gt and{(h) Hi ST cvs join cvx exec 0 get WB}if + /HF t D /AH f D /PO f D} D +/EH {Bm H2 get GS mul BE OA /SL SL 1 sub NN D /CF 0 D /FN fn D + SZ SL get FR SL get FS /HF f D /GS Ts D ()Ec} D +/P {E PF{WR}{PO{EP}{BN}ie Ts 4 mul Np AE not{Tm 0 get Ts mul neg SP}if + dup 0 ge AH and{Pi Pd}if}ie 1 sub dup 0 lt{pop AV AL get}if /AT E D /PO t D} D +/EP {PF{WR}{BN Ts 4 mul Np}ie AE not{Bm 0 get Ts mul neg SP}if + /AT AV AL get D /PO f D} D +/BE {E PO{EP}{BN}ie Ts 4 mul Np neg SP} D +/HR {/Aw W EO sub D /RW E dup 0 gt{Aw mul}{neg}ie dup Aw gt{pop Aw}if D /RZ E D + E BN Ts neg SP 1 sub 2 div Aw RW sub mul EO add CP E pop M PF{0 Ps neg R}if + 0 Np OU{gsave RZ LW Cf{Hc VC}{0 Sg}ie CP BB RW 0 RL CP BB stroke grestore}if + /CI 0 D /BP f D PF not{Ts neg SP}if /Ms t D} D +/AD {I NL EG 14 get dup 0 lt{pop AT}if NA /AE t D Tm 14 get Ts mul neg SP + Cf{EU 14 get dup -1 eq{pop CA CL get}if Sc}if} D +/DA {BN ()ES OA /AE f D ()Ec Bm 14 get Ts mul neg SP} D +/PR {/MW E D /Li E D Tm 1 get Ps mul BE 0 NA /FN Fp D /PF t D SI /SL SL 1 add D + /CF 0 D Ps CS mul Ts div MW WC mul CS mul Ts div dup LL gt PL 0 eq and + {LL div div}{pop}ie Ey 1 get FS CP E pop LE add YI neg div cvi dup Li lt + AH and{4 lt YI Li mul 5 mul LE add 0 gt or PL 0 eq and{NP}if}{pop}ie + EU 1 get Sc /GS Ps D}D +/RP {WR NL () /PF f D SI /FN 0 D ES Bm 1 get Ps mul neg SP OA /GS Ts D} D +/SI {/XO Lm 15 get BC NN mul Lm 16 get AI UI sub NN mul add + Lm 17 get UI NN mul add Lm 20 get LG NN mul add Ts mul + PF{Lm 1 get Ps mul add}if EO add D + /MR Rm 15 get BC NN mul Rm 16 get AI UI sub NN mul add + Rm 17 get UI NN mul add Rm 20 get LG NN mul add Ts mul + PF{Rm 1 get Ps mul add}if D /LL W XO sub MR sub D} D +/DT {/cC E D BN /LG LG 1 sub D SI /LG LG 1 add D WW 2 div Np BL} D +/DD {WB Cc 0 eq cC 0 eq and L1 0 eq or Lm 20 get Ts mul L1 sub TB{BW add}if + Ts 2 div lt or NL /LF E D SI BL /cC 0 D} D +/DL {Dc LG Cc put /Cc E D BG{Tm 18 get Ts mul BE}{BN}ie /LG LG 1 add D BL} D +/LD {BN LG 0 gt{/LG LG 1 sub D}if /Cc Dc LG get D SI + BG{()Bm 18 get Ts mul BE}if BL} D +/UL {BG{Tm 17 get Ts mul BE}{BN}ie NR AI NN 0 put /UI UI 1 add D + /AI AI 1 add D SI BL} D +/LU {BN /UI UI 1 sub D /AI AI 1 sub D SI BG{()Bm 17 get Ts mul BE}if BL} D +/OL {E BG{Tm 16 get Ts mul BE}{BN}ie TR AI NN Ty put /Ty E D NR AI NN 1 put + /AI AI 1 add D SI BL 1 Ln} D +/LO {BN /AI AI 1 sub D /Ty TR AI get D SI BG{()Bm 16 get Ts mul BE}if BL} D +/LI {E BN -1 SP /BP f D /CI 0 D 0 Np NR AI 1 sub NN get 1 eq + {dup dup 0 gt E 4 le and{/Ty E D}{pop}ie + /L1 L1 Ty AR AI NN get Ns SW pop XO sub dup 0 lt{pop 0}if add D ( ON )} + {pop ( B )}ie C1 E join /C1 E D CS Mf gt{/Mf CS D}if BL} D +/BQ {Tm 15 get Ts mul BE /BC BC 1 add D SI BL} D +/QB {Bm 15 get Ts mul BE /BC BC 1 sub D SI BL} D +/Al {E EP 1 sub dup 0 lt{pop AV AL get}if NA} D +/Ea {EP OA} D +/WB {PF{WR}{BT}ie} D +/F1 {WB /FN 0 D CS 0 FS} D +/F2 {WB /FN WI D CS 0 FS} D +/HY {/Hy t D WB /Hy f D} D +/YH {WB} D +/A {/LT E D LT 1 eq{/RN E D}if /Lh E D WB /C1 C1 ( Cp ) join D + Lc AF not and{Cl Sc}if /AF t D} D +/EA {Lc AF and{Ec}{WB}ie TL Pa AF and Lh 0 ne and + {( \() Lh join (\)) join /AF f D WB}if /AF f D} D +/TL {C1 ( Tl ) apa /C1 E D} d +/apa {AF OU and Lh 0 ne LT 1 eq or and{LT 1 eq{RN ( /) E ST cvs join} + {(\() Lh join (\)) join}ie E join join}{pop}ie} d +/Cp {/Xc CP /Yc E D D} D +/SS {Cf{dup 0 ge{EU E get dup -1 eq{pop CA CL get}if}{pop CA CL get}ie Sc} + {pop}ie SZ SL get /SL SL 1 add D} D +/I {WB 8 SS 1 FS} D +/EM {WB 8 SS /CF CF 1 xor D 0 FS} D +/BD {WB 9 SS 2 FS} D +/TT {WB 10 SS /FN Fp D 0 FS} D +/KB {WB 11 SS /FN Fp D 2 FS} D +/CT {WB 12 SS 1 FS} D +/SM {WB 13 SS /FN Fp D 0 FS} D +/Q {/QL QL 1 add D QO QL 2 mod get La get join WB} D +/EQ {QC QL 2 mod get La get join WB /QL QL 1 sub D} D +/RO {WB -1 SS /CF 0 D 0 FS} D +/SY {WB -1 SS -1 FS} D +/MY {WB -1 SS -2 FS} D +/ES {WB /SL SL 1 sub NN D /CF 0 D /FN FO SL get D SZ SL get FR SL get FS ()Ec}D +/FZ {3 sub 1.2 E exp GS mul E WB TL /C1 C1 ( Cp ) join D /SL SL 1 add D 0 FS} D +/Ef {WB TL ()ES /C1 C1 ( Cp ) join D} D +/BZ {dup /Bf E D FZ}D +/Sc {dup -1 ne Cf and{/CL CL 1 add D dup 0 eq{pop [0 0 0]}if + dup CA E CL E put VS ( VC ) join C1 E join /C1 E D}{pop}ie} D +/Ec {WB Cf{/CL CL 1 sub NN D CA CL get VS ( VC ) join C1 E join /C1 E D}if} D +/VS {dup type /arraytype eq{([) E {ST cvs join ( ) join}forall (]) join}if} D +/VC {{255 div}forall setrgbcolor} D +/Sl {dup type /integertype ne{Ds}if /La E D WB}d +/UN {WB /UF t D} D +/NU {WB /UF f D} D +/SE {WB /sF t D} D +/XE {WB /sF f D} D +/sM {/C1 C1 ( k1 ) join D}d +/eM {/C1 C1 ( k2 ) join D}d +/k1 {/YC CP E pop Ts add D /mF t D /f1 t D}d +/k2 {gsave 3 LW -9 CP E pop Ts 0.2 mul sub M -9 YC L stroke grestore /mF f D}d +/Ac {/AC E D WB}d +/Ca {eA{( \()join AC join(\) )join}if WB}d +/s {OU{gsave 0 CS .25 mul R dup SW pop CJ 0 RL stroke grestore}if}D +/CJ {AT 3 eq LB and{E dup dup length 1 sub A1 mul E + {( ) search{pop pop E A2 add E}{pop exit}ie}loop 3 -1 roll add + W CP pop sub 2 copy gt{E}if pop}if}D +/So {/Co E D} D +/SO {C1 Yo ST cvs join ( So ) join /C1 E D (j) SW pop 2 div Pd} D +/Se {E WB CS E div Pd}D +/Pd {dup type /stringtype eq{SW pop}if dup /L1 E L1 add D + ST cvs ( 0 R ) join C1 E join /C1 E D} D +/Sp {0.35 CO} D +/Sb {-0.2 CO} D +/CO {OV Io Yo put /Yo E CS mul Yo add D /Io Io 1 add D -1.5 Io mul 3 add FZ SO + CS Yo add dup YA gt{/YA E D}{pop}ie + Yo neg dup YB gt{/YB E D}{pop}ie} D +/Es {ES /Io Io 1 sub NN D /Yo OV Io get D SO} D +/SB {/N2 0 D 0 1 NI{/N E D{IX N2 get 0 lt{/N2 N2 1 add D}{exit}ie}loop + /K WS N get FC N get mul D /NY AY N2 get D /BV NY array D + 0 1 NY 1 sub{/TM K string D currentfile TM readhexstring pop pop BV E TM put} + for BM N BV put /N2 N2 1 add D}for} D +/IC [{/MA E D /MB 0 D}{2 div /MA E D /MB MA D}{/MB E CS sub D /MA CS D} + {pop /MA YS AB mul D /MB 1 AB sub YS mul D}{pop /MA 0 D /MB 0 D}] D +/IP {BV N get /N N 1 add D} D +/II {/K E D IX K get 0 lt{/EC E D}if /TY E D + TY 4 eq{/Y E D /X E D}if TY 3 eq{/AB E D}if + /XW AX K get D /YW AY K get D /IS SG IT K get get D /XS XW IS mul D + /YS YW IS mul D YS IC TY get exec /MA MA Fl not{3 add}if D} D +/IM {II /ty TY D /xs XS D /ys YS D /ya YA D /yb YB D /ma MA D /mb MB D /k K D + /ec EC D /BP f D /CI 0 D WB TL L1 xs add dup XO add MR add W gt + {pop /ma ma Fl{3 add}if D NL /YA ma D /YB mb D /YS ys D /L1 xs D} + {/L1 E D ma YA gt{/YA ma D}if mb YB gt{/YB mb D}if}ie /TB f D + OU{CP E pop YS sub LE neg lt Fl not and PB not and{NP /YA ma D /YB mb D}if + /BP f D ty ST cvs ( ) join IX k get 0 lt{(\() join ec join (\) ) join}if + k ST cvs join ty 3 eq{AB ST cvs ( ) join E join}if + ty 4 eq{X ST cvs ( ) join Y ST cvs join ( ) join E join}if C1 E join + ( DI ) join FP 2 eq FP 1 eq AF and or{( FM ) join}if + ( Il Cp ) apa /C1 E D /EN f D}if /HM t D /T f D} D +/DI {II /Xc CP /Yc E D D /YN YW neg D /HM t D /CI 0 D /K2 IX K get D gsave + TY 4 eq{OX X IS mul add OY FY add YS sub Y IS mul sub} + {/FY YS D CP MB sub 2 copy /OY E D /OX E D}ie + translate K2 0 ge{/DP AZ K2 get D /BV BM K2 get D XS YS scale /N 0 D XW YW DP + [XW 0 0 YN 0 YW] {IP} FC K2 get 1 eq{image}{f 3 colorimage}ie} + {EX}ie grestore XS 0 R /Ms t D} D +/FM {gsave 0 Sg CP MB sub translate XS neg 0 M 0 YS RL XS 0 RL 0 YS neg RL + XS neg 0 RL stroke grestore} D +/NA {/AT E D /AL AL 1 add D AV AL AT put} D +/OA {AL 0 gt{/AL AL 1 sub D /AT AV AL get D}if} D +/D1 {/BR {CP E pop E BN Mb{CP E pop eq{0 YI R}if}{pop}ie} D + /Sn {OU{C1 E ST cvs join ( Ld ) join /C1 E D}{pop}ie} D} D +/D1 {/BR {BN} D /Sn {OU {C1 E ST cvs join ( Ld ) join /C1 E D} {pop} ie} D} D +/TC {/TF t D /ML 0 D HN{SW pop dup ML gt{/ML E D}{pop}ie}forall NP /RM RM not D + RC /OU Tc D Ep /PN 0 D Ms not TP and{Ip}if /W IW ML sub Ts sub D + /A0 0 D TH{/BR {( ) join BT} D /Sn {pop} D /Au () D}if} D +/TN {0 eq{E EA PF HF or not XR and{HN E get Xr}{pop}ie} + {OU{Tn 0 ge{() BN}if /Tn E D}{pop}ie WB}ie} D +/NT {OU LB not and Tn 0 ge and{PL 0 eq{Ms not{CS CF FS}if CP dup + /y E YA sub D W 9 sub CS -1.8 mul XO L1 add 2 add{y M (.) show}for + HN Tn get dup SW pop IW E sub y M show CP BB M}if /Tn -1 D}if} D +/Ld {/DN E D HN DN Pn put [/View [/XYZ -4 Fl{PS}{CP YA add US E pop}ie null] + /Dest DN ST cvs cvn /DEST pdfmark} D +/C {ND 1 eq{1 sub}if TI mul /XO E D NL Nf not{pop()}if 0 3 -1 roll 1 A} D +/OP {BP not{NP}if PN 2 mod 0 eq{/Ms t D NP}if}D +/Ep {Xp PN 2 mod 0 eq and OU and{/Pn (-) D showpage /PM 1 D LA}if}D +/Dg [73 86 88 76 67 68 77] D +/Rd [0 [1 1 0][2 1 0][3 1 0][2 1 1][1 1 1][2 2 1][3 3 1][4 4 1][2 1 2]] D +/Ns {/m E D /c E 32 mul D /j m 1000 idiv D /p j 12 add string D + c 96 le m 0 gt and{c 32 le {/i 0 D /d 77 D /l 100 D /m m j 1000 mul sub D + j -1 1 {pop p i d c add put /i i 1 add D}for + 4 -2 0 {/j E D /n m l idiv D /m m n l mul sub D /d Dg j get D + n 0 gt {/x Rd n get D x 0 get -1 1 {pop p i d c add put /i i 1 add D}for + p i x 1 get sub Dg x 2 get j add get c add put}if /l l 10 idiv D + }for p 0 i GI} + {/i ST length 1 sub D m {1 sub dup 0 ge{dup 26 mod c add 1 add + ST i 3 -1 roll put 26 idiv dup 0 eq{pop exit}if}if /i i 1 sub D}loop + ST i ST length i sub GI}ie} + {m p cvs}ie} D +/US {matrix currentmatrix matrix defaultmatrix matrix invertmatrix + matrix concatmatrix transform} D +/GB {Gb{US}if}D +/Tl {/Rn E D Xc CP pop ne{ + [/Rect [Xc 1 sub Yc cS 0.25 mul sub GB CP E 1 add E cS 0.85 mul add GB] + /Subtype /Link /Border [0 0 Cf Lc and LX and AU or{0}{1}ie] Rn type + /nametype eq {/Dest Rn}{/Action [/Subtype /URI /URI Rn] Cd}ie + /ANN pdfmark}if} D +/Il {/Rn E D [/Rect [Xc Yc GB Xc XS add Yc YS add GB] /Subtype /Link + /Border [0 0 0] Rn type /nametype eq{/Dest Rn} + {/Action [/Subtype /URI /URI Rn] Cd}ie /ANN pdfmark} D +/XP {[{/Z Bz 2 div D Z 0 R Z Z RL Z neg Z RL Z neg Z neg RL Z Z neg RL + Fi cH 1 eq and{fill}if} {Bz 0 RL 0 Bz RL Bz neg 0 RL 0 Bz neg RL + Fi cH 1 eq and{fill}if} {0 -5 R Bz 0 RL 0 21 RL Bz neg 0 RL 0 -21 RL}]} D +/MS {/Sm E D WB}D +/O {BN()0 Sm BX} D +/BX {/Bt E D Bt 2 lt{/Ch E D CS 0.8 mul}{11 mul}ie W XO sub MR sub + 2 copy gt{E}if pop /HZ E D Bt 2 eq{Fi not{pop()}if ( )E join /Ft E D TT + /PF t D /MW 1 D /Li 1 D /Fw Ft SW pop D Fw HZ gt{/HZ Fw 8 add D}if + HZ ST cvs( )join}{WB Ch ST cvs( )join}ie L1 HZ add XO add MR add W gt{NL}if + Bt 2 eq{Ft ES Fw neg HM{CS sub}if Pd}if Bt ST cvs join( Bx )join + Bt 2 eq HM and{CS Pd}if C1 E join /C1 E D /L1 L1 HZ add D /T f D + ( ) Pd /PF f D Bt 2 lt{YA CS .8 mul lt{/YA CS .8 mul D}if} + {YB 5 lt{/YB 5 D}if YA 21 lt{/YA 21 D}if}ie /CI 0 D} D +/Bx {dup 2 eq{E /Bz E D}{E /cH E D /Bz CS .8 mul D}ie + OU {gsave 0 Sg XP E get exec stroke grestore}{pop}ie Bz 0 R /Ms t D}D +/SD {FD 4 mul Dy add DZ NF newpath 0 0 M DX t charpath pathbbox + 3 -1 roll sub /DY E D E dup /X1 E D sub WM mul WX DY mul add WM DG mul E div + /DF E D /DR WX DF mul DY mul WM div 2 div D} d +/Sd {gsave 0 IL Di mul neg translate IL IW atan Di 0 eq{neg}if rotate + FD 4 mul Dy add DZ NF DR X1 sub DY 2 div neg M cD VC DX show grestore} d +/Pt {/tp t D Tp{NP /Pn (TP) D 0 Tt neg R Th BN NP Ep ET RC ZF}if /tp f D} D +/RC {/AI 0 D /LG 0 D /BC 0 D /UI 0 D /PF f D /Cc 0 D /cC 0 D /Dc 10 array D + /NR [0 1 9{pop 0}for] D /La Ds D /AR 10 array D /TR 10 array D /AV 30 array D + SI /AL -1 D /AT A0 D AT NA /OV 9 array D /Yo 0 D /Co 0 D /Io 0 D /Hy f D + /Ph f D /CL -1 D Ct Sc}D +/ZF {/FR [0 1 30{pop 0}for] D /SZ [0 1 30{pop 0}for] D /FO [0 1 30{pop 0}for] D + /SL 0 D /CF 0 D /FN 0 D 0 Ts SF}D +/QO [[(\233)(\234)(\273)(\232)(\253)(\253\240)][(`)(')(\273)(\231)(\253)(\253\240)]] D +/QC [[(\234)(\234)(\253)(\233)(\273)(\240\273)][(')(')(\253)(`)(\273)(\240\273)]] D +/Hf EF length 2 sub D +/Hz EZ Hf get D +/HS Ey Hf get D +/Fz EZ Hf 1 add get D +/Fs Ey Hf 1 add get D +/LE IL D +/Ps EZ 1 get D +/Fp EF 1 get D +/XO 0 D +/YI 0 D +/CI 0 D +/FP 0 D +/WW Ts 7 mul D +/Mf 0 D +/YA 0 D +/YB 0 D +/Cs Ts D +/GS Ts D +/F0 0 D +/NS 0 D +/NB 0 D +/N 0 D +/C0 [] D +/C1 () D +/Lo 0 D +/L1 0 D +/LM 0 D +/PH 0 D +/EC 0 D +/Lh 0 D +/LT 0 D +/CH 1 string D +/ST 16 string D +/CA 9 array D +/HC (\255) D +/HM f D +/PF f D +/EN f D +/TB f D +/UF f D +/sF f D +/AE f D +/AF f D +/BP t D +/CD f D +/PA t D +/GL f D +/T t D +/HF f D +/AH f D +/SA f D +/PB f D +/f1 f D +/mF f D +/OX 0 D +/OY 0 D +/FY 0 D +/EO 0 D +/FB 0 D +/PL 0 D +/Bw 0 D +/PD -1 D +/TP f D +/tp f D +/TH t D +/Ty 4 D +/Tn -1 D +/Fl t D +/LB t D +/PM 1 D +/Ms f D +/Ba f D +/Bb f D +/Hl 3 D +/hl 6 D +/Hv 6 D +/Hs f D +/HI 0 D +/hi 0 D +/PO t D +/TE f D +/LF t D +/BO 0 D +/Sm 1 D +/Bf 3 D +/A1 0 D +/A2 0 D +/Ds 0 D +/QL -1 D +/Cb Db D +/Ct Dt D +/Cl Dl D +[/Creator (html2ps version 1.0 beta7) /Author () /Keywords (xsd, xml, schema, c++, mapping, data, binding, parsing, serialization, validation) /Subject () + /Title (C++/Tree Mapping Getting Started Guide) /DOCINFO pdfmark +/ND 1 D +/HN [(1) (1) (1) (1) (1) (1) (1) (1) (2) (3) (3) (5) (7) (7) (8) (11) (13) (15) +(16) (16) (16) (17) (17) (18) (20) (23) (24) (26) (29) (??) (32) (33) (35) +(36) (37) (38) (??) (??) (??) (??) (1) (1) (1) (1) (1) (2) (3) (3) (5) (7) +(7) (8) (11) (13) (15) (16) (16) (16) (17) (17) (18) (20) (23) (24) (26) +(29) (32) (33) (35) (36) (37) (38)] D +/h0 [()(Table of Contents)] D +/h1 [(1\240\240)(Preface)] D +/h2 [(1.1\240\240)(About This Document)] D +/h3 [(1.2\240\240)(More Information)] D +/h4 [(2\240\240)(1 Introduction)] D +/h5 [(2.1\240\240)(1.1 Mapping Overview)] D +/h6 [(2.2\240\240)(1.2 Benefits)] D +/h7 [(3\240\240)(2 Hello World Example)] D +/h8 [(3.1\240\240)(2.1 Writing XML Document and Schema)] D +/h9 [(3.2\240\240)(2.2 Translating Schema to C++)] D +/h10 [(3.3\240\240)(2.3 Implementing Application Logic)] D +/h11 [(3.4\240\240)(2.4 Compiling and Running)] D +/h12 [(3.5\240\240)(2.5 Adding Serialization)] D +/h13 [(3.6\240\240)(2.6 Selecting Naming Convention)] D +/h14 [(3.7\240\240)(2.7 Generating Documentation)] D +/h15 [(4\240\240)(3 Overall Mapping Configuration)] D +/h16 [(4.1\240\240)(3.1 C++ Standard)] D +/h17 [(4.2\240\240)(3.2 Character Type and Encoding)] D +/h18 [(4.3\240\240)(3.3 Support for Polymorphism)] D +/h19 [(4.4\240\240)(3.4 Namespace Mapping)] D +/h20 [(4.5\240\240)(3.5 Thread Safety)] D +/h21 [(5\240\240)(4 Working with Object Models)] D +/h22 [(5.1\240\240)(4.1 Attribute and Element Cardinalities)] D +/h23 [(5.2\240\240)(4.2 Accessing the Object Model)] D +/h24 [(5.3\240\240)(4.3 Modifying the Object Model)] D +/h25 [(5.4\240\240)(4.4 Creating the Object Model from Scratch)] D +/h26 [(5.5\240\240)(4.5 Mapping for the Built-in XML Schema Types)] D +/h27 [(6\240\240)(5 Parsing)] D +/h28 [(6.1\240\240)(5.1 XML Schema Validation and Searching)] D +/h29 [(6.2\240\240)(5.2 Error Handling)] D +/h30 [(7\240\240)(6 Serialization)] D +/h31 [(7.1\240\240)(6.1 Namespace and Schema Information)] D +/h32 [(7.2\240\240)(6.2 Error Handling)] D +/Hr [40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 +62 63 64 65 66 67 68 69 70 71]D +/HV [1 2 2 1 2 2 1 2 2 2 2 2 2 2 1 2 2 2 2 2 1 2 2 2 2 2 1 2 2 1 2 2]D +/Cn [2 0 0 2 0 0 7 0 0 0 0 0 0 0 5 0 0 0 0 0 5 0 0 0 0 0 2 0 0 2 0 0]D +Hr length 0 gt{[/PageMode /UseOutlines /DOCVIEW pdfmark}if +/Hn 1 D +0 1 Hr length 1 sub{ + /Bn E D [Cn Bn get dup 0 gt{/Count E HV Bn get Bl ge{neg}if}{pop}ie + /Dest Hr Bn get dup abs ST cvs cvn E 0 ge{(h)Hn ST cvs join cvx exec + dup 1 get E Nf{0 get E join}{pop}ie /Hn Hn 1 add D}{()}ie + /Title E dup length 255 gt{0 255 getinterval}if /OUT pdfmark}for +ZF /FN Fp D Ps 0 FS /WC Wf{( )}{}ie SW pop D +ET RC ZF +/Df f D +/R0 (https://www.codesynthesis.com/licenses/fdl-1.2.txt) D +/R1 (https://www.codesynthesis.com/projects/xsd/documentation/cxx/tree/guide/index.xhtml) D +/R2 (https://www.codesynthesis.com/projects/xsd/documentation/cxx/tree/guide/cxx-parser-guide.pdf) D +/R3 (https://www.codesynthesis.com/projects/xsd/documentation/cxx/tree/guide/cxx-parser-guide.ps) D +/R1 (https://www.codesynthesis.com/projects/xsd/documentation/cxx/tree/manual/) D +/R2 (http://wiki.codesynthesis.com/Tree/Customization_guide) D +/R3 (http://wiki.codesynthesis.com/Tree/FAQ) D +/R4 (https://www.codesynthesis.com/projects/xsd/documentation/xsd.xhtml) D +/R5 (https://cppget.org/xsd-examples) D +/R6 (https://www.codesynthesis.com/mailman/listinfo/xsd-users) D +/R7 (https://www.codesynthesis.com/pipermail/xsd-users/) D +/R8 (http://www.w3.org/TR/xmlschema-0/) D +/R9 (https://cppget.org/libxsd) D +/R10 (http://www.doxygen.org/) D +/R11 (https://www.codesynthesis.com/projects/xsd/documentation/cxx/tree/hello/html/annotated.html) D +/R12 (https://www.codesynthesis.com/projects/xsd/documentation/cxx/tree/manual/#2.11) D +/R13 (https://www.codesynthesis.com/projects/xsd/documentation/cxx/tree/manual/#2.8.4) D +/R14 (https://www.codesynthesis.com/projects/xsd/documentation/cxx/tree/manual/#2.8) D +/R15 (https://www.codesynthesis.com/projects/xsd/documentation/cxx/tree/manual/#2.5) D +/R16 (https://www.codesynthesis.com/projects/xsd/documentation/cxx/tree/manual/#2.9) D +/R17 (https://www.codesynthesis.com/projects/xsd/documentation/cxx/tree/manual/#3) D +/R18 (https://www.codesynthesis.com/projects/xsd/documentation/cxx/tree/manual/#3.3) D +/R19 (https://www.codesynthesis.com/projects/xsd/documentation/cxx/tree/manual/#4) D +/R20 (https://www.codesynthesis.com/projects/xsd/documentation/cxx/tree/manual/#4.4) D +/TS { + tables E get /table E D + table aload pop /rdesc E D /cdesc E D /tdesc E D + tdesc aload pop /capalg E D /caption E D /rules E D /frame E D /nfoot E D + /nhead E D /ncol E D /nrow E D /border E D /twid E D /units E D /talign E D + /flow E D /clear E D /tclass E D pop pop + /w W D /eps 0.1 D /OU f D /PL 1 D + /FN EF 21 get D EZ 21 get Ey 21 get FS + 0 1 1{ + /pass E D + 0 1 nrow{ + /irow E D + /cells rdesc irow get 6 get D + 0 1 ncol{ + /icol E D + /cell cells icol get D + cell 0 ne{ + cell aload pop /ang E D /CB E D pop pop pop + /DV E D /bot E D /top E D /right E D /left E D /nowrap E D /valign E D + /dp E D /align E D /rspan E D /cspan E D /cclass E D /ctype E D /cmax E D + /cmin E D /proc E D + rspan 0 eq{/rspan nrow irow sub 1 add D}if + cspan 0 eq{/cspan ncol icol sub 1 add D}if + pass 0 eq cspan 1 eq and pass 1 eq cspan 1 gt and or{ + /W 1e5 D /LL W D /PH 1 D + ctype 1 eq{() BD}if + RC align NA + AT 4 eq{/CD t D /DC dp D /LN 0 D /M1 0 D /M2 0 D}{/CD f D}ie + 0 0 M /LM 0 D proc exec BN + AT 4 eq{ + LN array astore cell 15 3 -1 roll put + cdesc icol get dup dup 5 get M1 lt{5 M1 put}{5 get /M1 E D}ie + dup 6 get M2 lt{6 M2 put}{6 get /M2 E D}ie + /LM M1 M2 add D + }if + /CD f D + ang 0 ne{/LM CP E pop neg D}if + /thiswid LM left add right add eps add D + /oldmin 0 D /oldmax 0 D + 0 1 cspan 1 sub{ + icol add cdesc E get dup 2 get /oldmax E oldmax add D + 1 get /oldmin E oldmin add D + }for + thiswid oldmax ge{ + 0 1 cspan 1 sub{ + icol add cdesc E get dup 2 E 2 get oldmax 0 eq + {pop thiswid cspan div}{thiswid mul oldmax div}ie + put + }for + }if + nowrap 1 eq{ + thiswid oldmin ge{ + 0 1 cspan 1 sub{ + icol add cdesc E get dup 1 E 1 get oldmin 0 eq + {pop thiswid cspan div}{thiswid mul oldmin div}ie + put + }for + }if + }{ + /W 0 D /LL W D /PH 2 D + ctype 1 eq{() ES () BD}if + 0 0 M /LM 0 D RC proc exec BN + /thiswid LM left add right add eps add D + thiswid oldmin ge{ + 0 1 cspan 1 sub{ + icol add cdesc E get dup 1 E 1 get oldmin 0 eq + {pop thiswid cspan div}{thiswid mul oldmin div}ie + put + }for + }if + }ie + ctype 1 eq{() ES}if + }if + }if + }for + }for + }for + /tmin 0 D /tmax 0 D + 0 1 ncol{ + cdesc E get dup 1 get E 2 get 2 copy gt{pop dup}if + tmax add /tmax E D tmin add /tmin E D + }for + twid 0 lt{twid neg IW gt{IW neg}{twid}ie /twid E D}if + tdesc 0 twid neg tmin 2 copy lt{E}if pop put + tdesc 1 twid neg tmax 2 copy lt{E}if pop put + /W w D /LL W D /OU t D /PH 0 D /PL 0 D +} D +/PT { + /PL PL 1 add D + tables E get /table E D Tm 21 get Ts mul BE + PL 2 ge{save}if + /SL SL 1 add D /FN EF 21 get D EZ 21 get Ey 21 get FS + table aload pop /rdesc E D /cdesc E D /tdesc E D + tdesc aload pop /capalg E D /caption E D /rules E D /frame E D /nfoot E D + /nhead E D /ncol E D /nrow E D /border E D /twid E D /units E D /talign E D + /flow E D /clear E D /tclass E D /tmax E D /tmin E D + /w W D /xo XO D /mr MR D /ll LL D /lg LG D /ai AI D /bc BC D /nr NR D /ar AR D + /tr TR D /ui UI D /ph PH D /a0 A0 D /pf PF D /at AT D /av AV D /al AL D + /Le LE D /la La D + talign 0 lt{/talign AL 0 gt{AV AL get}{A0 2 le{A0}{0}ie}ie D}if + ph 1 eq ph 2 eq or{ + NL ph 1 eq{tmax}{tmin}ie dup XO add LM gt{/LM E XO add D}{pop}ie LM E + }{ + /PH 3 D /LE 1e5 D RC %ZF + border 0 gt{/border 1 D}if + /twidth 0 D /avail W xo sub D + twid 0 eq{0 1 ncol{cdesc E get dup 2 get E 3 get dup 0 gt{div neg dup twid lt + {/twid E D}{pop}ie}{pop pop}ie}for}if + /twid twid dup 0 lt{neg avail 2 copy gt{E}if pop}{avail mul}ie D + /OK t D 0 1 ncol{cdesc E get dup 1 get E 3 get twid mul gt{/OK f D}if}for + 0 1 ncol{ + cdesc E get dup 1 get /colmin E D dup 3 get /cwid E twid mul D dup + tmax avail le{2 get}if + tmin avail le tmax avail gt and{ + dup 2 get E 1 get dup 3 1 roll sub avail tmin sub mul tmax tmin sub div add + }if + tmin avail gt{1 get}if + 0 E colmin cwid lt OK and{pop cwid}if dup /twidth E twidth add D put + }for + /OU f D CP + tmin twid le{ + 0 1 ncol{cdesc E get dup 0 get twidth div twid mul 0 E put}for + /twidth twid D + }if + CP printcap CP E pop sub /caphig E D pop + 0 1 1{ + /pass E D + 0 1 nrow{ + /irow E D + /cells rdesc irow get 6 get D + 0 1 ncol{ + /icol E D + /cell cells icol get D + cell 0 ne{ + cell aload pop /ang E D /CB E D pop pop pop + /DV E D /bot E D /top E D /right E D /left E D /nowrap E D /valign E D + /dp E D /align E D /rspan E D /cspan E D /cclass E D /ctype E D /cmax E D + /cmin E D /proc E D + rspan 0 eq{/rspan nrow irow sub 1 add D}if + cspan 0 eq{/cspan ncol icol sub 1 add D}if + /W 0 D + 0 1 cspan 1 sub{icol add cdesc E get 0 get /W E W add D}for + pass 0 eq rspan 1 eq and pass 1 eq rspan 1 gt and or{ + ctype 1 eq{() BD}if + /W W left sub right sub D /XO 0 D /EO 0 D SI + /A0 align D RC align NA + AT 4 eq{ + /DC dp D /DO 0 D /ID 1 D + 0 1 DV length 1 sub{DV E get dup DO gt{/DO E D}{pop}ie}for + /Lo DO DV 0 get sub D /L1 Lo D + }if + 0 0 M /BP t D /Fl t D /MF 0 D /FB 0 D + proc exec T not{/CI 0 D}if BN 0 FB neg R MF 0 eq{/MF CS D}if + CP /thishig E neg bot add top add CI add D pop + ang 0 ne{/thishig LM bot add top add D}if + cell 16 MF put cell 17 Ya put cell 18 thishig put + valign 4 eq{ + /below thishig Ya sub D + rdesc irow get dup dup 4 get Ya lt + {4 Ya put}{4 get /Ya E D}ie + dup 5 get below lt{5 below put}{5 get /below E D}ie + /thishig Ya below add D + }if + ctype 1 eq{()ES}if + /oldhig 0 D + 0 1 rspan 1 sub{ + irow add rdesc E get 0 get /oldhig E oldhig add D + }for + thishig oldhig ge{ + 0 1 rspan 1 sub{ + irow add rdesc E get dup 0 E 0 get oldhig 0 eq + {pop thishig rspan div}{thishig mul oldhig div}ie + put + }for + }if + }if + }if + }for + }for + }for M RC %ZF + /thight 0 D /racc 0 D /maxh 0 D /brk 0 D /rbeg nhead nfoot add D + 0 1 nrow{ + rdesc E get dup 0 get dup /thight E thight add D + brk 0 eq{/racc E D}{/racc E racc add D}ie + racc maxh gt{/maxh racc D}if 2 get /brk E D + }for + ph 3 ge{thight caphig add E}if + ph 0 eq ph 4 eq or{ + /PH 4 D /LE Le D /OU Ou D /yoff 0 D /headsz 0 D + 0 1 nhead 1 sub{rdesc E get 0 get headsz add /headsz E D}for + /footsz 0 D + 0 1 nfoot 1 sub{rdesc E nhead add get 0 get footsz add /footsz E D}for + /ahig LE BO add MI add D /maxh maxh headsz add footsz add D + /thight thight headsz add footsz add D + tmin avail gt maxh ahig gt or + {/Sf avail tmin div dup ahig maxh div gt{pop ahig maxh div}if D /SA t D} + {/Sf 1 D}ie + tclass 1 eq thight LE 15 sub gt and + {/SA t D LE 15 sub thight div dup Sf lt{/Sf E D}{pop}ie}if + SA{Sf Sf scale /ll ll Sf div D /xo xo Sf div D /LE LE Sf div D + /mr mr Sf div D /BO BO Sf div D /ahig ahig Sf div D}if + nhead nfoot add getwid + LE CP E pop add capalg 0 eq{caphig sub}if + bT{f}{dup thight lt thight ahig lt and}ie + E headsz sub footsz sub rwid lt or{NP}if + capalg 0 eq{printcap -8 SP}if + CP /ycur E D pop + printhead + rbeg 1 nrow{/row E D row + getwid + ycur yoff add rwid sub footsz sub LE add 0 lt + {nfoot 0 gt{printfoot}if Tf NP /rbeg irow1 D + Ba{MI /MI MI SA{Sf div}if D MI SP /MI E D}if + CP /ycur E D pop /yoff 0 D printhead}if + irow1 printrow + }for + printfoot /row row 1 add D Tf + 0 ycur yoff add M + capalg 1 eq{/EO 0 D SI -3 SP printcap}if + Sf 1 lt{1 Sf div dup scale /ll ll Sf mul D /xo xo Sf mul D /LE LE Sf mul D + /mr mr Sf mul D /BO BO Sf mul D /SA f D}if + /EO 0 D + }if + }ie + /W w D /XO xo D /MR mr D /LL ll D /LG lg D /AI ai D /BC bc D /NR nr D /AR ar D + /TR tr D /UI ui D /PH ph D /A0 a0 D /PF pf D /AT at D /AV av D /AL al D + /La la D + /SL SL 1 sub NN D /CF 0 D /FN 0 D SZ SL get FR SL get FS Wf not{()F2}if + PL 2 ge{Ms E restore Ms or /Ms E D PH 1 eq PH 2 eq or + {/LM E D}if PH 3 ge{/CI 0 D NL 0 E neg R}if + }if + /PL PL 1 sub D /CI 0 D /BP f D /PO f D () Bm 21 get Ts mul BE BL %CF CS SF +} D +/printcap{ + capalg 0 ge{ + SA{/W w Sf div D} + {talign 1 eq{/XO xo ll twidth sub 2 div add D}if + talign 2 eq{/XO xo ll twidth sub add D}if + /W XO twidth add D + }ie /XO xo D /LL W XO sub MR sub D + /PA f D /Fl capalg 0 eq D + 1 NA BL caption exec BN OA /PA t D + }if +} D +/getwid{ + /irow1 E D + /irow2 irow1 D + /rwid 0 D + {rdesc irow2 get dup 0 get rwid add /rwid E D 2 get 0 eq + {exit}{/irow2 irow2 1 add D}ie + }loop +} D +/printrow{ + /xoff ll twidth PL 2 ge{Sf div}if sub talign mul 2 div D + /xleft xoff xo add D + /irow E D + /cells rdesc irow get 6 get D + 0 1 ncol{ + /icol E D + /cell cells icol get D + cell 0 ne{ + cell aload pop /ang E D /CB E D /cvsize E D /above E D /fontsz E D + /DV E D /bot E D /top E D /right E D /left E D /nowrap E D /valign E D + /dp E D /align E D /rspan E D /cspan E D /cclass E D /ctype E D /cmax E D + /cmin E D /proc E D + rspan 0 eq{/rspan nrow irow sub 1 add D}if + cspan 0 eq{/cspan ncol icol sub 1 add D}if + /width 0 D + 0 1 cspan 1 sub{icol add cdesc E get 0 get /width E width add D}for + /rhight rdesc irow get 0 get D + /hight rhight D + 1 1 rspan 1 sub{irow add rdesc E get 0 get /hight E hight add D}for + /W xo xoff add width add right sub D + ang 0 ne{/W xo xoff add hight add right sub D}if + /EO xo xoff add left add D SI + Cf{ + gsave CB VC xo xoff add ycur yoff add M + 0 hight neg RL width 0 RL 0 hight RL width neg 0 RL fill + grestore + }if + ctype 1 eq{() BD}if + /A0 align D RC + AT 4 eq{ + /DC dp D /ID 1 D /DO cdesc icol get 5 get D /Lo DO DV 0 get sub D /L1 Lo D + }if + ang 0 ne{ + gsave ang 90 eq + {xoff ycur add hight cvsize sub 2 div sub ycur hight sub xoff sub} + {xoff ycur sub width add hight cvsize sub 2 div add ycur xoff add}ie + translate ang rotate + }if + valign 3 le{0 ycur yoff add top sub + hight cvsize sub valign 1 sub mul 2 div sub M} + {0 ycur yoff add top sub above add rdesc irow get 4 get sub M}ie + /PA f D /BP t D /Fl t D + BL proc exec BN + ang 0 ne{grestore}if + /PA t D + ctype 1 eq{() ES}if + }if + /xoff xoff cdesc icol get 0 get add D + }for + /yoff yoff rhight sub D +} D +/printhead {0 1 nhead 1 sub{printrow}for} D +/printfoot {nhead 1 nhead nfoot add 1 sub{printrow}for} D +/Tf { + OU{rules 2 ge{/yoff 0 D + gsave 0 Sg + [0 1 nhead 1 sub{}for rbeg 1 row 1 sub{}for nhead 1 nhead nfoot add 1 sub{}for]{ + /irow E D + /xoff ll twidth PL 2 ge{Sf div}if sub talign mul 2 div D + /cells rdesc irow get 6 get D + 0 1 ncol{ + /icol E D + /cell cells icol get D + cell 0 ne{ + /rspan cell 6 get D + /cspan cell 5 get D + rspan 0 eq{/rspan nrow irow sub 1 add D}if + cspan 0 eq{/cspan ncol icol sub 1 add D}if + /width 0 D + 0 1 cspan 1 sub{icol add cdesc E get 0 get /width E width add D}for + /rhight rdesc irow get 0 get D + /hight rhight D + 1 1 rspan 1 sub{irow add rdesc E get 0 get /hight E hight add D}for + xo xoff add width add ycur yoff add M + 0 hight neg icol cspan add 1 sub ncol lt + {cdesc icol 1 add get 4 get dup rules 3 le{1 eq}{pop t}ie + {1 eq{0.8}{0.3}ie + LW RL CP stroke M}{pop R}ie}{R}ie + irow nhead nfoot add 1 sub ne nfoot 0 eq or + {irow rspan add 1 sub nrow lt + {rdesc irow rspan add get 3 get}{nfoot 0 eq{0}{1}ie}ie + dup rules 2 mod 0 eq{1 eq}{pop t}ie + {1 eq irow rspan add nhead eq or irow rspan add row eq nfoot 0 gt and or + {0.8}{0.3}ie LW width neg 0 RL CP stroke M}{pop}ie}if + }if + /xoff xoff cdesc icol get 0 get add D + }for + /yoff yoff rhight sub D + }forall + grestore + /Ms t D + }if + frame 1 gt{ + gsave + 1 LW 0 Sg + xleft ycur M CP BB + 0 yoff frame 5 eq frame 7 ge or{RL}{R}ie + twidth 0 frame 3 eq frame 4 eq or frame 8 ge or{RL}{R}ie CP BB + 0 yoff neg frame 6 ge{RL}{R}ie + twidth neg 0 frame 2 eq frame 4 eq or frame 8 ge or{RL}{R}ie + closepath stroke + grestore + /Ms t D + }if + }if +} D +/tables [[[0 0 0 0 0 -1 0 0 1 55 2 0 0 9 5 {()} -1] + [[0 0 0 0 0 0 0][0 0 0 0 0 0 0][0 0 0 0 0 0 0]] + [[0 0 0 0 0 0 [[{()0 Sl()WB(XML Schema type)} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB(Alias in the )SM(xml_schema)ES( names)HY(pace)YH()} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB(C++ type + )} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB(fixed-length inte)HY(gral)YH( types + )} 0 0 1 0 3 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +0 +0 +]] +[0 0 0 0 0 0 [[{()0 Sl()WB()SM(byte)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(byte)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(signed\240char)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB()SM(unsigned)HY(Byte)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(unsigned_byte)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(unsigned\240char)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB()SM(short)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(short_)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(short)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB()SM(unsigned)HY(Short)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(unsigned_short)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(unsigned\240short)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB()SM(int)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(int_)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(int)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB()SM(unsignedInt)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(unsigned_int)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(unsigned\240int)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB()SM(long)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(long_)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(long\240long)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB()SM(unsigned)HY(Long)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(unsigned_long)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(unsigned\240long\240long)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB(arbi)HY(trary)YH(-length inte)HY(gral)YH( types + )} 0 0 1 0 3 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +0 +0 +]] +[0 0 0 0 0 0 [[{()0 Sl()WB()SM(integer)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(integer)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(long\240long)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB()SM(nonPos)HY(i)HY(tiveIn)HY(te)HY(ger)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(non_posi)HY(tive)YH(_integer)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(long\240long)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB()SM(nonNeg)HY(a)HY(tiveIn)HY(te)HY(ger)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(non_nega)HY(tive)YH(_integer)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(unsigned long\240long)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB()SM(posi)HY(tiveIn)HY(te)HY(ger)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(posi)HY(tive)YH(_integer)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(unsigned long\240long)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB()SM(nega)HY(tiveIn)HY(te)HY(ger)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(nega)HY(tive)YH(_integer)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(long\240long)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB(boolean types + )} 0 0 1 0 3 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +0 +0 +]] +[0 0 0 0 0 0 [[{()0 Sl()WB()SM(boolean)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(boolean)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(bool)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB(fixed-preci)HY(sion)YH( float)HY(ing)YH(-point types + )} 0 0 1 0 3 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +0 +0 +]] +[0 0 0 0 0 0 [[{()0 Sl()WB()SM(float)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(float_)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(float)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB()SM(double)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(double_)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(double)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB(arbi)HY(trary)YH(-preci)HY(sion)YH( float)HY(ing)YH(-point types + )} 0 0 1 0 3 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +0 +0 +]] +[0 0 0 0 0 0 [[{()0 Sl()WB()SM(decimal)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(decimal)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(double)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB(string types + )} 0 0 1 0 3 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +0 +0 +]] +[0 0 0 0 0 0 [[{()0 Sl()WB()SM(string)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(string)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB(type derived from )SM(std::basic_string)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB()SM(normal)HY(ized)HY(String)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(normal)HY(ized)YH(_string)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB(type derived from )SM(string)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB()SM(token)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(token)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB(type\240derived\240from\240)SM(normal)HY(ized)YH(_string)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB()SM(Name)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(name)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB(type derived from )SM(token)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB()SM(NMTOKEN)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(nmtoken)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB(type derived from )SM(token)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB()SM(NMTO)HY(KENS)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(nmto)HY(kens)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB(type derived from )SM(sequence)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB()SM(NCName)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(ncname)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB(type derived from )SM(name)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB()SM(language)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(language)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB(type derived from )SM(token)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB(qual)HY(i)HY(fied)YH( name + )} 0 0 1 0 3 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +0 +0 +]] +[0 0 0 0 0 0 [[{()0 Sl()WB()SM(QName)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(qname)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(xml_schema::qname)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB(ID/IDREF types + )} 0 0 1 0 3 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +0 +0 +]] +[0 0 0 0 0 0 [[{()0 Sl()WB()SM(ID)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(id)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB(type derived from )SM(ncname)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB()SM(IDREF)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(idref)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB(type derived from )SM(ncname)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB()SM(IDREFS)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(idrefs)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB(type derived from )SM(sequence)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB(URI types + )} 0 0 1 0 3 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +0 +0 +]] +[0 0 0 0 0 0 [[{()0 Sl()WB()SM(anyURI)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(uri)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB(type derived from )SM(std::basic_string)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB(binary types + )} 0 0 1 0 3 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +0 +0 +]] +[0 0 0 0 0 0 [[{()0 Sl()WB()SM(base64Binary)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(base64_binary)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(xml_schema::base64_binary)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB()SM(hexBi)HY(nary)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(hex_binary)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(xml_schema::hex_binary)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB(date/time types + )} 0 0 1 0 3 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +0 +0 +]] +[0 0 0 0 0 0 [[{()0 Sl()WB()SM(date)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(date)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(xml_schema::date)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB()SM(date)HY(Time)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(date_time)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(xml_schema::date_time)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB()SM(dura)HY(tion)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(dura)HY(tion)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(xml_schema::dura)HY(tion)YH()ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB()SM(gDay)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(gday)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(xml_schema::gday)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB()SM(gMonth)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(gmonth)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(xml_schema::gmonth)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB()SM(gMon)HY(th)HY(Day)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(gmonth_day)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(xml_schema::gmonth_day)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB()SM(gYear)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(gyear)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(xml_schema::gyear)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB()SM(gYear)HY(Month)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(gyear_month)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(xml_schema::gyear_month)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB()SM(time)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(time)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(xml_schema::time)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB(entity types + )} 0 0 1 0 3 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +0 +0 +]] +[0 0 0 0 0 0 [[{()0 Sl()WB()SM(ENTITY)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(entity)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB(type derived from )SM(name)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()0 Sl()WB()SM(ENTI)HY(TIES)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB()SM(enti)HY(ties)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()0 Sl()WB(type derived from )SM(sequence)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +]] +] D +0 1 0{TS}for RC ZF +/Ba f D /BO 0 D Bs +/UR (/home/boris/work/xsd/builds/gcc8-host/xsd/doc/cxx/tree/guide/index.xhtml) D +/Ti (C++/Tree Mapping Getting Started Guide) D +/Au () D +/Df f D +/ME [] D +Pt +/BO 0 D TC /Ba f D Bs /AU f D /UR () D RC ZF + tH WB +ND 1 gt{Ts 3 mul Np 0()0 C()BD(C++/Tree Mapping Getting Started Guide)ES()0 1 TN()EA()BN}if +1 NH le{40(1\240\240)1 C(Preface)WB 3 Sn()40 1 TN()EA()BN}if +2 NH le{41(1.1\240\240)2 C(About)WB 4 Sn( This Docu)HY(ment)YH()41 1 TN()EA()BN}if +2 NH le{42(1.2\240\240)2 C(More)WB 5 Sn( Infor)HY(ma)HY(tion)YH()42 1 TN()EA()BN}if +1 NH le{43(2\240\240)1 C(1)WB 6 Sn( Intro)HY(duc)HY(tion)YH()43 1 TN()EA()BN}if +2 NH le{44(2.1\240\240)2 C(1.1)WB 7 Sn( Mapping Overview)44 1 TN()EA()BN}if +2 NH le{45(2.2\240\240)2 C(1.2)WB 8 Sn( Bene)HY(fits)YH()45 1 TN()EA()BN}if +1 NH le{46(3\240\240)1 C(2)WB 9 Sn( Hello World Example)46 1 TN()EA()BN}if +2 NH le{47(3.1\240\240)2 C(2.1)WB 10 Sn( Writing XML Docu)HY(ment)YH( and Schema)47 1 TN()EA()BN}if +2 NH le{48(3.2\240\240)2 C(2.2)WB 11 Sn( Trans)HY(lat)HY(ing)YH( Schema to C++)48 1 TN()EA()BN}if +2 NH le{49(3.3\240\240)2 C(2.3)WB 12 Sn( Imple)HY(ment)HY(ing)YH( Appli)HY(ca)HY(tion)YH( Logic)49 1 TN()EA()BN}if +2 NH le{50(3.4\240\240)2 C(2.4)WB 13 Sn( Compil)HY(ing)YH( and Running)50 1 TN()EA()BN}if +2 NH le{51(3.5\240\240)2 C(2.5)WB 14 Sn( Adding Seri)HY(al)HY(iza)HY(tion)YH()51 1 TN()EA()BN}if +2 NH le{52(3.6\240\240)2 C(2.6)WB 15 Sn( Select)HY(ing)YH( Naming Conven)HY(tion)YH()52 1 TN()EA()BN}if +2 NH le{53(3.7\240\240)2 C(2.7)WB 16 Sn( Gener)HY(at)HY(ing)YH( Docu)HY(men)HY(ta)HY(tion)YH()53 1 TN()EA()BN}if +1 NH le{54(4\240\240)1 C(3)WB 17 Sn( Overall Mapping Config)HY(u)HY(ra)HY(tion)YH()54 1 TN()EA()BN}if +2 NH le{55(4.1\240\240)2 C(3.1)WB 18 Sn( C++ Stan)HY(dard)YH()55 1 TN()EA()BN}if +2 NH le{56(4.2\240\240)2 C(3.2)WB 19 Sn( Char)HY(ac)HY(ter)YH( Type and Encod)HY(ing)YH()56 1 TN()EA()BN}if +2 NH le{57(4.3\240\240)2 C(3.3)WB 20 Sn( Support for Poly)HY(mor)HY(phism)YH()57 1 TN()EA()BN}if +2 NH le{58(4.4\240\240)2 C(3.4)WB 21 Sn( Names)HY(pace)YH( Mapping)58 1 TN()EA()BN}if +2 NH le{59(4.5\240\240)2 C(3.5)WB 22 Sn( Thread Safety)59 1 TN()EA()BN}if +1 NH le{60(5\240\240)1 C(4)WB 23 Sn( Working with Object Models)60 1 TN()EA()BN}if +2 NH le{61(5.1\240\240)2 C(4.1)WB 24 Sn( Attribute and Element Cardi)HY(nal)HY(i)HY(ties)YH()61 1 TN()EA()BN}if +2 NH le{62(5.2\240\240)2 C(4.2)WB 25 Sn( Access)HY(ing)YH( the Object Model)62 1 TN()EA()BN}if +2 NH le{63(5.3\240\240)2 C(4.3)WB 26 Sn( Modi)HY(fy)HY(ing)YH( the Object Model)63 1 TN()EA()BN}if +2 NH le{64(5.4\240\240)2 C(4.4)WB 27 Sn( Creat)HY(ing)YH( the Object Model from Scratch)64 1 TN()EA()BN}if +2 NH le{65(5.5\240\240)2 C(4.5)WB 28 Sn( Mapping for the Built-in XML Schema Types)65 1 TN()EA()BN}if +1 NH le{66(6\240\240)1 C(5)WB 30 Sn( Parsing)66 1 TN()EA()BN}if +2 NH le{67(6.1\240\240)2 C(5.1)WB 31 Sn( XML Schema Vali)HY(da)HY(tion)YH( and Search)HY(ing)YH()67 1 TN()EA()BN}if +2 NH le{68(6.2\240\240)2 C(5.2)WB 32 Sn( Error Handling)68 1 TN()EA()BN}if +1 NH le{69(7\240\240)1 C(6)WB 33 Sn( Seri)HY(al)HY(iza)HY(tion)YH()69 1 TN()EA()BN}if +2 NH le{70(7.1\240\240)2 C(6.1)WB 34 Sn( Names)HY(pace)YH( and Schema Infor)HY(ma)HY(tion)YH()70 1 TN()EA()BN}if +2 NH le{71(7.2\240\240)2 C(6.2)WB 35 Sn( Error Handling)71 1 TN()EA()BN}if +/OU t D /Cb Db D NP Ep ET +/Cb Db D /Ct [16#00 16#00 16#00] D /Cl [16#00 16#00 16#00] D /CL -1 D Ct Sc + +/Ba f D /BO 0 D Bs +/UR (/home/boris/work/xsd/builds/gcc8-host/xsd/doc/cxx/tree/guide/index.xhtml) D +/Ti (C++/Tree Mapping Getting Started Guide) D +/Au () D +/Df f D +/ME [] D + +NP RC ZF +()0 Sl()WB 0 Sn( + +)BR()WB 1 Sn( )BR()WB 2 Sn( + + + )0 1 0 H(Preface)WB 40 Sn()WB 3 Sn()EA()EH( + + )0 2 1 H(About)WB 41 Sn()WB 4 Sn( This Docu)HY(ment)YH()EA()EH( + + )0 P(The goal of this docu)HY(ment)YH( is to provide you with an under)HY(stand)HY(ing)YH( of + the C++/Tree program)HY(ming)YH( model and allow you to effi)HY(ciently)YH( eval)HY(u)HY(ate)YH( + XSD against your project's tech)HY(ni)HY(cal)YH( require)HY(ments)YH(. As such, this + docu)HY(ment)YH( is intended for C++ devel)HY(op)HY(ers)YH( and soft)HY(ware)YH( archi)HY(tects)YH( + who are looking for an XML process)HY(ing)YH( solu)HY(tion)YH(. For a more in-depth + descrip)HY(tion)YH( of the C++/Tree mapping refer to the + )R1 2 A(C++/Tree + Mapping User Manual)EA(.)EP( + + )0 P(Prior expe)HY(ri)HY(ence)YH( with XML and C++ is required to under)HY(stand)YH( this + docu)HY(ment)YH(. Basic under)HY(stand)HY(ing)YH( of XML Schema is advan)HY(ta)HY(geous)YH( but + not expected or required. + )EP( + + + )0 2 2 H(More)WB 42 Sn()WB 5 Sn( Infor)HY(ma)HY(tion)YH()EA()EH( + + )0 P(Beyond this guide, you may also find the follow)HY(ing)YH( sources of + infor)HY(ma)HY(tion)YH( useful:)EP( + + )UL( )-1 LI()R1 2 A(C++/Tree + Mapping User Manual)EA( + + )-1 LI()R2 2 A(C++/Tree + Mapping Customiza)HY(tion)YH( Guide)EA( + + )-1 LI()R3 2 A(C++/Tree + Mapping Frequently Asked Ques)HY(tions)YH( \201FAQ\202)EA( + + )-1 LI()R4 2 A(XSD + Compiler Command Line Manual)EA( + + )-1 LI(The )SM(cxx/tree/)ES( direc)HY(tory)YH( in the + )R5 2 A(xsd-exam)HY(ples)YH()EA( package + contains a collec)HY(tion)YH( of exam)HY(ples)YH( and a README file with an overview + of each example. + + )-1 LI(The )SM(README)ES( file in the + )R5 2 A(xsd-exam)HY(ples)YH()EA( package + explains how to build the exam)HY(ples)YH(. + + )-1 LI(The )R6 2 A(xsd-users)EA( + mailing list is the place to ask tech)HY(ni)HY(cal)YH( ques)HY(tions)YH( about XSD and the C++/Parser mapping. + Further)HY(more)YH(, the )R7 2 A(archives)EA( + may already have answers to some of your ques)HY(tions)YH(. + )LU( + + + + )0 1 3 H(1)WB 43 Sn()WB 6 Sn( Intro)HY(duc)HY(tion)YH()EA()EH( + + )0 P(Welcome to CodeSyn)HY(the)HY(sis)YH( XSD and the C++/Tree mapping. XSD is a + cross-plat)HY(form)YH( W3C XML Schema to C++ data binding compiler. C++/Tree + is a W3C XML Schema to C++ mapping that repre)HY(sents)YH( the data stored + in XML as a stat)HY(i)HY(cally)YH(-typed, vocab)HY(u)HY(lary)YH(-specific object model. + )EP( + + )0 2 4 H(1.1)WB 44 Sn()WB 7 Sn( Mapping Overview)EA()EH( + + )0 P(Based on a formal descrip)HY(tion)YH( of an XML vocab)HY(u)HY(lary)YH( \201schema\202, the + C++/Tree mapping produces a tree-like data struc)HY(ture)YH( suit)HY(able)YH( for + in-memory process)HY(ing)YH(. The core of the mapping consists of C++ + classes that consti)HY(tute)YH( the object model and are derived from + types defined in XML Schema as well as XML parsing and + seri)HY(al)HY(iza)HY(tion)YH( code.)EP( + + )0 P(Besides the core features, C++/Tree provide a number of addi)HY(tional)YH( + mapping elements that can be useful in some appli)HY(ca)HY(tions)YH(. These + include seri)HY(al)HY(iza)HY(tion)YH( and extrac)HY(tion)YH( to/from formats others than + XML, such as unstruc)HY(tured)YH( text \201useful for debug)HY(ging)YH(\202 and binary + repre)HY(sen)HY(ta)HY(tions)YH( such as XDR and CDR for high-speed data process)HY(ing)YH( + as well as auto)HY(matic)YH( docu)HY(men)HY(ta)HY(tion)YH( gener)HY(a)HY(tion)YH(. The C++/Tree mapping + also provides a wide range of mech)HY(a)HY(nisms)YH( for control)HY(ling)YH( and + customiz)HY(ing)YH( the gener)HY(ated)YH( code.)EP( + + )0 P(A typical appli)HY(ca)HY(tion)YH( that uses C++/Tree for XML process)HY(ing)YH( usually + performs the follow)HY(ing)YH( three steps: it first reads \201parses\202 an XML + docu)HY(ment)YH( to an in-memory object model, it then performs some useful + compu)HY(ta)HY(tions)YH( on that object model which may involve modi)HY(fi)HY(ca)HY(tion)YH( + of the model, and finally it may write \201seri)HY(al)HY(ize)YH(\202 the modi)HY(fied)YH( + object model back to XML.)EP( + + )0 P(The next chapter presents a simple appli)HY(ca)HY(tion)YH( that performs these + three steps. The follow)HY(ing)YH( chap)HY(ters)YH( show how to use the C++/Tree + mapping in more detail.)EP( + + )0 2 5 H(1.2)WB 45 Sn()WB 8 Sn( Bene)HY(fits)YH()EA()EH( + + )0 P(Tradi)HY(tional)YH( XML access APIs such as Docu)HY(ment)YH( Object Model \201DOM\202 + or Simple API for XML \201SAX\202 have a number of draw)HY(backs)YH( that + make them less suit)HY(able)YH( for creat)HY(ing)YH( robust and main)HY(tain)HY(able)YH( + XML process)HY(ing)YH( appli)HY(ca)HY(tions)YH(. These draw)HY(backs)YH( include: + )EP( + + )UL( )-1 LI(Generic repre)HY(sen)HY(ta)HY(tion)YH( of XML in terms of elements, attributes, + and text forces an appli)HY(ca)HY(tion)YH( devel)HY(oper)YH( to write a substan)HY(tial)YH( + amount of bridg)HY(ing)YH( code that iden)HY(ti)HY(fies)YH( and trans)HY(forms)YH( pieces + of infor)HY(ma)HY(tion)YH( encoded in XML to a repre)HY(sen)HY(ta)HY(tion)YH( more suit)HY(able)YH( + for consump)HY(tion)YH( by the appli)HY(ca)HY(tion)YH( logic. + + )-1 LI(String-based flow control defers error detec)HY(tion)YH( to runtime. + It also reduces code read)HY(abil)HY(ity)YH( and main)HY(tain)HY(abil)HY(ity)YH(. + + )-1 LI(Lack of type safety because the data is repre)HY(sented)YH( as text. + + )-1 LI(Result)HY(ing)YH( appli)HY(ca)HY(tions)YH( are hard to debug, change, and + main)HY(tain)YH(. + )LU( + + )0 P(In contrast, stat)HY(i)HY(cally)YH(-typed, vocab)HY(u)HY(lary)YH(-specific object model + produced by the C++/Tree mapping allows you to operate in your + domain terms instead of the generic elements, attributes, and + text. Static typing helps catch errors at compile-time rather + than at run-time. Auto)HY(matic)YH( code gener)HY(a)HY(tion)YH( frees you for more + inter)HY(est)HY(ing)YH( tasks \201such as doing some)HY(thing)YH( useful with the + infor)HY(ma)HY(tion)YH( stored in the XML docu)HY(ments)YH(\202 and mini)HY(mizes)YH( the + effort needed to adapt your appli)HY(ca)HY(tions)YH( to changes in the + docu)HY(ment)YH( struc)HY(ture)YH(. To summa)HY(rize)YH(, the C++/Tree object model has + the follow)HY(ing)YH( key advan)HY(tages)YH( over generic XML access APIs:)EP( + + )UL( )-1 LI()BD(Ease of use.)ES( The gener)HY(ated)YH( code hides all the complex)HY(ity)YH( + asso)HY(ci)HY(ated)YH( with parsing and seri)HY(al)HY(iz)HY(ing)YH( XML. This includes navi)HY(gat)HY(ing)YH( + the struc)HY(ture)YH( and convert)HY(ing)YH( between the text repre)HY(sen)HY(ta)HY(tion)YH( and + data types suit)HY(able)YH( for manip)HY(u)HY(la)HY(tion)YH( by the appli)HY(ca)HY(tion)YH( + logic. + + )-1 LI()BD(Natural repre)HY(sen)HY(ta)HY(tion)YH(.)ES( The object repre)HY(sen)HY(ta)HY(tion)YH( allows + you to access the XML data using your domain vocab)HY(u)HY(lary)YH( instead + of generic elements, attributes, and text. + + )-1 LI()BD(Concise code.)ES( With the object repre)HY(sen)HY(ta)HY(tion)YH( the + appli)HY(ca)HY(tion)YH( imple)HY(men)HY(ta)HY(tion)YH( is simpler and thus easier + to read and under)HY(stand)YH(. + + )-1 LI()BD(Safety.)ES( The gener)HY(ated)YH( object model is stat)HY(i)HY(cally)YH( + typed and uses func)HY(tions)YH( instead of strings to access the + infor)HY(ma)HY(tion)YH(. This helps catch program)HY(ming)YH( errors at compile-time + rather than at runtime. + + )-1 LI()BD(Main)HY(tain)HY(abil)HY(ity)YH(.)ES( Auto)HY(matic)YH( code gener)HY(a)HY(tion)YH( mini)HY(mizes)YH( the + effort needed to adapt the appli)HY(ca)HY(tion)YH( to changes in the + docu)HY(ment)YH( struc)HY(ture)YH(. With static typing, the C++ compiler + can pin-point the places in the client code that need to be + changed. + + )-1 LI()BD(Compat)HY(i)HY(bil)HY(ity)YH(.)ES( Sequences of elements are repre)HY(sented)YH( in + the object model as contain)HY(ers)YH( conform)HY(ing)YH( to the stan)HY(dard)YH( C++ + sequence require)HY(ments)YH(. This makes it possi)HY(ble)YH( to use stan)HY(dard)YH( + C++ algo)HY(rithms)YH( on the object repre)HY(sen)HY(ta)HY(tion)YH( and frees you from + learn)HY(ing)YH( yet another container inter)HY(face)YH(, as is the case with + DOM. + + )-1 LI()BD(Effi)HY(ciency)YH(.)ES( If the appli)HY(ca)HY(tion)YH( makes repet)HY(i)HY(tive)YH( use + of the data extracted from XML, then the C++/Tree object model + is more effi)HY(cient)YH( because the navi)HY(ga)HY(tion)YH( is performed using + func)HY(tion)YH( calls rather than string compar)HY(isons)YH( and the XML + data is extracted only once. Further)HY(more)YH(, the runtime memory + usage is reduced due to more effi)HY(cient)YH( data storage + \201for instance, storing numeric data as inte)HY(gers)YH( instead of + strings\202 as well as the static knowl)HY(edge)YH( of cardi)HY(nal)HY(ity)YH( + constraints. + )LU( + + + + + + )0 1 6 H(2)WB 46 Sn()WB 9 Sn( Hello World Example)EA()EH( + + )0 P(In this chapter we will examine how to parse, access, modify, and + seri)HY(al)HY(ize)YH( a very simple XML docu)HY(ment)YH( using the XSD-gener)HY(ated)YH( + C++/Tree object model. The code presented in this chapter is + based on the )SM(hello)ES( example which can be found in + the )SM(cxx/tree/)ES( direc)HY(tory)YH( in the + )R5 2 A(xsd-exam)HY(ples)YH()EA( package.)EP( + + )0 2 7 H(2.1)WB 47 Sn()WB 10 Sn( Writing XML Docu)HY(ment)YH( and Schema)EA()EH( + + )0 P(First, we need to get an idea about the struc)HY(ture)YH( + of the XML docu)HY(ments)YH( we are going to process. Our + )SM(hello.xml)ES(, for example, could look like this:)EP( + + ) 10 28 PR( + + + Hello + + sun + moon + world + +)RP( + + )0 P(Then we can write a descrip)HY(tion)YH( of the above XML in the + XML Schema language and save it into )SM(hello.xsd)ES(:)EP( + + ) 13 70 PR( + + + + + + + + + + + +)RP( + + )0 P(Even if you are not famil)HY(iar)YH( with XML Schema, it + should be easy to connect decla)HY(ra)HY(tions)YH( in )SM(hello.xsd)ES( + to elements in )SM(hello.xml)ES(. The )SM(hello_t)ES( type + is defined as a sequence of the nested )SM(greet)HY(ing)YH()ES( and + )SM(name)ES( elements. Note that the term sequence in XML + Schema means that elements should appear in a partic)HY(u)HY(lar)YH( order + as opposed to appear)HY(ing)YH( multi)HY(ple)YH( times. The )SM(name)ES( + element has its )SM(maxOc)HY(curs)YH()ES( prop)HY(erty)YH( set to + )SM(unbounded)ES( which means it can appear multi)HY(ple)YH( times + in an XML docu)HY(ment)YH(. Finally, the glob)HY(ally)YH(-defined )SM(hello)ES( + element prescribes the root element for our vocab)HY(u)HY(lary)YH(. For an + easily-approach)HY(able)YH( intro)HY(duc)HY(tion)YH( to XML Schema refer to + )R8 2 A(XML Schema Part 0: + Primer)EA(.)EP( + + )0 P(The above schema is a spec)HY(i)HY(fi)HY(ca)HY(tion)YH( of our XML vocab)HY(u)HY(lary)YH(; it tells + every)HY(body)YH( what valid docu)HY(ments)YH( of our XML-based language should look + like. We can also update our )SM(hello.xml)ES( to include the + infor)HY(ma)HY(tion)YH( about the schema so that XML parsers can vali)HY(date)YH( + our docu)HY(ment)YH(:)EP( + + ) 11 60 PR( + + + Hello + + sun + moon + world + +)RP( + + + )0 P(The next step is to compile the schema to gener)HY(ate)YH( the object + model and parsing func)HY(tions)YH(.)EP( + + )0 2 8 H(2.2)WB 48 Sn()WB 11 Sn( Trans)HY(lat)HY(ing)YH( Schema to C++)EA()EH( + + )0 P(Now we are ready to trans)HY(late)YH( our )SM(hello.xsd)ES( to C++. + To do this we invoke the XSD compiler from a termi)HY(nal)YH( \201UNIX\202 or + a command prompt \201Windows\202: + )EP( + + ) 1 24 PR($ xsd cxx-tree hello.xsd)RP( + + )0 P(The XSD compiler produces two C++ files: )SM(hello.hxx)ES( and + )SM(hello.cxx)ES(. The follow)HY(ing)YH( code frag)HY(ment)YH( is taken from + )SM(hello.hxx)ES(; it should give you an idea about what gets + gener)HY(ated)YH(: + )EP( + + ) 45 60 PR(class hello_t +{ +public: + // greeting + // + typedef xml_schema::string greeting_type; + + const greeting_type& + greeting \201\202 const; + + greeting_type& + greeting \201\202; + + void + greeting \201const greeting_type& x\202; + + // name + // + typedef xml_schema::string name_type; + typedef xsd::sequence name_sequence; + typedef name_sequence::iterator name_iterator; + typedef name_sequence::const_iterator name_const_iterator; + + const name_sequence& + name \201\202 const; + + name_sequence& + name \201\202; + + void + name \201const name_sequence& s\202;)WR( + + // Constructor. + // + hello_t \201const greeting_type&\202; + + ... + +}; + +std::unique_ptr +hello \201const std::string& uri\202; + +std::unique_ptr +hello \201std::istream&\202;)RP( + + )0 P(The )SM(hello_t)ES( C++ class corre)HY(sponds)YH( to the + )SM(hello_t)ES( XML Schema type. For each element + in this type a set of C++ type defi)HY(ni)HY(tions)YH( as well as + acces)HY(sor)YH( and modi)HY(fier)YH( func)HY(tions)YH( are gener)HY(ated)YH( inside the + )SM(hello_t)ES( class. Note that the type defi)HY(ni)HY(tions)YH( + and member func)HY(tions)YH( for the )SM(greet)HY(ing)YH()ES( and + )SM(name)ES( elements are differ)HY(ent)YH( because of the + cardi)HY(nal)HY(ity)YH( differ)HY(ences)YH( between these two elements + \201)SM(greet)HY(ing)YH()ES( is a required single element and + )SM(name)ES( is a sequence of elements\202.)EP( + + )0 P(The )SM(xml_schema::string)ES( type used in the type + defi)HY(ni)HY(tions)YH( is a C++ class provided by the XSD runtime + that corre)HY(sponds)YH( to built-in XML Schema type + )SM(string)ES(. The )SM(xml_schema::string)ES( + is based on )SM(std::string)ES( and can be used as + such. Simi)HY(larly)YH(, the )SM(sequence)ES( class template + that is used in the )SM(name_sequence)ES( type + defi)HY(ni)HY(tion)YH( is based on and has the same inter)HY(face)YH( as + )SM(std::vector)ES(. The mapping between the built-in + XML Schema types and C++ types is described in more detail in + )0 36 1 A(Section 4.5, "Mapping for the Built-in XML Schema + Types")36 0 TN TL()Ec /AF f D(. The )SM(hello_t)ES( class also includes a + construc)HY(tor)YH( with an initial)HY(izer)YH( for the required + )SM(greet)HY(ing)YH()ES( element as its argu)HY(ment)YH(.)EP( + + )0 P(The )SM(hello)ES( over)HY(loaded)YH( global func)HY(tions)YH( corre)HY(spond)YH( + to the )SM(hello)ES( global element in XML Schema. A + global element in XML Schema is a valid docu)HY(ment)YH( root. + By default XSD gener)HY(ated)YH( a set of parsing func)HY(tions)YH( for each + global element defined in XML Schema \201this can be over)HY(rid)HY(den)YH( + with the )SM(--root-element-*)ES( options\202. Parsing + func)HY(tions)YH( return a dynam)HY(i)HY(cally)YH( allo)HY(cated)YH( object model as an + auto)HY(matic)YH( pointer. The actual pointer used depends on the + C++ stan)HY(dard)YH( selected. For C++11 it is )SM(std::unique_ptr)ES( + as shown above. For C++98 it is )SM(std::auto_ptr)ES(. + For example, if we modify our XSD compiler invo)HY(ca)HY(tion)YH( to + select C++98:)EP( + + ) 1 36 PR($ xsd cxx-tree --std c++98 hello.xsd)RP( + + )0 P(Then the parsing func)HY(tion)YH( signa)HY(tures)YH( will become:)EP( + + ) 5 31 PR(std::auto_ptr +hello \201const std::string& uri\202; + +std::auto_ptr +hello \201std::istream&\202;)RP( + + )0 P(For more infor)HY(ma)HY(tion)YH( on parsing func)HY(tions)YH( see )0 37 1 A(Chapter 5, + "Parsing")37 0 TN TL()Ec /AF f D(.)EP( + + )0 2 9 H(2.3)WB 49 Sn()WB 12 Sn( Imple)HY(ment)HY(ing)YH( Appli)HY(ca)HY(tion)YH( Logic)EA()EH( + + )0 P(At this point we have all the parts we need to do some)HY(thing)YH( useful + with the infor)HY(ma)HY(tion)YH( stored in our XML docu)HY(ment)YH(: + )EP( + + ) 25 62 PR(#include +#include "hello.hxx" + +using namespace std; + +int +main \201int argc, char* argv[]\202 +{ + try + { + unique_ptr h \201hello \201argv[1]\202\202; + + for \201hello_t::name_const_iterator i \201h->name \201\202.begin \201\202\202; + i != h->name \201\202.end \201\202; + ++i\202 + { + cerr << h->greeting \201\202 << ", " << *i << "!" << endl; + } + } + catch \201const xml_schema::exception& e\202 + { + cerr << e << endl; + return 1; + } +})RP( + + )0 P(The first part of our appli)HY(ca)HY(tion)YH( calls one of the parsing + func)HY(tions)YH( to parser an XML file spec)HY(i)HY(fied)YH( in the command line. + We then use the returned object model to iterate over names + and print a greet)HY(ing)YH( line for each of them. Finally, we + catch and print the )SM(xml_schema::excep)HY(tion)YH()ES( + excep)HY(tion)YH( in case some)HY(thing)YH( goes wrong. This excep)HY(tion)YH( + is the root of the excep)HY(tion)YH( hier)HY(ar)HY(chy)YH( used by the + XSD-gener)HY(ated)YH( code. + )EP( + + + )0 2 10 H(2.4)WB 50 Sn()WB 13 Sn( Compil)HY(ing)YH( and Running)EA()EH( + + )0 P(After saving our appli)HY(ca)HY(tion)YH( from the previ)HY(ous)YH( section in + )SM(driver.cxx)ES(, we are ready to compile our first + program and run it on the test XML docu)HY(ment)YH(. On a UNIX + system this can be done with the follow)HY(ing)YH( commands: + )EP( + + ) 6 54 PR($ c++ -std=c++11 -I.../libxsd -c driver.cxx hello.cxx +$ c++ -std=c++11 -o driver driver.o hello.o -lxerces-c +$ ./driver hello.xml +Hello, sun! +Hello, moon! +Hello, world!)RP( + + )0 P(Here )SM(.../libxsd)ES( repre)HY(sents)YH( the path to the + )R9 2 A(libxsd)EA( package root + direc)HY(tory)YH(. Note also that we are required to link our + appli)HY(ca)HY(tion)YH( with the Xerces-C++ library because the gener)HY(ated)YH( + code uses it as the under)HY(ly)HY(ing)YH( XML parser.)EP( + + )0 2 11 H(2.5)WB 51 Sn()WB 14 Sn( Adding Seri)HY(al)HY(iza)HY(tion)YH()EA()EH( + + )0 P(While parsing and access)HY(ing)YH( the XML data may be every)HY(thing)YH( + you need, there are appli)HY(ca)HY(tions)YH( that require creat)HY(ing)YH( new + or modi)HY(fy)HY(ing)YH( exist)HY(ing)YH( XML docu)HY(ments)YH(. By default XSD does + not produce seri)HY(al)HY(iza)HY(tion)YH( code. We will need to request + it with the )SM(--gener)HY(ate)YH(-seri)HY(al)HY(iza)HY(tion)YH()ES( options:)EP( + + ) 1 49 PR($ xsd cxx-tree --generate-serialization hello.xsd)RP( + + )0 P(If we now examine the gener)HY(ated)YH( )SM(hello.hxx)ES( file, + we will find a set of over)HY(loaded)YH( seri)HY(al)HY(iza)HY(tion)YH( func)HY(tions)YH(, + includ)HY(ing)YH( the follow)HY(ing)YH( version:)EP( + + ) 5 45 PR(void +hello \201std::ostream&, + const hello_t&, + const xml_schema::namespace_infomap& = + xml_schema::namespace_infomap \201\202\202; +)RP( + + )0 P(Just like with parsing func)HY(tions)YH(, XSD gener)HY(ates)YH( seri)HY(al)HY(iza)HY(tion)YH( + func)HY(tions)YH( for each global element unless instructed other)HY(wise)YH( + with one of the )SM(--root-element-*)ES( options. For more + infor)HY(ma)HY(tion)YH( on seri)HY(al)HY(iza)HY(tion)YH( func)HY(tions)YH( see )0 38 1 A(Chapter 6, + "Seri)HY(al)HY(iza)HY(tion)YH(")38 0 TN TL()Ec /AF f D(.)EP( + + )0 P(We first examine an appli)HY(ca)HY(tion)YH( that modi)HY(fies)YH( an exist)HY(ing)YH( + object model and seri)HY(al)HY(izes)YH( it back to XML:)EP( + + ) 34 50 PR(#include +#include "hello.hxx" + +using namespace std; + +int +main \201int argc, char* argv[]\202 +{ + try + { + unique_ptr h \201hello \201argv[1]\202\202; + + // Change the greeting phrase. + // + h->greeting \201"Hi"\202; + + // Add another entry to the name sequence. + // + h->name \201\202.push_back \201"mars"\202; + + // Serialize the modified object model to XML. + // + xml_schema::namespace_infomap map; + map[""].name = ""; + map[""].schema = "hello.xsd"; + + hello \201cout, *h, map\202; + } + catch \201const xml_schema::exception& e\202 + { + cerr << e << endl;)WR( + return 1; + } +})RP( + + )0 P(First, our appli)HY(ca)HY(tion)YH( parses an XML docu)HY(ment)YH( and obtains its + object model as in the previ)HY(ous)YH( example. Then it changes the + greet)HY(ing)YH( string and adds another entry to the list of names. + Finally, it seri)HY(al)HY(izes)YH( the object model back to XML by calling + the seri)HY(al)HY(iza)HY(tion)YH( func)HY(tion)YH(.)EP( + + )0 P(The first argu)HY(ment)YH( we pass to the seri)HY(al)HY(iza)HY(tion)YH( func)HY(tion)YH( is + )SM(cout)ES( which results in the XML being written to + the stan)HY(dard)YH( output for us to inspect. We could have also + written the result to a file or memory buffer by creat)HY(ing)YH( an + instance of )SM(std::ofstream)ES( or )SM(std::ostringstream)ES( + and passing it instead of )SM(cout)ES(. The second argu)HY(ment)YH( is the + object model we want to seri)HY(al)HY(ize)YH(. The final argu)HY(ment)YH( is an optional + names)HY(pace)YH( infor)HY(ma)HY(tion)YH( map for our vocab)HY(u)HY(lary)YH(. It captures infor)HY(ma)HY(tion)YH( + such as names)HY(paces)YH(, names)HY(pace)YH( prefixes to which they should be mapped, + and schemas asso)HY(ci)HY(ated)YH( with these names)HY(paces)YH(. If we don't provide + this argu)HY(ment)YH( then generic names)HY(pace)YH( prefixes \201)SM(p1)ES(, + )SM(p2)ES(, etc.\202 will be auto)HY(mat)HY(i)HY(cally)YH( assigned to XML names)HY(paces)YH( + and no schema infor)HY(ma)HY(tion)YH( will be added to the result)HY(ing)YH( docu)HY(ment)YH( + \201see )0 38 1 A(Chapter 6, "Seri)HY(al)HY(iza)HY(tion)YH(")38 0 TN TL()Ec /AF f D( for details\202. + In our case, the prefix \201map key\202 and names)HY(pace)YH( name are empty + because our vocab)HY(u)HY(lary)YH( does not use XML names)HY(paces)YH(.)EP( + + )0 P(If we now compile and run this appli)HY(ca)HY(tion)YH( we will see the + output as shown in the follow)HY(ing)YH( listing:)EP( + + ) 12 60 PR( + + + Hi + + sun + moon + world + mars + +)RP( + + )0 P(We can also create and seri)HY(al)HY(ize)YH( an object model from scratch + as shown in the follow)HY(ing)YH( example:)EP( + + ) 33 43 PR(#include +#include +#include "hello.hxx" + +using namespace std; + +int +main \201int argc, char* argv[]\202 +{ + try + { + hello_t h \201"Hi"\202; + + hello_t::name_sequence& ns \201h.name \201\202\202; + + ns.push_back \201"Jane"\202; + ns.push_back \201"John"\202; + + // Serialize the object model to XML. + // + xml_schema::namespace_infomap map; + map[""].name = ""; + map[""].schema = "hello.xsd"; + + std::ofstream ofs \201argv[1]\202; + hello \201ofs, h, map\202; + } + catch \201const xml_schema::exception& e\202 + { + cerr << e << endl; + return 1;)WR( + } +})RP( + + )0 P(In this example we used the gener)HY(ated)YH( construc)HY(tor)YH( to create + an instance of type )SM(hello_t)ES(. To reduce typing, + we obtained a refer)HY(ence)YH( to the name sequence which we then + used to add a few names. The seri)HY(al)HY(iza)HY(tion)YH( part is iden)HY(ti)HY(cal)YH( + to the previ)HY(ous)YH( example except this time we are writing to + a file. If we compile and run this program, it produces the + follow)HY(ing)YH( XML file:)EP( + + ) 10 60 PR( + + + Hi + + Jane + John + +)RP( + + )0 2 12 H(2.6)WB 52 Sn()WB 15 Sn( Select)HY(ing)YH( Naming Conven)HY(tion)YH()EA()EH( + + )0 P(By default XSD uses the so-called K&R \201Kernighan and Ritchie\202 + iden)HY(ti)HY(fier)YH( naming conven)HY(tion)YH( in the gener)HY(ated)YH( code. In this + conven)HY(tion)YH( both type and func)HY(tion)YH( names are in lower case and + words are sepa)HY(rated)YH( by under)HY(scores)YH(. If your appli)HY(ca)HY(tion)YH( code or + schemas use a differ)HY(ent)YH( nota)HY(tion)YH(, you may want to change the + naming conven)HY(tion)YH( used in the gener)HY(ated)YH( code for consis)HY(tency)YH(. + XSD supports a set of widely-used naming conven)HY(tions)YH( + that you can select with the )SM(--type-naming)ES( and + )SM(--func)HY(tion)YH(-naming)ES( options. You can also further + refine one of the prede)HY(fined)YH( conven)HY(tions)YH( or create a completely + custom naming scheme by using the )SM(--*-regex)ES( options.)EP( + + )0 P(As an example, let's assume that our "Hello World" appli)HY(ca)HY(tion)YH( + uses the so-called upper-camel-case naming conven)HY(tion)YH( for types + \201that is, each word in a type name is capi)HY(tal)HY(ized)YH(\202 and the K&R + conven)HY(tion)YH( for func)HY(tion)YH( names. Since K&R is the default + conven)HY(tion)YH( for both type and func)HY(tion)YH( names, we only need to + change the type naming scheme:)EP( + + ) 1 42 PR($ xsd cxx-tree --type-naming ucc hello.xsd)RP( + + )0 P(The )SM(ucc)ES( argu)HY(ment)YH( to the )SM(--type-naming)ES( + options stands for upper-camel-case. If we now examine the + gener)HY(ated)YH( )SM(hello.hxx)ES(, we will see the follow)HY(ing)YH( + changes compared to the decla)HY(ra)HY(tions)YH( shown in the previ)HY(ous)YH( + sections:)EP( + + ) 45 57 PR(class Hello_t +{ +public: + // greeting + // + typedef xml_schema::String GreetingType; + + const GreetingType& + greeting \201\202 const; + + GreetingType& + greeting \201\202; + + void + greeting \201const GreetingType& x\202; + + // name + // + typedef xml_schema::String NameType; + typedef xsd::sequence NameSequence; + typedef NameSequence::iterator NameIterator; + typedef NameSequence::const_iterator NameConstIterator; + + const NameSequence& + name \201\202 const; + + NameSequence& + name \201\202; + + void + name \201const NameSequence& s\202;)WR( + + // Constructor. + // + Hello_t \201const GreetingType&\202; + + ... + +}; + +std::unique_ptr +hello \201const std::string& uri\202; + +std::unique_ptr +hello \201std::istream&\202;)RP( + + )0 P(Notice that the type names in the )SM(xml_schema)ES( names)HY(pace)YH(, + for example )SM(xml_schema::String)ES(, now also use the + upper-camel-case naming conven)HY(tion)YH(. The only thing that we may + be unhappy about in the above code is the )SM(_t)ES( + suffix in )SM(Hello_t)ES(. If we are not in a posi)HY(tion)YH( + to change the schema, we can )EM(touch-up)ES( the )SM(ucc)ES( + conven)HY(tion)YH( with a custom trans)HY(la)HY(tion)YH( rule using the + )SM(--type-regex)ES( option:)EP( + + ) 1 72 PR($ xsd cxx-tree --type-naming ucc --type-regex '/ \201.+\202_t/\200u$1/' hello.xsd)RP( + + )0 P(This results in the follow)HY(ing)YH( changes to the gener)HY(ated)YH( code:)EP( + + ) 45 57 PR(class Hello +{ +public: + // greeting + // + typedef xml_schema::String GreetingType; + + const GreetingType& + greeting \201\202 const; + + GreetingType& + greeting \201\202; + + void + greeting \201const GreetingType& x\202; + + // name + // + typedef xml_schema::String NameType; + typedef xsd::sequence NameSequence; + typedef NameSequence::iterator NameIterator; + typedef NameSequence::const_iterator NameConstIterator; + + const NameSequence& + name \201\202 const; + + NameSequence& + name \201\202; + + void + name \201const NameSequence& s\202;)WR( + + // Constructor. + // + Hello \201const GreetingType&\202; + + ... + +}; + +std::unique_ptr +hello \201const std::string& uri\202; + +std::unique_ptr +hello \201std::istream&\202;)RP( + + )0 P(For more detailed infor)HY(ma)HY(tion)YH( on the )SM(--type-naming)ES(, + )SM(--func)HY(tion)YH(-naming)ES(, )SM(--type-regex)ES(, and + other )SM(--*-regex)ES( options refer to the NAMING + CONVEN)HY(TION)YH( section in the )R4 2 A(XSD + Compiler Command Line Manual)EA(.)EP( + + )0 2 13 H(2.7)WB 53 Sn()WB 16 Sn( Gener)HY(at)HY(ing)YH( Docu)HY(men)HY(ta)HY(tion)YH()EA()EH( + + )0 P(While our object model is quite simple, real-world vocab)HY(u)HY(lar)HY(ies)YH( + can be quite complex with hundreds of types, elements, and + attributes. For such vocab)HY(u)HY(lar)HY(ies)YH( figur)HY(ing)YH( out which types + provide which member func)HY(tions)YH( by study)HY(ing)YH( the gener)HY(ated)YH( + source code or schemas can be a daunt)HY(ing)YH( task. To provide + appli)HY(ca)HY(tion)YH( devel)HY(op)HY(ers)YH( with a more acces)HY(si)HY(ble)YH( way of + under)HY(stand)HY(ing)YH( the gener)HY(ated)YH( object models, the XSD compiler + can be instructed to produce source code with docu)HY(men)HY(ta)HY(tion)YH( + comments in the Doxygen format. Then the source code can be + processed with the )R10 2 A(Doxygen)EA( + docu)HY(men)HY(ta)HY(tion)YH( system to extract this infor)HY(ma)HY(tion)YH( and produce + docu)HY(men)HY(ta)HY(tion)YH( in various formats. + )EP( + + )0 P(In this section we will see how to gener)HY(ate)YH( docu)HY(men)HY(ta)HY(tion)YH( + for our "Hello World" vocab)HY(u)HY(lary)YH(. To show)HY(case)YH( the full power + of the XSD docu)HY(men)HY(ta)HY(tion)YH( facil)HY(i)HY(ties)YH(, we will first docu)HY(ment)YH( + our schema. The XSD compiler will then trans)HY(fer)YH( + this infor)HY(ma)HY(tion)YH( from the schema to the gener)HY(ated)YH( code and + then to the object model docu)HY(men)HY(ta)HY(tion)YH(. Note that the + docu)HY(men)HY(ta)HY(tion)YH( in the schema is not required for XSD to + gener)HY(ate)YH( useful docu)HY(men)HY(ta)HY(tion)YH(. Below you will find + our )SM(hello.xsd)ES( with added docu)HY(men)HY(ta)HY(tion)YH(:)EP( + + ) 43 69 PR( + + + + + + The hello_t type consists of a greeting phrase and a + collection of names to which this greeting applies. + + + + + + + + + The greeting element contains the greeting phrase + for this hello object. + + + + + + + + The name elements contains names to be greeted. + + + + + )WR( + + + + + + The hello element is a root of the Hello XML vocabulary. + Every conforming document should start with this element. + + + + +)RP( + + )0 P(The first step in obtain)HY(ing)YH( the docu)HY(men)HY(ta)HY(tion)YH( is to recom)HY(pile)YH( + our schema with the )SM(--gener)HY(ate)YH(-doxygen)ES( option:)EP( + + ) 1 68 PR($ xsd cxx-tree --generate-serialization --generate-doxygen hello.xsd)RP( + + )0 P(Now the gener)HY(ated)YH( )SM(hello.hxx)ES( file contains comments + in the Doxygen format. The next step is to process this file + with the Doxygen docu)HY(men)HY(ta)HY(tion)YH( system. If your project does + not use Doxygen then you first need to create a config)HY(u)HY(ra)HY(tion)YH( + file for your project:)EP( + + ) 1 26 PR($ doxygen -g hello.doxygen)RP( + + )0 P(You only need to perform this step once. Now we can gener)HY(ate)YH( + the docu)HY(men)HY(ta)HY(tion)YH( by execut)HY(ing)YH( the follow)HY(ing)YH( command in the + direc)HY(tory)YH( with the gener)HY(ated)YH( source code:)EP( + + ) 1 23 PR($ doxygen hello.doxygen)RP( + + )0 P(While the gener)HY(ated)YH( docu)HY(men)HY(ta)HY(tion)YH( can be useful as is, we can + go one step further and link \201using the Doxygen tags mech)HY(a)HY(nism)YH(\202 + the docu)HY(men)HY(ta)HY(tion)YH( for our object model with the docu)HY(men)HY(ta)HY(tion)YH( + for the XSD runtime library which defines C++ classes for the + built-in XML Schema types. This way we can seam)HY(lessly)YH( browse + between docu)HY(men)HY(ta)HY(tion)YH( for the )SM(hello_t)ES( class which + is gener)HY(ated)YH( by the XSD compiler and the )SM(xml_schema::string)ES( + class which is defined in the XSD runtime library. The Doxygen + config)HY(u)HY(ra)HY(tion)YH( file for the XSD runtime is provided with the XSD + distri)HY(bu)HY(tion)YH(.)EP( + + )0 P(You can view the result of the steps described in this section + on the )R11 2 A(Hello + Example Docu)HY(men)HY(ta)HY(tion)YH()EA( page.)EP( + + + + + )0 1 14 H(3)WB 54 Sn()WB 17 Sn( Overall Mapping Config)HY(u)HY(ra)HY(tion)YH()EA()EH( + + )0 P(The C++/Tree mapping has a number of config)HY(u)HY(ra)HY(tion)YH( param)HY(e)HY(ters)YH( that + deter)HY(mine)YH( the overall prop)HY(er)HY(ties)YH( and behav)HY(ior)YH( of the gener)HY(ated)YH( code. + Config)HY(u)HY(ra)HY(tion)YH( param)HY(e)HY(ters)YH( are spec)HY(i)HY(fied)YH( with the XSD command line + options. This chapter describes config)HY(u)HY(ra)HY(tion)YH( aspects that are most + commonly encoun)HY(tered)YH( by appli)HY(ca)HY(tion)YH( devel)HY(op)HY(ers)YH(. These include: the + C++ stan)HY(dard)YH(, the char)HY(ac)HY(ter)YH( type that is used by the gener)HY(ated)YH( code, + handling of vocab)HY(u)HY(lar)HY(ies)YH( that use XML Schema poly)HY(mor)HY(phism)YH(, XML Schema + to C++ names)HY(pace)YH( mapping, and thread safety. For more ways to config)HY(ure)YH( + the gener)HY(ated)YH( code refer to the + )R4 2 A(XSD + Compiler Command Line Manual)EA(. + )EP( + + )0 2 15 H(3.1)WB 55 Sn()WB 18 Sn( C++ Stan)HY(dard)YH()EA()EH( + + )0 P(The C++/Tree mapping provides support for ISO/IEC C++ 2011 \201C++11\202 + and ISO/IEC C++ 1998/2003 \201C++98\202. To select the C++ stan)HY(dard)YH( for the + gener)HY(ated)YH( code we use the )SM(--std)ES( XSD compiler command + line option. While the major)HY(ity)YH( of the exam)HY(ples)YH( in this guide use + C++11, the docu)HY(ment)YH( explains the C++11/98 usage differ)HY(ence)YH( and so + they can easily be converted to C++98.)EP( + + )0 2 16 H(3.2)WB 56 Sn()WB 19 Sn( Char)HY(ac)HY(ter)YH( Type and Encod)HY(ing)YH()EA()EH( + + )0 P(The C++/Tree mapping has built-in support for two char)HY(ac)HY(ter)YH( types: + )SM(char)ES( and )SM(wchar_t)ES(. You can select the + char)HY(ac)HY(ter)YH( type with the )SM(--char-type)ES( command line + option. The default char)HY(ac)HY(ter)YH( type is )SM(char)ES(. The + char)HY(ac)HY(ter)YH( type affects all string and string-based types that + are used in the mapping. These include the string-based built-in + XML Schema types, excep)HY(tion)YH( types, stream types, etc.)EP( + + )0 P(Another aspect of the mapping that depends on the char)HY(ac)HY(ter)YH( type + is char)HY(ac)HY(ter)YH( encod)HY(ing)YH(. For the )SM(char)ES( char)HY(ac)HY(ter)YH( type + the default encod)HY(ing)YH( is UTF-8. Other supported encod)HY(ings)YH( are + ISO-8859-1, Xerces-C++ Local Code Page \201LPC\202, as well as + custom encod)HY(ings)YH(. You can select which encod)HY(ing)YH( should be used + in the object model with the )SM(--char-encod)HY(ing)YH()ES( command + line option.)EP( + + )0 P(For the )SM(wchar_t)ES( char)HY(ac)HY(ter)YH( type the encod)HY(ing)YH( is + auto)HY(mat)HY(i)HY(cally)YH( selected between UTF-16 and UTF-32/UCS-4 depend)HY(ing)YH( + on the size of the )SM(wchar_t)ES( type. On some plat)HY(forms)YH( + \201for example, Windows with Visual C++ and AIX with IBM XL C++\202 + )SM(wchar_t)ES( is 2 bytes long. For these plat)HY(forms)YH( the + encod)HY(ing)YH( is UTF-16. On other plat)HY(forms)YH( )SM(wchar_t)ES( is 4 bytes + long and UTF-32/UCS-4 is used.)EP( + + )0 P(Note also that the char)HY(ac)HY(ter)YH( encod)HY(ing)YH( that is used in the object model + is inde)HY(pen)HY(dent)YH( of the encod)HY(ings)YH( used in input and output XML. In fact, + all three \201object mode, input XML, and output XML\202 can have differ)HY(ent)YH( + encod)HY(ings)YH(.)EP( + + )0 2 17 H(3.3)WB 57 Sn()WB 20 Sn( Support for Poly)HY(mor)HY(phism)YH()EA()EH( + + )0 P(By default XSD gener)HY(ates)YH( non-poly)HY(mor)HY(phic)YH( code. If your vocab)HY(u)HY(lary)YH( + uses XML Schema poly)HY(mor)HY(phism)YH( in the form of )SM(xsi:type)ES( + and/or substi)HY(tu)HY(tion)YH( groups, then you will need to compile + your schemas with the )SM(--gener)HY(ate)YH(-poly)HY(mor)HY(phic)YH()ES( option + to produce poly)HY(mor)HY(phism)YH(-aware code. For more infor)HY(ma)HY(tion)YH( on + working with poly)HY(mor)HY(phic)YH( object models, refer to + )R12 2 A(Section 2.11, + "Mapping for )SM(xsi:type)ES( and Substi)HY(tu)HY(tion)YH( Groups")EA( in + the C++/Tree Mapping User Manual.)EP( + + )0 2 18 H(3.4)WB 58 Sn()WB 21 Sn( Names)HY(pace)YH( Mapping)EA()EH( + + )0 P(XSD maps XML names)HY(paces)YH( spec)HY(i)HY(fied)YH( in the )SM(target)HY(Names)HY(pace)YH()ES( + attribute in XML Schema to one or more nested C++ names)HY(paces)YH(. By + default, a names)HY(pace)YH( URI is mapped to a sequence of C++ names)HY(pace)YH( + names by remov)HY(ing)YH( the proto)HY(col)YH( and host parts and split)HY(ting)YH( the + rest into a sequence of names with )SM('/')ES( as the name + sepa)HY(ra)HY(tor)YH(.)EP( + + )0 P(The default mapping of names)HY(pace)YH( URIs to C++ names)HY(paces)YH( + can be altered using the )SM(--names)HY(pace)YH(-map)ES( and + )SM(--names)HY(pace)YH(-regex)ES( compiler options. For example, + to map names)HY(pace)YH( URI )SM(https://www.codesyn)HY(the)HY(sis)YH(.com/my)ES( to + C++ names)HY(pace)YH( )SM(cs::my)ES(, we can use the follow)HY(ing)YH( option:)EP( + + ) 1 55 PR(--namespace-map https://www.codesynthesis.com/my=cs::my)RP( + + )0 P(A vocab)HY(u)HY(lary)YH( without a names)HY(pace)YH( is mapped to the global scope. This + also can be altered with the above options by using an empty name + for the XML names)HY(pace)YH(:)EP( + + ) 1 19 PR(--namespace-map =cs)RP( + + )0 2 19 H(3.5)WB 59 Sn()WB 22 Sn( Thread Safety)EA()EH( + + )0 P(XSD-gener)HY(ated)YH( code is thread-safe in the sense that you can + use differ)HY(ent)YH( instan)HY(ti)HY(a)HY(tions)YH( of the object model in several + threads concur)HY(rently)YH(. This is possi)HY(ble)YH( due to the gener)HY(ated)YH( + code not relying on any writable global vari)HY(ables)YH(. If you need + to share the same object between several threads then you will + need to provide some form of synchro)HY(niza)HY(tion)YH(. One approach would + be to use the gener)HY(ated)YH( code customiza)HY(tion)YH( mech)HY(a)HY(nisms)YH( to embed + synchro)HY(niza)HY(tion)YH( prim)HY(i)HY(tives)YH( into the gener)HY(ated)YH( C++ classes. For more + infor)HY(ma)HY(tion)YH( on gener)HY(ated)YH( code customiza)HY(tion)YH( refer to the + )R2 2 A(C++/Tree + Mapping Customiza)HY(tion)YH( Guide)EA(.)EP( + + )0 P(If you also would like to call parsing and/or seri)HY(al)HY(iza)HY(tion)YH( + func)HY(tions)YH( from several threads poten)HY(tially)YH( concur)HY(rently)YH(, then + you will need to make sure the Xerces-C++ runtime is initial)HY(ized)YH( + and termi)HY(nated)YH( only once. The easiest way to do this is to + initial)HY(ize)YH(/termi)HY(nate)YH( Xerces-C++ from )SM(main\201\202)ES( when + there are no threads yet/anymore:)EP( + + ) 13 56 PR(#include + +int +main \201\202 +{ + xercesc::XMLPlatformUtils::Initialize \201\202; + + { + // Start/terminate threads and parse/serialize here. + } + + xercesc::XMLPlatformUtils::Terminate \201\202; +})RP( + + )0 P(Because you initial)HY(ize)YH( the Xerces-C++ runtime your)HY(self)YH( you should + also pass the )SM(xml_schema::flags::dont_initial)HY(ize)YH()ES( flag + to parsing and seri)HY(al)HY(iza)HY(tion)YH( func)HY(tions)YH(. See )0 37 1 A(Chapter 5, + "Parsing")37 0 TN TL()Ec /AF f D( and )0 38 1 A(Chapter 6, "Seri)HY(al)HY(iza)HY(tion)YH(")38 0 TN TL()Ec /AF f D( for + more infor)HY(ma)HY(tion)YH(.)EP( + + + + + + )0 1 20 H(4)WB 60 Sn()WB 23 Sn( Working with Object Models)EA()EH( + + )0 P(As we have seen in the previ)HY(ous)YH( chap)HY(ters)YH(, the XSD compiler gener)HY(ates)YH( + a C++ class for each type defined in XML Schema. Together these classes + consti)HY(tute)YH( an object model for an XML vocab)HY(u)HY(lary)YH(. In this chapter we + will take a closer look at differ)HY(ent)YH( elements that comprise an + object model class as well as how to create, access, and modify + object models.)EP( + + )0 P(In this and subse)HY(quent)YH( chap)HY(ters)YH( we will use the follow)HY(ing)YH( schema + that describes a collec)HY(tion)YH( of person records. We save it in + )SM(people.xsd)ES(:)EP( + + ) 30 71 PR( + + + + + + + + + + + + + + + + + + + + + + + + + + + + +)RP( + + )0 P(A sample XML instance to go along with this schema is saved + in )SM(people.xml)ES(:)EP( + + ) 20 61 PR( + + + + John + Doe + male + 32 + + + + Jane + Mary + Doe + female + 28 + + +)RP( + + )0 P(Compil)HY(ing)YH( )SM(people.xsd)ES( with the XSD compiler results + in three gener)HY(ated)YH( C++ classes: )SM(gender_t)ES(, + )SM(person_t)ES(, and )SM(people_t)ES(. + The )SM(gender_t)ES( class is modelled after the C++ + )SM(enum)ES( type. Its defi)HY(ni)HY(tion)YH( is presented below:)EP( + + ) 17 41 PR(class gender_t: public xml_schema::string +{ +public: + enum value + { + male, + female + }; + + gender_t \201value\202; + gender_t \201const xml_schema::string&\202; + + gender_t& + operator= \201value\202; + + operator value \201\202 const; +};)RP( + + )0 P(The follow)HY(ing)YH( listing shows how we can use this type:)EP( + + ) 19 41 PR(gender_t m \201gender_t::male\202; +gender_t f \201"female"\202; + +if \201m == "female" || f == gender_t::male\202 +{ + ... +} + +switch \201m\202 +{ +case gender_t::male: + { + ... + } +case gender_t::female: + { + ... + } +})RP( + + )0 P(The other two classes will be exam)HY(ined)YH( in detail in the subse)HY(quent)YH( + sections.)EP( + + )0 2 21 H(4.1)WB 61 Sn()WB 24 Sn( Attribute and Element Cardi)HY(nal)HY(i)HY(ties)YH()EA()EH( + + )0 P(As we have seen in the previ)HY(ous)YH( chap)HY(ters)YH(, XSD gener)HY(ates)YH( a differ)HY(ent)YH( + set of type defi)HY(ni)HY(tions)YH( and member func)HY(tions)YH( for elements with + differ)HY(ent)YH( cardi)HY(nal)HY(i)HY(ties)YH(. The C++/Tree mapping divides all the possi)HY(ble)YH( + element and attribute cardi)HY(nal)HY(i)HY(ties)YH( into three cardi)HY(nal)HY(ity)YH( classes: + )EM(one)ES(, )EM(optional)ES(, and )EM(sequence)ES(.)EP( + + )0 P(The )EM(one)ES( cardi)HY(nal)HY(ity)YH( class covers all elements that should + occur exactly once as well as required attributes. In our + example, the )SM(first-name)ES(, )SM(last-name)ES(, + )SM(gender)ES(, and )SM(age)ES( elements as well as + the )SM(id)ES( attribute belong to this cardi)HY(nal)HY(ity)YH( class. + The follow)HY(ing)YH( code frag)HY(ment)YH( shows type defi)HY(ni)HY(tions)YH( as well as the + acces)HY(sor)YH( and modi)HY(fier)YH( func)HY(tions)YH( that are gener)HY(ated)YH( for the + )SM(gender)ES( element in the )SM(person_t)ES( class:)EP( + + ) 15 31 PR(class person_t +{ + // gender + // + typedef gender_t gender_type; + + const gender_type& + gender \201\202 const; + + gender_type& + gender \201\202; + + void + gender \201const gender_type&\202; +};)RP( + + )0 P(The )SM(gender_type)ES( type is an alias for the element's type. + The first two acces)HY(sor)YH( func)HY(tions)YH( return read-only \201constant\202 and + read-write refer)HY(ences)YH( to the element's value, respec)HY(tively)YH(. The + modi)HY(fier)YH( func)HY(tion)YH( sets the new value for the element.)EP( + + )0 P(The )EM(optional)ES( cardi)HY(nal)HY(ity)YH( class covers all elements that + can occur zero or one time as well as optional attributes. In our + example, the )SM(middle-name)ES( element belongs to this + cardi)HY(nal)HY(ity)YH( class. The follow)HY(ing)YH( code frag)HY(ment)YH( shows the type + defi)HY(ni)HY(tions)YH( as well as the acces)HY(sor)YH( and modi)HY(fier)YH( func)HY(tions)YH( that + are gener)HY(ated)YH( for this element in the )SM(person_t)ES( class:)EP( + + ) 19 63 PR(class person_t +{ + // middle-name + // + typedef xml_schema::string middle_name_type; + typedef xsd::optional middle_name_optional; + + const middle_name_optional& + middle_name \201\202 const; + + middle_name_optional& + middle_name \201\202; + + void + middle_name \201const middle_name_type&\202; + + void + middle_name \201const middle_name_optional&\202; +};)RP( + + )0 P(As with the )SM(gender)ES( element, )SM(middle_name_type)ES( + is an alias for the element's type. The )SM(middle_name_optional)ES( + type is a container for the element's optional value. It can be queried + for the pres)HY(ence)YH( of the value using the )SM(present\201\202)ES( func)HY(tion)YH(. + The value itself can be retrieved using the )SM(get\201\202)ES( + acces)HY(sor)YH( and set using the )SM(set\201\202)ES( modi)HY(fier)YH(. The container + can be reverted to the value not present state with the call to the + )SM(reset\201\202)ES( func)HY(tion)YH(. The follow)HY(ing)YH( example shows how we + can use this container:)EP( + + ) 9 42 PR(person_t::middle_name_optional n \201"John"\202; + +if \201n.present \201\202\202 +{ + cout << n.get \201\202 << endl; +} + +n.set \201"Jane"\202; +n.reset \201\202;)RP( + + + )0 P(Unlike the )EM(one)ES( cardi)HY(nal)HY(ity)YH( class, the acces)HY(sor)YH( func)HY(tions)YH( + for the )EM(optional)ES( class return read-only \201constant\202 and + read-write refer)HY(ences)YH( to the container instead of the element's + value directly. The modi)HY(fier)YH( func)HY(tions)YH( set the new value for the + element.)EP( + + )0 P(Finally, the )EM(sequence)ES( cardi)HY(nal)HY(ity)YH( class covers all elements + that can occur more than once. In our example, the + )SM(person)ES( element in the )SM(people_t)ES( type + belongs to this cardi)HY(nal)HY(ity)YH( class. The follow)HY(ing)YH( code frag)HY(ment)YH( shows + the type defi)HY(ni)HY(tions)YH( as well as the acces)HY(sor)YH( and modi)HY(fier)YH( func)HY(tions)YH( + that are gener)HY(ated)YH( for this element in the )SM(people_t)ES( + class:)EP( + + ) 18 64 PR(class people_t +{ + // person + // + typedef person_t person_type; + typedef xsd::sequence person_sequence; + typedef person_sequence::iterator person_iterator; + typedef person_sequence::const_iterator person_const_iterator; + + const person_sequence& + person \201\202 const; + + person_sequence& + person \201\202; + + void + person \201const person_sequence&\202; +};)RP( + + )0 P(Iden)HY(ti)HY(cal)YH( to the other cardi)HY(nal)HY(ity)YH( classes, )SM(person_type)ES( + is an alias for the element's type. The )SM(person_sequence)ES( + type is a sequence container for the element's values. It is based + on and has the same inter)HY(face)YH( as )SM(std::vector)ES( and + there)HY(fore)YH( can be used in similar ways. The )SM(person_iter)HY(a)HY(tor)YH()ES( + and )SM(person_const_iter)HY(a)HY(tor)YH()ES( types are read-only + \201constant\202 and read-write iter)HY(a)HY(tors)YH( for the )SM(person_sequence)ES( + container.)EP( + + )0 P(Similar to the )EM(optional)ES( cardi)HY(nal)HY(ity)YH( class, the + acces)HY(sor)YH( func)HY(tions)YH( for the )EM(sequence)ES( class return + read-only \201constant\202 and read-write refer)HY(ences)YH( to the sequence + container. The modi)HY(fier)YH( func)HY(tions)YH( copies the entries from + the passed sequence.)EP( + + )0 P(C++/Tree is a "flat)HY(ten)HY(ing)YH(" mapping in a sense that many levels of + nested compos)HY(i)HY(tors)YH( \201)SM(choice)ES( and )SM(sequence)ES(\202, + all poten)HY(tially)YH( with their own cardi)HY(nal)HY(i)HY(ties)YH(, are in the end mapped + to a flat set of elements with one of the three cardi)HY(nal)HY(ity)YH( classes + discussed above. While this results in a simple and easy to use API + for most types, in certain cases, the order of elements in the actual + XML docu)HY(ments)YH( is not preserved once parsed into the object model. To + over)HY(come)YH( this limi)HY(ta)HY(tion)YH( we can mark certain schema types, for which + content order is not suffi)HY(ciently)YH( preserved, as ordered. For more + infor)HY(ma)HY(tion)YH( on this func)HY(tion)HY(al)HY(ity)YH( refer to + )R13 2 A(Section + 2.8.4, "Element Order")EA( in the C++/Tree Mapping User Manual.)EP( + + )0 P(For complex schemas with many levels of nested compos)HY(i)HY(tors)YH( + \201)SM(choice)ES( and )SM(sequence)ES(\202 it can also + be hard to deduce the cardi)HY(nal)HY(ity)YH( class of a partic)HY(u)HY(lar)YH( element. + The gener)HY(ated)YH( Doxygen docu)HY(men)HY(ta)HY(tion)YH( can greatly help with + this task. For each element and attribute the docu)HY(men)HY(ta)HY(tion)YH( + clearly iden)HY(ti)HY(fies)YH( its cardi)HY(nal)HY(ity)YH( class. Alter)HY(na)HY(tively)YH(, you + can study the gener)HY(ated)YH( header files to find out the cardi)HY(nal)HY(ity)YH( + class of a partic)HY(u)HY(lar)YH( attribute or element.)EP( + + )0 P(In the next sections we will examine how to access and modify + infor)HY(ma)HY(tion)YH( stored in an object model using acces)HY(sor)YH( and modi)HY(fier)YH( + func)HY(tions)YH( described in this section.)EP( + + )0 2 22 H(4.2)WB 62 Sn()WB 25 Sn( Access)HY(ing)YH( the Object Model)EA()EH( + + )0 P(In this section we will learn how to get to the infor)HY(ma)HY(tion)YH( + stored in the object model for our person records vocab)HY(u)HY(lary)YH(. + The follow)HY(ing)YH( appli)HY(ca)HY(tion)YH( accesses and prints the contents + of the )SM(people.xml)ES( file:)EP( + + ) 36 70 PR(#include +#include "people.hxx" + +using namespace std; + +int +main \201\202 +{ + unique_ptr ppl \201people \201"people.xml"\202\202; + + // Iterate over individual person records. + // + people_t::person_sequence& ps \201ppl->person \201\202\202; + + for \201people_t::person_iterator i \201ps.begin \201\202\202; i != ps.end \201\202; ++i\202 + { + person_t& p \201*i\202; + + // Print names: first-name and last-name are required elements, + // middle-name is optional. + // + cout << "name: " << p.first_name \201\202 << " "; + + if \201p.middle_name \201\202.present \201\202\202 + cout << p.middle_name \201\202.get \201\202 << " "; + + cout << p.last_name \201\202 << endl; + + // Print gender, age, and id which are all required. + // + cout << "gender: " << p.gender \201\202 << endl)WR( + << "age: " << p.age \201\202 << endl + << "id: " << p.id \201\202 << endl + << endl; + } +})RP( + + )0 P(This code shows common patterns of access)HY(ing)YH( elements and attributes + with differ)HY(ent)YH( cardi)HY(nal)HY(ity)YH( classes. For the sequence element + \201)SM(person)ES( in )SM(people_t)ES(\202 we first obtain a + refer)HY(ence)YH( to the container and then iterate over indi)HY(vid)HY(ual)YH( + records. The values of elements and attributes with the + )EM(one)ES( cardi)HY(nal)HY(ity)YH( class \201)SM(first-name)ES(, + )SM(last-name)ES(, )SM(gender)ES(, )SM(age)ES(, + and )SM(id)ES(\202 can be obtained directly by calling the + corre)HY(spond)HY(ing)YH( acces)HY(sor)YH( func)HY(tions)YH(. For the optional element + )SM(middle-name)ES( we first check if the value is present + and only then call )SM(get\201\202)ES( to retrieve it.)EP( + + )0 P(Note that when we want to reduce typing by creat)HY(ing)YH( a vari)HY(able)YH( + repre)HY(sent)HY(ing)YH( a frag)HY(ment)YH( of the object model that we are currently + working with \201)SM(ps)ES( and )SM(p)ES( above\202, we obtain + a refer)HY(ence)YH( to that frag)HY(ment)YH( instead of making a poten)HY(tially)YH( + expen)HY(sive)YH( copy. This is gener)HY(ally)YH( a good rule to follow when + creat)HY(ing)YH( high-perfor)HY(mance)YH( appli)HY(ca)HY(tions)YH(.)EP( + + )0 P(If we run the above appli)HY(ca)HY(tion)YH( on our sample + )SM(people.xml)ES(, the output looks as follows:)EP( + + ) 9 21 PR(name: John Doe +gender: male +age: 32 +id: 1 + +name: Jane Mary Doe +gender: female +age: 28 +id: 2)RP( + + + )0 2 23 H(4.3)WB 63 Sn()WB 26 Sn( Modi)HY(fy)HY(ing)YH( the Object Model)EA()EH( + + )0 P(In this section we will learn how to modify the infor)HY(ma)HY(tion)YH( + stored in the object model for our person records vocab)HY(u)HY(lary)YH(. + The follow)HY(ing)YH( appli)HY(ca)HY(tion)YH( changes the contents of the + )SM(people.xml)ES( file:)EP( + + ) 43 70 PR(#include +#include "people.hxx" + +using namespace std; + +int +main \201\202 +{ + unique_ptr ppl \201people \201"people.xml"\202\202; + + // Iterate over individual person records and increment + // the age. + // + people_t::person_sequence& ps \201ppl->person \201\202\202; + + for \201people_t::person_iterator i \201ps.begin \201\202\202; i != ps.end \201\202; ++i\202 + { + // Alternative way: i->age \201\202++; + // + i->age \201i->age \201\202 + 1\202; + } + + // Add middle-name to the first record and remove it from + // the second. + // + person_t& john \201ps[0]\202; + person_t& jane \201ps[1]\202; + + john.middle_name \201"Mary"\202; + jane.middle_name \201\202.reset \201\202; +)WR( + // Add another John record. + // + ps.push_back \201john\202; + + // Serialize the modified object model to XML. + // + xml_schema::namespace_infomap map; + map[""].name = ""; + map[""].schema = "people.xsd"; + + people \201cout, *ppl, map\202; +})RP( + + )0 P(The first modi)HY(fi)HY(ca)HY(tion)YH( the above appli)HY(ca)HY(tion)YH( performs is iter)HY(at)HY(ing)YH( + over person records and incre)HY(ment)HY(ing)YH( the age value. This code + frag)HY(ment)YH( shows how to modify the value of a required attribute + or element. The next modi)HY(fi)HY(ca)HY(tion)YH( shows how to set a new value + for the optional )SM(middle-name)ES( element as well + as clear its value. Finally the example adds a copy of the + John Doe record to the )SM(person)ES( element sequence.)EP( + + )0 P(Note that in this case using refer)HY(ences)YH( for the )SM(ps)ES(, + )SM(john)ES(, and )SM(jane)ES( vari)HY(ables)YH( is no longer + a perfor)HY(mance)YH( improve)HY(ment)YH( but a require)HY(ment)YH( for the appli)HY(ca)HY(tion)YH( + to func)HY(tion)YH( correctly. If we hadn't used refer)HY(ences)YH(, all our changes + would have been made on copies without affect)HY(ing)YH( the object model.)EP( + + )0 P(If we run the above appli)HY(ca)HY(tion)YH( on our sample )SM(people.xml)ES(, + the output looks as follows:)EP( + + ) 28 61 PR( + + + + John + Mary + Doe + male + 33 + + + + Jane + Doe + female + 29 + + + + John + Mary + Doe + male + 33 + + +)RP( + + + )0 2 24 H(4.4)WB 64 Sn()WB 27 Sn( Creat)HY(ing)YH( the Object Model from Scratch)EA()EH( + + )0 P(In this section we will learn how to create a new object model + for our person records vocab)HY(u)HY(lary)YH(. The follow)HY(ing)YH( appli)HY(ca)HY(tion)YH( + recre)HY(ates)YH( the content of the orig)HY(i)HY(nal)YH( )SM(people.xml)ES( + file:)EP( + + ) 42 48 PR(#include +#include "people.hxx" + +using namespace std; + +int +main \201\202 +{ + people_t ppl; + people_t::person_sequence& ps \201ppl.person \201\202\202; + + // Add the John Doe record. + // + ps.push_back \201 + person_t \201"John", // first-name + "Doe", // last-name + gender_t::male, // gender + 32, // age + 1\202\202; + + // Add the Jane Doe record. + // + ps.push_back \201 + person_t \201"Jane", // first-name + "Doe", // last-name + gender_t::female, // gender + 28, // age + 2\202\202; // id + + // Add middle name to the Jane Doe record. + //)WR( + person_t& jane \201ps.back \201\202\202; + jane.middle_name \201"Mary"\202; + + // Serialize the object model to XML. + // + xml_schema::namespace_infomap map; + map[""].name = ""; + map[""].schema = "people.xsd"; + + people \201cout, ppl, map\202; +})RP( + + )0 P(The only new part in the above appli)HY(ca)HY(tion)YH( is the calls + to the )SM(people_t)ES( and )SM(person_t)ES( + construc)HY(tors)YH(. As a general rule, for each C++ class + XSD gener)HY(ates)YH( a construc)HY(tor)YH( with initial)HY(iz)HY(ers)YH( + for each element and attribute belong)HY(ing)YH( to the )EM(one)ES( + cardi)HY(nal)HY(ity)YH( class. For our vocab)HY(u)HY(lary)YH(, the follow)HY(ing)YH( + construc)HY(tors)YH( are gener)HY(ated)YH(:)EP( + + ) 13 35 PR(class person_t +{ + person_t \201const first_name_type&, + const last_name_type&, + const gender_type&, + const age_type&, + const id_type&\202; +}; + +class people_t +{ + people_t \201\202; +};)RP( + + )0 P(Note also that we set the )SM(middle-name)ES( element + on the Jane Doe record by obtain)HY(ing)YH( a refer)HY(ence)YH( to that record + in the object model and setting the )SM(middle-name)ES( + value on it. This is a general rule that should be followed + in order to obtain the best perfor)HY(mance)YH(: if possi)HY(ble)YH(, + direct modi)HY(fi)HY(ca)HY(tions)YH( to the object model should be preferred + to modi)HY(fi)HY(ca)HY(tions)YH( on tempo)HY(raries)YH( with subse)HY(quent)YH( copying. The + follow)HY(ing)YH( code frag)HY(ment)YH( shows a seman)HY(ti)HY(cally)YH( equiv)HY(a)HY(lent)YH( but + slightly slower version:)EP( + + ) 11 46 PR(// Add the Jane Doe record. +// +person_t jane \201"Jane", // first-name + "Doe", // last-name + gender_t::female, // gender + 28, // age + 2\202; // id + +jane.middle_name \201"Mary"\202; + +ps.push_back \201jane\202;)RP( + + )0 P(We can also go one step further to reduce copying and improve + the perfor)HY(mance)YH( of our appli)HY(ca)HY(tion)YH( by using the non-copying + )SM(push_back\201\202)ES( func)HY(tion)YH( which assumes owner)HY(ship)YH( + of the passed objects:)EP( + + ) 19 55 PR(// Add the Jane Doe record. C++11 version +// +unique_ptr jane_p \201 + new person_t \201"Jane", // first-name + "Doe", // last-name + gender_t::female, // gender + 28, // age + 2\202\202; // id +ps.push_back \201std::move \201jane_p\202\202; // assumes ownership + +// Add the John Doe record. C++98 version. +// +auto_ptr john_p \201 + new person_t \201"John", // first-name + "Doe", // last-name + gender_t::male, // gender + 32, // age + 1\202\202; +ps.push_back \201john_p\202; // assumes ownership)RP( + + )0 P(For more infor)HY(ma)HY(tion)YH( on the non-copying modi)HY(fier)YH( func)HY(tions)YH( refer to + )R14 2 A(Section + 2.8, "Mapping for Local Elements and Attributes")EA( in the C++/Tree Mapping + User Manual. The above appli)HY(ca)HY(tion)YH( produces the follow)HY(ing)YH( output:)EP( + + ) 20 61 PR( + + + + John + Doe + male + 32 + + + + Jane + Mary + Doe + female + 28 + + +)RP( + + )0 2 25 H(4.5)WB 65 Sn()WB 28 Sn( Mapping for the Built-in XML Schema Types)EA()EH( + + )0 P(Our person record vocab)HY(u)HY(lary)YH( uses several built-in XML Schema + types: )SM(string)ES(, )SM(short)ES(, and + )SM(unsignedInt)ES(. Until now we haven't talked about + the mapping of built-in XML Schema types to C++ types and how + to work with them. This section provides an overview + of the built-in types. For more detailed infor)HY(ma)HY(tion)YH( refer + to )R15 2 A(Section + 2.5, "Mapping for Built-in Data Types")EA( in the C++/Tree Mapping + User Manual.)EP( + + )0 P(In XML Schema, built-in types are defined in the XML Schema names)HY(pace)YH(. + By default, the C++/Tree mapping maps this names)HY(pace)YH( to C++ + names)HY(pace)YH( )SM(xml_schema)ES( \201this mapping can be altered + with the )SM(--names)HY(pace)YH(-map)ES( option\202. The follow)HY(ing)YH( table + summa)HY(rizes)YH( the mapping of XML Schema built-in types to C++ types:)EP( + + + )0 PT( + + )0 P(As you can see from the table above a number of built-in + XML Schema types are mapped to funda)HY(men)HY(tal)YH( C++ types such + as )SM(int)ES( or )SM(bool)ES(. All string-based + XML Schema types are mapped to C++ types that are derived + from either )SM(std::string)ES( or + )SM(std::wstring)ES(, depend)HY(ing)YH( on the char)HY(ac)HY(ter)YH( + type selected. For access and modi)HY(fi)HY(ca)HY(tion)YH( purposes these + types can be treated as )SM(std::string)ES(. A number + of built-in types, such as )SM(qname)ES(, the binary + types, and the date/time types do not have suit)HY(able)YH( + funda)HY(men)HY(tal)YH( or stan)HY(dard)YH( C++ types to map to. As a result, + these types are imple)HY(mented)YH( from scratch in the XSD runtime. + For more infor)HY(ma)HY(tion)YH( on their inter)HY(faces)YH( refer to + )R15 2 A(Section + 2.5, "Mapping for Built-in Data Types")EA( in the C++/Tree Mapping + User Manual.)EP( + + + + + + )0 1 26 H(5)WB 66 Sn()WB 30 Sn( Parsing)EA()EH( + + )0 P(We have already seen how to parse XML to an object model in this guide + before. In this chapter we will discuss the parsing topic in more + detail.)EP( + + )0 P(By default, the C++/Tree mapping provides a total of 14 over)HY(loaded)YH( + parsing func)HY(tions)YH(. They differ in the input methods used to + read XML as well as the error report)HY(ing)YH( mech)HY(a)HY(nisms)YH(. It is also possi)HY(ble)YH( + to gener)HY(ate)YH( types for root elements instead of parsing and seri)HY(al)HY(iza)HY(tion)YH( + func)HY(tions)YH(. This may be useful if your XML vocab)HY(u)HY(lary)YH( has multi)HY(ple)YH( + root elements. For more infor)HY(ma)HY(tion)YH( on element types refer to + )R16 2 A(Section + 2.9, "Mapping for Global Elements")EA( in the C++/Tree Mapping User + Manual.)EP( + + + )0 P(In this section we will discuss the most commonly used versions of + the parsing func)HY(tions)YH(. For a compre)HY(hen)HY(sive)YH( descrip)HY(tion)YH( of parsing + refer to )R17 2 A(Chapter + 3, "Parsing")EA( in the C++/Tree Mapping User Manual. For the )SM(people)ES( + global element from our person record vocab)HY(u)HY(lary)YH(, we will concen)HY(trate)YH( + on the follow)HY(ing)YH( three parsing func)HY(tions)YH(:)EP( + + ) 15 71 PR(std::[unique|auto]_ptr +people \201const std::string& uri, + xml_schema::flags f = 0, + const xml_schema::properties& p = xml_schema::properties \201\202\202; + +std::[unique|auto]_ptr +people \201std::istream& is, + xml_schema::flags f = 0, + const xml_schema::properties& p = xml_schema::properties \201\202\202; + +std::[unique|auto]_ptr +people \201std::istream& is, + const std::string& resource_id, + xml_schema::flags f = 0, + const xml_schema::properties& p = ::xml_schema::properties \201\202\202;)RP( + + )0 P(The first func)HY(tion)YH( parses a local file or a URI. We have already + used this parsing func)HY(tion)YH( in the previ)HY(ous)YH( chap)HY(ters)YH(. The second + and third func)HY(tions)YH( read XML from a stan)HY(dard)YH( input stream. The + last func)HY(tion)YH( also requires a resource id. This id is used to + iden)HY(tify)YH( the XML docu)HY(ment)YH( being parser in diag)HY(nos)HY(tics)YH( messages + as well as to resolve rela)HY(tive)YH( paths to other docu)HY(ments)YH( \201for example, + schemas\202 that might be refer)HY(enced)YH( from the XML docu)HY(ment)YH(.)EP( + + )0 P(The last two argu)HY(ments)YH( to all three parsing func)HY(tions)YH( are parsing + flags and prop)HY(er)HY(ties)YH(. The flags argu)HY(ment)YH( provides a number of ways + to fine-tune the parsing process. The prop)HY(er)HY(ties)YH( argu)HY(ment)YH( allows + to pass addi)HY(tional)YH( infor)HY(ma)HY(tion)YH( to the parsing func)HY(tions)YH(. We will + use these two argu)HY(ments)YH( in )0 39 1 A(Section 5.1, "XML Schema + Vali)HY(da)HY(tion)YH( and Search)HY(ing)YH(")39 0 TN TL()Ec /AF f D( below. All three func)HY(tions)YH( return + the object model as either )SM(std::unique_ptr)ES( \201C++11\202 or + )SM(std::auto_ptr)ES( \201C++98\202, depend)HY(ing)YH( on the C++ stan)HY(dard)YH( + selected \201)SM(--std)ES( XSD compiler option\202. The follow)HY(ing)YH( + example shows how we can use the above parsing func)HY(tions)YH(:)EP( + + ) 17 67 PR(using std::unique_ptr; + +// Parse a local file or URI. +// +unique_ptr p1 \201people \201"people.xml"\202\202; +unique_ptr p2 \201people \201"http://example.com/people.xml"\202\202; + +// Parse a local file via ifstream. +// +std::ifstream ifs \201"people.xml"\202; +unique_ptr p3 \201people \201ifs, "people.xml"\202\202; + +// Parse an XML string. +// +std::string str \201"..."\202; // XML in a string. +std::istringstream iss \201str\202; +unique_ptr p4 \201people \201iss\202\202;)RP( + + + )0 2 27 H(5.1)WB 67 Sn()WB 31 Sn( XML Schema Vali)HY(da)HY(tion)YH( and Search)HY(ing)YH()EA()EH( + + )0 P(The C++/Tree mapping relies on the under)HY(ly)HY(ing)YH( Xerces-C++ XML + parser for full XML docu)HY(ment)YH( vali)HY(da)HY(tion)YH(. The XML Schema + vali)HY(da)HY(tion)YH( is enabled by default and can be disabled by + passing the )SM(xml_schema::flags::dont_vali)HY(date)YH()ES( + flag to the parsing func)HY(tions)YH(, for example:)EP( + + ) 2 59 PR(unique_ptr p \201 + people \201"people.xml", xml_schema::flags::dont_validate\202\202;)RP( + + )0 P(Even when XML Schema vali)HY(da)HY(tion)YH( is disabled, the gener)HY(ated)YH( + code still performs a number of checks to prevent + construc)HY(tion)YH( of an incon)HY(sis)HY(tent)YH( object model \201for example, an + object model with missing required attributes or elements\202.)EP( + + )0 P(When XML Schema vali)HY(da)HY(tion)YH( is enabled, the XML parser needs + to locate a schema to vali)HY(date)YH( against. There are several + methods to provide the schema loca)HY(tion)YH( infor)HY(ma)HY(tion)YH( to the + parser. The easiest and most commonly used method is to + specify schema loca)HY(tions)YH( in the XML docu)HY(ment)YH( itself + with the )SM(schemaLo)HY(ca)HY(tion)YH()ES( or + )SM(noNames)HY(paceSchemaLo)HY(ca)HY(tion)YH()ES( attributes, for example:)EP( + + ) 4 74 PR( +)RP( + + )0 P(As you might have noticed, we used this method in all the sample XML + docu)HY(ments)YH( presented in this guide up until now. Note that the + schema loca)HY(tions)YH( spec)HY(i)HY(fied)YH( with these two attributes are rela)HY(tive)YH( + to the docu)HY(ment)YH('s path unless they are abso)HY(lute)YH( URIs \201that is + start with )SM(http://)ES(, )SM(file://)ES(, etc.\202. + In partic)HY(u)HY(lar)YH(, if you specify just file names as your schema + loca)HY(tions)YH(, as we did above, then the schemas should reside in + the same direc)HY(tory)YH( as the XML docu)HY(ment)YH( itself.)EP( + + )0 P(Another method of provid)HY(ing)YH( the schema loca)HY(tion)YH( infor)HY(ma)HY(tion)YH( + is via the )SM(xml_schema::prop)HY(er)HY(ties)YH()ES( argu)HY(ment)YH(, as + shown in the follow)HY(ing)YH( example:)EP( + + ) 5 74 PR(xml_schema::properties props; +props.no_namespace_schema_location \201"people.xsd"\202; +props.schema_location \201"http://www.w3.org/XML/1998/namespace", "xml.xsd"\202; + +unique_ptr p \201people \201"people.xml", 0, props\202\202;)RP( + + )0 P(The schema loca)HY(tions)YH( provided with this method over)HY(rides)YH( + those spec)HY(i)HY(fied)YH( in the XML docu)HY(ment)YH(. As with the previ)HY(ous)YH( + method, the schema loca)HY(tions)YH( spec)HY(i)HY(fied)YH( this way are + rela)HY(tive)YH( to the docu)HY(ment)YH('s path unless they are abso)HY(lute)YH( URIs. + In partic)HY(u)HY(lar)YH(, if you want to use local schemas that are + not related to the docu)HY(ment)YH( being parsed, then you will + need to use the )SM(file://)ES( URI. The follow)HY(ing)YH( + example shows how to use schemas that reside in the current + working direc)HY(tory)YH(:)EP( + + ) 19 57 PR(#include // getcwd +#include // PATH_MAX + +char cwd[PATH_MAX]; +if \201getcwd \201cwd, PATH_MAX\202 == 0\202 +{ + // Buffer too small? +} + +xml_schema::properties props; + +props.no_namespace_schema_location \201 + "file:///" + std::string \201cwd\202 + "/people.xsd"\202; + +props.schema_location \201 + "http://www.w3.org/XML/1998/namespace", + "file:///" + std::string \201cwd\202 + "/xml.xsd"\202; + +unique_ptr p \201people \201"people.xml", 0, props\202\202;)RP( + + )0 P(A third method is the most useful if you are plan)HY(ning)YH( to parse + several XML docu)HY(ments)YH( of the same vocab)HY(u)HY(lary)YH(. In that case + it may be bene)HY(fi)HY(cial)YH( to pre-parse and cache the schemas in + the XML parser which can then be used to parse all docu)HY(ments)YH( + without re-parsing the schemas. For more infor)HY(ma)HY(tion)YH( on + this method refer to the )SM(caching)ES( example in the + )SM(cxx/tree/)ES( direc)HY(tory)YH( in the + )R5 2 A(xsd-exam)HY(ples)YH()EA( package. + It is also possi)HY(ble)YH( to convert the schemas into a pre-compiled + binary repre)HY(sen)HY(ta)HY(tion)YH( and embed this repre)HY(sen)HY(ta)HY(tion)YH( directly into + the appli)HY(ca)HY(tion)YH( executable. With this approach your appli)HY(ca)HY(tion)YH( can + perform XML Schema vali)HY(da)HY(tion)YH( without depend)HY(ing)YH( on any exter)HY(nal)YH( + schema files. For more infor)HY(ma)HY(tion)YH( on how to achieve this refer to + the )SM(embed)HY(ded)YH()ES( example in the )SM(cxx/tree/)ES( + direc)HY(tory)YH( in the )R5 2 A(xsd-exam)HY(ples)YH()EA( + package.)EP( + + )0 P(When the XML parser cannot locate a schema for the + XML docu)HY(ment)YH(, the vali)HY(da)HY(tion)YH( fails and XML docu)HY(ment)YH( + elements and attributes for which schema defi)HY(ni)HY(tions)YH( could + not be located are reported in the diag)HY(nos)HY(tics)YH(. For + example, if we remove the )SM(noNames)HY(paceSchemaLo)HY(ca)HY(tion)YH()ES( + attribute in )SM(people.xml)ES( from the previ)HY(ous)YH( chapter, + then we will get the follow)HY(ing)YH( diag)HY(nos)HY(tics)YH( if we try to parse + this file with vali)HY(da)HY(tion)YH( enabled:)EP( + + ) 8 74 PR(people.xml:2:63 error: no declaration found for element 'people' +people.xml:4:18 error: no declaration found for element 'person' +people.xml:4:18 error: attribute 'id' is not declared for element 'person' +people.xml:5:17 error: no declaration found for element 'first-name' +people.xml:6:18 error: no declaration found for element 'middle-name' +people.xml:7:16 error: no declaration found for element 'last-name' +people.xml:8:13 error: no declaration found for element 'gender' +people.xml:9:10 error: no declaration found for element 'age')RP( + + )0 2 28 H(5.2)WB 68 Sn()WB 32 Sn( Error Handling)EA()EH( + + )0 P(The parsing func)HY(tions)YH( offer a number of ways to handle error condi)HY(tions)YH( + with the C++ excep)HY(tions)YH( being the most commonly used mech)HY(a)HY(nism)YH(. All + C++/Tree excep)HY(tions)YH( derive from common base )SM(xml_schema::excep)HY(tion)YH()ES( + which in turn derives from )SM(std::excep)HY(tion)YH()ES(. The easiest + way to uniformly handle all possi)HY(ble)YH( C++/Tree excep)HY(tions)YH( and print + detailed infor)HY(ma)HY(tion)YH( about the error is to catch and print + )SM(xml_schema::excep)HY(tion)YH()ES(, as shown in the follow)HY(ing)YH( + example:)EP( + + ) 8 49 PR(try +{ + unique_ptr p \201people \201"people.xml"\202\202; +} +catch \201const xml_schema::exception& e\202 +{ + cerr << e << endl; +})RP( + + )0 P(Each indi)HY(vid)HY(ual)YH( C++/Tree excep)HY(tion)YH( also allows you to obtain + error details program)HY(mat)HY(i)HY(cally)YH(. For example, the + )SM(xml_schema::parsing)ES( excep)HY(tion)YH( is thrown when + the XML parsing and vali)HY(da)HY(tion)YH( in the under)HY(ly)HY(ing)YH( XML parser + fails. It encap)HY(su)HY(lates)YH( various diag)HY(nos)HY(tics)YH( infor)HY(ma)HY(tion)YH( + such as the file name, line and column numbers, as well as the + error or warning message for each entry. For more infor)HY(ma)HY(tion)YH( + about this and other excep)HY(tions)YH( that can be thrown during + parsing, refer to + )R18 2 A(Section + 3.3, "Error Handling")EA( in the C++/Tree Mapping + User Manual.)EP( + + )0 P(Note that if you are parsing )SM(std::istream)ES( on which + excep)HY(tions)YH( are not enabled, then you will need to check the + stream state after the call to the parsing func)HY(tion)YH( in order + to detect any possi)HY(ble)YH( stream fail)HY(ures)YH(, for example:)EP( + + ) 15 52 PR(std::ifstream ifs \201"people.xml"\202; + +if \201ifs.fail \201\202\202 +{ + cerr << "people.xml: unable to open" << endl; + return 1; +} + +unique_ptr p \201people \201ifs, "people.xml"\202\202; + +if \201ifs.fail \201\202\202 +{ + cerr << "people.xml: read error" << endl; + return 1; +})RP( + + )0 P(The above example can be rewrit)HY(ten)YH( to use excep)HY(tions)YH( as + shown below:)EP( + + ) 13 66 PR(try +{ + std::ifstream ifs; + ifs.exceptions \201std::ifstream::badbit | std::ifstream::failbit\202; + ifs.open \201"people.xml"\202; + + unique_ptr p \201people \201ifs, "people.xml"\202\202; +} +catch \201const std::ifstream::failure&\202 +{ + cerr << "people.xml: unable to open or read error" << endl; + return 1; +})RP( + + + + + + )0 1 29 H(6)WB 69 Sn()WB 33 Sn( Seri)HY(al)HY(iza)HY(tion)YH()EA()EH( + + )0 P(We have already seen how to seri)HY(al)HY(ize)YH( an object model back to XML + in this guide before. In this chapter we will discuss the + seri)HY(al)HY(iza)HY(tion)YH( topic in more detail.)EP( + + )0 P(By default, the C++/Tree mapping provides a total of 8 over)HY(loaded)YH( + seri)HY(al)HY(iza)HY(tion)YH( func)HY(tions)YH(. They differ in the output methods used to write + XML as well as the error report)HY(ing)YH( mech)HY(a)HY(nisms)YH(. It is also possi)HY(ble)YH( to + gener)HY(ate)YH( types for root elements instead of parsing and seri)HY(al)HY(iza)HY(tion)YH( + func)HY(tions)YH(. This may be useful if your XML vocab)HY(u)HY(lary)YH( has multi)HY(ple)YH( + root elements. For more infor)HY(ma)HY(tion)YH( on element types refer to + )R16 2 A(Section + 2.9, "Mapping for Global Elements")EA( in the C++/Tree Mapping User + Manual.)EP( + + + )0 P(In this section we will discuss the most commonly + used version of seri)HY(al)HY(iza)HY(tion)YH( func)HY(tions)YH(. For a compre)HY(hen)HY(sive)YH( descrip)HY(tion)YH( + of seri)HY(al)HY(iza)HY(tion)YH( refer to + )R19 2 A(Chapter + 4, "Seri)HY(al)HY(iza)HY(tion)YH(")EA( in the C++/Tree Mapping User Manual. For the + )SM(people)ES( global element from our person record vocab)HY(u)HY(lary)YH(, + we will concen)HY(trate)YH( on the follow)HY(ing)YH( seri)HY(al)HY(iza)HY(tion)YH( func)HY(tion)YH(:)EP( + + ) 7 50 PR(void +people \201std::ostream& os, + const people_t& x, + const xml_schema::namespace_infomap& map = + xml_schema::namespace_infomap \201\202, + const std::string& encoding = "UTF-8", + xml_schema::flags f = 0\202;)RP( + + )0 P(This func)HY(tion)YH( seri)HY(al)HY(izes)YH( the object model passed as the second + argu)HY(ment)YH( to the stan)HY(dard)YH( output stream passed as the first + argu)HY(ment)YH(. The third argu)HY(ment)YH( is a names)HY(pace)YH( infor)HY(ma)HY(tion)YH( map + which we will discuss in more detail in the next section. + The fourth argu)HY(ment)YH( is a char)HY(ac)HY(ter)YH( encod)HY(ing)YH( that the result)HY(ing)YH( + XML docu)HY(ment)YH( should be in. Possi)HY(ble)YH( valid values for this + argu)HY(ment)YH( are "US-ASCII", "ISO8859-1", "UTF-8", "UTF-16BE", + "UTF-16LE", "UCS-4BE", and "UCS-4LE". Finally, the flags + argu)HY(ment)YH( allows fine-tuning of the seri)HY(al)HY(iza)HY(tion)YH( process. + The follow)HY(ing)YH( example shows how we can use the above seri)HY(al)HY(iza)HY(tion)YH( + func)HY(tion)YH(:)EP( + + ) 19 34 PR(people_t& p = ... + +xml_schema::namespace_infomap map; +map[""].schema = "people.xsd"; + +// Serialize to stdout. +// +people \201std::cout, p, map\202; + +// Serialize to a file. +// +std::ofstream ofs \201"people.xml"\202; +people \201ofs, p, map\202; + +// Serialize to a string. +// +std::ostringstream oss; +people \201oss, p, map\202; +std::string xml \201oss.str \201\202\202;)RP( + + + )0 2 30 H(6.1)WB 70 Sn()WB 34 Sn( Names)HY(pace)YH( and Schema Infor)HY(ma)HY(tion)YH()EA()EH( + + )0 P(While XML seri)HY(al)HY(iza)HY(tion)YH( can be done just from the object + model alone, it is often desir)HY(able)YH( to assign mean)HY(ing)HY(ful)YH( + prefixes to XML names)HY(paces)YH( used in the vocab)HY(u)HY(lary)YH( as + well as to provide the schema loca)HY(tion)YH( infor)HY(ma)HY(tion)YH(. + This is accom)HY(plished)YH( by passing the names)HY(pace)YH( infor)HY(ma)HY(tion)YH( + map to the seri)HY(al)HY(iza)HY(tion)YH( func)HY(tion)YH(. The key in this map is + a names)HY(pace)YH( prefix that should be assigned to an XML names)HY(pace)YH( + spec)HY(i)HY(fied)YH( in the )SM(name)ES( vari)HY(able)YH( of the + map value. You can also assign an optional schema loca)HY(tion)YH( for + this names)HY(pace)YH( in the )SM(schema)ES( vari)HY(able)YH(. Based + on each key-value entry in this map, the seri)HY(al)HY(iza)HY(tion)YH( + func)HY(tion)YH( adds two attributes to the result)HY(ing)YH( XML docu)HY(ment)YH(: + the names)HY(pace)YH(-prefix mapping attribute and schema loca)HY(tion)YH( + attribute. The empty prefix indi)HY(cates)YH( that the names)HY(pace)YH( + should be mapped without a prefix. For example, the follow)HY(ing)YH( + map:)EP( + + ) 7 55 PR(xml_schema::namespace_infomap map; + +map[""].name = "http://www.example.com/example"; +map[""].schema = "example.xsd"; + +map["x"].name = "http://www.w3.org/XML/1998/namespace"; +map["x"].schema = "xml.xsd";)RP( + + )0 P(Results in the follow)HY(ing)YH( XML docu)HY(ment)YH(:)EP( + + ) 7 68 PR( +)RP( + + )0 P(The empty names)HY(pace)YH( indi)HY(cates)YH( that the vocab)HY(u)HY(lary)YH( has no target + names)HY(pace)YH(. For example, the follow)HY(ing)YH( map results in only the + )SM(noNames)HY(paceSchemaLo)HY(ca)HY(tion)YH()ES( attribute being added:)EP( + + ) 4 34 PR(xml_schema::namespace_infomap map; + +map[""].name = ""; +map[""].schema = "example.xsd";)RP( + + )0 2 31 H(6.2)WB 71 Sn()WB 35 Sn( Error Handling)EA()EH( + + )0 P(Similar to the parsing func)HY(tions)YH(, the seri)HY(al)HY(iza)HY(tion)YH( func)HY(tions)YH( offer a + number of ways to handle error condi)HY(tions)YH( with the C++ excep)HY(tions)YH( being + the most commonly used mech)HY(a)HY(nisms)YH(. As with parsing, the easiest way to + uniformly handle all possi)HY(ble)YH( seri)HY(al)HY(iza)HY(tion)YH( excep)HY(tions)YH( and print + detailed infor)HY(ma)HY(tion)YH( about the error is to catch and print + )SM(xml_schema::excep)HY(tion)YH()ES(:)EP( + + ) 13 38 PR(try +{ + people_t& p = ... + + xml_schema::namespace_infomap map; + map[""].schema = "people.xsd"; + + people \201std::cout, p, map\202\202; +} +catch \201const xml_schema::exception& e\202 +{ + cerr << e << endl; +})RP( + + )0 P(The most commonly encoun)HY(tered)YH( seri)HY(al)HY(iza)HY(tion)YH( excep)HY(tion)YH( is + )SM(xml_schema::seri)HY(al)HY(iza)HY(tion)YH()ES(. It is thrown + when the XML seri)HY(al)HY(iza)HY(tion)YH( in the under)HY(ly)HY(ing)YH( XML writer + fails. It encap)HY(su)HY(lates)YH( various diag)HY(nos)HY(tics)YH( infor)HY(ma)HY(tion)YH( + such as the file name, line and column numbers, as well as the + error or warning message for each entry. For more infor)HY(ma)HY(tion)YH( + about this and other excep)HY(tions)YH( that can be thrown during + seri)HY(al)HY(iza)HY(tion)YH(, refer to + )R20 2 A(Section + 4.4, "Error Handling")EA( in the C++/Tree Mapping + User Manual.)EP( + + )0 P(Note that if you are seri)HY(al)HY(iz)HY(ing)YH( to )SM(std::ostream)ES( on + which excep)HY(tions)YH( are not enabled, then you will need to check the + stream state after the call to the seri)HY(al)HY(iza)HY(tion)YH( func)HY(tion)YH( in order + to detect any possi)HY(ble)YH( stream fail)HY(ures)YH(, for example:)EP( + + ) 15 47 PR(std::ofstream ofs \201"people.xml"\202; + +if \201ofs.fail \201\202\202 +{ + cerr << "people.xml: unable to open" << endl; + return 1; +} + +people \201ofs, p, map\202\202; + +if \201ofs.fail \201\202\202 +{ + cerr << "people.xml: write error" << endl; + return 1; +})RP( + + )0 P(The above example can be rewrit)HY(ten)YH( to use excep)HY(tions)YH( as + shown below:)EP( + + ) 13 66 PR(try +{ + std::ofstream ofs; + ofs.exceptions \201std::ofstream::badbit | std::ofstream::failbit\202; + ofs.open \201"people.xml"\202; + + people \201ofs, p, map\202\202; +} +catch \201const std::ofstream::failure&\202 +{ + cerr << "people.xml: unable to open or write error" << endl; + return 1; +})RP( + + )BR( +)BR( + +)WB NL +/TE t D NP /OU t D TU PM 1 eq and{/Pn () D showpage}if end restore diff --git a/doc/pregenerated/cxx/tree/manual/cxx-tree-manual.pdf b/doc/pregenerated/cxx/tree/manual/cxx-tree-manual.pdf new file mode 100644 index 0000000..b8e55a7 Binary files /dev/null and b/doc/pregenerated/cxx/tree/manual/cxx-tree-manual.pdf differ diff --git a/doc/pregenerated/cxx/tree/manual/cxx-tree-manual.ps b/doc/pregenerated/cxx/tree/manual/cxx-tree-manual.ps new file mode 100644 index 0000000..7c32dea --- /dev/null +++ b/doc/pregenerated/cxx/tree/manual/cxx-tree-manual.ps @@ -0,0 +1,7387 @@ +%!PS +%%Title: C++/Tree Mapping User Manual +%%Creator: html2ps version 1.0 beta7 +%%EndComments +save +2000 dict begin +/d {bind def} bind def +/D {def} d +/t true D +/f false D +/FL [/Times-Roman +/Times-Italic +/Times-Bold +/Times-BoldItalic +/Courier +/Courier-Oblique +/Courier-Bold +/Courier-BoldOblique +/Helvetica +/Helvetica-Oblique +/Helvetica-Bold +/Helvetica-BoldOblique] D +/WF t D +/WI 0 D +/F 1 D +/IW 471 F div D +/IL 621 F div D +/PS 791 D +/EF [0 1 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 2 2] D +/EZ [12 10 19 17 15 13 12 11 12 12 12 12 12 12 12 12 12 12 12 12 12 12 8 8] D +/Ey [0 0 2 2 2 2 2 2 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0] D +/EG [-1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1] D +/Tm [1 1 0.8 0.8 0.8 0.8 0.8 0.8 0 0 0 0 0 0 0.5 1 1 1 1 0 0 1.3 0 0] D +/Bm [1 1 0.5 0.5 0.5 0.5 0.5 0.5 0 0 0 0 0 0 0.5 1 1 1 1 0 0 1 0 0] D +/Lm [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 2 2 0 0 2 0 0 0] D +/Rm [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0] D +/EU [-1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 0 0] D +/NO f D +/YY [[{()}{ h }][{ h }{()}][{()}{()}]] D +/ZZ [[{ (September 2023) }{ Pn }][{ Pn }{ (September 2023) }][{ Ti(, v)join ME 0 get join }{ Ti(, v)join ME 0 get join }]] D +/Ts EZ 0 get D +/TU f D +/Xp t D +/AU f D +/SN 0 D +/Cf t D +/Tp t D +/Fe f D +/TI 2 Ts mul D +/Fm 14 D +/xL 71 D +/xR 71 D +/yL 706 D +/yR 706 D +/Wl 471 F div D +/Wr 471 F div D +/hL 621 F div D +/hR 621 F div D +/FE {newpath Fm neg Fm M CP BB IW Fm add Fm L IW Fm add IL Fm add neg L CP BB + Fm neg IL Fm add neg L closepath} D +/LA {PM 0 eq{/IW Wl D /IL hL D}{/IW Wr D /IL hR D}ie /W IW D /LL W D /LS W D + TU PM 0 eq and{IW 56 F div add SA{Sf div}if 0 translate} + {PM 0 eq{xL yL}{xR yR}ie translate F SA{Sf mul}if dup scale + CS CF FS Cf{CA CL get VC}if /Bb f D}ie 0 0 M + TF not Tc or {Cf{gsave SA{1 Sf div dup scale}if Cb VC FE fill grestore}if}if}D +/Pi 0 Ts mul D +/SG [0.8 1 1] D +/Ab 15 D +/J 0 D +/Tc t D +/NH 6 D +/Nf f D +/Pa f D +/LH 1.2 D +/XR f D +/Xr {/pN E D ( [p ) WB pN WB (] )WB} D +/Db [16#FF 16#FF 16#FF] D +/Dt [16#00 16#00 16#00] D +/eA f D +/Fi f D +/bT f D +/Lc t D +/Dl [16#00 16#00 16#00] D +/LX f D +/Br 0.25 D +/IA ([IMAGE]) D +/DS {/PF f D()WB NL NP()pop RC ZF} D +/Gb f D +/Mb t D +/Hc [16#00 16#00 16#00] D +/Bl 3 D +/MI -15.6 D +/DX (DRAFT) D +/Di 0 D +/Tt 113.385826771654 D +/Th { ( +) 2 Al()BR ( + ) 0 1 -1 H()4 FZ (C++/Tree Mapping User Manual) ES()EH ( + ) 0 1 -1 H ( ) EH ( + ) 0 1 -1 H ( ) EH ( + ) 0 1 -1 H ( ) EH ( + ) 0 1 -1 H ( ) EH ( + ) 0 1 -1 H ( ) EH ( + ) 0 1 -1 H ( ) EH ( + ) 0 1 -1 H ( ) EH ( +) Ea()BR ( + ) 0 P (Revision ) ME 0 get join(     September 2023)join EP ( + ) 0 P (Copyright © 2005-2023 Code Synthesis.) EP ( + + ) 0 P (Permission is granted to copy, distribute and/or modify this + document under the terms of the + ) R0 2 A (GNU Free + Documentation License, version 1.2) EA (; with no Invariant Sections, + no Front-Cover Texts and no Back-Cover Texts. + ) EP ( + + ) 0 P (This document is available in the following formats: + ) R1 2 A (XHTML) EA (, + ) R2 2 A (PDF) EA (, and + ) R3 2 A (PostScript) EA (.) EP()} D +/tH {()0 1 -1 H (Table of Contents) EH()} D +/FD 2 D +/Dy 2 D +/cD [16#F0 16#F0 16#F0] D +/FW 0.6 D +/FU [16#00 16#00 16#00] D +/ET {/RM f D /A0 3 D /PN SN D /OU t D /Ou t D /W IW D /LL W D D1 + Ms not TP and{Ip}if /TF f D} D + +%-- End of variable part -- +/MySymbol 10 dict dup begin + /FontType 3 D /FontMatrix [.001 0 0 .001 0 0 ] D /FontBBox [25 -10 600 600] D + /Encoding 256 array D 0 1 255{Encoding exch /.notdef put}for + Encoding (e) 0 get /euro put + /Metrics 2 dict D Metrics begin + /.notdef 0 D + /euro 651 D + end + /BBox 2 dict D BBox begin + /.notdef [0 0 0 0] D + /euro [25 -10 600 600] D + end + /CharacterDefs 2 dict D CharacterDefs begin + /.notdef {} D + /euro{newpath 114 600 moveto 631 600 lineto 464 200 lineto 573 200 lineto + 573 0 lineto -94 0 lineto 31 300 lineto -10 300 lineto closepath clip + 50 setlinewidth newpath 656 300 moveto 381 300 275 0 360 arc stroke + -19 350 moveto 600 0 rlineto -19 250 moveto 600 0 rlineto stroke}d + end + /BuildChar{0 begin + /char E D /fontdict E D /charname fontdict /Encoding get char get D + fontdict begin + Metrics charname get 0 BBox charname get aload pop setcachedevice + CharacterDefs charname get exec + end + end}D + /BuildChar load 0 3 dict put /UniqueID 1 D +end +definefont pop + +/Cd {aload length 2 idiv dup dict begin {D} repeat currentdict end} D +/EX {EC cvx exec} D +/DU {} d +/BB {pop pop}d +/ie {ifelse} d +/E {exch} d +/M {moveto} d +/R {rmoveto} d +/L {lineto} d +/RL {rlineto} d +/CP {currentpoint} d +/SW {stringwidth} d +/GI {getinterval} d +/PI {putinterval} d +/Sg {setgray} d +/LW {setlinewidth} d +/S {dup () ne OU and{0 Co R AT 3 eq LB and HF not and A1 0 ne A2 0 ne or and + {A2 0 32 A1 0 6 -1 roll awidthshow}{show}ie 0 Co neg R}{pop}ie + OU PH 3 eq or{/Ms t D}if} D +/U {OU{gsave CP currentfont /FontInfo get /UnderlinePosition get + 0 E currentfont /FontMatrix get dtransform E pop add newpath M dup SW pop + CJ 0 RL stroke grestore}if} D +/B {OU Br 0 gt and{CP Ts neg Ts .33 mul R gsave 0 Sg + CP newpath Ts Br mul 0 360 arc closepath UI 2 mod 0 eq{stroke}{fill}ie + grestore M CP E Ts Br 1 add mul sub E BB /Ms t D}if}D +/NP {Ms TP not or PA and OU and{TP{OR}if f1{mF k2 /mF E D /YC 0 D}if + TP TU not PM 0 eq or and{showpage}if DU Ip TE not{LA}if 0.6 LW + /CI 0 D /TP t D /Hs f D /hl 6 D /Hv 6 D /HI hi D /Ms f D}if Bs XO BO M} D +/Np {LE sub CP E pop gt PL 0 eq and{NP}if}D +/Ip {/PN PN 1 add D /Pn RM{1}{4}ie PN Ns D /PM PN SN sub 2 mod D} D +/GP {E dup 3 -1 roll get PN 1 add 2 mod get dup type /integertype eq + {get 0 get}{E pop}ie}d +/Fc {dup 2 GP exec SW pop /S1 E D dup 1 GP exec SW pop /S2 E D 0 GP exec SW + pop /S3 E D S1 0 gt{S2 2 mul S1 add S3 2 mul S1 add 2 copy lt{E}if pop}{0}ie + S2 S3 add 2 copy lt{E}if pop IW .9 mul div dup 1 gt{1 E div}{pop 1}ie}D +/OR {Df{Sd}if tp not{gsave SA{1 Sf div dup scale}if Fe{Cf{FU VC}if FW LW + 1 setlinejoin FE stroke}if /YO {60 F div dup 40 gt{pop 40}if}D /cs CS D + /cf CF D /CF 0 D /pf PF D /PF f D /Fn FN D /At AT D /AT 0 D /FN EF Hf 1 add + get D Fz Fs FS ZZ Fc Fz mul Fs FS EU Hf 1 add get dup type /arraytype eq + Cf and{VC}{pop 0 Sg}ie IW IL neg YO sub M ZZ 1 GP exec dup SW pop neg 0 R Sh + 0 IL neg YO sub M ZZ 0 GP exec Sh ZZ 2 GP exec dup SW pop IW E sub 2 div + IL neg YO sub M Sh Fz Fs FS NO{/AW IW Pn SW pop sub D AW 2 div IL neg YO sub + S1 0 gt S2 AW .45 mul gt or S3 AW .45 mul gt or{Fz 2 mul sub}if M Pn Sh}if + EU Hf get dup type /arraytype eq Cf and{VC}{pop 0 Sg}ie YY Fc /FN EF Hf get D + Hz mul HS FS IW YO M YY 1 GP exec dup SW pop neg 0 R Sh 0 YO M YY 0 GP exec Sh + YY 2 GP exec dup SW pop IW E sub 2 div YO M Sh /FN Fn D /AT At D t Pb XO SZ + SL get neg R /PF pf D grestore /CF 0 D cs cf FS}if}D +/Sh {dup () ne{CP Hz 4 div sub BB show CP CS add BB}{pop}ie}D +/Pb {/OU E D /Ou OU D /PB t D 0 0 M Ba{/Sa save D /BP t D /Fl t D RC /PL 0 D + /PH 0 D /W IW D /LE IL .7 mul D /EO 0 D SI ZF /YA 0 D /BO 0 D /C1 () D + BA 0 Ts neg R Bb{Xl Yl Xh Yh}if Bb CP Sa restore M + {/Yh E D /Xh E D /Yl E D /Xl E D}if /Fl t D}if + BL /OU t D /HM f D /Ou t D /PB f D} D +/Bs {/BP Ba not D}D +/reencodeISO { + dup dup findfont dup length dict begin{1 index /FID ne{D}{pop pop}ie}forall + /Encoding ISOLatin1Encoding D currentdict end definefont} D +/ISOLatin1Encoding [ +/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef +/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef +/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef +/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef +/space/exclam/quotedbl/numbersign/dollar/percent/ampersand/quoteright +/parenleft/parenright/asterisk/plus/comma/hyphen/period/slash +/zero/one/two/three/four/five/six/seven/eight/nine/colon/semicolon +/less/equal/greater/question/at/A/B/C/D/E/F/G/H/I/J/K/L/M/N +/O/P/Q/R/S/T/U/V/W/X/Y/Z/bracketleft/backslash/bracketright +/asciicircum/underscore/quoteleft/a/b/c/d/e/f/g/h/i/j/k/l/m +/n/o/p/q/r/s/t/u/v/w/x/y/z/braceleft/bar/braceright/asciitilde +/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef +/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef +/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef +/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef +/.notdef/space/exclamdown/cent/sterling/currency/yen/brokenbar +/section/dieresis/copyright/ordfeminine/guillemotleft/logicalnot +/hyphen/registered/macron/degree/plusminus/twosuperior/threesuperior +/acute/mu/paragraph/periodcentered/cedilla/onesuperior/ordmasculine +/guillemotright/onequarter/onehalf/threequarters/questiondown +/Agrave/Aacute/Acircumflex/Atilde/Adieresis/Aring/AE/Ccedilla +/Egrave/Eacute/Ecircumflex/Edieresis/Igrave/Iacute/Icircumflex +/Idieresis/Eth/Ntilde/Ograve/Oacute/Ocircumflex/Otilde/Odieresis +/multiply/Oslash/Ugrave/Uacute/Ucircumflex/Udieresis/Yacute +/Thorn/germandbls/agrave/aacute/acircumflex/atilde/adieresis +/aring/ae/ccedilla/egrave/eacute/ecircumflex/edieresis/igrave +/iacute/icircumflex/idieresis/eth/ntilde/ograve/oacute/ocircumflex +/otilde/odieresis/divide/oslash/ugrave/uacute/ucircumflex/udieresis +/yacute/thorn/ydieresis +] D +[128/backslash 129/parenleft 130/parenright 141/circumflex 142/tilde +143/perthousand 144/dagger 145/daggerdbl 146/Ydieresis 147/scaron 148/Scaron +149/oe 150/OE 151/guilsinglleft 152/guilsinglright 153/quotesinglbase +154/quotedblbase 155/quotedblleft 156/quotedblright 157/endash 158/emdash +159/trademark] +aload length 2 idiv 1 1 3 -1 roll{pop ISOLatin1Encoding 3 1 roll put}for +/colorimage where{pop}{ + /colorimage { + pop pop /Pr E D {/Cv Pr D /Gr Cv length 3 idiv string D 0 1 Gr length 1 sub + {Gr E dup /i E 3 mul D Cv i get 0.299 mul Cv i 1 add get 0.587 mul add + Cv i 2 add get 0.114 mul add cvi put}for Gr} image} D +}ie +/pdfmark where{pop}{userdict /pdfmark /cleartomark load put}ie +WF{FL{reencodeISO D}forall}{4 1 FL length 1 sub{FL E get reencodeISO D}for}ie +/Symbol dup dup findfont dup length dict begin + {1 index /FID ne{D}{pop pop}ie}forall /Encoding [Encoding aload pop] + dup 128 /therefore put D currentdict end definefont D + +/SF {/CS E D SZ SL CS put FO SL FN put /YI CS LH neg mul D dup ST cvs ( ) join + CS ST cvs join C1 E join ( NF ) join /C1 E D CS NF /Wf WF FN 0 gt or D + /BW Wf{( ) SW pop}{0}ie D}D +/NF {/cS E D /cF E D cF 0 ge{FL cF get}{cF -1 eq{/Symbol}{/MySymbol}ie}ie + findfont cS scalefont setfont} D +/FS {CF or /CF E D FR SL CF put CF CF 0 ge{FN 4 mul add}if E SF} D +/PC {SH /BP f D fin not GL not and{NL}if /HM t D /LL LS D} D +/BS {/TX E D Wf{/fin f D /CW 0 D /LK 0 D /SC 0 D + /RT TX D {RT ( ) search{/NW E D pop /RT E D /WH NW SW pop D CW WH add LL gt + {TX SC LK SC sub 1 sub NN GI GL{SH cF cS OC + 2 copy cS ne E cF ne or{NF}{pop pop}ie}{PC /CW WH BW add D}ie + /SC LK D} + {GL{JC}if + /CW CW WH add BW add D /HM t D}ie /GL f D /Ph f D + /LK LK NW length 1 add add D}{pop exit}ie}loop + /fin t D TX SC LK SC sub GI SH RT () ne{GL not{CC}if}if + /LC TX length D /WH RT SW pop D CW WH add Hy{HC SW pop add}if LL gt + {RT GL{SH cF cS OC 2 copy cS ne E cF ne or{NF}{pop pop}ie + Hy{/Ph t D}if /LL LS D}{NL /LL LS D SH}ie} + {RT PC Hy{CC}if /Ph Ph Hy or D}ie RT () ne{/GL t D /HM t D}if} + {TX SW pop LL le{TX SH}{/NW () D 0 2 TX length 1 sub + {/CW E D TX 0 CW GI dup SW pop LL gt{pop NW SH /HM t D NL/LL W XO sub MR sub D + /CW CW 2 sub NN D /TX TX CW TX length CW sub GI D TX BS exit} + {/NW E D}ie}for}ie}ie /HM t D}D +/CC {C0 length 0 gt{JC}if /C0 [C1 L1 YA YB Mf NS NB TB AF Bw] D + /C1 () D /L0 L1 D /YA 0 D /YB 0 D /Mf 0 D /NS 0 D /NB 0 D}D +/JC {C0 aload length 0 gt{pop pop pop NB add /NB E D NS add /NS E D + dup Mf gt{/Mf E D}{pop}ie dup YB gt{/YB E D}{pop}ie + dup YA gt{/YA E D}{pop}ie pop C1 join /C1 E D /C0 [] D}if}D +/OC {C0 length 0 gt{C1 L1 L0 sub YA YB Mf NS NB TB AF Bw GL C0 aload pop + /Bw E D /AF E D /TB E D /NB E D /NS E D /Mf E D /YB E D /YA E D /C0 [] D + /L1 E D /C1 E D Ph{HC SH}if NL /GL E D /Bw E D /AF E D /TB E D /NB E D /NS E D + /Mf E D /YB E D /YA E D /L1 E D /LL W L1 sub XO sub MR sub WH sub D /CW 0 D + C1 E join /C1 E D}if}D +/BT {/LB t D dup length string copy RS dup dup () ne E ( ) ne and + {/CI 0 D /LS LL D /LL W L1 sub XO sub MR sub D BS} + {dup ( ) eq{/GL f D}if dup () eq L1 0 eq or{pop}{SH /BP f D /Ph f D}ie}ie + /LB f D} D +/BL {CP E pop XO E M} D +/NL {JC /GL f D /SK W XO sub MR sub L1 sub TB{Bw add}if D + /YA LF{Mf HM Fl not and PF or{LH mul}if}{0 /LF t D}ie YA 2 copy lt{E}if pop D + C1 () ne{/FB YB Mf SA{Sf mul}if 4 div 2 copy lt{E}if pop D}if Fl{/Ya YA D}if + CP E pop YA sub YB sub LE neg lt Fl not and PB not and{NP}if NT TL BL + OU PF not and PB or{/RE L1 TB{Bw sub}if + W XO sub MR sub div YA YB add LE BO add div 2 copy lt{E}if pop D + RE 1 gt{BL 1 RE div dup scale}if}if + AT 2 le{SK AT mul 2 div YA neg R}if + AT 3 eq{0 YA neg R TB{/NB NB 1 sub D /NS NS 1 sub D}if /NB NB 1 sub NN D + /A3 NS 6 mul NB add D NS NB add 0 eq + {/A1 0 D /A2 0 D} + {NS 0 eq{/A1 SK NB div dup J gt{pop 0}if D /A2 0 D}{J A3 mul SK lt + {/A1 J D /A2 SK J NB mul sub NS div dup Ab gt{/A1 0 D pop 0}if D} + {/A1 SK A3 div D /A2 A1 6 mul D}ie}ie}ie /A1 A1 NN D /A2 A2 NN D}if + AT 4 eq{0 YA neg R PH 2 le{PD 0 lt{/PD L1 D}if PD M1 gt{/M1 PD D}if + L1 PD sub M2 gt{/M2 L1 PD sub D}if}{DV ID 1 sub get 0 ge{Lo 0 R}if}ie}if + F0 cF ne Cs cS ne or{F0 Cs NF}if + /ms Ms D /Ms f D CP FB sub + C1 cvx exec XO EO sub L1 add TB{BW sub}if dup LM gt{/LM E D}{pop}ie + PH 0 eq PH 4 eq or Ms and{HF not{/PO t D /AH t D}if + BB CP YA add E AT 3 eq LB and{A1 sub}if TB{BW sub}if E BB} + {pop pop}ie Ms HM PH 3 eq and or{/BP f D /Fl f D}if + /Lo 0 D /L1 0 D /F0 cF D /Cs cS D BP not{0 YB NN neg R}if + OU f1 and mF not and{k2 /f1 f D}if + OU PF not and PB or{RE 1 gt{RE dup scale}if}if /Ms ms Ms or D + /C1 AF{(Cp )}{()}ie D /YA 0 D /YB 0 D BL + AT 4 eq LB not and PH 3 ge and + {ID DV length lt{DV ID get dup 0 ge{DO E sub /Lo E D /L1 Lo D}{pop}ie + /ID ID 1 add D}if}if /T t D CD{/LN LN 1 add D PD}if + /PD -1 D /NS 0 D /NB 0 D /TB f D /Ph f D /Mf 0 D /HM f D} D +/RS {/TM E D /CN 0 D TM{10 eq{TM CN ( ) PI}if /CN CN 1 add D}forall + /CN 0 D /BK HM EN and{0}{1}ie D TM + {dup 32 ne{TM CN 3 2 roll put /CN CN 1 add D /BK 0 D} + {pop BK 0 eq{TM CN 32 put /CN CN 1 add D}if /BK 1 D}ie}forall + TM 0 CN GI dup dup () ne E ( ) ne and + {dup CN 1 sub get 32 eq{/EN f D}{/EN t D}ie}if} D +/join {2 copy length E length add string dup 4 2 roll 2 index 0 3 index + PI E length E PI}d +/WR {(\n) search{dup () ne BP not or + {Li 4 le CP E pop YI Li mul add LE add 0 lt and PL 0 eq and{NP}if + SH NL pop /Li Li 1 sub D WR}{pop pop WR}ie}{SH}ie /CI 0 D /BP f D} D +/SH {dup dup () ne E ( ) ne and PF or CS Mf gt and{/Mf CS D}if + T not Wf and{( ) E join /T t D}if dup BP{/MF CS D}if + AT 3 eq{2 copy length dup 0 gt{/NB E NB add D + {( ) search{/NS NS 1 add D pop pop}{pop exit}ie}loop}{pop pop}ie}if + CD PD 0 lt and{dup DC search{SW pop /PD E L1 add D pop pop}{pop}ie}if + 0 Np dup SW pop L1 add /L1 E D dup () ne + {C1 (\() join E join (\)) join AU AF and UF or Wf and{( U ) join}if + sF{( s ) join}if ( S ) join + /C1 E D dup length 1 sub get 32 eq /TB E D /Bw BW D}{pop pop}ie} D +/BG {AI LG BC add add 0 eq} D +/ON {OU{Ty AR AI NN get dup 1 add Ln Ns Ty 2 mod 0 eq{(. )}{(\) )}ie join + dup SW pop neg 0 R CP E 0 lt{0 E M}{pop}ie CP BB show /Ms t D}if} D +/Ln {AR AI 3 -1 roll put}D +/SP {dup CI lt BP not and{dup CI sub 0 E R /CI E D}{pop}ie} D +/BN {PF{WR /HM f D}{BT NL}ie} D +/NN {dup 0 lt{pop 0}if} D +/h {(h) HI ST cvs join cvx exec dup 1 get E Nf{0 get E join}{pop}ie} D +/H {/fn FN D /Hi E 1 add D 1 sub /HL E D /H2 HL 2 add D /GS EZ H2 get D + E Tm H2 get GS mul BE dup 0 gt{1 sub}{pop EG H2 get dup 0 lt{pop AT}if}ie NA + WW Np /SL SL 1 add D /FN EF H2 get D GS Ey H2 get FS + EU H2 get Sc Hs not HL Hl lt and Hs HL hl lt and or Hi 0 eq or + {/HI Hi D /Hs t D /hl HL D /Hv HL D}if HL Hl lt{/hi Hi D}if + Nf HI 0 gt and{(h) Hi ST cvs join cvx exec 0 get WB}if + /HF t D /AH f D /PO f D} D +/EH {Bm H2 get GS mul BE OA /SL SL 1 sub NN D /CF 0 D /FN fn D + SZ SL get FR SL get FS /HF f D /GS Ts D ()Ec} D +/P {E PF{WR}{PO{EP}{BN}ie Ts 4 mul Np AE not{Tm 0 get Ts mul neg SP}if + dup 0 ge AH and{Pi Pd}if}ie 1 sub dup 0 lt{pop AV AL get}if /AT E D /PO t D} D +/EP {PF{WR}{BN Ts 4 mul Np}ie AE not{Bm 0 get Ts mul neg SP}if + /AT AV AL get D /PO f D} D +/BE {E PO{EP}{BN}ie Ts 4 mul Np neg SP} D +/HR {/Aw W EO sub D /RW E dup 0 gt{Aw mul}{neg}ie dup Aw gt{pop Aw}if D /RZ E D + E BN Ts neg SP 1 sub 2 div Aw RW sub mul EO add CP E pop M PF{0 Ps neg R}if + 0 Np OU{gsave RZ LW Cf{Hc VC}{0 Sg}ie CP BB RW 0 RL CP BB stroke grestore}if + /CI 0 D /BP f D PF not{Ts neg SP}if /Ms t D} D +/AD {I NL EG 14 get dup 0 lt{pop AT}if NA /AE t D Tm 14 get Ts mul neg SP + Cf{EU 14 get dup -1 eq{pop CA CL get}if Sc}if} D +/DA {BN ()ES OA /AE f D ()Ec Bm 14 get Ts mul neg SP} D +/PR {/MW E D /Li E D Tm 1 get Ps mul BE 0 NA /FN Fp D /PF t D SI /SL SL 1 add D + /CF 0 D Ps CS mul Ts div MW WC mul CS mul Ts div dup LL gt PL 0 eq and + {LL div div}{pop}ie Ey 1 get FS CP E pop LE add YI neg div cvi dup Li lt + AH and{4 lt YI Li mul 5 mul LE add 0 gt or PL 0 eq and{NP}if}{pop}ie + EU 1 get Sc /GS Ps D}D +/RP {WR NL () /PF f D SI /FN 0 D ES Bm 1 get Ps mul neg SP OA /GS Ts D} D +/SI {/XO Lm 15 get BC NN mul Lm 16 get AI UI sub NN mul add + Lm 17 get UI NN mul add Lm 20 get LG NN mul add Ts mul + PF{Lm 1 get Ps mul add}if EO add D + /MR Rm 15 get BC NN mul Rm 16 get AI UI sub NN mul add + Rm 17 get UI NN mul add Rm 20 get LG NN mul add Ts mul + PF{Rm 1 get Ps mul add}if D /LL W XO sub MR sub D} D +/DT {/cC E D BN /LG LG 1 sub D SI /LG LG 1 add D WW 2 div Np BL} D +/DD {WB Cc 0 eq cC 0 eq and L1 0 eq or Lm 20 get Ts mul L1 sub TB{BW add}if + Ts 2 div lt or NL /LF E D SI BL /cC 0 D} D +/DL {Dc LG Cc put /Cc E D BG{Tm 18 get Ts mul BE}{BN}ie /LG LG 1 add D BL} D +/LD {BN LG 0 gt{/LG LG 1 sub D}if /Cc Dc LG get D SI + BG{()Bm 18 get Ts mul BE}if BL} D +/UL {BG{Tm 17 get Ts mul BE}{BN}ie NR AI NN 0 put /UI UI 1 add D + /AI AI 1 add D SI BL} D +/LU {BN /UI UI 1 sub D /AI AI 1 sub D SI BG{()Bm 17 get Ts mul BE}if BL} D +/OL {E BG{Tm 16 get Ts mul BE}{BN}ie TR AI NN Ty put /Ty E D NR AI NN 1 put + /AI AI 1 add D SI BL 1 Ln} D +/LO {BN /AI AI 1 sub D /Ty TR AI get D SI BG{()Bm 16 get Ts mul BE}if BL} D +/LI {E BN -1 SP /BP f D /CI 0 D 0 Np NR AI 1 sub NN get 1 eq + {dup dup 0 gt E 4 le and{/Ty E D}{pop}ie + /L1 L1 Ty AR AI NN get Ns SW pop XO sub dup 0 lt{pop 0}if add D ( ON )} + {pop ( B )}ie C1 E join /C1 E D CS Mf gt{/Mf CS D}if BL} D +/BQ {Tm 15 get Ts mul BE /BC BC 1 add D SI BL} D +/QB {Bm 15 get Ts mul BE /BC BC 1 sub D SI BL} D +/Al {E EP 1 sub dup 0 lt{pop AV AL get}if NA} D +/Ea {EP OA} D +/WB {PF{WR}{BT}ie} D +/F1 {WB /FN 0 D CS 0 FS} D +/F2 {WB /FN WI D CS 0 FS} D +/HY {/Hy t D WB /Hy f D} D +/YH {WB} D +/A {/LT E D LT 1 eq{/RN E D}if /Lh E D WB /C1 C1 ( Cp ) join D + Lc AF not and{Cl Sc}if /AF t D} D +/EA {Lc AF and{Ec}{WB}ie TL Pa AF and Lh 0 ne and + {( \() Lh join (\)) join /AF f D WB}if /AF f D} D +/TL {C1 ( Tl ) apa /C1 E D} d +/apa {AF OU and Lh 0 ne LT 1 eq or and{LT 1 eq{RN ( /) E ST cvs join} + {(\() Lh join (\)) join}ie E join join}{pop}ie} d +/Cp {/Xc CP /Yc E D D} D +/SS {Cf{dup 0 ge{EU E get dup -1 eq{pop CA CL get}if}{pop CA CL get}ie Sc} + {pop}ie SZ SL get /SL SL 1 add D} D +/I {WB 8 SS 1 FS} D +/EM {WB 8 SS /CF CF 1 xor D 0 FS} D +/BD {WB 9 SS 2 FS} D +/TT {WB 10 SS /FN Fp D 0 FS} D +/KB {WB 11 SS /FN Fp D 2 FS} D +/CT {WB 12 SS 1 FS} D +/SM {WB 13 SS /FN Fp D 0 FS} D +/Q {/QL QL 1 add D QO QL 2 mod get La get join WB} D +/EQ {QC QL 2 mod get La get join WB /QL QL 1 sub D} D +/RO {WB -1 SS /CF 0 D 0 FS} D +/SY {WB -1 SS -1 FS} D +/MY {WB -1 SS -2 FS} D +/ES {WB /SL SL 1 sub NN D /CF 0 D /FN FO SL get D SZ SL get FR SL get FS ()Ec}D +/FZ {3 sub 1.2 E exp GS mul E WB TL /C1 C1 ( Cp ) join D /SL SL 1 add D 0 FS} D +/Ef {WB TL ()ES /C1 C1 ( Cp ) join D} D +/BZ {dup /Bf E D FZ}D +/Sc {dup -1 ne Cf and{/CL CL 1 add D dup 0 eq{pop [0 0 0]}if + dup CA E CL E put VS ( VC ) join C1 E join /C1 E D}{pop}ie} D +/Ec {WB Cf{/CL CL 1 sub NN D CA CL get VS ( VC ) join C1 E join /C1 E D}if} D +/VS {dup type /arraytype eq{([) E {ST cvs join ( ) join}forall (]) join}if} D +/VC {{255 div}forall setrgbcolor} D +/Sl {dup type /integertype ne{Ds}if /La E D WB}d +/UN {WB /UF t D} D +/NU {WB /UF f D} D +/SE {WB /sF t D} D +/XE {WB /sF f D} D +/sM {/C1 C1 ( k1 ) join D}d +/eM {/C1 C1 ( k2 ) join D}d +/k1 {/YC CP E pop Ts add D /mF t D /f1 t D}d +/k2 {gsave 3 LW -9 CP E pop Ts 0.2 mul sub M -9 YC L stroke grestore /mF f D}d +/Ac {/AC E D WB}d +/Ca {eA{( \()join AC join(\) )join}if WB}d +/s {OU{gsave 0 CS .25 mul R dup SW pop CJ 0 RL stroke grestore}if}D +/CJ {AT 3 eq LB and{E dup dup length 1 sub A1 mul E + {( ) search{pop pop E A2 add E}{pop exit}ie}loop 3 -1 roll add + W CP pop sub 2 copy gt{E}if pop}if}D +/So {/Co E D} D +/SO {C1 Yo ST cvs join ( So ) join /C1 E D (j) SW pop 2 div Pd} D +/Se {E WB CS E div Pd}D +/Pd {dup type /stringtype eq{SW pop}if dup /L1 E L1 add D + ST cvs ( 0 R ) join C1 E join /C1 E D} D +/Sp {0.35 CO} D +/Sb {-0.2 CO} D +/CO {OV Io Yo put /Yo E CS mul Yo add D /Io Io 1 add D -1.5 Io mul 3 add FZ SO + CS Yo add dup YA gt{/YA E D}{pop}ie + Yo neg dup YB gt{/YB E D}{pop}ie} D +/Es {ES /Io Io 1 sub NN D /Yo OV Io get D SO} D +/SB {/N2 0 D 0 1 NI{/N E D{IX N2 get 0 lt{/N2 N2 1 add D}{exit}ie}loop + /K WS N get FC N get mul D /NY AY N2 get D /BV NY array D + 0 1 NY 1 sub{/TM K string D currentfile TM readhexstring pop pop BV E TM put} + for BM N BV put /N2 N2 1 add D}for} D +/IC [{/MA E D /MB 0 D}{2 div /MA E D /MB MA D}{/MB E CS sub D /MA CS D} + {pop /MA YS AB mul D /MB 1 AB sub YS mul D}{pop /MA 0 D /MB 0 D}] D +/IP {BV N get /N N 1 add D} D +/II {/K E D IX K get 0 lt{/EC E D}if /TY E D + TY 4 eq{/Y E D /X E D}if TY 3 eq{/AB E D}if + /XW AX K get D /YW AY K get D /IS SG IT K get get D /XS XW IS mul D + /YS YW IS mul D YS IC TY get exec /MA MA Fl not{3 add}if D} D +/IM {II /ty TY D /xs XS D /ys YS D /ya YA D /yb YB D /ma MA D /mb MB D /k K D + /ec EC D /BP f D /CI 0 D WB TL L1 xs add dup XO add MR add W gt + {pop /ma ma Fl{3 add}if D NL /YA ma D /YB mb D /YS ys D /L1 xs D} + {/L1 E D ma YA gt{/YA ma D}if mb YB gt{/YB mb D}if}ie /TB f D + OU{CP E pop YS sub LE neg lt Fl not and PB not and{NP /YA ma D /YB mb D}if + /BP f D ty ST cvs ( ) join IX k get 0 lt{(\() join ec join (\) ) join}if + k ST cvs join ty 3 eq{AB ST cvs ( ) join E join}if + ty 4 eq{X ST cvs ( ) join Y ST cvs join ( ) join E join}if C1 E join + ( DI ) join FP 2 eq FP 1 eq AF and or{( FM ) join}if + ( Il Cp ) apa /C1 E D /EN f D}if /HM t D /T f D} D +/DI {II /Xc CP /Yc E D D /YN YW neg D /HM t D /CI 0 D /K2 IX K get D gsave + TY 4 eq{OX X IS mul add OY FY add YS sub Y IS mul sub} + {/FY YS D CP MB sub 2 copy /OY E D /OX E D}ie + translate K2 0 ge{/DP AZ K2 get D /BV BM K2 get D XS YS scale /N 0 D XW YW DP + [XW 0 0 YN 0 YW] {IP} FC K2 get 1 eq{image}{f 3 colorimage}ie} + {EX}ie grestore XS 0 R /Ms t D} D +/FM {gsave 0 Sg CP MB sub translate XS neg 0 M 0 YS RL XS 0 RL 0 YS neg RL + XS neg 0 RL stroke grestore} D +/NA {/AT E D /AL AL 1 add D AV AL AT put} D +/OA {AL 0 gt{/AL AL 1 sub D /AT AV AL get D}if} D +/D1 {/BR {CP E pop E BN Mb{CP E pop eq{0 YI R}if}{pop}ie} D + /Sn {OU{C1 E ST cvs join ( Ld ) join /C1 E D}{pop}ie} D} D +/D1 {/BR {BN} D /Sn {OU {C1 E ST cvs join ( Ld ) join /C1 E D} {pop} ie} D} D +/TC {/TF t D /ML 0 D HN{SW pop dup ML gt{/ML E D}{pop}ie}forall NP /RM RM not D + RC /OU Tc D Ep /PN 0 D Ms not TP and{Ip}if /W IW ML sub Ts sub D + /A0 0 D TH{/BR {( ) join BT} D /Sn {pop} D /Au () D}if} D +/TN {0 eq{E EA PF HF or not XR and{HN E get Xr}{pop}ie} + {OU{Tn 0 ge{() BN}if /Tn E D}{pop}ie WB}ie} D +/NT {OU LB not and Tn 0 ge and{PL 0 eq{Ms not{CS CF FS}if CP dup + /y E YA sub D W 9 sub CS -1.8 mul XO L1 add 2 add{y M (.) show}for + HN Tn get dup SW pop IW E sub y M show CP BB M}if /Tn -1 D}if} D +/Ld {/DN E D HN DN Pn put [/View [/XYZ -4 Fl{PS}{CP YA add US E pop}ie null] + /Dest DN ST cvs cvn /DEST pdfmark} D +/C {ND 1 eq{1 sub}if TI mul /XO E D NL Nf not{pop()}if 0 3 -1 roll 1 A} D +/OP {BP not{NP}if PN 2 mod 0 eq{/Ms t D NP}if}D +/Ep {Xp PN 2 mod 0 eq and OU and{/Pn (-) D showpage /PM 1 D LA}if}D +/Dg [73 86 88 76 67 68 77] D +/Rd [0 [1 1 0][2 1 0][3 1 0][2 1 1][1 1 1][2 2 1][3 3 1][4 4 1][2 1 2]] D +/Ns {/m E D /c E 32 mul D /j m 1000 idiv D /p j 12 add string D + c 96 le m 0 gt and{c 32 le {/i 0 D /d 77 D /l 100 D /m m j 1000 mul sub D + j -1 1 {pop p i d c add put /i i 1 add D}for + 4 -2 0 {/j E D /n m l idiv D /m m n l mul sub D /d Dg j get D + n 0 gt {/x Rd n get D x 0 get -1 1 {pop p i d c add put /i i 1 add D}for + p i x 1 get sub Dg x 2 get j add get c add put}if /l l 10 idiv D + }for p 0 i GI} + {/i ST length 1 sub D m {1 sub dup 0 ge{dup 26 mod c add 1 add + ST i 3 -1 roll put 26 idiv dup 0 eq{pop exit}if}if /i i 1 sub D}loop + ST i ST length i sub GI}ie} + {m p cvs}ie} D +/US {matrix currentmatrix matrix defaultmatrix matrix invertmatrix + matrix concatmatrix transform} D +/GB {Gb{US}if}D +/Tl {/Rn E D Xc CP pop ne{ + [/Rect [Xc 1 sub Yc cS 0.25 mul sub GB CP E 1 add E cS 0.85 mul add GB] + /Subtype /Link /Border [0 0 Cf Lc and LX and AU or{0}{1}ie] Rn type + /nametype eq {/Dest Rn}{/Action [/Subtype /URI /URI Rn] Cd}ie + /ANN pdfmark}if} D +/Il {/Rn E D [/Rect [Xc Yc GB Xc XS add Yc YS add GB] /Subtype /Link + /Border [0 0 0] Rn type /nametype eq{/Dest Rn} + {/Action [/Subtype /URI /URI Rn] Cd}ie /ANN pdfmark} D +/XP {[{/Z Bz 2 div D Z 0 R Z Z RL Z neg Z RL Z neg Z neg RL Z Z neg RL + Fi cH 1 eq and{fill}if} {Bz 0 RL 0 Bz RL Bz neg 0 RL 0 Bz neg RL + Fi cH 1 eq and{fill}if} {0 -5 R Bz 0 RL 0 21 RL Bz neg 0 RL 0 -21 RL}]} D +/MS {/Sm E D WB}D +/O {BN()0 Sm BX} D +/BX {/Bt E D Bt 2 lt{/Ch E D CS 0.8 mul}{11 mul}ie W XO sub MR sub + 2 copy gt{E}if pop /HZ E D Bt 2 eq{Fi not{pop()}if ( )E join /Ft E D TT + /PF t D /MW 1 D /Li 1 D /Fw Ft SW pop D Fw HZ gt{/HZ Fw 8 add D}if + HZ ST cvs( )join}{WB Ch ST cvs( )join}ie L1 HZ add XO add MR add W gt{NL}if + Bt 2 eq{Ft ES Fw neg HM{CS sub}if Pd}if Bt ST cvs join( Bx )join + Bt 2 eq HM and{CS Pd}if C1 E join /C1 E D /L1 L1 HZ add D /T f D + ( ) Pd /PF f D Bt 2 lt{YA CS .8 mul lt{/YA CS .8 mul D}if} + {YB 5 lt{/YB 5 D}if YA 21 lt{/YA 21 D}if}ie /CI 0 D} D +/Bx {dup 2 eq{E /Bz E D}{E /cH E D /Bz CS .8 mul D}ie + OU {gsave 0 Sg XP E get exec stroke grestore}{pop}ie Bz 0 R /Ms t D}D +/SD {FD 4 mul Dy add DZ NF newpath 0 0 M DX t charpath pathbbox + 3 -1 roll sub /DY E D E dup /X1 E D sub WM mul WX DY mul add WM DG mul E div + /DF E D /DR WX DF mul DY mul WM div 2 div D} d +/Sd {gsave 0 IL Di mul neg translate IL IW atan Di 0 eq{neg}if rotate + FD 4 mul Dy add DZ NF DR X1 sub DY 2 div neg M cD VC DX show grestore} d +/Pt {/tp t D Tp{NP /Pn (TP) D 0 Tt neg R Th BN NP Ep ET RC ZF}if /tp f D} D +/RC {/AI 0 D /LG 0 D /BC 0 D /UI 0 D /PF f D /Cc 0 D /cC 0 D /Dc 10 array D + /NR [0 1 9{pop 0}for] D /La Ds D /AR 10 array D /TR 10 array D /AV 30 array D + SI /AL -1 D /AT A0 D AT NA /OV 9 array D /Yo 0 D /Co 0 D /Io 0 D /Hy f D + /Ph f D /CL -1 D Ct Sc}D +/ZF {/FR [0 1 30{pop 0}for] D /SZ [0 1 30{pop 0}for] D /FO [0 1 30{pop 0}for] D + /SL 0 D /CF 0 D /FN 0 D 0 Ts SF}D +/QO [[(\253\240)(\233)(\232)(\273)(\234)(\253)][(\253\240)(`)(\231)(\273)(')(\253)]] D +/QC [[(\240\273)(\234)(\233)(\253)(\234)(\273)][(\240\273)(')(`)(\253)(')(\273)]] D +/Hf EF length 2 sub D +/Hz EZ Hf get D +/HS Ey Hf get D +/Fz EZ Hf 1 add get D +/Fs Ey Hf 1 add get D +/LE IL D +/Ps EZ 1 get D +/Fp EF 1 get D +/XO 0 D +/YI 0 D +/CI 0 D +/FP 0 D +/WW Ts 7 mul D +/Mf 0 D +/YA 0 D +/YB 0 D +/Cs Ts D +/GS Ts D +/F0 0 D +/NS 0 D +/NB 0 D +/N 0 D +/C0 [] D +/C1 () D +/Lo 0 D +/L1 0 D +/LM 0 D +/PH 0 D +/EC 0 D +/Lh 0 D +/LT 0 D +/CH 1 string D +/ST 16 string D +/CA 9 array D +/HC (\255) D +/HM f D +/PF f D +/EN f D +/TB f D +/UF f D +/sF f D +/AE f D +/AF f D +/BP t D +/CD f D +/PA t D +/GL f D +/T t D +/HF f D +/AH f D +/SA f D +/PB f D +/f1 f D +/mF f D +/OX 0 D +/OY 0 D +/FY 0 D +/EO 0 D +/FB 0 D +/PL 0 D +/Bw 0 D +/PD -1 D +/TP f D +/tp f D +/TH t D +/Ty 4 D +/Tn -1 D +/Fl t D +/LB t D +/PM 1 D +/Ms f D +/Ba f D +/Bb f D +/Hl 3 D +/hl 6 D +/Hv 6 D +/Hs f D +/HI 0 D +/hi 0 D +/PO t D +/TE f D +/LF t D +/BO 0 D +/Sm 1 D +/Bf 3 D +/A1 0 D +/A2 0 D +/Ds 1 D +/QL -1 D +/Cb Db D +/Ct Dt D +/Cl Dl D +[/Creator (html2ps version 1.0 beta7) /Author () /Keywords (xsd, xml, schema, c++, mapping, data, binding, tree, serialization, guide, manual, examples) /Subject () + /Title (C++/Tree Mapping User Manual) /DOCINFO pdfmark +/ND 1 D +/HN [(1) (1) (1) (1) (1) (1) (1) (2) (2) (2) (2) (3) (3) (3) (4) (5) (5) (5) +(5) (6) (6) (7) (??) (9) (10) (12) (13) (14) (16) (19) (20) (21) (22) (23) +(24) (25) (26) (27) (27) (28) (29) (30) (31) (32) (33) (36) (36) (37) (38) +(40) (45) (47) (54) (55) (57) (59) (59) (62) (64) (65) (68) (73) (75) (80) +(82) (85) (85) (86) (88) (89) (89) (90) (91) (91) (91) (92) (92) (93) (93) +(94) (94) (94) (96) (97) (99) (99) (100) (100) (100) (101) (101) (102) (103) +(103) (106) (107) (??) (??) (??) (??) (??) (??) (??) (??) (??) (??) (??) +(??) (??) (??) (??) (??) (??) (??) (??) (??) (??) (??) (??) (??) (??) (??) +(??) (??) (??) (??) (??) (??) (??) (??) (??) (??) (??) (??) (??) (??) (??) +(??) (??) (??) (??) (??) (??) (??) (??) (1) (1) (1) (1) (2) (2) (2) (2) +(3) (3) (3) (4) (5) (5) (5) (5) (6) (6) (7) (9) (10) (12) (13) (14) (16) +(19) (20) (21) (22) (23) (24) (25) (26) (27) (27) (28) (29) (30) (31) (32) +(33) (36) (36) (37) (38) (40) (45) (47) (54) (55) (57) (59) (59) (62) (64) +(65) (68) (73) (75) (80) (82) (85) (85) (86) (88) (89) (89) (90) (91) (91) +(91) (92) (92) (93) (93) (94) (94) (94) (96) (97) (99) (99) (100) (100) +(100) (101) (101) (102) (103) (103) (106) (107)] D +/h0 [()(Table of Contents)] D +/h1 [(1\240\240)(Preface)] D +/h2 [(1.1\240\240)(About This Document)] D +/h3 [(1.2\240\240)(More Information)] D +/h4 [(2\240\240)(1 Introduction)] D +/h5 [(3\240\240)(2 C++/Tree Mapping)] D +/h6 [(3.1\240\240)(2.1 Preliminary Information)] D +/h7 [(3.1.1\240\240)(2.1.1 C++ Standard)] D +/h8 [(3.1.2\240\240)(2.1.2 Identifiers)] D +/h9 [(3.1.3\240\240)(2.1.3 Character Type and Encoding)] D +/h10 [(3.1.4\240\240)(2.1.4 XML Schema Namespace)] D +/h11 [(3.1.5\240\240)(2.1.5 Anonymous Types)] D +/h12 [(3.2\240\240)(2.2 Error Handling)] D +/h13 [(3.2.1\240\240)(2.2.1 xml_schema::duplicate_id)] D +/h14 [(3.3\240\240)(2.3 Mapping for import and include)] D +/h15 [(3.3.1\240\240)(2.3.1 Import)] D +/h16 [(3.3.2\240\240)(2.3.2 Inclusion with Target Namespace)] D +/h17 [(3.3.3\240\240)(2.3.3 Inclusion without Target Namespace)] D +/h18 [(3.4\240\240)(2.4 Mapping for Namespaces)] D +/h19 [(3.5\240\240)(2.5 Mapping for Built-in Data Types)] D +/h20 [(3.5.1\240\240)(2.5.1 Inheritance from Built-in Data Types)] D +/h21 [(3.5.2\240\240)(2.5.2 Mapping for anyType)] D +/h22 [(3.5.3\240\240)(2.5.3 Mapping for anySimpleType)] D +/h23 [(3.5.4\240\240)(2.5.4 Mapping for QName)] D +/h24 [(3.5.5\240\240)(2.5.5 Mapping for IDREF)] D +/h25 [(3.5.6\240\240)(2.5.6 Mapping for base64Binary and hexBinary)] D +/h26 [(3.6\240\240)(2.5.7 Time Zone Representation)] D +/h27 [(3.7\240\240)(2.5.8 Mapping for date)] D +/h28 [(3.8\240\240)(2.5.9 Mapping for dateTime)] D +/h29 [(3.9\240\240)(2.5.10 Mapping for duration)] D +/h30 [(3.10\240\240)(2.5.11 Mapping for gDay)] D +/h31 [(3.11\240\240)(2.5.12 Mapping for gMonth)] D +/h32 [(3.12\240\240)(2.5.13 Mapping for gMonthDay)] D +/h33 [(3.13\240\240)(2.5.14 Mapping for gYear)] D +/h34 [(3.14\240\240)(2.5.15 Mapping for gYearMonth)] D +/h35 [(3.15\240\240)(2.5.16 Mapping for time)] D +/h36 [(3.16\240\240)(2.6 Mapping for Simple Types)] D +/h37 [(3.16.1\240\240)(2.6.1 Mapping for Derivation by Restriction)] D +/h38 [(3.16.2\240\240)(2.6.2 Mapping for Enumerations)] D +/h39 [(3.16.3\240\240)(2.6.3 Mapping for Derivation by List)] D +/h40 [(3.16.4\240\240)(2.6.4 Mapping for Derivation by Union)] D +/h41 [(3.17\240\240)(2.7 Mapping for Complex Types)] D +/h42 [(3.17.1\240\240)(2.7.1 Mapping for Derivation by Extension)] D +/h43 [(3.17.2\240\240)(2.7.2 Mapping for Derivation by Restriction)] D +/h44 [(3.18\240\240)(2.8 Mapping for Local Elements and Attributes)] D +/h45 [(3.18.1\240\240)(2.8.1 Mapping for Members with the One Cardinality Class)] D +/h46 [(3.18.2\240\240)(2.8.2 Mapping for Members with the Optional Cardinality Class)] D +/h47 [(3.18.3\240\240)(2.8.3 Mapping for Members with the Sequence Cardinality Class)] D +/h48 [(3.18.4\240\240)(2.8.4 Element Order)] D +/h49 [(3.19\240\240)(2.9 Mapping for Global Elements)] D +/h50 [(3.19.1\240\240)(2.9.1 Element Types)] D +/h51 [(3.19.2\240\240)(2.9.2 Element Map)] D +/h52 [(3.20\240\240)(2.10 Mapping for Global Attributes)] D +/h53 [(3.21\240\240)(2.11 Mapping for xsi:type and Substitution Groups)] D +/h54 [(3.22\240\240)(2.12 Mapping for any and anyAttribute)] D +/h55 [(3.22.1\240\240)(2.12.1 Mapping for any with the One Cardinality Class)] D +/h56 [(3.22.2\240\240)(2.12.2 Mapping for any with the Optional Cardinality Class)] D +/h57 [(3.22.3\240\240)(2.12.3 Mapping for any with the Sequence Cardinality Class)] D +/h58 [(3.22.4\240\240)(2.12.4 Element Wildcard Order)] D +/h59 [(3.22.5\240\240)(2.12.5 Mapping for anyAttribute)] D +/h60 [(3.23\240\240)(2.13 Mapping for Mixed Content Models)] D +/h61 [(4\240\240)(3 Parsing)] D +/h62 [(4.1\240\240)(3.1 Initializing the Xerces-C++ Runtime)] D +/h63 [(4.2\240\240)(3.2 Flags and Properties)] D +/h64 [(4.3\240\240)(3.3 Error Handling)] D +/h65 [(4.3.1\240\240)(3.3.1 xml_schema::parsing)] D +/h66 [(4.3.2\240\240)(3.3.2 xml_schema::expected_element)] D +/h67 [(4.3.3\240\240)(3.3.3 xml_schema::unexpected_element)] D +/h68 [(4.3.4\240\240)(3.3.4 xml_schema::expected_attribute)] D +/h69 [(4.3.5\240\240)(3.3.5 xml_schema::unexpected_enumerator)] D +/h70 [(4.3.6\240\240)(3.3.6 xml_schema::expected_text_content)] D +/h71 [(4.3.7\240\240)(3.3.7 xml_schema::no_type_info)] D +/h72 [(4.3.8\240\240)(3.3.8 xml_schema::not_derived)] D +/h73 [(4.3.9\240\240)(3.3.9 xml_schema::no_prefix_mapping)] D +/h74 [(4.4\240\240)(3.4 Reading from a Local File or URI)] D +/h75 [(4.5\240\240)(3.5 Reading from std::istream)] D +/h76 [(4.6\240\240)(3.6 Reading from xercesc::InputSource)] D +/h77 [(4.7\240\240)(3.7 Reading from DOM)] D +/h78 [(5\240\240)(4 Serialization)] D +/h79 [(5.1\240\240)(4.1 Initializing the Xerces-C++ Runtime)] D +/h80 [(5.2\240\240)(4.2 Namespace Infomap and Character Encoding)] D +/h81 [(5.3\240\240)(4.3 Flags)] D +/h82 [(5.4\240\240)(4.4 Error Handling)] D +/h83 [(5.4.1\240\240)(4.4.1 xml_schema::serialization)] D +/h84 [(5.4.2\240\240)(4.4.2 xml_schema::unexpected_element)] D +/h85 [(5.4.3\240\240)(4.4.3 xml_schema::no_type_info)] D +/h86 [(5.5\240\240)(4.5 Serializing to std::ostream)] D +/h87 [(5.6\240\240)(4.6 Serializing to xercesc::XMLFormatTarget)] D +/h88 [(5.7\240\240)(4.7 Serializing to DOM)] D +/h89 [(6\240\240)(5 Additional Functionality)] D +/h90 [(6.1\240\240)(5.1 DOM Association)] D +/h91 [(6.2\240\240)(5.2 Binary Serialization)] D +/h92 [(7\240\240)(Appendix A \236 Default and Fixed Values)] D +/Hr [145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 +162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 +180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 +198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 +216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 +234 235 236]D +/HV [1 2 2 1 1 2 3 3 3 3 3 2 3 2 3 3 3 2 2 3 3 3 3 3 3 2 2 2 2 2 2 2 2 +2 2 2 3 3 3 3 2 3 3 2 3 3 3 3 2 3 3 2 2 2 3 3 3 3 3 2 1 2 2 2 3 3 3 3 3 +3 3 3 3 2 2 2 2 1 2 2 2 2 3 3 3 2 2 2 1 2 2 1]D +/Cn [2 0 0 0 23 5 0 0 0 0 0 1 0 3 0 0 0 0 6 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 4 0 0 0 0 2 0 0 4 0 0 0 0 2 0 0 0 0 5 0 0 0 0 0 0 7 0 0 9 0 0 0 0 0 +0 0 0 0 0 0 0 0 7 0 0 0 3 0 0 0 0 0 0 2 0 0 0]D +Hr length 0 gt{[/PageMode /UseOutlines /DOCVIEW pdfmark}if +/Hn 1 D +0 1 Hr length 1 sub{ + /Bn E D [Cn Bn get dup 0 gt{/Count E HV Bn get Bl ge{neg}if}{pop}ie + /Dest Hr Bn get dup abs ST cvs cvn E 0 ge{(h)Hn ST cvs join cvx exec + dup 1 get E Nf{0 get E join}{pop}ie /Hn Hn 1 add D}{()}ie + /Title E dup length 255 gt{0 255 getinterval}if /OUT pdfmark}for +ZF /FN Fp D Ps 0 FS /WC Wf{( )}{}ie SW pop D +ET RC ZF +/Df f D +/R0 (https://www.codesynthesis.com/licenses/fdl-1.2.txt) D +/R1 (https://www.codesynthesis.com/projects/xsd/documentation/cxx/tree/manual/index.xhtml) D +/R2 (https://www.codesynthesis.com/projects/xsd/documentation/cxx/tree/manual/cxx-tree-manual.pdf) D +/R3 (https://www.codesynthesis.com/projects/xsd/documentation/cxx/tree/manual/cxx-tree-manual.ps) D +/R1 (https://www.codesynthesis.com/products/xsd) D +/R2 (https://www.codesynthesis.com/projects/xsd/documentation/cxx/tree/guide/) D +/R3 (http://wiki.codesynthesis.com/Tree/Customization_guide) D +/R4 (http://wiki.codesynthesis.com/Tree/FAQ) D +/R5 (https://www.codesynthesis.com/projects/xsd/documentation/xsd.xhtml) D +/R6 (https://cppget.org/xsd-examples) D +/R7 (https://www.codesynthesis.com/mailman/listinfo/xsd-users) D +/R8 (https://www.codesynthesis.com/pipermail/xsd-users/) D +/R9 (http://en.wikipedia.org/wiki/Character_code) D +/TS { + tables E get /table E D + table aload pop /rdesc E D /cdesc E D /tdesc E D + tdesc aload pop /capalg E D /caption E D /rules E D /frame E D /nfoot E D + /nhead E D /ncol E D /nrow E D /border E D /twid E D /units E D /talign E D + /flow E D /clear E D /tclass E D pop pop + /w W D /eps 0.1 D /OU f D /PL 1 D + /FN EF 21 get D EZ 21 get Ey 21 get FS + 0 1 1{ + /pass E D + 0 1 nrow{ + /irow E D + /cells rdesc irow get 6 get D + 0 1 ncol{ + /icol E D + /cell cells icol get D + cell 0 ne{ + cell aload pop /ang E D /CB E D pop pop pop + /DV E D /bot E D /top E D /right E D /left E D /nowrap E D /valign E D + /dp E D /align E D /rspan E D /cspan E D /cclass E D /ctype E D /cmax E D + /cmin E D /proc E D + rspan 0 eq{/rspan nrow irow sub 1 add D}if + cspan 0 eq{/cspan ncol icol sub 1 add D}if + pass 0 eq cspan 1 eq and pass 1 eq cspan 1 gt and or{ + /W 1e5 D /LL W D /PH 1 D + ctype 1 eq{() BD}if + RC align NA + AT 4 eq{/CD t D /DC dp D /LN 0 D /M1 0 D /M2 0 D}{/CD f D}ie + 0 0 M /LM 0 D proc exec BN + AT 4 eq{ + LN array astore cell 15 3 -1 roll put + cdesc icol get dup dup 5 get M1 lt{5 M1 put}{5 get /M1 E D}ie + dup 6 get M2 lt{6 M2 put}{6 get /M2 E D}ie + /LM M1 M2 add D + }if + /CD f D + ang 0 ne{/LM CP E pop neg D}if + /thiswid LM left add right add eps add D + /oldmin 0 D /oldmax 0 D + 0 1 cspan 1 sub{ + icol add cdesc E get dup 2 get /oldmax E oldmax add D + 1 get /oldmin E oldmin add D + }for + thiswid oldmax ge{ + 0 1 cspan 1 sub{ + icol add cdesc E get dup 2 E 2 get oldmax 0 eq + {pop thiswid cspan div}{thiswid mul oldmax div}ie + put + }for + }if + nowrap 1 eq{ + thiswid oldmin ge{ + 0 1 cspan 1 sub{ + icol add cdesc E get dup 1 E 1 get oldmin 0 eq + {pop thiswid cspan div}{thiswid mul oldmin div}ie + put + }for + }if + }{ + /W 0 D /LL W D /PH 2 D + ctype 1 eq{() ES () BD}if + 0 0 M /LM 0 D RC proc exec BN + /thiswid LM left add right add eps add D + thiswid oldmin ge{ + 0 1 cspan 1 sub{ + icol add cdesc E get dup 1 E 1 get oldmin 0 eq + {pop thiswid cspan div}{thiswid mul oldmin div}ie + put + }for + }if + }ie + ctype 1 eq{() ES}if + }if + }if + }for + }for + }for + /tmin 0 D /tmax 0 D + 0 1 ncol{ + cdesc E get dup 1 get E 2 get 2 copy gt{pop dup}if + tmax add /tmax E D tmin add /tmin E D + }for + twid 0 lt{twid neg IW gt{IW neg}{twid}ie /twid E D}if + tdesc 0 twid neg tmin 2 copy lt{E}if pop put + tdesc 1 twid neg tmax 2 copy lt{E}if pop put + /W w D /LL W D /OU t D /PH 0 D /PL 0 D +} D +/PT { + /PL PL 1 add D + tables E get /table E D Tm 21 get Ts mul BE + PL 2 ge{save}if + /SL SL 1 add D /FN EF 21 get D EZ 21 get Ey 21 get FS + table aload pop /rdesc E D /cdesc E D /tdesc E D + tdesc aload pop /capalg E D /caption E D /rules E D /frame E D /nfoot E D + /nhead E D /ncol E D /nrow E D /border E D /twid E D /units E D /talign E D + /flow E D /clear E D /tclass E D /tmax E D /tmin E D + /w W D /xo XO D /mr MR D /ll LL D /lg LG D /ai AI D /bc BC D /nr NR D /ar AR D + /tr TR D /ui UI D /ph PH D /a0 A0 D /pf PF D /at AT D /av AV D /al AL D + /Le LE D /la La D + talign 0 lt{/talign AL 0 gt{AV AL get}{A0 2 le{A0}{0}ie}ie D}if + ph 1 eq ph 2 eq or{ + NL ph 1 eq{tmax}{tmin}ie dup XO add LM gt{/LM E XO add D}{pop}ie LM E + }{ + /PH 3 D /LE 1e5 D RC %ZF + border 0 gt{/border 1 D}if + /twidth 0 D /avail W xo sub D + twid 0 eq{0 1 ncol{cdesc E get dup 2 get E 3 get dup 0 gt{div neg dup twid lt + {/twid E D}{pop}ie}{pop pop}ie}for}if + /twid twid dup 0 lt{neg avail 2 copy gt{E}if pop}{avail mul}ie D + /OK t D 0 1 ncol{cdesc E get dup 1 get E 3 get twid mul gt{/OK f D}if}for + 0 1 ncol{ + cdesc E get dup 1 get /colmin E D dup 3 get /cwid E twid mul D dup + tmax avail le{2 get}if + tmin avail le tmax avail gt and{ + dup 2 get E 1 get dup 3 1 roll sub avail tmin sub mul tmax tmin sub div add + }if + tmin avail gt{1 get}if + 0 E colmin cwid lt OK and{pop cwid}if dup /twidth E twidth add D put + }for + /OU f D CP + tmin twid le{ + 0 1 ncol{cdesc E get dup 0 get twidth div twid mul 0 E put}for + /twidth twid D + }if + CP printcap CP E pop sub /caphig E D pop + 0 1 1{ + /pass E D + 0 1 nrow{ + /irow E D + /cells rdesc irow get 6 get D + 0 1 ncol{ + /icol E D + /cell cells icol get D + cell 0 ne{ + cell aload pop /ang E D /CB E D pop pop pop + /DV E D /bot E D /top E D /right E D /left E D /nowrap E D /valign E D + /dp E D /align E D /rspan E D /cspan E D /cclass E D /ctype E D /cmax E D + /cmin E D /proc E D + rspan 0 eq{/rspan nrow irow sub 1 add D}if + cspan 0 eq{/cspan ncol icol sub 1 add D}if + /W 0 D + 0 1 cspan 1 sub{icol add cdesc E get 0 get /W E W add D}for + pass 0 eq rspan 1 eq and pass 1 eq rspan 1 gt and or{ + ctype 1 eq{() BD}if + /W W left sub right sub D /XO 0 D /EO 0 D SI + /A0 align D RC align NA + AT 4 eq{ + /DC dp D /DO 0 D /ID 1 D + 0 1 DV length 1 sub{DV E get dup DO gt{/DO E D}{pop}ie}for + /Lo DO DV 0 get sub D /L1 Lo D + }if + 0 0 M /BP t D /Fl t D /MF 0 D /FB 0 D + proc exec T not{/CI 0 D}if BN 0 FB neg R MF 0 eq{/MF CS D}if + CP /thishig E neg bot add top add CI add D pop + ang 0 ne{/thishig LM bot add top add D}if + cell 16 MF put cell 17 Ya put cell 18 thishig put + valign 4 eq{ + /below thishig Ya sub D + rdesc irow get dup dup 4 get Ya lt + {4 Ya put}{4 get /Ya E D}ie + dup 5 get below lt{5 below put}{5 get /below E D}ie + /thishig Ya below add D + }if + ctype 1 eq{()ES}if + /oldhig 0 D + 0 1 rspan 1 sub{ + irow add rdesc E get 0 get /oldhig E oldhig add D + }for + thishig oldhig ge{ + 0 1 rspan 1 sub{ + irow add rdesc E get dup 0 E 0 get oldhig 0 eq + {pop thishig rspan div}{thishig mul oldhig div}ie + put + }for + }if + }if + }if + }for + }for + }for M RC %ZF + /thight 0 D /racc 0 D /maxh 0 D /brk 0 D /rbeg nhead nfoot add D + 0 1 nrow{ + rdesc E get dup 0 get dup /thight E thight add D + brk 0 eq{/racc E D}{/racc E racc add D}ie + racc maxh gt{/maxh racc D}if 2 get /brk E D + }for + ph 3 ge{thight caphig add E}if + ph 0 eq ph 4 eq or{ + /PH 4 D /LE Le D /OU Ou D /yoff 0 D /headsz 0 D + 0 1 nhead 1 sub{rdesc E get 0 get headsz add /headsz E D}for + /footsz 0 D + 0 1 nfoot 1 sub{rdesc E nhead add get 0 get footsz add /footsz E D}for + /ahig LE BO add MI add D /maxh maxh headsz add footsz add D + /thight thight headsz add footsz add D + tmin avail gt maxh ahig gt or + {/Sf avail tmin div dup ahig maxh div gt{pop ahig maxh div}if D /SA t D} + {/Sf 1 D}ie + tclass 1 eq thight LE 15 sub gt and + {/SA t D LE 15 sub thight div dup Sf lt{/Sf E D}{pop}ie}if + SA{Sf Sf scale /ll ll Sf div D /xo xo Sf div D /LE LE Sf div D + /mr mr Sf div D /BO BO Sf div D /ahig ahig Sf div D}if + nhead nfoot add getwid + LE CP E pop add capalg 0 eq{caphig sub}if + bT{f}{dup thight lt thight ahig lt and}ie + E headsz sub footsz sub rwid lt or{NP}if + capalg 0 eq{printcap -8 SP}if + CP /ycur E D pop + printhead + rbeg 1 nrow{/row E D row + getwid + ycur yoff add rwid sub footsz sub LE add 0 lt + {nfoot 0 gt{printfoot}if Tf NP /rbeg irow1 D + Ba{MI /MI MI SA{Sf div}if D MI SP /MI E D}if + CP /ycur E D pop /yoff 0 D printhead}if + irow1 printrow + }for + printfoot /row row 1 add D Tf + 0 ycur yoff add M + capalg 1 eq{/EO 0 D SI -3 SP printcap}if + Sf 1 lt{1 Sf div dup scale /ll ll Sf mul D /xo xo Sf mul D /LE LE Sf mul D + /mr mr Sf mul D /BO BO Sf mul D /SA f D}if + /EO 0 D + }if + }ie + /W w D /XO xo D /MR mr D /LL ll D /LG lg D /AI ai D /BC bc D /NR nr D /AR ar D + /TR tr D /UI ui D /PH ph D /A0 a0 D /PF pf D /AT at D /AV av D /AL al D + /La la D + /SL SL 1 sub NN D /CF 0 D /FN 0 D SZ SL get FR SL get FS Wf not{()F2}if + PL 2 ge{Ms E restore Ms or /Ms E D PH 1 eq PH 2 eq or + {/LM E D}if PH 3 ge{/CI 0 D NL 0 E neg R}if + }if + /PL PL 1 sub D /CI 0 D /BP f D /PO f D () Bm 21 get Ts mul BE BL %CF CS SF +} D +/printcap{ + capalg 0 ge{ + SA{/W w Sf div D} + {talign 1 eq{/XO xo ll twidth sub 2 div add D}if + talign 2 eq{/XO xo ll twidth sub add D}if + /W XO twidth add D + }ie /XO xo D /LL W XO sub MR sub D + /PA f D /Fl capalg 0 eq D + 1 NA BL caption exec BN OA /PA t D + }if +} D +/getwid{ + /irow1 E D + /irow2 irow1 D + /rwid 0 D + {rdesc irow2 get dup 0 get rwid add /rwid E D 2 get 0 eq + {exit}{/irow2 irow2 1 add D}ie + }loop +} D +/printrow{ + /xoff ll twidth PL 2 ge{Sf div}if sub talign mul 2 div D + /xleft xoff xo add D + /irow E D + /cells rdesc irow get 6 get D + 0 1 ncol{ + /icol E D + /cell cells icol get D + cell 0 ne{ + cell aload pop /ang E D /CB E D /cvsize E D /above E D /fontsz E D + /DV E D /bot E D /top E D /right E D /left E D /nowrap E D /valign E D + /dp E D /align E D /rspan E D /cspan E D /cclass E D /ctype E D /cmax E D + /cmin E D /proc E D + rspan 0 eq{/rspan nrow irow sub 1 add D}if + cspan 0 eq{/cspan ncol icol sub 1 add D}if + /width 0 D + 0 1 cspan 1 sub{icol add cdesc E get 0 get /width E width add D}for + /rhight rdesc irow get 0 get D + /hight rhight D + 1 1 rspan 1 sub{irow add rdesc E get 0 get /hight E hight add D}for + /W xo xoff add width add right sub D + ang 0 ne{/W xo xoff add hight add right sub D}if + /EO xo xoff add left add D SI + Cf{ + gsave CB VC xo xoff add ycur yoff add M + 0 hight neg RL width 0 RL 0 hight RL width neg 0 RL fill + grestore + }if + ctype 1 eq{() BD}if + /A0 align D RC + AT 4 eq{ + /DC dp D /ID 1 D /DO cdesc icol get 5 get D /Lo DO DV 0 get sub D /L1 Lo D + }if + ang 0 ne{ + gsave ang 90 eq + {xoff ycur add hight cvsize sub 2 div sub ycur hight sub xoff sub} + {xoff ycur sub width add hight cvsize sub 2 div add ycur xoff add}ie + translate ang rotate + }if + valign 3 le{0 ycur yoff add top sub + hight cvsize sub valign 1 sub mul 2 div sub M} + {0 ycur yoff add top sub above add rdesc irow get 4 get sub M}ie + /PA f D /BP t D /Fl t D + BL proc exec BN + ang 0 ne{grestore}if + /PA t D + ctype 1 eq{() ES}if + }if + /xoff xoff cdesc icol get 0 get add D + }for + /yoff yoff rhight sub D +} D +/printhead {0 1 nhead 1 sub{printrow}for} D +/printfoot {nhead 1 nhead nfoot add 1 sub{printrow}for} D +/Tf { + OU{rules 2 ge{/yoff 0 D + gsave 0 Sg + [0 1 nhead 1 sub{}for rbeg 1 row 1 sub{}for nhead 1 nhead nfoot add 1 sub{}for]{ + /irow E D + /xoff ll twidth PL 2 ge{Sf div}if sub talign mul 2 div D + /cells rdesc irow get 6 get D + 0 1 ncol{ + /icol E D + /cell cells icol get D + cell 0 ne{ + /rspan cell 6 get D + /cspan cell 5 get D + rspan 0 eq{/rspan nrow irow sub 1 add D}if + cspan 0 eq{/cspan ncol icol sub 1 add D}if + /width 0 D + 0 1 cspan 1 sub{icol add cdesc E get 0 get /width E width add D}for + /rhight rdesc irow get 0 get D + /hight rhight D + 1 1 rspan 1 sub{irow add rdesc E get 0 get /hight E hight add D}for + xo xoff add width add ycur yoff add M + 0 hight neg icol cspan add 1 sub ncol lt + {cdesc icol 1 add get 4 get dup rules 3 le{1 eq}{pop t}ie + {1 eq{0.8}{0.3}ie + LW RL CP stroke M}{pop R}ie}{R}ie + irow nhead nfoot add 1 sub ne nfoot 0 eq or + {irow rspan add 1 sub nrow lt + {rdesc irow rspan add get 3 get}{nfoot 0 eq{0}{1}ie}ie + dup rules 2 mod 0 eq{1 eq}{pop t}ie + {1 eq irow rspan add nhead eq or irow rspan add row eq nfoot 0 gt and or + {0.8}{0.3}ie LW width neg 0 RL CP stroke M}{pop}ie}if + }if + /xoff xoff cdesc icol get 0 get add D + }for + /yoff yoff rhight sub D + }forall + grestore + /Ms t D + }if + frame 1 gt{ + gsave + 1 LW 0 Sg + xleft ycur M CP BB + 0 yoff frame 5 eq frame 7 ge or{RL}{R}ie + twidth 0 frame 3 eq frame 4 eq or frame 8 ge or{RL}{R}ie CP BB + 0 yoff neg frame 6 ge{RL}{R}ie + twidth neg 0 frame 2 eq frame 4 eq or frame 8 ge or{RL}{R}ie + closepath stroke + grestore + /Ms t D + }if + }if +} D +/tables [[[0 0 0 0 0 -1 0 0 1 58 2 0 0 9 5 {()} -1] + [[0 0 0 0 0 0 0][0 0 0 0 0 0 0][0 0 0 0 0 0 0]] + [[0 0 0 0 0 0 [[{()1 Sl()WB(XML Schema type)} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(Alias in the )SM(xml_schema)ES( names)HY(pace)YH()} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(C++ type + )} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB(anyType and anySim)HY(ple)HY(Type)YH( types + )} 0 0 1 0 3 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +0 +0 +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(anyType)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(type)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 109 1 A(Section 2.5.2, "Mapping for )SM(anyType)ES(")109 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(anySim)HY(ple)HY(Type)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(simple_type)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 110 1 A(Section 2.5.3, "Mapping for )SM(anySim)HY(ple)HY(Type)YH()ES(")110 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB(fixed-length inte)HY(gral)YH( types + )} 0 0 1 0 3 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +0 +0 +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(byte)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(byte)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(signed\240char)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(unsigned)HY(Byte)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(unsigned_byte)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(unsigned\240char)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(short)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(short_)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(short)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(unsigned)HY(Short)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(unsigned_short)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(unsigned\240short)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(int)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(int_)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(int)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(unsignedInt)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(unsigned_int)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(unsigned\240int)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(long)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(long_)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(long\240long)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(unsigned)HY(Long)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(unsigned_long)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(unsigned\240long\240long)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB(arbi)HY(trary)YH(-length inte)HY(gral)YH( types + )} 0 0 1 0 3 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +0 +0 +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(integer)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(integer)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(long\240long)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(nonPos)HY(i)HY(tiveIn)HY(te)HY(ger)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(non_posi)HY(tive)YH(_integer)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(long\240long)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(nonNeg)HY(a)HY(tiveIn)HY(te)HY(ger)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(non_nega)HY(tive)YH(_integer)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(unsigned long\240long)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(posi)HY(tiveIn)HY(te)HY(ger)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(posi)HY(tive)YH(_integer)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(unsigned long\240long)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(nega)HY(tiveIn)HY(te)HY(ger)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(nega)HY(tive)YH(_integer)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(long\240long)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB(boolean types + )} 0 0 1 0 3 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +0 +0 +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(boolean)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(boolean)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(bool)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB(fixed-preci)HY(sion)YH( float)HY(ing)YH(-point types + )} 0 0 1 0 3 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +0 +0 +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(float)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(float_)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(float)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(double)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(double_)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(double)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB(arbi)HY(trary)YH(-preci)HY(sion)YH( float)HY(ing)YH(-point types + )} 0 0 1 0 3 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +0 +0 +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(decimal)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(decimal)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(double)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB(string types + )} 0 0 1 0 3 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +0 +0 +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(string)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(string)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(type derived from )SM(std::basic_string)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(normal)HY(ized)HY(String)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(normal)HY(ized)YH(_string)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(type derived from )SM(string)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(token)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(token)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(type\240derived\240from\240)SM(normal)HY(ized)YH(_string)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(Name)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(name)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(type derived from )SM(token)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(NMTOKEN)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(nmtoken)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(type derived from )SM(token)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(NMTO)HY(KENS)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(nmto)HY(kens)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(type derived from )SM(sequence)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(NCName)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(ncname)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(type derived from )SM(name)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(language)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(language)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(type derived from )SM(token)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB(qual)HY(i)HY(fied)YH( name + )} 0 0 1 0 3 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +0 +0 +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(QName)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(qname)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 111 1 A(Section 2.5.4, "Mapping for )SM(QName)ES(")111 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB(ID/IDREF types + )} 0 0 1 0 3 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +0 +0 +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(ID)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(id)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(type derived from )SM(ncname)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(IDREF)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(idref)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 112 1 A(Section 2.5.5, "Mapping for )SM(IDREF)ES(")112 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(IDREFS)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(idrefs)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(type derived from )SM(sequence)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB(URI types + )} 0 0 1 0 3 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +0 +0 +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(anyURI)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(uri)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(type derived from )SM(std::basic_string)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB(binary types + )} 0 0 1 0 3 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +0 +0 +]] +[0 0 1 0 0 0 [[{()1 Sl()WB()SM(base64Binary)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(base64_binary)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 113 1 A(Section 2.5.6, "Mapping for + )SM(base64Binary)ES( and )SM(hexBi)HY(nary)YH()ES(")113 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 2 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(hexBi)HY(nary)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(hex_binary)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +0 +]] +[0 0 0 0 0 0 [[{()1 Sl()WB(date/time types + )} 0 0 1 0 3 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +0 +0 +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(date)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(date)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 114 1 A(Section 2.5.8, "Mapping for + )SM(date)ES(")114 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(date)HY(Time)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(date_time)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 115 1 A(Section 2.5.9, "Mapping for + )SM(date)HY(Time)YH()ES(")115 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(dura)HY(tion)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(dura)HY(tion)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 116 1 A(Section 2.5.10, "Mapping for + )SM(dura)HY(tion)YH()ES(")116 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(gDay)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(gday)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 117 1 A(Section 2.5.11, "Mapping for + )SM(gDay)ES(")117 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(gMonth)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(gmonth)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 118 1 A(Section 2.5.12, "Mapping for + )SM(gMonth)ES(")118 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(gMon)HY(th)HY(Day)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(gmonth_day)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 119 1 A(Section 2.5.13, "Mapping for + )SM(gMon)HY(th)HY(Day)YH()ES(")119 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(gYear)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(gyear)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 120 1 A(Section 2.5.14, "Mapping for + )SM(gYear)ES(")120 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(gYear)HY(Month)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(gyear_month)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 121 1 A(Section 2.5.15, "Mapping for + )SM(gYear)HY(Month)YH()ES(")121 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(time)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(time)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 122 1 A(Section 2.5.16, "Mapping for + )SM(time)ES(")122 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB(entity types + )} 0 0 1 0 3 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +0 +0 +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(ENTITY)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(entity)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(type derived from )SM(name)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(ENTI)HY(TIES)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(enti)HY(ties)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(type derived from )SM(sequence)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +]] +[[0 0 0 0 0 -1 0 0 1 8 5 0 0 9 5 {()} -1] + [[0 0 0 0 0 0 0][0 0 0 0 0 0 0][0 0 0 0 0 0 0][0 0 0 0 0 0 0][0 0 0 0 0 0 0][0 0 0 0 0 0 0]] + [[0 0 0 0 0 0 [[{()1 Sl()WB()} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(default)} 0 0 1 0 2 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +0 +[{()1 Sl()WB(fixed + )} 0 0 1 0 2 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +0 +]] +[0 0 1 0 0 0 [[{()1 Sl()WB(element)} 0 0 1 0 1 4 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(not present)} 0 0 1 0 1 2 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(optional)} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(required)} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(optional)} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(required + )} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 1 0 0 0 [0 +0 +[{()1 Sl()WB(not present)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(invalid instance)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(not present)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(invalid instance + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 1 0 0 0 [0 +[{()1 Sl()WB(empty)} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(default value is used)} 0 0 0 0 2 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +0 +[{()1 Sl()WB(fixed value is used + )} 0 0 0 0 2 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +0 +]] +[0 0 0 0 0 0 [0 +[{()1 Sl()WB(value)} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(value is used)} 0 0 0 0 2 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +0 +[{()1 Sl()WB(value is used provided it's the same as fixed + )} 0 0 0 0 2 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +0 +]] +[0 0 1 0 0 0 [[{()1 Sl()WB(attribute)} 0 0 1 0 1 4 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(not present)} 0 0 1 0 1 2 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(optional)} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(required)} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(optional)} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(required + )} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 1 0 0 0 [0 +0 +[{()1 Sl()WB(default value is used)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(invalid schema)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(fixed value is used)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(invalid instance + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 1 0 0 0 [0 +[{()1 Sl()WB(empty)} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(empty value is used)} 0 0 0 0 2 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +0 +[{()1 Sl()WB(empty value is used provided it's the same as fixed + )} 0 0 0 0 2 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +0 +]] +[0 0 0 0 0 0 [0 +[{()1 Sl()WB(value)} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(value is used)} 0 0 0 0 2 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +0 +[{()1 Sl()WB(value is used provided it's the same as fixed + )} 0 0 0 0 2 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +0 +]] +]] +] D +0 1 1{TS}for RC ZF +/Ba f D /BO 0 D Bs +/UR (/home/boris/work/xsd/builds/gcc8-host/xsd/doc/cxx/tree/manual/index.xhtml) D +/Ti (C++/Tree Mapping User Manual) D +/Au () D +/Df f D +/ME [(4.1.0)] D +Pt +/BO 0 D TC /Ba f D Bs /AU f D /UR () D RC ZF + tH WB +ND 1 gt{Ts 3 mul Np 0()0 C()BD(C++/Tree Mapping User Manual)ES()0 1 TN()EA()BN}if +1 NH le{145(1\240\240)1 C(Preface)WB 3 Sn()145 1 TN()EA()BN}if +2 NH le{146(1.1\240\240)2 C(About)WB 4 Sn( This Docu)HY(ment)YH()146 1 TN()EA()BN}if +2 NH le{147(1.2\240\240)2 C(More)WB 5 Sn( Infor)HY(ma)HY(tion)YH()147 1 TN()EA()BN}if +1 NH le{148(2\240\240)1 C(1)WB 6 Sn( Intro)HY(duc)HY(tion)YH()148 1 TN()EA()BN}if +1 NH le{149(3\240\240)1 C(2)WB 7 Sn( C++/Tree Mapping)149 1 TN()EA()BN}if +2 NH le{150(3.1\240\240)2 C(2.1)WB 8 Sn( Prelim)HY(i)HY(nary)YH( Infor)HY(ma)HY(tion)YH()150 1 TN()EA()BN}if +3 NH le{151(3.1.1\240\240)3 C(2.1.1)WB 9 Sn( C++ Stan)HY(dard)YH()151 1 TN()EA()BN}if +3 NH le{152(3.1.2\240\240)3 C(2.1.2)WB 10 Sn( Iden)HY(ti)HY(fiers)YH()152 1 TN()EA()BN}if +3 NH le{153(3.1.3\240\240)3 C(2.1.3)WB 11 Sn( Char)HY(ac)HY(ter)YH( Type and Encod)HY(ing)YH()153 1 TN()EA()BN}if +3 NH le{154(3.1.4\240\240)3 C(2.1.4)WB 12 Sn( XML Schema Names)HY(pace)YH()154 1 TN()EA()BN}if +3 NH le{155(3.1.5\240\240)3 C(2.1.5)WB 13 Sn( Anony)HY(mous)YH( Types)155 1 TN()EA()BN}if +2 NH le{156(3.2\240\240)2 C(2.2)WB 14 Sn( Error Handling)156 1 TN()EA()BN}if +3 NH le{157(3.2.1\240\240)3 C(2.2.1)WB 15 Sn( )SM(xml_schema::dupli)HY(cate)YH(_id)ES()157 1 TN()EA()BN}if +2 NH le{158(3.3\240\240)2 C(2.3)WB 16 Sn( Mapping for )SM(import)ES( and )SM(include)ES()158 1 TN()EA()BN}if +3 NH le{159(3.3.1\240\240)3 C(2.3.1)WB 17 Sn( Import)159 1 TN()EA()BN}if +3 NH le{160(3.3.2\240\240)3 C(2.3.2)WB 18 Sn( Inclu)HY(sion)YH( with Target Names)HY(pace)YH()160 1 TN()EA()BN}if +3 NH le{161(3.3.3\240\240)3 C(2.3.3)WB 19 Sn( Inclu)HY(sion)YH( without Target Names)HY(pace)YH()161 1 TN()EA()BN}if +2 NH le{162(3.4\240\240)2 C(2.4)WB 20 Sn( Mapping for Names)HY(paces)YH()162 1 TN()EA()BN}if +2 NH le{163(3.5\240\240)2 C(2.5)WB 21 Sn( Mapping for Built-in Data Types)163 1 TN()EA()BN}if +3 NH le{164(3.5.1\240\240)3 C(2.5.1)WB 23 Sn( Inher)HY(i)HY(tance)YH( from Built-in Data Types)164 1 TN()EA()BN}if +3 NH le{165(3.5.2\240\240)3 C(2.5.2)WB 24 Sn( Mapping for )SM(anyType)ES()165 1 TN()EA()BN}if +3 NH le{166(3.5.3\240\240)3 C(2.5.3)WB 25 Sn( Mapping for )SM(anySim)HY(ple)HY(Type)YH()ES()166 1 TN()EA()BN}if +3 NH le{167(3.5.4\240\240)3 C(2.5.4)WB 26 Sn( Mapping for )SM(QName)ES()167 1 TN()EA()BN}if +3 NH le{168(3.5.5\240\240)3 C(2.5.5)WB 27 Sn( Mapping for )SM(IDREF)ES()168 1 TN()EA()BN}if +3 NH le{169(3.5.6\240\240)3 C(2.5.6)WB 28 Sn( Mapping for )SM(base64Binary)ES( and + )SM(hexBi)HY(nary)YH()ES()169 1 TN()EA()BN}if +2 NH le{170(3.6\240\240)2 C(2.5.7)WB 29 Sn( Time Zone Repre)HY(sen)HY(ta)HY(tion)YH()170 1 TN()EA()BN}if +2 NH le{171(3.7\240\240)2 C(2.5.8)WB 30 Sn( Mapping for )SM(date)ES()171 1 TN()EA()BN}if +2 NH le{172(3.8\240\240)2 C(2.5.9)WB 31 Sn( Mapping for )SM(date)HY(Time)YH()ES()172 1 TN()EA()BN}if +2 NH le{173(3.9\240\240)2 C(2.5.10)WB 32 Sn( Mapping for )SM(dura)HY(tion)YH()ES()173 1 TN()EA()BN}if +2 NH le{174(3.10\240\240)2 C(2.5.11)WB 33 Sn( Mapping for )SM(gDay)ES()174 1 TN()EA()BN}if +2 NH le{175(3.11\240\240)2 C(2.5.12)WB 34 Sn( Mapping for )SM(gMonth)ES()175 1 TN()EA()BN}if +2 NH le{176(3.12\240\240)2 C(2.5.13)WB 35 Sn( Mapping for )SM(gMon)HY(th)HY(Day)YH()ES()176 1 TN()EA()BN}if +2 NH le{177(3.13\240\240)2 C(2.5.14)WB 36 Sn( Mapping for )SM(gYear)ES()177 1 TN()EA()BN}if +2 NH le{178(3.14\240\240)2 C(2.5.15)WB 37 Sn( Mapping for )SM(gYear)HY(Month)YH()ES()178 1 TN()EA()BN}if +2 NH le{179(3.15\240\240)2 C(2.5.16)WB 38 Sn( Mapping for )SM(time)ES()179 1 TN()EA()BN}if +2 NH le{180(3.16\240\240)2 C(2.6)WB 39 Sn( Mapping for Simple Types)180 1 TN()EA()BN}if +3 NH le{181(3.16.1\240\240)3 C(2.6.1)WB 40 Sn( Mapping for Deriva)HY(tion)YH( by Restric)HY(tion)YH()181 1 TN()EA()BN}if +3 NH le{182(3.16.2\240\240)3 C(2.6.2)WB 41 Sn( Mapping for Enumer)HY(a)HY(tions)YH()182 1 TN()EA()BN}if +3 NH le{183(3.16.3\240\240)3 C(2.6.3)WB 42 Sn( Mapping for Deriva)HY(tion)YH( by List)183 1 TN()EA()BN}if +3 NH le{184(3.16.4\240\240)3 C(2.6.4)WB 43 Sn( Mapping for Deriva)HY(tion)YH( by Union)184 1 TN()EA()BN}if +2 NH le{185(3.17\240\240)2 C(2.7)WB 44 Sn( Mapping for Complex Types)185 1 TN()EA()BN}if +3 NH le{186(3.17.1\240\240)3 C(2.7.1)WB 45 Sn( Mapping for Deriva)HY(tion)YH( by Exten)HY(sion)YH()186 1 TN()EA()BN}if +3 NH le{187(3.17.2\240\240)3 C(2.7.2)WB 46 Sn( Mapping for Deriva)HY(tion)YH( by Restric)HY(tion)YH()187 1 TN()EA()BN}if +2 NH le{188(3.18\240\240)2 C(2.8)WB 47 Sn( Mapping for Local Elements and Attributes)188 1 TN()EA()BN}if +3 NH le{189(3.18.1\240\240)3 C(2.8.1)WB 48 Sn( Mapping for Members with the One Cardi)HY(nal)HY(ity)YH( Class)189 1 TN()EA()BN}if +3 NH le{190(3.18.2\240\240)3 C(2.8.2)WB 49 Sn( Mapping for Members with the Optional Cardi)HY(nal)HY(ity)YH( Class)190 1 TN()EA()BN}if +3 NH le{191(3.18.3\240\240)3 C(2.8.3)WB 50 Sn( Mapping for Members with the Sequence Cardi)HY(nal)HY(ity)YH( Class)191 1 TN()EA()BN}if +3 NH le{192(3.18.4\240\240)3 C(2.8.4)WB 51 Sn( Element Order)192 1 TN()EA()BN}if +2 NH le{193(3.19\240\240)2 C(2.9)WB 52 Sn( Mapping for Global Elements)193 1 TN()EA()BN}if +3 NH le{194(3.19.1\240\240)3 C(2.9.1)WB 53 Sn( Element Types)194 1 TN()EA()BN}if +3 NH le{195(3.19.2\240\240)3 C(2.9.2)WB 54 Sn( Element Map)195 1 TN()EA()BN}if +2 NH le{196(3.20\240\240)2 C(2.10)WB 55 Sn( Mapping for Global Attributes)196 1 TN()EA()BN}if +2 NH le{197(3.21\240\240)2 C(2.11)WB 56 Sn( Mapping for )SM(xsi:type)ES( and Substi)HY(tu)HY(tion)YH( + Groups)197 1 TN()EA()BN}if +2 NH le{198(3.22\240\240)2 C(2.12)WB 57 Sn( Mapping for )SM(any)ES( and )SM(anyAt)HY(tribute)YH()ES()198 1 TN()EA()BN}if +3 NH le{199(3.22.1\240\240)3 C(2.12.1)WB 58 Sn( Mapping for )SM(any)ES( with the One Cardi)HY(nal)HY(ity)YH( Class)199 1 TN()EA()BN}if +3 NH le{200(3.22.2\240\240)3 C(2.12.2)WB 59 Sn( Mapping for )SM(any)ES( with the Optional Cardi)HY(nal)HY(ity)YH( Class)200 1 TN()EA()BN}if +3 NH le{201(3.22.3\240\240)3 C(2.12.3)WB 60 Sn( Mapping for )SM(any)ES( with the Sequence Cardi)HY(nal)HY(ity)YH( Class)201 1 TN()EA()BN}if +3 NH le{202(3.22.4\240\240)3 C(2.12.4)WB 61 Sn( Element Wild)HY(card)YH( Order)202 1 TN()EA()BN}if +3 NH le{203(3.22.5\240\240)3 C(2.12.5)WB 62 Sn( Mapping for )SM(anyAt)HY(tribute)YH()ES()203 1 TN()EA()BN}if +2 NH le{204(3.23\240\240)2 C(2.13)WB 63 Sn( Mapping for Mixed Content Models)204 1 TN()EA()BN}if +1 NH le{205(4\240\240)1 C(3)WB 64 Sn( Parsing)205 1 TN()EA()BN}if +2 NH le{206(4.1\240\240)2 C(3.1)WB 65 Sn( Initial)HY(iz)HY(ing)YH( the Xerces-C++ Runtime)206 1 TN()EA()BN}if +2 NH le{207(4.2\240\240)2 C(3.2)WB 66 Sn( Flags and Prop)HY(er)HY(ties)YH()207 1 TN()EA()BN}if +2 NH le{208(4.3\240\240)2 C(3.3)WB 67 Sn( Error Handling)208 1 TN()EA()BN}if +3 NH le{209(4.3.1\240\240)3 C(3.3.1)WB 68 Sn( )SM(xml_schema::parsing)ES()209 1 TN()EA()BN}if +3 NH le{210(4.3.2\240\240)3 C(3.3.2)WB 69 Sn( )SM(xml_schema::expected_element)ES()210 1 TN()EA()BN}if +3 NH le{211(4.3.3\240\240)3 C(3.3.3)WB 70 Sn( )SM(xml_schema::unex)HY(pected)YH(_element)ES()211 1 TN()EA()BN}if +3 NH le{212(4.3.4\240\240)3 C(3.3.4)WB 71 Sn( )SM(xml_schema::expected_attribute)ES()212 1 TN()EA()BN}if +3 NH le{213(4.3.5\240\240)3 C(3.3.5)WB 72 Sn( )SM(xml_schema::unex)HY(pected)YH(_enumer)HY(a)HY(tor)YH()ES()213 1 TN()EA()BN}if +3 NH le{214(4.3.6\240\240)3 C(3.3.6)WB 73 Sn( )SM(xml_schema::expected_text_content)ES()214 1 TN()EA()BN}if +3 NH le{215(4.3.7\240\240)3 C(3.3.7)WB 74 Sn( )SM(xml_schema::no_type_info)ES()215 1 TN()EA()BN}if +3 NH le{216(4.3.8\240\240)3 C(3.3.8)WB 75 Sn( )SM(xml_schema::not_derived)ES()216 1 TN()EA()BN}if +3 NH le{217(4.3.9\240\240)3 C(3.3.9)WB 76 Sn( )SM(xml_schema::no_prefix_mapping)ES()217 1 TN()EA()BN}if +2 NH le{218(4.4\240\240)2 C(3.4)WB 77 Sn( Reading from a Local File or URI)218 1 TN()EA()BN}if +2 NH le{219(4.5\240\240)2 C(3.5)WB 78 Sn( Reading from )SM(std::istream)ES()219 1 TN()EA()BN}if +2 NH le{220(4.6\240\240)2 C(3.6)WB 79 Sn( Reading from )SM(xercesc::Input)HY(Source)YH()ES()220 1 TN()EA()BN}if +2 NH le{221(4.7\240\240)2 C(3.7)WB 80 Sn( Reading from DOM)221 1 TN()EA()BN}if +1 NH le{222(5\240\240)1 C(4)WB 81 Sn( Seri)HY(al)HY(iza)HY(tion)YH()222 1 TN()EA()BN}if +2 NH le{223(5.1\240\240)2 C(4.1)WB 82 Sn( Initial)HY(iz)HY(ing)YH( the Xerces-C++ Runtime)223 1 TN()EA()BN}if +2 NH le{224(5.2\240\240)2 C(4.2)WB 83 Sn( Names)HY(pace)YH( Infomap and Char)HY(ac)HY(ter)YH( Encod)HY(ing)YH()224 1 TN()EA()BN}if +2 NH le{225(5.3\240\240)2 C(4.3)WB 84 Sn( Flags)225 1 TN()EA()BN}if +2 NH le{226(5.4\240\240)2 C(4.4)WB 85 Sn( Error Handling)226 1 TN()EA()BN}if +3 NH le{227(5.4.1\240\240)3 C(4.4.1)WB 86 Sn( )SM(xml_schema::seri)HY(al)HY(iza)HY(tion)YH()ES()227 1 TN()EA()BN}if +3 NH le{228(5.4.2\240\240)3 C(4.4.2)WB 87 Sn( )SM(xml_schema::unex)HY(pected)YH(_element)ES()228 1 TN()EA()BN}if +3 NH le{229(5.4.3\240\240)3 C(4.4.3)WB 88 Sn( )SM(xml_schema::no_type_info)ES()229 1 TN()EA()BN}if +2 NH le{230(5.5\240\240)2 C(4.5)WB 89 Sn( Seri)HY(al)HY(iz)HY(ing)YH( to )SM(std::ostream)ES()230 1 TN()EA()BN}if +2 NH le{231(5.6\240\240)2 C(4.6)WB 90 Sn( Seri)HY(al)HY(iz)HY(ing)YH( to )SM(xercesc::XMLFor)HY(mat)HY(Tar)HY(get)YH()ES()231 1 TN()EA()BN}if +2 NH le{232(5.7\240\240)2 C(4.7)WB 91 Sn( Seri)HY(al)HY(iz)HY(ing)YH( to DOM)232 1 TN()EA()BN}if +1 NH le{233(6\240\240)1 C(5)WB 92 Sn( Addi)HY(tional)YH( Func)HY(tion)HY(al)HY(ity)YH()233 1 TN()EA()BN}if +2 NH le{234(6.1\240\240)2 C(5.1)WB 93 Sn( DOM Asso)HY(ci)HY(a)HY(tion)YH()234 1 TN()EA()BN}if +2 NH le{235(6.2\240\240)2 C(5.2)WB 94 Sn( Binary Seri)HY(al)HY(iza)HY(tion)YH()235 1 TN()EA()BN}if +1 NH le{236(7\240\240)1 C(Appendix)WB 95 Sn( A \236 Default and Fixed Values)236 1 TN()EA()BN}if +/OU t D /Cb Db D NP Ep ET +/Cb Db D /Ct [16#00 16#00 16#00] D /Cl [16#00 16#00 16#00] D /CL -1 D Ct Sc + +/Ba f D /BO 0 D Bs +/UR (/home/boris/work/xsd/builds/gcc8-host/xsd/doc/cxx/tree/manual/index.xhtml) D +/Ti (C++/Tree Mapping User Manual) D +/Au () D +/Df f D +/ME [(4.1.0)] D + +NP RC ZF +()1 Sl()WB 0 Sn( + +)BR()WB 1 Sn( )BR()WB 2 Sn( + + + )0 1 0 H(Preface)WB 145 Sn()WB 3 Sn()EA()EH( + + )0 2 1 H(About)WB 146 Sn()WB 4 Sn( This Docu)HY(ment)YH()EA()EH( + + )0 P(This docu)HY(ment)YH( describes the mapping of W3C XML Schema + to the C++ program)HY(ming)YH( language as imple)HY(mented)YH( by + )R1 2 A(CodeSyn)HY(the)HY(sis)YH( + XSD)EA( - an XML Schema to C++ data binding compiler. The mapping + repre)HY(sents)YH( infor)HY(ma)HY(tion)YH( stored in XML instance docu)HY(ments)YH( as a + stat)HY(i)HY(cally)YH(-typed, tree-like in-memory data struc)HY(ture)YH( and is + called C++/Tree. + )EP( + + )0 P(Revi)HY(sion)YH( 4.1.0)BR( + This revi)HY(sion)YH( of the manual describes the C++/Tree + mapping as imple)HY(mented)YH( by CodeSyn)HY(the)HY(sis)YH( XSD version 4.1.0. + )EP( + + )0 P(This docu)HY(ment)YH( is avail)HY(able)YH( in the follow)HY(ing)YH( formats: + )R1 2 A(XHTML)EA(, + )R2 2 A(PDF)EA(, and + )R3 2 A(PostScript)EA(.)EP( + + )0 2 2 H(More)WB 147 Sn()WB 5 Sn( Infor)HY(ma)HY(tion)YH()EA()EH( + + )0 P(Beyond this manual, you may also find the follow)HY(ing)YH( sources of + infor)HY(ma)HY(tion)YH( useful:)EP( + + )UL( )-1 LI()R2 2 A(C++/Tree + Mapping Getting Started Guide)EA( + + )-1 LI()R3 2 A(C++/Tree + Mapping Customiza)HY(tion)YH( Guide)EA( + + )-1 LI()R4 2 A(C++/Tree + Mapping Frequently Asked Ques)HY(tions)YH( \201FAQ\202)EA( + + )-1 LI()R5 2 A(XSD + Compiler Command Line Manual)EA( + + )-1 LI(The )SM(cxx/tree/)ES( direc)HY(tory)YH( in the + )R6 2 A(xsd-exam)HY(ples)YH()EA( package + contains a collec)HY(tion)YH( of exam)HY(ples)YH( and a README file with an overview + of each example. + + )-1 LI(The )SM(README)ES( file in the + )R6 2 A(xsd-exam)HY(ples)YH()EA( package + explains how to build the exam)HY(ples)YH(. + + )-1 LI(The )R7 2 A(xsd-users)EA( + mailing list is a place to ask ques)HY(tions)YH(. Further)HY(more)YH( the + )R8 2 A(archives)EA( + may already have answers to some of your ques)HY(tions)YH(. + )LU( + + + )0 1 3 H(1)WB 148 Sn()WB 6 Sn( Intro)HY(duc)HY(tion)YH()EA()EH( + + )0 P(C++/Tree is a W3C XML Schema to C++ mapping that repre)HY(sents)YH( the + data stored in XML as a stat)HY(i)HY(cally)YH(-typed, vocab)HY(u)HY(lary)YH(-specific + object model. Based on a formal descrip)HY(tion)YH( of an XML vocab)HY(u)HY(lary)YH( + \201schema\202, the C++/Tree mapping produces a tree-like data struc)HY(ture)YH( + suit)HY(able)YH( for in-memory process)HY(ing)YH( as well as XML parsing and + seri)HY(al)HY(iza)HY(tion)YH( code.)EP( + + )0 P(A typical appli)HY(ca)HY(tion)YH( that processes XML docu)HY(ments)YH( usually + performs the follow)HY(ing)YH( three steps: it first reads \201parses\202 an XML + instance docu)HY(ment)YH( to an object model, it then performs + some useful compu)HY(ta)HY(tions)YH( on that model which may involve + modi)HY(fi)HY(ca)HY(tion)YH( of the model, and finally it may write \201seri)HY(al)HY(ize)YH(\202 + the modi)HY(fied)YH( object model back to XML. + )EP( + + )0 P(The C++/Tree mapping consists of C++ types that repre)HY(sent)YH( the + given vocab)HY(u)HY(lary)YH( \201)0 97 1 A(Chapter 2, "C++/Tree Mapping")97 0 TN TL()Ec /AF f D(\202, + a set of parsing func)HY(tions)YH( that convert XML docu)HY(ments)YH( to + a tree-like in-memory data struc)HY(ture)YH( \201)0 98 1 A(Chapter 3, + "Parsing")98 0 TN TL()Ec /AF f D(\202, and a set of seri)HY(al)HY(iza)HY(tion)YH( func)HY(tions)YH( that convert + the object model back to XML \201)0 99 1 A(Chapter 4, + "Seri)HY(al)HY(iza)HY(tion)YH(")99 0 TN TL()Ec /AF f D(\202. Further)HY(more)YH(, the mapping provides a number + of addi)HY(tional)YH( features, such as DOM asso)HY(ci)HY(a)HY(tion)YH( and binary + seri)HY(al)HY(iza)HY(tion)YH(, that can be useful in some appli)HY(ca)HY(tions)YH( + \201)0 100 1 A(Chapter 5, "Addi)HY(tional)YH( Func)HY(tion)HY(al)HY(ity)YH(")100 0 TN TL()Ec /AF f D(\202. + )EP( + + + + + + )0 1 4 H(2)WB 149 Sn()WB 7 Sn( C++/Tree Mapping)EA()EH( + + )0 2 5 H(2.1)WB 150 Sn()WB 8 Sn( Prelim)HY(i)HY(nary)YH( Infor)HY(ma)HY(tion)YH()EA()EH( + + )0 3 6 H(2.1.1)WB 151 Sn()WB 9 Sn( C++ Stan)HY(dard)YH()EA()EH( + + )0 P(The C++/Tree mapping provides support for ISO/IEC C++ 2011 \201C++11\202 + and ISO/IEC C++ 1998/2003 \201C++98\202. To select the C++ stan)HY(dard)YH( for the + gener)HY(ated)YH( code we use the )SM(--std)ES( XSD compiler command + line option. While the major)HY(ity)YH( of the exam)HY(ples)YH( in this guide use + C++11, the docu)HY(ment)YH( explains the C++11/98 usage differ)HY(ence)YH( and so + they can easily be converted to C++98.)EP( + + )0 3 7 H(2.1.2)WB 152 Sn()WB 10 Sn( Iden)HY(ti)HY(fiers)YH()EA()EH( + + )0 P(XML Schema names may happen to be reserved C++ keywords or contain + char)HY(ac)HY(ters)YH( that are illegal in C++ iden)HY(ti)HY(fiers)YH(. To avoid C++ compi)HY(la)HY(tion)YH( + prob)HY(lems)YH(, such names are changed \201escaped\202 when mapped to C++. If an + XML Schema name is a C++ keyword, the "_" suffix is added to it. All + char)HY(ac)HY(ter)YH( of an XML Schema name that are not allowed in C++ iden)HY(ti)HY(fiers)YH( + are replaced with "_". + )EP( + + )0 P(For example, XML Schema name )SM(try)ES( will be mapped to + C++ iden)HY(ti)HY(fier)YH( )SM(try_)ES(. Simi)HY(larly)YH(, XML Schema name + )SM(strange.na-me)ES( will be mapped to C++ iden)HY(ti)HY(fier)YH( + )SM(strange_na_me)ES(. + )EP( + + )0 P(Further)HY(more)YH(, conflicts between type names and func)HY(tion)YH( names in the + same scope are resolved using name escap)HY(ing)YH(. Such conflicts include + both a global element \201which is mapped to a set of parsing and/or + seri)HY(al)HY(iza)HY(tion)YH( func)HY(tions)YH( or element types, see )0 101 1 A(Section + 2.9, "Mapping for Global Elements")101 0 TN TL()Ec /AF f D(\202 and a global type sharing the + same name as well as a local element or attribute inside a type having + the same name as the type itself.)EP( + + )0 P(For example, if we had a global type )SM(catalog)ES( + and a global element with the same name then the type would be + mapped to a C++ class with name )SM(catalog)ES( while the + parsing func)HY(tions)YH( corre)HY(spond)HY(ing)YH( to the global element would have + their names escaped as )SM(catalog_)ES(. + )EP( + + )0 P(By default the mapping uses the so-called K&R \201Kernighan and + Ritchie\202 iden)HY(ti)HY(fier)YH( naming conven)HY(tion)YH( which is also used through)HY(out)YH( + this manual. In this conven)HY(tion)YH( both type and func)HY(tion)YH( names are in + lower case and words are sepa)HY(rated)YH( by under)HY(scores)YH(. If your appli)HY(ca)HY(tion)YH( + code or schemas use a differ)HY(ent)YH( nota)HY(tion)YH(, you may want to change the + naming conven)HY(tion)YH( used by the mapping for consis)HY(tency)YH(. + The compiler supports a set of widely-used naming conven)HY(tions)YH( + that you can select with the )SM(--type-naming)ES( and + )SM(--func)HY(tion)YH(-naming)ES( options. You can also further + refine one of the prede)HY(fined)YH( conven)HY(tions)YH( or create a completely + custom naming scheme by using the )SM(--*-regex)ES( options. + For more detailed infor)HY(ma)HY(tion)YH( on these options refer to the NAMING + CONVEN)HY(TION)YH( section in the )R5 2 A(XSD + Compiler Command Line Manual)EA(.)EP( + + )0 3 8 H(2.1.3)WB 153 Sn()WB 11 Sn( Char)HY(ac)HY(ter)YH( Type and Encod)HY(ing)YH()EA()EH( + + )0 P(The code that imple)HY(ments)YH( the mapping, depend)HY(ing)YH( on the + )SM(--char-type)ES( option, is gener)HY(ated)YH( using either + )SM(char)ES( or )SM(wchar_t)ES( as the char)HY(ac)HY(ter)YH( + type. In this docu)HY(ment)YH( code samples use symbol )SM(C)ES( + to refer to the char)HY(ac)HY(ter)YH( type you have selected when trans)HY(lat)HY(ing)YH( + your schemas, for example )SM(std::basic_string)ES(. + )EP( + + )0 P(Another aspect of the mapping that depends on the char)HY(ac)HY(ter)YH( type + is char)HY(ac)HY(ter)YH( encod)HY(ing)YH(. For the )SM(char)ES( char)HY(ac)HY(ter)YH( type + the default encod)HY(ing)YH( is UTF-8. Other supported encod)HY(ings)YH( are + ISO-8859-1, Xerces-C++ Local Code Page \201LPC\202, as well as + custom encod)HY(ings)YH( and can be selected with the + )SM(--char-encod)HY(ing)YH()ES( command line option.)EP( + + )0 P(For the )SM(wchar_t)ES( char)HY(ac)HY(ter)YH( type the encod)HY(ing)YH( is + auto)HY(mat)HY(i)HY(cally)YH( selected between UTF-16 and UTF-32/UCS-4 depend)HY(ing)YH( + on the size of the )SM(wchar_t)ES( type. On some plat)HY(forms)YH( + \201for example, Windows with Visual C++ and AIX with IBM XL C++\202 + )SM(wchar_t)ES( is 2 bytes long. For these plat)HY(forms)YH( the + encod)HY(ing)YH( is UTF-16. On other plat)HY(forms)YH( )SM(wchar_t)ES( is 4 bytes + long and UTF-32/UCS-4 is used.)EP( + + )0 3 9 H(2.1.4)WB 154 Sn()WB 12 Sn( XML Schema Names)HY(pace)YH()EA()EH( + + )0 P(The mapping relies on some prede)HY(fined)YH( types, classes, and func)HY(tions)YH( + that are logi)HY(cally)YH( defined in the XML Schema names)HY(pace)YH( reserved for + the XML Schema language \201)SM(http://www.w3.org/2001/XMLSchema)ES(\202. + By default, this names)HY(pace)YH( is mapped to C++ names)HY(pace)YH( + )SM(xml_schema)ES(. It is auto)HY(mat)HY(i)HY(cally)YH( acces)HY(si)HY(ble)YH( + from a C++ compi)HY(la)HY(tion)YH( unit that includes a header file gener)HY(ated)YH( + from an XML Schema defi)HY(ni)HY(tion)YH(. + )EP( + + )0 P(Note that, if desired, the default mapping of this names)HY(pace)YH( can be + changed as described in )0 102 1 A(Section 2.4, "Mapping for + Names)HY(paces)YH(")102 0 TN TL()Ec /AF f D(. + )EP( + + + )0 3 10 H(2.1.5)WB 155 Sn()WB 13 Sn( Anony)HY(mous)YH( Types)EA()EH( + + )0 P(For the purpose of code gener)HY(a)HY(tion)YH(, anony)HY(mous)YH( types defined in + XML Schema are auto)HY(mat)HY(i)HY(cally)YH( assigned names that are derived + from enclos)HY(ing)YH( attributes and elements. Other)HY(wise)YH(, such types + follows stan)HY(dard)YH( mapping rules for simple and complex type + defi)HY(ni)HY(tions)YH( \201see )0 103 1 A(Section 2.6, "Mapping for Simple Types")103 0 TN TL()Ec /AF f D( + and )0 104 1 A(Section 2.7, "Mapping for Complex Types")104 0 TN TL()Ec /AF f D(\202. + For example, in the follow)HY(ing)YH( schema frag)HY(ment)YH(: + )EP( + + ) 5 23 PR( + + ... + +)RP( + + )0 P(The anony)HY(mous)YH( type defined inside element )SM(object)ES( will + be given name )SM(object)ES(. The compiler has a number of + options that control the process of anony)HY(mous)YH( type naming. For more + infor)HY(ma)HY(tion)YH( refer to the )R5 2 A(XSD + Compiler Command Line Manual)EA(.)EP( + + + )0 2 11 H(2.2)WB 156 Sn()WB 14 Sn( Error Handling)EA()EH( + + )0 P(The mapping uses the C++ excep)HY(tion)YH( handling mech)HY(a)HY(nism)YH( as a primary way + of report)HY(ing)YH( error condi)HY(tions)YH(. All excep)HY(tions)YH( that are spec)HY(i)HY(fied)YH( in + this mapping derive from )SM(xml_schema::excep)HY(tion)YH()ES( which + itself is derived from )SM(std::excep)HY(tion)YH()ES(: + )EP( + + ) 14 60 PR(struct exception: virtual std::exception +{ + friend + std::basic_ostream& + operator<< \201std::basic_ostream& os, const exception& e\202 + { + e.print \201os\202; + return os; + } + +protected: + virtual void + print \201std::basic_ostream&\202 const = 0; +};)RP( + + )0 P(The excep)HY(tion)YH( hier)HY(ar)HY(chy)YH( supports "virtual" )SM(oper)HY(a)HY(tor)YH(<<)ES( + which allows you to obtain diag)HY(nos)HY(tics)YH( corre)HY(spond)HY(ing)YH( to the thrown + excep)HY(tion)YH( using the base excep)HY(tion)YH( inter)HY(face)YH(. For example:)EP( + + ) 8 38 PR(try +{ + ... +} +catch \201const xml_schema::exception& e\202 +{ + cerr << e << endl; +})RP( + + )0 P(The follow)HY(ing)YH( sub-sections describe excep)HY(tions)YH( thrown by the + types that consti)HY(tute)YH( the object model. + )0 105 1 A(Section 3.3, "Error Handling")105 0 TN TL()Ec /AF f D( of + )0 98 1 A(Chapter 3, "Parsing")98 0 TN TL()Ec /AF f D( describes excep)HY(tions)YH( + and error handling mech)HY(a)HY(nisms)YH( specific to the parsing func)HY(tions)YH(. + )0 106 1 A(Section 4.4, "Error Handling")106 0 TN TL()Ec /AF f D( of + )0 99 1 A(Chapter 4, "Seri)HY(al)HY(iza)HY(tion)YH(")99 0 TN TL()Ec /AF f D( describes excep)HY(tions)YH( + and error handling mech)HY(a)HY(nisms)YH( specific to the seri)HY(al)HY(iza)HY(tion)YH( func)HY(tions)YH(. + )EP( + + + )0 3 12 H(2.2.1)WB 157 Sn()WB 15 Sn( )SM(xml_schema::dupli)HY(cate)YH(_id)ES()EA()EH( + + ) 10 48 PR(struct duplicate_id: virtual exception +{ + duplicate_id \201const std::basic_string& id\202; + + const std::basic_string& + id \201\202 const; + + virtual const char* + what \201\202 const throw \201\202; +};)RP( + + )0 P(The )SM(xml_schema::dupli)HY(cate)YH(_id)ES( is thrown when + a conflict)HY(ing)YH( instance of )SM(xml_schema::id)ES( \201see + )0 107 1 A(Section 2.5, "Mapping for Built-in Data Types")107 0 TN TL()Ec /AF f D(\202 + is added to a tree. The offend)HY(ing)YH( ID value can be obtained using + the )SM(id)ES( func)HY(tion)YH(. + )EP( + + )0 2 13 H(2.3)WB 158 Sn()WB 16 Sn( Mapping for )SM(import)ES( and )SM(include)ES()EA()EH( + + )0 3 14 H(2.3.1)WB 159 Sn()WB 17 Sn( Import)EA()EH( + + )0 P(The XML Schema )SM(import)ES( element is mapped to the C++ + Prepro)HY(ces)HY(sor)YH( )SM(#include)ES( direc)HY(tive)YH(. The value of + the )SM(schemaLo)HY(ca)HY(tion)YH()ES( attribute is used to derive + the name of the header file that appears in the )SM(#include)ES( + direc)HY(tive)YH(. For instance: + )EP( + + ) 2 54 PR()RP( + + )0 P(is mapped to:)EP( + + ) 1 19 PR(#include "test.hxx")RP( + + )0 P(Note that you will need to compile imported schemas sepa)HY(rately)YH( + in order to produce corre)HY(spond)HY(ing)YH( header files.)EP( + + )0 3 15 H(2.3.2)WB 160 Sn()WB 18 Sn( Inclu)HY(sion)YH( with Target Names)HY(pace)YH()EA()EH( + + )0 P(The XML Schema )SM(include)ES( element which refers to a schema + with a target names)HY(pace)YH( or appears in a schema without a target names)HY(pace)YH( + follows the same mapping rules as the )SM(import)ES( element, + see )0 108 1 A(Section 2.3.1, "Import")108 0 TN TL()Ec /AF f D(. + )EP( + + )0 3 16 H(2.3.3)WB 161 Sn()WB 19 Sn( Inclu)HY(sion)YH( without Target Names)HY(pace)YH()EA()EH( + + )0 P(For the XML Schema )SM(include)ES( element which refers to a schema + without a target names)HY(pace)YH( and appears in a schema with a target + names)HY(pace)YH( \201such inclu)HY(sion)YH( some)HY(times)YH( called "chameleon inclu)HY(sion)YH("\202, + decla)HY(ra)HY(tions)YH( and defi)HY(ni)HY(tions)YH( from the included schema are gener)HY(ated)YH( + in-line in the names)HY(pace)YH( of the includ)HY(ing)YH( schema as if they were + declared and defined there verba)HY(tim)YH(. For example, consider the + follow)HY(ing)YH( two schemas: + )EP( + + ) 11 61 PR(<-- common.xsd --> + + + ... + + + +<-- test.xsd --> + + +)RP( + + )0 P(The frag)HY(ment)YH( of inter)HY(est)YH( from the gener)HY(ated)YH( header file for + )SM(text.xsd)ES( would look like this:)EP( + + ) 8 14 PR(// test.hxx +namespace test +{ + class type + { + ... + }; +})RP( + + )0 2 17 H(2.4)WB 162 Sn()WB 20 Sn( Mapping for Names)HY(paces)YH()EA()EH( + + )0 P(An XML Schema names)HY(pace)YH( is mapped to one or more nested C++ + names)HY(paces)YH(. XML Schema names)HY(paces)YH( are iden)HY(ti)HY(fied)YH( by URIs. + By default, a names)HY(pace)YH( URI is mapped to a sequence of + C++ names)HY(pace)YH( names by remov)HY(ing)YH( the proto)HY(col)YH( and host parts + and split)HY(ting)YH( the rest into a sequence of names with ')SM(/)ES(' + as the name sepa)HY(ra)HY(tor)YH(. For instance: + )EP( + + ) 3 68 PR( + ... +)RP( + + )0 P(is mapped to:)EP( + + ) 7 16 PR(namespace system +{ + namespace test + { + ... + } +})RP( + + )0 P(The default mapping of names)HY(pace)YH( URIs to C++ names)HY(pace)YH( names can be + altered using the )SM(--names)HY(pace)YH(-map)ES( and + )SM(--names)HY(pace)YH(-regex)ES( options. See the + )R5 2 A(XSD + Compiler Command Line Manual)EA( for more infor)HY(ma)HY(tion)YH(. + )EP( + + )0 2 18 H(2.5)WB 163 Sn()WB 21 Sn( Mapping for Built-in Data Types)EA()EH( + + )0 P(The mapping of XML Schema built-in data types to C++ types is + summa)HY(rized)YH( in the table below.)EP( + + + )0 PT( + + )0 P(All XML Schema built-in types are mapped to C++ classes that are + derived from the )SM(xml_schema::simple_type)ES( class except + where the mapping is to a funda)HY(men)HY(tal)YH( C++ type.)EP( + + )0 P(The )SM(sequence)ES( class template is defined in an + imple)HY(men)HY(ta)HY(tion)YH(-specific names)HY(pace)YH(. It conforms to the + sequence inter)HY(face)YH( as defined by the ISO/ANSI Stan)HY(dard)YH( for + C++ \201ISO/IEC 14882:1998, Section 23.1.1, "Sequences"\202. + Prac)HY(ti)HY(cally)YH(, this means that you can treat such a sequence + as if it was )SM(std::vector)ES(. One notable exten)HY(sion)YH( + to the stan)HY(dard)YH( inter)HY(face)YH( that is avail)HY(able)YH( only for + sequences of non-funda)HY(men)HY(tal)YH( C++ types is the addi)HY(tion)YH( of + the over)HY(loaded)YH( )SM(push_back)ES( and )SM(insert)ES( + member func)HY(tions)YH( which instead of the constant refer)HY(ence)YH( + to the element type accept auto)HY(matic)YH( pointer \201)SM(std::unique_ptr)ES( + or )SM(std::auto_ptr)ES(, depend)HY(ing)YH( on the C++ stan)HY(dard)YH( + selected\202 to the element type. These func)HY(tions)YH( assume owner)HY(ship)YH( + of the pointed to object and reset the passed auto)HY(matic)YH( pointer. + )EP( + + )0 3 19 H(2.5.1)WB 164 Sn()WB 23 Sn( Inher)HY(i)HY(tance)YH( from Built-in Data Types)EA()EH( + + )0 P(In cases where the mapping calls for an inher)HY(i)HY(tance)YH( from a built-in + type which is mapped to a funda)HY(men)HY(tal)YH( C++ type, a proxy type is + used instead of the funda)HY(men)HY(tal)YH( C++ type \201C++ does not allow + inher)HY(i)HY(tance)YH( from funda)HY(men)HY(tal)YH( types\202. For instance:)EP( + + ) 3 27 PR( + +)RP( + + )0 P(is mapped to:)EP( + + ) 4 42 PR(class my_int: public fundamental_base +{ + ... +};)RP( + + )0 P(The )SM(funda)HY(men)HY(tal)YH(_base)ES( class template provides a close + emula)HY(tion)YH( \201though not exact\202 of a funda)HY(men)HY(tal)YH( C++ type. + It is defined in an imple)HY(men)HY(ta)HY(tion)YH(-specific names)HY(pace)YH( and has the + follow)HY(ing)YH( inter)HY(face)YH(:)EP( + + ) 22 44 PR(template +class fundamental_base: public simple_type +{ +public: + fundamental_base \201\202; + fundamental_base \201X\202 + fundamental_base \201const fundamental_base&\202 + +public: + fundamental_base& + operator= \201const X&\202; + +public: + operator const X & \201\202 const; + operator X& \201\202; + + template + operator Y \201\202 const; + + template + operator Y \201\202; +};)RP( + + )0 3 20 H(2.5.2)WB 165 Sn()WB 24 Sn( Mapping for )SM(anyType)ES()EA()EH( + + )0 P(The XML Schema )SM(anyType)ES( built-in data type is mapped to the + )SM(xml_schema::type)ES( C++ class:)EP( + + ) 53 48 PR(class type +{ +public: + virtual + ~type \201\202; + + type \201\202; + type \201const type&\202; + + type& + operator= \201const type&\202; + + virtual type* + _clone \201\202 const; + + // anyType DOM content. + // +public: + typedef element_optional dom_content_optional; + + const dom_content_optional& + dom_content \201\202 const; + + dom_content_optional& + dom_content \201\202; + + void + dom_content \201const xercesc::DOMElement&\202; + + void + dom_content \201xercesc::DOMElement*\202;)WR( + + void + dom_content \201const dom_content_optional&\202; + + const xercesc::DOMDocument& + dom_content_document \201\202 const; + + xercesc::DOMDocument& + dom_content_document \201\202; + + bool + null_content \201\202 const; + + // DOM association. + // +public: + const xercesc::DOMNode* + _node \201\202 const; + + xercesc::DOMNode* + _node \201\202; +};)RP( + + )0 P(When )SM(xml_schema::type)ES( is used to create an instance + \201as opposed to being a base of a derived type\202, it repre)HY(sents)YH( + the XML Schema )SM(anyType)ES( type. )SM(anyType)ES( + allows any attributes and any content in any order. In the + C++/Tree mapping this content can be repre)HY(sented)YH( as a DOM + frag)HY(ment)YH(, similar to XML Schema wild)HY(cards)YH( \201)0 123 1 A(Section + 2.12, "Mapping for )SM(any)ES( and + )SM(anyAt)HY(tribute)YH()ES(")123 0 TN TL()Ec /AF f D(\202.)EP( + + )0 P(To enable auto)HY(matic)YH( extrac)HY(tion)YH( of )SM(anyType)ES( content + during parsing, the )SM(--gener)HY(ate)YH(-any-type)ES( option must be + spec)HY(i)HY(fied)YH(. Because the DOM API is used to access such content, the + Xerces-C++ runtime should be initial)HY(ized)YH( by the appli)HY(ca)HY(tion)YH( prior to + parsing and should remain initial)HY(ized)YH( for the life)HY(time)YH( of objects + with the DOM content. For more infor)HY(ma)HY(tion)YH( on the Xerces-C++ runtime + initial)HY(iza)HY(tion)YH( see )0 124 1 A(Section 3.1, "Initial)HY(iz)HY(ing)YH( the + Xerces-C++ Runtime")124 0 TN TL()Ec /AF f D(.)EP( + + )0 P(The DOM content is stored as the optional DOM element container + and the DOM content acces)HY(sors)YH( and modi)HY(fiers)YH( presented above are + iden)HY(ti)HY(cal)YH( to those gener)HY(ated)YH( for an optional element wild)HY(card)YH(. + Refer to )0 125 1 A(Section 2.12.2, "Mapping for )SM(any)ES( + with the Optional Cardi)HY(nal)HY(ity)YH( Class")125 0 TN TL()Ec /AF f D( for details on their + seman)HY(tics)YH(.)EP( + + )0 P(The )SM(dom_content_docu)HY(ment)YH(\201\202)ES( func)HY(tion)YH( returns the + DOM docu)HY(ment)YH( used to store the raw XML content corre)HY(spond)HY(ing)YH( + to the )SM(anyType)ES( instance. It is equiv)HY(a)HY(lent)YH( to the + )SM(dom_docu)HY(ment)YH(\201\202)ES( func)HY(tion)YH( gener)HY(ated)YH( for types + with wild)HY(cards)YH(.)EP( + + )0 P(The )SM(null_content\201\202)ES( acces)HY(sor)YH( is an opti)HY(miza)HY(tion)YH( func)HY(tion)YH( + that allows us to check for the lack of content without actu)HY(ally)YH( + creat)HY(ing)YH( its empty repre)HY(sen)HY(ta)HY(tion)YH(, that is, empty DOM docu)HY(ment)YH( for + )SM(anyType)ES( or empty string for )SM(anySim)HY(ple)HY(Type)YH()ES( + \201see the follow)HY(ing)YH( section for details on )SM(anySim)HY(ple)HY(Type)YH()ES(\202.)EP( + + )0 P(For more infor)HY(ma)HY(tion)YH( on DOM asso)HY(ci)HY(a)HY(tion)YH( refer to + )0 126 1 A(Section 5.1, "DOM Asso)HY(ci)HY(a)HY(tion)YH(")126 0 TN TL()Ec /AF f D(.)EP( + + )0 3 21 H(2.5.3)WB 166 Sn()WB 25 Sn( Mapping for )SM(anySim)HY(ple)HY(Type)YH()ES()EA()EH( + + )0 P(The XML Schema )SM(anySim)HY(ple)HY(Type)YH()ES( built-in data type is mapped + to the )SM(xml_schema::simple_type)ES( C++ class:)EP( + + ) 27 45 PR(class simple_type: public type +{ +public: + simple_type \201\202; + simple_type \201const C*\202; + simple_type \201const std::basic_string&\202; + + simple_type \201const simple_type&\202; + + simple_type& + operator= \201const simple_type&\202; + + virtual simple_type* + _clone \201\202 const; + + // anySimpleType text content. + // +public: + const std::basic_string& + text_content \201\202 const; + + std::basic_string& + text_content \201\202; + + void + text_content \201const std::basic_string&\202; +};)RP( + + )0 P(When )SM(xml_schema::simple_type)ES( is used to create an instance + \201as opposed to being a base of a derived type\202, it repre)HY(sents)YH( + the XML Schema )SM(anySim)HY(ple)HY(Type)YH()ES( type. )SM(anySim)HY(ple)HY(Type)YH()ES( + allows any simple content. In the C++/Tree mapping this content can + be repre)HY(sented)YH( as a string and accessed or modi)HY(fied)YH( with the + )SM(text_content\201\202)ES( func)HY(tions)YH( shown above.)EP( + + )0 3 22 H(2.5.4)WB 167 Sn()WB 26 Sn( Mapping for )SM(QName)ES()EA()EH( + + )0 P(The XML Schema )SM(QName)ES( built-in data type is mapped to the + )SM(xml_schema::qname)ES( C++ class:)EP( + + ) 25 36 PR(class qname: public simple_type +{ +public: + qname \201const ncname&\202; + qname \201const uri&, const ncname&\202; + qname \201const qname&\202; + +public: + qname& + operator= \201const qname&\202; + +public: + virtual qname* + _clone \201\202 const; + +public: + bool + qualified \201\202 const; + + const uri& + namespace_ \201\202 const; + + const ncname& + name \201\202 const; +};)RP( + + )0 P(The )SM(qual)HY(i)HY(fied)YH()ES( acces)HY(sor)YH( func)HY(tion)YH( can be used to deter)HY(mine)YH( + if the name is qual)HY(i)HY(fied)YH(.)EP( + + )0 3 23 H(2.5.5)WB 168 Sn()WB 27 Sn( Mapping for )SM(IDREF)ES()EA()EH( + + )0 P(The XML Schema )SM(IDREF)ES( built-in data type is mapped to the + )SM(xml_schema::idref)ES( C++ class. This class imple)HY(ments)YH( the + smart pointer C++ idiom:)EP( + + ) 56 44 PR(class idref: public ncname +{ +public: + idref \201const C* s\202; + idref \201const C* s, std::size_t n\202; + idref \201std::size_t n, C c\202; + idref \201const std::basic_string&\202; + idref \201const std::basic_string&, + std::size_t pos, + std::size_t n = npos\202; + +public: + idref \201const idref&\202; + +public: + virtual idref* + _clone \201\202 const; + +public: + idref& + operator= \201C c\202; + + idref& + operator= \201const C* s\202; + + idref& + operator= \201const std::basic_string&\202 + + idref& + operator= \201const idref&\202; +)WR( +public: + const type* + operator-> \201\202 const; + + type* + operator-> \201\202; + + const type& + operator* \201\202 const; + + type& + operator* \201\202; + + const type* + get \201\202 const; + + type* + get \201\202; + + // Conversion to bool. + // +public: + typedef void \201idref::*bool_convertible\202\201\202; + operator bool_convertible \201\202 const; +};)RP( + + )0 P(The object, )SM(idref)ES( instance refers to, is the imme)HY(di)HY(ate)YH( + container of the match)HY(ing)YH( )SM(id)ES( instance. For example, + with the follow)HY(ing)YH( instance docu)HY(ment)YH( and schema: + )EP( + + + ) 22 49 PR( + + + obj-1 + + + + + + + + + + + + + + + + + +)RP( + + )0 P(The )SM(ref)ES( instance in the code below will refer to + an object of type )SM(object_type)ES(:)EP( + + ) 4 53 PR(root_type& root = ...; +xml_schema::idref& ref \201root.reference \201\202\202; +object_type& obj \201dynamic_cast \201*ref\202\202; +cout << obj.text \201\202 << endl;)RP( + + )0 P(The smart pointer inter)HY(face)YH( of the )SM(idref)ES( class always + returns a pointer or refer)HY(ence)YH( to )SM(xml_schema::type)ES(. + This means that you will need to manu)HY(ally)YH( cast such pointer or + refer)HY(ence)YH( to its real \201dynamic\202 type before you can use it \201unless + all you need is the base inter)HY(face)YH( provided by + )SM(xml_schema::type)ES(\202. As a special exten)HY(sion)YH( to the XML + Schema language, the mapping supports static typing of )SM(idref)ES( + refer)HY(ences)YH( by employ)HY(ing)YH( the )SM(refType)ES( exten)HY(sion)YH( attribute. + The follow)HY(ing)YH( example illus)HY(trates)YH( this mech)HY(a)HY(nism)YH(: + )EP( + + ) 11 72 PR( + + + ... + + + + ... + +)RP( + + )0 P(With this modi)HY(fi)HY(ca)HY(tion)YH( we do not need to do manual casting anymore: + )EP( + + ) 4 51 PR(root_type& root = ...; +root_type::reference_type& ref \201root.reference \201\202\202; +object_type& obj \201*ref\202; +cout << ref->text \201\202 << endl;)RP( + + + )0 3 24 H(2.5.6)WB 169 Sn()WB 28 Sn( Mapping for )SM(base64Binary)ES( and + )SM(hexBi)HY(nary)YH()ES()EA()EH( + + )0 P(The XML Schema )SM(base64Binary)ES( and )SM(hexBi)HY(nary)YH()ES( + built-in data types are mapped to the + )SM(xml_schema::base64_binary)ES( and + )SM(xml_schema::hex_binary)ES( C++ classes, respec)HY(tively)YH(. The + )SM(base64_binary)ES( and )SM(hex_binary)ES( classes + support a simple buffer abstrac)HY(tion)YH( by inher)HY(it)HY(ing)YH( from the + )SM(xml_schema::buffer)ES( class: + )EP( + + ) 64 58 PR(class bounds: public virtual exception +{ +public: + virtual const char* + what \201\202 const throw \201\202; +}; + +class buffer +{ +public: + typedef std::size_t size_t; + +public: + buffer \201size_t size = 0\202; + buffer \201size_t size, size_t capacity\202; + buffer \201const void* data, size_t size\202; + buffer \201const void* data, size_t size, size_t capacity\202; + buffer \201void* data, + size_t size, + size_t capacity, + bool assume_ownership\202; + +public: + buffer \201const buffer&\202; + + buffer& + operator= \201const buffer&\202; + + void + swap \201buffer&\202; +)WR( +public: + size_t + capacity \201\202 const; + + bool + capacity \201size_t\202; + +public: + size_t + size \201\202 const; + + bool + size \201size_t\202; + +public: + const char* + data \201\202 const; + + char* + data \201\202; + + const char* + begin \201\202 const; + + char* + begin \201\202; + + const char* + end \201\202 const; +)WR( + char* + end \201\202; +};)RP( + + )0 P(The last over)HY(loaded)YH( construc)HY(tor)YH( reuses an exist)HY(ing)YH( data buffer instead + of making a copy. If the )SM(assume_owner)HY(ship)YH()ES( argu)HY(ment)YH( is + )SM(true)ES(, the instance assumes owner)HY(ship)YH( of the + memory block pointed to by the )SM(data)ES( argu)HY(ment)YH( and will + even)HY(tu)HY(ally)YH( release it by calling )SM(oper)HY(a)HY(tor)YH( delete)ES(. The + )SM(capac)HY(ity)YH()ES( and )SM(size)ES( modi)HY(fier)YH( func)HY(tions)YH( return + )SM(true)ES( if the under)HY(ly)HY(ing)YH( buffer has moved. + )EP( + + )0 P(The )SM(bounds)ES( excep)HY(tion)YH( is thrown if the construc)HY(tor)YH( + argu)HY(ments)YH( violate the )SM(\201size\240<=\240capac)HY(ity)YH(\202)ES( + constraint.)EP( + + )0 P(The )SM(base64_binary)ES( and )SM(hex_binary)ES( classes + support the )SM(buffer)ES( inter)HY(face)YH( and perform auto)HY(matic)YH( + decod)HY(ing)YH(/encod)HY(ing)YH( from/to the Base64 and Hex formats, respec)HY(tively)YH(: + )EP( + + ) 25 65 PR(class base64_binary: public simple_type, public buffer +{ +public: + base64_binary \201size_t size = 0\202; + base64_binary \201size_t size, size_t capacity\202; + base64_binary \201const void* data, size_t size\202; + base64_binary \201const void* data, size_t size, size_t capacity\202; + base64_binary \201void* data, + size_t size, + size_t capacity, + bool assume_ownership\202; + +public: + base64_binary \201const base64_binary&\202; + + base64_binary& + operator= \201const base64_binary&\202; + + virtual base64_binary* + _clone \201\202 const; + +public: + std::basic_string + encode \201\202 const; +};)RP( + + ) 25 62 PR(class hex_binary: public simple_type, public buffer +{ +public: + hex_binary \201size_t size = 0\202; + hex_binary \201size_t size, size_t capacity\202; + hex_binary \201const void* data, size_t size\202; + hex_binary \201const void* data, size_t size, size_t capacity\202; + hex_binary \201void* data, + size_t size, + size_t capacity, + bool assume_ownership\202; + +public: + hex_binary \201const hex_binary&\202; + + hex_binary& + operator= \201const hex_binary&\202; + + virtual hex_binary* + _clone \201\202 const; + +public: + std::basic_string + encode \201\202 const; +};)RP( + + + )0 2 25 H(2.5.7)WB 170 Sn()WB 29 Sn( Time Zone Repre)HY(sen)HY(ta)HY(tion)YH()EA()EH( + + )0 P(The )SM(date)ES(, )SM(date)HY(Time)YH()ES(, )SM(gDay)ES(, + )SM(gMonth)ES(, )SM(gMon)HY(th)HY(Day)YH()ES(, )SM(gYear)ES(, + )SM(gYear)HY(Month)YH()ES(, and )SM(time)ES( XML Schema built-in + types all include an optional time zone compo)HY(nent)YH(. The follow)HY(ing)YH( + )SM(xml_schema::time_zone)ES( base class is used to repre)HY(sent)YH( + this infor)HY(ma)HY(tion)YH(:)EP( + + ) 30 48 PR(class time_zone +{ +public: + time_zone \201\202; + time_zone \201short hours, short minutes\202; + + bool + zone_present \201\202 const; + + void + zone_reset \201\202; + + short + zone_hours \201\202 const; + + void + zone_hours \201short\202; + + short + zone_minutes \201\202 const; + + void + zone_minutes \201short\202; +}; + +bool +operator== \201const time_zone&, const time_zone&\202; + +bool +operator!= \201const time_zone&, const time_zone&\202;)RP( + + )0 P(The )SM(zone_present\201\202)ES( acces)HY(sor)YH( func)HY(tion)YH( returns )SM(true)ES( + if the time zone is spec)HY(i)HY(fied)YH(. The )SM(zone_reset\201\202)ES( modi)HY(fier)YH( + func)HY(tion)YH( resets the time zone object to the )EM(not spec)HY(i)HY(fied)YH()ES( + state. If the time zone offset is nega)HY(tive)YH( then both hours and + minutes compo)HY(nents)YH( are repre)HY(sented)YH( as nega)HY(tive)YH( inte)HY(gers)YH(.)EP( + + + )0 2 26 H(2.5.8)WB 171 Sn()WB 30 Sn( Mapping for )SM(date)ES()EA()EH( + + )0 P(The XML Schema )SM(date)ES( built-in data type is mapped to the + )SM(xml_schema::date)ES( C++ class which repre)HY(sents)YH( a year, a day, + and a month with an optional time zone. Its inter)HY(face)YH( is presented + below. For more infor)HY(ma)HY(tion)YH( on the base )SM(xml_schema::time_zone)ES( + class refer to )0 127 1 A(Section 2.5.7, "Time Zone + Repre)HY(sen)HY(ta)HY(tion)YH(")127 0 TN TL()Ec /AF f D(.)EP( + + ) 41 60 PR(class date: public simple_type, public time_zone +{ +public: + date \201int year, unsigned short month, unsigned short day\202; + date \201int year, unsigned short month, unsigned short day, + short zone_hours, short zone_minutes\202; + +public: + date \201const date&\202; + + date& + operator= \201const date&\202; + + virtual date* + _clone \201\202 const; + +public: + int + year \201\202 const; + + void + year \201int\202; + + unsigned short + month \201\202 const; + + void + month \201unsigned short\202; + + unsigned short + day \201\202 const;)WR( + + void + day \201unsigned short\202; +}; + +bool +operator== \201const date&, const date&\202; + +bool +operator!= \201const date&, const date&\202;)RP( + + )0 2 27 H(2.5.9)WB 172 Sn()WB 31 Sn( Mapping for )SM(date)HY(Time)YH()ES()EA()EH( + + )0 P(The XML Schema )SM(date)HY(Time)YH()ES( built-in data type is mapped to the + )SM(xml_schema::date_time)ES( C++ class which repre)HY(sents)YH( a year, a month, + a day, hours, minutes, and seconds with an optional time zone. Its inter)HY(face)YH( + is presented below. For more infor)HY(ma)HY(tion)YH( on the base + )SM(xml_schema::time_zone)ES( class refer to )0 127 1 A(Section + 2.5.7, "Time Zone Repre)HY(sen)HY(ta)HY(tion)YH(")127 0 TN TL()Ec /AF f D(.)EP( + + ) 62 67 PR(class date_time: public simple_type, public time_zone +{ +public: + date_time \201int year, unsigned short month, unsigned short day, + unsigned short hours, unsigned short minutes, + double seconds\202; + + date_time \201int year, unsigned short month, unsigned short day, + unsigned short hours, unsigned short minutes, + double seconds, short zone_hours, short zone_minutes\202; +public: + date_time \201const date_time&\202; + + date_time& + operator= \201const date_time&\202; + + virtual date_time* + _clone \201\202 const; + +public: + int + year \201\202 const; + + void + year \201int\202; + + unsigned short + month \201\202 const; + + void + month \201unsigned short\202;)WR( + + unsigned short + day \201\202 const; + + void + day \201unsigned short\202; + + unsigned short + hours \201\202 const; + + void + hours \201unsigned short\202; + + unsigned short + minutes \201\202 const; + + void + minutes \201unsigned short\202; + + double + seconds \201\202 const; + + void + seconds \201double\202; +}; + +bool +operator== \201const date_time&, const date_time&\202; + +bool)WR( +operator!= \201const date_time&, const date_time&\202;)RP( + + + )0 2 28 H(2.5.10)WB 173 Sn()WB 32 Sn( Mapping for )SM(dura)HY(tion)YH()ES()EA()EH( + + )0 P(The XML Schema )SM(dura)HY(tion)YH()ES( built-in data type is mapped to the + )SM(xml_schema::dura)HY(tion)YH()ES( C++ class which repre)HY(sents)YH( a poten)HY(tially)YH( + nega)HY(tive)YH( dura)HY(tion)YH( in the form of years, months, days, hours, minutes, + and seconds. Its inter)HY(face)YH( is presented below.)EP( + + ) 64 71 PR(class duration: public simple_type +{ +public: + duration \201bool negative, + unsigned int years, unsigned int months, unsigned int days, + unsigned int hours, unsigned int minutes, double seconds\202; +public: + duration \201const duration&\202; + + duration& + operator= \201const duration&\202; + + virtual duration* + _clone \201\202 const; + +public: + bool + negative \201\202 const; + + void + negative \201bool\202; + + unsigned int + years \201\202 const; + + void + years \201unsigned int\202; + + unsigned int + months \201\202 const; +)WR( + void + months \201unsigned int\202; + + unsigned int + days \201\202 const; + + void + days \201unsigned int\202; + + unsigned int + hours \201\202 const; + + void + hours \201unsigned int\202; + + unsigned int + minutes \201\202 const; + + void + minutes \201unsigned int\202; + + double + seconds \201\202 const; + + void + seconds \201double\202; +}; + +bool +operator== \201const duration&, const duration&\202;)WR( + +bool +operator!= \201const duration&, const duration&\202;)RP( + + + )0 2 29 H(2.5.11)WB 174 Sn()WB 33 Sn( Mapping for )SM(gDay)ES()EA()EH( + + )0 P(The XML Schema )SM(gDay)ES( built-in data type is mapped to the + )SM(xml_schema::gday)ES( C++ class which repre)HY(sents)YH( a day of the + month with an optional time zone. Its inter)HY(face)YH( is presented below. + For more infor)HY(ma)HY(tion)YH( on the base )SM(xml_schema::time_zone)ES( + class refer to )0 127 1 A(Section 2.5.7, "Time Zone + Repre)HY(sen)HY(ta)HY(tion)YH(")127 0 TN TL()Ec /AF f D(.)EP( + + ) 29 66 PR(class gday: public simple_type, public time_zone +{ +public: + explicit + gday \201unsigned short day\202; + gday \201unsigned short day, short zone_hours, short zone_minutes\202; + +public: + gday \201const gday&\202; + + gday& + operator= \201const gday&\202; + + virtual gday* + _clone \201\202 const; + +public: + unsigned short + day \201\202 const; + + void + day \201unsigned short\202; +}; + +bool +operator== \201const gday&, const gday&\202; + +bool +operator!= \201const gday&, const gday&\202;)RP( + + + )0 2 30 H(2.5.12)WB 175 Sn()WB 34 Sn( Mapping for )SM(gMonth)ES()EA()EH( + + )0 P(The XML Schema )SM(gMonth)ES( built-in data type is mapped to the + )SM(xml_schema::gmonth)ES( C++ class which repre)HY(sents)YH( a month of the + year with an optional time zone. Its inter)HY(face)YH( is presented below. + For more infor)HY(ma)HY(tion)YH( on the base )SM(xml_schema::time_zone)ES( + class refer to )0 127 1 A(Section 2.5.7, "Time Zone + Repre)HY(sen)HY(ta)HY(tion)YH(")127 0 TN TL()Ec /AF f D(.)EP( + + ) 30 50 PR(class gmonth: public simple_type, public time_zone +{ +public: + explicit + gmonth \201unsigned short month\202; + gmonth \201unsigned short month, + short zone_hours, short zone_minutes\202; + +public: + gmonth \201const gmonth&\202; + + gmonth& + operator= \201const gmonth&\202; + + virtual gmonth* + _clone \201\202 const; + +public: + unsigned short + month \201\202 const; + + void + month \201unsigned short\202; +}; + +bool +operator== \201const gmonth&, const gmonth&\202; + +bool +operator!= \201const gmonth&, const gmonth&\202;)RP( + + + )0 2 31 H(2.5.13)WB 176 Sn()WB 35 Sn( Mapping for )SM(gMon)HY(th)HY(Day)YH()ES()EA()EH( + + )0 P(The XML Schema )SM(gMon)HY(th)HY(Day)YH()ES( built-in data type is mapped to the + )SM(xml_schema::gmonth_day)ES( C++ class which repre)HY(sents)YH( a day and + a month of the year with an optional time zone. Its inter)HY(face)YH( is presented + below. For more infor)HY(ma)HY(tion)YH( on the base )SM(xml_schema::time_zone)ES( + class refer to )0 127 1 A(Section 2.5.7, "Time Zone + Repre)HY(sen)HY(ta)HY(tion)YH(")127 0 TN TL()Ec /AF f D(.)EP( + + ) 35 56 PR(class gmonth_day: public simple_type, public time_zone +{ +public: + gmonth_day \201unsigned short month, unsigned short day\202; + gmonth_day \201unsigned short month, unsigned short day, + short zone_hours, short zone_minutes\202; + +public: + gmonth_day \201const gmonth_day&\202; + + gmonth_day& + operator= \201const gmonth_day&\202; + + virtual gmonth_day* + _clone \201\202 const; + +public: + unsigned short + month \201\202 const; + + void + month \201unsigned short\202; + + unsigned short + day \201\202 const; + + void + day \201unsigned short\202; +}; + +bool)WR( +operator== \201const gmonth_day&, const gmonth_day&\202; + +bool +operator!= \201const gmonth_day&, const gmonth_day&\202;)RP( + + + )0 2 32 H(2.5.14)WB 177 Sn()WB 36 Sn( Mapping for )SM(gYear)ES()EA()EH( + + )0 P(The XML Schema )SM(gYear)ES( built-in data type is mapped to the + )SM(xml_schema::gyear)ES( C++ class which repre)HY(sents)YH( a year with + an optional time zone. Its inter)HY(face)YH( is presented below. For more + infor)HY(ma)HY(tion)YH( on the base )SM(xml_schema::time_zone)ES( class refer + to )0 127 1 A(Section 2.5.7, "Time Zone Repre)HY(sen)HY(ta)HY(tion)YH(")127 0 TN TL()Ec /AF f D(.)EP( + + ) 29 57 PR(class gyear: public simple_type, public time_zone +{ +public: + explicit + gyear \201int year\202; + gyear \201int year, short zone_hours, short zone_minutes\202; + +public: + gyear \201const gyear&\202; + + gyear& + operator= \201const gyear&\202; + + virtual gyear* + _clone \201\202 const; + +public: + int + year \201\202 const; + + void + year \201int\202; +}; + +bool +operator== \201const gyear&, const gyear&\202; + +bool +operator!= \201const gyear&, const gyear&\202;)RP( + + + )0 2 33 H(2.5.15)WB 178 Sn()WB 37 Sn( Mapping for )SM(gYear)HY(Month)YH()ES()EA()EH( + + )0 P(The XML Schema )SM(gYear)HY(Month)YH()ES( built-in data type is mapped to + the )SM(xml_schema::gyear_month)ES( C++ class which repre)HY(sents)YH( + a year and a month with an optional time zone. Its inter)HY(face)YH( is presented + below. For more infor)HY(ma)HY(tion)YH( on the base )SM(xml_schema::time_zone)ES( + class refer to )0 127 1 A(Section 2.5.7, "Time Zone + Repre)HY(sen)HY(ta)HY(tion)YH(")127 0 TN TL()Ec /AF f D(.)EP( + + ) 34 55 PR(class gyear_month: public simple_type, public time_zone +{ +public: + gyear_month \201int year, unsigned short month\202; + gyear_month \201int year, unsigned short month, + short zone_hours, short zone_minutes\202; +public: + gyear_month \201const gyear_month&\202; + + gyear_month& + operator= \201const gyear_month&\202; + + virtual gyear_month* + _clone \201\202 const; + +public: + int + year \201\202 const; + + void + year \201int\202; + + unsigned short + month \201\202 const; + + void + month \201unsigned short\202; +}; + +bool +operator== \201const gyear_month&, const gyear_month&\202;)WR( + +bool +operator!= \201const gyear_month&, const gyear_month&\202;)RP( + + + )0 2 34 H(2.5.16)WB 179 Sn()WB 38 Sn( Mapping for )SM(time)ES()EA()EH( + + )0 P(The XML Schema )SM(time)ES( built-in data type is mapped to + the )SM(xml_schema::time)ES( C++ class which repre)HY(sents)YH( hours, + minutes, and seconds with an optional time zone. Its inter)HY(face)YH( is + presented below. For more infor)HY(ma)HY(tion)YH( on the base + )SM(xml_schema::time_zone)ES( class refer to + )0 127 1 A(Section 2.5.7, "Time Zone Repre)HY(sen)HY(ta)HY(tion)YH(")127 0 TN TL()Ec /AF f D(.)EP( + + ) 41 70 PR(class time: public simple_type, public time_zone +{ +public: + time \201unsigned short hours, unsigned short minutes, double seconds\202; + time \201unsigned short hours, unsigned short minutes, double seconds, + short zone_hours, short zone_minutes\202; + +public: + time \201const time&\202; + + time& + operator= \201const time&\202; + + virtual time* + _clone \201\202 const; + +public: + unsigned short + hours \201\202 const; + + void + hours \201unsigned short\202; + + unsigned short + minutes \201\202 const; + + void + minutes \201unsigned short\202; + + double + seconds \201\202 const;)WR( + + void + seconds \201double\202; +}; + +bool +operator== \201const time&, const time&\202; + +bool +operator!= \201const time&, const time&\202;)RP( + + + + + )0 2 35 H(2.6)WB 180 Sn()WB 39 Sn( Mapping for Simple Types)EA()EH( + + )0 P(An XML Schema simple type is mapped to a C++ class with the same + name as the simple type. The class defines a public copy construc)HY(tor)YH(, + a public copy assign)HY(ment)YH( oper)HY(a)HY(tor)YH(, and a public virtual + )SM(_clone)ES( func)HY(tion)YH(. The )SM(_clone)ES( func)HY(tion)YH( is + declared )SM(const)ES(, does not take any argu)HY(ments)YH(, and returns + a pointer to a complete copy of the instance allo)HY(cated)YH( in the free + store. The )SM(_clone)ES( func)HY(tion)YH( shall be used to make copies + when static type and dynamic type of the instance may differ \201see + )0 128 1 A(Section 2.11, "Mapping for )SM(xsi:type)ES( + and Substi)HY(tu)HY(tion)YH( Groups")128 0 TN TL()Ec /AF f D(\202. For instance:)EP( + + ) 3 26 PR( + ... +)RP( + + )0 P(is mapped to:)EP( + + ) 16 28 PR(class object: ... +{ +public: + object \201const object&\202; + +public: + object& + operator= \201const object&\202; + +public: + virtual object* + _clone \201\202 const; + + ... + +};)RP( + + )0 P(The base class spec)HY(i)HY(fi)HY(ca)HY(tion)YH( and the rest of the class defi)HY(ni)HY(tion)YH( + depend on the type of deriva)HY(tion)YH( used to define the simple type. )EP( + + + )0 3 36 H(2.6.1)WB 181 Sn()WB 40 Sn( Mapping for Deriva)HY(tion)YH( by Restric)HY(tion)YH()EA()EH( + + )0 P(XML Schema deriva)HY(tion)YH( by restric)HY(tion)YH( is mapped to C++ public + inher)HY(i)HY(tance)YH(. The base type of the restric)HY(tion)YH( becomes the base + type for the result)HY(ing)YH( C++ class. In addi)HY(tion)YH( to the members described + in )0 103 1 A(Section 2.6, "Mapping for Simple Types")103 0 TN TL()Ec /AF f D(, the + result)HY(ing)YH( C++ class defines a public construc)HY(tor)YH( with the base type + as its single argu)HY(ment)YH(. For instance:)EP( + + ) 5 27 PR( + + ... + +)RP( + + )0 P(is mapped to:)EP( + + ) 14 28 PR(class object: public base +{ +public: + object \201const base&\202; + object \201const object&\202; + +public: + object& + operator= \201const object&\202; + +public: + virtual object* + _clone \201\202 const; +};)RP( + + + )0 3 37 H(2.6.2)WB 182 Sn()WB 41 Sn( Mapping for Enumer)HY(a)HY(tions)YH()EA()EH( + +)0 P(XML Schema restric)HY(tion)YH( by enumer)HY(a)HY(tion)YH( is mapped to a C++ class + with seman)HY(tics)YH( similar to C++ )SM(enum)ES(. Each XML Schema + enumer)HY(a)HY(tion)YH( element is mapped to a C++ enumer)HY(a)HY(tor)YH( with the + name derived from the )SM(value)ES( attribute and defined + in the class scope. In addi)HY(tion)YH( to the members + described in )0 103 1 A(Section 2.6, "Mapping for Simple Types")103 0 TN TL()Ec /AF f D(, + the result)HY(ing)YH( C++ class defines a public construc)HY(tor)YH( that can be called + with one of the enumer)HY(a)HY(tors)YH( as its single argu)HY(ment)YH(, a public construc)HY(tor)YH( + that can be called with enumer)HY(a)HY(tion)YH('s base value as its single + argu)HY(ment)YH(, a public assign)HY(ment)YH( oper)HY(a)HY(tor)YH( that can be used to assign the + value of one of the enumer)HY(a)HY(tors)YH(, and a public implicit conver)HY(sion)YH( + oper)HY(a)HY(tor)YH( to the under)HY(ly)HY(ing)YH( C++ enum type.)EP( + +)0 P(Further)HY(more)YH(, for string-based enumer)HY(a)HY(tion)YH( types, the result)HY(ing)YH( C++ + class defines a public construc)HY(tor)YH( with a single argu)HY(ment)YH( of type + )SM(const C*)ES( and a public construc)HY(tor)YH( with a single + argu)HY(ment)YH( of type )SM(const std::basic_string&)ES(. + For instance:)EP( + + ) 7 32 PR( + + + + + +)RP( + + )0 P(is mapped to:)EP( + + ) 31 38 PR(class color: public xml_schema::string +{ +public: + enum value + { + red, + green, + blue + }; + +public: + color \201value\202; + color \201const C*\202; + color \201const std::basic_string&\202; + color \201const xml_schema::string&\202; + color \201const color&\202; + +public: + color& + operator= \201value\202; + + color& + operator= \201const color&\202; + +public: + virtual color* + _clone \201\202 const; + +public: + operator value \201\202 const; +};)WR()RP( + + )0 3 38 H(2.6.3)WB 183 Sn()WB 42 Sn( Mapping for Deriva)HY(tion)YH( by List)EA()EH( + + )0 P(XML Schema deriva)HY(tion)YH( by list is mapped to C++ public + inher)HY(i)HY(tance)YH( from )SM(xml_schema::simple_type)ES( + \201)0 110 1 A(Section 2.5.3, "Mapping for + )SM(anySim)HY(ple)HY(Type)YH()ES(")110 0 TN TL()Ec /AF f D(\202 and a suit)HY(able)YH( sequence type. + The list item type becomes the element type of the sequence. + In addi)HY(tion)YH( to the members described in )0 103 1 A(Section 2.6, + "Mapping for Simple Types")103 0 TN TL()Ec /AF f D(, the result)HY(ing)YH( C++ class defines + a public default construc)HY(tor)YH(, a public construc)HY(tor)YH( + with the first argu)HY(ment)YH( of type )SM(size_type)ES( and + the second argu)HY(ment)YH( of list item type that creates + a list object with the spec)HY(i)HY(fied)YH( number of copies of the spec)HY(i)HY(fied)YH( + element value, and a public construc)HY(tor)YH( with the two argu)HY(ments)YH( + of an input iter)HY(a)HY(tor)YH( type that creates a list object from an + iter)HY(a)HY(tor)YH( range. For instance: + )EP( + + ) 3 28 PR( + +)RP( + + )0 P(is mapped to:)EP( + + ) 19 42 PR(class int_list: public simple_type, + public sequence +{ +public: + int_list \201\202; + int_list \201size_type n, int x\202; + + template + int_list \201const I& begin, const I& end\202; + int_list \201const int_list&\202; + +public: + int_list& + operator= \201const int_list&\202; + +public: + virtual int_list* + _clone \201\202 const; +};)RP( + + )0 P(The )SM(sequence)ES( class template is defined in an + imple)HY(men)HY(ta)HY(tion)YH(-specific names)HY(pace)YH(. It conforms to the + sequence inter)HY(face)YH( as defined by the ISO/ANSI Stan)HY(dard)YH( for + C++ \201ISO/IEC 14882:1998, Section 23.1.1, "Sequences"\202. + Prac)HY(ti)HY(cally)YH(, this means that you can treat such a sequence + as if it was )SM(std::vector)ES(. One notable exten)HY(sion)YH( + to the stan)HY(dard)YH( inter)HY(face)YH( that is avail)HY(able)YH( only for + sequences of non-funda)HY(men)HY(tal)YH( C++ types is the addi)HY(tion)YH( of + the over)HY(loaded)YH( )SM(push_back)ES( and )SM(insert)ES( + member func)HY(tions)YH( which instead of the constant refer)HY(ence)YH( + to the element type accept auto)HY(matic)YH( pointer \201)SM(std::unique_ptr)ES( + or )SM(std::auto_ptr)ES(, depend)HY(ing)YH( on the C++ stan)HY(dard)YH( + selected\202 to the element type. These func)HY(tions)YH( assume owner)HY(ship)YH( + of the pointed to object and reset the passed auto)HY(matic)YH( pointer. + )EP( + + )0 3 39 H(2.6.4)WB 184 Sn()WB 43 Sn( Mapping for Deriva)HY(tion)YH( by Union)EA()EH( + + )0 P(XML Schema deriva)HY(tion)YH( by union is mapped to C++ public + inher)HY(i)HY(tance)YH( from )SM(xml_schema::simple_type)ES( + \201)0 110 1 A(Section 2.5.3, "Mapping for + )SM(anySim)HY(ple)HY(Type)YH()ES(")110 0 TN TL()Ec /AF f D(\202 and )SM(std::basic_string)ES(. + In addi)HY(tion)YH( to the members described in )0 103 1 A(Section 2.6, + "Mapping for Simple Types")103 0 TN TL()Ec /AF f D(, the result)HY(ing)YH( C++ class defines a + public construc)HY(tor)YH( with a single argu)HY(ment)YH( of type )SM(const C*)ES( + and a public construc)HY(tor)YH( with a single argu)HY(ment)YH( of type + )SM(const std::basic_string&)ES(. For instance: + )EP( + + ) 3 47 PR( + +)RP( + + )0 P(is mapped to:)EP( + + ) 16 51 PR(class int_string_union: public simple_type, + public std::basic_string +{ +public: + int_string_union \201const C*\202; + int_string_union \201const std::basic_string&\202; + int_string_union \201const int_string_union&\202; + +public: + int_string_union& + operator= \201const int_string_union&\202; + +public: + virtual int_string_union* + _clone \201\202 const; +};)RP( + + )0 2 40 H(2.7)WB 185 Sn()WB 44 Sn( Mapping for Complex Types)EA()EH( + + )0 P(An XML Schema complex type is mapped to a C++ class with the same + name as the complex type. The class defines a public copy construc)HY(tor)YH(, + a public copy assign)HY(ment)YH( oper)HY(a)HY(tor)YH(, and a public virtual + )SM(_clone)ES( func)HY(tion)YH(. The )SM(_clone)ES( func)HY(tion)YH( is + declared )SM(const)ES(, does not take any argu)HY(ments)YH(, and returns + a pointer to a complete copy of the instance allo)HY(cated)YH( in the free + store. The )SM(_clone)ES( func)HY(tion)YH( shall be used to make copies + when static type and dynamic type of the instance may differ \201see + )0 128 1 A(Section 2.11, "Mapping for )SM(xsi:type)ES( + and Substi)HY(tu)HY(tion)YH( Groups")128 0 TN TL()Ec /AF f D(\202.)EP( + + )0 P(Addi)HY(tion)HY(ally)YH(, the result)HY(ing)YH( C++ class + defines two public construc)HY(tors)YH( that take an initial)HY(izer)YH( for each + member of the complex type and all its base types that belongs to + the One cardi)HY(nal)HY(ity)YH( class \201see )0 129 1 A(Section 2.8, "Mapping + for Local Elements and Attributes")129 0 TN TL()Ec /AF f D(\202. In the first construc)HY(tor)YH(, + the argu)HY(ments)YH( are passed as constant refer)HY(ences)YH( and the newly created + instance is initial)HY(ized)YH( with copies of the passed objects. In the + second construc)HY(tor)YH(, argu)HY(ments)YH( that are complex types \201that is, + they them)HY(selves)YH( contain elements or attributes\202 are passed as + either )SM(std::unique_ptr)ES( \201C++11\202 or )SM(std::auto_ptr)ES( + \201C++98\202, depend)HY(ing)YH( on the C++ stan)HY(dard)YH( selected. In this case the newly + created instance is directly initial)HY(ized)YH( with and assumes owner)HY(ship)YH( + of the pointed to objects and the )SM(std::[unique|auto]_ptr)ES( + argu)HY(ments)YH( are reset to )SM(0)ES(. For instance:)EP( + + ) 15 66 PR( + + + + + + + + + + + + + +)RP( + + )0 P(is mapped to:)EP( + + ) 36 68 PR(class complex: public xml_schema::type +{ +public: + object \201const int& a, const xml_schema::string& b\202; + object \201const complex&\202; + +public: + object& + operator= \201const complex&\202; + +public: + virtual complex* + _clone \201\202 const; + + ... + +}; + +class object: public xml_schema::type +{ +public: + object \201const bool& s_one, const complex& c_one\202; + object \201const bool& s_one, std::[unique|auto]_ptr c_one\202; + object \201const object&\202; + +public: + object& + operator= \201const object&\202; + +public: + virtual object*)WR( + _clone \201\202 const; + + ... + +};)RP( + + )0 P(Notice that the gener)HY(ated)YH( )SM(complex)ES( class does not + have the second \201)SM(std::[unique|auto]_ptr)ES(\202 version of the + construc)HY(tor)YH( since all its required members are of simple types.)EP( + + )0 P(If an XML Schema complex type has an ulti)HY(mate)YH( base which is an XML + Schema simple type then the result)HY(ing)YH( C++ class also defines a public + construc)HY(tor)YH( that takes an initial)HY(izer)YH( for the base type as well as + for each member of the complex type and all its base types that + belongs to the One cardi)HY(nal)HY(ity)YH( class. For instance:)EP( + + ) 7 61 PR( + + + + + +)RP( + + )0 P(is mapped to:)EP( + + ) 11 44 PR(class object: public xml_schema::string +{ +public: + object \201const xml_schema::language& lang\202; + + object \201const xml_schema::date& base, + const xml_schema::language& lang\202; + + ... + +};)RP( + + )0 P(Further)HY(more)YH(, for string-based XML Schema complex types, the result)HY(ing)YH( C++ + class also defines two public construc)HY(tors)YH( with the first argu)HY(ments)YH( + of type )SM(const C*)ES( and )SM(std::basic_string&)ES(, + respec)HY(tively)YH(, followed by argu)HY(ments)YH( for each member of the complex + type and all its base types that belongs to the One cardi)HY(nal)HY(ity)YH( + class. For enumer)HY(a)HY(tion)YH(-based complex types the result)HY(ing)YH( C++ + class also defines a public construc)HY(tor)YH( with the first argu)HY(ments)YH( + of the under)HY(ly)HY(ing)YH( enum type followed by argu)HY(ments)YH( for each member + of the complex type and all its base types that belongs to the One + cardi)HY(nal)HY(ity)YH( class. For instance:)EP( + + ) 15 61 PR( + + + + + + + + + + + + + +)RP( + + )0 P(is mapped to:)EP( + + ) 37 44 PR(class color: public xml_schema::string +{ +public: + enum value + { + red, + green, + blue + }; + +public: + color \201value\202; + color \201const C*\202; + color \201const std::basic_string&\202; + + ... + +}; + +class object: color +{ +public: + object \201const color& base, + const xml_schema::language& lang\202; + + object \201const color::value& base, + const xml_schema::language& lang\202; + + object \201const C* base, + const xml_schema::language& lang\202; +)WR( + object \201const std::basic_string& base, + const xml_schema::language& lang\202; + + ... + +};)RP( + + )0 P(Addi)HY(tional)YH( construc)HY(tors)YH( can be requested with the + )SM(--gener)HY(ate)YH(-default-ctor)ES( and + )SM(--gener)HY(ate)YH(-from-base-ctor)ES( options. See the + )R5 2 A(XSD + Compiler Command Line Manual)EA( for details.)EP( + + )0 P(If an XML Schema complex type is not explic)HY(itly)YH( derived from any type, + the result)HY(ing)YH( C++ class is derived from )SM(xml_schema::type)ES(. + In cases where an XML Schema complex type is defined using deriva)HY(tion)YH( + by exten)HY(sion)YH( or restric)HY(tion)YH(, the result)HY(ing)YH( C++ base class spec)HY(i)HY(fi)HY(ca)HY(tion)YH( + depends on the type of deriva)HY(tion)YH( and is described in the subse)HY(quent)YH( + sections. + )EP( + + )0 P(The mapping for elements and attributes that are defined in a complex + type is described in )0 129 1 A(Section 2.8, "Mapping for Local + Elements and Attributes")129 0 TN TL()Ec /AF f D(. + )EP( + + )0 3 41 H(2.7.1)WB 186 Sn()WB 45 Sn( Mapping for Deriva)HY(tion)YH( by Exten)HY(sion)YH()EA()EH( + + )0 P(XML Schema deriva)HY(tion)YH( by exten)HY(sion)YH( is mapped to C++ public + inher)HY(i)HY(tance)YH(. The base type of the exten)HY(sion)YH( becomes the base + type for the result)HY(ing)YH( C++ class. + )EP( + + )0 3 42 H(2.7.2)WB 187 Sn()WB 46 Sn( Mapping for Deriva)HY(tion)YH( by Restric)HY(tion)YH()EA()EH( + + )0 P(XML Schema deriva)HY(tion)YH( by restric)HY(tion)YH( is mapped to C++ public + inher)HY(i)HY(tance)YH(. The base type of the restric)HY(tion)YH( becomes the base + type for the result)HY(ing)YH( C++ class. XML Schema elements and + attributes defined within restric)HY(tion)YH( do not result in any + defi)HY(ni)HY(tions)YH( in the result)HY(ing)YH( C++ class. Instead, corre)HY(spond)HY(ing)YH( + \201unre)HY(stricted)YH(\202 defi)HY(ni)HY(tions)YH( are inher)HY(ited)YH( from the base class. + In the future versions of this mapping, such elements and + attributes may result in redef)HY(i)HY(ni)HY(tions)YH( of acces)HY(sors)YH( and + modi)HY(fiers)YH( to reflect their restricted seman)HY(tics)YH(. + )EP( + + + + )0 2 43 H(2.8)WB 188 Sn()WB 47 Sn( Mapping for Local Elements and Attributes)EA()EH( + + )0 P(XML Schema element and attribute defi)HY(ni)HY(tions)YH( are called local + if they appear within a complex type defi)HY(ni)HY(tion)YH(, an element group + defi)HY(ni)HY(tion)YH(, or an attribute group defi)HY(ni)HY(tions)YH(. + )EP( + + )0 P(Local XML Schema element and attribute defi)HY(ni)HY(tions)YH( have the same + C++ mapping. There)HY(fore)YH(, in this section, local elements and + attributes are collec)HY(tively)YH( called members. + )EP( + + )0 P(While there are many differ)HY(ent)YH( member cardi)HY(nal)HY(ity)YH( combi)HY(na)HY(tions)YH( + \201deter)HY(mined)YH( by the )SM(use)ES( attribute for attributes and + the )SM(minOc)HY(curs)YH()ES( and )SM(maxOc)HY(curs)YH()ES( attributes + for elements\202, the mapping divides all possi)HY(ble)YH( cardi)HY(nal)HY(ity)YH( + combi)HY(na)HY(tions)YH( into three cardi)HY(nal)HY(ity)YH( classes: + )EP( + + )0 DL( )0 DT()I(one)ES( + )DD(attributes: )SM(use == "required")ES( + )DD(attributes: )SM(use == "optional")ES( and has default or fixed value + )DD(elements: )SM(minOc)HY(curs)YH( == "1")ES( and )SM(maxOc)HY(curs)YH( == "1")ES( + + )0 DT()I(optional)ES( + )DD(attributes: )SM(use == "optional")ES( and doesn't have default or fixed value + )DD(elements: )SM(minOc)HY(curs)YH( == "0")ES( and )SM(maxOc)HY(curs)YH( == "1")ES( + + )0 DT()I(sequence)ES( + )DD(elements: )SM(maxOc)HY(curs)YH( > "1")ES( + )LD( + + )0 P(An optional attribute with a default or fixed value acquires this value + if the attribute hasn't been spec)HY(i)HY(fied)YH( in an instance docu)HY(ment)YH( \201see + )0 130 1 A(Appendix A, "Default and Fixed Values")130 0 TN TL()Ec /AF f D(\202. This + mapping places such optional attributes to the One cardi)HY(nal)HY(ity)YH( + class.)EP( + + )0 P(A member is mapped to a set of public type defi)HY(ni)HY(tions)YH( + \201)SM(typedef)ES(s\202 and a set of public acces)HY(sor)YH( and modi)HY(fier)YH( + func)HY(tions)YH(. Type defi)HY(ni)HY(tions)YH( have names derived from the member's + name. The acces)HY(sor)YH( and modi)HY(fier)YH( func)HY(tions)YH( have the same name as the + member. For example: + )EP( + + ) 5 42 PR( + + + +)RP( + + )0 P(is mapped to:)EP( + + ) 11 41 PR(class object: public xml_schema::type +{ +public: + typedef xml_schema::string member_type; + + const member_type& + member \201\202 const; + + ... + +};)RP( + + )0 P(In addi)HY(tion)YH(, if a member has a default or fixed value, a static + acces)HY(sor)YH( func)HY(tion)YH( is gener)HY(ated)YH( that returns this value. For + example:)EP( + +) 3 55 PR( + +)RP( + + )0 P(is mapped to:)EP( + + ) 14 39 PR(class object: public xml_schema::type +{ +public: + typedef xml_schema::string data_type; + + const data_type& + data \201\202 const; + + static const data_type& + data_default_value \201\202; + + ... + +};)RP( + + )0 P(Names and seman)HY(tics)YH( of type defi)HY(ni)HY(tions)YH( for the member as well + as signa)HY(tures)YH( of the acces)HY(sor)YH( and modi)HY(fier)YH( func)HY(tions)YH( depend on + the member's cardi)HY(nal)HY(ity)YH( class and are described in the follow)HY(ing)YH( + sub-sections. + )EP( + + + )0 3 44 H(2.8.1)WB 189 Sn()WB 48 Sn( Mapping for Members with the One Cardi)HY(nal)HY(ity)YH( Class)EA()EH( + + )0 P(For the One cardi)HY(nal)HY(ity)YH( class, the type defi)HY(ni)HY(tions)YH( consist of + an alias for the member's type with the name created by append)HY(ing)YH( + the )SM(_type)ES( suffix to the member's name. + )EP( + + )0 P(The acces)HY(sor)YH( func)HY(tions)YH( come in constant and non-constant versions. + The constant acces)HY(sor)YH( func)HY(tion)YH( returns a constant refer)HY(ence)YH( to the + member and can be used for read-only access. The non-constant + version returns an unre)HY(stricted)YH( refer)HY(ence)YH( to the member and can + be used for read-write access. + )EP( + + )0 P(The first modi)HY(fier)YH( func)HY(tion)YH( expects an argu)HY(ment)YH( of type refer)HY(ence)YH( to + constant of the member's type. It makes a deep copy of its argu)HY(ment)YH(. + Except for member's types that are mapped to funda)HY(men)HY(tal)YH( C++ types, + the second modi)HY(fier)YH( func)HY(tion)YH( is provided that expects an argu)HY(ment)YH( + of type auto)HY(matic)YH( pointer \201)SM(std::unique_ptr)ES( or + )SM(std::auto_ptr)ES(, depend)HY(ing)YH( on the C++ stan)HY(dard)YH( selected\202 + to the member's type. It assumes owner)HY(ship)YH( of the pointed to object + and resets the passed auto)HY(matic)YH( pointer. For instance:)EP( + + ) 5 42 PR( + + + +)RP( + + )0 P(is mapped to:)EP( + + ) 25 47 PR(class object: public xml_schema::type +{ +public: + // Type definitions. + // + typedef xml_schema::string member_type; + + // Accessors. + // + const member_type& + member \201\202 const; + + member_type& + member \201\202; + + // Modifiers. + // + void + member \201const member_type&\202; + + void + member \201std::[unique|auto]_ptr\202; + ... + +};)RP( + + )0 P(In addi)HY(tion)YH(, if requested by spec)HY(i)HY(fy)HY(ing)YH( the )SM(--gener)HY(ate)YH(-detach)ES( + option and only for members of non-funda)HY(men)HY(tal)YH( C++ types, the mapping + provides a detach func)HY(tion)YH( that returns an auto)HY(matic)YH( pointer to the + member's type, for example:)EP( + + ) 10 37 PR(class object: public xml_schema::type +{ +public: + ... + + std::[unique|auto]_ptr + detach_member \201\202; + ... + +};)RP( + + )0 P(This func)HY(tion)YH( detaches the value from the tree leaving the member + value unini)HY(tial)HY(ized)YH(. Access)HY(ing)YH( such an unini)HY(tial)HY(ized)YH( value prior to + re-initial)HY(iz)HY(ing)YH( it results in unde)HY(fined)YH( behav)HY(ior)YH(.)EP( + + )0 P(The follow)HY(ing)YH( code shows how one could use this mapping:)EP( + + ) 25 66 PR(void +f \201object& o\202 +{ + using xml_schema::string; + + string s \201o.member \201\202\202; // get + object::member_type& sr \201o.member \201\202\202; // get + + o.member \201"hello"\202; // set, deep copy + o.member \201\202 = "hello"; // set, deep copy + + // C++11 version. + // + std::unique_ptr p \201new string \201"hello"\202\202; + o.member \201std::move \201p\202\202; // set, assumes ownership + p = o.detach_member \201\202; // detach, member is uninitialized + o.member \201std::move \201p\202\202; // re-attach + + // C++98 version. + // + std::auto_ptr p \201new string \201"hello"\202\202; + o.member \201p\202; // set, assumes ownership + p = o.detach_member \201\202; // detach, member is uninitialized + o.member \201p\202; // re-attach +})RP( + + +)0 3 45 H(2.8.2)WB 190 Sn()WB 49 Sn( Mapping for Members with the Optional Cardi)HY(nal)HY(ity)YH( Class)EA()EH( + + )0 P(For the Optional cardi)HY(nal)HY(ity)YH( class, the type defi)HY(ni)HY(tions)YH( consist of + an alias for the member's type with the name created by append)HY(ing)YH( + the )SM(_type)ES( suffix to the member's name and an alias for + the container type with the name created by append)HY(ing)YH( the + )SM(_optional)ES( suffix to the member's name. + )EP( + + )0 P(Unlike acces)HY(sor)YH( func)HY(tions)YH( for the One cardi)HY(nal)HY(ity)YH( class, acces)HY(sor)YH( + func)HY(tions)YH( for the Optional cardi)HY(nal)HY(ity)YH( class return refer)HY(ences)YH( to + corre)HY(spond)HY(ing)YH( contain)HY(ers)YH( rather than directly to members. The + acces)HY(sor)YH( func)HY(tions)YH( come in constant and non-constant versions. + The constant acces)HY(sor)YH( func)HY(tion)YH( returns a constant refer)HY(ence)YH( to + the container and can be used for read-only access. The non-constant + version returns an unre)HY(stricted)YH( refer)HY(ence)YH( to the container + and can be used for read-write access. + )EP( + + )0 P(The modi)HY(fier)YH( func)HY(tions)YH( are over)HY(loaded)YH( for the member's + type and the container type. The first modi)HY(fier)YH( func)HY(tion)YH( + expects an argu)HY(ment)YH( of type refer)HY(ence)YH( to constant of the + member's type. It makes a deep copy of its argu)HY(ment)YH(. + Except for member's types that are mapped to funda)HY(men)HY(tal)YH( C++ types, + the second modi)HY(fier)YH( func)HY(tion)YH( is provided that expects an argu)HY(ment)YH( + of type auto)HY(matic)YH( pointer \201)SM(std::unique_ptr)ES( or + )SM(std::auto_ptr)ES(, depend)HY(ing)YH( on the C++ stan)HY(dard)YH( selected\202 + to the member's type. It assumes owner)HY(ship)YH( of the pointed to object + and resets the passed auto)HY(matic)YH( pointer. The last modi)HY(fier)YH( func)HY(tion)YH( + expects an argu)HY(ment)YH( of type refer)HY(ence)YH( to constant of the container + type. It makes a deep copy of its argu)HY(ment)YH(. For instance: + )EP( + + ) 5 56 PR( + + + +)RP( + + )0 P(is mapped to:)EP( + + ) 30 48 PR(class object: public xml_schema::type +{ +public: + // Type definitions. + // + typedef xml_schema::string member_type; + typedef optional member_optional; + + // Accessors. + // + const member_optional& + member \201\202 const; + + member_optional& + member \201\202; + + // Modifiers. + // + void + member \201const member_type&\202; + + void + member \201std::[unique|auto]_ptr\202; + + void + member \201const member_optional&\202; + + ... + +};)RP( + + + )0 P(The )SM(optional)ES( class template is defined in an + imple)HY(men)HY(ta)HY(tion)YH(-specific names)HY(pace)YH( and has the follow)HY(ing)YH( + inter)HY(face)YH(. The )SM([unique|auto]_ptr)ES(-based construc)HY(tor)YH( + and modi)HY(fier)YH( func)HY(tion)YH( are only avail)HY(able)YH( if the template + argu)HY(ment)YH( is not a funda)HY(men)HY(tal)YH( C++ type. + )EP( + + ) 97 52 PR(template +class optional +{ +public: + optional \201\202; + + // Makes a deep copy. + // + explicit + optional \201const X&\202; + + // Assumes ownership. + // + explicit + optional \201std::[unique|auto]_ptr\202; + + optional \201const optional&\202; + +public: + optional& + operator= \201const X&\202; + + optional& + operator= \201const optional&\202; + + // Pointer-like interface. + // +public: + const X* + operator-> \201\202 const; +)WR( + X* + operator-> \201\202; + + const X& + operator* \201\202 const; + + X& + operator* \201\202; + + typedef void \201optional::*bool_convertible\202 \201\202; + operator bool_convertible \201\202 const; + + // Get/set interface. + // +public: + bool + present \201\202 const; + + const X& + get \201\202 const; + + X& + get \201\202; + + // Makes a deep copy. + // + void + set \201const X&\202; + + // Assumes ownership.)WR( + // + void + set \201std::[unique|auto]_ptr\202; + + // Detach and return the contained value. + // + std::[unique|auto]_ptr + detach \201\202; + + void + reset \201\202; +}; + +template +bool +operator== \201const optional&, const optional&\202; + +template +bool +operator!= \201const optional&, const optional&\202; + +template +bool +operator< \201const optional&, const optional&\202; + +template +bool +operator> \201const optional&, const optional&\202; + +template )WR( +bool +operator<= \201const optional&, const optional&\202; + +template +bool +operator>= \201const optional&, const optional&\202;)RP( + + + )0 P(The follow)HY(ing)YH( code shows how one could use this mapping:)EP( + + ) 45 62 PR(void +f \201object& o\202 +{ + using xml_schema::string; + + if \201o.member \201\202.present \201\202\202 // test + { + string& s \201o.member \201\202.get \201\202\202; // get + o.member \201"hello"\202; // set, deep copy + o.member \201\202.set \201"hello"\202; // set, deep copy + o.member \201\202.reset \201\202; // reset + } + + // Same as above but using pointer notation: + // + if \201o.member \201\202\202 // test + { + string& s \201*o.member \201\202\202; // get + o.member \201"hello"\202; // set, deep copy + *o.member \201\202 = "hello"; // set, deep copy + o.member \201\202.reset \201\202; // reset + } + + // C++11 version. + // + std::unique_ptr p \201new string \201"hello"\202\202; + o.member \201std::move \201p\202\202; // set, assumes ownership + + p.reset \201new string \201"hello"\202\202; + o.member \201\202.set \201std::move \201p\202\202; // set, assumes ownership +)WR( + p = o.member \201\202.detach \201\202; // detach, member is reset + o.member \201\202.set \201std::move \201p\202\202; // re-attach + + // C++98 version. + // + std::auto_ptr p \201new string \201"hello"\202\202; + o.member \201p\202; // set, assumes ownership + + p = new string \201"hello"\202; + o.member \201\202.set \201p\202; // set, assumes ownership + + p = o.member \201\202.detach \201\202; // detach, member is reset + o.member \201\202.set \201p\202; // re-attach +})RP( + + + )0 3 46 H(2.8.3)WB 191 Sn()WB 50 Sn( Mapping for Members with the Sequence Cardi)HY(nal)HY(ity)YH( Class)EA()EH( + + )0 P(For the Sequence cardi)HY(nal)HY(ity)YH( class, the type defi)HY(ni)HY(tions)YH( consist of an + alias for the member's type with the name created by append)HY(ing)YH( + the )SM(_type)ES( suffix to the member's name, an alias of + the container type with the name created by append)HY(ing)YH( the + )SM(_sequence)ES( suffix to the member's name, an alias of + the iter)HY(a)HY(tor)YH( type with the name created by append)HY(ing)YH( the + )SM(_iter)HY(a)HY(tor)YH()ES( suffix to the member's name, and an alias + of the constant iter)HY(a)HY(tor)YH( type with the name created by append)HY(ing)YH( the + )SM(_const_iter)HY(a)HY(tor)YH()ES( suffix to the member's name. + )EP( + + )0 P(The acces)HY(sor)YH( func)HY(tions)YH( come in constant and non-constant versions. + The constant acces)HY(sor)YH( func)HY(tion)YH( returns a constant refer)HY(ence)YH( to the + container and can be used for read-only access. The non-constant + version returns an unre)HY(stricted)YH( refer)HY(ence)YH( to the container and can + be used for read-write access. + )EP( + + )0 P(The modi)HY(fier)YH( func)HY(tion)YH( expects an argu)HY(ment)YH( of type refer)HY(ence)YH( to + constant of the container type. The modi)HY(fier)YH( func)HY(tion)YH( + makes a deep copy of its argu)HY(ment)YH(. For instance: + )EP( + + + ) 5 64 PR( + + + +)RP( + + )0 P(is mapped to:)EP( + + ) 26 64 PR(class object: public xml_schema::type +{ +public: + // Type definitions. + // + typedef xml_schema::string member_type; + typedef sequence member_sequence; + typedef member_sequence::iterator member_iterator; + typedef member_sequence::const_iterator member_const_iterator; + + // Accessors. + // + const member_sequence& + member \201\202 const; + + member_sequence& + member \201\202; + + // Modifier. + // + void + member \201const member_sequence&\202; + + ... + +};)RP( + + )0 P(The )SM(sequence)ES( class template is defined in an + imple)HY(men)HY(ta)HY(tion)YH(-specific names)HY(pace)YH(. It conforms to the + sequence inter)HY(face)YH( as defined by the ISO/ANSI Stan)HY(dard)YH( for + C++ \201ISO/IEC 14882:1998, Section 23.1.1, "Sequences"\202. + Prac)HY(ti)HY(cally)YH(, this means that you can treat such a sequence + as if it was )SM(std::vector)ES(. Two notable exten)HY(sions)YH( + to the stan)HY(dard)YH( inter)HY(face)YH( that are avail)HY(able)YH( only for + sequences of non-funda)HY(men)HY(tal)YH( C++ types are the addi)HY(tion)YH( of + the over)HY(loaded)YH( )SM(push_back)ES( and )SM(insert)ES( + as well as the )SM(detach_back)ES( and )SM(detach)ES( + member func)HY(tions)YH(. The addi)HY(tional)YH( )SM(push_back)ES( and + )SM(insert)ES( func)HY(tions)YH( accept an auto)HY(matic)YH( pointer + \201)SM(std::unique_ptr)ES( or )SM(std::auto_ptr)ES(, + depend)HY(ing)YH( on the C++ stan)HY(dard)YH( selected\202 to the + element type instead of the constant refer)HY(ence)YH(. They assume + owner)HY(ship)YH( of the pointed to object and reset the passed + auto)HY(matic)YH( pointer. The )SM(detach_back)ES( and + )SM(detach)ES( func)HY(tions)YH( detach the element + value from the sequence container and, by default, remove + the element from the sequence. These addi)HY(tional)YH( func)HY(tions)YH( + have the follow)HY(ing)YH( signa)HY(tures)YH(:)EP( + + ) 22 55 PR(template +class sequence +{ +public: + ... + + void + push_back \201std::[unique|auto]_ptr\202 + + iterator + insert \201iterator position, std::[unique|auto]_ptr\202 + + std::[unique|auto]_ptr + detach_back \201bool pop = true\202; + + iterator + detach \201iterator position, + std::[unique|auto]_ptr& result, + bool erase = true\202 + + ... +})RP( + + )0 P(The follow)HY(ing)YH( code shows how one could use this mapping:)EP( + + ) 39 66 PR(void +f \201object& o\202 +{ + using xml_schema::string; + + object::member_sequence& s \201o.member \201\202\202; + + // Iteration. + // + for \201object::member_iterator i \201s.begin \201\202\202; i != s.end \201\202; ++i\202 + { + string& value \201*i\202; + } + + // Modification. + // + s.push_back \201"hello"\202; // deep copy + + // C++11 version. + // + std::unique_ptr p \201new string \201"hello"\202\202; + s.push_back \201std::move \201p\202\202; // assumes ownership + p = s.detach_back \201\202; // detach and pop + s.push_back \201std::move \201p\202\202; // re-append + + // C++98 version. + // + std::auto_ptr p \201new string \201"hello"\202\202; + s.push_back \201p\202; // assumes ownership + p = s.detach_back \201\202; // detach and pop + s.push_back \201p\202; // re-append)WR( + + // Setting a new container. + // + object::member_sequence n; + n.push_back \201"one"\202; + n.push_back \201"two"\202; + o.member \201n\202; // deep copy +})RP( + + )0 3 47 H(2.8.4)WB 192 Sn()WB 51 Sn( Element Order)EA()EH( + + )0 P(C++/Tree is a "flat)HY(ten)HY(ing)YH(" mapping in a sense that many levels of + nested compos)HY(i)HY(tors)YH( \201)SM(choice)ES( and )SM(sequence)ES(\202, + all poten)HY(tially)YH( with their own cardi)HY(nal)HY(i)HY(ties)YH(, are in the end mapped + to a flat set of elements with one of the three cardi)HY(nal)HY(ity)YH( classes + discussed in the previ)HY(ous)YH( sections. While this results in a simple + and easy to use API for most types, in certain cases, the order of + elements in the actual XML docu)HY(ments)YH( is not preserved once parsed + into the object model. And some)HY(times)YH( such order has + appli)HY(ca)HY(tion)YH(-specific signif)HY(i)HY(cance)YH(. As an example, consider a schema + that defines a batch of bank trans)HY(ac)HY(tions)YH(:)EP( + + ) 20 48 PR( + + + + + + + + + + + + + + + + + + +)RP( + + )0 P(The batch can contain any number of trans)HY(ac)HY(tions)YH( in any order + but the order of trans)HY(ac)HY(tions)YH( in each actual batch is signif)HY(i)HY(cant)YH(. + For instance, consider what could happen if we reorder the + trans)HY(ac)HY(tions)YH( and apply all the with)HY(drawals)YH( before deposits.)EP( + + )0 P(For the )SM(batch)ES( schema type defined above the default + C++/Tree mapping will produce a C++ class that contains a pair of + sequence contain)HY(ers)YH(, one for each of the two elements. While this + will capture the content \201trans)HY(ac)HY(tions)YH(\202, the order of this content + as it appears in XML will be lost. Also, if we try to seri)HY(al)HY(ize)YH( the + batch we just loaded back to XML, all the with)HY(drawal)YH( trans)HY(ac)HY(tions)YH( + will appear before deposits.)EP( + + )0 P(To over)HY(come)YH( this limi)HY(ta)HY(tion)YH( of a flat)HY(ten)HY(ing)YH( mapping, C++/Tree + allows us to mark certain XML Schema types, for which content + order is impor)HY(tant)YH(, as ordered.)EP( + + )0 P(There are several command line options that control which + schema types are treated as ordered. To make an indi)HY(vid)HY(ual)YH( + type ordered, we use the )SM(--ordered-type)ES( option, + for example:)EP( + + ) 1 20 PR(--ordered-type batch)RP( + + )0 P(To auto)HY(mat)HY(i)HY(cally)YH( treat all the types that are derived from an ordered + type also ordered, we use the )SM(--ordered-type-derived)ES( + option. This is primar)HY(ily)YH( useful if you would like to iterate + over the complete hier)HY(ar)HY(chy)YH('s content using the content order + sequence \201discussed below\202.)EP( + + )0 P(Ordered types are also useful for handling mixed content. To + auto)HY(mat)HY(i)HY(cally)YH( mark all the types with mixed content as ordered + we use the )SM(--ordered-type-mixed)ES( option. For more + infor)HY(ma)HY(tion)YH( on handling mixed content see )0 131 1 A(Section + 2.13, "Mapping for Mixed Content Models")131 0 TN TL()Ec /AF f D(.)EP( + + )0 P(Finally, we can mark all the types in the schema we are + compil)HY(ing)YH( with the )SM(--ordered-type-all)ES( option. + You should only resort to this option if all the types in + your schema truly suffer from the loss of content + order since, as we will discuss shortly, ordered types + require extra effort to access and, espe)HY(cially)YH(, modify. + See the + )R5 2 A(XSD + Compiler Command Line Manual)EA( for more infor)HY(ma)HY(tion)YH( on + these options.)EP( + + )0 P(Once a type is marked ordered, C++/Tree alters its mapping + in several ways. Firstly, for each local element, element + wild)HY(card)YH( \201)0 132 1 A(Section 2.12.4, "Element Wild)HY(card)YH( + Order")132 0 TN TL()Ec /AF f D(\202, and mixed content text \201)0 131 1 A(Section + 2.13, "Mapping for Mixed Content Models")131 0 TN TL()Ec /AF f D(\202 in this type, a + content id constant is gener)HY(ated)YH(. Secondly, an addi)HY(tion)YH( sequence + is added to the class that captures the content order. Here + is how the mapping of our )SM(batch)ES( class changes + once we make it ordered:)EP( + + ) 57 78 PR(class batch: public xml_schema::type +{ +public: + // withdraw + // + typedef withdraw withdraw_type; + typedef sequence withdraw_sequence; + typedef withdraw_sequence::iterator withdraw_iterator; + typedef withdraw_sequence::const_iterator withdraw_const_iterator; + + static const std::size_t withdraw_id = 1; + + const withdraw_sequence& + withdraw \201\202 const; + + withdraw_sequence& + withdraw \201\202; + + void + withdraw \201const withdraw_sequence&\202; + + // deposit + // + typedef deposit deposit_type; + typedef sequence deposit_sequence; + typedef deposit_sequence::iterator deposit_iterator; + typedef deposit_sequence::const_iterator deposit_const_iterator; + + static const std::size_t deposit_id = 2; + + const deposit_sequence&)WR( + deposit \201\202 const; + + deposit_sequence& + deposit \201\202; + + void + deposit \201const deposit_sequence&\202; + + // content_order + // + typedef xml_schema::content_order content_order_type; + typedef std::vector content_order_sequence; + typedef content_order_sequence::iterator content_order_iterator; + typedef content_order_sequence::const_iterator content_order_const_iterator; + + const content_order_sequence& + content_order \201\202 const; + + content_order_sequence& + content_order \201\202; + + void + content_order \201const content_order_sequence&\202; + + ... +};)RP( + + )0 P(Notice the )SM(with)HY(draw)YH(_id)ES( and )SM(deposit_id)ES( + content ids as well as the extra )SM(content_order)ES( + sequence that does not corre)HY(spond)YH( to any element in the + schema defi)HY(ni)HY(tion)YH(. The other changes to the mapping for ordered + types has to do with XML parsing and seri)HY(al)HY(iza)HY(tion)YH( code. During + parsing the content order is captured in the )SM(content_order)ES( + sequence while during seri)HY(al)HY(iza)HY(tion)YH( this sequence is used to + deter)HY(mine)YH( the order in which content is seri)HY(al)HY(ized)YH(. The + )SM(content_order)ES( sequence is also copied during + copy construc)HY(tion)YH( and assigned during copy assign)HY(ment)YH(. It is also + taken into account during compar)HY(i)HY(son)YH(.)EP( + + )0 P(The entry type of the )SM(content_order)ES( sequence is the + )SM(xml_schema::content_order)ES( type that has the follow)HY(ing)YH( + inter)HY(face)YH(:)EP( + + ) 19 58 PR(namespace xml_schema +{ + struct content_order + { + content_order \201std::size_t id, std::size_t index = 0\202; + + std::size_t id; + std::size_t index; + }; + + bool + operator== \201const content_order&, const content_order&\202; + + bool + operator!= \201const content_order&, const content_order&\202; + + bool + operator< \201const content_order&, const content_order&\202; +})RP( + + )0 P(The )SM(content_order)ES( sequence describes the order of + content \201elements, includ)HY(ing)YH( wild)HY(cards)YH(, as well as mixed content + text\202. Each entry in this sequence consists of the content id + \201for example, )SM(with)HY(draw)YH(_id)ES( or )SM(deposit_id)ES( + in our case\202 as well as, for elements of the sequence cardi)HY(nal)HY(ity)YH( + class, an index into the corre)HY(spond)HY(ing)YH( sequence container \201the + index is unused for the one and optional cardi)HY(nal)HY(ity)YH( classes\202. + For example, in our case, if the content id is )SM(with)HY(draw)YH(_id)ES(, + then the index will point into the )SM(with)HY(draw)YH()ES( element + sequence.)EP( + + )0 P(With all this infor)HY(ma)HY(tion)YH( we can now examine how to iterate over + trans)HY(ac)HY(tion)YH( in the batch in content order:)EP( + + ) 26 73 PR(batch& b = ... + +for \201batch::content_order_const_iterator i \201b.content_order \201\202.begin \201\202\202; + i != b.content_order \201\202.end \201\202; + ++i\202 +{ + switch \201i->id\202 + { + case batch::withdraw_id: + { + const withdraw& t \201b.withdraw \201\202[i->index]\202; + cerr << t.account \201\202 << " withdraw " << t.amount \201\202 << endl; + break; + } + case batch::deposit_id: + { + const deposit& t \201b.deposit \201\202[i->index]\202; + cerr << t.account \201\202 << " deposit " << t.amount \201\202 << endl; + break; + } + default: + { + assert \201false\202; // Unknown content id. + } + } +})RP( + + )0 P(If we seri)HY(al)HY(ized)YH( our batch back to XML, we would also see that the + order of trans)HY(ac)HY(tions)YH( in the output is exactly the same as in the + input rather than all the with)HY(drawals)YH( first followed by all the + deposits.)EP( + + )0 P(The most complex aspect of working with ordered types is + modi)HY(fi)HY(ca)HY(tions)YH(. Now we not only need to change the content, + but also remem)HY(ber)YH( to update the order infor)HY(ma)HY(tion)YH( corre)HY(spond)HY(ing)YH( + to this change. As a first example, we add a deposit trans)HY(ac)HY(tion)YH( + to the batch:)EP( + + ) 8 64 PR(using xml_schema::content_order; + +batch::deposit_sequence& d \201b.deposit \201\202\202; +batch::withdraw_sequence& w \201b.withdraw \201\202\202; +batch::content_order_sequence& co \201b.content_order \201\202\202; + +d.push_back \201deposit \201123456789, 100000\202\202; +co.push_back \201content_order \201batch::deposit_id, d.size \201\202 - 1\202\202;)RP( + + )0 P(In the above example we first added the content \201deposit + trans)HY(ac)HY(tion)YH(\202 and then updated the content order infor)HY(ma)HY(tion)YH( + by adding an entry with )SM(deposit_id)ES( content + id and the index of the just added deposit trans)HY(ac)HY(tion)YH(.)EP( + + )0 P(Remov)HY(ing)YH( the last trans)HY(ac)HY(tion)YH( can be easy if we know which + trans)HY(ac)HY(tion)YH( \201deposit or with)HY(drawal)YH(\202 is last:)EP( + + ) 2 15 PR(d.pop_back \201\202; +co.pop_back \201\202;)RP( + + )0 P(If, however, we do not know which trans)HY(ac)HY(tion)YH( is last, then + things get a bit more compli)HY(cated)YH(:)EP( + + ) 15 24 PR(switch \201co.back \201\202.id\202 +{ +case batch::withdraw_id: + { + d.pop_back \201\202; + break; + } +case batch::deposit_id: + { + w.pop_back \201\202; + break; + } +} + +co.pop_back \201\202;)RP( + + )0 P(The follow)HY(ing)YH( example shows how to add a trans)HY(ac)HY(tion)YH( at the + begin)HY(ning)YH( of the batch:)EP( + + ) 3 62 PR(w.push_back \201withdraw \201123456789, 100000\202\202; +co.insert \201co.begin \201\202, + content_order \201batch::withdraw_id, w.size \201\202 - 1\202\202;)RP( + + )0 P(Note also that when we merely modify the content of one + of the elements in place, we do not need to update its + order since it doesn't change. For example, here is how + we can change the amount in the first with)HY(drawal)YH(:)EP( + + ) 1 20 PR(w[0].amount \20110000\202;)RP( + + )0 P(For the complete working code shown in this section refer to the + )SM(order/element)ES( example in the + )SM(cxx/tree/)ES( direc)HY(tory)YH( in the + )R6 2 A(xsd-exam)HY(ples)YH()EA( + package.)EP( + + )0 P(If both the base and derived types are ordered, then the + content order sequence is only added to the base and the content + ids are unique within the whole hier)HY(ar)HY(chy)YH(. In this case + the content order sequence for the derived type contains + order)HY(ing)YH( infor)HY(ma)HY(tion)YH( for both base and derived content.)EP( + + )0 P(In some appli)HY(ca)HY(tions)YH( we may need to perform more complex + content process)HY(ing)YH(. For example, in our case, we may need + to remove all the with)HY(drawal)YH( trans)HY(ac)HY(tions)YH(. The default + container, )SM(std::vector)ES(, is not partic)HY(u)HY(larly)YH( + suit)HY(able)YH( for such oper)HY(a)HY(tions)YH(. What may be required by + some appli)HY(ca)HY(tions)YH( is a multi-index container that not + only allows us to iterate in content order similar to + )SM(std::vector)ES( but also search by the content + id as well as the content id and index pair.)EP( + + )0 P(While C++/Tree does not provide this func)HY(tion)HY(al)HY(ity)YH( by + default, it allows us to specify a custom container + type for content order with the )SM(--order-container)ES( + command line option. The only require)HY(ment)YH( from the + gener)HY(ated)YH( code side for such a container is to provide + the )SM(vector)ES(-like )SM(push_back\201\202)ES(, + )SM(size\201\202)ES(, and const iter)HY(a)HY(tion)YH( inter)HY(faces)YH(.)EP( + + )0 P(As an example, here is how we can use the Boost Multi-Index + container for content order. First we create the + )SM(content-order-container.hxx)ES( header with the + follow)HY(ing)YH( defi)HY(ni)HY(tion)YH(:)EP( + + ) 32 58 PR(#ifndef CONTENT_ORDER_CONTAINER +#define CONTENT_ORDER_CONTAINER + +#include // std::size_t + +#include +#include +#include +#include +#include + +struct by_id {}; +struct by_id_index {}; + +template +using content_order_container = + boost::multi_index::multi_index_container< + T, + boost::multi_index::indexed_by< + boost::multi_index::random_access<>, + boost::multi_index::ordered_unique< + boost::multi_index::tag, + boost::multi_index::identity + >, + boost::multi_index::ordered_non_unique< + boost::multi_index::tag, + boost::multi_index::member + > + > + >; +)WR( +#endif)RP( + + )0 P(Next we add the follow)HY(ing)YH( two XSD compiler options to include + this header into every gener)HY(ated)YH( header file and to use the + custom container type \201see the XSD compiler command line manual + for more infor)HY(ma)HY(tion)YH( on shell quoting for the first option\202:)EP( + + ) 2 55 PR(--hxx-prologue '#include "content-order-container.hxx"' +--order-container content_order_container)RP( + + )0 P(With these changes we can now use the multi-index func)HY(tion)HY(al)HY(ity)YH(, + for example, to search for a specific content id:)EP( + + ) 13 65 PR(typedef batch::content_order_sequence::index::type id_set; +typedef id_set::iterator id_iterator; + +const id_set& ids \201b.content_order \201\202.get \201\202\202; + +std::pair r \201 + ids.equal_range \201std::size_t \201batch::deposit_id\202\202; + +for \201id_iterator i \201r.first\202; i != r.second; ++i\202 +{ + const deposit& t \201b.deposit \201\202[i->index]\202; + cerr << t.account \201\202 << " deposit " << t.amount \201\202 << endl; +})RP( + + )0 2 48 H(2.9)WB 193 Sn()WB 52 Sn( Mapping for Global Elements)EA()EH( + + )0 P(An XML Schema element defi)HY(ni)HY(tion)YH( is called global if it appears + directly under the )SM(schema)ES( element. + A global element is a valid root of an instance docu)HY(ment)YH(. By + default, a global element is mapped to a set of over)HY(loaded)YH( + parsing and, option)HY(ally)YH(, seri)HY(al)HY(iza)HY(tion)YH( func)HY(tions)YH( with the + same name as the element. It is also possi)HY(ble)YH( to gener)HY(ate)YH( types + for root elements instead of parsing and seri)HY(al)HY(iza)HY(tion)YH( func)HY(tions)YH(. + This is primar)HY(ily)YH( useful to distin)HY(guish)YH( object models with the + same root type but with differ)HY(ent)YH( root elements. See + )0 133 1 A(Section 2.9.1, "Element Types")133 0 TN TL()Ec /AF f D( for details. + It is also possi)HY(ble)YH( to request the gener)HY(a)HY(tion)YH( of an element map + which allows uniform parsing and seri)HY(al)HY(iza)HY(tion)YH( of multi)HY(ple)YH( root + elements. See )0 134 1 A(Section 2.9.2, "Element Map")134 0 TN TL()Ec /AF f D( + for details. + )EP( + + )0 P(The parsing func)HY(tions)YH( read XML instance docu)HY(ments)YH( and return + corre)HY(spond)HY(ing)YH( object models as an auto)HY(matic)YH( pointer + \201)SM(std::unique_ptr)ES( or )SM(std::auto_ptr)ES(, + depend)HY(ing)YH( on the C++ stan)HY(dard)YH( selected\202. Their signa)HY(tures)YH( + have the follow)HY(ing)YH( pattern \201)SM(type)ES( denotes + element's type and )SM(name)ES( denotes element's + name\202: + )EP( + + ) 2 28 PR(std::[unique|auto]_ptr +name \201....\202;)RP( + + )0 P(The process of parsing, includ)HY(ing)YH( the exact signa)HY(tures)YH( of the parsing + func)HY(tions)YH(, is the subject of )0 98 1 A(Chapter 3, "Parsing")98 0 TN TL()Ec /AF f D(. + )EP( + + )0 P(The seri)HY(al)HY(iza)HY(tion)YH( func)HY(tions)YH( write object models back to XML instance + docu)HY(ments)YH(. Their signa)HY(tures)YH( have the follow)HY(ing)YH( pattern: + )EP( + + ) 2 41 PR(void +name \201&, const type&, ....\202;)RP( + + )0 P(The process of seri)HY(al)HY(iza)HY(tion)YH(, includ)HY(ing)YH( the exact signa)HY(tures)YH( of the + seri)HY(al)HY(iza)HY(tion)YH( func)HY(tions)YH(, is the subject of )0 99 1 A(Chapter 4, + "Seri)HY(al)HY(iza)HY(tion)YH(")99 0 TN TL()Ec /AF f D(. + )EP( + + + )0 3 49 H(2.9.1)WB 194 Sn()WB 53 Sn( Element Types)EA()EH( + + )0 P(The gener)HY(a)HY(tion)YH( of element types is requested with the + )SM(--gener)HY(ate)YH(-element-type)ES( option. With this option + each global element is mapped to a C++ class with the + same name as the element. Such a class is derived from + )SM(xml_schema::element_type)ES( and contains the same set + of type defi)HY(ni)HY(tions)YH(, construc)HY(tors)YH(, and member func)HY(tion)YH( as would a + type contain)HY(ing)YH( a single element with the One cardi)HY(nal)HY(ity)YH( class + named )SM("value")ES(. In addi)HY(tion)YH(, the element type also + contains a set of member func)HY(tions)YH( for access)HY(ing)YH( the element + name and names)HY(pace)YH( as well as its value in a uniform manner. + For example:)EP( + + ) 7 34 PR( + + ... + + + +)RP( + +)0 P(is mapped to:)EP( + + ) 62 59 PR(class type +{ + ... +}; + +class root: public xml_schema::element_type +{ +public: + // Element value. + // + typedef type value_type; + + const value_type& + value \201\202 const; + + value_type& + value \201\202; + + void + value \201const value_type&\202; + + void + value \201std::[unique|auto]_ptr\202; + + // Constructors. + // + root \201const value_type&\202; + + root \201std::[unique|auto]_ptr\202; + + root \201const xercesc::DOMElement&, xml_schema::flags = 0\202;)WR( + + root \201const root&, xml_schema::flags = 0\202; + + virtual root* + _clone \201xml_schema::flags = 0\202 const; + + // Element name and namespace. + // + static const std::string& + name \201\202; + + static const std::string& + namespace_ \201\202; + + virtual const std::string& + _name \201\202 const; + + virtual const std::string& + _namespace \201\202 const; + + // Element value as xml_schema::type. + // + virtual const xml_schema::type* + _value \201\202 const; + + virtual xml_schema::type* + _value \201\202; +}; + +void)WR( +operator<< \201xercesc::DOMElement&, const root&\202;)RP( + + )0 P(The )SM(xml_schema::element_type)ES( class is a common + base type for all element types and is defined as follows:)EP( + + ) 24 39 PR(namespace xml_schema +{ + class element_type + { + public: + virtual + ~element_type \201\202; + + virtual element_type* + _clone \201flags f = 0\202 const = 0; + + virtual const std::basic_string& + _name \201\202 const = 0; + + virtual const std::basic_string& + _namespace \201\202 const = 0; + + virtual xml_schema::type* + _value \201\202 = 0; + + virtual const xml_schema::type* + _value \201\202 const = 0; + }; +})RP( + + )0 P(The )SM(_value\201\202)ES( member func)HY(tion)YH( returns a pointer to + the element value or 0 if the element is of a funda)HY(men)HY(tal)YH( C++ + type and there)HY(fore)YH( is not derived from )SM(xml_schema::type)ES(. + )EP( + + )0 P(Unlike parsing and seri)HY(al)HY(iza)HY(tion)YH( func)HY(tions)YH(, element types + are only capable of parsing and seri)HY(al)HY(iz)HY(ing)YH( from/to a + )SM(DOMEle)HY(ment)YH()ES( object. This means that the appli)HY(ca)HY(tion)YH( + will need to perform its own XML-to-DOM parsing and DOM-to-XML + seri)HY(al)HY(iza)HY(tion)YH(. The follow)HY(ing)YH( section describes a mech)HY(a)HY(nism)YH( + provided by the mapping to uniformly parse and seri)HY(al)HY(ize)YH( + multi)HY(ple)YH( root elements.)EP( + + + )0 3 50 H(2.9.2)WB 195 Sn()WB 54 Sn( Element Map)EA()EH( + + )0 P(When element types are gener)HY(ated)YH( for root elements it is also + possi)HY(ble)YH( to request the gener)HY(a)HY(tion)YH( of an element map with the + )SM(--gener)HY(ate)YH(-element-map)ES( option. The element map + allows uniform parsing and seri)HY(al)HY(iza)HY(tion)YH( of multi)HY(ple)YH( root + elements via the common )SM(xml_schema::element_type)ES( + base type. The )SM(xml_schema::element_map)ES( class is + defined as follows:)EP( + + ) 12 59 PR(namespace xml_schema +{ + class element_map + { + public: + static std::[unique|auto]_ptr + parse \201const xercesc::DOMElement&, flags = 0\202; + + static void + serialize \201xercesc::DOMElement&, const element_type&\202; + }; +})RP( + + )0 P(The )SM(parse\201\202)ES( func)HY(tion)YH( creates the corre)HY(spond)HY(ing)YH( + element type object based on the element name and names)HY(pace)YH( + and returns it as an auto)HY(matic)YH( pointer \201)SM(std::unique_ptr)ES( + or )SM(std::auto_ptr)ES(, depend)HY(ing)YH( on the C++ stan)HY(dard)YH( + selected\202 to )SM(xml_schema::element_type)ES(. + The )SM(seri)HY(al)HY(ize)YH(\201\202)ES( func)HY(tion)YH( seri)HY(al)HY(izes)YH( the passed element + object to )SM(DOMEle)HY(ment)YH()ES(. Note that in case of + )SM(seri)HY(al)HY(ize)YH(\201\202)ES(, the )SM(DOMEle)HY(ment)YH()ES( object + should have the correct name and names)HY(pace)YH(. If no element type is + avail)HY(able)YH( for an element, both func)HY(tions)YH( throw the + )SM(xml_schema::no_element_info)ES( excep)HY(tion)YH(:)EP( + + ) 14 66 PR(struct no_element_info: virtual exception +{ + no_element_info \201const std::basic_string& element_name, + const std::basic_string& element_namespace\202; + + const std::basic_string& + element_name \201\202 const; + + const std::basic_string& + element_namespace \201\202 const; + + virtual const char* + what \201\202 const throw \201\202; +};)RP( + + )0 P(The appli)HY(ca)HY(tion)YH( can discover the actual type of the element + object returned by )SM(parse\201\202)ES( either using + )SM(dynamic_cast)ES( or by compar)HY(ing)YH( element names and + names)HY(paces)YH(. The follow)HY(ing)YH( code frag)HY(ments)YH( illus)HY(trate)YH( how the + element map can be used:)EP( + + ) 18 50 PR(// Parsing. +// +DOMElement& e = ... // Parse XML to DOM. + +unique_ptr r \201 + xml_schema::element_map::parse \201e\202\202; + +if \201root1 r1 = dynamic_cast \201r.get \201\202\202\202 +{ + ... +} +else if \201r->_name == root2::name \201\202 && + r->_namespace \201\202 == root2::namespace_ \201\202\202 +{ + root2& r2 \201static_cast \201*r\202\202; + + ... +})RP( + + ) 13 68 PR(// Serialization. +// +xml_schema::element_type& r = ... + +string name \201r._name \201\202\202; +string ns \201r._namespace \201\202\202; + +DOMDocument& doc = ... // Create a new DOMDocument with name and ns. +DOMElement& e \201*doc->getDocumentElement \201\202\202; + +xml_schema::element_map::serialize \201e, r\202; + +// Serialize DOMDocument to XML.)RP( + + + + )0 2 51 H(2.10)WB 196 Sn()WB 55 Sn( Mapping for Global Attributes)EA()EH( + + )0 P(An XML Schema attribute defi)HY(ni)HY(tion)YH( is called global if it appears + directly under the )SM(schema)ES( element. A global + attribute does not have any mapping. + )EP( + + + + )0 2 52 H(2.11)WB 197 Sn()WB 56 Sn( Mapping for )SM(xsi:type)ES( and Substi)HY(tu)HY(tion)YH( + Groups)EA()EH( + + )0 P(The mapping provides optional support for the XML Schema poly)HY(mor)HY(phism)YH( + features \201)SM(xsi:type)ES( and substi)HY(tu)HY(tion)YH( groups\202 which can + be requested with the )SM(--gener)HY(ate)YH(-poly)HY(mor)HY(phic)YH()ES( option. + When used, the dynamic type of a member may be differ)HY(ent)YH( from + its static type. Consider the follow)HY(ing)YH( schema defi)HY(ni)HY(tion)YH( and + instance docu)HY(ment)YH(: + )EP( + + ) 28 62 PR( + + + + + + + + + + + + + + + + + + + + + + + + + + +)RP( + + )0 P(In the result)HY(ing)YH( object model, the container for + the )SM(root::item)ES( member will have two elements: + the first element's type will be )SM(base)ES( while + the second element's \201dynamic\202 type will be + )SM(derived)ES(. This can be discov)HY(ered)YH( using the + )SM(dynamic_cast)ES( oper)HY(a)HY(tor)YH( as shown in the follow)HY(ing)YH( + example: + )EP( + + ) 17 56 PR(void +f \201root& r\202 +{ + for \201root::item_const_iterator i \201r.item \201\202.begin \201\202\202; + i != r.item \201\202.end \201\202 + ++i\202 + { + if \201derived* d = dynamic_cast \201&\201*i\202\202\202 + { + // derived + } + else + { + // base + } + } +})RP( + + )0 P(The )SM(_clone)ES( virtual func)HY(tion)YH( should be used instead of + copy construc)HY(tors)YH( to make copies of members that might use + poly)HY(mor)HY(phism)YH(: + )EP( + + ) 10 56 PR(void +f \201root& r\202 +{ + for \201root::item_const_iterator i \201r.item \201\202.begin \201\202\202; + i != r.item \201\202.end \201\202 + ++i\202 + { + std::unique_ptr c \201i->_clone \201\202\202; + } +})RP( + + )0 P(The mapping can often auto)HY(mat)HY(i)HY(cally)YH( deter)HY(mine)YH( which types are + poly)HY(mor)HY(phic)YH( based on the substi)HY(tu)HY(tion)YH( group decla)HY(ra)HY(tions)YH(. However, + if your XML vocab)HY(u)HY(lary)YH( is not using substi)HY(tu)HY(tion)YH( groups or if + substi)HY(tu)HY(tion)YH( groups are defined in a sepa)HY(rate)YH( schema, then you will + need to use the )SM(--poly)HY(mor)HY(phic)YH(-type)ES( option to specify + which types are poly)HY(mor)HY(phic)YH(. When using this option you only need + to specify the root of a poly)HY(mor)HY(phic)YH( type hier)HY(ar)HY(chy)YH( and the mapping + will assume that all the derived types are also poly)HY(mor)HY(phic)YH(. + Also note that you need to specify this option when compil)HY(ing)YH( every + schema file that refer)HY(ences)YH( the poly)HY(mor)HY(phic)YH( type. Consider the follow)HY(ing)YH( + two schemas as an example:)EP( + + ) 13 55 PR( + + + + + + + + + + + +)RP( + + ) 18 70 PR( + + + + + + + + + + + + + + + + +)RP( + + )0 P(In this example we need to specify ")SM(--poly)HY(mor)HY(phic)YH(-type base)ES(" + when compil)HY(ing)YH( both schemas because the substi)HY(tu)HY(tion)YH( group is declared + in a schema other than the one defin)HY(ing)YH( type )SM(base)ES(.)EP( + + )0 P(You can also indi)HY(cate)YH( that all types should be treated as poly)HY(mor)HY(phic)YH( + with the )SM(--poly)HY(mor)HY(phic)YH(-type-all)ES(. However, this may result + in slower gener)HY(ated)YH( code with a greater foot)HY(print)YH(.)EP( + + + + + + )0 2 53 H(2.12)WB 198 Sn()WB 57 Sn( Mapping for )SM(any)ES( and )SM(anyAt)HY(tribute)YH()ES()EA()EH( + + )0 P(For the XML Schema )SM(any)ES( and )SM(anyAt)HY(tribute)YH()ES( + wild)HY(cards)YH( an optional mapping can be requested with the + )SM(--gener)HY(ate)YH(-wild)HY(card)YH()ES( option. The mapping repre)HY(sents)YH( + the content matched by wild)HY(cards)YH( as DOM frag)HY(ments)YH(. Because the + DOM API is used to access such content, the Xerces-C++ runtime + should be initial)HY(ized)YH( by the appli)HY(ca)HY(tion)YH( prior to parsing and + should remain initial)HY(ized)YH( for the life)HY(time)YH( of objects with + the wild)HY(card)YH( content. For more infor)HY(ma)HY(tion)YH( on the Xerces-C++ + runtime initial)HY(iza)HY(tion)YH( see )0 124 1 A(Section 3.1, + "Initial)HY(iz)HY(ing)YH( the Xerces-C++ Runtime")124 0 TN TL()Ec /AF f D(. + )EP( + + )0 P(The mapping for )SM(any)ES( is similar to the mapping for + local elements \201see )0 129 1 A(Section 2.8, "Mapping for Local + Elements and Attributes")129 0 TN TL()Ec /AF f D(\202 except that the type used in the + wild)HY(card)YH( mapping is )SM(xercesc::DOMEle)HY(ment)YH()ES(. As with local + elements, the mapping divides all possi)HY(ble)YH( cardi)HY(nal)HY(ity)YH( combi)HY(na)HY(tions)YH( + into three cardi)HY(nal)HY(ity)YH( classes: )I(one)ES(, )I(optional)ES(, and + )I(sequence)ES(. + )EP( + + )0 P(The mapping for )SM(anyAt)HY(tribute)YH()ES( repre)HY(sents)YH( the attributes + matched by this wild)HY(card)YH( as a set of )SM(xercesc::DOMAttr)ES( + objects with a key being the attribute's name and names)HY(pace)YH(.)EP( + + )0 P(Similar to local elements and attributes, the )SM(any)ES( and + )SM(anyAt)HY(tribute)YH()ES( wild)HY(cards)YH( are mapped to a set of public type + defi)HY(ni)HY(tions)YH( \201type)HY(defs)YH(\202 and a set of public acces)HY(sor)YH( and modi)HY(fier)YH( + func)HY(tions)YH(. Type defi)HY(ni)HY(tions)YH( have names derived from )SM("any")ES( + for the )SM(any)ES( wild)HY(card)YH( and )SM("any_attribute")ES( + for the )SM(anyAt)HY(tribute)YH()ES( wild)HY(card)YH(. The acces)HY(sor)YH( and modi)HY(fier)YH( + func)HY(tions)YH( are named )SM("any")ES( for the )SM(any)ES( wild)HY(card)YH( + and )SM("any_attribute")ES( for the )SM(anyAt)HY(tribute)YH()ES( + wild)HY(card)YH(. Subse)HY(quent)YH( wild)HY(cards)YH( in the same type have escaped names + such as )SM("any1")ES( or )SM("any_attribute1")ES(. + )EP( + + )0 P(Because Xerces-C++ DOM nodes always belong to a )SM(DOMDoc)HY(u)HY(ment)YH()ES(, + each type with a wild)HY(card)YH( has an asso)HY(ci)HY(ated)YH( )SM(DOMDoc)HY(u)HY(ment)YH()ES( + object. The refer)HY(ence)YH( to this object can be obtained using the acces)HY(sor)YH( + func)HY(tion)YH( called )SM(dom_docu)HY(ment)YH()ES(. The access to the docu)HY(ment)YH( + object from the appli)HY(ca)HY(tion)YH( code may be neces)HY(sary)YH( to create or modify + the wild)HY(card)YH( content. For example: + )EP( + + ) 6 37 PR( + + + + +)RP( + + )0 P(is mapped to:)EP( + + ) 37 73 PR(class object: public xml_schema::type +{ +public: + // any + // + const xercesc::DOMElement& + any \201\202 const; + + void + any \201const xercesc::DOMElement&\202; + + ... + + // any_attribute + // + typedef attribute_set any_attribute_set; + typedef any_attribute_set::iterator any_attribute_iterator; + typedef any_attribute_set::const_iterator any_attribute_const_iterator; + + const any_attribute_set& + any_attribute \201\202 const; + + any_attribute_set& + any_attribute \201\202; + + ... + + // DOMDocument object for wildcard content. + // + const xercesc::DOMDocument& + dom_document \201\202 const;)WR( + + xercesc::DOMDocument& + dom_document \201\202; + + ... +};)RP( + + + )0 P(Names and seman)HY(tics)YH( of type defi)HY(ni)HY(tions)YH( for the wild)HY(cards)YH( as well + as signa)HY(tures)YH( of the acces)HY(sor)YH( and modi)HY(fier)YH( func)HY(tions)YH( depend on the + wild)HY(card)YH( type as well as the cardi)HY(nal)HY(ity)YH( class for the )SM(any)ES( + wild)HY(card)YH(. They are described in the follow)HY(ing)YH( sub-sections. + )EP( + + + )0 3 54 H(2.12.1)WB 199 Sn()WB 58 Sn( Mapping for )SM(any)ES( with the One Cardi)HY(nal)HY(ity)YH( Class)EA()EH( + + )0 P(For )SM(any)ES( with the One cardi)HY(nal)HY(ity)YH( class, + there are no type defi)HY(ni)HY(tions)YH(. The acces)HY(sor)YH( func)HY(tions)YH( come in + constant and non-constant versions. The constant acces)HY(sor)YH( func)HY(tion)YH( + returns a constant refer)HY(ence)YH( to )SM(xercesc::DOMEle)HY(ment)YH()ES( and + can be used for read-only access. The non-constant version returns + an unre)HY(stricted)YH( refer)HY(ence)YH( to )SM(xercesc::DOMEle)HY(ment)YH()ES( and can + be used for read-write access. + )EP( + + )0 P(The first modi)HY(fier)YH( func)HY(tion)YH( expects an argu)HY(ment)YH( of type refer)HY(ence)YH( + to constant )SM(xercesc::DOMEle)HY(ment)YH()ES( and makes a deep copy + of its argu)HY(ment)YH(. The second modi)HY(fier)YH( func)HY(tion)YH( expects an argu)HY(ment)YH( of + type pointer to )SM(xercesc::DOMEle)HY(ment)YH()ES(. This modi)HY(fier)YH( + func)HY(tion)YH( assumes owner)HY(ship)YH( of its argu)HY(ment)YH( and expects the element + object to be created using the DOM docu)HY(ment)YH( asso)HY(ci)HY(ated)YH( with this + instance. For example: + )EP( + + ) 5 30 PR( + + + +)RP( + + )0 P(is mapped to:)EP( + + ) 22 37 PR(class object: public xml_schema::type +{ +public: + // Accessors. + // + const xercesc::DOMElement& + any \201\202 const; + + xercesc::DOMElement& + any \201\202; + + // Modifiers. + // + void + any \201const xercesc::DOMElement&\202; + + void + any \201xercesc::DOMElement*\202; + + ... + +};)RP( + + + )0 P(The follow)HY(ing)YH( code shows how one could use this mapping:)EP( + + ) 10 66 PR(void +f \201object& o, const xercesc::DOMElement& e\202 +{ + using namespace xercesc; + + DOMElement& e1 \201o.any \201\202\202; // get + o.any \201e\202 // set, deep copy + DOMDocument& doc \201o.dom_document \201\202\202; + o.any \201doc.createElement \201...\202\202; // set, assumes ownership +})RP( + + )0 3 55 H(2.12.2)WB 200 Sn()WB 59 Sn( Mapping for )SM(any)ES( with the Optional Cardi)HY(nal)HY(ity)YH( Class)EA()EH( + + )0 P(For )SM(any)ES( with the Optional cardi)HY(nal)HY(ity)YH( class, the type + defi)HY(ni)HY(tions)YH( consist of an alias for the container type with name + )SM(any_optional)ES( \201or )SM(any1_optional)ES(, etc., for + subse)HY(quent)YH( wild)HY(cards)YH( in the type defi)HY(ni)HY(tion)YH(\202. + )EP( + + )0 P(Unlike acces)HY(sor)YH( func)HY(tions)YH( for the One cardi)HY(nal)HY(ity)YH( class, acces)HY(sor)YH( + func)HY(tions)YH( for the Optional cardi)HY(nal)HY(ity)YH( class return refer)HY(ences)YH( to + corre)HY(spond)HY(ing)YH( contain)HY(ers)YH( rather than directly to )SM(DOMEle)HY(ment)YH()ES(. + The acces)HY(sor)YH( func)HY(tions)YH( come in constant and non-constant versions. + The constant acces)HY(sor)YH( func)HY(tion)YH( returns a constant refer)HY(ence)YH( to + the container and can be used for read-only access. The non-constant + version returns an unre)HY(stricted)YH( refer)HY(ence)YH( to the container + and can be used for read-write access. + )EP( + + )0 P(The modi)HY(fier)YH( func)HY(tions)YH( are over)HY(loaded)YH( for )SM(xercesc::DOMEle)HY(ment)YH()ES( + and the container type. The first modi)HY(fier)YH( func)HY(tion)YH( expects an argu)HY(ment)YH( of + type refer)HY(ence)YH( to constant )SM(xercesc::DOMEle)HY(ment)YH()ES( and + makes a deep copy of its argu)HY(ment)YH(. The second modi)HY(fier)YH( func)HY(tion)YH( + expects an argu)HY(ment)YH( of type pointer to )SM(xercesc::DOMEle)HY(ment)YH()ES(. + This modi)HY(fier)YH( func)HY(tion)YH( assumes owner)HY(ship)YH( of its argu)HY(ment)YH( and expects + the element object to be created using the DOM docu)HY(ment)YH( asso)HY(ci)HY(ated)YH( + with this instance. The third modi)HY(fier)YH( func)HY(tion)YH( expects an argu)HY(ment)YH( + of type refer)HY(ence)YH( to constant of the container type and makes a + deep copy of its argu)HY(ment)YH(. For instance: + )EP( + + ) 5 44 PR( + + + +)RP( + + )0 P(is mapped to:)EP( + + ) 29 40 PR(class object: public xml_schema::type +{ +public: + // Type definitions. + // + typedef element_optional any_optional; + + // Accessors. + // + const any_optional& + any \201\202 const; + + any_optional& + any \201\202; + + // Modifiers. + // + void + any \201const xercesc::DOMElement&\202; + + void + any \201xercesc::DOMElement*\202; + + void + any \201const any_optional&\202; + + ... + +};)RP( + + + )0 P(The )SM(element_optional)ES( container is a + special)HY(iza)HY(tion)YH( of the )SM(optional)ES( class template described + in )0 135 1 A(Section 2.8.2, "Mapping for Members with the Optional + Cardi)HY(nal)HY(ity)YH( Class")135 0 TN TL()Ec /AF f D(. Its inter)HY(face)YH( is presented below: + )EP( + + ) 72 71 PR(class element_optional +{ +public: + explicit + element_optional \201xercesc::DOMDocument&\202; + + // Makes a deep copy. + // + element_optional \201const xercesc::DOMElement&, xercesc::DOMDocument&\202; + + // Assumes ownership. + // + element_optional \201xercesc::DOMElement*, xercesc::DOMDocument&\202; + + element_optional \201const element_optional&, xercesc::DOMDocument&\202; + +public: + element_optional& + operator= \201const xercesc::DOMElement&\202; + + element_optional& + operator= \201const element_optional&\202; + + // Pointer-like interface. + // +public: + const xercesc::DOMElement* + operator-> \201\202 const; + + xercesc::DOMElement* + operator-> \201\202;)WR( + + const xercesc::DOMElement& + operator* \201\202 const; + + xercesc::DOMElement& + operator* \201\202; + + typedef void \201element_optional::*bool_convertible\202 \201\202; + operator bool_convertible \201\202 const; + + // Get/set interface. + // +public: + bool + present \201\202 const; + + const xercesc::DOMElement& + get \201\202 const; + + xercesc::DOMElement& + get \201\202; + + // Makes a deep copy. + // + void + set \201const xercesc::DOMElement&\202; + + // Assumes ownership. + // + void)WR( + set \201xercesc::DOMElement*\202; + + void + reset \201\202; +}; + +bool +operator== \201const element_optional&, const element_optional&\202; + +bool +operator!= \201const element_optional&, const element_optional&\202;)RP( + + + )0 P(The follow)HY(ing)YH( code shows how one could use this mapping:)EP( + + ) 25 69 PR(void +f \201object& o, const xercesc::DOMElement& e\202 +{ + using namespace xercesc; + + DOMDocument& doc \201o.dom_document \201\202\202; + + if \201o.any \201\202.present \201\202\202 // test + { + DOMElement& e1 \201o.any \201\202.get \201\202\202; // get + o.any \201\202.set \201e\202; // set, deep copy + o.any \201\202.set \201doc.createElement \201...\202\202; // set, assumes ownership + o.any \201\202.reset \201\202; // reset + } + + // Same as above but using pointer notation: + // + if \201o.member \201\202\202 // test + { + DOMElement& e1 \201*o.any \201\202\202; // get + o.any \201e\202; // set, deep copy + o.any \201doc.createElement \201...\202\202; // set, assumes ownership + o.any \201\202.reset \201\202; // reset + } +})RP( + + + + )0 3 56 H(2.12.3)WB 201 Sn()WB 60 Sn( Mapping for )SM(any)ES( with the Sequence Cardi)HY(nal)HY(ity)YH( Class)EA()EH( + + )0 P(For )SM(any)ES( with the Sequence cardi)HY(nal)HY(ity)YH( class, the type + defi)HY(ni)HY(tions)YH( consist of an alias of the container type with name + )SM(any_sequence)ES( \201or )SM(any1_sequence)ES(, etc., for + subse)HY(quent)YH( wild)HY(cards)YH( in the type defi)HY(ni)HY(tion)YH(\202, an alias of the iter)HY(a)HY(tor)YH( + type with name )SM(any_iter)HY(a)HY(tor)YH()ES( \201or )SM(any1_iter)HY(a)HY(tor)YH()ES(, + etc., for subse)HY(quent)YH( wild)HY(cards)YH( in the type defi)HY(ni)HY(tion)YH(\202, and an alias + of the constant iter)HY(a)HY(tor)YH( type with name )SM(any_const_iter)HY(a)HY(tor)YH()ES( + \201or )SM(any1_const_iter)HY(a)HY(tor)YH()ES(, etc., for subse)HY(quent)YH( wild)HY(cards)YH( + in the type defi)HY(ni)HY(tion)YH(\202. + )EP( + + )0 P(The acces)HY(sor)YH( func)HY(tions)YH( come in constant and non-constant versions. + The constant acces)HY(sor)YH( func)HY(tion)YH( returns a constant refer)HY(ence)YH( to the + container and can be used for read-only access. The non-constant + version returns an unre)HY(stricted)YH( refer)HY(ence)YH( to the container and can + be used for read-write access. + )EP( + + )0 P(The modi)HY(fier)YH( func)HY(tion)YH( expects an argu)HY(ment)YH( of type refer)HY(ence)YH( to + constant of the container type. The modi)HY(fier)YH( func)HY(tion)YH( makes + a deep copy of its argu)HY(ment)YH(. For instance: + )EP( + + + ) 5 52 PR( + + + +)RP( + + )0 P(is mapped to:)EP( + + ) 25 58 PR(class object: public xml_schema::type +{ +public: + // Type definitions. + // + typedef element_sequence any_sequence; + typedef any_sequence::iterator any_iterator; + typedef any_sequence::const_iterator any_const_iterator; + + // Accessors. + // + const any_sequence& + any \201\202 const; + + any_sequence& + any \201\202; + + // Modifier. + // + void + any \201const any_sequence&\202; + + ... + +};)RP( + + )0 P(The )SM(element_sequence)ES( container is a + special)HY(iza)HY(tion)YH( of the )SM(sequence)ES( class template described + in )0 136 1 A(Section 2.8.3, "Mapping for Members with the + Sequence Cardi)HY(nal)HY(ity)YH( Class")136 0 TN TL()Ec /AF f D(. Its inter)HY(face)YH( is similar to + the sequence inter)HY(face)YH( as defined by the ISO/ANSI Stan)HY(dard)YH( for + C++ \201ISO/IEC 14882:1998, Section 23.1.1, "Sequences"\202 and is + presented below: + )EP( + + ) 178 70 PR(class element_sequence +{ +public: + typedef xercesc::DOMElement value_type; + typedef xercesc::DOMElement* pointer; + typedef const xercesc::DOMElement* const_pointer; + typedef xercesc::DOMElement& reference; + typedef const xercesc::DOMElement& const_reference; + + typedef iterator; + typedef const_iterator; + typedef reverse_iterator; + typedef const_reverse_iterator; + + typedef size_type; + typedef difference_type; + typedef allocator_type; + +public: + explicit + element_sequence \201xercesc::DOMDocument&\202; + + // DOMElement cannot be default-constructed. + // + // explicit + // element_sequence \201size_type n\202; + + element_sequence \201size_type n, + const xercesc::DOMElement&, + xercesc::DOMDocument&\202; +)WR( + template + element_sequence \201const I& begin, + const I& end, + xercesc::DOMDocument&\202; + + element_sequence \201const element_sequence&, xercesc::DOMDocument&\202; + + element_sequence& + operator= \201const element_sequence&\202; + +public: + void + assign \201size_type n, const xercesc::DOMElement&\202; + + template + void + assign \201const I& begin, const I& end\202; + +public: + // This version of resize can only be used to shrink the + // sequence because DOMElement cannot be default-constructed. + // + void + resize \201size_type\202; + + void + resize \201size_type, const xercesc::DOMElement&\202; + +public: + size_type)WR( + size \201\202 const; + + size_type + max_size \201\202 const; + + size_type + capacity \201\202 const; + + bool + empty \201\202 const; + + void + reserve \201size_type\202; + + void + clear \201\202; + +public: + const_iterator + begin \201\202 const; + + const_iterator + end \201\202 const; + + iterator + begin \201\202; + + iterator + end \201\202; +)WR( + const_reverse_iterator + rbegin \201\202 const; + + const_reverse_iterator + rend \201\202 const + + reverse_iterator + rbegin \201\202; + + reverse_iterator + rend \201\202; + +public: + xercesc::DOMElement& + operator[] \201size_type\202; + + const xercesc::DOMElement& + operator[] \201size_type\202 const; + + xercesc::DOMElement& + at \201size_type\202; + + const xercesc::DOMElement& + at \201size_type\202 const; + + xercesc::DOMElement& + front \201\202; + + const xercesc::DOMElement& + front \201\202 const;)WR( + + xercesc::DOMElement& + back \201\202; + + const xercesc::DOMElement& + back \201\202 const; + +public: + // Makes a deep copy. + // + void + push_back \201const xercesc::DOMElement&\202; + + // Assumes ownership. + // + void + push_back \201xercesc::DOMElement*\202; + + void + pop_back \201\202; + + // Makes a deep copy. + // + iterator + insert \201iterator position, const xercesc::DOMElement&\202; + + // Assumes ownership. + // + iterator + insert \201iterator position, xercesc::DOMElement*\202;)WR( + + void + insert \201iterator position, size_type n, const xercesc::DOMElement&\202; + + template + void + insert \201iterator position, const I& begin, const I& end\202; + + iterator + erase \201iterator position\202; + + iterator + erase \201iterator begin, iterator end\202; + +public: + // Note that the DOMDocument object of the two sequences being + // swapped should be the same. + // + void + swap \201sequence& x\202; +}; + +inline bool +operator== \201const element_sequence&, const element_sequence&\202; + +inline bool +operator!= \201const element_sequence&, const element_sequence&\202;)RP( + + + )0 P(The follow)HY(ing)YH( code shows how one could use this mapping:)EP( + + ) 20 63 PR(void +f \201object& o, const xercesc::DOMElement& e\202 +{ + using namespace xercesc; + + object::any_sequence& s \201o.any \201\202\202; + + // Iteration. + // + for \201object::any_iterator i \201s.begin \201\202\202; i != s.end \201\202; ++i\202 + { + DOMElement& e \201*i\202; + } + + // Modification. + // + s.push_back \201e\202; // deep copy + DOMDocument& doc \201o.dom_document \201\202\202; + s.push_back \201doc.createElement \201...\202\202; // assumes ownership +})RP( + + )0 3 57 H(2.12.4)WB 202 Sn()WB 61 Sn( Element Wild)HY(card)YH( Order)EA()EH( + + )0 P(Similar to elements, element wild)HY(cards)YH( in ordered types + \201)0 137 1 A(Section 2.8.4, "Element Order")137 0 TN TL()Ec /AF f D(\202 are assigned + content ids and are included in the content order sequence. + Contin)HY(u)HY(ing)YH( with the bank trans)HY(ac)HY(tions)YH( example started in Section + 2.8.4, we can extend the batch by allow)HY(ing)YH( custom trans)HY(ac)HY(tions)YH(:)EP( + + ) 7 52 PR( + + + + + +)RP( + + )0 P(This will lead to the follow)HY(ing)YH( changes in the gener)HY(ated)YH( + )SM(batch)ES( C++ class:)EP( + + ) 24 58 PR(class batch: public xml_schema::type +{ +public: + ... + + // any + // + typedef element_sequence any_sequence; + typedef any_sequence::iterator any_iterator; + typedef any_sequence::const_iterator any_const_iterator; + + static const std::size_t any_id = 3UL; + + const any_sequence& + any \201\202 const; + + any_sequence& + any \201\202; + + void + any \201const any_sequence&\202; + + ... +};)RP( + + )0 P(With this change we also need to update the iter)HY(a)HY(tion)YH( code to handle + the new content id:)EP( + + ) 18 73 PR(for \201batch::content_order_const_iterator i \201b.content_order \201\202.begin \201\202\202; + i != b.content_order \201\202.end \201\202; + ++i\202 +{ + switch \201i->id\202 + { + ... + + case batch::any_id: + { + const DOMElement& e \201b.any \201\202[i->index]\202; + ... + break; + } + + ... + } +})RP( + + )0 P(For the complete working code that shows the use of wild)HY(cards)YH( in + ordered types refer to the )SM(order/element)ES( example in + the )SM(cxx/tree/)ES( direc)HY(tory)YH( in the + )R6 2 A(xsd-exam)HY(ples)YH()EA( + package.)EP( + + )0 3 58 H(2.12.5)WB 203 Sn()WB 62 Sn( Mapping for )SM(anyAt)HY(tribute)YH()ES()EA()EH( + + )0 P(For )SM(anyAt)HY(tribute)YH()ES( the type defi)HY(ni)HY(tions)YH( consist of an alias + of the container type with name )SM(any_attribute_set)ES( + \201or )SM(any1_attribute_set)ES(, etc., for subse)HY(quent)YH( wild)HY(cards)YH( + in the type defi)HY(ni)HY(tion)YH(\202, an alias of the iter)HY(a)HY(tor)YH( type with name + )SM(any_attribute_iter)HY(a)HY(tor)YH()ES( \201or )SM(any1_attribute_iter)HY(a)HY(tor)YH()ES(, + etc., for subse)HY(quent)YH( wild)HY(cards)YH( in the type defi)HY(ni)HY(tion)YH(\202, and an alias + of the constant iter)HY(a)HY(tor)YH( type with name )SM(any_attribute_const_iter)HY(a)HY(tor)YH()ES( + \201or )SM(any1_attribute_const_iter)HY(a)HY(tor)YH()ES(, etc., for subse)HY(quent)YH( + wild)HY(cards)YH( in the type defi)HY(ni)HY(tion)YH(\202. + )EP( + + )0 P(The acces)HY(sor)YH( func)HY(tions)YH( come in constant and non-constant versions. + The constant acces)HY(sor)YH( func)HY(tion)YH( returns a constant refer)HY(ence)YH( to the + container and can be used for read-only access. The non-constant + version returns an unre)HY(stricted)YH( refer)HY(ence)YH( to the container and can + be used for read-write access. + )EP( + + )0 P(The modi)HY(fier)YH( func)HY(tion)YH( expects an argu)HY(ment)YH( of type refer)HY(ence)YH( to + constant of the container type. The modi)HY(fier)YH( func)HY(tion)YH( makes + a deep copy of its argu)HY(ment)YH(. For instance: + )EP( + + + ) 6 37 PR( + + ... + + +)RP( + + )0 P(is mapped to:)EP( + + ) 25 73 PR(class object: public xml_schema::type +{ +public: + // Type definitions. + // + typedef attribute_set any_attribute_set; + typedef any_attribute_set::iterator any_attribute_iterator; + typedef any_attribute_set::const_iterator any_attribute_const_iterator; + + // Accessors. + // + const any_attribute_set& + any_attribute \201\202 const; + + any_attribute_set& + any_attribute \201\202; + + // Modifier. + // + void + any_attribute \201const any_attribute_set&\202; + + ... + +};)RP( + + )0 P(The )SM(attribute_set)ES( class is an asso)HY(cia)HY(tive)YH( container + similar to the )SM(std::set)ES( class template as defined by + the ISO/ANSI Stan)HY(dard)YH( for C++ \201ISO/IEC 14882:1998, Section 23.3.3, + "Class template set"\202 with the key being the attribute's name + and names)HY(pace)YH(. Unlike )SM(std::set)ES(, )SM(attribute_set)ES( + allows search)HY(ing)YH( using names and names)HY(paces)YH( instead of + )SM(xercesc::DOMAttr)ES( objects. It is defined in an + imple)HY(men)HY(ta)HY(tion)YH(-specific names)HY(pace)YH( and its inter)HY(face)YH( is presented + below: + )EP( + + ) 166 70 PR(class attribute_set +{ +public: + typedef xercesc::DOMAttr key_type; + typedef xercesc::DOMAttr value_type; + typedef xercesc::DOMAttr* pointer; + typedef const xercesc::DOMAttr* const_pointer; + typedef xercesc::DOMAttr& reference; + typedef const xercesc::DOMAttr& const_reference; + + typedef iterator; + typedef const_iterator; + typedef reverse_iterator; + typedef const_reverse_iterator; + + typedef size_type; + typedef difference_type; + typedef allocator_type; + +public: + attribute_set \201xercesc::DOMDocument&\202; + + template + attribute_set \201const I& begin, const I& end, xercesc::DOMDocument&\202; + + attribute_set \201const attribute_set&, xercesc::DOMDocument&\202; + + attribute_set& + operator= \201const attribute_set&\202; + +public:)WR( + const_iterator + begin \201\202 const; + + const_iterator + end \201\202 const; + + iterator + begin \201\202; + + iterator + end \201\202; + + const_reverse_iterator + rbegin \201\202 const; + + const_reverse_iterator + rend \201\202 const; + + reverse_iterator + rbegin \201\202; + + reverse_iterator + rend \201\202; + +public: + size_type + size \201\202 const; + + size_type + max_size \201\202 const;)WR( + + bool + empty \201\202 const; + + void + clear \201\202; + +public: + // Makes a deep copy. + // + std::pair + insert \201const xercesc::DOMAttr&\202; + + // Assumes ownership. + // + std::pair + insert \201xercesc::DOMAttr*\202; + + // Makes a deep copy. + // + iterator + insert \201iterator position, const xercesc::DOMAttr&\202; + + // Assumes ownership. + // + iterator + insert \201iterator position, xercesc::DOMAttr*\202; + + template + void)WR( + insert \201const I& begin, const I& end\202; + +public: + void + erase \201iterator position\202; + + size_type + erase \201const std::basic_string& name\202; + + size_type + erase \201const std::basic_string& namespace_, + const std::basic_string& name\202; + + size_type + erase \201const XMLCh* name\202; + + size_type + erase \201const XMLCh* namespace_, const XMLCh* name\202; + + void + erase \201iterator begin, iterator end\202; + +public: + size_type + count \201const std::basic_string& name\202 const; + + size_type + count \201const std::basic_string& namespace_, + const std::basic_string& name\202 const; +)WR( + size_type + count \201const XMLCh* name\202 const; + + size_type + count \201const XMLCh* namespace_, const XMLCh* name\202 const; + + iterator + find \201const std::basic_string& name\202; + + iterator + find \201const std::basic_string& namespace_, + const std::basic_string& name\202; + + iterator + find \201const XMLCh* name\202; + + iterator + find \201const XMLCh* namespace_, const XMLCh* name\202; + + const_iterator + find \201const std::basic_string& name\202 const; + + const_iterator + find \201const std::basic_string& namespace_, + const std::basic_string& name\202 const; + + const_iterator + find \201const XMLCh* name\202 const; + + const_iterator)WR( + find \201const XMLCh* namespace_, const XMLCh* name\202 const; + +public: + // Note that the DOMDocument object of the two sets being + // swapped should be the same. + // + void + swap \201attribute_set&\202; +}; + +bool +operator== \201const attribute_set&, const attribute_set&\202; + +bool +operator!= \201const attribute_set&, const attribute_set&\202;)RP( + + )0 P(The follow)HY(ing)YH( code shows how one could use this mapping:)EP( + + ) 25 73 PR(void +f \201object& o, const xercesc::DOMAttr& a\202 +{ + using namespace xercesc; + + object::any_attribute_set& s \201o.any_attribute \201\202\202; + + // Iteration. + // + for \201object::any_attribute_iterator i \201s.begin \201\202\202; i != s.end \201\202; ++i\202 + { + DOMAttr& a \201*i\202; + } + + // Modification. + // + s.insert \201a\202; // deep copy + DOMDocument& doc \201o.dom_document \201\202\202; + s.insert \201doc.createAttribute \201...\202\202; // assumes ownership + + // Searching. + // + object::any_attribute_iterator i \201s.find \201"name"\202\202; + i = s.find \201"http://www.w3.org/XML/1998/namespace", "lang"\202; +})RP( + + + + )0 2 59 H(2.13)WB 204 Sn()WB 63 Sn( Mapping for Mixed Content Models)EA()EH( + + )0 P(For XML Schema types with mixed content models C++/Tree provides + mapping support only if the type is marked as ordered + \201)0 137 1 A(Section 2.8.4, "Element Order")137 0 TN TL()Ec /AF f D(\202. Use the + )SM(--ordered-type-mixed)ES( XSD compiler option to + auto)HY(mat)HY(i)HY(cally)YH( mark all types with mixed content as ordered.)EP( + + )0 P(For an ordered type with mixed content, C++/Tree adds an extra + text content sequence that is used to store the text frag)HY(ments)YH(. + This text content sequence is also assigned the content id and + its entries are included in the content order sequence, just + like elements. As a result, it is possi)HY(ble)YH( to capture the order + between elements and text frag)HY(ments)YH(.)EP( + + )0 P(As an example, consider the follow)HY(ing)YH( schema that describes text + with embed)HY(ded)YH( links:)EP( + + ) 13 73 PR( + + + + + + + + + + + +)RP( + + )0 P(The gener)HY(ated)YH( )SM(text)ES( C++ class will provide the follow)HY(ing)YH( + API \201assum)HY(ing)YH( it is marked as ordered\202:)EP( + + ) 57 78 PR(class text: public xml_schema::type +{ +public: + // a + // + typedef anchor a_type; + typedef sequence a_sequence; + typedef a_sequence::iterator a_iterator; + typedef a_sequence::const_iterator a_const_iterator; + + static const std::size_t a_id = 1UL; + + const a_sequence& + a \201\202 const; + + a_sequence& + a \201\202; + + void + a \201const a_sequence&\202; + + // text_content + // + typedef xml_schema::string text_content_type; + typedef sequence text_content_sequence; + typedef text_content_sequence::iterator text_content_iterator; + typedef text_content_sequence::const_iterator text_content_const_iterator; + + static const std::size_t text_content_id = 2UL; + + const text_content_sequence&)WR( + text_content \201\202 const; + + text_content_sequence& + text_content \201\202; + + void + text_content \201const text_content_sequence&\202; + + // content_order + // + typedef xml_schema::content_order content_order_type; + typedef std::vector content_order_sequence; + typedef content_order_sequence::iterator content_order_iterator; + typedef content_order_sequence::const_iterator content_order_const_iterator; + + const content_order_sequence& + content_order \201\202 const; + + content_order_sequence& + content_order \201\202; + + void + content_order \201const content_order_sequence&\202; + + ... +};)RP( + + )0 P(Given this inter)HY(face)YH( we can iterate over both link elements + and text in content order. The follow)HY(ing)YH( code frag)HY(ment)YH( converts + our format to plain text with refer)HY(ences)YH(.)EP( + + ) 26 72 PR(const text& t = ... + +for \201text::content_order_const_iterator i \201t.content_order \201\202.begin \201\202\202; + i != t.content_order \201\202.end \201\202; + ++i\202 +{ + switch \201i->id\202 + { + case text::a_id: + { + const anchor& a \201t.a \201\202[i->index]\202; + cerr << a << "[" << a.href \201\202 << "]"; + break; + } + case text::text_content_id: + { + const xml_schema::string& s \201t.text_content \201\202[i->index]\202; + cerr << s; + break; + } + default: + { + assert \201false\202; // Unknown content id. + } + } +})RP( + + )0 P(For the complete working code that shows the use of mixed content + in ordered types refer to the )SM(order/mixed)ES( example in + the )SM(cxx/tree/)ES( direc)HY(tory)YH( in the + )R6 2 A(xsd-exam)HY(ples)YH()EA( + package.)EP( + + + + + )0 1 60 H(3)WB 205 Sn()WB 64 Sn( Parsing)EA()EH( + + )0 P(This chapter covers various aspects of parsing XML instance + docu)HY(ments)YH( in order to obtain corre)HY(spond)HY(ing)YH( tree-like object + model. + )EP( + + )0 P(Each global XML Schema element in the form:)EP( + + ) 1 34 PR()RP( + + )0 P(is mapped to 14 over)HY(loaded)YH( C++ func)HY(tions)YH( in the form:)EP( + + ) 96 65 PR(// Read from a URI or a local file. +// + +std::[unique|auto]_ptr +name \201const std::basic_string& uri, + xml_schema::flags = 0, + const xml_schema::properties& = xml_schema::properties \201\202\202; + +std::[unique|auto]_ptr +name \201const std::basic_string& uri, + xml_schema::error_handler&, + xml_schema::flags = 0, + const xml_schema::properties& = xml_schema::properties \201\202\202; + +std::[unique|auto]_ptr +name \201const std::basic_string& uri, + xercesc::DOMErrorHandler&, + xml_schema::flags = 0, + const xml_schema::properties& = xml_schema::properties \201\202\202; + + +// Read from std::istream. +// + +std::[unique|auto]_ptr +name \201std::istream&, + xml_schema::flags = 0, + const xml_schema::properties& = xml_schema::properties \201\202\202; + +std::[unique|auto]_ptr +name \201std::istream&,)WR( + xml_schema::error_handler&, + xml_schema::flags = 0, + const xml_schema::properties& = xml_schema::properties \201\202\202; + +std::[unique|auto]_ptr +name \201std::istream&, + xercesc::DOMErrorHandler&, + xml_schema::flags = 0, + const xml_schema::properties& = xml_schema::properties \201\202\202; + + +std::[unique|auto]_ptr +name \201std::istream&, + const std::basic_string& id, + xml_schema::flags = 0, + const xml_schema::properties& = xml_schema::properties \201\202\202; + +std::[unique|auto]_ptr +name \201std::istream&, + const std::basic_string& id, + xml_schema::error_handler&, + xml_schema::flags = 0, + const xml_schema::properties& = xml_schema::properties \201\202\202; + +std::[unique|auto]_ptr +name \201std::istream&, + const std::basic_string& id, + xercesc::DOMErrorHandler&, + xml_schema::flags = 0, + const xml_schema::properties& = xml_schema::properties \201\202\202;)WR( + + +// Read from InputSource. +// + +std::[unique|auto]_ptr +name \201xercesc::InputSource&, + xml_schema::flags = 0, + const xml_schema::properties& = xml_schema::properties \201\202\202; + +std::[unique|auto]_ptr +name \201xercesc::InputSource&, + xml_schema::error_handler&, + xml_schema::flags = 0, + const xml_schema::properties& = xml_schema::properties \201\202\202; + +std::[unique|auto]_ptr +name \201xercesc::InputSource&, + xercesc::DOMErrorHandler&, + xml_schema::flags = 0, + const xml_schema::properties& = xml_schema::properties \201\202\202; + + +// Read from DOM. +// + +std::[unique|auto]_ptr +name \201const xercesc::DOMDocument&, + xml_schema::flags = 0, + const xml_schema::properties& = xml_schema::properties \201\202\202;)WR( + +std::[unique|auto]_ptr +name \201xml_schema::dom::[unique|auto]_ptr, + xml_schema::flags = 0, + const xml_schema::properties& = xml_schema::properties \201\202\202;)RP( + + )0 P(You can choose between reading an XML instance from a local file, + URI, )SM(std::istream)ES(, )SM(xercesc::Input)HY(Source)YH()ES(, + or a pre-parsed DOM instance in the form of + )SM(xercesc::DOMDoc)HY(u)HY(ment)YH()ES(. All the parsing func)HY(tions)YH( + return a dynam)HY(i)HY(cally)YH( allo)HY(cated)YH( object model as either + )SM(std::unique_ptr)ES( or )SM(std::auto_ptr)ES(, + depend)HY(ing)YH( on the C++ stan)HY(dard)YH( selected. Each of these parsing + func)HY(tions)YH( is discussed in more detail in the follow)HY(ing)YH( sections. + )EP( + + )0 2 61 H(3.1)WB 206 Sn()WB 65 Sn( Initial)HY(iz)HY(ing)YH( the Xerces-C++ Runtime)EA()EH( + + )0 P(Some parsing func)HY(tions)YH( expect you to initial)HY(ize)YH( the Xerces-C++ + runtime while others initial)HY(ize)YH( and termi)HY(nate)YH( it as part of their + work. The general rule is as follows: if a func)HY(tion)YH( has any argu)HY(ments)YH( + or return a value that is an instance of a Xerces-C++ type, then + this func)HY(tion)YH( expects you to initial)HY(ize)YH( the Xerces-C++ runtime. + Other)HY(wise)YH(, the func)HY(tion)YH( initial)HY(izes)YH( and termi)HY(nates)YH( the runtime for + you. Note that it is legal to have nested calls to the Xerces-C++ + initial)HY(ize)YH( and termi)HY(nate)YH( func)HY(tions)YH( as long as the calls are balanced. + )EP( + + )0 P(You can instruct parsing func)HY(tions)YH( that initial)HY(ize)YH( and termi)HY(nate)YH( + the runtime not to do so by passing the + )SM(xml_schema::flags::dont_initial)HY(ize)YH()ES( flag \201see + )0 138 1 A(Section 3.2, "Flags and Prop)HY(er)HY(ties)YH(")138 0 TN TL()Ec /AF f D(\202. + )EP( + + + )0 2 62 H(3.2)WB 207 Sn()WB 66 Sn( Flags and Prop)HY(er)HY(ties)YH()EA()EH( + + )0 P(Parsing flags and prop)HY(er)HY(ties)YH( are the last two argu)HY(ments)YH( of every + parsing func)HY(tion)YH(. They allow you to fine-tune the process of + instance vali)HY(da)HY(tion)YH( and parsing. Both argu)HY(ments)YH( are optional. + )EP( + + + )0 P(The follow)HY(ing)YH( flags are recog)HY(nized)YH( by the parsing func)HY(tions)YH(:)EP( + + )0 DL( )0 DT()SM(xml_schema::flags::keep_dom)ES( + )DD(Keep asso)HY(ci)HY(a)HY(tion)YH( between DOM nodes and the result)HY(ing)YH( + object model nodes. For more infor)HY(ma)HY(tion)YH( about DOM asso)HY(ci)HY(a)HY(tion)YH( + refer to )0 126 1 A(Section 5.1, "DOM Asso)HY(ci)HY(a)HY(tion)YH(")126 0 TN TL()Ec /AF f D(. + + )0 DT()SM(xml_schema::flags::own_dom)ES( + )DD(Assume owner)HY(ship)YH( of the DOM docu)HY(ment)YH( passed. This flag only + makes sense together with the )SM(keep_dom)ES( flag in + the call to the parsing func)HY(tion)YH( with the + )SM(xml_schema::dom::[unique|auto]_ptr)ES( + argu)HY(ment)YH(. + + )0 DT()SM(xml_schema::flags::dont_vali)HY(date)YH()ES( + )DD(Do not vali)HY(date)YH( instance docu)HY(ments)YH( against schemas. + + )0 DT()SM(xml_schema::flags::dont_initial)HY(ize)YH()ES( + )DD(Do not initial)HY(ize)YH( the Xerces-C++ runtime. + )LD( + + )0 P(You can pass several flags by combin)HY(ing)YH( them using the bit-wise OR + oper)HY(a)HY(tor)YH(. For example:)EP( + + ) 4 61 PR(using xml_schema::flags; + +std::unique_ptr r \201 + name \201"test.xml", flags::keep_dom | flags::dont_validate\202\202;)RP( + + )0 P(By default, vali)HY(da)HY(tion)YH( of instance docu)HY(ments)YH( is turned on even + though parsers gener)HY(ated)YH( by XSD do not assume instance + docu)HY(ments)YH( are valid. They include a number of checks that prevent + construc)HY(tion)YH( of incon)HY(sis)HY(tent)YH( object models. This, + however, does not mean that an instance docu)HY(ment)YH( that was + success)HY(fully)YH( parsed by the XSD-gener)HY(ated)YH( parsers is + valid per the corre)HY(spond)HY(ing)YH( schema. If an instance docu)HY(ment)YH( is not + "valid enough" for the gener)HY(ated)YH( parsers to construct consis)HY(tent)YH( + object model, one of the excep)HY(tions)YH( defined in + )SM(xml_schema)ES( names)HY(pace)YH( is thrown \201see + )0 105 1 A(Section 3.3, "Error Handling")105 0 TN TL()Ec /AF f D(\202. + )EP( + + )0 P(For more infor)HY(ma)HY(tion)YH( on the Xerces-C++ runtime initial)HY(iza)HY(tion)YH( + refer to )0 124 1 A(Section 3.1, "Initial)HY(iz)HY(ing)YH( the Xerces-C++ + Runtime")124 0 TN TL()Ec /AF f D(. + )EP( + + )0 P(The )SM(xml_schema::prop)HY(er)HY(ties)YH()ES( class allows you to + program)HY(mat)HY(i)HY(cally)YH( specify schema loca)HY(tions)YH( to be used instead + of those spec)HY(i)HY(fied)YH( with the )SM(xsi::schemaLo)HY(ca)HY(tion)YH()ES( + and )SM(xsi::noNames)HY(paceSchemaLo)HY(ca)HY(tion)YH()ES( attributes + in instance docu)HY(ments)YH(. The inter)HY(face)YH( of the )SM(prop)HY(er)HY(ties)YH()ES( + class is presented below: + )EP( + + ) 9 70 PR(class properties +{ +public: + void + schema_location \201const std::basic_string& namespace_, + const std::basic_string& location\202; + void + no_namespace_schema_location \201const std::basic_string& location\202; +};)RP( + + )0 P(Note that all loca)HY(tions)YH( are rela)HY(tive)YH( to an instance docu)HY(ment)YH( unless + they are URIs. For example, if you want to use a local file as your + schema, then you will need to pass + )SM(file:///abso)HY(lute)YH(/path/to/your/schema)ES( as the loca)HY(tion)YH( + argu)HY(ment)YH(. + )EP( + + )0 2 63 H(3.3)WB 208 Sn()WB 67 Sn( Error Handling)EA()EH( + + )0 P(As discussed in )0 139 1 A(Section 2.2, "Error Handling")139 0 TN TL()Ec /AF f D(, + the mapping uses the C++ excep)HY(tion)YH( handling mech)HY(a)HY(nism)YH( as its primary + way of report)HY(ing)YH( error condi)HY(tions)YH(. However, to handle recov)HY(er)HY(able)YH( + parsing and vali)HY(da)HY(tion)YH( errors and warn)HY(ings)YH(, a call)HY(back)YH( inter)HY(face)YH( maybe + preferred by the appli)HY(ca)HY(tion)YH(.)EP( + + )0 P(To better under)HY(stand)YH( error handling and report)HY(ing)YH( strate)HY(gies)YH( employed + by the parsing func)HY(tions)YH(, it is useful to know that the + trans)HY(for)HY(ma)HY(tion)YH( of an XML instance docu)HY(ment)YH( to a stat)HY(i)HY(cally)YH(-typed + tree happens in two stages. The first stage, performed by Xerces-C++, + consists of parsing an XML docu)HY(ment)YH( into a DOM instance. For short, + we will call this stage the XML-DOM stage. Vali)HY(da)HY(tion)YH(, if not disabled, + happens during this stage. The second stage, + performed by the gener)HY(ated)YH( parsers, consist of parsing the DOM + instance into the stat)HY(i)HY(cally)YH(-typed tree. We will call this stage + the DOM-Tree stage. Addi)HY(tional)YH( checks are performed during this + stage in order to prevent construc)HY(tion)YH( of incon)HY(sis)HY(tent)YH( tree which + could other)HY(wise)YH( happen when vali)HY(da)HY(tion)YH( is disabled, for example.)EP( + + )0 P(All parsing func)HY(tions)YH( except the one that oper)HY(ates)YH( on a DOM instance + come in over)HY(loaded)YH( triples. The first func)HY(tion)YH( in such a triple + reports error condi)HY(tions)YH( exclu)HY(sively)YH( by throw)HY(ing)YH( excep)HY(tions)YH(. It + accu)HY(mu)HY(lates)YH( all the parsing and vali)HY(da)HY(tion)YH( errors of the XML-DOM + stage and throws them in a single instance of the + )SM(xml_schema::parsing)ES( excep)HY(tion)YH( \201described below\202. + The second and the third func)HY(tions)YH( in the triple use call)HY(back)YH( + inter)HY(faces)YH( to report parsing and vali)HY(da)HY(tion)YH( errors and warn)HY(ings)YH(. + The two call)HY(back)YH( inter)HY(faces)YH( are )SM(xml_schema::error_handler)ES( + and )SM(xercesc::DOMEr)HY(rorHan)HY(dler)YH()ES(. For more infor)HY(ma)HY(tion)YH( + on the )SM(xercesc::DOMEr)HY(rorHan)HY(dler)YH()ES( inter)HY(face)YH( refer to + the Xerces-C++ docu)HY(men)HY(ta)HY(tion)YH(. The )SM(xml_schema::error_handler)ES( + inter)HY(face)YH( is presented below: + )EP( + + ) 23 51 PR(class error_handler +{ +public: + struct severity + { + enum value + { + warning, + error, + fatal + }; + }; + + virtual bool + handle \201const std::basic_string& id, + unsigned long line, + unsigned long column, + severity, + const std::basic_string& message\202 = 0; + + virtual + ~error_handler \201\202; +};)RP( + + )0 P(The )SM(id)ES( argu)HY(ment)YH( of the )SM(error_handler::handle)ES( + func)HY(tion)YH( iden)HY(ti)HY(fies)YH( the resource being parsed \201e.g., a file name or + URI\202. + )EP( + + )0 P(By return)HY(ing)YH( )SM(true)ES( from the )SM(handle)ES( func)HY(tion)YH( + you instruct the parser to recover and continue parsing. Return)HY(ing)YH( + )SM(false)ES( results in termi)HY(na)HY(tion)YH( of the parsing process. + An error with the )SM(fatal)ES( sever)HY(ity)YH( level results in + termi)HY(na)HY(tion)YH( of the parsing process no matter what is returned from + the )SM(handle)ES( func)HY(tion)YH(. It is safe to throw an excep)HY(tion)YH( + from the )SM(handle)ES( func)HY(tion)YH(. + )EP( + + )0 P(The DOM-Tree stage reports error condi)HY(tions)YH( exclu)HY(sively)YH( by throw)HY(ing)YH( + excep)HY(tions)YH(. Indi)HY(vid)HY(ual)YH( excep)HY(tions)YH( thrown by the parsing func)HY(tions)YH( + are described in the follow)HY(ing)YH( sub-sections. + )EP( + + + )0 3 64 H(3.3.1)WB 209 Sn()WB 68 Sn( )SM(xml_schema::parsing)ES()EA()EH( + + ) 57 56 PR(struct severity +{ + enum value + { + warning, + error + }; + + severity \201value\202; + operator value \201\202 const; +}; + +struct error +{ + error \201severity, + const std::basic_string& id, + unsigned long line, + unsigned long column, + const std::basic_string& message\202; + + severity + severity \201\202 const; + + const std::basic_string& + id \201\202 const; + + unsigned long + line \201\202 const; + + unsigned long + column \201\202 const;)WR( + + const std::basic_string& + message \201\202 const; +}; + +std::basic_ostream& +operator<< \201std::basic_ostream&, const error&\202; + +struct diagnostics: std::vector +{ +}; + +std::basic_ostream& +operator<< \201std::basic_ostream&, const diagnostics&\202; + +struct parsing: virtual exception +{ + parsing \201\202; + parsing \201const diagnostics&\202; + + const diagnostics& + diagnostics \201\202 const; + + virtual const char* + what \201\202 const throw \201\202; +};)RP( + + )0 P(The )SM(xml_schema::parsing)ES( excep)HY(tion)YH( is thrown if there + were parsing or vali)HY(da)HY(tion)YH( errors reported during the XML-DOM stage. + If no call)HY(back)YH( inter)HY(face)YH( was provided to the parsing func)HY(tion)YH(, the + excep)HY(tion)YH( contains a list of errors and warn)HY(ings)YH( acces)HY(si)HY(ble)YH( using + the )SM(diag)HY(nos)HY(tics)YH()ES( func)HY(tion)YH(. The usual condi)HY(tions)YH( when + this excep)HY(tion)YH( is thrown include malformed XML instances and, if + vali)HY(da)HY(tion)YH( is turned on, invalid instance docu)HY(ments)YH(. + )EP( + + )0 3 65 H(3.3.2)WB 210 Sn()WB 69 Sn( )SM(xml_schema::expected_element)ES()EA()EH( + + ) 16 60 PR(struct expected_element: virtual exception +{ + expected_element \201const std::basic_string& name, + const std::basic_string& namespace_\202; + + + const std::basic_string& + name \201\202 const; + + const std::basic_string& + namespace_ \201\202 const; + + + virtual const char* + what \201\202 const throw \201\202; +};)RP( + + )0 P(The )SM(xml_schema::expected_element)ES( excep)HY(tion)YH( is thrown + when an expected element is not encoun)HY(tered)YH( by the DOM-Tree stage. + The name and names)HY(pace)YH( of the expected element can be obtained using + the )SM(name)ES( and )SM(names)HY(pace)YH(_)ES( func)HY(tions)YH( respec)HY(tively)YH(. + )EP( + + + )0 3 66 H(3.3.3)WB 211 Sn()WB 70 Sn( )SM(xml_schema::unex)HY(pected)YH(_element)ES()EA()EH( + + ) 25 72 PR(struct unexpected_element: virtual exception +{ + unexpected_element \201const std::basic_string& encountered_name, + const std::basic_string& encountered_namespace, + const std::basic_string& expected_name, + const std::basic_string& expected_namespace\202 + + + const std::basic_string& + encountered_name \201\202 const; + + const std::basic_string& + encountered_namespace \201\202 const; + + + const std::basic_string& + expected_name \201\202 const; + + const std::basic_string& + expected_namespace \201\202 const; + + + virtual const char* + what \201\202 const throw \201\202; +};)RP( + + )0 P(The )SM(xml_schema::unex)HY(pected)YH(_element)ES( excep)HY(tion)YH( is thrown + when an unex)HY(pected)YH( element is encoun)HY(tered)YH( by the DOM-Tree stage. + The name and names)HY(pace)YH( of the encoun)HY(tered)YH( element can be obtained + using the )SM(encoun)HY(tered)YH(_name)ES( and + )SM(encoun)HY(tered)YH(_names)HY(pace)YH()ES( func)HY(tions)YH( respec)HY(tively)YH(. If an + element was expected instead of the encoun)HY(tered)YH( one, its name + and names)HY(pace)YH( can be obtained using the )SM(expected_name)ES( and + )SM(expected_names)HY(pace)YH()ES( func)HY(tions)YH( respec)HY(tively)YH(. Other)HY(wise)YH( + these func)HY(tions)YH( return empty strings. + )EP( + + )0 3 67 H(3.3.4)WB 212 Sn()WB 71 Sn( )SM(xml_schema::expected_attribute)ES()EA()EH( + + ) 16 62 PR(struct expected_attribute: virtual exception +{ + expected_attribute \201const std::basic_string& name, + const std::basic_string& namespace_\202; + + + const std::basic_string& + name \201\202 const; + + const std::basic_string& + namespace_ \201\202 const; + + + virtual const char* + what \201\202 const throw \201\202; +};)RP( + + )0 P(The )SM(xml_schema::expected_attribute)ES( excep)HY(tion)YH( is thrown + when an expected attribute is not encoun)HY(tered)YH( by the DOM-Tree stage. + The name and names)HY(pace)YH( of the expected attribute can be obtained using + the )SM(name)ES( and )SM(names)HY(pace)YH(_)ES( func)HY(tions)YH( respec)HY(tively)YH(. + )EP( + + + )0 3 68 H(3.3.5)WB 213 Sn()WB 72 Sn( )SM(xml_schema::unex)HY(pected)YH(_enumer)HY(a)HY(tor)YH()ES()EA()EH( + + ) 10 65 PR(struct unexpected_enumerator: virtual exception +{ + unexpected_enumerator \201const std::basic_string& enumerator\202; + + const std::basic_string& + enumerator \201\202 const; + + virtual const char* + what \201\202 const throw \201\202; +};)RP( + + )0 P(The )SM(xml_schema::unex)HY(pected)YH(_enumer)HY(a)HY(tor)YH()ES( excep)HY(tion)YH( is thrown + when an unex)HY(pected)YH( enumer)HY(a)HY(tor)YH( is encoun)HY(tered)YH( by the DOM-Tree stage. + The enumer)HY(a)HY(tor)YH( can be obtained using the )SM(enumer)HY(a)HY(tor)YH()ES( + func)HY(tions)YH(. + )EP( + + )0 3 69 H(3.3.6)WB 214 Sn()WB 73 Sn( )SM(xml_schema::expected_text_content)ES()EA()EH( + + ) 5 47 PR(struct expected_text_content: virtual exception +{ + virtual const char* + what \201\202 const throw \201\202; +};)RP( + + )0 P(The )SM(xml_schema::expected_text_content)ES( excep)HY(tion)YH( is thrown + when a content other than text is encoun)HY(tered)YH( and the text content was + expected by the DOM-Tree stage. + )EP( + + )0 3 70 H(3.3.7)WB 215 Sn()WB 74 Sn( )SM(xml_schema::no_type_info)ES()EA()EH( + + ) 14 60 PR(struct no_type_info: virtual exception +{ + no_type_info \201const std::basic_string& type_name, + const std::basic_string& type_namespace\202; + + const std::basic_string& + type_name \201\202 const; + + const std::basic_string& + type_namespace \201\202 const; + + virtual const char* + what \201\202 const throw \201\202; +};)RP( + + )0 P(The )SM(xml_schema::no_type_info)ES( excep)HY(tion)YH( is thrown + when there is no type infor)HY(ma)HY(tion)YH( asso)HY(ci)HY(ated)YH( with a type spec)HY(i)HY(fied)YH( + by the )SM(xsi:type)ES( attribute. This excep)HY(tion)YH( is thrown + by the DOM-Tree stage. The name and names)HY(pace)YH( of the type in ques)HY(tion)YH( + can be obtained using the )SM(type_name)ES( and + )SM(type_names)HY(pace)YH()ES( func)HY(tions)YH( respec)HY(tively)YH(. Usually, catch)HY(ing)YH( + this excep)HY(tion)YH( means that you haven't linked the code gener)HY(ated)YH( + from the schema defin)HY(ing)YH( the type in ques)HY(tion)YH( with your appli)HY(ca)HY(tion)YH( + or this schema has been compiled without the + )SM(--gener)HY(ate)YH(-poly)HY(mor)HY(phic)YH()ES( option. + )EP( + + + )0 3 71 H(3.3.8)WB 216 Sn()WB 75 Sn( )SM(xml_schema::not_derived)ES()EA()EH( + + ) 23 67 PR(struct not_derived: virtual exception +{ + not_derived \201const std::basic_string& base_type_name, + const std::basic_string& base_type_namespace, + const std::basic_string& derived_type_name, + const std::basic_string& derived_type_namespace\202; + + const std::basic_string& + base_type_name \201\202 const; + + const std::basic_string& + base_type_namespace \201\202 const; + + + const std::basic_string& + derived_type_name \201\202 const; + + const std::basic_string& + derived_type_namespace \201\202 const; + + virtual const char* + what \201\202 const throw \201\202; +};)RP( + + )0 P(The )SM(xml_schema::not_derived)ES( excep)HY(tion)YH( is thrown + when a type spec)HY(i)HY(fied)YH( by the )SM(xsi:type)ES( attribute is + not derived from the expected base type. This excep)HY(tion)YH( is thrown + by the DOM-Tree stage. The name and names)HY(pace)YH( of the expected + base type can be obtained using the )SM(base_type_name)ES( and + )SM(base_type_names)HY(pace)YH()ES( func)HY(tions)YH( respec)HY(tively)YH(. The name + and names)HY(pace)YH( of the offend)HY(ing)YH( type can be obtained using the + )SM(derived_type_name)ES( and + )SM(derived_type_names)HY(pace)YH()ES( func)HY(tions)YH( respec)HY(tively)YH(. + )EP( + + )0 3 72 H(3.3.9)WB 217 Sn()WB 76 Sn( )SM(xml_schema::no_prefix_mapping)ES()EA()EH( + + ) 10 57 PR(struct no_prefix_mapping: virtual exception +{ + no_prefix_mapping \201const std::basic_string& prefix\202; + + const std::basic_string& + prefix \201\202 const; + + virtual const char* + what \201\202 const throw \201\202; +};)RP( + + )0 P(The )SM(xml_schema::no_prefix_mapping)ES( excep)HY(tion)YH( is thrown + during the DOM-Tree stage if a names)HY(pace)YH( prefix is encoun)HY(tered)YH( for + which a prefix-names)HY(pace)YH( mapping hasn't been provided. The names)HY(pace)YH( + prefix in ques)HY(tion)YH( can be obtained using the )SM(prefix)ES( + func)HY(tion)YH(. + )EP( + + )0 2 73 H(3.4)WB 218 Sn()WB 77 Sn( Reading from a Local File or URI)EA()EH( + + )0 P(Using a local file or URI is the simplest way to parse an XML instance. + For example:)EP( + + ) 4 70 PR(using std::unique_ptr; + +unique_ptr r1 \201name \201"test.xml"\202\202; +unique_ptr r2 \201name \201"https://www.codesynthesis.com/test.xml"\202\202;)RP( + + )0 P(Or, in the C++98 mode:)EP( + + ) 4 68 PR(using std::auto_ptr; + +auto_ptr r1 \201name \201"test.xml"\202\202; +auto_ptr r2 \201name \201"https://www.codesynthesis.com/test.xml"\202\202;)RP( + + )0 2 74 H(3.5)WB 219 Sn()WB 78 Sn( Reading from )SM(std::istream)ES()EA()EH( + + )0 P(When using an )SM(std::istream)ES( instance, you may also + pass an optional resource id. This id is used to iden)HY(tify)YH( the + resource \201for example in error messages\202 as well as to resolve + rela)HY(tive)YH( paths. For instance:)EP( + + ) 12 48 PR(using std::unique_ptr; + +{ + std::ifstream ifs \201"test.xml"\202; + unique_ptr r \201name \201ifs, "test.xml"\202\202; +} + +{ + std::string str \201"..."\202; // Some XML fragment. + std::istringstream iss \201str\202; + unique_ptr r \201name \201iss\202\202; +})RP( + + )0 2 75 H(3.6)WB 220 Sn()WB 79 Sn( Reading from )SM(xercesc::Input)HY(Source)YH()ES()EA()EH( + + )0 P(Reading from a )SM(xercesc::Input)HY(Source)YH()ES( instance + is similar to the )SM(std::istream)ES( case except + the resource id is main)HY(tained)YH( by the )SM(Input)HY(Source)YH()ES( + object. For instance:)EP( + + ) 2 36 PR(xercesc::StdInInputSource is; +std::unique_ptr r \201name \201is\202\202;)RP( + + )0 2 76 H(3.7)WB 221 Sn()WB 80 Sn( Reading from DOM)EA()EH( + + )0 P(Reading from a )SM(xercesc::DOMDoc)HY(u)HY(ment)YH()ES( instance allows + you to setup a custom XML-DOM stage. Things like DOM + parser reuse, schema pre-parsing, and schema caching can be achieved + with this approach. For more infor)HY(ma)HY(tion)YH( on how to obtain DOM + repre)HY(sen)HY(ta)HY(tion)YH( from an XML instance refer to the Xerces-C++ + docu)HY(men)HY(ta)HY(tion)YH(. In addi)HY(tion)YH(, the + )R4 2 A(C++/Tree Mapping + FAQ)EA( shows how to parse an XML instance to a Xerces-C++ + DOM docu)HY(ment)YH( using the XSD runtime util)HY(i)HY(ties)YH(. + )EP( + + )0 P(The last parsing func)HY(tion)YH( is useful when you would like to perform + your own XML-to-DOM parsing and as)HY(so)HY(ciate)YH( the result)HY(ing)YH( DOM docu)HY(ment)YH( + with the object model nodes. The auto)HY(matic)YH( )SM(DOMDoc)HY(u)HY(ment)YH()ES( + pointer is reset and the result)HY(ing)YH( object model assumes owner)HY(ship)YH( + of the DOM docu)HY(ment)YH( passed. For example:)EP( + + ) 18 72 PR(// C++11 version. +// +xml_schema::dom::unique_ptr doc = ... + +std::unique_ptr r \201 + name \201std::move \201doc\202, + xml_schema::flags::keep_dom | xml_schema::flags::own_dom\202\202; + +// At this point doc is reset to 0. + +// C++98 version. +// +xml_schema::dom::auto_ptr doc = ... + +std::auto_ptr r \201 + name \201doc, xml_schema::flags::keep_dom | xml_schema::flags::own_dom\202\202; + +// At this point doc is reset to 0.)RP( + + )0 1 77 H(4)WB 222 Sn()WB 81 Sn( Seri)HY(al)HY(iza)HY(tion)YH()EA()EH( + + )0 P(This chapter covers various aspects of seri)HY(al)HY(iz)HY(ing)YH( a + tree-like object model to DOM or XML. + In this regard, seri)HY(al)HY(iza)HY(tion)YH( is compli)HY(men)HY(tary)YH( to the reverse + process of parsing a DOM or XML instance into an object model + which is discussed in )0 98 1 A(Chapter 3, + "Parsing")98 0 TN TL()Ec /AF f D(. Note that the gener)HY(a)HY(tion)YH( of the seri)HY(al)HY(iza)HY(tion)YH( code + is optional and should be explic)HY(itly)YH( requested with the + )SM(--gener)HY(ate)YH(-seri)HY(al)HY(iza)HY(tion)YH()ES( option. See the + )R5 2 A(XSD + Compiler Command Line Manual)EA( for more infor)HY(ma)HY(tion)YH(. + )EP( + + )0 P(Each global XML Schema element in the form: + )EP( + + + ) 1 38 PR()RP( + + )0 P(is mapped to 8 over)HY(loaded)YH( C++ func)HY(tions)YH( in the form:)EP( + + ) 70 56 PR(// Serialize to std::ostream. +// +void +name \201std::ostream&, + const type&, + const xml_schema::namespace_fomap& = + xml_schema::namespace_infomap \201\202, + const std::basic_string& encoding = "UTF-8", + xml_schema::flags = 0\202; + +void +name \201std::ostream&, + const type&, + xml_schema::error_handler&, + const xml_schema::namespace_infomap& = + xml_schema::namespace_infomap \201\202, + const std::basic_string& encoding = "UTF-8", + xml_schema::flags = 0\202; + +void +name \201std::ostream&, + const type&, + xercesc::DOMErrorHandler&, + const xml_schema::namespace_infomap& = + xml_schema::namespace_infomap \201\202, + const std::basic_string& encoding = "UTF-8", + xml_schema::flags = 0\202; + + +// Serialize to XMLFormatTarget. +//)WR( +void +name \201xercesc::XMLFormatTarget&, + const type&, + const xml_schema::namespace_infomap& = + xml_schema::namespace_infomap \201\202, + const std::basic_string& encoding = "UTF-8", + xml_schema::flags = 0\202; + +void +name \201xercesc::XMLFormatTarget&, + const type&, + xml_schema::error_handler&, + const xml_schema::namespace_infomap& = + xml_schema::namespace_infomap \201\202, + const std::basic_string& encoding = "UTF-8", + xml_schema::flags = 0\202; + +void +name \201xercesc::XMLFormatTarget&, + const type&, + xercesc::DOMErrorHandler&, + const xml_schema::namespace_infomap& = + xml_schema::namespace_infomap \201\202, + const std::basic_string& encoding = "UTF-8", + xml_schema::flags = 0\202; + + +// Serialize to DOM. +// +xml_schema::dom::[unique|auto]_ptr)WR( +name \201const type&, + const xml_schema::namespace_infomap& + xml_schema::namespace_infomap \201\202, + xml_schema::flags = 0\202; + +void +name \201xercesc::DOMDocument&, + const type&, + xml_schema::flags = 0\202;)RP( + + )0 P(You can choose between writing XML to )SM(std::ostream)ES( or + )SM(xercesc::XMLFor)HY(mat)HY(Tar)HY(get)YH()ES( and creat)HY(ing)YH( a DOM instance + in the form of )SM(xercesc::DOMDoc)HY(u)HY(ment)YH()ES(. Seri)HY(al)HY(iza)HY(tion)YH( + to )SM(ostream)ES( or )SM(XMLFor)HY(mat)HY(Tar)HY(get)YH()ES( requires a + consid)HY(er)HY(ably)YH( less work while seri)HY(al)HY(iza)HY(tion)YH( to DOM provides + for greater flex)HY(i)HY(bil)HY(ity)YH(. Each of these seri)HY(al)HY(iza)HY(tion)YH( func)HY(tions)YH( + is discussed in more detail in the follow)HY(ing)YH( sections. + )EP( + + + )0 2 78 H(4.1)WB 223 Sn()WB 82 Sn( Initial)HY(iz)HY(ing)YH( the Xerces-C++ Runtime)EA()EH( + + )0 P(Some seri)HY(al)HY(iza)HY(tion)YH( func)HY(tions)YH( expect you to initial)HY(ize)YH( the Xerces-C++ + runtime while others initial)HY(ize)YH( and termi)HY(nate)YH( it as part of their + work. The general rule is as follows: if a func)HY(tion)YH( has any argu)HY(ments)YH( + or return a value that is an instance of a Xerces-C++ type, then + this func)HY(tion)YH( expects you to initial)HY(ize)YH( the Xerces-C++ runtime. + Other)HY(wise)YH(, the func)HY(tion)YH( initial)HY(izes)YH( and termi)HY(nates)YH( the runtime for + you. Note that it is legal to have nested calls to the Xerces-C++ + initial)HY(ize)YH( and termi)HY(nate)YH( func)HY(tions)YH( as long as the calls are balanced. + )EP( + + )0 P(You can instruct seri)HY(al)HY(iza)HY(tion)YH( func)HY(tions)YH( that initial)HY(ize)YH( and termi)HY(nate)YH( + the runtime not to do so by passing the + )SM(xml_schema::flags::dont_initial)HY(ize)YH()ES( flag \201see + )0 140 1 A(Section 4.3, "Flags")140 0 TN TL()Ec /AF f D(\202. + )EP( + + )0 2 79 H(4.2)WB 224 Sn()WB 83 Sn( Names)HY(pace)YH( Infomap and Char)HY(ac)HY(ter)YH( Encod)HY(ing)YH()EA()EH( + + )0 P(When a docu)HY(ment)YH( being seri)HY(al)HY(ized)YH( uses XML names)HY(paces)YH(, custom + prefix-names)HY(pace)YH( asso)HY(ci)HY(a)HY(tions)YH( can to be estab)HY(lished)YH(. If custom + prefix-names)HY(pace)YH( mapping is not provided then generic prefixes + \201)SM(p1)ES(, )SM(p2)ES(, etc\202 are auto)HY(mat)HY(i)HY(cally)YH( assigned + to names)HY(paces)YH( as needed. Also, if + you would like the result)HY(ing)YH( instance docu)HY(ment)YH( to contain the + )SM(schemaLo)HY(ca)HY(tion)YH()ES( or )SM(noNames)HY(paceSchemaLo)HY(ca)HY(tion)YH()ES( + attributes, you will need to provide names)HY(pace)YH(-schema asso)HY(ci)HY(a)HY(tions)YH(. + The )SM(xml_schema::names)HY(pace)YH(_infomap)ES( class is used + to capture this infor)HY(ma)HY(tion)YH(:)EP( + + ) 16 63 PR(struct namespace_info +{ + namespace_info \201\202; + namespace_info \201const std::basic_string& name, + const std::basic_string& schema\202; + + std::basic_string name; + std::basic_string schema; +}; + +// Map of namespace prefix to namespace_info. +// +struct namespace_infomap: public std::map, + namespace_info> +{ +};)RP( + + )0 P(Consider the follow)HY(ing)YH( asso)HY(ci)HY(a)HY(tions)YH( as an example:)EP( + + ) 4 53 PR(xml_schema::namespace_infomap map; + +map["t"].name = "https://www.codesynthesis.com/test"; +map["t"].schema = "test.xsd";)RP( + + )0 P(This map, if passed to one of the seri)HY(al)HY(iza)HY(tion)YH( func)HY(tions)YH(, + could result in the follow)HY(ing)YH( XML frag)HY(ment)YH(:)EP( + + ) 4 73 PR( +)RP( + + )0 P(As you can see, the seri)HY(al)HY(iza)HY(tion)YH( func)HY(tion)YH( auto)HY(mat)HY(i)HY(cally)YH( added names)HY(pace)YH( + mapping for the )SM(xsi)ES( prefix. You can change this by + provid)HY(ing)YH( your own prefix:)EP( + + ) 6 62 PR(xml_schema::namespace_infomap map; + +map["xsn"].name = "http://www.w3.org/2001/XMLSchema-instance"; + +map["t"].name = "https://www.codesynthesis.com/test"; +map["t"].schema = "test.xsd";)RP( + + )0 P(This could result in the follow)HY(ing)YH( XML frag)HY(ment)YH(:)EP( + + ) 4 73 PR( +)RP( + + )0 P(To specify the loca)HY(tion)YH( of a schema without a names)HY(pace)YH( you can use + an empty prefix as in the example below: )EP( + + ) 3 34 PR(xml_schema::namespace_infomap map; + +map[""].schema = "test.xsd";)RP( + + )0 P(This would result in the follow)HY(ing)YH( XML frag)HY(ment)YH(:)EP( + + ) 3 59 PR( +)RP( + + )0 P(To make a partic)HY(u)HY(lar)YH( names)HY(pace)YH( default you can use an empty + prefix, for example:)EP( + + ) 4 52 PR(xml_schema::namespace_infomap map; + +map[""].name = "https://www.codesynthesis.com/test"; +map[""].schema = "test.xsd";)RP( + + )0 P(This could result in the follow)HY(ing)YH( XML frag)HY(ment)YH(:)EP( + + ) 4 71 PR( +)RP( + + + )0 P(Another bit of infor)HY(ma)HY(tion)YH( that you can pass to the seri)HY(al)HY(iza)HY(tion)YH( + func)HY(tions)YH( is the char)HY(ac)HY(ter)YH( encod)HY(ing)YH( method that you would like to use. + Common values for this argu)HY(ment)YH( are )SM("US-ASCII")ES(, + )SM("ISO8859-1")ES(, )SM("UTF-8")ES(, + )SM("UTF-16BE")ES(, )SM("UTF-16LE")ES(, + )SM("UCS-4BE")ES(, and )SM("UCS-4LE")ES(. The default + encod)HY(ing)YH( is )SM("UTF-8")ES(. For more infor)HY(ma)HY(tion)YH( on + encod)HY(ing)YH( methods see the + ")R9 2 A(Char)HY(ac)HY(ter)YH( + Encod)HY(ing)YH()EA(" article from Wikipedia. + )EP( + + )0 2 80 H(4.3)WB 225 Sn()WB 84 Sn( Flags)EA()EH( + + )0 P(Seri)HY(al)HY(iza)HY(tion)YH( flags are the last argu)HY(ment)YH( of every seri)HY(al)HY(iza)HY(tion)YH( + func)HY(tion)YH(. They allow you to fine-tune the process of seri)HY(al)HY(iza)HY(tion)YH(. + The flags argu)HY(ment)YH( is optional. + )EP( + + + )0 P(The follow)HY(ing)YH( flags are recog)HY(nized)YH( by the seri)HY(al)HY(iza)HY(tion)YH( + func)HY(tions)YH(:)EP( + + )0 DL( )0 DT()SM(xml_schema::flags::dont_initial)HY(ize)YH()ES( + )DD(Do not initial)HY(ize)YH( the Xerces-C++ runtime. + + )0 DT()SM(xml_schema::flags::dont_pretty_print)ES( + )DD(Do not add extra spaces or new lines that make the result)HY(ing)YH( XML + slightly bigger but easier to read. + + )0 DT()SM(xml_schema::flags::no_xml_decla)HY(ra)HY(tion)YH()ES( + )DD(Do not write XML decla)HY(ra)HY(tion)YH( \201\202. + )LD( + + )0 P(You can pass several flags by combin)HY(ing)YH( them using the bit-wise OR + oper)HY(a)HY(tor)YH(. For example:)EP( + + ) 9 45 PR(std::unique_ptr r = ... +std::ofstream ofs \201"test.xml"\202; +xml_schema::namespace_infomap map; +name \201ofs, + *r, + map, + "UTF-8", + xml_schema::flags::no_xml_declaration | + xml_schema::flags::dont_pretty_print\202;)RP( + + )0 P(For more infor)HY(ma)HY(tion)YH( on the Xerces-C++ runtime initial)HY(iza)HY(tion)YH( + refer to )0 141 1 A(Section 4.1, "Initial)HY(iz)HY(ing)YH( the Xerces-C++ + Runtime")141 0 TN TL()Ec /AF f D(. + )EP( + + )0 2 81 H(4.4)WB 226 Sn()WB 85 Sn( Error Handling)EA()EH( + + )0 P(As with the parsing func)HY(tions)YH( \201see )0 105 1 A(Section 3.3, + "Error Handling")105 0 TN TL()Ec /AF f D(\202, to better under)HY(stand)YH( error handling and + report)HY(ing)YH( strate)HY(gies)YH( employed by the seri)HY(al)HY(iza)HY(tion)YH( func)HY(tions)YH(, it + is useful to know that the trans)HY(for)HY(ma)HY(tion)YH( of a stat)HY(i)HY(cally)YH(-typed + tree to an XML instance docu)HY(ment)YH( happens in two stages. The first + stage, performed by the gener)HY(ated)YH( code, consist of build)HY(ing)YH( a DOM + instance from the stat)HY(i)HY(cally)YH(-typed tree . For short, we will call + this stage the Tree-DOM stage. The second stage, performed by + Xerces-C++, consists of seri)HY(al)HY(iz)HY(ing)YH( the DOM instance into the XML + docu)HY(ment)YH(. We will call this stage the DOM-XML stage. + )EP( + + )0 P(All seri)HY(al)HY(iza)HY(tion)YH( func)HY(tions)YH( except the two that seri)HY(al)HY(ize)YH( into + a DOM instance come in over)HY(loaded)YH( triples. The first func)HY(tion)YH( + in such a triple reports error condi)HY(tions)YH( exclu)HY(sively)YH( by throw)HY(ing)YH( + excep)HY(tions)YH(. It accu)HY(mu)HY(lates)YH( all the seri)HY(al)HY(iza)HY(tion)YH( errors of the + DOM-XML stage and throws them in a single instance of the + )SM(xml_schema::seri)HY(al)HY(iza)HY(tion)YH()ES( excep)HY(tion)YH( \201described below\202. + The second and the third func)HY(tions)YH( in the triple use call)HY(back)YH( + inter)HY(faces)YH( to report seri)HY(al)HY(iza)HY(tion)YH( errors and warn)HY(ings)YH(. The two + call)HY(back)YH( inter)HY(faces)YH( are )SM(xml_schema::error_handler)ES( and + )SM(xercesc::DOMEr)HY(rorHan)HY(dler)YH()ES(. The + )SM(xml_schema::error_handler)ES( inter)HY(face)YH( is described in + )0 105 1 A(Section 3.3, "Error Handling")105 0 TN TL()Ec /AF f D(. For more infor)HY(ma)HY(tion)YH( + on the )SM(xercesc::DOMEr)HY(rorHan)HY(dler)YH()ES( inter)HY(face)YH( refer to the + Xerces-C++ docu)HY(men)HY(ta)HY(tion)YH(. + )EP( + + )0 P(The Tree-DOM stage reports error condi)HY(tions)YH( exclu)HY(sively)YH( by throw)HY(ing)YH( + excep)HY(tions)YH(. Indi)HY(vid)HY(ual)YH( excep)HY(tions)YH( thrown by the seri)HY(al)HY(iza)HY(tion)YH( func)HY(tions)YH( + are described in the follow)HY(ing)YH( sub-sections. + )EP( + + )0 3 82 H(4.4.1)WB 227 Sn()WB 86 Sn( )SM(xml_schema::seri)HY(al)HY(iza)HY(tion)YH()ES()EA()EH( + + ) 11 39 PR(struct serialization: virtual exception +{ + serialization \201\202; + serialization \201const diagnostics&\202; + + const diagnostics& + diagnostics \201\202 const; + + virtual const char* + what \201\202 const throw \201\202; +};)RP( + + )0 P(The )SM(xml_schema::diag)HY(nos)HY(tics)YH()ES( class is described in + )0 142 1 A(Section 3.3.1, ")SM(xml_schema::parsing)ES(")142 0 TN TL()Ec /AF f D(. + The )SM(xml_schema::seri)HY(al)HY(iza)HY(tion)YH()ES( excep)HY(tion)YH( is thrown if + there were seri)HY(al)HY(iza)HY(tion)YH( errors reported during the DOM-XML stage. + If no call)HY(back)YH( inter)HY(face)YH( was provided to the seri)HY(al)HY(iza)HY(tion)YH( func)HY(tion)YH(, + the excep)HY(tion)YH( contains a list of errors and warn)HY(ings)YH( acces)HY(si)HY(ble)YH( using + the )SM(diag)HY(nos)HY(tics)YH()ES( func)HY(tion)YH(. + )EP( + + + )0 3 83 H(4.4.2)WB 228 Sn()WB 87 Sn( )SM(xml_schema::unex)HY(pected)YH(_element)ES()EA()EH( + + )0 P(The )SM(xml_schema::unex)HY(pected)YH(_element)ES( excep)HY(tion)YH( is + described in )0 143 1 A(Section 3.3.3, + ")SM(xml_schema::unex)HY(pected)YH(_element)ES(")143 0 TN TL()Ec /AF f D(. It is thrown + by the seri)HY(al)HY(iza)HY(tion)YH( func)HY(tions)YH( during the Tree-DOM stage if the + root element name of the provided DOM instance does not match with + the name of the element this seri)HY(al)HY(iza)HY(tion)YH( func)HY(tion)YH( is for. + )EP( + + )0 3 84 H(4.4.3)WB 229 Sn()WB 88 Sn( )SM(xml_schema::no_type_info)ES()EA()EH( + + )0 P(The )SM(xml_schema::no_type_info)ES( excep)HY(tion)YH( is + described in )0 144 1 A(Section 3.3.7, + ")SM(xml_schema::no_type_info)ES(")144 0 TN TL()Ec /AF f D(. It is thrown + by the seri)HY(al)HY(iza)HY(tion)YH( func)HY(tions)YH( during the Tree-DOM stage when there + is no type infor)HY(ma)HY(tion)YH( asso)HY(ci)HY(ated)YH( with a dynamic type of an + element. Usually, catch)HY(ing)YH( this excep)HY(tion)YH( means that you haven't + linked the code gener)HY(ated)YH( from the schema defin)HY(ing)YH( the type in + ques)HY(tion)YH( with your appli)HY(ca)HY(tion)YH( or this schema has been compiled + without the )SM(--gener)HY(ate)YH(-poly)HY(mor)HY(phic)YH()ES( option. + )EP( + + )0 2 85 H(4.5)WB 230 Sn()WB 89 Sn( Seri)HY(al)HY(iz)HY(ing)YH( to )SM(std::ostream)ES()EA()EH( + + )0 P(In order to seri)HY(al)HY(ize)YH( to )SM(std::ostream)ES( you will need + an object model, an output stream and, option)HY(ally)YH(, a names)HY(pace)YH( + infomap. For instance:)EP( + + ) 14 61 PR(// Obtain the object model. +// +std::unique_ptr r = ... + +// Prepare namespace mapping and schema location information. +// +xml_schema::namespace_infomap map; + +map["t"].name = "https://www.codesynthesis.com/test"; +map["t"].schema = "test.xsd"; + +// Write it out. +// +name \201std::cout, *r, map\202;)RP( + + )0 P(Note that the output stream is treated as a binary stream. This + becomes impor)HY(tant)YH( when you use a char)HY(ac)HY(ter)YH( encod)HY(ing)YH( that is wider + than 8-bit )SM(char)ES(, for instance UTF-16 or UCS-4. For + example, things will most likely break if you try to seri)HY(al)HY(ize)YH( + to )SM(std::ostringstream)ES( with UTF-16 or UCS-4 as an + encod)HY(ing)YH(. This is due to the special value, + )SM('\2000')ES(, that will most likely occur as part of such + seri)HY(al)HY(iza)HY(tion)YH( and it won't have the special meaning assumed by + )SM(std::ostringstream)ES(. + )EP( + + + )0 2 86 H(4.6)WB 231 Sn()WB 90 Sn( Seri)HY(al)HY(iz)HY(ing)YH( to )SM(xercesc::XMLFor)HY(mat)HY(Tar)HY(get)YH()ES()EA()EH( + + )0 P(Seri)HY(al)HY(iz)HY(ing)YH( to an )SM(xercesc::XMLFor)HY(mat)HY(Tar)HY(get)YH()ES( instance + is similar the )SM(std::ostream)ES( case. For instance: + )EP( + + ) 38 65 PR(using std::unique_ptr; + +// Obtain the object model. +// +unique_ptr r = ... + +// Prepare namespace mapping and schema location information. +// +xml_schema::namespace_infomap map; + +map["t"].name = "https://www.codesynthesis.com/test"; +map["t"].schema = "test.xsd"; + +using namespace xercesc; + +XMLPlatformUtils::Initialize \201\202; + +{ + // Choose a target. + // + unique_ptr ft; + + if \201argc != 2\202 + { + ft = unique_ptr \201new StdOutFormatTarget \201\202\202; + } + else + { + ft = unique_ptr \201 + new LocalFileFormatTarget \201argv[1]\202\202; + })WR( + + // Write it out. + // + name \201*ft, *r, map\202; +} + +XMLPlatformUtils::Terminate \201\202;)RP( + + )0 P(Note that we had to initial)HY(ize)YH( the Xerces-C++ runtime before we + could call this seri)HY(al)HY(iza)HY(tion)YH( func)HY(tion)YH(.)EP( + + )0 2 87 H(4.7)WB 232 Sn()WB 91 Sn( Seri)HY(al)HY(iz)HY(ing)YH( to DOM)EA()EH( + + )0 P(The mapping provides two over)HY(loaded)YH( func)HY(tions)YH( that imple)HY(ment)YH( + seri)HY(al)HY(iza)HY(tion)YH( to a DOM instance. The first creates a DOM instance + for you and the second seri)HY(al)HY(izes)YH( to an exist)HY(ing)YH( DOM instance. + While seri)HY(al)HY(iz)HY(ing)YH( to a new DOM instance is similar to seri)HY(al)HY(iz)HY(ing)YH( + to )SM(std::ostream)ES( or )SM(xercesc::XMLFor)HY(mat)HY(Tar)HY(get)YH()ES(, + seri)HY(al)HY(iz)HY(ing)YH( to an exist)HY(ing)YH( DOM instance requires quite a bit of work + from your side. You will need to set all the custom names)HY(pace)YH( mapping + attributes as well as the )SM(schemaLo)HY(ca)HY(tion)YH()ES( and/or + )SM(noNames)HY(paceSchemaLo)HY(ca)HY(tion)YH()ES( attributes. The follow)HY(ing)YH( + listing should give you an idea about what needs to be done: + )EP( + + ) 24 67 PR(// Obtain the object model. +// +std::unique_ptr r = ... + +using namespace xercesc; + +XMLPlatformUtils::Initialize \201\202; + +{ + // Create a DOM instance. Set custom namespace mapping and schema + // location attributes. + // + DOMDocument& doc = ... + + // Serialize to DOM. + // + name \201doc, *r\202; + + // Serialize the DOM document to XML. + // + ... +} + +XMLPlatformUtils::Terminate \201\202;)RP( + + )0 P(For more infor)HY(ma)HY(tion)YH( on how to create and seri)HY(al)HY(ize)YH( a DOM instance + refer to the Xerces-C++ docu)HY(men)HY(ta)HY(tion)YH(. In addi)HY(tion)YH(, the + )R4 2 A(C++/Tree Mapping + FAQ)EA( shows how to imple)HY(ment)YH( these oper)HY(a)HY(tions)YH( using the XSD + runtime util)HY(i)HY(ties)YH(. + )EP( + + )0 1 88 H(5)WB 233 Sn()WB 92 Sn( Addi)HY(tional)YH( Func)HY(tion)HY(al)HY(ity)YH()EA()EH( + + )0 P(The C++/Tree mapping provides a number of optional features + that can be useful in certain situ)HY(a)HY(tions)YH(. They are described + in the follow)HY(ing)YH( sections.)EP( + + )0 2 89 H(5.1)WB 234 Sn()WB 93 Sn( DOM Asso)HY(ci)HY(a)HY(tion)YH()EA()EH( + + )0 P(Normally, after parsing is complete, the DOM docu)HY(ment)YH( which + was used to extract the data is discarded. However, the parsing + func)HY(tions)YH( can be instructed to preserve the DOM docu)HY(ment)YH( + and create an asso)HY(ci)HY(a)HY(tion)YH( between the DOM nodes and object model + nodes. When there is an asso)HY(ci)HY(a)HY(tion)YH( between the DOM and + object model nodes, you can obtain the corre)HY(spond)HY(ing)YH( DOM element + or attribute node from an object model node as well as perform + the reverse tran)HY(si)HY(tion)YH(: obtain the corre)HY(spond)HY(ing)YH( object model + from a DOM element or attribute node.)EP( + + )0 P(Main)HY(tain)HY(ing)YH( DOM asso)HY(ci)HY(a)HY(tion)YH( is normally useful when the appli)HY(ca)HY(tion)YH( + needs access to XML constructs that are not preserved in the + object model, for example, XML comments. + Another useful aspect of DOM asso)HY(ci)HY(a)HY(tion)YH( is the ability of the + appli)HY(ca)HY(tion)YH( to navi)HY(gate)YH( the docu)HY(ment)YH( tree using the generic DOM + inter)HY(face)YH( \201for example, with the help of an XPath proces)HY(sor)YH(\202 + and then move back to the stat)HY(i)HY(cally)YH(-typed object model. Note + also that while you can change the under)HY(ly)HY(ing)YH( DOM docu)HY(ment)YH(, + these changes are not reflected in the object model and will + be ignored during seri)HY(al)HY(iza)HY(tion)YH(. If you need to not only access + but also modify some aspects of XML that are not preserved in + the object model, then type customiza)HY(tion)YH( with custom parsing + construc)HY(tors)YH( and seri)HY(al)HY(iza)HY(tion)YH( oper)HY(a)HY(tors)YH( should be used instead.)EP( + + )0 P(To request DOM asso)HY(ci)HY(a)HY(tion)YH( you will need to pass the + )SM(xml_schema::flags::keep_dom)ES( flag to one of the + parsing func)HY(tions)YH( \201see )0 138 1 A(Section 3.2, + "Flags and Prop)HY(er)HY(ties)YH(")138 0 TN TL()Ec /AF f D( for more infor)HY(ma)HY(tion)YH(\202. In this case the + DOM docu)HY(ment)YH( is retained and will be released when the object model + is deleted. Note that since DOM nodes "out-live" the parsing func)HY(tion)YH( + call, you need to initial)HY(ize)YH( the Xerces-C++ runtime before calling + one of the parsing func)HY(tions)YH( with the )SM(keep_dom)ES( flag and + termi)HY(nate)YH( it after the object model is destroyed \201see + )0 124 1 A(Section 3.1, "Initial)HY(iz)HY(ing)YH( the Xerces-C++ Runtime")124 0 TN TL()Ec /AF f D(\202.)EP( + + )0 P(If the )SM(keep_dom)ES( flag is passed + as the second argu)HY(ment)YH( to the copy construc)HY(tor)YH( and the copy + being made is of a complete tree, then the DOM asso)HY(ci)HY(a)HY(tion)YH( + is also main)HY(tained)YH( in the copy by cloning the under)HY(ly)HY(ing)YH( + DOM docu)HY(ment)YH( and reestab)HY(lish)HY(ing)YH( the asso)HY(ci)HY(a)HY(tions)YH(. For example:)EP( + + ) 22 48 PR(using namespace xercesc; + +XMLPlatformUtils::Initialize \201\202; + +{ + // Parse XML to object model. + // + std::unique_ptr r \201root \201 + "root.xml", + xml_schema::flags::keep_dom | + xml_schema::flags::dont_initialize\202\202; + + // Copy without DOM association. + // + type copy1 \201*r\202; + + // Copy with DOM association. + // + type copy2 \201*r, xml_schema::flags::keep_dom\202; +} + +XMLPlatformUtils::Terminate \201\202;)RP( + + + )0 P(To obtain the corre)HY(spond)HY(ing)YH( DOM node from an object model node + you will need to call the )SM(_node)ES( acces)HY(sor)YH( func)HY(tion)YH( + which returns a pointer to )SM(DOMNode)ES(. You can then query + this DOM node's type and cast it to either )SM(DOMAttr*)ES( + or )SM(DOMEle)HY(ment)YH(*)ES(. To obtain the corre)HY(spond)HY(ing)YH( object + model node from a DOM node, the DOM user data API is used. The + )SM(xml_schema::dom::tree_node_key)ES( vari)HY(able)YH( contains + the key for object model nodes. The follow)HY(ing)YH( schema and code + frag)HY(ment)YH( show how to navi)HY(gate)YH( from DOM to object model nodes + and in the oppo)HY(site)YH( direc)HY(tion)YH(:)EP( + + ) 7 37 PR( + + + + + +)RP( + + ) 42 68 PR(using namespace xercesc; + +XMLPlatformUtils::Initialize \201\202; + +{ + // Parse XML to object model. + // + std::unique_ptr r \201root \201 + "root.xml", + xml_schema::flags::keep_dom | + xml_schema::flags::dont_initialize\202\202; + + DOMNode* n = r->_node \201\202; + assert \201n->getNodeType \201\202 == DOMNode::ELEMENT_NODE\202; + DOMElement* re = static_cast \201n\202; + + // Get the 'a' element. Note that it is not necessarily the + // first child node of 'root' since there could be whitespace + // nodes before it. + // + DOMElement* ae; + + for \201n = re->getFirstChild \201\202; n != 0; n = n->getNextSibling \201\202\202 + { + if \201n->getNodeType \201\202 == DOMNode::ELEMENT_NODE\202 + { + ae = static_cast \201n\202; + break; + } + } +)WR( + // Get from the 'a' DOM element to xml_schema::string object model + // node. + // + xml_schema::type& t \201 + *reinterpret_cast \201 + ae->getUserData \201xml_schema::dom::tree_node_key\202\202\202; + + xml_schema::string& a \201dynamic_cast \201t\202\202; +} + +XMLPlatformUtils::Terminate \201\202;)RP( + + )0 P(The 'mixed' example which can be found in the XSD distri)HY(bu)HY(tion)YH( + shows how to handle the mixed content using DOM asso)HY(ci)HY(a)HY(tion)YH(.)EP( + + )0 2 90 H(5.2)WB 235 Sn()WB 94 Sn( Binary Seri)HY(al)HY(iza)HY(tion)YH()EA()EH( + + )0 P(Besides reading from and writing to XML, the C++/Tree mapping + also allows you to save the object model to and load it from a + number of prede)HY(fined)YH( as well as custom data repre)HY(sen)HY(ta)HY(tion)YH( + formats. The prede)HY(fined)YH( binary formats are CDR \201Common Data + Repre)HY(sen)HY(ta)HY(tion)YH(\202 and XDR \201eXter)HY(nal)YH( Data Repre)HY(sen)HY(ta)HY(tion)YH(\202. A + custom format can easily be supported by provid)HY(ing)YH( + inser)HY(tion)YH( and extrac)HY(tion)YH( oper)HY(a)HY(tors)YH( for basic types.)EP( + + )0 P(Binary seri)HY(al)HY(iza)HY(tion)YH( saves only the data without any meta + infor)HY(ma)HY(tion)YH( or markup. As a result, saving to and loading + from a binary repre)HY(sen)HY(ta)HY(tion)YH( can be an order of magni)HY(tude)YH( + faster than parsing and seri)HY(al)HY(iz)HY(ing)YH( the same data in XML. + Further)HY(more)YH(, the result)HY(ing)YH( repre)HY(sen)HY(ta)HY(tion)YH( is normally several + times smaller than the equiv)HY(a)HY(lent)YH( XML repre)HY(sen)HY(ta)HY(tion)YH(. These + prop)HY(er)HY(ties)YH( make binary seri)HY(al)HY(iza)HY(tion)YH( ideal for inter)HY(nal)YH( data + exchange and storage. A typical appli)HY(ca)HY(tion)YH( that uses this + facil)HY(ity)YH( stores the data and commu)HY(ni)HY(cates)YH( within the + system using a binary format and reads/writes the data + in XML when commu)HY(ni)HY(cat)HY(ing)YH( with the outside world.)EP( + + )0 P(In order to request the gener)HY(a)HY(tion)YH( of inser)HY(tion)YH( oper)HY(a)HY(tors)YH( and + extrac)HY(tion)YH( construc)HY(tors)YH( for a specific prede)HY(fined)YH( or custom + data repre)HY(sen)HY(ta)HY(tion)YH( stream, you will need to use the + )SM(--gener)HY(ate)YH(-inser)HY(tion)YH()ES( and )SM(--gener)HY(ate)YH(-extrac)HY(tion)YH()ES( + compiler options. See the + )R5 2 A(XSD + Compiler Command Line Manual)EA( for more infor)HY(ma)HY(tion)YH(.)EP( + + )0 P(Once the inser)HY(tion)YH( oper)HY(a)HY(tors)YH( and extrac)HY(tion)YH( construc)HY(tors)YH( are + gener)HY(ated)YH(, you can use the )SM(xml_schema::istream)ES( + and )SM(xml_schema::ostream)ES( wrapper stream templates + to save the object model to and load it from a specific format. + The follow)HY(ing)YH( code frag)HY(ment)YH( shows how to do this using ACE + \201Adap)HY(tive)YH( Commu)HY(ni)HY(ca)HY(tion)YH( Envi)HY(ron)HY(ment)YH(\202 CDR streams as an example:)EP( + + ) 8 37 PR( + + + + + + +)RP( + + ) 21 51 PR(// Parse XML to object model. +// +std::unique_ptr r \201root \201"root.xml"\202\202; + +// Save to a CDR stream. +// +ACE_OutputCDR ace_ocdr; +xml_schema::ostream ocdr \201ace_ocdr\202; + +ocdr << *r; + +// Load from a CDR stream. +// +ACE_InputCDR ace_icdr \201buf, size\202; +xml_schema::istream icdr \201ace_icdr\202; + +std::unique_ptr copy \201new object \201icdr\202\202; + +// Serialize to XML. +// +root \201std::cout, *copy\202;)RP( + + )0 P(The XSD distri)HY(bu)HY(tion)YH( contains a number of exam)HY(ples)YH( that + show how to save the object model to and load it from + CDR, XDR, and a custom format.)EP( + + + + + )0 1 91 H(Appendix)WB 236 Sn()WB 95 Sn( A \236 Default and Fixed Values)EA()EH( + + )0 P(The follow)HY(ing)YH( table summa)HY(rizes)YH( the effect of default and fixed + values \201spec)HY(i)HY(fied)YH( with the )SM(default)ES( and )SM(fixed)ES( + attributes, respec)HY(tively)YH(\202 on attribute and element values. The + )SM(default)ES( and )SM(fixed)ES( attributes are mutu)HY(ally)YH( + exclu)HY(sive)YH(. It is also worth)HY(while)YH( to note that the fixed value seman)HY(tics)YH( + is a super)HY(set)YH( of the default value seman)HY(tics)YH(. + )EP( + + + )1 PT( + + )BR( +)BR( + + +)WB NL +/TE t D NP /OU t D TU PM 1 eq and{/Pn () D showpage}if end restore diff --git a/doc/pregenerated/xsd.1 b/doc/pregenerated/xsd.1 new file mode 100644 index 0000000..74c9e89 --- /dev/null +++ b/doc/pregenerated/xsd.1 @@ -0,0 +1,1500 @@ +.\" Process this file with +.\" groff -man -Tascii xsd.1 +.\" +.TH XSD 1 "January 2023" "XSD 4.2.0" +.SH NAME +xsd \- W3C XML Schema to C++ Compiler +.\" +.\" +.\" +.\"-------------------------------------------------------------------- +.SH SYNOPSIS +.\"-------------------------------------------------------------------- +.B xsd +.I command +.B [ +.I options +.B ] +.I file +.B [ +.I file +.B ...] +.in +.B xsd help +.B [ +.I command +.B ] +.in +.B xsd version +.\" +.\" +.\" +.\"-------------------------------------------------------------------- +.SH DESCRIPTION +.\"-------------------------------------------------------------------- +.B xsd +generates vocabulary-specific, statically-typed C++ mapping from W3C XML +Schema definitions. Particular mapping to produce is selected by a +.IR command . +Each mapping has a number of mapping-specific +.I options +that should appear, if any, after the +.IR command . +Input files should be W3C XML Schema definitions. The exact set of the +generated files depends on the selected mapping and options. +.\" +.\" +.\" +.\"-------------------------------------------------------------------- +.SH COMMANDS +.\"-------------------------------------------------------------------- +.IP \fBcxx-tree\fR +Generate the C++/Tree mapping. For each input file in the form +.B name.xsd +the following C++ files are generated: +.B name.hxx +(header file), +.B name.ixx +(inline file, generated only if the +.B --generate-inline +option is specified), +.B name.cxx +(source file), and +.B name-fwd.hxx +(forward declaration file, generated only if the +.B --generate-forward +option is specified). + +.IP \fBcxx-parser\fR +Generate the C++/Parser mapping. For each input file in the form +.B name.xsd +the following C++ files are generated: +.B name-pskel.hxx +(parser skeleton header file), +.B name-pskel.ixx +(parser skeleton inline file, generated only if the +.B --generate-inline +option is specified), and +.B name-pskel.cxx +(parser skeleton source file). If the +.B --generate-noop-impl +or +.B --generate-print-impl +option is specified, the following additional sample implementation files +are generated: +.B name-pimpl.hxx +(parser implementation header file) and +.B name-pimpl.cxx +(parser implementation source file). If the +.B --generate-test-driver +option is specified, the additional +.B name-driver.cxx +test driver file is generated. + +.IP \fBhelp\fR +Print usage information and exit. Use +.PP +.RS +.RS 3 +.B xsd help +.I command +.RE +.PP +for command-specific help. +.RE +.IP \fBversion\fR +Print version and exit. +.\"-------------------------------------------------------------------- +.SH OPTIONS +.\"-------------------------------------------------------------------- +Command-specific +.IR options , +if any, should appear after the corresponding +.IR command . + +.\" +.\" Common options. +.\" +.SS common options +. +.IP "\fB--std\fR \fIversion\fR" +Specify the C++ standard that the generated code should conform to\. Valid +values are \fBc++98\fR, \fBc++11\fR (default), \fBc++14\fR, \fBc++17\fR, +\fBc++20\fR, and \fBc++23\fR\. + +The C++ standard affects various aspects of the generated code that are +discussed in more detail in various mapping-specific documentation\. Overall, +when C++11 is selected, the generated code relies on the move semantics and +uses \fBstd::unique_ptr\fR instead of deprecated \fBstd::auto_ptr\fR\. +Currently, there is no difference between the C++11 and the later standards +modes\. + +When the C++11 mode is selected, you normally don't need to perform any extra +steps other than enable C++11 in your C++ compiler, if required\. The XSD +compiler will automatically add the necessary macro defines to the generated +header files that will switch the header-only XSD runtime library +(\fBlibxsd\fR) to the C++11 mode\. However, if you include any of the XSD +runtime headers directly in your application (normally you just include the +generated headers), then you will need to define the \fBXSD_CXX11\fR macro for +your entire project\. +.IP "\fB--char-type\fR \fItype\fR" +Generate code using the provided character \fItype\fR instead of the default +\fBchar\fR\. Valid values are \fBchar\fR and \fBwchar_t\fR\. +.IP "\fB--char-encoding\fR \fIenc\fR" +Specify the character encoding that should be used in the generated code\. +Valid values for the \fBchar\fR character type are \fButf8\fR (default), +\fBiso8859-1\fR, \fBlcp\fR (Xerces-C++ local code page), and \fBcustom\fR\. If +you pass \fBcustom\fR as the value then you will need to include the +transcoder implementation header for your encoding at the beginning of the +generated header files (see the \fB--hxx-prologue\fR option)\. + +For the \fBwchar_t\fR character type the only valid value is \fBauto\fR and +the encoding is automatically selected between UTF-16 and UTF-32/UCS-4, +depending on the \fBwchar_t\fR type size\. +.IP "\fB--output-dir\fR \fIdir\fR" +Write generated files to \fIdir\fR instead of the current directory\. +.IP "\fB--generate-inline\fR" +Generate simple functions inline\. This option triggers creation of the inline +file\. +.IP "\fB--generate-xml-schema\fR" +Generate a C++ header file as if the schema being compiled defines the XML +Schema namespace\. For the C++/Tree mapping, the resulting file will contain +definitions for all XML Schema built-in types\. For the C++/Parser mapping, +the resulting file will contain definitions for all the parser skeletons and +implementations corresponding to the XML Schema built-in types\. + +The schema file provided to the compiler need not exist and is only used to +derive the name of the resulting header file\. Use the +\fB--extern-xml-schema\fR option to include this file in the generated files +for other schemas\. +.IP "\fB--extern-xml-schema\fR \fIfile\fR" +Include a header file derived from \fIfile\fR instead of generating the XML +Schema namespace mapping inline\. The provided file need not exist and is only +used to derive the name of the included header file\. Use the +\fB--generate-xml-schema\fR option to generate this header file\. +.IP "\fB--namespace-map\fR \fIxns\fR=\fIcns\fR" +Map XML Schema namespace \fIxns\fR to C++ namespace \fIcns\fR\. Repeat this +option to specify mapping for more than one XML Schema namespace\. For +example, the following option: + +\fB--namespace-map http://example\.com/foo/bar=foo::bar\fR + +Will map the \fBhttp://example\.com/foo/bar\fR XML Schema namespace to the +\fBfoo::bar\fR C++ namespace\. +.IP "\fB--namespace-regex\fR \fIregex\fR" +Add \fIregex\fR to the list of regular expressions used to translate XML +Schema namespace names to C++ namespace names\. \fIregex\fR is a Perl-like +regular expression in the form +\fB/\fR\fIpattern\fR\fB/\fR\fIreplacement\fR\fB/\fR\fR\. Any character can be +used as a delimiter instead of '\fB/\fR'\. Escaping of the delimiter character +in \fIpattern\fR or \fIreplacement\fR is not supported\. + +All the regular expressions are pushed into a stack with the last specified +expression considered first\. The first match that succeeds is used\. Regular +expressions are applied to a string in the form + +\fIfilename\fR \fInamespace\fR\fR + +For example, if you have file \fBhello\.xsd\fR with namespace +\fBhttp://example\.com/hello\fR and you run \fBxsd\fR on this file, then the +string in question will be: + +\fBhello\.xsd\. http://example\.com/hello\fR + +For the built-in XML Schema namespace the string is: + +\fBXMLSchema\.xsd http://www\.w3\.org/2001/XMLSchema\fR + +The following three steps are performed for each regular expression until the +match is found: + +1\. The expression is applied and if the result is empty the next expression +is considered\. + +2\. All '\fB/\fR' are replaced with '\fB::\fR'\. + +3\. The result is verified to be a valid C++ scope name (e\.g\., +\fBfoo::bar\fR)\. If this test succeeds, the result is used as a C++ namespace +name\. + +As an example, the following expression maps XML Schema namespaces in the +form \fBhttp://example\.com/foo/bar\fR to C++ namespaces in the form +\fBfoo::bar\fR: + +\fB%\.* http://example\.com/(\.+)%$1%\fR + +See also the REGEX AND SHELL QUOTING section below\. +.IP "\fB--namespace-regex-trace\fR" +Trace the process of applying regular expressions specified with the +\fB--namespace-regex\fR option\. Use this option to find out why your regular +expressions don't do what you expected them to do\. +.IP "\fB--reserved-name\fR \fIn\fR[=\fIr\fR]" +Add name \fIn\fR to the list of names that should not be used as identifiers\. +The name can optionally be followed by \fB=\fR and the replacement name +\fIr\fR that should be used instead\. All the C++ keywords are already in this +list\. +.IP "\fB--include-with-brackets\fR" +Use angle brackets (<>) instead of quotes ("") in generated \fB#include\fR +directives\. +.IP "\fB--include-prefix\fR \fIprefix\fR" +Add \fIprefix\fR to generated \fB#include\fR directive paths\. + +For example, if you had the following import element in your schema + +\fB\fR + +and compiled this fragment with \fB--include-prefix schemas/\fR, then the +include directive in the generated code would be: + +\fB#include "schemas/base\.hxx"\fR +.IP "\fB--include-regex\fR \fIregex\fR" +Add \fIregex\fR to the list of regular expressions used to transform +\fB#include\fR directive paths\. \fIregex\fR is a Perl-like regular expression +in the form \fB/\fR\fIpattern\fR\fB/\fR\fIreplacement\fR\fB/\fR\fR\. Any +character can be used as a delimiter instead of '\fB/\fR'\. Escaping of the +delimiter character in \fIpattern\fR or \fIreplacement\fR is not supported\. + +All the regular expressions are pushed into a stack with the last specified +expression considered first\. The first match that succeeds is used\. + +As an example, the following expression transforms paths in the form +\fBschemas/foo/bar\fR to paths in the form \fBgenerated/foo/bar\fR: + +\fB%schemas/(\.+)%generated/$1%\fR + +See also the REGEX AND SHELL QUOTING section below\. +.IP "\fB--include-regex-trace\fR" +Trace the process of applying regular expressions specified with the +\fB--include-regex\fR option\. Use this option to find out why your regular +expressions don't do what you expected them to do\. +.IP "\fB--guard-prefix\fR \fIprefix\fR" +Add \fIprefix\fR to generated header inclusion guards\. The prefix is +transformed to upper case and characters that are illegal in a preprocessor +macro name are replaced with underscores\. If this option is not specified +then the directory part of the input schema file is used as a prefix\. +.IP "\fB--hxx-suffix\fR \fIsuffix\fR" +Use the provided \fIsuffix\fR instead of the default \fB\.hxx\fR to construct +the name of the header file\. Note that this suffix is also used to construct +names of header files corresponding to included/imported schemas\. +.IP "\fB--ixx-suffix\fR \fIsuffix\fR" +Use the provided \fIsuffix\fR instead of the default \fB\.ixx\fR to construct +the name of the inline file\. +.IP "\fB--cxx-suffix\fR \fIsuffix\fR" +Use the provided \fIsuffix\fR instead of the default \fB\.cxx\fR to construct +the name of the source file\. +.IP "\fB--fwd-suffix\fR \fIsuffix\fR" +Use the provided \fIsuffix\fR instead of the default \fB-fwd\.hxx\fR to +construct the name of the forward declaration file\. +.IP "\fB--hxx-regex\fR \fIregex\fR" +Use the provided expression to construct the name of the header file\. +\fIregex\fR is a Perl-like regular expression in the form +\fB/\fR\fIpattern\fR\fB/\fR\fIreplacement\fR\fB/\fR\fR\. Note that this +expression is also used to construct names of header files corresponding to +included/imported schemas\. See also the REGEX AND SHELL QUOTING section +below\. +.IP "\fB--ixx-regex\fR \fIregex\fR" +Use the provided expression to construct the name of the inline file\. +\fIregex\fR is a Perl-like regular expression in the form +\fB/\fR\fIpattern\fR\fB/\fR\fIreplacement\fR\fB/\fR\fR\. See also the REGEX +AND SHELL QUOTING section below\. +.IP "\fB--cxx-regex\fR \fIregex\fR" +Use the provided expression to construct the name of the source file\. +\fIregex\fR is a Perl-like regular expression in the form +\fB/\fR\fIpattern\fR\fB/\fR\fIreplacement\fR\fB/\fR\fR\. See also the REGEX +AND SHELL QUOTING section below\. +.IP "\fB--fwd-regex\fR \fIregex\fR" +Use the provided expression to construct the name of the forward declaration +file\. \fIregex\fR is a Perl-like regular expression in the form +\fB/\fR\fIpattern\fR\fB/\fR\fIreplacement\fR\fB/\fR\fR\. See also the REGEX +AND SHELL QUOTING section below\. +.IP "\fB--hxx-prologue\fR \fItext\fR" +Insert \fItext\fR at the beginning of the header file\. +.IP "\fB--ixx-prologue\fR \fItext\fR" +Insert \fItext\fR at the beginning of the inline file\. +.IP "\fB--cxx-prologue\fR \fItext\fR" +Insert \fItext\fR at the beginning of the source file\. +.IP "\fB--fwd-prologue\fR \fItext\fR" +Insert \fItext\fR at the beginning of the forward declaration file\. +.IP "\fB--prologue\fR \fItext\fR" +Insert \fItext\fR at the beginning of each generated file for which there is +no file-specific prologue\. +.IP "\fB--hxx-epilogue\fR \fItext\fR" +Insert \fItext\fR at the end of the header file\. +.IP "\fB--ixx-epilogue\fR \fItext\fR" +Insert \fItext\fR at the end of the inline file\. +.IP "\fB--cxx-epilogue\fR \fItext\fR" +Insert \fItext\fR at the end of the source file\. +.IP "\fB--fwd-epilogue\fR \fItext\fR" +Insert \fItext\fR at the end of the forward declaration file\. +.IP "\fB--epilogue\fR \fItext\fR" +Insert \fItext\fR at the end of each generated file for which there is no +file-specific epilogue\. +.IP "\fB--hxx-prologue-file\fR \fIfile\fR" +Insert the content of the \fIfile\fR at the beginning of the header file\. +.IP "\fB--ixx-prologue-file\fR \fIfile\fR" +Insert the content of the \fIfile\fR at the beginning of the inline file\. +.IP "\fB--cxx-prologue-file\fR \fIfile\fR" +Insert the content of the \fIfile\fR at the beginning of the source file\. +.IP "\fB--fwd-prologue-file\fR \fIfile\fR" +Insert the content of the \fIfile\fR at the beginning of the forward +declaration file\. +.IP "\fB--prologue-file\fR \fIfile\fR" +Insert the content of the \fIfile\fR at the beginning of each generated file +for which there is no file-specific prologue file\. +.IP "\fB--hxx-epilogue-file\fR \fIfile\fR" +Insert the content of the \fIfile\fR at the end of the header file\. +.IP "\fB--ixx-epilogue-file\fR \fIfile\fR" +Insert the content of the \fIfile\fR at the end of the inline file\. +.IP "\fB--cxx-epilogue-file\fR \fIfile\fR" +Insert the content of the \fIfile\fR at the end of the source file\. +.IP "\fB--fwd-epilogue-file\fR \fIfile\fR" +Insert the content of the \fIfile\fR at the end of the forward declaration +file\. +.IP "\fB--epilogue-file\fR \fIfile\fR" +Insert the content of the \fIfile\fR at the end of each generated file for +which there is no file-specific epilogue file\. +.IP "\fB--export-symbol\fR \fIsymbol\fR" +Insert \fIsymbol\fR in places where DLL export/import control statements +(\fB__declspec(dllexport/dllimport)\fR) are necessary\. +.IP "\fB--export-xml-schema\fR" +Export/import types in the XML Schema namespace using the export symbol +provided with the \fB--export-symbol\fR option\. The \fBXSD_NO_EXPORT\fR macro +can be used to omit this code during C++ compilation, which may be useful if +you would like to use the same generated code across multiple platforms\. +.IP "\fB--export-maps\fR" +Export polymorphism support maps from a Win32 DLL into which this generated +code is placed\. This is necessary when your type hierarchy is split across +several DLLs since otherwise each DLL will have its own set of maps\. In this +situation the generated code for the DLL which contains base types and/or +substitution group heads should be compiled with this option and the generated +code for all other DLLs should be compiled with \fB--import-maps\fR\. This +option is only valid together with \fB--generate-polymorphic\fR\. The +\fBXSD_NO_EXPORT\fR macro can be used to omit this code during C++ +compilation, which may be useful if you would like to use the same generated +code across multiple platforms\. +.IP "\fB--import-maps\fR" +Import polymorphism support maps to a Win32 DLL or executable into which this +generated code is linked\. See the \fB--export-maps\fR option documentation +for details\. This options is only valid together with +\fB--generate-polymorphic\fR\. The \fBXSD_NO_EXPORT\fR macro can be used to +omit this code during C++ compilation, which may be useful if you would like +to use the same generated code across multiple platforms\. +.IP "\fB--generate-dep\fR" +Generate \fBmake\fR dependency information\. This option triggers the creation +of the \fB\.d\fR file containing the dependencies of the generated files on +the main schema file as well as all the schema files that it includes/imports, +transitively\. This dependency file is then normally included into the main +\fBmakefile\fR to implement automatic dependency tracking\. See also the +\fB--dep-*\fR options\. + +Note also that automatic dependency generation is not supported in the +file-per-type mode (\fB--file-per-type\fR)\. In this case, all the generated +files are produced with a single compiler invocation and depend on all the +schemas\. As a result, it is easier to establish such a dependency manually, +perhaps with the help of the \fB--file-list*\fR options\. +.IP "\fB--generate-dep-only\fR" +Generate \fBmake\fR dependency information only\. +.IP "\fB--dep-phony\fR" +Generate phony targets for included/imported schema files, causing each to +depend on nothing\. Such dummy rules work around \fBmake\fR errors caused by +the removal of schema files without also updating the dependency file to +match\. +.IP "\fB--dep-target\fR \fItarget\fR" +Change the target of the dependency rule\. By default it contains all the +generated C++ files as well as the dependency file itself, without any +directory prefixes\. If you require multiple targets, then you can specify +them as a single, space-separated argument or you can repeat this option +multiple times\. +.IP "\fB--dep-suffix\fR \fIsuffix\fR" +Use \fIsuffix\fR instead of the default \fB\.d\fR to construct the name of the +dependency file\. See also \fB--dep-file\fR\. +.IP "\fB--dep-file\fR \fIpath\fR" +Use \fIpath\fR as the generated dependency file path instead of deriving it +from the input file name\. Write the dependency information to \fBstdout\fR if +\fIpath\fR is \fB-\fR\. See also \fB--dep-regex\fR\. +.IP "\fB--dep-regex\fR \fIregex\fR" +Use the provided expression to construct the name of the dependency file\. +\fIregex\fR is a Perl-like regular expression in the form +\fB/\fR\fIpattern\fR\fB/\fR\fIreplacement\fR\fB/\fR\fR\. See also the REGEX +AND SHELL QUOTING section below\. +.IP "\fB--disable-warning\fR \fIwarn\fR" +Disable printing warning with id \fIwarn\fR\. If \fBall\fR is specified for +the warning id then all warnings are disabled\. +.IP "\fB--options-file\fR \fIfile\fR" +Read additional options from \fIfile\fR\. Each option should appearing on a +separate line optionally followed by space and an option value\. Empty lines +and lines starting with \fB#\fR are ignored\. Option values can be enclosed in +double (\fB"\fR) or single (\fB'\fR) quotes to preserve leading and trailing +whitespaces as well as to specify empty values\. If the value itself contains +trailing or leading quotes, enclose it with an extra pair of quotes, for +example \fB'"x"'\fR\. Non-leading and non-trailing quotes are interpreted as +being part of the option value\. + +The semantics of providing options in a file is equivalent to providing the +same set of options in the same order on the command line at the point where +the \fB--options-file\fR option is specified except that the shell escaping +and quoting is not required\. You can repeat this option to specify more than +one options file\. +.IP "\fB--show-sloc\fR" +Show the number of generated physical source lines of code (SLOC)\. +.IP "\fB--sloc-limit\fR \fInum\fR" +Check that the number of generated physical source lines of code (SLOC) does +not exceed \fInum\fR\. +.IP "\fB--proprietary-license\fR" +Indicate that the generated code is licensed under a proprietary license +instead of the GPL\. +.IP "\fB--custom-literals\fR \fIfile\fR" +Load custom XML string to C++ literal mappings from \fIfile\fR\. This +mechanism can be useful if you are using a custom character encoding and some +of the strings in your schemas, for example element/attribute names or +enumeration values, contain non-ASCII characters\. In this case you will need +to provide a custom mapping to C++ literals for such strings\. The format of +this file is specified in the \fBcustom-literals\.xsd\fR XML Schema file that +can be found in the documentation directory\. +.IP "\fB--preserve-anonymous\fR" +Preserve anonymous types\. By default anonymous types are automatically named +with names derived from the enclosing elements/attributes\. Because mappings +implemented by this compiler require all types to be named, this option is +only useful if you want to make sure your schemas don't have anonymous types\. +.IP "\fB--show-anonymous\fR" +Show elements and attributes that are of anonymous types\. This option only +makes sense together with the \fB--preserve-anonymous\fR option\. +.IP "\fB--anonymous-regex\fR \fIregex\fR" +Add \fIregex\fR to the list of regular expressions used to derive names for +anonymous types from the enclosing attributes/elements\. \fIregex\fR is a +Perl-like regular expression in the form +\fB/\fR\fIpattern\fR\fB/\fR\fIreplacement\fR\fB/\fR\fR\. Any character can be +used as a delimiter instead of '\fB/\fR'\. Escaping of the delimiter character +in \fIpattern\fR or \fIreplacement\fR is not supported\. + +All the regular expressions are pushed into a stack with the last specified +expression considered first\. The first match that succeeds is used\. Regular +expressions are applied to a string in the form + +\fIfilename\fR \fInamespace\fR \fIxpath\fR\fR + +For instance: + +\fBhello\.xsd http://example\.com/hello element\fR + +\fBhello\.xsd http://example\.com/hello type/element\fR + +As an example, the following expression makes all the derived names start with +capital letters\. This could be useful when your naming convention requires +type names to start with capital letters: + +\fB%\.* \.* (\.+/)*(\.+)%\eu$2%\fR + +See also the REGEX AND SHELL QUOTING section below\. +.IP "\fB--anonymous-regex-trace\fR" +Trace the process of applying regular expressions specified with the +\fB--anonymous-regex\fR option\. Use this option to find out why your regular +expressions don't do what you expected them to do\. +.IP "\fB--location-map\fR \fIol\fR=\fInl\fR" +Map the original schema location \fIol\fR that is specified in the XML Schema +include or import elements to new schema location \fInl\fR\. Repeat this +option to map more than one schema location\. For example, the following +option maps the \fBhttp://example\.com/foo\.xsd\fR URL to the \fBfoo\.xsd\fR +local file\. + +\fB--location-map http://example\.com/foo\.xsd=foo\.xsd\fR +.IP "\fB--location-regex\fR \fIregex\fR" +Add \fIregex\fR to the list of regular expressions used to map schema +locations that are specified in the XML Schema include or import elements\. +\fIregex\fR is a Perl-like regular expression in the form +\fB/\fR\fIpattern\fR\fB/\fR\fIreplacement\fR\fB/\fR\fR\. Any character can be +used as a delimiter instead of '\fB/\fR'\. Escaping of the delimiter character +in \fIpattern\fR or \fIreplacement\fR is not supported\. All the regular +expressions are pushed into a stack with the last specified expression +considered first\. The first match that succeeds is used\. + +For example, the following expression maps URL locations in the form +\fBhttp://example\.com/foo/bar\.xsd\fR to local files in the form +\fBbar\.xsd\fR: + +\fB%http://\.+/(\.+)%$1%\fR + +See also the REGEX AND SHELL QUOTING section below\. +.IP "\fB--location-regex-trace\fR" +Trace the process of applying regular expressions specified with the +\fB--location-regex\fR option\. Use this option to find out why your regular +expressions don't do what you expected them to do\. +.IP "\fB--file-per-type\fR" +Generate a separate set of C++ files for each type defined in XML Schema\. +Note that in this mode you only need to compile the root schema(s) and the +code will be generated for all included and imported schemas\. This +compilation mode is primarily useful when some of your schemas cannot be +compiled separately or have cyclic dependencies which involve type +inheritance\. Other options related to this mode are: \fB--type-file-regex\fR, +\fB--schema-file-regex\fR, \fB--fat-type-file\fR, and \fB--file-list\fR\. +.IP "\fB--type-file-regex\fR \fIregex\fR" +Add \fIregex\fR to the list of regular expressions used to translate type +names to file names when the \fB--file-per-type\fR option is specified\. +\fIregex\fR is a Perl-like regular expression in the form +\fB/\fR\fIpattern\fR\fB/\fR\fIreplacement\fR\fB/\fR\fR\. Any character can be +used as a delimiter instead of '\fB/\fR'\. Escaping of the delimiter character +in \fIpattern\fR or \fIreplacement\fR is not supported\. All the regular +expressions are pushed into a stack with the last specified expression +considered first\. The first match that succeeds is used\. Regular expressions +are applied to a string in the form + +\fInamespace\fR \fItype-name\fR\fR + +For example, the following expression maps type \fBfoo\fR that is defined in +the \fBhttp://example\.com/bar\fR namespace to file name \fBbar-foo\fR: + +\fB%http://example\.com/(\.+) (\.+)%$1-$2%\fR + +See also the REGEX AND SHELL QUOTING section below\. +.IP "\fB--type-file-regex-trace\fR" +Trace the process of applying regular expressions specified with the +\fB--type-file-regex\fR option\. Use this option to find out why your regular +expressions don't do what you expected them to do\. +.IP "\fB--schema-file-regex\fR \fIregex\fR" +Add \fIregex\fR to the list of regular expressions used to translate schema +file names when the \fB--file-per-type\fR option is specified\. \fIregex\fR is +a Perl-like regular expression in the form +\fB/\fR\fIpattern\fR\fB/\fR\fIreplacement\fR\fB/\fR\fR\. Any character can be +used as a delimiter instead of '\fB/\fR'\. Escaping of the delimiter character +in \fIpattern\fR or \fIreplacement\fR is not supported\. All the regular +expressions are pushed into a stack with the last specified expression +considered first\. The first match that succeeds is used\. Regular Expressions +are applied to the absolute filesystem path of a schema file and the result, +including the directory part, if any, is used to derive the \fB#include\fR +directive paths as well as the generated C++ file paths\. This option, along +with \fB--type-file-regex\fR are primarily useful to place the generated files +into subdirectories or to resolve file name conflicts\. + +For example, the following expression maps schema files in the +\fBfoo/1\.0\.0/\fR subdirectory to the files in the \fBfoo/\fR subdirectory\. +As a result, the \fB#include\fR directive paths for such schemas will be in +the \fBfoo/schema\.hxx\fR form and the generated C++ files will be placed into +the \fBfoo/\fR subdirectory: + +\fB%\.*/foo/1\.0\.0/(\.+)%foo/$1%\fR + +See also the REGEX AND SHELL QUOTING section below\. +.IP "\fB--schema-file-regex-trace\fR" +Trace the process of applying regular expressions specified with the +\fB--schema-file-regex\fR option\. Use this option to find out why your +regular expressions don't do what you expected them to do\. +.IP "\fB--fat-type-file\fR" +Generate code corresponding to global elements into type files instead of +schema files when the \fB--type-file-regex\fR option is specified\. This +option is primarily useful when trying to minimize the amount of object code +that is linked to an executable by packaging compiled generated code into a +static (archive) library\. +.IP "\fB--file-list\fR \fIfile\fR" +Write a list of generated C++ files to \fIfile\fR or to \fBstdout\fR if +\fIfile\fR is \fB-\fR\. This option is primarily useful in the file-per-type +compilation mode (\fB--file-per-type\fR) to create a list of generated C++ +files, for example, as a makefile fragment\. +.IP "\fB--file-list-only\fR" +Only write the list of C++ files that would be generated without actually +generating them\. This option only makes sense together with +\fB--file-list\fR\. +.IP "\fB--file-list-prologue\fR \fItext\fR" +Insert \fItext\fR at the beginning of the file list\. As a convenience, all +occurrences of the \fB\en\fR character sequence in \fItext\fR are replaced +with new lines\. This option can, for example, be used to assign the generated +file list to a makefile variable\. +.IP "\fB--file-list-epilogue\fR \fItext\fR" +Insert \fItext\fR at the end of the file list\. As a convenience, all +occurrences of the \fB\en\fR character sequence in \fItext\fR are replaced +with new lines\. +.IP "\fB--file-list-delim\fR \fItext\fR" +Delimit file names written to the file list with \fItext\fR instead of new +lines\. As a convenience, all occurrences of the \fB\en\fR character sequence +in \fItext\fR are replaced with new lines\. +.\" +.\" C++/Tree options. +.\" +.SS cxx-tree command options +.IP "\fB--generate-polymorphic\fR" +Generate polymorphism-aware code\. Specify this option if you use substitution +groups or \fBxsi:type\fR\. Use the \fB--polymorphic-type\fR or +\fB--polymorphic-type-all\fR option to specify which type hierarchies are +polymorphic\. +.IP "\fB--polymorphic-type\fR \fItype\fR" +Indicate that \fItype\fR is a root of a polymorphic type hierarchy\. The +compiler can often automatically determine which types are polymorphic based +on the substitution group declarations\. However, you may need to use this +option if you are not using substitution groups or if substitution groups are +defined in another schema\. You need to specify this option when compiling +every schema file that references \fItype\fR\. The \fItype\fR argument is an +XML Schema type name that can be optionally qualified with a namespace in the +\fInamespace\fR\fB#\fR\fIname\fR\fR form\. +.IP "\fB--polymorphic-type-all\fR" +Indicate that all types should be treated as polymorphic\. +.IP "\fB--polymorphic-plate\fR \fInum\fR" +Specify the polymorphic map plate the generated code should register on\. This +functionality is primarily useful to segregate multiple schemas that define +the same polymorphic types\. +.IP "\fB--ordered-type\fR \fItype\fR" +Indicate that element order in \fItype\fR is significant\. An example would be +a complex type with unbounded choice as a content model where the element +order in XML has application-specific semantics\. For ordered types the +compiler generates a special container data member and a corresponding set of +accessors and modifiers that are used to capture the order of elements and, +for mixed content, of text\. + +The \fItype\fR argument is an XML Schema type name that can be optionally +qualified with a namespace in the \fInamespace\fR\fB#\fR\fIname\fR\fR form\. +Note also that you will need to specify this option when compiling every +schema file that has other ordered types derived from this type\. +.IP "\fB--ordered-type-derived\fR" +Automatically treat types derived from ordered bases as also ordered\. This is +primarily useful if you would like to be able to iterate over the complete +content using the content order container\. +.IP "\fB--ordered-type-mixed\fR" +Automatically treat complex types with mixed content as ordered\. +.IP "\fB--ordered-type-all\fR" +Indicate that element order in all types is significant\. +.IP "\fB--order-container\fR \fItype\fR" +Specify a custom class template that should be used as a container for the +content order in ordered types instead of the default \fBstd::vector\fR\. See +\fB--ordered-type\fR for more information on ordered type\. This option is +primarily useful if you need to perform more complex lookups in the content +order container, for example by element id\. In this case, a container like +Boost multi-index may be more convenient\. Note that if using a custom +container, you will also most likely need to include the relevant headers +using the \fB--hxx-prologue*\fR options\. +.IP "\fB--generate-serialization\fR" +Generate serialization functions\. Serialization functions convert the object +model back to XML\. +.IP "\fB--generate-ostream\fR" +Generate ostream insertion operators (\fBoperator<<\fR) for generated types\. +This allows one to easily print a fragment or the whole object model for +debugging or logging\. +.IP "\fB--generate-doxygen\fR" +Generate documentation comments suitable for extraction by the Doxygen +documentation system\. Documentation from annotations is added to the comments +if present in the schema\. +.IP "\fB--generate-comparison\fR" +Generate comparison operators (\fBoperator==\fR and \fBoperator!=\fR) for +complex types\. Comparison is performed member-wise\. +.IP "\fB--generate-default-ctor\fR" +Generate default constructors even for types that have required members\. +Required members of an instance constructed using such a constructor are not +initialized and accessing them results in undefined behavior\. +.IP "\fB--generate-from-base-ctor\fR" +Generate constructors that expect an instance of a base type followed by all +required members\. +.IP "\fB--suppress-assignment\fR" +Suppress the generation of copy assignment operators for complex types\. If +this option is specified, the copy assignment operators for such types are +declared private and left unimplemented\. +.IP "\fB--generate-detach\fR" +Generate detach functions for required elements and attributes\. Detach +functions for optional and sequence cardinalities are provided by the +respective containers\. These functions, for example, allow you to move +sub-trees in the object model either within the same tree or between different +trees\. +.IP "\fB--generate-wildcard\fR" +Generate accessors and modifiers as well as parsing and serialization code for +XML Schema wildcards (\fBany\fR and \fBanyAttribute\fR)\. XML content matched +by wildcards is presented as DOM fragments\. Note that you need to initialize +the Xerces-C++ runtime if you are using this option\. +.IP "\fB--generate-any-type\fR" +Extract and store content of the XML Schema \fBanyType\fR type as a DOM +fragment\. Note that you need to initialize the Xerces-C++ runtime if you are +using this option\. +.IP "\fB--generate-insertion\fR \fIos\fR" +Generate data representation stream insertion operators for the \fIos\fR +output stream type\. Repeat this option to specify more than one stream type\. +The ACE CDR stream (\fBACE_OutputCDR\fR) and RPC XDR are recognized by the +compiler and the necessary \fB#include\fR directives are automatically +generated\. For custom stream types use the \fB--hxx-prologue*\fR options to +provide the necessary declarations\. +.IP "\fB--generate-extraction\fR \fIis\fR" +Generate data representation stream extraction constructors for the \fIis\fR +input stream type\. Repeat this option to specify more than one stream type\. +The ACE CDR stream (\fBACE_InputCDR\fR) and RPC XDR are recognized by the +compiler and the necessary \fB#include\fR directives are automatically +generated\. For custom stream types use the \fB--hxx-prologue*\fR options to +provide the necessary declarations\. +.IP "\fB--generate-forward\fR" +Generate a separate header file with forward declarations for the types being +generated\. +.IP "\fB--suppress-parsing\fR" +Suppress the generation of the parsing functions and constructors\. Use this +option to reduce the generated code size when parsing from XML is not needed\. +.IP "\fB--generate-element-type\fR" +Generate types instead of parsing and serialization functions for root +elements\. This is primarily useful to distinguish object models with the same +root type but with different root elements\. +.IP "\fB--generate-element-map\fR" +Generate a root element map that allows uniform parsing and serialization of +multiple root elements\. This option is only valid together with +\fB--generate-element-type\fR\. +.IP "\fB--generate-intellisense\fR" +Generate workarounds for IntelliSense bugs in Visual Studio 2005 (8\.0)\. When +this option is used, the resulting code is slightly more verbose\. +IntelliSense in Visual Studio 2008 (9\.0) and later does not require these +workarounds\. Support for IntelliSense in Visual Studio 2003 (7\.1) is +improved with this option but is still incomplete\. +.IP "\fB--omit-default-attributes\fR" +Omit attributes with default and fixed values from serialized XML documents\. +.IP "\fB--type-naming\fR \fIstyle\fR" +Specify the type naming convention that should be used in the generated code\. +Valid styles are \fBknr\fR (default), \fBucc\fR, and \fBjava\fR\. See the +NAMING CONVENTION section below for more information\. +.IP "\fB--function-naming\fR \fIstyle\fR" +Specify the function naming convention that should be used in the generated +code\. Valid styles are \fBknr\fR (default), \fBlcc\fR, \fBucc\fR, and +\fBjava\fR\. See the NAMING CONVENTION section below for more information\. +.IP "\fB--type-regex\fR \fIregex\fR" +Add \fIregex\fR to the list of regular expressions used to translate XML +Schema type names to C++ type names\. See the NAMING CONVENTION section below +for more information\. +.IP "\fB--accessor-regex\fR \fIregex\fR" +Add \fIregex\fR to the list of regular expressions used to translate XML +Schema names of elements/attributes to C++ accessor function names\. See the +NAMING CONVENTION section below for more information\. +.IP "\fB--one-accessor-regex\fR \fIregex\fR" +Add \fIregex\fR to the list of regular expressions used to translate XML +Schema names of elements/attributes with cardinality one to C++ accessor +function names\. See the NAMING CONVENTION section below for more +information\. +.IP "\fB--opt-accessor-regex\fR \fIregex\fR" +Add \fIregex\fR to the list of regular expressions used to translate XML +Schema names of elements/attributes with cardinality optional to C++ accessor +function names\. See the NAMING CONVENTION section below for more +information\. +.IP "\fB--seq-accessor-regex\fR \fIregex\fR" +Add \fIregex\fR to the list of regular expressions used to translate XML +Schema names of elements/attributes with cardinality sequence to C++ accessor +function names\. See the NAMING CONVENTION section below for more +information\. +.IP "\fB--modifier-regex\fR \fIregex\fR" +Add \fIregex\fR to the list of regular expressions used to translate XML +Schema names of elements/attributes to C++ modifier function names\. See the +NAMING CONVENTION section below for more information\. +.IP "\fB--one-modifier-regex\fR \fIregex\fR" +Add \fIregex\fR to the list of regular expressions used to translate XML +Schema names of elements/attributes with cardinality one to C++ modifier +function names\. See the NAMING CONVENTION section below for more +information\. +.IP "\fB--opt-modifier-regex\fR \fIregex\fR" +Add \fIregex\fR to the list of regular expressions used to translate XML +Schema names of elements/attributes with cardinality optional to C++ modifier +function names\. See the NAMING CONVENTION section below for more +information\. +.IP "\fB--seq-modifier-regex\fR \fIregex\fR" +Add \fIregex\fR to the list of regular expressions used to translate XML +Schema names of elements/attributes with cardinality sequence to C++ modifier +function names\. See the NAMING CONVENTION section below for more +information\. +.IP "\fB--parser-regex\fR \fIregex\fR" +Add \fIregex\fR to the list of regular expressions used to translate XML +Schema element names to C++ parsing function names\. See the NAMING CONVENTION +section below for more information\. +.IP "\fB--serializer-regex\fR \fIregex\fR" +Add \fIregex\fR to the list of regular expressions used to translate XML +Schema element names to C++ serialization function names\. See the NAMING +CONVENTION section below for more information\. +.IP "\fB--const-regex\fR \fIregex\fR" +Add \fIregex\fR to the list of regular expressions used to translate XML +Schema-derived names to C++ constant names\. See the NAMING CONVENTION section +below for more information\. +.IP "\fB--enumerator-regex\fR \fIregex\fR" +Add \fIregex\fR to the list of regular expressions used to translate XML +Schema enumeration values to C++ enumerator names\. See the NAMING CONVENTION +section below for more information\. +.IP "\fB--element-type-regex\fR \fIregex\fR" +Add \fIregex\fR to the list of regular expressions used to translate XML +Schema element names to C++ element type names\. See the NAMING CONVENTION +section below for more information\. +.IP "\fB--name-regex-trace\fR" +Trace the process of applying regular expressions specified with the name +transformation options\. Use this option to find out why your regular +expressions don't do what you expected them to do\. +.IP "\fB--root-element-first\fR" +Treat only the first global element as a document root\. By default all global +elements are considered document roots\. +.IP "\fB--root-element-last\fR" +Treat only the last global element as a document root\. By default all global +elements are considered document roots\. +.IP "\fB--root-element-all\fR" +Treat all global elements as document roots\. This is the default behavior\. +By explicitly specifying this option you can suppress the warning that is +issued if more than one global element is defined\. +.IP "\fB--root-element-none\fR" +Do not treat any global elements as document roots\. By default all global +elements are considered document roots\. +.IP "\fB--root-element\fR \fIelement\fR" +Treat only \fIelement\fR as a document root\. Repeat this option to specify +more than one root element\. +.IP "\fB--custom-type\fR \fImap\fR" +Use a custom C++ type instead of the generated class\. The \fImap\fR argument +is in the form \fIname\fR[\fB=\fR\fItype\fR[\fB/\fR\fIbase\fR]]\fR, where +\fIname\fR is a type name as defined in XML Schema and \fItype\fR is a C++ +type name that should be used instead\. If \fItype\fR is not present or empty +then the custom type is assumed to have the same name and be defined in the +same namespace as the generated class would have\. If \fIbase\fR is specified +then the generated class is still generated but with that name\. +.IP "\fB--custom-type-regex\fR \fIregex\fR" +Use custom C++ types instead of the generated classes\. The \fIregex\fR +argument is in the form +\fB/\fR\fIname-pat\fR\fB/\fR[\fItype-sub\fR\fB/\fR[\fIbase-sub\fR\fB/\fR]]\fR, +where \fIname-pat\fR is a regex pattern that will be matched against type +names as defined in XML Schema and \fItype-sub\fR is a C++ type name +substitution that should be used instead\. If \fItype-sub\fR is not present or +its substitution results in an empty string then the custom type is assumed to +have the same name and be defined in the same namespace as the generated class +would have\. If \fIbase-sub\fR is present and its substitution results in a +non-empty string then the generated class is still generated but with the +result of this substitution as its name\. The pattern and substitutions are in +the Perl regular expression format\. See also the REGEX AND SHELL QUOTING +section below\. +.IP "\fB--parts\fR \fInum\fR" +Split generated source code into \fInum\fR parts\. This is useful when +translating large, monolithic schemas and a C++ compiler is not able to +compile the resulting source code at once (usually due to insufficient +memory)\. +.IP "\fB--parts-suffix\fR \fIsuffix\fR" +Use \fIsuffix\fR instead of the default '\fB-\fR' to separate the file name +from the part number\. +\" +\" C++/Parser +\" +.SS cxx-parser command options +.IP "\fB--type-map\fR \fImapfile\fR" +Read XML Schema to C++ type mapping information from \fImapfile\fR\. Repeat +this option to specify several type maps\. Type maps are considered in order +of appearance and the first match is used\. By default all user-defined types +are mapped to \fBvoid\fR\. See the TYPE MAP section below for more +information\. +.IP "\fB--xml-parser\fR \fIparser\fR" +Use \fIparser\fR as the underlying XML parser\. Valid values are \fBxerces\fR +for Xerces-C++ (default) and \fBexpat\fR for Expat\. +.IP "\fB--generate-validation\fR" +Generate validation code\. The validation code ("perfect parser") ensures that +instance documents conform to the schema\. Validation code is generated by +default when the selected underlying XML parser is non-validating +(\fBexpat\fR)\. +.IP "\fB--suppress-validation\fR" +Suppress the generation of validation code\. Validation is suppressed by +default when the selected underlying XML parser is validating (\fBxerces\fR)\. +.IP "\fB--generate-polymorphic\fR" +Generate polymorphism-aware code\. Specify this option if you use substitution +groups or \fBxsi:type\fR\. +.IP "\fB--generate-noop-impl\fR" +Generate a sample parser implementation that does nothing (no operation)\. The +sample implementation can then be filled with the application-specific code\. +For an input file in the form \fBname\.xsd\fR this option triggers the +generation of two additional C++ files in the form: \fBname-pimpl\.hxx\fR +(parser implementation header file) and \fBname-pimpl\.cxx\fR (parser +implementation source file)\. +.IP "\fB--generate-print-impl\fR" +Generate a sample parser implementation that prints the XML data to +STDOUT\fR\. For an input file in the form \fBname\.xsd\fR this option triggers +the generation of two additional C++ files in the form: \fBname-pimpl\.hxx\fR +(parser implementation header file) and \fBname-pimpl\.cxx\fR (parser +implementation source file)\. +.IP "\fB--generate-test-driver\fR" +Generate a test driver for the sample parser implementation\. For an input +file in the form \fBname\.xsd\fR this option triggers the generation of an +additional C++ file in the form \fBname-driver\.cxx\fR\. +.IP "\fB--force-overwrite\fR" +Force overwriting of the existing implementation and test driver files\. Use +this option only if you do not mind loosing the changes you have made in the +sample implementation or test driver files\. +.IP "\fB--root-element-first\fR" +Indicate that the first global element is the document root\. This information +is used to generate the test driver for the sample implementation\. +.IP "\fB--root-element-last\fR" +Indicate that the last global element is the document root\. This information +is used to generate the test driver for the sample implementation\. +.IP "\fB--root-element\fR \fIelement\fR" +Indicate that \fIelement\fR is the document root\. This information is used to +generate the test driver for the sample implementation\. +.IP "\fB--skel-type-suffix\fR \fIsuffix\fR" +Use the provided \fIsuffix\fR instead of the default \fB_pskel\fR to construct +the names of the generated parser skeletons\. +.IP "\fB--skel-file-suffix\fR \fIsuffix\fR" +Use the provided \fIsuffix\fR instead of the default \fB-pskel\fR to construct +the names of the generated parser skeleton files\. +.IP "\fB--impl-type-suffix\fR \fIsuffix\fR" +Use the provided \fIsuffix\fR instead of the default \fB_pimpl\fR to construct +the names of the parser implementations for the built-in XML Schema types as +well as sample parser implementations\. +.IP "\fB--impl-file-suffix\fR \fIsuffix\fR" +Use the provided \fIsuffix\fR instead of the default \fB-pimpl\fR to construct +the names of the generated sample parser implementation files\. +\" +\" NAMING CONVENTION +\" + +.SH NAMING CONVENTION +The compiler can be instructed to use a particular naming convention in +the generated code. A number of widely-used conventions can be selected +using the +.B --type-naming +and +.B --function-naming +options. A custom naming convention can be achieved using the +.BR --type-regex , +.BR --accessor-regex , +.BR --one-accessor-regex , +.BR --opt-accessor-regex , +.BR --seq-accessor-regex , +.BR --modifier-regex , +.BR --one-modifier-regex , +.BR --opt-modifier-regex , +.BR --seq-modifier-regex , +.BR --parser-regex , +.BR --serializer-regex , +.BR --const-regex , +.BR --enumerator-regex , +and +.B --element-type-regex +options. + +The +.B --type-naming +option specifies the convention that should be used for naming C++ types. +Possible values for this option are +.B knr +(default), +.BR ucc , +and +.BR java . +The +.B knr +value (stands for K&R) signifies the standard, lower-case naming convention +with the underscore used as a word delimiter, for example: foo, foo_bar. +The +.B ucc +(stands for upper-camel-case) and +.B java +values a synonyms for the same naming convention where the first letter +of each word in the name is capitalized, for example: Foo, FooBar. + +Similarly, the +.B --function-naming +option specifies the convention that should be used for naming C++ functions. +Possible values for this option are +.B knr +(default), +.BR lcc , +and +.BR java . +The +.B knr +value (stands for K&R) signifies the standard, lower-case naming convention +with the underscore used as a word delimiter, for example: foo(), foo_bar(). +The +.B lcc +value (stands for lower-camel-case) signifies a naming convention where the +first letter of each word except the first is capitalized, for example: foo(), +fooBar(). The +.B ucc +value (stands for upper-camel-case) signifies a naming convention where the +first letter of each word is capitalized, for example: Foo(), FooBar(). The +.B java +naming convention is similar to the lower-camel-case one except that accessor +functions are prefixed with get, modifier functions are prefixed with set, +parsing functions are prefixed with parse, and serialization functions are +prefixed with serialize, for example: getFoo(), setFooBar(), parseRoot(), +serializeRoot(). + +Note that the naming conventions specified with the +.B --type-naming +and +.B --function-naming +options perform only limited transformations on the +names that come from the schema in the form of type, attribute, and element +names. In other words, to get consistent results, your schemas should follow +a similar naming convention as the one you would like to have in the generated +code. Alternatively, you can use the +.B --*-regex +options (discussed below) to perform further transformations on the names +that come from the schema. + +The +.BR --type-regex , +.BR --accessor-regex , +.BR --one-accessor-regex , +.BR --opt-accessor-regex , +.BR --seq-accessor-regex , +.BR --modifier-regex , +.BR --one-modifier-regex , +.BR --opt-modifier-regex , +.BR --seq-modifier-regex , +.BR --parser-regex , +.BR --serializer-regex , +.BR --const-regex , +.BR --enumerator-regex , +and +.B --element-type-regex +options allow you to specify extra regular expressions for each name +category in addition to the predefined set that is added depending on +the +.B --type-naming +and +.B --function-naming +options. Expressions that are provided with the +.B --*-regex +options are evaluated prior to any predefined expressions. This allows +you to selectively override some or all of the predefined transformations. +When debugging your own expressions, it is often useful to see which +expressions match which names. The +.B --name-regex-trace +option allows you to trace the process of applying +regular expressions to names. + +The value for the +.B --*-regex +options should be a perl-like regular expression in the form +.BI / pattern / replacement /\fR. +Any character can be used as a delimiter instead of +.BR / . +Escaping of the delimiter character in +.I pattern +or +.I replacement +is not supported. All the regular expressions for each category are pushed +into a category-specific stack with the last specified expression +considered first. The first match that succeeds is used. For the +.B --one-accessor-regex +(accessors with cardinality one), +.B --opt-accessor-regex +(accessors with cardinality optional), and +.B --seq-accessor-regex +(accessors with cardinality sequence) categories the +.B --accessor-regex +expressions are used as a fallback. For the +.BR --one-modifier-regex , +.BR --opt-modifier-regex , +and +.B --seq-modifier-regex +categories the +.B --modifier-regex +expressions are used as a fallback. For the +.B --element-type-regex +category the +.B --type-regex +expressions are used as a fallback. + +The type name expressions +.RB ( --type-regex ) +are evaluated on the name string that has the following format: + +[\fInamespace \fR]\fIname\fR[\fB,\fIname\fR][\fB,\fIname\fR][\fB,\fIname\fR] + +The element type name expressions +.RB ( --element-type-regex ), +effective only when the +.B --generate-element-type +option is specified, are evaluated on the name string that has the following +format: + +.I namespace name + +In the type name format the +.I namespace +part followed by a space is only present for global type names. For global +types and elements defined in schemas without a target namespace, the +.I namespace +part is empty but the space is still present. In the type name format after +the initial +.I name +component, up to three additional +.I name +components can be present, separated by commas. For example: + +.B http://example.com/hello type + +.B foo + +.B foo,iterator + +.B foo,const,iterator + +The following set of predefined regular expressions is used to transform +type names when the upper-camel-case naming convention is selected: + +.B /(?:[^ ]* )?([^,]+)/\\\\u$1/ + +.B /(?:[^ ]* )?([^,]+),([^,]+)/\\\\u$1\\\\u$2/ + +.B /(?:[^ ]* )?([^,]+),([^,]+),([^,]+)/\\\\u$1\\\\u$2\\\\u$3/ + +.B /(?:[^ ]* )?([^,]+),([^,]+),([^,]+),([^,]+)/\\\\u$1\\\\u$2\\\\u$3\\\\u$4/ + +The accessor and modifier expressions +.RB ( --*accessor-regex +and +.BR --*modifier-regex ) +are evaluated on the name string that has the following format: + +\fIname\fR[\fB,\fIname\fR][\fB,\fIname\fR] + +After the initial +.I name +component, up to two additional +.I name +components can be present, separated by commas. For example: + +.B foo + +.B dom,document + +.B foo,default,value + +The following set of predefined regular expressions is used to transform +accessor names when the +.B java +naming convention is selected: + +.B /([^,]+)/get\\\\u$1/ + +.B /([^,]+),([^,]+)/get\\\\u$1\\\\u$2/ + +.B /([^,]+),([^,]+),([^,]+)/get\\\\u$1\\\\u$2\\\\u$3/ + +For the parser, serializer, and enumerator categories, the corresponding +regular expressions are evaluated on local names of elements and on +enumeration values, respectively. For example, the following predefined +regular expression is used to transform parsing function names when the +.B java +naming convention is selected: + +.B /(.+)/parse\\\\u$1/ + +The const category is used to create C++ constant names for the +element/wildcard/text content ids in ordered types. + +See also the REGEX AND SHELL QUOTING section below. + +\" +\" TYPE MAP +\" +.SH TYPE MAP +Type map files are used in C++/Parser to define a mapping between XML +Schema and C++ types. The compiler uses this information to determine +the return types of +.B post_* +functions in parser skeletons corresponding to XML Schema types +as well as argument types for callbacks corresponding to elements +and attributes of these types. + +The compiler has a set of predefined mapping rules that map built-in +XML Schema types to suitable C++ types (discussed below) and all +other types to +.BR void . +By providing your own type maps you can override these predefined rules. +The format of the type map file is presented below: + +.RS +.B namespace +.I schema-namespace +[ +.I cxx-namespace +] +.br +.B { +.br + ( +.B include +.IB file-name ; +)* +.br + ([ +.B type +] +.I schema-type cxx-ret-type +[ +.I cxx-arg-type +.RB ] ; +)* +.br +.B } +.br +.RE + +Both +.I schema-namespace +and +.I schema-type +are regex patterns while +.IR cxx-namespace , +.IR cxx-ret-type , +and +.I cxx-arg-type +are regex pattern substitutions. All names can be optionally enclosed +in \fR" "\fR, for example, to include white-spaces. + +.I schema-namespace +determines XML Schema namespace. Optional +.I cxx-namespace +is prefixed to every C++ type name in this namespace declaration. +.I cxx-ret-type +is a C++ type name that is used as a return type for the +.B post_* +functions. Optional +.I cxx-arg-type +is an argument type for callback functions corresponding to elements and +attributes of this type. If +.I cxx-arg-type +is not specified, it defaults to +.I cxx-ret-type +if +.I cxx-ret-type +ends with +.B * +or +.B & +(that is, it is a pointer or a reference) and +.B const +\fIcxx-ret-type\fB&\fR otherwise. +.I file-name +is a file name either in the \fR" "\fR or < > format and is added with the +.B #include +directive to the generated code. + +The \fB#\fR character starts a comment that ends with a new line or end of +file. To specify a name that contains \fB#\fR enclose it in \fR" "\fR. For +example: + +.RS +namespace http://www.example.com/xmlns/my my +.br +{ +.br + include "my.hxx"; +.br + + # Pass apples by value. + # + apple apple; +.br + + # Pass oranges as pointers. + # + orange orange_t*; +.br +} +.br +.RE + +In the example above, for the +.B http://www.example.com/xmlns/my#orange +XML Schema type, the +.B my::orange_t* +C++ type will be used as both return and argument types. + +Several namespace declarations can be specified in a single file. +The namespace declaration can also be completely omitted to map +types in a schema without a namespace. For instance: + +.RS +include "my.hxx"; +.br +apple apple; +.br + +namespace http://www.example.com/xmlns/my +.br +{ +.br + orange "const orange_t*"; +.br +} +.br +.RE + +The compiler has a number of predefined mapping rules that can be +presented as the following map files. The string-based XML Schema +built-in types are mapped to either +.B std::string +or +.B std::wstring +depending on the character type selected with the +.B --char-type +option +.RB ( char +by default). The binary XML Schema types are mapped to either +.B std::unique_ptr +or +.B std::auto_ptr +depending on the C++ standard selected with the +.B --std +option +.RB ( c++11 +by default). + +.RS +namespace http://www.w3.org/2001/XMLSchema +.br +{ +.br + boolean bool bool; +.br + + byte "signed char" "signed char"; +.br + unsignedByte "unsigned char" "unsigned char"; +.br + + short short short; +.br + unsignedShort "unsigned short" "unsigned short"; +.br + + int int int; +.br + unsignedInt "unsigned int" "unsigned int"; +.br + + long "long long" "long long"; +.br + unsignedLong "unsigned long long" "unsigned long long"; +.br + + integer "long long" "long long"; +.br + + negativeInteger "long long" "long long"; +.br + nonPositiveInteger "long long" "long long"; +.br + + positiveInteger "unsigned long long" "unsigned long long"; +.br + nonNegativeInteger "unsigned long long" "unsigned long long"; +.br + + float float float; +.br + double double double; +.br + decimal double double; +.br + + string std::string; +.br + normalizedString std::string; +.br + token std::string; +.br + Name std::string; +.br + NMTOKEN std::string; +.br + NCName std::string; +.br + ID std::string; +.br + IDREF std::string; +.br + language std::string; +.br + anyURI std::string; +.br + + NMTOKENS xml_schema::string_sequence; +.br + IDREFS xml_schema::string_sequence; +.br + + QName xml_schema::qname; +.br + + base64Binary std::[unique|auto]_ptr +.br + std::[unique|auto]_ptr; +.br + hexBinary std::[unique|auto]_ptr +.br + std::[unique|auto]_ptr; +.br + + date xml_schema::date; +.br + dateTime xml_schema::date_time; +.br + duration xml_schema::duration; +.br + gDay xml_schema::gday; +.br + gMonth xml_schema::gmonth; +.br + gMonthDay xml_schema::gmonth_day; +.br + gYear xml_schema::gyear; +.br + gYearMonth xml_schema::gyear_month; +.br + time xml_schema::time; +.br +} +.br +.RE + + +The last predefined rule maps anything that wasn't mapped by previous +rules to +.BR void : + +.RS +namespace .* +.br +{ +.br + .* void void; +.br +} +.br +.RE + +When you provide your own type maps with the +.B --type-map +option, they are evaluated first. This allows you to selectively override +predefined rules. + +.\" +.\" REGEX AND SHELL QUOTING +.\" +.SH REGEX AND SHELL QUOTING +When entering a regular expression argument in the shell command line +it is often necessary to use quoting (enclosing the argument in " " +or ' ') in order to prevent the shell from interpreting certain +characters, for example, spaces as argument separators and $ as +variable expansions. + +Unfortunately it is hard to achieve this in a manner that is portable +across POSIX shells, such as those found on GNU/Linux and UNIX, and +Windows shell. For example, if you use " " for quoting you will get +a wrong result with POSIX shells if your expression contains $. The +standard way of dealing with this on POSIX systems is to use ' ' +instead. Unfortunately, Windows shell does not remove ' ' from +arguments when they are passed to applications. As a result you may +have to use ' ' for POSIX and " " for Windows ($ is not treated as +a special character on Windows). + +Alternatively, you can save regular expression options into a file, +one option per line, and use this file with the +.B --options-file +option. With this approach you don't need to worry about shell quoting. + +.\" +.\" DIAGNOSTICS +.\" +.SH DIAGNOSTICS +If the input file is not a valid W3C XML Schema definition, +.B xsd +will issue diagnostic messages to +.B STDERR +and exit with non-zero exit code. +.SH BUGS +Send bug reports to the xsd-users@codesynthesis.com mailing list. +.SH COPYRIGHT +Copyright (c) 2005-2023 Code Synthesis. + +Permission is granted to copy, distribute and/or modify this +document under the terms of the GNU Free Documentation License, +version 1.2; with no Invariant Sections, no Front-Cover Texts and +no Back-Cover Texts. Copy of the license can be obtained from +https://www.codesynthesis.com/licenses/fdl-1.2.txt diff --git a/doc/pregenerated/xsd.xhtml b/doc/pregenerated/xsd.xhtml new file mode 100644 index 0000000..26aa3e4 --- /dev/null +++ b/doc/pregenerated/xsd.xhtml @@ -0,0 +1,1621 @@ + + + + + + XSD 4.2.0 Compiler Command Line Manual + + + + + + + + + + + + +
+
+ +

NAME

+ +

xsd - W3C XML Schema to C++ Compiler

+ +

SYNOPSIS

+ +
+
xsd command [options] file [file ...]
+
xsd help [command]
+
xsd version
+
+ +

DESCRIPTION

+ +

xsd generates vocabulary-specific, statically-typed + C++ mapping from W3C XML Schema definitions. Particular mapping to + produce is selected by a command. Each mapping has + a number of mapping-specific options that should + appear, if any, after the command. Input files should + be W3C XML Schema definitions. The exact set of the generated files depends + on the selected mapping and options.

+ +

COMMANDS

+ +
+
cxx-tree
+
Generate the C++/Tree mapping. For each input file in the form + name.xsd the following C++ files are generated: + name.hxx (header file), + name.ixx (inline file, generated only if the + --generate-inline option is specified), + name.cxx (source file), and + name-fwd.hxx (forward declaration file, generated + only if the --generate-forward option is + specified).
+ +
cxx-parser
+
Generate the C++/Parser mapping. For each input file in the form + name.xsd the following C++ files are generated: + name-pskel.hxx (parser skeleton header file), + name-pskel.ixx (parser skeleton inline file, + generated only if the --generate-inline + option is specified), and + name-pskel.cxx (parser skeleton source file). + If the --generate-noop-impl or + --generate-print-impl option is specified, + the following additional sample implementation files are generated: + name-pimpl.hxx (parser implementation header + file) and + name-pimpl.cxx (parser implementation source + file). If the --generate-test-driver option + is specified, the additional name-driver.cxx + test driver file is generated.
+ +
help
+
Print usage information and exit. Use +

xsd help command

+ for command-specific help. +
+ +
version
+
Print version and exit.
+
+ +

OPTIONS

+ +

Command-specific options, if any, should appear + after the corresponding command.

+ +

COMMON OPTIONS

+
+
--std version
+
Specify the C++ standard that the generated code should conform to. + Valid values are c++98, c++11 + (default), c++14, c++17, + c++20, and c++23. + +

The C++ standard affects various aspects of the generated code that are + discussed in more detail in various mapping-specific documentation. + Overall, when C++11 is selected, the generated code relies on the move + semantics and uses std::unique_ptr instead of + deprecated std::auto_ptr. Currently, there is no + difference between the C++11 and the later standards modes.

+ +

When the C++11 mode is selected, you normally don't need to perform any + extra steps other than enable C++11 in your C++ compiler, if required. The + XSD compiler will automatically add the necessary macro defines to the + generated header files that will switch the header-only XSD runtime + library (libxsd) to the C++11 mode. However, if you + include any of the XSD runtime headers directly in your application + (normally you just include the generated headers), then you will need to + define the XSD_CXX11 macro for your entire + project.

+ +
--char-type type
+
Generate code using the provided character type + instead of the default char. Valid values are + char and wchar_t.
+ +
--char-encoding enc
+
Specify the character encoding that should be used in the generated + code. Valid values for the char character type are + utf8 (default), iso8859-1, + lcp (Xerces-C++ local code page), and + custom. If you pass custom as the + value then you will need to include the transcoder implementation header + for your encoding at the beginning of the generated header files (see the + --hxx-prologue option). + +

For the wchar_t character type the only valid value + is auto and the encoding is automatically selected + between UTF-16 and UTF-32/UCS-4, depending on the + wchar_t type size.

+ +
--output-dir dir
+
Write generated files to dir instead of the + current directory.
+ +
--generate-inline
+
Generate simple functions inline. This option triggers creation of the + inline file.
+ +
--generate-xml-schema
+
Generate a C++ header file as if the schema being compiled defines the + XML Schema namespace. For the C++/Tree mapping, the resulting file will + contain definitions for all XML Schema built-in types. For the C++/Parser + mapping, the resulting file will contain definitions for all the parser + skeletons and implementations corresponding to the XML Schema built-in + types. + +

The schema file provided to the compiler need not exist and is only + used to derive the name of the resulting header file. Use the + --extern-xml-schema option to include this file in the + generated files for other schemas.

+ +
--extern-xml-schema file
+
Include a header file derived from file instead of + generating the XML Schema namespace mapping inline. The provided file need + not exist and is only used to derive the name of the included header file. + Use the --generate-xml-schema option to generate this + header file.
+ +
--namespace-map xns=cns
+
Map XML Schema namespace xns to C++ namespace + cns. Repeat this option to specify mapping for more + than one XML Schema namespace. For example, the following option: + +

--namespace-map + http://example.com/foo/bar=foo::bar

+ +

Will map the http://example.com/foo/bar XML Schema + namespace to the foo::bar C++ namespace.

+ +
--namespace-regex regex
+
Add regex to the list of regular expressions used + to translate XML Schema namespace names to C++ namespace names. + regex is a Perl-like regular expression in the form + /pattern/replacement/. Any + character can be used as a delimiter instead of '/'. + Escaping of the delimiter character in pattern or + replacement is not supported. + +

All the regular expressions are pushed into a stack with the last + specified expression considered first. The first match that succeeds is + used. Regular expressions are applied to a string in the form

+ +

filename namespace

+ +

For example, if you have file hello.xsd with + namespace http://example.com/hello and you run + xsd on this file, then the string in question will + be:

+ +

hello.xsd. + http://example.com/hello

+ +

For the built-in XML Schema namespace the string is:

+ +

XMLSchema.xsd + http://www.w3.org/2001/XMLSchema

+ +

The following three steps are performed for each regular expression + until the match is found:

+ +

1. The expression is applied and if the result is empty the next + expression is considered.

+ +

2. All '/' are replaced with + '::'.

+ +

3. The result is verified to be a valid C++ scope name (e.g., + foo::bar). If this test succeeds, the result is used + as a C++ namespace name.

+ +

As an example, the following expression maps XML Schema namespaces in + the form http://example.com/foo/bar to C++ namespaces + in the form foo::bar:

+ +

%.* http://example.com/(.+)%$1%

+ +

See also the REGEX AND SHELL QUOTING section below.

+ +
--namespace-regex-trace
+
Trace the process of applying regular expressions specified with the + --namespace-regex option. Use this option to find out + why your regular expressions don't do what you expected them to do.
+ +
--reserved-name n[=r]
+
Add name n to the list of names that should not be + used as identifiers. The name can optionally be followed by + = and the replacement name r that + should be used instead. All the C++ keywords are already in this + list.
+ +
--include-with-brackets
+
Use angle brackets (<>) instead of quotes ("") in generated + #include directives.
+ +
--include-prefix prefix
+
Add prefix to generated + #include directive paths. + +

For example, if you had the following import element in your schema

+ +

<import namespace="..." + schemaLocation="base.xsd"/>

+ +

and compiled this fragment with --include-prefix + schemas/, then the include directive in the generated code + would be:

+ +

#include "schemas/base.hxx"

+ +
--include-regex regex
+
Add regex to the list of regular expressions used + to transform #include directive paths. + regex is a Perl-like regular expression in the form + /pattern/replacement/. Any + character can be used as a delimiter instead of '/'. + Escaping of the delimiter character in pattern or + replacement is not supported. + +

All the regular expressions are pushed into a stack with the last + specified expression considered first. The first match that succeeds is + used.

+ +

As an example, the following expression transforms paths in the form + schemas/foo/bar to paths in the form + generated/foo/bar:

+ +

%schemas/(.+)%generated/$1%

+ +

See also the REGEX AND SHELL QUOTING section below.

+ +
--include-regex-trace
+
Trace the process of applying regular expressions specified with the + --include-regex option. Use this option to find out + why your regular expressions don't do what you expected them to do.
+ +
--guard-prefix prefix
+
Add prefix to generated header inclusion guards. + The prefix is transformed to upper case and characters that are illegal in + a preprocessor macro name are replaced with underscores. If this option is + not specified then the directory part of the input schema file is used as + a prefix.
+ +
--hxx-suffix suffix
+
Use the provided suffix instead of the default + .hxx to construct the name of the header file. Note + that this suffix is also used to construct names of header files + corresponding to included/imported schemas.
+ +
--ixx-suffix suffix
+
Use the provided suffix instead of the default + .ixx to construct the name of the inline file.
+ +
--cxx-suffix suffix
+
Use the provided suffix instead of the default + .cxx to construct the name of the source file.
+ +
--fwd-suffix suffix
+
Use the provided suffix instead of the default + -fwd.hxx to construct the name of the forward + declaration file.
+ +
--hxx-regex regex
+
Use the provided expression to construct the name of the header file. + regex is a Perl-like regular expression in the form + /pattern/replacement/. + Note that this expression is also used to construct names of header files + corresponding to included/imported schemas. See also the REGEX AND SHELL + QUOTING section below.
+ +
--ixx-regex regex
+
Use the provided expression to construct the name of the inline file. + regex is a Perl-like regular expression in the form + /pattern/replacement/. See + also the REGEX AND SHELL QUOTING section below.
+ +
--cxx-regex regex
+
Use the provided expression to construct the name of the source file. + regex is a Perl-like regular expression in the form + /pattern/replacement/. See + also the REGEX AND SHELL QUOTING section below.
+ +
--fwd-regex regex
+
Use the provided expression to construct the name of the forward + declaration file. regex is a Perl-like regular + expression in the form + /pattern/replacement/. See + also the REGEX AND SHELL QUOTING section below.
+ +
--hxx-prologue text
+
Insert text at the beginning of the header + file.
+ +
--ixx-prologue text
+
Insert text at the beginning of the inline + file.
+ +
--cxx-prologue text
+
Insert text at the beginning of the source + file.
+ +
--fwd-prologue text
+
Insert text at the beginning of the forward + declaration file.
+ +
--prologue text
+
Insert text at the beginning of each generated + file for which there is no file-specific prologue.
+ +
--hxx-epilogue text
+
Insert text at the end of the header file.
+ +
--ixx-epilogue text
+
Insert text at the end of the inline file.
+ +
--cxx-epilogue text
+
Insert text at the end of the source file.
+ +
--fwd-epilogue text
+
Insert text at the end of the forward declaration + file.
+ +
--epilogue text
+
Insert text at the end of each generated file for + which there is no file-specific epilogue.
+ +
--hxx-prologue-file file
+
Insert the content of the file at the beginning of + the header file.
+ +
--ixx-prologue-file file
+
Insert the content of the file at the beginning of + the inline file.
+ +
--cxx-prologue-file file
+
Insert the content of the file at the beginning of + the source file.
+ +
--fwd-prologue-file file
+
Insert the content of the file at the beginning of + the forward declaration file.
+ +
--prologue-file file
+
Insert the content of the file at the beginning of + each generated file for which there is no file-specific prologue + file.
+ +
--hxx-epilogue-file file
+
Insert the content of the file at the end of the + header file.
+ +
--ixx-epilogue-file file
+
Insert the content of the file at the end of the + inline file.
+ +
--cxx-epilogue-file file
+
Insert the content of the file at the end of the + source file.
+ +
--fwd-epilogue-file file
+
Insert the content of the file at the end of the + forward declaration file.
+ +
--epilogue-file file
+
Insert the content of the file at the end of each + generated file for which there is no file-specific epilogue file.
+ +
--export-symbol symbol
+
Insert symbol in places where DLL export/import + control statements (__declspec(dllexport/dllimport)) + are necessary.
+ +
--export-xml-schema
+
Export/import types in the XML Schema namespace using the export + symbol provided with the --export-symbol option. The + XSD_NO_EXPORT macro can be used to omit this code + during C++ compilation, which may be useful if you would like to use the + same generated code across multiple platforms.
+ +
--export-maps
+
Export polymorphism support maps from a Win32 DLL into which this + generated code is placed. This is necessary when your type hierarchy is + split across several DLLs since otherwise each DLL will have its own set + of maps. In this situation the generated code for the DLL which contains + base types and/or substitution group heads should be compiled with this + option and the generated code for all other DLLs should be compiled with + --import-maps. This option is only valid together with + --generate-polymorphic. The + XSD_NO_EXPORT macro can be used to omit this code + during C++ compilation, which may be useful if you would like to use the + same generated code across multiple platforms.
+ +
--import-maps
+
Import polymorphism support maps to a Win32 DLL or executable into + which this generated code is linked. See the + --export-maps option documentation for details. This + options is only valid together with + --generate-polymorphic. The + XSD_NO_EXPORT macro can be used to omit this code + during C++ compilation, which may be useful if you would like to use the + same generated code across multiple platforms.
+ +
--generate-dep
+
Generate make dependency information. This option + triggers the creation of the .d file containing the + dependencies of the generated files on the main schema file as well as all + the schema files that it includes/imports, transitively. This dependency + file is then normally included into the main makefile + to implement automatic dependency tracking. See also the + --dep-* options. + +

Note also that automatic dependency generation is not supported in the + file-per-type mode (--file-per-type). In this case, + all the generated files are produced with a single compiler invocation and + depend on all the schemas. As a result, it is easier to establish such a + dependency manually, perhaps with the help of the + --file-list* options.

+ +
--generate-dep-only
+
Generate make dependency information only.
+ +
--dep-phony
+
Generate phony targets for included/imported schema files, causing + each to depend on nothing. Such dummy rules work around + make errors caused by the removal of schema files + without also updating the dependency file to match.
+ +
--dep-target target
+
Change the target of the dependency rule. By default it contains all + the generated C++ files as well as the dependency file itself, without any + directory prefixes. If you require multiple targets, then you can specify + them as a single, space-separated argument or you can repeat this option + multiple times.
+ +
--dep-suffix suffix
+
Use suffix instead of the default + .d to construct the name of the dependency file. See + also --dep-file.
+ +
--dep-file path
+
Use path as the generated dependency file path + instead of deriving it from the input file name. Write the dependency + information to stdout if path is + -. See also --dep-regex.
+ +
--dep-regex regex
+
Use the provided expression to construct the name of the dependency + file. regex is a Perl-like regular expression in the + form + /pattern/replacement/. See + also the REGEX AND SHELL QUOTING section below.
+ +
--disable-warning warn
+
Disable printing warning with id warn. If + all is specified for the warning id then all warnings + are disabled.
+ +
--options-file file
+
Read additional options from file. Each option + should appearing on a separate line optionally followed by space and an + option value. Empty lines and lines starting with # + are ignored. Option values can be enclosed in double + (") or single (') quotes to + preserve leading and trailing whitespaces as well as to specify empty + values. If the value itself contains trailing or leading quotes, enclose + it with an extra pair of quotes, for example '"x"'. + Non-leading and non-trailing quotes are interpreted as being part of the + option value. + +

The semantics of providing options in a file is equivalent to providing + the same set of options in the same order on the command line at the point + where the --options-file option is specified except + that the shell escaping and quoting is not required. You can repeat this + option to specify more than one options file.

+ +
--show-sloc
+
Show the number of generated physical source lines of code + (SLOC).
+ +
--sloc-limit num
+
Check that the number of generated physical source lines of code + (SLOC) does not exceed num.
+ +
--proprietary-license
+
Indicate that the generated code is licensed under a proprietary + license instead of the GPL.
+ +
--custom-literals file
+
Load custom XML string to C++ literal mappings from + file. This mechanism can be useful if you are using a + custom character encoding and some of the strings in your schemas, for + example element/attribute names or enumeration values, contain non-ASCII + characters. In this case you will need to provide a custom mapping to C++ + literals for such strings. The format of this file is specified in the + custom-literals.xsd XML Schema file that can be found + in the documentation directory.
+ +
--preserve-anonymous
+
Preserve anonymous types. By default anonymous types are automatically + named with names derived from the enclosing elements/attributes. Because + mappings implemented by this compiler require all types to be named, this + option is only useful if you want to make sure your schemas don't have + anonymous types.
+ +
--show-anonymous
+
Show elements and attributes that are of anonymous types. This option + only makes sense together with the + --preserve-anonymous option.
+ +
--anonymous-regex regex
+
Add regex to the list of regular expressions used + to derive names for anonymous types from the enclosing + attributes/elements. regex is a Perl-like regular + expression in the form + /pattern/replacement/. Any + character can be used as a delimiter instead of '/'. + Escaping of the delimiter character in pattern or + replacement is not supported. + +

All the regular expressions are pushed into a stack with the last + specified expression considered first. The first match that succeeds is + used. Regular expressions are applied to a string in the form

+ +

filename namespace + xpath

+ +

For instance:

+ +

hello.xsd http://example.com/hello + element

+ +

hello.xsd http://example.com/hello + type/element

+ +

As an example, the following expression makes all the derived names + start with capital letters. This could be useful when your naming + convention requires type names to start with capital letters:

+ +

%.* .* (.+/)*(.+)%\u$2%

+ +

See also the REGEX AND SHELL QUOTING section below.

+ +
--anonymous-regex-trace
+
Trace the process of applying regular expressions specified with the + --anonymous-regex option. Use this option to find out + why your regular expressions don't do what you expected them to do.
+ +
--location-map ol=nl
+
Map the original schema location ol that is + specified in the XML Schema include or import elements to new schema + location nl. Repeat this option to map more than one + schema location. For example, the following option maps the + http://example.com/foo.xsd URL to the + foo.xsd local file. + +

--location-map + http://example.com/foo.xsd=foo.xsd

+ +
--location-regex regex
+
Add regex to the list of regular expressions used + to map schema locations that are specified in the XML Schema include or + import elements. regex is a Perl-like regular + expression in the form + /pattern/replacement/. Any + character can be used as a delimiter instead of '/'. + Escaping of the delimiter character in pattern or + replacement is not supported. All the regular + expressions are pushed into a stack with the last specified expression + considered first. The first match that succeeds is used. + +

For example, the following expression maps URL locations in the form + http://example.com/foo/bar.xsd to local files in the + form bar.xsd:

+ +

%http://.+/(.+)%$1%

+ +

See also the REGEX AND SHELL QUOTING section below.

+ +
--location-regex-trace
+
Trace the process of applying regular expressions specified with the + --location-regex option. Use this option to find out + why your regular expressions don't do what you expected them to do.
+ +
--file-per-type
+
Generate a separate set of C++ files for each type defined in XML + Schema. Note that in this mode you only need to compile the root schema(s) + and the code will be generated for all included and imported schemas. This + compilation mode is primarily useful when some of your schemas cannot be + compiled separately or have cyclic dependencies which involve type + inheritance. Other options related to this mode are: + --type-file-regex, + --schema-file-regex, + --fat-type-file, and + --file-list.
+ +
--type-file-regex regex
+
Add regex to the list of regular expressions used + to translate type names to file names when the + --file-per-type option is specified. + regex is a Perl-like regular expression in the form + /pattern/replacement/. Any + character can be used as a delimiter instead of '/'. + Escaping of the delimiter character in pattern or + replacement is not supported. All the regular + expressions are pushed into a stack with the last specified expression + considered first. The first match that succeeds is used. Regular + expressions are applied to a string in the form + +

namespace type-name

+ +

For example, the following expression maps type foo + that is defined in the http://example.com/bar + namespace to file name bar-foo:

+ +

%http://example.com/(.+) + (.+)%$1-$2%

+ +

See also the REGEX AND SHELL QUOTING section below.

+ +
--type-file-regex-trace
+
Trace the process of applying regular expressions specified with the + --type-file-regex option. Use this option to find out + why your regular expressions don't do what you expected them to do.
+ +
--schema-file-regex regex
+
Add regex to the list of regular expressions used + to translate schema file names when the + --file-per-type option is specified. + regex is a Perl-like regular expression in the form + /pattern/replacement/. Any + character can be used as a delimiter instead of '/'. + Escaping of the delimiter character in pattern or + replacement is not supported. All the regular + expressions are pushed into a stack with the last specified expression + considered first. The first match that succeeds is used. Regular + Expressions are applied to the absolute filesystem path of a schema file + and the result, including the directory part, if any, is used to derive + the #include directive paths as well as the generated + C++ file paths. This option, along with + --type-file-regex are primarily useful to place the + generated files into subdirectories or to resolve file name conflicts. + +

For example, the following expression maps schema files in the + foo/1.0.0/ subdirectory to the files in the + foo/ subdirectory. As a result, the + #include directive paths for such schemas will be in + the foo/schema.hxx form and the generated C++ files + will be placed into the foo/ subdirectory:

+ +

%.*/foo/1.0.0/(.+)%foo/$1%

+ +

See also the REGEX AND SHELL QUOTING section below.

+ +
--schema-file-regex-trace
+
Trace the process of applying regular expressions specified with the + --schema-file-regex option. Use this option to find + out why your regular expressions don't do what you expected them to + do.
+ +
--fat-type-file
+
Generate code corresponding to global elements into type files instead + of schema files when the --type-file-regex option is + specified. This option is primarily useful when trying to minimize the + amount of object code that is linked to an executable by packaging + compiled generated code into a static (archive) library.
+ +
--file-list file
+
Write a list of generated C++ files to file or to + stdout if file is + -. This option is primarily useful in the + file-per-type compilation mode (--file-per-type) to + create a list of generated C++ files, for example, as a makefile + fragment.
+ +
--file-list-only
+
Only write the list of C++ files that would be generated without + actually generating them. This option only makes sense together with + --file-list.
+ +
--file-list-prologue text
+
Insert text at the beginning of the file list. As + a convenience, all occurrences of the \n character + sequence in text are replaced with new lines. This + option can, for example, be used to assign the generated file list to a + makefile variable.
+ +
--file-list-epilogue text
+
Insert text at the end of the file list. As a + convenience, all occurrences of the \n character + sequence in text are replaced with new lines.
+ +
--file-list-delim text
+
Delimit file names written to the file list with + text instead of new lines. As a convenience, all + occurrences of the \n character sequence in + text are replaced with new lines.
+
+ +

CXX-TREE COMMAND OPTIONS

+
+
--generate-polymorphic
+
Generate polymorphism-aware code. Specify this option if you use + substitution groups or xsi:type. Use the + --polymorphic-type or + --polymorphic-type-all option to specify which type + hierarchies are polymorphic.
+ +
--polymorphic-type type
+
Indicate that type is a root of a polymorphic type + hierarchy. The compiler can often automatically determine which types are + polymorphic based on the substitution group declarations. However, you may + need to use this option if you are not using substitution groups or if + substitution groups are defined in another schema. You need to specify + this option when compiling every schema file that references + type. The type argument is an XML + Schema type name that can be optionally qualified with a namespace in the + namespace#name form.
+ +
--polymorphic-type-all
+
Indicate that all types should be treated as polymorphic.
+ +
--polymorphic-plate num
+
Specify the polymorphic map plate the generated code should register + on. This functionality is primarily useful to segregate multiple schemas + that define the same polymorphic types.
+ +
--ordered-type type
+
Indicate that element order in type is + significant. An example would be a complex type with unbounded choice as a + content model where the element order in XML has application-specific + semantics. For ordered types the compiler generates a special container + data member and a corresponding set of accessors and modifiers that are + used to capture the order of elements and, for mixed content, of text. + +

The type argument is an XML Schema type name that + can be optionally qualified with a namespace in the + namespace#name form. Note also that you + will need to specify this option when compiling every schema file that has + other ordered types derived from this type.

+ +
--ordered-type-derived
+
Automatically treat types derived from ordered bases as also ordered. + This is primarily useful if you would like to be able to iterate over the + complete content using the content order container.
+ +
--ordered-type-mixed
+
Automatically treat complex types with mixed content as ordered.
+ +
--ordered-type-all
+
Indicate that element order in all types is significant.
+ +
--order-container type
+
Specify a custom class template that should be used as a container for + the content order in ordered types instead of the default + std::vector. See --ordered-type + for more information on ordered type. This option is primarily useful if + you need to perform more complex lookups in the content order container, + for example by element id. In this case, a container like Boost + multi-index may be more convenient. Note that if using a custom container, + you will also most likely need to include the relevant headers using the + --hxx-prologue* options.
+ +
--generate-serialization
+
Generate serialization functions. Serialization functions convert the + object model back to XML.
+ +
--generate-ostream
+
Generate ostream insertion operators + (operator<<) for generated types. This allows + one to easily print a fragment or the whole object model for debugging or + logging.
+ +
--generate-doxygen
+
Generate documentation comments suitable for extraction by the Doxygen + documentation system. Documentation from annotations is added to the + comments if present in the schema.
+ +
--generate-comparison
+
Generate comparison operators (operator== and + operator!=) for complex types. Comparison is performed + member-wise.
+ +
--generate-default-ctor
+
Generate default constructors even for types that have required + members. Required members of an instance constructed using such a + constructor are not initialized and accessing them results in undefined + behavior.
+ +
--generate-from-base-ctor
+
Generate constructors that expect an instance of a base type followed + by all required members.
+ +
--suppress-assignment
+
Suppress the generation of copy assignment operators for complex + types. If this option is specified, the copy assignment operators for such + types are declared private and left unimplemented.
+ +
--generate-detach
+
Generate detach functions for required elements and attributes. Detach + functions for optional and sequence cardinalities are provided by the + respective containers. These functions, for example, allow you to move + sub-trees in the object model either within the same tree or between + different trees.
+ +
--generate-wildcard
+
Generate accessors and modifiers as well as parsing and serialization + code for XML Schema wildcards (any and + anyAttribute). XML content matched by wildcards is + presented as DOM fragments. Note that you need to initialize the + Xerces-C++ runtime if you are using this option.
+ +
--generate-any-type
+
Extract and store content of the XML Schema + anyType type as a DOM fragment. Note that you need to + initialize the Xerces-C++ runtime if you are using this option.
+ +
--generate-insertion os
+
Generate data representation stream insertion operators for the + os output stream type. Repeat this option to specify + more than one stream type. The ACE CDR stream + (ACE_OutputCDR) and RPC XDR are recognized by the + compiler and the necessary #include directives are + automatically generated. For custom stream types use the + --hxx-prologue* options to provide the necessary + declarations.
+ +
--generate-extraction is
+
Generate data representation stream extraction constructors for the + is input stream type. Repeat this option to specify + more than one stream type. The ACE CDR stream + (ACE_InputCDR) and RPC XDR are recognized by the + compiler and the necessary #include directives are + automatically generated. For custom stream types use the + --hxx-prologue* options to provide the necessary + declarations.
+ +
--generate-forward
+
Generate a separate header file with forward declarations for the + types being generated.
+ +
--suppress-parsing
+
Suppress the generation of the parsing functions and constructors. Use + this option to reduce the generated code size when parsing from XML is not + needed.
+ +
--generate-element-type
+
Generate types instead of parsing and serialization functions for root + elements. This is primarily useful to distinguish object models with the + same root type but with different root elements.
+ +
--generate-element-map
+
Generate a root element map that allows uniform parsing and + serialization of multiple root elements. This option is only valid + together with --generate-element-type.
+ +
--generate-intellisense
+
Generate workarounds for IntelliSense bugs in Visual Studio 2005 + (8.0). When this option is used, the resulting code is slightly more + verbose. IntelliSense in Visual Studio 2008 (9.0) and later does not + require these workarounds. Support for IntelliSense in Visual Studio 2003 + (7.1) is improved with this option but is still incomplete.
+ +
--omit-default-attributes
+
Omit attributes with default and fixed values from serialized XML + documents.
+ +
--type-naming style
+
Specify the type naming convention that should be used in the + generated code. Valid styles are knr (default), + ucc, and java. See the NAMING + CONVENTION section below for more information.
+ +
--function-naming style
+
Specify the function naming convention that should be used in the + generated code. Valid styles are knr (default), + lcc, ucc, and + java. See the NAMING CONVENTION section below for more + information.
+ +
--type-regex regex
+
Add regex to the list of regular expressions used + to translate XML Schema type names to C++ type names. See the NAMING + CONVENTION section below for more information.
+ +
--accessor-regex regex
+
Add regex to the list of regular expressions used + to translate XML Schema names of elements/attributes to C++ accessor + function names. See the NAMING CONVENTION section below for more + information.
+ +
--one-accessor-regex regex
+
Add regex to the list of regular expressions used + to translate XML Schema names of elements/attributes with cardinality one + to C++ accessor function names. See the NAMING CONVENTION section below + for more information.
+ +
--opt-accessor-regex regex
+
Add regex to the list of regular expressions used + to translate XML Schema names of elements/attributes with cardinality + optional to C++ accessor function names. See the NAMING CONVENTION section + below for more information.
+ +
--seq-accessor-regex regex
+
Add regex to the list of regular expressions used + to translate XML Schema names of elements/attributes with cardinality + sequence to C++ accessor function names. See the NAMING CONVENTION section + below for more information.
+ +
--modifier-regex regex
+
Add regex to the list of regular expressions used + to translate XML Schema names of elements/attributes to C++ modifier + function names. See the NAMING CONVENTION section below for more + information.
+ +
--one-modifier-regex regex
+
Add regex to the list of regular expressions used + to translate XML Schema names of elements/attributes with cardinality one + to C++ modifier function names. See the NAMING CONVENTION section below + for more information.
+ +
--opt-modifier-regex regex
+
Add regex to the list of regular expressions used + to translate XML Schema names of elements/attributes with cardinality + optional to C++ modifier function names. See the NAMING CONVENTION section + below for more information.
+ +
--seq-modifier-regex regex
+
Add regex to the list of regular expressions used + to translate XML Schema names of elements/attributes with cardinality + sequence to C++ modifier function names. See the NAMING CONVENTION section + below for more information.
+ +
--parser-regex regex
+
Add regex to the list of regular expressions used + to translate XML Schema element names to C++ parsing function names. See + the NAMING CONVENTION section below for more information.
+ +
--serializer-regex regex
+
Add regex to the list of regular expressions used + to translate XML Schema element names to C++ serialization function names. + See the NAMING CONVENTION section below for more information.
+ +
--const-regex regex
+
Add regex to the list of regular expressions used + to translate XML Schema-derived names to C++ constant names. See the + NAMING CONVENTION section below for more information.
+ +
--enumerator-regex regex
+
Add regex to the list of regular expressions used + to translate XML Schema enumeration values to C++ enumerator names. See + the NAMING CONVENTION section below for more information.
+ +
--element-type-regex regex
+
Add regex to the list of regular expressions used + to translate XML Schema element names to C++ element type names. See the + NAMING CONVENTION section below for more information.
+ +
--name-regex-trace
+
Trace the process of applying regular expressions specified with the + name transformation options. Use this option to find out why your regular + expressions don't do what you expected them to do.
+ +
--root-element-first
+
Treat only the first global element as a document root. By default all + global elements are considered document roots.
+ +
--root-element-last
+
Treat only the last global element as a document root. By default all + global elements are considered document roots.
+ +
--root-element-all
+
Treat all global elements as document roots. This is the default + behavior. By explicitly specifying this option you can suppress the + warning that is issued if more than one global element is defined.
+ +
--root-element-none
+
Do not treat any global elements as document roots. By default all + global elements are considered document roots.
+ +
--root-element element
+
Treat only element as a document root. Repeat this + option to specify more than one root element.
+ +
--custom-type map
+
Use a custom C++ type instead of the generated class. The + map argument is in the form + name[=type[/base]], where + name is a type name as defined in XML Schema and type is a + C++ type name that should be used instead. If type is not present + or empty then the custom type is assumed to have the same name and be + defined in the same namespace as the generated class would have. If + base is specified then the generated class is still generated but + with that name.
+ +
--custom-type-regex regex
+
Use custom C++ types instead of the generated classes. The + regex argument is in the form + /name-pat/[type-sub/[base-sub/]], + where name-pat is a regex pattern that will be matched against type + names as defined in XML Schema and type-sub is a C++ type name + substitution that should be used instead. If type-sub is not + present or its substitution results in an empty string then the custom + type is assumed to have the same name and be defined in the same namespace + as the generated class would have. If base-sub is present and its + substitution results in a non-empty string then the generated class is + still generated but with the result of this substitution as its name. The + pattern and substitutions are in the Perl regular expression format. See + also the REGEX AND SHELL QUOTING section below.
+ +
--parts num
+
Split generated source code into num parts. This + is useful when translating large, monolithic schemas and a C++ compiler is + not able to compile the resulting source code at once (usually due to + insufficient memory).
+ +
--parts-suffix suffix
+
Use suffix instead of the default + '-' to separate the file name from the part + number.
+
+ +

CXX-PARSER COMMAND OPTIONS

+
+
--type-map mapfile
+
Read XML Schema to C++ type mapping information from + mapfile. Repeat this option to specify several type + maps. Type maps are considered in order of appearance and the first match + is used. By default all user-defined types are mapped to + void. See the TYPE MAP section below for more + information.
+ +
--xml-parser parser
+
Use parser as the underlying XML parser. Valid + values are xerces for Xerces-C++ (default) and + expat for Expat.
+ +
--generate-validation
+
Generate validation code. The validation code ("perfect parser") + ensures that instance documents conform to the schema. Validation code is + generated by default when the selected underlying XML parser is + non-validating (expat).
+ +
--suppress-validation
+
Suppress the generation of validation code. Validation is suppressed + by default when the selected underlying XML parser is validating + (xerces).
+ +
--generate-polymorphic
+
Generate polymorphism-aware code. Specify this option if you use + substitution groups or xsi:type.
+ +
--generate-noop-impl
+
Generate a sample parser implementation that does nothing (no + operation). The sample implementation can then be filled with the + application-specific code. For an input file in the form + name.xsd this option triggers the generation of two + additional C++ files in the form: name-pimpl.hxx + (parser implementation header file) and name-pimpl.cxx + (parser implementation source file).
+ +
--generate-print-impl
+
Generate a sample parser implementation that prints the XML data to + STDOUT. For an input file in the form + name.xsd this option triggers the generation of two + additional C++ files in the form: name-pimpl.hxx + (parser implementation header file) and name-pimpl.cxx + (parser implementation source file).
+ +
--generate-test-driver
+
Generate a test driver for the sample parser implementation. For an + input file in the form name.xsd this option triggers + the generation of an additional C++ file in the form + name-driver.cxx.
+ +
--force-overwrite
+
Force overwriting of the existing implementation and test driver + files. Use this option only if you do not mind loosing the changes you + have made in the sample implementation or test driver files.
+ +
--root-element-first
+
Indicate that the first global element is the document root. This + information is used to generate the test driver for the sample + implementation.
+ +
--root-element-last
+
Indicate that the last global element is the document root. This + information is used to generate the test driver for the sample + implementation.
+ +
--root-element element
+
Indicate that element is the document root. This + information is used to generate the test driver for the sample + implementation.
+ +
--skel-type-suffix suffix
+
Use the provided suffix instead of the default + _pskel to construct the names of the generated parser + skeletons.
+ +
--skel-file-suffix suffix
+
Use the provided suffix instead of the default + -pskel to construct the names of the generated parser + skeleton files.
+ +
--impl-type-suffix suffix
+
Use the provided suffix instead of the default + _pimpl to construct the names of the parser + implementations for the built-in XML Schema types as well as sample parser + implementations.
+ +
--impl-file-suffix suffix
+
Use the provided suffix instead of the default + -pimpl to construct the names of the generated sample + parser implementation files.
+
+ +

NAMING CONVENTION

+ +

The compiler can be instructed to use a particular naming + convention in the generated code. A number of widely-used + conventions can be selected using the --type-naming + and --function-naming options. A custom + naming convention can be achieved using the + --type-regex, + --accessor-regex, + --one-accessor-regex, + --opt-accessor-regex, + --seq-accessor-regex, + --modifier-regex, + --one-modifier-regex, + --opt-modifier-regex, + --seq-modifier-regex, + --parser-regex, + --serializer-regex, + --const-regex, + --enumerator-regex, and + --element-type-regex options. +

+ +

The --type-naming option specifies the + convention that should be used for naming C++ types. Possible + values for this option are knr (default), + ucc, and java. The + knr value (stands for K&R) signifies + the standard, lower-case naming convention with the underscore + used as a word delimiter, for example: foo, + foo_bar. The ucc (stands + for upper-camel-case) and + java values a synonyms for the same + naming convention where the first letter of each word in the + name is capitalized, for example: Foo, + FooBar.

+ +

Similarly, the --function-naming option + specifies the convention that should be used for naming C++ + functions. Possible values for this option are knr + (default), lcc, ucc, and + java. The knr value (stands + for K&R) signifies the standard, lower-case naming convention + with the underscore used as a word delimiter, for example: + foo(), foo_bar(). The lcc + value (stands for lower-camel-case) signifies a naming convention + where the first letter of each word except the first is capitalized, + for example: foo(), fooBar(). The + ucc value (stands for upper-camel-case) signifies + a naming convention where the first letter of each word is capitalized, + for example: Foo(), FooBar(). + The java naming convention is similar to + the lower-camel-case one except that accessor functions are prefixed + with get, modifier functions are prefixed + with set, parsing functions are prefixed + with parse, and serialization functions are + prefixed with serialize, for example: + getFoo(), setFooBar(), + parseRoot(), serializeRoot().

+ +

Note that the naming conventions specified with the + --type-naming and + --function-naming options perform only limited + transformations on the names that come from the schema in the + form of type, attribute, and element names. In other words, to + get consistent results, your schemas should follow a similar + naming convention as the one you would like to have in the + generated code. Alternatively, you can use the + --*-regex options (discussed below) + to perform further transformations on the names that come from + the schema.

+ +

The + --type-regex, + --accessor-regex, + --one-accessor-regex, + --opt-accessor-regex, + --seq-accessor-regex, + --modifier-regex, + --one-modifier-regex, + --opt-modifier-regex, + --seq-modifier-regex, + --parser-regex, + --serializer-regex, + --const-regex, + --enumerator-regex, and + --element-type-regex options allow you to + specify extra regular expressions for each name category in + addition to the predefined set that is added depending on + the --type-naming and + --function-naming options. Expressions + that are provided with the --*-regex + options are evaluated prior to any predefined expressions. + This allows you to selectively override some or all of the + predefined transformations. When debugging your own expressions, + it is often useful to see which expressions match which names. + The --name-regex-trace option allows you + to trace the process of applying regular expressions to + names.

+ +

The value for the --*-regex options should be + a perl-like regular expression in the form + /pattern/replacement/. + Any character can be used as a delimiter instead of /. + Escaping of the delimiter character in pattern or + replacement is not supported. + All the regular expressions for each category are pushed into a + category-specific stack with the last specified expression + considered first. The first match that succeeds is used. For the + --one-accessor-regex (accessors with cardinality one), + --opt-accessor-regex (accessors with cardinality optional), and + --seq-accessor-regex (accessors with cardinality sequence) + categories the --accessor-regex expressions are + used as a fallback. For the + --one-modifier-regex, + --opt-modifier-regex, and + --seq-modifier-regex + categories the --modifier-regex expressions are + used as a fallback. For the --element-type-regex + category the --type-regex expressions are + used as a fallback.

+ +

The type name expressions (--type-regex) + are evaluated on the name string that has the following + format:

+ +

[namespace ]name[,name][,name][,name]

+ +

The element type name expressions + (--element-type-regex), effective only when + the --generate-element-type option is specified, + are evaluated on the name string that has the following + format:

+ +

namespace name

+ +

In the type name format the namespace part + followed by a space is only present for global type names. For + global types and elements defined in schemas without a target + namespace, the namespace part is empty but + the space is still present. In the type name format after the + initial name component, up to three additional + name components can be present, separated + by commas. For example:

+ +

http://example.com/hello type

+

foo

+

foo,iterator

+

foo,const,iterator

+ +

The following set of predefined regular expressions is used to + transform type names when the upper-camel-case naming convention + is selected:

+ +

/(?:[^ ]* )?([^,]+)/\u$1/

+

/(?:[^ ]* )?([^,]+),([^,]+)/\u$1\u$2/

+

/(?:[^ ]* )?([^,]+),([^,]+),([^,]+)/\u$1\u$2\u$3/

+

/(?:[^ ]* )?([^,]+),([^,]+),([^,]+),([^,]+)/\u$1\u$2\u$3\u$4/

+ +

The accessor and modifier expressions + (--*accessor-regex and + --*modifier-regex) are evaluated on the name string + that has the following format:

+ +

name[,name][,name]

+ +

After the initial name component, up to two + additional name components can be present, + separated by commas. For example:

+ +

foo

+

dom,document

+

foo,default,value

+ +

The following set of predefined regular expressions is used to + transform accessor names when the java naming + convention is selected:

+ +

/([^,]+)/get\u$1/

+

/([^,]+),([^,]+)/get\u$1\u$2/

+

/([^,]+),([^,]+),([^,]+)/get\u$1\u$2\u$3/

+ +

For the parser, serializer, and enumerator categories, the + corresponding regular expressions are evaluated on local names of + elements and on enumeration values, respectively. For example, the + following predefined regular expression is used to transform parsing + function names when the java naming convention + is selected:

+ +

/(.+)/parse\u$1/

+ +

The const category is used to create C++ constant names for the + element/wildcard/text content ids in ordered types.

+ +

See also the REGEX AND SHELL QUOTING section below.

+ +

TYPE MAP

+ +

Type map files are used in C++/Parser to define a mapping between + XML Schema and C++ types. The compiler uses this information + to determine the return types of post_* + functions in parser skeletons corresponding to XML Schema + types as well as argument types for callbacks corresponding + to elements and attributes of these types.

+ +

The compiler has a set of predefined mapping rules that map + built-in XML Schema types to suitable C++ types (discussed + below) and all other types to void. + By providing your own type maps you can override these predefined + rules. The format of the type map file is presented below: +

+ + 
+namespace <schema-namespace> [<cxx-namespace>]
+{
+  (include <file-name>;)*
+  ([type] <schema-type> <cxx-ret-type> [<cxx-arg-type>];)*
+}
+
+ +

Both <schema-namespace> and + <schema-type> are regex patterns while + <cxx-namespace>, + <cxx-ret-type>, and + <cxx-arg-type> are regex pattern + substitutions. All names can be optionally enclosed in + " ", for example, to include white-spaces.

+ +

<schema-namespace> determines XML + Schema namespace. Optional <cxx-namespace> + is prefixed to every C++ type name in this namespace declaration. + <cxx-ret-type> is a C++ type name that is + used as a return type for the post_* functions. + Optional <cxx-arg-type> is an argument + type for callback functions corresponding to elements and attributes + of this type. If + <cxx-arg-type> is not specified, it defaults + to <cxx-ret-type> if <cxx-ret-type> + ends with * or & (that is, + it is a pointer or a reference) and + const <cxx-ret-type>& + otherwise. + <file-name> is a file name either in the + " " or < > format + and is added with the #include directive to + the generated code.

+ +

The # character starts a comment that ends + with a new line or end of file. To specify a name that contains + # enclose it in " ". + For example:

+ + 
+namespace http://www.example.com/xmlns/my my
+{
+  include "my.hxx";
+
+  # Pass apples by value.
+  #
+  apple apple;
+
+  # Pass oranges as pointers.
+  #
+  orange orange_t*;
+}
+
+ +

In the example above, for the + http://www.example.com/xmlns/my#orange + XML Schema type, the my::orange_t* C++ type will + be used as both return and argument types.

+ +

Several namespace declarations can be specified in a single + file. The namespace declaration can also be completely + omitted to map types in a schema without a namespace. For + instance:

+ + 
+include "my.hxx";
+apple apple;
+
+namespace http://www.example.com/xmlns/my
+{
+  orange "const orange_t*";
+}
+
+ +

The compiler has a number of predefined mapping rules that can be + presented as the following map files. The string-based XML Schema + built-in types are mapped to either std::string + or std::wstring depending on the character type + selected with the --char-type option + (char by default). The binary XML Schema types are + mapped to either std::unique_ptr<xml_schema::buffer> + or std::auto_ptr<xml_schema::buffer> depending on the C++ + standard selected with the --std option + (c++11 by default).

+ + 
+namespace http://www.w3.org/2001/XMLSchema
+{
+  boolean bool bool;
+
+  byte "signed char" "signed char";
+  unsignedByte "unsigned char" "unsigned char";
+
+  short short short;
+  unsignedShort "unsigned short" "unsigned short";
+
+  int int int;
+  unsignedInt "unsigned int" "unsigned int";
+
+  long "long long" "long long";
+  unsignedLong "unsigned long long" "unsigned long long";
+
+  integer "long long" "long long";
+
+  negativeInteger "long long" "long long";
+  nonPositiveInteger "long long" "long long";
+
+  positiveInteger "unsigned long long" "unsigned long long";
+  nonNegativeInteger "unsigned long long" "unsigned long long";
+
+  float float float;
+  double double double;
+  decimal double double;
+
+  string std::string;
+  normalizedString std::string;
+  token std::string;
+  Name std::string;
+  NMTOKEN std::string;
+  NCName std::string;
+  ID std::string;
+  IDREF std::string;
+  language std::string;
+  anyURI std::string;
+
+  NMTOKENS xml_schema::string_sequence;
+  IDREFS xml_schema::string_sequence;
+
+  QName xml_schema::qname;
+
+  base64Binary std::[unique|auto]_ptr<xml_schema::buffer>
+               std::[unique|auto]_ptr<xml_schema::buffer>;
+  hexBinary std::[unique|auto]_ptr<xml_schema::buffer>
+            std::[unique|auto]_ptr<xml_schema::buffer>;
+
+  date xml_schema::date;
+  dateTime xml_schema::date_time;
+  duration xml_schema::duration;
+  gDay xml_schema::gday;
+  gMonth xml_schema::gmonth;
+  gMonthDay xml_schema::gmonth_day;
+  gYear xml_schema::gyear;
+  gYearMonth xml_schema::gyear_month;
+  time xml_schema::time;
+}
+
+ +

The last predefined rule maps anything that wasn't mapped by + previous rules to void:

+ + 
+namespace .*
+{
+  .* void void;
+}
+
+ + +

When you provide your own type maps with the + --type-map option, they are evaluated first. + This allows you to selectively override predefined rules.

+ +

REGEX AND SHELL QUOTING

+ +

When entering a regular expression argument in the shell + command line it is often necessary to use quoting (enclosing + the argument in " " or + ' ') in order to prevent the shell + from interpreting certain characters, for example, spaces as + argument separators and $ as variable + expansions.

+ +

Unfortunately it is hard to achieve this in a manner that is + portable across POSIX shells, such as those found on + GNU/Linux and UNIX, and Windows shell. For example, if you + use " " for quoting you will get a + wrong result with POSIX shells if your expression contains + $. The standard way of dealing with this + on POSIX systems is to use ' ' instead. + Unfortunately, Windows shell does not remove ' ' + from arguments when they are passed to applications. As a result you + may have to use ' ' for POSIX and + " " for Windows ($ is + not treated as a special character on Windows).

+ +

Alternatively, you can save regular expression options into + a file, one option per line, and use this file with the + --options-file option. With this approach + you don't need to worry about shell quoting.

+ +

DIAGNOSTICS

+ +

If the input file is not a valid W3C XML Schema definition, + xsd will issue diagnostic messages to STDERR + and exit with non-zero exit code.

+ +

BUGS

+ +

Send bug reports to the + xsd-users@codesynthesis.com mailing list.

+ +
+ +
+ + diff --git a/doc/xsd-epilogue.1 b/doc/xsd-epilogue.1 new file mode 100644 index 0000000..9ab1952 --- /dev/null +++ b/doc/xsd-epilogue.1 @@ -0,0 +1,576 @@ +\" +\" NAMING CONVENTION +\" + +.SH NAMING CONVENTION +The compiler can be instructed to use a particular naming convention in +the generated code. A number of widely-used conventions can be selected +using the +.B --type-naming +and +.B --function-naming +options. A custom naming convention can be achieved using the +.BR --type-regex , +.BR --accessor-regex , +.BR --one-accessor-regex , +.BR --opt-accessor-regex , +.BR --seq-accessor-regex , +.BR --modifier-regex , +.BR --one-modifier-regex , +.BR --opt-modifier-regex , +.BR --seq-modifier-regex , +.BR --parser-regex , +.BR --serializer-regex , +.BR --const-regex , +.BR --enumerator-regex , +and +.B --element-type-regex +options. + +The +.B --type-naming +option specifies the convention that should be used for naming C++ types. +Possible values for this option are +.B knr +(default), +.BR ucc , +and +.BR java . +The +.B knr +value (stands for K&R) signifies the standard, lower-case naming convention +with the underscore used as a word delimiter, for example: foo, foo_bar. +The +.B ucc +(stands for upper-camel-case) and +.B java +values a synonyms for the same naming convention where the first letter +of each word in the name is capitalized, for example: Foo, FooBar. + +Similarly, the +.B --function-naming +option specifies the convention that should be used for naming C++ functions. +Possible values for this option are +.B knr +(default), +.BR lcc , +and +.BR java . +The +.B knr +value (stands for K&R) signifies the standard, lower-case naming convention +with the underscore used as a word delimiter, for example: foo(), foo_bar(). +The +.B lcc +value (stands for lower-camel-case) signifies a naming convention where the +first letter of each word except the first is capitalized, for example: foo(), +fooBar(). The +.B ucc +value (stands for upper-camel-case) signifies a naming convention where the +first letter of each word is capitalized, for example: Foo(), FooBar(). The +.B java +naming convention is similar to the lower-camel-case one except that accessor +functions are prefixed with get, modifier functions are prefixed with set, +parsing functions are prefixed with parse, and serialization functions are +prefixed with serialize, for example: getFoo(), setFooBar(), parseRoot(), +serializeRoot(). + +Note that the naming conventions specified with the +.B --type-naming +and +.B --function-naming +options perform only limited transformations on the +names that come from the schema in the form of type, attribute, and element +names. In other words, to get consistent results, your schemas should follow +a similar naming convention as the one you would like to have in the generated +code. Alternatively, you can use the +.B --*-regex +options (discussed below) to perform further transformations on the names +that come from the schema. + +The +.BR --type-regex , +.BR --accessor-regex , +.BR --one-accessor-regex , +.BR --opt-accessor-regex , +.BR --seq-accessor-regex , +.BR --modifier-regex , +.BR --one-modifier-regex , +.BR --opt-modifier-regex , +.BR --seq-modifier-regex , +.BR --parser-regex , +.BR --serializer-regex , +.BR --const-regex , +.BR --enumerator-regex , +and +.B --element-type-regex +options allow you to specify extra regular expressions for each name +category in addition to the predefined set that is added depending on +the +.B --type-naming +and +.B --function-naming +options. Expressions that are provided with the +.B --*-regex +options are evaluated prior to any predefined expressions. This allows +you to selectively override some or all of the predefined transformations. +When debugging your own expressions, it is often useful to see which +expressions match which names. The +.B --name-regex-trace +option allows you to trace the process of applying +regular expressions to names. + +The value for the +.B --*-regex +options should be a perl-like regular expression in the form +.BI / pattern / replacement /\fR. +Any character can be used as a delimiter instead of +.BR / . +Escaping of the delimiter character in +.I pattern +or +.I replacement +is not supported. All the regular expressions for each category are pushed +into a category-specific stack with the last specified expression +considered first. The first match that succeeds is used. For the +.B --one-accessor-regex +(accessors with cardinality one), +.B --opt-accessor-regex +(accessors with cardinality optional), and +.B --seq-accessor-regex +(accessors with cardinality sequence) categories the +.B --accessor-regex +expressions are used as a fallback. For the +.BR --one-modifier-regex , +.BR --opt-modifier-regex , +and +.B --seq-modifier-regex +categories the +.B --modifier-regex +expressions are used as a fallback. For the +.B --element-type-regex +category the +.B --type-regex +expressions are used as a fallback. + +The type name expressions +.RB ( --type-regex ) +are evaluated on the name string that has the following format: + +[\fInamespace \fR]\fIname\fR[\fB,\fIname\fR][\fB,\fIname\fR][\fB,\fIname\fR] + +The element type name expressions +.RB ( --element-type-regex ), +effective only when the +.B --generate-element-type +option is specified, are evaluated on the name string that has the following +format: + +.I namespace name + +In the type name format the +.I namespace +part followed by a space is only present for global type names. For global +types and elements defined in schemas without a target namespace, the +.I namespace +part is empty but the space is still present. In the type name format after +the initial +.I name +component, up to three additional +.I name +components can be present, separated by commas. For example: + +.B http://example.com/hello type + +.B foo + +.B foo,iterator + +.B foo,const,iterator + +The following set of predefined regular expressions is used to transform +type names when the upper-camel-case naming convention is selected: + +.B /(?:[^ ]* )?([^,]+)/\\\\u$1/ + +.B /(?:[^ ]* )?([^,]+),([^,]+)/\\\\u$1\\\\u$2/ + +.B /(?:[^ ]* )?([^,]+),([^,]+),([^,]+)/\\\\u$1\\\\u$2\\\\u$3/ + +.B /(?:[^ ]* )?([^,]+),([^,]+),([^,]+),([^,]+)/\\\\u$1\\\\u$2\\\\u$3\\\\u$4/ + +The accessor and modifier expressions +.RB ( --*accessor-regex +and +.BR --*modifier-regex ) +are evaluated on the name string that has the following format: + +\fIname\fR[\fB,\fIname\fR][\fB,\fIname\fR] + +After the initial +.I name +component, up to two additional +.I name +components can be present, separated by commas. For example: + +.B foo + +.B dom,document + +.B foo,default,value + +The following set of predefined regular expressions is used to transform +accessor names when the +.B java +naming convention is selected: + +.B /([^,]+)/get\\\\u$1/ + +.B /([^,]+),([^,]+)/get\\\\u$1\\\\u$2/ + +.B /([^,]+),([^,]+),([^,]+)/get\\\\u$1\\\\u$2\\\\u$3/ + +For the parser, serializer, and enumerator categories, the corresponding +regular expressions are evaluated on local names of elements and on +enumeration values, respectively. For example, the following predefined +regular expression is used to transform parsing function names when the +.B java +naming convention is selected: + +.B /(.+)/parse\\\\u$1/ + +The const category is used to create C++ constant names for the +element/wildcard/text content ids in ordered types. + +See also the REGEX AND SHELL QUOTING section below. + +\" +\" TYPE MAP +\" +.SH TYPE MAP +Type map files are used in C++/Parser to define a mapping between XML +Schema and C++ types. The compiler uses this information to determine +the return types of +.B post_* +functions in parser skeletons corresponding to XML Schema types +as well as argument types for callbacks corresponding to elements +and attributes of these types. + +The compiler has a set of predefined mapping rules that map built-in +XML Schema types to suitable C++ types (discussed below) and all +other types to +.BR void . +By providing your own type maps you can override these predefined rules. +The format of the type map file is presented below: + +.RS +.B namespace +.I schema-namespace +[ +.I cxx-namespace +] +.br +.B { +.br + ( +.B include +.IB file-name ; +)* +.br + ([ +.B type +] +.I schema-type cxx-ret-type +[ +.I cxx-arg-type +.RB ] ; +)* +.br +.B } +.br +.RE + +Both +.I schema-namespace +and +.I schema-type +are regex patterns while +.IR cxx-namespace , +.IR cxx-ret-type , +and +.I cxx-arg-type +are regex pattern substitutions. All names can be optionally enclosed +in \fR" "\fR, for example, to include white-spaces. + +.I schema-namespace +determines XML Schema namespace. Optional +.I cxx-namespace +is prefixed to every C++ type name in this namespace declaration. +.I cxx-ret-type +is a C++ type name that is used as a return type for the +.B post_* +functions. Optional +.I cxx-arg-type +is an argument type for callback functions corresponding to elements and +attributes of this type. If +.I cxx-arg-type +is not specified, it defaults to +.I cxx-ret-type +if +.I cxx-ret-type +ends with +.B * +or +.B & +(that is, it is a pointer or a reference) and +.B const +\fIcxx-ret-type\fB&\fR otherwise. +.I file-name +is a file name either in the \fR" "\fR or < > format and is added with the +.B #include +directive to the generated code. + +The \fB#\fR character starts a comment that ends with a new line or end of +file. To specify a name that contains \fB#\fR enclose it in \fR" "\fR. For +example: + +.RS +namespace http://www.example.com/xmlns/my my +.br +{ +.br + include "my.hxx"; +.br + + # Pass apples by value. + # + apple apple; +.br + + # Pass oranges as pointers. + # + orange orange_t*; +.br +} +.br +.RE + +In the example above, for the +.B http://www.example.com/xmlns/my#orange +XML Schema type, the +.B my::orange_t* +C++ type will be used as both return and argument types. + +Several namespace declarations can be specified in a single file. +The namespace declaration can also be completely omitted to map +types in a schema without a namespace. For instance: + +.RS +include "my.hxx"; +.br +apple apple; +.br + +namespace http://www.example.com/xmlns/my +.br +{ +.br + orange "const orange_t*"; +.br +} +.br +.RE + +The compiler has a number of predefined mapping rules that can be +presented as the following map files. The string-based XML Schema +built-in types are mapped to either +.B std::string +or +.B std::wstring +depending on the character type selected with the +.B --char-type +option +.RB ( char +by default). The binary XML Schema types are mapped to either +.B std::unique_ptr +or +.B std::auto_ptr +depending on the C++ standard selected with the +.B --std +option +.RB ( c++11 +by default). + +.RS +namespace http://www.w3.org/2001/XMLSchema +.br +{ +.br + boolean bool bool; +.br + + byte "signed char" "signed char"; +.br + unsignedByte "unsigned char" "unsigned char"; +.br + + short short short; +.br + unsignedShort "unsigned short" "unsigned short"; +.br + + int int int; +.br + unsignedInt "unsigned int" "unsigned int"; +.br + + long "long long" "long long"; +.br + unsignedLong "unsigned long long" "unsigned long long"; +.br + + integer "long long" "long long"; +.br + + negativeInteger "long long" "long long"; +.br + nonPositiveInteger "long long" "long long"; +.br + + positiveInteger "unsigned long long" "unsigned long long"; +.br + nonNegativeInteger "unsigned long long" "unsigned long long"; +.br + + float float float; +.br + double double double; +.br + decimal double double; +.br + + string std::string; +.br + normalizedString std::string; +.br + token std::string; +.br + Name std::string; +.br + NMTOKEN std::string; +.br + NCName std::string; +.br + ID std::string; +.br + IDREF std::string; +.br + language std::string; +.br + anyURI std::string; +.br + + NMTOKENS xml_schema::string_sequence; +.br + IDREFS xml_schema::string_sequence; +.br + + QName xml_schema::qname; +.br + + base64Binary std::[unique|auto]_ptr +.br + std::[unique|auto]_ptr; +.br + hexBinary std::[unique|auto]_ptr +.br + std::[unique|auto]_ptr; +.br + + date xml_schema::date; +.br + dateTime xml_schema::date_time; +.br + duration xml_schema::duration; +.br + gDay xml_schema::gday; +.br + gMonth xml_schema::gmonth; +.br + gMonthDay xml_schema::gmonth_day; +.br + gYear xml_schema::gyear; +.br + gYearMonth xml_schema::gyear_month; +.br + time xml_schema::time; +.br +} +.br +.RE + + +The last predefined rule maps anything that wasn't mapped by previous +rules to +.BR void : + +.RS +namespace .* +.br +{ +.br + .* void void; +.br +} +.br +.RE + +When you provide your own type maps with the +.B --type-map +option, they are evaluated first. This allows you to selectively override +predefined rules. + +.\" +.\" REGEX AND SHELL QUOTING +.\" +.SH REGEX AND SHELL QUOTING +When entering a regular expression argument in the shell command line +it is often necessary to use quoting (enclosing the argument in " " +or ' ') in order to prevent the shell from interpreting certain +characters, for example, spaces as argument separators and $ as +variable expansions. + +Unfortunately it is hard to achieve this in a manner that is portable +across POSIX shells, such as those found on GNU/Linux and UNIX, and +Windows shell. For example, if you use " " for quoting you will get +a wrong result with POSIX shells if your expression contains $. The +standard way of dealing with this on POSIX systems is to use ' ' +instead. Unfortunately, Windows shell does not remove ' ' from +arguments when they are passed to applications. As a result you may +have to use ' ' for POSIX and " " for Windows ($ is not treated as +a special character on Windows). + +Alternatively, you can save regular expression options into a file, +one option per line, and use this file with the +.B --options-file +option. With this approach you don't need to worry about shell quoting. + +.\" +.\" DIAGNOSTICS +.\" +.SH DIAGNOSTICS +If the input file is not a valid W3C XML Schema definition, +.B xsd +will issue diagnostic messages to +.B STDERR +and exit with non-zero exit code. +.SH BUGS +Send bug reports to the xsd-users@codesynthesis.com mailing list. +.SH COPYRIGHT +Copyright (c) $copyright$. + +Permission is granted to copy, distribute and/or modify this +document under the terms of the GNU Free Documentation License, +version 1.2; with no Invariant Sections, no Front-Cover Texts and +no Back-Cover Texts. Copy of the license can be obtained from +https://www.codesynthesis.com/licenses/fdl-1.2.txt diff --git a/doc/xsd-epilogue.xhtml b/doc/xsd-epilogue.xhtml new file mode 100644 index 0000000..178cf8b --- /dev/null +++ b/doc/xsd-epilogue.xhtml @@ -0,0 +1,429 @@ +

NAMING CONVENTION

+ +

The compiler can be instructed to use a particular naming + convention in the generated code. A number of widely-used + conventions can be selected using the --type-naming + and --function-naming options. A custom + naming convention can be achieved using the + --type-regex, + --accessor-regex, + --one-accessor-regex, + --opt-accessor-regex, + --seq-accessor-regex, + --modifier-regex, + --one-modifier-regex, + --opt-modifier-regex, + --seq-modifier-regex, + --parser-regex, + --serializer-regex, + --const-regex, + --enumerator-regex, and + --element-type-regex options. +

+ +

The --type-naming option specifies the + convention that should be used for naming C++ types. Possible + values for this option are knr (default), + ucc, and java. The + knr value (stands for K&R) signifies + the standard, lower-case naming convention with the underscore + used as a word delimiter, for example: foo, + foo_bar. The ucc (stands + for upper-camel-case) and + java values a synonyms for the same + naming convention where the first letter of each word in the + name is capitalized, for example: Foo, + FooBar.

+ +

Similarly, the --function-naming option + specifies the convention that should be used for naming C++ + functions. Possible values for this option are knr + (default), lcc, ucc, and + java. The knr value (stands + for K&R) signifies the standard, lower-case naming convention + with the underscore used as a word delimiter, for example: + foo(), foo_bar(). The lcc + value (stands for lower-camel-case) signifies a naming convention + where the first letter of each word except the first is capitalized, + for example: foo(), fooBar(). The + ucc value (stands for upper-camel-case) signifies + a naming convention where the first letter of each word is capitalized, + for example: Foo(), FooBar(). + The java naming convention is similar to + the lower-camel-case one except that accessor functions are prefixed + with get, modifier functions are prefixed + with set, parsing functions are prefixed + with parse, and serialization functions are + prefixed with serialize, for example: + getFoo(), setFooBar(), + parseRoot(), serializeRoot().

+ +

Note that the naming conventions specified with the + --type-naming and + --function-naming options perform only limited + transformations on the names that come from the schema in the + form of type, attribute, and element names. In other words, to + get consistent results, your schemas should follow a similar + naming convention as the one you would like to have in the + generated code. Alternatively, you can use the + --*-regex options (discussed below) + to perform further transformations on the names that come from + the schema.

+ +

The + --type-regex, + --accessor-regex, + --one-accessor-regex, + --opt-accessor-regex, + --seq-accessor-regex, + --modifier-regex, + --one-modifier-regex, + --opt-modifier-regex, + --seq-modifier-regex, + --parser-regex, + --serializer-regex, + --const-regex, + --enumerator-regex, and + --element-type-regex options allow you to + specify extra regular expressions for each name category in + addition to the predefined set that is added depending on + the --type-naming and + --function-naming options. Expressions + that are provided with the --*-regex + options are evaluated prior to any predefined expressions. + This allows you to selectively override some or all of the + predefined transformations. When debugging your own expressions, + it is often useful to see which expressions match which names. + The --name-regex-trace option allows you + to trace the process of applying regular expressions to + names.

+ +

The value for the --*-regex options should be + a perl-like regular expression in the form + /pattern/replacement/. + Any character can be used as a delimiter instead of /. + Escaping of the delimiter character in pattern or + replacement is not supported. + All the regular expressions for each category are pushed into a + category-specific stack with the last specified expression + considered first. The first match that succeeds is used. For the + --one-accessor-regex (accessors with cardinality one), + --opt-accessor-regex (accessors with cardinality optional), and + --seq-accessor-regex (accessors with cardinality sequence) + categories the --accessor-regex expressions are + used as a fallback. For the + --one-modifier-regex, + --opt-modifier-regex, and + --seq-modifier-regex + categories the --modifier-regex expressions are + used as a fallback. For the --element-type-regex + category the --type-regex expressions are + used as a fallback.

+ +

The type name expressions (--type-regex) + are evaluated on the name string that has the following + format:

+ +

[namespace ]name[,name][,name][,name]

+ +

The element type name expressions + (--element-type-regex), effective only when + the --generate-element-type option is specified, + are evaluated on the name string that has the following + format:

+ +

namespace name

+ +

In the type name format the namespace part + followed by a space is only present for global type names. For + global types and elements defined in schemas without a target + namespace, the namespace part is empty but + the space is still present. In the type name format after the + initial name component, up to three additional + name components can be present, separated + by commas. For example:

+ +

http://example.com/hello type

+

foo

+

foo,iterator

+

foo,const,iterator

+ +

The following set of predefined regular expressions is used to + transform type names when the upper-camel-case naming convention + is selected:

+ +

/(?:[^ ]* )?([^,]+)/\u$1/

+

/(?:[^ ]* )?([^,]+),([^,]+)/\u$1\u$2/

+

/(?:[^ ]* )?([^,]+),([^,]+),([^,]+)/\u$1\u$2\u$3/

+

/(?:[^ ]* )?([^,]+),([^,]+),([^,]+),([^,]+)/\u$1\u$2\u$3\u$4/

+ +

The accessor and modifier expressions + (--*accessor-regex and + --*modifier-regex) are evaluated on the name string + that has the following format:

+ +

name[,name][,name]

+ +

After the initial name component, up to two + additional name components can be present, + separated by commas. For example:

+ +

foo

+

dom,document

+

foo,default,value

+ +

The following set of predefined regular expressions is used to + transform accessor names when the java naming + convention is selected:

+ +

/([^,]+)/get\u$1/

+

/([^,]+),([^,]+)/get\u$1\u$2/

+

/([^,]+),([^,]+),([^,]+)/get\u$1\u$2\u$3/

+ +

For the parser, serializer, and enumerator categories, the + corresponding regular expressions are evaluated on local names of + elements and on enumeration values, respectively. For example, the + following predefined regular expression is used to transform parsing + function names when the java naming convention + is selected:

+ +

/(.+)/parse\u$1/

+ +

The const category is used to create C++ constant names for the + element/wildcard/text content ids in ordered types.

+ +

See also the REGEX AND SHELL QUOTING section below.

+ +

TYPE MAP

+ +

Type map files are used in C++/Parser to define a mapping between + XML Schema and C++ types. The compiler uses this information + to determine the return types of post_* + functions in parser skeletons corresponding to XML Schema + types as well as argument types for callbacks corresponding + to elements and attributes of these types.

+ +

The compiler has a set of predefined mapping rules that map + built-in XML Schema types to suitable C++ types (discussed + below) and all other types to void. + By providing your own type maps you can override these predefined + rules. The format of the type map file is presented below: +

+ + 
+namespace <schema-namespace> [<cxx-namespace>]
+{
+  (include <file-name>;)*
+  ([type] <schema-type> <cxx-ret-type> [<cxx-arg-type>];)*
+}
+
+ +

Both <schema-namespace> and + <schema-type> are regex patterns while + <cxx-namespace>, + <cxx-ret-type>, and + <cxx-arg-type> are regex pattern + substitutions. All names can be optionally enclosed in + " ", for example, to include white-spaces.

+ +

<schema-namespace> determines XML + Schema namespace. Optional <cxx-namespace> + is prefixed to every C++ type name in this namespace declaration. + <cxx-ret-type> is a C++ type name that is + used as a return type for the post_* functions. + Optional <cxx-arg-type> is an argument + type for callback functions corresponding to elements and attributes + of this type. If + <cxx-arg-type> is not specified, it defaults + to <cxx-ret-type> if <cxx-ret-type> + ends with * or & (that is, + it is a pointer or a reference) and + const <cxx-ret-type>& + otherwise. + <file-name> is a file name either in the + " " or < > format + and is added with the #include directive to + the generated code.

+ +

The # character starts a comment that ends + with a new line or end of file. To specify a name that contains + # enclose it in " ". + For example:

+ + 
+namespace http://www.example.com/xmlns/my my
+{
+  include "my.hxx";
+
+  # Pass apples by value.
+  #
+  apple apple;
+
+  # Pass oranges as pointers.
+  #
+  orange orange_t*;
+}
+
+ +

In the example above, for the + http://www.example.com/xmlns/my#orange + XML Schema type, the my::orange_t* C++ type will + be used as both return and argument types.

+ +

Several namespace declarations can be specified in a single + file. The namespace declaration can also be completely + omitted to map types in a schema without a namespace. For + instance:

+ + 
+include "my.hxx";
+apple apple;
+
+namespace http://www.example.com/xmlns/my
+{
+  orange "const orange_t*";
+}
+
+ +

The compiler has a number of predefined mapping rules that can be + presented as the following map files. The string-based XML Schema + built-in types are mapped to either std::string + or std::wstring depending on the character type + selected with the --char-type option + (char by default). The binary XML Schema types are + mapped to either std::unique_ptr<xml_schema::buffer> + or std::auto_ptr<xml_schema::buffer> depending on the C++ + standard selected with the --std option + (c++11 by default).

+ + 
+namespace http://www.w3.org/2001/XMLSchema
+{
+  boolean bool bool;
+
+  byte "signed char" "signed char";
+  unsignedByte "unsigned char" "unsigned char";
+
+  short short short;
+  unsignedShort "unsigned short" "unsigned short";
+
+  int int int;
+  unsignedInt "unsigned int" "unsigned int";
+
+  long "long long" "long long";
+  unsignedLong "unsigned long long" "unsigned long long";
+
+  integer "long long" "long long";
+
+  negativeInteger "long long" "long long";
+  nonPositiveInteger "long long" "long long";
+
+  positiveInteger "unsigned long long" "unsigned long long";
+  nonNegativeInteger "unsigned long long" "unsigned long long";
+
+  float float float;
+  double double double;
+  decimal double double;
+
+  string std::string;
+  normalizedString std::string;
+  token std::string;
+  Name std::string;
+  NMTOKEN std::string;
+  NCName std::string;
+  ID std::string;
+  IDREF std::string;
+  language std::string;
+  anyURI std::string;
+
+  NMTOKENS xml_schema::string_sequence;
+  IDREFS xml_schema::string_sequence;
+
+  QName xml_schema::qname;
+
+  base64Binary std::[unique|auto]_ptr<xml_schema::buffer>
+               std::[unique|auto]_ptr<xml_schema::buffer>;
+  hexBinary std::[unique|auto]_ptr<xml_schema::buffer>
+            std::[unique|auto]_ptr<xml_schema::buffer>;
+
+  date xml_schema::date;
+  dateTime xml_schema::date_time;
+  duration xml_schema::duration;
+  gDay xml_schema::gday;
+  gMonth xml_schema::gmonth;
+  gMonthDay xml_schema::gmonth_day;
+  gYear xml_schema::gyear;
+  gYearMonth xml_schema::gyear_month;
+  time xml_schema::time;
+}
+
+ +

The last predefined rule maps anything that wasn't mapped by + previous rules to void:

+ + 
+namespace .*
+{
+  .* void void;
+}
+
+ + +

When you provide your own type maps with the + --type-map option, they are evaluated first. + This allows you to selectively override predefined rules.

+ +

REGEX AND SHELL QUOTING

+ +

When entering a regular expression argument in the shell + command line it is often necessary to use quoting (enclosing + the argument in " " or + ' ') in order to prevent the shell + from interpreting certain characters, for example, spaces as + argument separators and $ as variable + expansions.

+ +

Unfortunately it is hard to achieve this in a manner that is + portable across POSIX shells, such as those found on + GNU/Linux and UNIX, and Windows shell. For example, if you + use " " for quoting you will get a + wrong result with POSIX shells if your expression contains + $. The standard way of dealing with this + on POSIX systems is to use ' ' instead. + Unfortunately, Windows shell does not remove ' ' + from arguments when they are passed to applications. As a result you + may have to use ' ' for POSIX and + " " for Windows ($ is + not treated as a special character on Windows).

+ +

Alternatively, you can save regular expression options into + a file, one option per line, and use this file with the + --options-file option. With this approach + you don't need to worry about shell quoting.

+ +

DIAGNOSTICS

+ +

If the input file is not a valid W3C XML Schema definition, + xsd will issue diagnostic messages to STDERR + and exit with non-zero exit code.

+ +

BUGS

+ +

Send bug reports to the + xsd-users@codesynthesis.com mailing list.

+ + + + + + diff --git a/doc/xsd-parser-header.1 b/doc/xsd-parser-header.1 new file mode 100644 index 0000000..e0cf84e --- /dev/null +++ b/doc/xsd-parser-header.1 @@ -0,0 +1,4 @@ +\" +\" C++/Parser +\" +.SS cxx-parser command options diff --git a/doc/xsd-parser-header.xhtml b/doc/xsd-parser-header.xhtml new file mode 100644 index 0000000..94fa2c1 --- /dev/null +++ b/doc/xsd-parser-header.xhtml @@ -0,0 +1 @@ +

CXX-PARSER COMMAND OPTIONS

diff --git a/doc/xsd-prologue.1 b/doc/xsd-prologue.1 new file mode 100644 index 0000000..33f039e --- /dev/null +++ b/doc/xsd-prologue.1 @@ -0,0 +1,119 @@ +.\" Process this file with +.\" groff -man -Tascii xsd.1 +.\" +.TH XSD 1 "$date$" "$project$ $version$" +.SH NAME +xsd \- W3C XML Schema to C++ Compiler +.\" +.\" +.\" +.\"-------------------------------------------------------------------- +.SH SYNOPSIS +.\"-------------------------------------------------------------------- +.B xsd +.I command +.B [ +.I options +.B ] +.I file +.B [ +.I file +.B ...] +.in +.B xsd help +.B [ +.I command +.B ] +.in +.B xsd version +.\" +.\" +.\" +.\"-------------------------------------------------------------------- +.SH DESCRIPTION +.\"-------------------------------------------------------------------- +.B xsd +generates vocabulary-specific, statically-typed C++ mapping from W3C XML +Schema definitions. Particular mapping to produce is selected by a +.IR command . +Each mapping has a number of mapping-specific +.I options +that should appear, if any, after the +.IR command . +Input files should be W3C XML Schema definitions. The exact set of the +generated files depends on the selected mapping and options. +.\" +.\" +.\" +.\"-------------------------------------------------------------------- +.SH COMMANDS +.\"-------------------------------------------------------------------- +.IP \fBcxx-tree\fR +Generate the C++/Tree mapping. For each input file in the form +.B name.xsd +the following C++ files are generated: +.B name.hxx +(header file), +.B name.ixx +(inline file, generated only if the +.B --generate-inline +option is specified), +.B name.cxx +(source file), and +.B name-fwd.hxx +(forward declaration file, generated only if the +.B --generate-forward +option is specified). + +.IP \fBcxx-parser\fR +Generate the C++/Parser mapping. For each input file in the form +.B name.xsd +the following C++ files are generated: +.B name-pskel.hxx +(parser skeleton header file), +.B name-pskel.ixx +(parser skeleton inline file, generated only if the +.B --generate-inline +option is specified), and +.B name-pskel.cxx +(parser skeleton source file). If the +.B --generate-noop-impl +or +.B --generate-print-impl +option is specified, the following additional sample implementation files +are generated: +.B name-pimpl.hxx +(parser implementation header file) and +.B name-pimpl.cxx +(parser implementation source file). If the +.B --generate-test-driver +option is specified, the additional +.B name-driver.cxx +test driver file is generated. + +.IP \fBhelp\fR +Print usage information and exit. Use +.PP +.RS +.RS 3 +.B xsd help +.I command +.RE +.PP +for command-specific help. +.RE +.IP \fBversion\fR +Print version and exit. +.\"-------------------------------------------------------------------- +.SH OPTIONS +.\"-------------------------------------------------------------------- +Command-specific +.IR options , +if any, should appear after the corresponding +.IR command . + +.\" +.\" Common options. +.\" +.SS common options +. diff --git a/doc/xsd-prologue.xhtml b/doc/xsd-prologue.xhtml new file mode 100644 index 0000000..e52e1fc --- /dev/null +++ b/doc/xsd-prologue.xhtml @@ -0,0 +1,123 @@ + + + + + + $project$ $version$ Compiler Command Line Manual + + + + + + + + + + + + +
+
+ +

NAME

+ +

xsd - W3C XML Schema to C++ Compiler

+ +

SYNOPSIS

+ +
+
xsd command [options] file [file ...]
+
xsd help [command]
+
xsd version
+
+ +

DESCRIPTION

+ +

xsd generates vocabulary-specific, statically-typed + C++ mapping from W3C XML Schema definitions. Particular mapping to + produce is selected by a command. Each mapping has + a number of mapping-specific options that should + appear, if any, after the command. Input files should + be W3C XML Schema definitions. The exact set of the generated files depends + on the selected mapping and options.

+ +

COMMANDS

+ +
+
cxx-tree
+
Generate the C++/Tree mapping. For each input file in the form + name.xsd the following C++ files are generated: + name.hxx (header file), + name.ixx (inline file, generated only if the + --generate-inline option is specified), + name.cxx (source file), and + name-fwd.hxx (forward declaration file, generated + only if the --generate-forward option is + specified).
+ +
cxx-parser
+
Generate the C++/Parser mapping. For each input file in the form + name.xsd the following C++ files are generated: + name-pskel.hxx (parser skeleton header file), + name-pskel.ixx (parser skeleton inline file, + generated only if the --generate-inline + option is specified), and + name-pskel.cxx (parser skeleton source file). + If the --generate-noop-impl or + --generate-print-impl option is specified, + the following additional sample implementation files are generated: + name-pimpl.hxx (parser implementation header + file) and + name-pimpl.cxx (parser implementation source + file). If the --generate-test-driver option + is specified, the additional name-driver.cxx + test driver file is generated.
+ +
help
+
Print usage information and exit. Use +

xsd help command

+ for command-specific help. +
+ +
version
+
Print version and exit.
+
+ +

OPTIONS

+ +

Command-specific options, if any, should appear + after the corresponding command.

+ +

COMMON OPTIONS

diff --git a/doc/xsd-tree-header.1 b/doc/xsd-tree-header.1 new file mode 100644 index 0000000..b9146a7 --- /dev/null +++ b/doc/xsd-tree-header.1 @@ -0,0 +1,4 @@ +.\" +.\" C++/Tree options. +.\" +.SS cxx-tree command options diff --git a/doc/xsd-tree-header.xhtml b/doc/xsd-tree-header.xhtml new file mode 100644 index 0000000..73f9c99 --- /dev/null +++ b/doc/xsd-tree-header.xhtml @@ -0,0 +1 @@ +

CXX-TREE COMMAND OPTIONS

diff --git a/manifest b/manifest new file mode 100644 index 0000000..4373575 --- /dev/null +++ b/manifest @@ -0,0 +1,164 @@ +: 1 +name: xsd +version: 4.2.0 +language: c++ +summary: XML Schema to C++ data binding compiler +license: other: GPL-2.0-only with Xerces-C++ linking exception and FLOSS exception +topics: C++, XML, XML Schema, XML parser, source code generation +description-file: README.md +package-description-file: PACKAGE-README.md +changes-file: NEWS +url: https://www.codesynthesis.com/products/xsd/ +doc-url: https://www.codesynthesis.com/products/xsd/ +src-url: https://git.codesynthesis.com/cgit/xsd/xsd/ +email: xsd-users@codesynthesis.com ; Mailing list +build-warning-email: builds@codesynthesis.com +requires: host +requires: c++11 +depends: * build2 >= 0.16.0 +depends: * bpkg >= 0.16.0 +depends: libxsd-frontend ^2.1.0 +depends: libcutl ^1.11.0 +depends: libxerces-c ^3.0.0 +depends: * cli ^1.2.0- ? ($config.xsd.develop) +tests: * xsd-tests == $ +examples: * xsd-examples == $ + +# Binary distribution packages. Overall notes: +# +# - Link dependencies that don't come from system packages statically. +# +# - We suppress generating binary packages for dependecies (libcutl, +# libxsd-frontend) with --recursive=auto since they are linked statically. +# +# - For archives we strip the default compiler name from metadata since +# it's unimportant (we link the C++ runtime statically). +# +# - We disable warning emails for configurations that build Xerces-C++. + +# Note that the Xerces-C++ package is in the unsupported `universe` section on +# Ubuntu so we have a separate configuration for it where we build Xerces-C++ +# ourselves. +# +bindist-debian-builds: bindist +bindist-debian-build-include: linux_debian*-** +bindist-debian-build-exclude: ** +bindist-debian-build-config: +\ ++bpkg.bindist.debian: ++bbot.bindist.upload: +bpkg.bindist.debian:--recursive=auto +bpkg.create:config.bin.lib=static +bpkg.create:config.bin.liba.lib="shared static" +?sys:libxerces-c +\ + +bindist-ubuntu-builds: bindist +bindist-ubuntu-build-include: linux_ubuntu*-** +bindist-ubuntu-build-exclude: ** +bindist-ubuntu-build-config: +\ ++bpkg.bindist.debian: ++bbot.bindist.upload: +bpkg.bindist.debian:--recursive=auto +bpkg.create:config.bin.lib=static +bpkg.create:config.bin.liba.lib="shared static" +?sys:libicuuc +?sys:libicui18n +\ +#bindist-ubuntu-build-error-email: builds@codesynthesis.com + +# Note that there is no Xerces-C++ package in RHEL (only in EPEL) so we +# have a separate configuration for RHEL. +# +bindist-fedora-builds: bindist +bindist-fedora-build-include: linux_fedora*-** +bindist-fedora-build-exclude: ** +bindist-fedora-build-config: +\ ++bpkg.bindist.fedora: ++bbot.bindist.upload: +bpkg.bindist.fedora:--recursive=auto +bpkg.create:config.bin.lib=static +bpkg.create:config.bin.liba.lib="shared static" +?sys:libxerces-c +\ + +bindist-rhel-builds: bindist +bindist-rhel-build-include: linux_rhel*-** +bindist-rhel-build-exclude: ** +bindist-rhel-build-config: +\ ++bpkg.bindist.fedora: ++bbot.bindist.upload: +bpkg.bindist.fedora:--recursive=auto +bpkg.create:config.bin.lib=static +bpkg.create:config.bin.liba.lib="shared static" +?sys:libicuuc +?sys:libicui18n +\ +#bindist-rhel-build-error-email: builds@codesynthesis.com + +# Note: use static runtime since the DLL runtime is not universally +# pre-installed. +# +bindist-windows-builds: bindist +bindist-windows-build-include: windows*-** +bindist-windows-build-exclude: ** +bindist-windows-build-config: +\ ++bpkg.bindist.archive: ++bbot.bindist.upload: +bpkg.bindist.archive:--recursive=auto +bpkg.bindist.archive:--archive-lang-impl=cc= +bpkg.bindist.archive:config.install.relocatable=true +bpkg.create:config.bin.lib=static +bpkg.create:config.bin.liba.lib="shared static" +bpkg.create:config.cc.coptions+="/MT" +b.create:config.cc.coptions="/W2 /O2" +\ +#bindist-windows-build-error-email: builds@codesynthesis.com + +# Note that /usr/lib/libc++.1.dylib is pre-installed and appears to be +# reasonably compatible (even forward-compatible) so we don't bother +# with linking it statically for now. +# +bindist-macos-builds: bindist +bindist-macos-build-include: macos*-** +bindist-macos-build-exclude: ** +bindist-macos-build-config: +\ ++bpkg.bindist.archive: ++bbot.bindist.upload: +bpkg.bindist.archive:--recursive=auto +bpkg.bindist.archive:--archive-lang-impl=cc= +bpkg.bindist.archive:config.install.relocatable=true +bpkg.create:config.bin.lib=static +bpkg.create:config.bin.liba.lib="shared static" +b.create:config.cc.coptions="-Wall -O3" +\ +#bindist-macos-build-error-email: builds@codesynthesis.com + +# Generic linux package (built using oldest Debian we support). +# +# Note: update glibc version if changing build configuration. +# +# @@ TMP glibc2_31 +# +bindist-linux-glibc2_31-builds: bindist +bindist-linux-glibc2_31-build-include: linux_debian_11-gcc_10.2-bindist +bindist-linux-glibc2_31-build-exclude: ** +bindist-linux-glibc2_31-build-config: +\ ++bpkg.bindist.archive: ++bbot.bindist.upload: +bpkg.bindist.archive:--recursive=auto +bpkg.bindist.archive:--archive-no-os +bpkg.bindist.archive:--archive-lang-impl=cc= +bpkg.bindist.archive:--archive-build-meta=+linux-glibc2.31 +bpkg.bindist.archive:config.install.relocatable=true +bpkg.create:config.bin.lib=static +bpkg.create:config.bin.liba.lib="shared static" +config.cc.loptions+="-static-libstdc++ -static-libgcc" +\ +#bindist-linux-glibc2_31-build-error-email: builds@codesynthesis.com diff --git a/tests/build/bootstrap.build b/tests/build/bootstrap.build new file mode 100644 index 0000000..33c8d02 --- /dev/null +++ b/tests/build/bootstrap.build @@ -0,0 +1,8 @@ +# file : tests/build/bootstrap.build +# license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +project = # Unnamed subproject. + +using config +using dist +using test diff --git a/tests/build/root.build b/tests/build/root.build new file mode 100644 index 0000000..dd7abe5 --- /dev/null +++ b/tests/build/root.build @@ -0,0 +1,16 @@ +# file : tests/build/root.build +# license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +# We need to configure C++ module to obtain the target information (see +# below). +# +using cxx.config + +# Import the XSD compiler we will be testing. +# +import! [metadata] xsd = xsd%exe{xsd} +testscript{*}: test = $xsd + +# Specify the test target for cross-testing. +# +test.target = $cxx.target diff --git a/tests/buildfile b/tests/buildfile new file mode 100644 index 0000000..201b1d7 --- /dev/null +++ b/tests/buildfile @@ -0,0 +1,4 @@ +# file : tests/buildfile +# license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +./: testscript $xsd diff --git a/tests/testscript b/tests/testscript new file mode 100644 index 0000000..7570d4d --- /dev/null +++ b/tests/testscript @@ -0,0 +1,26 @@ +# file : tests/testscript +# license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +: version +: +$* --version >>~/EOO/ +/CodeSynthesis XSD XML Schema to C\+\+ compiler .+/ +/.*/* +EOO + +: basics +: +cat <=test.xsd; + + + + + + + + + + +EOI +$* cxx-tree --generate-inline test.xsd &test.hxx &test.ixx &test.cxx; +test -f test.hxx && test -f test.ixx && test -f test.cxx diff --git a/xsd/buildfile b/xsd/buildfile new file mode 100644 index 0000000..d4e7af5 --- /dev/null +++ b/xsd/buildfile @@ -0,0 +1,121 @@ +# file : xsd/buildfile +# license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +import libs = libxsd-frontend%lib{xsd-frontend} +import libs += libcutl%lib{cutl} +import libs += libxerces-c%lib{xerces-c} + +ops = options cxx/options cxx/parser/options cxx/tree/options + +./: exe{xsd}: {hxx ixx txx cxx}{** -version -{$ops} -pregenerated/**} \ + {hxx}{version} \ + $libs + +# Target metadata, see also --build2-metadata in xsd.cxx. +# +# Note that xsd does not query any environment variables. +# +exe{xsd}: +{ + export.metadata = 1 xsd + xsd.name = [string] xsd + xsd.version = [string] $version + xsd.checksum = [string] $version +} + +hxx{version}: in{version} $src_root/manifest + +## Consumption build ($develop == false). +# + +# Use pregenerated versions in the consumption build. +# +exe{xsd}: pregenerated/{hxx ixx cxx}{**}: include = (!$develop) + +if! $develop + cxx.poptions =+ "-I($src_base/pregenerated)" # Note: must come first. + +# Distribute pregenerated versions only in the consumption build. +# +pregenerated/{hxx ixx cxx}{*}: dist = (!$develop) + +# +## + +## Development build ($develop == true). +# + +exe{xsd}: {hxx ixx cxx}{$ops}: include = $develop + +if $develop + import! [metadata] cli = cli%exe{cli} + +# In the development build distribute regenerated {hxx ixx cxx}{options}, +# remapping their locations to the paths of the pregenerated versions (which +# are only distributed in the consumption build; see above). This way we make +# sure that the distributed files are always up-to-date. +# +for f: $ops +{ + d = $directory($f) # empty, cxx/, etc. + + <{hxx ixx cxx}{$f}>: cli{$f} + { + dist = ($develop ? $relative([dir_path] "pregenerated/xsd/$d", $d) : false) + + # Symlink the generated code in src for convenience of development. + # + backlink = true + } +} + +: cli{~'/\1/'} $cli +% +if $develop +{{ + t = $path($>[0]).t + + depdb dyndep --byproduct --file $t + + h = $path($>[0]) + i = $path($>[1]) + c = $path($>[2]) + + d = $directory($h) + p = $string($leaf($d, $out_root)) # xsd, xsd/cxx, etc + + options = --std c++11 -I $src_root --include-prefix $p \ + --guard-prefix $regex.replace($ucase($p), '[/\\]', '_') \ + --generate-specifier --generate-file-scanner \ + --suppress-undocumented --ostream-type ::std::wostream \ + --exclude-base --include-with-brackets --option-length 28 \ + --cxx-prologue '#include ' + + $cli $options --generate-dep --dep-file $t -o $d $path($<[0]) + + # If the result differs from the pregenerated version, copy it over. + # + d = [dir_path] $src_base/pregenerated/$p + + dh = $d/$leaf($h) + di = $d/$leaf($i) + dc = $d/$leaf($c) + + if diff $dh $h >- && \ + diff $di $i >- && \ + diff $dc $c >- + exit + end + + cp $h $dh + cp $i $di + cp $c $dc +}} + +# +## + +# Pass the copyright notice extracted from the LICENSE file. +# +obj{xsd cxx/parser/generator cxx/tree/generator}: \ + cxx.poptions += -DXSD_COPYRIGHT=\"$copyright\" diff --git a/xsd/cxx/elements.cxx b/xsd/cxx/elements.cxx new file mode 100644 index 0000000..02a768e --- /dev/null +++ b/xsd/cxx/elements.cxx @@ -0,0 +1,1365 @@ +// file : xsd/cxx/elements.cxx +// license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +#include + +#include // std::toupper +#include +#include +#include +#include +#include + +using std::wcerr; +using std::endl; + +namespace CXX +{ + // + // + wchar_t + upcase (wchar_t c) + { + return std::toupper (c); + } + + namespace + { + wchar_t const* keywords[] = { + L"NULL", + L"and", + L"asm", + L"auto", + L"bitand", + L"bitor", + L"bool", + L"break", + L"case", + L"catch", + L"char", + L"class", + L"compl", + L"const", + L"const_cast", + L"continue", + L"default", + L"delete", + L"do", + L"double", + L"dynamic_cast", + L"else", + L"end_eq", + L"enum", + L"explicit", + L"export", + L"extern", + L"false", + L"float", + L"for", + L"friend", + L"goto", + L"if", + L"inline", + L"int", + L"long", + L"mutable", + L"namespace", + L"new", + L"not", + L"not_eq", + L"operator", + L"or", + L"or_eq", + L"private", + L"protected", + L"public", + L"register", + L"reinterpret_cast", + L"return", + L"short", + L"signed", + L"sizeof", + L"static", + L"static_cast", + L"struct", + L"switch", + L"template", + L"this", + L"throw", + L"true", + L"try", + L"typedef", + L"typeid", + L"typename", + L"union", + L"unsigned", + L"using", + L"virtual", + L"void", + L"volatile", + L"wchar_t", + L"while", + L"xor", + L"xor_eq" + }; + + // Note: excluding "identifiers with special meaning" in certain contexts + // ("final", "override") since they shouldn't cause any issues. + // + wchar_t const* keywords_cxx11[] = { + L"alignas", + L"alignof", + L"char16_t", + L"char32_t", + L"constexpr", + L"decltype", + L"noexcept", + L"nullptr", + L"static_assert", + L"thread_local" + }; + + // Note: excluding "identifiers with special meaning" in certain contexts + // ("import", "module") since they shouldn't cause any issues. + // + wchar_t const* keywords_cxx20[] = { + L"char8_t", + L"concept", + L"consteval", + L"constinit", + L"co_await", + L"co_return", + L"co_yield", + L"requires" + }; + } + + // Context + // + + Context:: + Context (std::wostream& o, + SemanticGraph::Schema& root, + SemanticGraph::Path const& path, + options_type const& ops, + StringLiteralMap const* string_literal_map_) + : os (o), + schema_root (root), + schema_path (schema_path_), + options (ops), + std (ops.std ()), + char_type (char_type_), + char_encoding (char_encoding_), + L (L_), + string_type (string_type_), + auto_ptr (auto_ptr_), + string_literal_map (string_literal_map_), + type_exp (type_exp_), + inst_exp (inst_exp_), + inl (inl_), + ns_mapping_cache (ns_mapping_cache_), + schema_path_ (path), + xs_ns_ (0), + char_type_ (ops.char_type ()), + char_encoding_ (ops.char_encoding ()), + L_ (char_type == L"wchar_t" ? L"L" : L""), + inl_ (ops.generate_inline () ? L"inline\n" : L""), + cxx_id_expr_ (L"^(::)?([a-zA-Z_]\\w*)(::[a-zA-Z_]\\w*)*$"), + cxx_id_expr (cxx_id_expr_), + urn_mapping_ (L"#^urn.*:([a-zA-Z_].*)$#$1#"), + urn_mapping (urn_mapping_), + nsr_mapping (nsr_mapping_), + nsm_mapping (nsm_mapping_), + include_mapping (include_mapping_), + reserved_name_map (reserved_name_map_), + keyword_set (keyword_set_) + { + // Export symbol. + // + { + String es (ops.export_symbol ()); + type_exp_ = es ? es + L" " : es; + inst_exp_ = es ? es + L"\n" : es; + } + + // Resolve and cache XML Schema namespace. + // + { + SemanticGraph::Nameable* n; + + if (schema_root.names_begin ()->name () == + L"http://www.w3.org/2001/XMLSchema") + { + // schema_root is the XML Schema itself. + // + n = &schema_root.names_begin ()->named (); + } + else + { + // Otherwise, the first used schema is implied XML Schema. + // + SemanticGraph::Uses& u = *schema_root.uses_begin (); + assert (u.is_a ()); + n = &u.schema ().names_begin ()->named (); + } + + xs_ns_ = dynamic_cast (n); + } + + // String type. + // + if (char_type == L"char") + string_type_ = L"::std::string"; + else if (char_type == L"wchar_t") + string_type_ = L"::std::wstring"; + else + string_type_ = L"::std::basic_string< " + char_type + L" >"; + + // Automatic pointer type. + // + auto_ptr_ = std >= cxx_version::cxx11 + ? "::std::unique_ptr" + : "::std::auto_ptr"; + + // Default encoding. + // + if (!char_encoding) + { + if (char_type == L"char") + char_encoding = L"utf8"; + else + char_encoding = L"auto"; + } + + // Default mapping. + // + nsr_mapping_.push_back ( + Regex (L"#^.* (.*?/)??" L"(([a-zA-Z_]\\w*)(/[a-zA-Z_]\\w*)*)/?$#$2#")); + nsr_mapping_.push_back ( + Regex (L"#^.* http://www\\.w3\\.org/2001/XMLSchema$#xml_schema#")); + + // Custom regex mapping. + // + for (NarrowStrings::const_iterator i (ops.namespace_regex ().begin ()), + e (ops.namespace_regex ().end ()); i != e; ++i) + { + nsr_mapping_.push_back (Regex (String (*i))); + } + + // Custom direct mapping. + // + for (NarrowStrings::const_iterator i (ops.namespace_map ().begin ()), + e (ops.namespace_map ().end ()); i != e; ++i) + { + String s (*i); + + // Split the string in two parts at the last '='. + // + size_t pos (s.rfind ('=')); + + if (pos == String::npos) + throw InvalidNamespaceMapping (s, "delimiter ('=') not found"); + + // Empty xml_ns designates the no-namespace case. + // + String xml_ns (s, 0, pos); + String cxx_ns (s, pos + 1); + + if (!cxx_ns.empty () && !cxx_id_expr.match (cxx_ns)) + throw InvalidNamespaceMapping (s, "invalid C++ identifier"); + + nsm_mapping_[xml_ns] = cxx_ns; + } + + // Include path regex + // + for (NarrowStrings::const_iterator i (ops.include_regex ().begin ()), + e (ops.include_regex ().end ()); i != e; ++i) + { + include_mapping_.push_back (Regex (String (*i))); + } + + // Reserved names. + // + for (NarrowStrings::const_iterator i (ops.reserved_name ().begin ()), + e (ops.reserved_name ().end ()); i != e; ++i) + { + String s (*i); + + // Split the string in two parts at '='. + // + size_t pos (s.find ('=')); + + if (pos == String::npos) + reserved_name_map_[s] = L""; + else + reserved_name_map_[String (s, 0, pos)] = String (s, pos + 1); + } + + // Populate the keyword set. + // + for (size_t i (0); i < sizeof (keywords) / sizeof (wchar_t*); ++i) + keyword_set_.insert (keywords[i]); + + if (std >= cxx_version::cxx11) + { + for (size_t i (0); i < sizeof (keywords_cxx11) / sizeof (wchar_t*); ++i) + keyword_set_.insert (keywords_cxx11[i]); + } + + if (std >= cxx_version::cxx20) + { + for (size_t i (0); i < sizeof (keywords_cxx20) / sizeof (wchar_t*); ++i) + keyword_set_.insert (keywords_cxx20[i]); + } + + } + + String Context:: + ns_name (SemanticGraph::Namespace& ns) + { + using SemanticGraph::Schema; + using SemanticGraph::Includes; + using SemanticGraph::Imports; + using SemanticGraph::Implies; + using SemanticGraph::Sources; + + String tmp; + MapMapping::const_iterator i (nsm_mapping.find (ns.name ())); + + if (i != nsm_mapping.end ()) + { + tmp = i->second; + } + else + { + SemanticGraph::Path path; + Schema& schema (dynamic_cast (ns.scope ())); + + if (schema.used_p ()) + { + // Here we need to detect a special multi-schema compilation + // case where the root schemas are imported into a special + // schema that doesn't have a namespace. + // + SemanticGraph::Uses& u (*schema.used_begin ()); + SemanticGraph::Schema& s (u.user ()); + + if (s.names_begin () != s.names_end ()) + path = u.path (); + } + else + path = schema_path; + + String pair; + + if (!path.empty ()) + { + path.normalize (); + + // Try to use the portable representation of the path. If that + // fails, fall back to the native representation. + // + try + { + pair = path.posix_string (); + } + catch (SemanticGraph::InvalidPath const&) + { + pair = path.string (); + } + } + + pair += L' ' + ns.name (); + + // Check cache first + // + MappingCache::const_iterator i (ns_mapping_cache.find (pair)); + + if (i != ns_mapping_cache.end ()) + { + tmp = i->second; + } + else + { + bool trace (options.namespace_regex_trace ()); + + if (trace) + wcerr << "namespace: '" << pair << "'" << endl; + + bool found (false); + Regex colon (L"#/#::#"); + + for (RegexMapping::const_reverse_iterator e (nsr_mapping.rbegin ()); + e != nsr_mapping.rend (); ++e) + { + if (trace) + wcerr << "try: '" << e->regex () << "' : "; + + if (e->match (pair)) + { + tmp = e->replace (pair); + tmp = colon.replace (tmp); // replace `/' with `::' + + // Check the result. + // + found = cxx_id_expr.match (tmp); + + if (trace) + wcerr << "'" << tmp << "' : "; + } + + if (trace) + wcerr << (found ? '+' : '-') << endl; + + if (found) + break; + } + + if (!found) + { + String const& n (ns.name ()); + + // Check if the name is valid by itself. + // + if (n.empty ()) + { + // Empty name denotes a no-namespace case. + // + tmp = n; + } + else + { + tmp = colon.replace (n); // replace `/' with `::' + + if (!cxx_id_expr.match (tmp)) + { + // See if this is a urn-style namespace. + // + if (urn_mapping.match (n)) + { + Regex filter (L"#[.:-]#_#"); + tmp = urn_mapping.replace (n); + tmp = filter.replace (tmp); + + if (!cxx_id_expr.match (tmp)) + throw NoNamespaceMapping ( + ns.file (), ns.line (), ns.column (), ns.name ()); + } + else + throw NoNamespaceMapping ( + ns.file (), ns.line (), ns.column (), ns.name ()); + } + } + } + + // Add the mapping to the cache. + // + ns_mapping_cache[pair] = tmp; + } + } + + + // Parse resulting namespace string and id() each name. + // + String r; + String::size_type b (0), e; + + do + { + e = tmp.find (L"::", b); + + String name (tmp, b, e == tmp.npos ? e : e - b); + + if (!name.empty ()) + r += L"::" + escape (name); + + b = e; + + if (b == tmp.npos) + break; + + b += 2; + + } while (true); + + return r; + } + + SemanticGraph::Namespace& Context:: + xs_ns () + { + return *xs_ns_; + } + + String Context:: + xs_ns_name () + { + return ns_name (*xs_ns_); + } + + SemanticGraph::Namespace& Context:: + namespace_ (SemanticGraph::Nameable& n) + { + // The basic idea goes like this: go up Names edges until you + // reach Namespace. There are, however, anonymous types which + // need special handling. In the case of an anonymous type we + // will go up the first Belongs edge (because the first edge + // is where the type was defined. + // + + if (n.named_p ()) + { + SemanticGraph::Scope& s (n.scope ()); + + SemanticGraph::Namespace* ns ( + dynamic_cast (&n)); + + return ns ? *ns : namespace_ (s); + } + else + { + SemanticGraph::Type& t (dynamic_cast (n)); + + SemanticGraph::Belongs& b (*t.classifies_begin ()); + + return namespace_ (b.instance ()); + } + } + + String Context:: + xml_ns_name (SemanticGraph::Nameable& n) + { + return namespace_ (n).name (); + } + + String Context:: + fq_name (SemanticGraph::Nameable& n, char const* name_key) + { + using namespace SemanticGraph; + + String r; + + if (dynamic_cast (&n)) + { + return L""; // Map to global namespace. + } + else if (SemanticGraph::Namespace* ns = + dynamic_cast (&n)) + { + r = ns_name (*ns); + } + else + { + r = fq_name (n.scope ()); + r += L"::"; + r += n.context ().get (name_key); + } + + return r; + } + + SemanticGraph::Type& Context:: + ultimate_base (SemanticGraph::Complex& c) + { + using namespace SemanticGraph; + + Type* b (&c.inherits ().base ()); + + while (true) + { + Complex* cb (dynamic_cast (b)); + + if (cb != 0 && cb->inherits_p ()) + { + b = &cb->inherits ().base (); + continue; + } + + break; + } + + return *b; + } + + String Context:: + escape (String const& name) + { + String r; + size_t n (name.size ()); + + // In most common cases we will have that many chars. + // + r.reserve (n); + + for (size_t i (0); i < n; ++i) + { + bool first (i == 0); + + unsigned int u (unicode_char (name, i)); // May advance i. + + if (first) + { + if (!((u >= 'a' && u <= 'z') || + (u >= 'A' && u <= 'Z') || + u == '_')) + r = (u >= '0' && u <= '9') ? L"cxx_" : L"cxx"; + } + + if (!((u >= 'a' && u <= 'z') || + (u >= 'A' && u <= 'Z') || + (u >= '0' && u <= '9') || + u == '_')) + r.push_back ('_'); + else + r.push_back (static_cast (u)); + } + + if (r.empty ()) + r = L"cxx"; + + // Custom reserved words. + // + ReservedNameMap::const_iterator i (reserved_name_map.find (r)); + + if (i != reserved_name_map.end ()) + { + if (i->second) + return i->second; + else + r += L'_'; + } + + // Keywords + // + if (keyword_set.find (r) != keyword_set.end ()) + { + r += L'_'; + + // Re-run custom words. + // + i = reserved_name_map.find (r); + + if (i != reserved_name_map.end ()) + { + if (i->second) + return i->second; + else + r += L'_'; + } + } + + return r; + } + + // String escaping. + // + + String + charlit (unsigned int u) + { + String r ("\\x"); + bool lead (true); + + for (int i (7); i >= 0; --i) + { + unsigned int x ((u >> (i * 4)) & 0x0F); + + if (lead) + { + if (x == 0) + continue; + + lead = false; + } + + r += x < 10 ? ('0' + x) : ('A' + x - 10); + } + + return r; + } + + String + strlit_ascii (String const& str) + { + String r; + size_t n (str.size ()); + + // In most common cases we will have that many chars. + // + r.reserve (n + 2); + + r += '"'; + + bool escape (false); + + for (size_t i (0); i < n; ++i) + { + unsigned int u (Context::unicode_char (str, i)); // May advance i. + + // [128 - ] - unrepresentable + // 127 - \x7F + // [32 - 126] - as is + // [0 - 31] - \X or \xXX + // + + if (u < 32 || u == 127) + { + switch (u) + { + case L'\n': + { + r += L"\\n"; + break; + } + case L'\t': + { + r += L"\\t"; + break; + } + case L'\v': + { + r += L"\\v"; + break; + } + case L'\b': + { + r += L"\\b"; + break; + } + case L'\r': + { + r += L"\\r"; + break; + } + case L'\f': + { + r += L"\\f"; + break; + } + case L'\a': + { + r += L"\\a"; + break; + } + default: + { + r += charlit (u); + escape = true; + break; + } + } + } + else if (u < 127) + { + if (escape) + { + // Close and open the string so there are no clashes. + // + r += '"'; + r += '"'; + + escape = false; + } + + switch (u) + { + case L'"': + { + r += L"\\\""; + break; + } + case L'\\': + { + r += L"\\\\"; + break; + } + default: + { + r += static_cast (u); + break; + } + } + } + else + { + // Unrepresentable character. + // + throw UnrepresentableCharacter (str, i + 1); + } + } + + r += '"'; + + return r; + } + + const unsigned int utf8_first_char_mask[5] = + { + 0x00, 0x00, 0xC0, 0xE0, 0xF0 + }; + + String + strlit_utf8 (String const& str) + { + String r; + size_t n (str.size ()); + + // In most common cases we will have that many chars. + // + r.reserve (n + 2); + + r += '"'; + + bool escape (false); + + for (size_t i (0); i < n; ++i) + { + unsigned int u (Context::unicode_char (str, i)); // May advance i. + + // [128 - ] - UTF-8 + // 127 - \x7F + // [32 - 126] - as is + // [0 - 31] - \X or \xXX + // + + if (u < 32 || u == 127) + { + switch (u) + { + case L'\n': + { + r += L"\\n"; + break; + } + case L'\t': + { + r += L"\\t"; + break; + } + case L'\v': + { + r += L"\\v"; + break; + } + case L'\b': + { + r += L"\\b"; + break; + } + case L'\r': + { + r += L"\\r"; + break; + } + case L'\f': + { + r += L"\\f"; + break; + } + case L'\a': + { + r += L"\\a"; + break; + } + default: + { + r += charlit (u); + escape = true; + break; + } + } + } + else if (u < 127) + { + if (escape) + { + // Close and open the string so there are no clashes. + // + r += '"'; + r += '"'; + + escape = false; + } + + switch (u) + { + case L'"': + { + r += L"\\\""; + break; + } + case L'\\': + { + r += L"\\\\"; + break; + } + default: + { + r += static_cast (u); + break; + } + } + } + else + { + unsigned int count (0); + unsigned int tmp[4]; + + if (u < 0x800) + count = 2; + else if (u < 0x10000) + count = 3; + else if (u < 0x110000) + count = 4; + + switch (count) + { + case 4: + { + tmp[3] = (u | 0x80UL) & 0xBFUL; + u >>= 6; + } + // Fall through. + case 3: + { + tmp[2] = (u | 0x80UL) & 0xBFUL; + u >>= 6; + } + // Fall through. + case 2: + { + tmp[1] = (u | 0x80UL) & 0xBFUL; + u >>= 6; + } + // Fall through. + case 1: + { + tmp[0] = u | utf8_first_char_mask[count]; + break; + } + default: + assert (false); + } + + for (unsigned int j (0); j < count; ++j) + r += charlit (tmp[j]); + + escape = true; + } + } + + r += '"'; + + return r; + } + + String + strlit_iso8859_1 (String const& str) + { + String r; + size_t n (str.size ()); + + // In most common cases we will have that many chars. + // + r.reserve (n + 2); + + r += '"'; + + bool escape (false); + + for (size_t i (0); i < n; ++i) + { + unsigned int u (Context::unicode_char (str, i)); // May advance i. + + // [256 - ] - unrepresentable + // [127 - 255] - \xXX + // [32 - 126] - as is + // [0 - 31] - \X or \xXX + // + + if (u < 32) + { + switch (u) + { + case L'\n': + { + r += L"\\n"; + break; + } + case L'\t': + { + r += L"\\t"; + break; + } + case L'\v': + { + r += L"\\v"; + break; + } + case L'\b': + { + r += L"\\b"; + break; + } + case L'\r': + { + r += L"\\r"; + break; + } + case L'\f': + { + r += L"\\f"; + break; + } + case L'\a': + { + r += L"\\a"; + break; + } + default: + { + r += charlit (u); + escape = true; + break; + } + } + } + else if (u < 127) + { + if (escape) + { + // Close and open the string so there are no clashes. + // + r += '"'; + r += '"'; + + escape = false; + } + + switch (u) + { + case L'"': + { + r += L"\\\""; + break; + } + case L'\\': + { + r += L"\\\\"; + break; + } + default: + { + r += static_cast (u); + break; + } + } + } + else if (u < 256) + { + r += charlit (u); + escape = true; + } + else + { + // Unrepresentable character. + // + throw UnrepresentableCharacter (str, i + 1); + } + } + + r += '"'; + + return r; + } + + String + strlit_utf32 (String const& str) + { + String r; + size_t n (str.size ()); + + // In most common cases we will have that many chars. + // + r.reserve (n + 3); + + r += L"L\""; + + bool escape (false); + + for (size_t i (0); i < n; ++i) + { + unsigned int u (Context::unicode_char (str, i)); // May advance i. + + // [128 - ] - \xUUUUUUUU + // 127 - \x7F + // [32 - 126] - as is + // [0 - 31] - \X or \xXX + // + + if (u < 32 || u == 127) + { + switch (u) + { + case L'\n': + { + r += L"\\n"; + break; + } + case L'\t': + { + r += L"\\t"; + break; + } + case L'\v': + { + r += L"\\v"; + break; + } + case L'\b': + { + r += L"\\b"; + break; + } + case L'\r': + { + r += L"\\r"; + break; + } + case L'\f': + { + r += L"\\f"; + break; + } + case L'\a': + { + r += L"\\a"; + break; + } + default: + { + r += charlit (u); + escape = true; + break; + } + } + } + else if (u < 127) + { + if (escape) + { + // Close and open the string so there are no clashes. C++11 + // requires a space between " and L. + // + r += L"\" L\""; + escape = false; + } + + switch (u) + { + case L'"': + { + r += L"\\\""; + break; + } + case L'\\': + { + r += L"\\\\"; + break; + } + default: + { + r += static_cast (u); + break; + } + } + } + else + { + r += charlit (u); + escape = true; + } + } + + r += '"'; + + return r; + } + + String Context:: + strlit (String const& str) + { + // First see if we have a custom mapping. + // + assert (string_literal_map != 0); + StringLiteralMap::const_iterator i (string_literal_map->find (str)); + + if (i != string_literal_map->end ()) + return i->second; + + if (char_type == L"char") + { + if (char_encoding == L"utf8") + return strlit_utf8 (str); + else if (char_encoding == L"iso8859-1") + return strlit_iso8859_1 (str); + else + { + // For LCP, custom, and other unknown encodings, use ASCII. + // + return strlit_ascii (str); + } + } + else + return strlit_utf32 (str); + } + + String Context:: + comment (String const& str) + { + String r; + + wchar_t const* s (str.c_str ()); + size_t size (str.size ()); + + // In most common cases we will have that many chars. + // + r.reserve (size); + + for (wchar_t const* p (s); p < s + size; ++p) + { + unsigned int u (unicode_char (p)); // May advance p. + + // We are going to treat \v, \f and \n as unrepresentable + // here even though they can be present in C++ source code. + // + if (u > 127 || (u < 32 && u != '\t')) + r += L'?'; + else + r += static_cast (u); + } + + return r; + } + + String Context:: + process_include_path (String const& name) const + { + String path (String (options.include_prefix ()) + name); + bool trace (options.include_regex_trace ()); + + if (trace) + wcerr << "include: '" << path << "'" << endl; + + String r; + bool found (false); + + for (RegexMapping::const_reverse_iterator e (include_mapping.rbegin ()); + e != include_mapping.rend (); ++e) + { + if (trace) + wcerr << "try: '" << e->regex () << "' : "; + + if (e->match (path)) + { + r = e->replace (path); + found = true; + + if (trace) + wcerr << "'" << r << "' : "; + } + + if (trace) + wcerr << (found ? '+' : '-') << endl; + + if (found) + break; + } + + if (!found) + r = path; + + if (!r.empty () && r[0] != L'"' && r[0] != L'<') + { + wchar_t op (options.include_with_brackets () ? L'<' : L'"'); + wchar_t cl (options.include_with_brackets () ? L'>' : L'"'); + r = op + r + cl; + } + + return r; + } + + // Namespace + // + + void Namespace:: + pre (Type& n) + { + String ns (ctx_.ns_name (n)); + + String::size_type b (0), e; + + if (st_) + st_->enter (n, L"", ns ? false : true); + + do + { + e = ns.find (L"::", b); + + String name (ns, b, e == ns.npos ? e : e - b); + + if (!name.empty ()) + { + if (st_) + st_->enter (n, name, e == ns.npos); + + ctx_.os << "namespace " << name << "{"; + } + + b = e; + + if (b == ns.npos) + break; + + b += 2; + + } while (true); + } + + void Namespace:: + post (Type& n) + { + String ns (ctx_.ns_name (n)); + + String::size_type b (0), e; + + do + { + e = ns.find (L"::", b); + + String name (ns, b, e == ns.npos ? e : e - b); + + if (!name.empty ()) + { + ctx_.os << "}"; + + if (st_) + st_->leave (); + } + + + b = e; + + if (b == ns.npos) + break; + + b += 2; + + } + while (true); + + if (st_) + st_->leave (); + } +} diff --git a/xsd/cxx/elements.hxx b/xsd/cxx/elements.hxx new file mode 100644 index 0000000..62ba97c --- /dev/null +++ b/xsd/cxx/elements.hxx @@ -0,0 +1,626 @@ +// file : xsd/cxx/elements.hxx +// license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +#ifndef XSD_CXX_ELEMENTS_HXX +#define XSD_CXX_ELEMENTS_HXX + +#include +#include +#include +#include + +#include + +#include +#include + +#include +#include + +#include +#include + +namespace CXX +{ + using std::endl; + + // On some platforms std::toupper can be something other than a + // function with C++ linkage. + // + wchar_t + upcase (wchar_t c); + + + // Exceptions. + // + + struct UnrepresentableCharacter + { + UnrepresentableCharacter (String const& str, size_t pos) + : str_ (str), pos_ (pos) + { + } + + String const& + string () const + { + return str_; + } + + size_t + position () const + { + return pos_; + } + + private: + String str_; + size_t pos_; + }; + + struct NoNamespaceMapping + { + NoNamespaceMapping (SemanticGraph::Path const& file, + size_t line, + size_t column, + String const& ns) + : file_ (file), + line_ (line), + column_ (column), + ns_ (ns) + { + } + + + SemanticGraph::Path const& + file () const + { + return file_; + } + + size_t + line () const + { + return line_; + } + + size_t + column () const + { + return column_; + } + + String const& + ns () const + { + return ns_; + } + + private: + SemanticGraph::Path file_; + size_t line_; + size_t column_; + String ns_; + }; + + struct InvalidNamespaceMapping + { + InvalidNamespaceMapping (String const& mapping, + String const& reason) + : mapping_ (mapping), reason_ (reason) + { + } + + String const& + mapping () const + { + return mapping_; + } + + String const& + reason () const + { + return reason_; + } + + private: + String mapping_; + String reason_; + }; + + // + // + class Context + { + public: + typedef cutl::re::wregex RegexPat; + typedef cutl::re::wregexsub Regex; + typedef std::vector RegexMapping; + typedef std::map MapMapping; + typedef std::map MappingCache; + + typedef std::map ReservedNameMap; + typedef std::set KeywordSet; + + typedef CXX::options options_type; + + public: + Context (std::wostream& o, + SemanticGraph::Schema& root, + SemanticGraph::Path const& path, + options_type const& ops, + StringLiteralMap const* custom_literals_map); + + protected: + Context (Context& c) + : os (c.os), + schema_root (c.schema_root), + schema_path (c.schema_path), + options (c.options), + std (c.std), + char_type (c.char_type), + char_encoding (c.char_encoding), + L (c.L), + string_type (c.string_type), + auto_ptr (c.auto_ptr), + string_literal_map (c.string_literal_map), + type_exp (c.type_exp), + inst_exp (c.inst_exp), + inl (c.inl), + ns_mapping_cache (c.ns_mapping_cache), + xs_ns_ (c.xs_ns_), + cxx_id_expr (c.cxx_id_expr), + urn_mapping (c.urn_mapping), + nsr_mapping (c.nsr_mapping), + nsm_mapping (c.nsm_mapping), + include_mapping (c.include_mapping), + reserved_name_map (c.reserved_name_map), + keyword_set (c.keyword_set) + { + } + + Context (Context& c, std::wostream& o) + : os (o), + schema_root (c.schema_root), + schema_path (c.schema_path), + options (c.options), + std (c.std), + char_type (c.char_type), + char_encoding (c.char_encoding), + L (c.L), + string_type (c.string_type), + auto_ptr (c.auto_ptr), + string_literal_map (c.string_literal_map), + type_exp (c.type_exp), + inst_exp (c.inst_exp), + inl (c.inl), + ns_mapping_cache (c.ns_mapping_cache), + xs_ns_ (c.xs_ns_), + cxx_id_expr (c.cxx_id_expr), + urn_mapping (c.urn_mapping), + nsr_mapping (c.nsr_mapping), + nsm_mapping (c.nsm_mapping), + include_mapping (c.include_mapping), + reserved_name_map (c.reserved_name_map), + keyword_set (c.keyword_set) + { + } + + public: + static String + unclash (String const& name, String const& new_name) + { + return name == new_name ? (new_name + L'_') : new_name; + } + + public: + // Return UTF-32 character starting at this position. Position is + // advanced by 1 if this Unicode character takes more than one + // underlying character. + // + static unsigned int + unicode_char (String const& str, size_t& pos); + + static unsigned int + unicode_char (wchar_t const*& p); + + // Escape C++ keywords and illegal characters. + // + String + escape (String const&); + + // Create a string literal so that it can be used in C++ source + // code. It includes "". + // + String + strlit (String const&); + + // Escape the string so that it can be used in C++ comment. + // + String + comment (String const&); + + // Translate XML namespace name to a C++ identifier. + // + String + ns_name (SemanticGraph::Namespace&); + + // XML Schema namespace. + // + SemanticGraph::Namespace& + xs_ns (); + + // C++ namespace for XML Schema. + // + String + xs_ns_name (); + + // + // + SemanticGraph::Namespace& + namespace_ (SemanticGraph::Nameable& n); + + // Original XML namespace name. + // + String + xml_ns_name (SemanticGraph::Nameable& ns); + + + // Fully-qualified C++ name. + // + String + fq_name (SemanticGraph::Nameable& n, char const* name_key = "name"); + + public: + static SemanticGraph::Type& + ultimate_base (SemanticGraph::Complex&); + + public: + String + process_include_path (String const&) const; + + public: + static bool + skip (SemanticGraph::Member& m) + { + // "Subsequent" local element. + // + return !m.scope ().is_a () && + m.context ().count ("min") == 0; + } + + static size_t + min (SemanticGraph::Member const& m) + { + return m.context ().get ("min"); + } + + static size_t + min (SemanticGraph::Any const& a) + { + return a.context ().get ("min"); + } + + static size_t + max (SemanticGraph::Member const& m) + { + return m.context ().get ("max"); + } + + static size_t + max (SemanticGraph::Any const& a) + { + return a.context ().get ("max"); + } + + public: + // Get escaped name. + // + static String const& + ename (SemanticGraph::Nameable const& n) + { + return n.context ().get ("name"); + } + + public: + std::wostream& os; + + SemanticGraph::Schema& schema_root; + SemanticGraph::Path const& schema_path; + + options_type const& options; + + cxx_version std; + + String& char_type; + String& char_encoding; + String& L; // string literal prefix + String& string_type; + String& auto_ptr; + + StringLiteralMap const* string_literal_map; + + String& type_exp; + String& inst_exp; + String& inl; + + public: + MappingCache& ns_mapping_cache; + + private: + SemanticGraph::Path const schema_path_; + + SemanticGraph::Namespace* xs_ns_; + + String char_type_; + String char_encoding_; + String L_; + String string_type_; + String auto_ptr_; + + String type_exp_; + String inst_exp_; + String inl_; + + private: + RegexPat const cxx_id_expr_; + RegexPat const& cxx_id_expr; + Regex urn_mapping_; + RegexMapping nsr_mapping_; + MapMapping nsm_mapping_; + Regex const& urn_mapping; + RegexMapping const& nsr_mapping; + MapMapping const& nsm_mapping; + MappingCache ns_mapping_cache_; + + RegexMapping include_mapping_; + RegexMapping const& include_mapping; + + ReservedNameMap const& reserved_name_map; + ReservedNameMap reserved_name_map_; + + KeywordSet const& keyword_set; + KeywordSet keyword_set_; + }; + + inline unsigned int Context:: + unicode_char (String const& str, size_t& pos) + { + if (sizeof (wchar_t) == 4) + { + return str[pos]; + } + else if (sizeof (wchar_t) == 2) + { + wchar_t x (str[pos]); + + if (x < 0xD800 || x > 0xDBFF) + return x; + else + return ((x - 0xD800) << 10) + (str[++pos] - 0xDC00) + 0x10000; + } + else + return 0; + } + + inline unsigned int Context:: + unicode_char (wchar_t const*& p) + { + if (sizeof (wchar_t) == 4) + { + return *p; + } + else if (sizeof (wchar_t) == 2) + { + wchar_t x (*p); + + if (x < 0xD800 || x > 0xDBFF) + return x; + else + return ((x - 0xD800) << 10) + (*(++p) - 0xDC00) + 0x10000; + } + else + return 0; + } + + // Sources traverser that goes into each schema only once. + // + struct Sources: Traversal::Sources + { + virtual void + traverse (SemanticGraph::Sources& s) + { + if (schemas_.insert (&s.schema ()).second) + Traversal::Sources::traverse (s); + } + + private: + std::set schemas_; + }; + + // Usual namespace mapping. + // + struct Namespace: Traversal::Namespace + { + struct ScopeTracker + { + // First scope name if always empty (global scope). The last flag + // signals the last scope. + // + virtual void + enter (Type&, String const& name, bool last) = 0; + + virtual void + leave () = 0; + }; + + + Namespace (Context& c) + : ctx_ (c), st_ (0) + { + } + + Namespace (Context& c, ScopeTracker& st) + : ctx_ (c), st_ (&st) + { + } + + virtual void + pre (Type&); + + virtual void + post (Type&); + + private: + Context& ctx_; + ScopeTracker* st_; + }; + + // + // + template + struct Has : X + { + Has (bool& result) + : result_ (result) + { + } + + virtual void + traverse (typename X::Type&) + { + result_ = true; + } + + private: + bool& result_; + }; + + // Checks if scope 'Y' names any of 'X' + // + template + bool + has (Y& y) + { + using SemanticGraph::Scope; + + bool result (false); + Has t (result); + + for (Scope::NamesIterator i (y.names_begin ()), e (y.names_end ()); + !result && i != e; ++i) + t.dispatch (i->named ()); + + return result; + } + + // Checks if the compositor has any particle of 'X' + // + template + bool + has_particle (SemanticGraph::Compositor& y) + { + using SemanticGraph::Compositor; + + bool result (false); + Has t (result); + + for (Compositor::ContainsIterator i (y.contains_begin ()), + e (y.contains_end ()); !result && i != e; ++i) + { + SemanticGraph::Particle& p (i->particle ()); + + t.dispatch (p); + + if (!result && p.is_a ()) + result = has_particle (dynamic_cast (p)); + } + + return result; + } + + // Specialization for Complex + // + template + bool + has_particle (SemanticGraph::Complex& c) + { + return c.contains_compositor_p () && + has_particle (c.contains_compositor ().compositor ()); + } + + // Fundamental type mapping helper. + // + struct Fundamental: Traversal::Fundamental::Type, + Traversal::Fundamental::String, + Traversal::Fundamental::NormalizedString, + Traversal::Fundamental::Token, + Traversal::Fundamental::Name, + Traversal::Fundamental::NameToken, + Traversal::Fundamental::NCName, + Traversal::Fundamental::Id, + Traversal::Fundamental::IdRef + { + virtual void + fundamental_type (SemanticGraph::Fundamental::Type& t) = 0; + + virtual void + fundamental_template (SemanticGraph::Fundamental::Type& t) = 0; + + virtual void + traverse (SemanticGraph::Fundamental::Type& t) + { + fundamental_type (t); + } + + virtual void + traverse (SemanticGraph::Fundamental::String& t) + { + fundamental_template (t); + } + + virtual void + traverse (SemanticGraph::Fundamental::NormalizedString& t) + { + fundamental_template (t); + } + + virtual void + traverse (SemanticGraph::Fundamental::Token& t) + { + fundamental_template (t); + } + + virtual void + traverse (SemanticGraph::Fundamental::Name& t) + { + fundamental_template (t); + } + + virtual void + traverse (SemanticGraph::Fundamental::NameToken& t) + { + fundamental_template (t); + } + + virtual void + traverse (SemanticGraph::Fundamental::NCName& t) + { + fundamental_template (t); + } + + virtual void + traverse (SemanticGraph::Fundamental::Id& t) + { + fundamental_template (t); + } + + virtual void + traverse (SemanticGraph::Fundamental::IdRef& t) + { + fundamental_template (t); + } + }; +} + +#endif // XSD_CXX_TREE_ELEMENTS_HXX diff --git a/xsd/cxx/literal-map.cxx b/xsd/cxx/literal-map.cxx new file mode 100644 index 0000000..b81f249 --- /dev/null +++ b/xsd/cxx/literal-map.cxx @@ -0,0 +1,261 @@ +// file : xsd/cxx/literal-map.cxx +// license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +#include // std::unique_ptr +#include // std::size_t +#include +#include + +#include + +#include + +#include +#include +#include +#include +#include + +#include + +#include + +using namespace std; +using namespace xercesc; +namespace XML = XSDFrontend::XML; + +namespace CXX +{ + class Handler: public DefaultHandler + { + public: + struct Failed {}; + + Handler (String const& file, StringLiteralMap& map) + : state_ (s_init), file_ (file), map_ (map) + { + } + + virtual void + setDocumentLocator (const Locator* const l) + { + locator_ = l; + } + + virtual void + startElement (const XMLCh* const, + const XMLCh* const lname, + const XMLCh* const, + const xercesc::Attributes&) + { + String n (XML::transcode (lname)); + + if (n == L"string-literal-map" && state_ == s_init) + state_ = s_map; + else if (n == L"entry" && state_ == s_map) + { + str_seen_ = false; + lit_seen_ = false; + state_ = s_entry; + } + else if (n == L"string" && state_ == s_entry) + { + str_seen_ = true; + str_.clear (); + state_ = s_string; + } + else if (n == L"literal" && state_ == s_entry) + { + lit_seen_ = true; + lit_.clear (); + state_ = s_literal; + } + else + { + wcerr << file_ << ":" << line () << ":" << col () << ": error: " + << "unexpected element '" << n << "'" << endl; + throw Failed (); + } + } + + virtual void + endElement (const XMLCh* const, + const XMLCh* const lname, + const XMLCh* const) + { + String n (XML::transcode (lname)); + + if (n == L"string-literal-map") + state_ = s_init; + else if (n == L"entry") + { + if (!str_seen_) + { + wcerr << file_ << ":" << line () << ":" << col () << ": error: " + << "expected 'string' element" << endl; + throw Failed (); + } + + if (!lit_seen_) + { + wcerr << file_ << ":" << line () << ":" << col () << ": error: " + << "expected 'literal' element" << endl; + throw Failed (); + } + + map_[str_] = lit_; + state_ = s_map; + } + else if (n == L"string") + state_ = s_entry; + else if (n == L"literal") + state_ = s_entry; + } + + virtual void + characters (const XMLCh* const s, const XMLSize_t length) + { + String str (XML::transcode (s, length)); + + if (state_ == s_string) + str_ += str; + else if (state_ == s_literal) + lit_ += str; + else + { + for (size_t i (0); i < str.size (); ++i) + { + wchar_t c (str[i]); + + if (c != 0x20 && c != 0x0A && c != 0x0D && c != 0x09) + { + wcerr << file_ << ":" << line () << ":" << col () << ": error: " + << "unexpected character data" << endl; + throw Failed (); + } + } + } + } + + // Error hanlding. + // + enum Severity {s_warning, s_error, s_fatal}; + + virtual void + warning (const SAXParseException& e) + { + handle (e, s_warning); + } + + virtual void + error (const SAXParseException& e) + { + handle (e, s_error); + } + + virtual void + fatalError (const SAXParseException& e) + { + handle (e, s_fatal); + } + + virtual void + resetErrors () + { + } + + void + handle (const SAXParseException& e, Severity s) + { + String msg (XML::transcode (e.getMessage ())); + + wcerr << file_ << ":" + << e.getLineNumber () << ":" << e.getColumnNumber () << ": " + << (s == s_warning ? "warning: " : "error: ") << msg << endl; + + if (s != s_warning) + throw Failed (); + } + + size_t + line () const + { + return locator_ != 0 + ? static_cast (locator_->getLineNumber ()) + : 0; + } + + size_t + col () const + { + return locator_ != 0 + ? static_cast (locator_->getColumnNumber ()) + : 0; + } + + private: + const Locator* locator_; + + enum + { + s_init, + s_map, + s_entry, + s_string, + s_literal + } state_; + + String file_; + StringLiteralMap& map_; + + bool str_seen_; + bool lit_seen_; + + String str_; + String lit_; + }; + + bool + read_literal_map (NarrowString const& file, StringLiteralMap& map) + { + try + { + // Try to open the file with fstream. This way we get to + // report the error in a consistent manner. + // + { + ifstream ifs (file.c_str ()); + if (!ifs.is_open ()) + { + wcerr << file.c_str () << ": unable to open in read mode" << endl; + return false; + } + } + + String wfile (file); + + LocalFileInputSource is (XML::XMLChString (wfile).c_str ()); + Handler h (wfile, map); + + unique_ptr parser ( + XMLReaderFactory::createXMLReader ()); + + parser->setFeature (XMLUni::fgSAX2CoreNameSpaces, true); + parser->setFeature (XMLUni::fgSAX2CoreNameSpacePrefixes, true); + parser->setFeature (XMLUni::fgSAX2CoreValidation, false); + parser->setFeature (XMLUni::fgXercesSchema, false); + parser->setFeature (XMLUni::fgXercesSchemaFullChecking, false); + + parser->setErrorHandler (&h); + parser->setContentHandler (&h); + + parser->parse (is); + } + catch (Handler::Failed const&) + { + return false; + } + + return true; + } +} diff --git a/xsd/cxx/literal-map.hxx b/xsd/cxx/literal-map.hxx new file mode 100644 index 0000000..bc8fabb --- /dev/null +++ b/xsd/cxx/literal-map.hxx @@ -0,0 +1,19 @@ +// file : xsd/cxx/literal-map.hxx +// license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +#ifndef XSD_CXX_LITERAL_MAP_HXX +#define XSD_CXX_LITERAL_MAP_HXX + +#include + +#include + +namespace CXX +{ + typedef std::map StringLiteralMap; + + bool + read_literal_map (NarrowString const& file, StringLiteralMap& map); +} + +#endif // XSD_CXX_LITERAL_MAP_HXX diff --git a/xsd/cxx/option-types.cxx b/xsd/cxx/option-types.cxx new file mode 100644 index 0000000..8744d7f --- /dev/null +++ b/xsd/cxx/option-types.cxx @@ -0,0 +1,59 @@ +// file : xsd/cxx/option-types.cxx +// license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +#include +#include + +#include + +using namespace std; + +namespace CXX +{ + // + // cxx_version + // + + static const char* cxx_version_[] = + { + "c++98", + "c++11", + "c++14", + "c++17", + "c++20", + "c++23", + }; + + string cxx_version:: + string () const + { + return cxx_version_[v_]; + } + + istream& + operator>> (istream& is, cxx_version& v) + { + string s; + is >> s; + + if (!is.fail ()) + { + if (s == "c++98") + v = cxx_version::cxx98; + else if (s == "c++11") + v = cxx_version::cxx11; + else if (s == "c++14") + v = cxx_version::cxx14; + else if (s == "c++17") + v = cxx_version::cxx17; + else if (s == "c++20") + v = cxx_version::cxx20; + else if (s == "c++23") + v = cxx_version::cxx23; + else + is.setstate (istream::failbit); + } + + return is; + } +} diff --git a/xsd/cxx/option-types.hxx b/xsd/cxx/option-types.hxx new file mode 100644 index 0000000..98a493a --- /dev/null +++ b/xsd/cxx/option-types.hxx @@ -0,0 +1,38 @@ +// file : xsd/cxx/option-types.hxx +// license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +#ifndef XSD_XSD_OPTION_TYPES_HXX +#define XSD_XSD_OPTION_TYPES_HXX + +#include +#include + +namespace CXX +{ + struct cxx_version + { + enum value + { + cxx98, + cxx11, + cxx14, + cxx17, + cxx20, + cxx23 + }; + + cxx_version (value v) : v_ (v) {} + operator value () const {return v_;} + + std::string + string () const; + + private: + value v_; + }; + + std::istream& + operator>> (std::istream&, cxx_version&); +} + +#endif // XSD_XSD_OPTION_TYPES_HXX diff --git a/xsd/cxx/options.cli b/xsd/cxx/options.cli new file mode 100644 index 0000000..1be7607 --- /dev/null +++ b/xsd/cxx/options.cli @@ -0,0 +1,560 @@ +// file : xsd/cxx/options.cli +// license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +include ; // std::size_t + +include ; // NarrowString, NarrowStrings + +include ; + +include ; + +namespace CXX +{ + class options: ::options = 0 + { + // Language. + // + cxx_version --std = cxx_version::cxx11 + { + "", + "Specify the C++ standard that the generated code should conform to. + Valid values are \cb{c++98}, \cb{c++11} (default), \cb{c++14}, + \cb{c++17}, \cb{c++20}, and \cb{c++23}. + + The C++ standard affects various aspects of the generated code that + are discussed in more detail in various mapping-specific + documentation. Overall, when C++11 is selected, the generated + code relies on the move semantics and uses \cb{std::unique_ptr} + instead of deprecated \cb{std::auto_ptr}. Currently, there is no + difference between the C++11 and the later standards modes. + + When the C++11 mode is selected, you normally don't need to + perform any extra steps other than enable C++11 in your C++ + compiler, if required. The XSD compiler will automatically + add the necessary macro defines to the generated header files + that will switch the header-only XSD runtime library (\cb{libxsd}) + to the C++11 mode. However, if you include any of the XSD runtime + headers directly in your application (normally you just include + the generated headers), then you will need to define the + \cb{XSD_CXX11} macro for your entire project." + }; + + // Character type and encoding. + // + NarrowString --char-type = "char" + { + "", + "Generate code using the provided character instead of the + default \cb{char}. Valid values are \cb{char} and \cb{wchar_t}." + }; + + NarrowString --char-encoding + { + "", + "Specify the character encoding that should be used in the generated + code. Valid values for the \cb{char} character type are \cb{utf8} + (default), \cb{iso8859-1}, \cb{lcp} (Xerces-C++ local code page), + and \cb{custom}. If you pass \cb{custom} as the value then you will + need to include the transcoder implementation header for your + encoding at the beginning of the generated header files (see the + \cb{--hxx-prologue} option). + + For the \cb{wchar_t} character type the only valid value is \cb{auto} + and the encoding is automatically selected between UTF-16 and + UTF-32/UCS-4, depending on the \cb{wchar_t} type size." + }; + + // Output options. + // + NarrowString --output-dir + { + "", + "Write generated files to instead of the current directory." + }; + + bool --generate-inline + { + "Generate simple functions inline. This option triggers creation of + the inline file." + }; + + // Extern XML Schema. + // + bool --generate-xml-schema + { + "Generate a C++ header file as if the schema being compiled defines the + XML Schema namespace. For the C++/Tree mapping, the resulting file will + contain definitions for all XML Schema built-in types. For the + C++/Parser mapping, the resulting file will contain definitions for + all the parser skeletons and implementations corresponding to the + XML Schema built-in types. + + The schema file provided to the compiler need not exist and is only + used to derive the name of the resulting header file. Use the + \cb{--extern-xml-schema} option to include this file in the + generated files for other schemas." + }; + + NarrowString --extern-xml-schema + { + "", + "Include a header file derived from instead of generating the + XML Schema namespace mapping inline. The provided file need not + exist and is only used to derive the name of the included header + file. Use the \cb{--generate-xml-schema} option to generate this + header file." + }; + + // Namespace mapping. + // + NarrowStrings --namespace-map + { + "=", + "Map XML Schema namespace to C++ namespace . Repeat + this option to specify mapping for more than one XML Schema namespace. + For example, the following option: + + \cb{--namespace-map http://example.com/foo/bar=foo::bar} + + Will map the \cb{http://example.com/foo/bar} XML Schema namespace to + the \cb{foo::bar} C++ namespace." + }; + + NarrowStrings --namespace-regex + { + "", + "Add to the list of regular expressions used to translate XML + Schema namespace names to C++ namespace names. is a Perl-like + regular expression in the form + \c{\b{/}\i{pattern}\b{/}\i{replacement}\b{/}}. Any character can be + used as a delimiter instead of '\cb{/}'. Escaping of the delimiter + character in \ci{pattern} or \ci{replacement} is not supported. + + All the regular expressions are pushed into a stack with the last + specified expression considered first. The first match that + succeeds is used. Regular expressions are applied to a string in + the form + + \c{\i{filename} \i{namespace}} + + For example, if you have file \cb{hello.xsd} with namespace + \cb{http://example.com/hello} and you run \cb{xsd} on this file, + then the string in question will be: + + \cb{hello.xsd. http://example.com/hello} + + For the built-in XML Schema namespace the string is: + + \cb{XMLSchema.xsd http://www.w3.org/2001/XMLSchema} + + The following three steps are performed for each regular expression + until the match is found: + + 1. The expression is applied and if the result is empty the next + expression is considered. + + 2. All '\cb{/}' are replaced with '\cb{::}'. + + 3. The result is verified to be a valid C++ scope name (e.g., + \cb{foo::bar}). If this test succeeds, the result is used as a + C++ namespace name. + + As an example, the following expression maps XML Schema namespaces + in the form \cb{http://example.com/foo/bar} to C++ namespaces in the + form \cb{foo::bar}: + + \cb{%.* http://example.com/(.+)%$1%} + + See also the REGEX AND SHELL QUOTING section below." + }; + + bool --namespace-regex-trace + { + "Trace the process of applying regular expressions specified with the + \cb{--namespace-regex} option. Use this option to find out why your + regular expressions don't do what you expected them to do." + }; + + // Reserved names. + // + NarrowStrings --reserved-name + { + "[=]", + "Add name to the list of names that should not be used as + identifiers. The name can optionally be followed by \cb{=} and the + replacement name that should be used instead. All the C++ keywords + are already in this list." + }; + + // Include options. + // + bool --include-with-brackets + { + "Use angle brackets (<>) instead of quotes (\"\") in generated + \cb{#include} directives." + }; + + NarrowString --include-prefix + { + "", + "Add to generated \cb{#include} directive paths. + + For example, if you had the following import element in your schema + + \cb{} + + and compiled this fragment with \cb{--include-prefix schemas/}, then + the include directive in the generated code would be: + + \cb{#include \"schemas/base.hxx\"}" + }; + + NarrowStrings --include-regex + { + "", + "Add to the list of regular expressions used to transform + \cb{#include} directive paths. is a Perl-like regular + expression in the form \c{\b{/}\i{pattern}\b{/}\i{replacement}\b{/}}. + Any character can be used as a delimiter instead of '\cb{/}'. Escaping + of the delimiter character in \ci{pattern} or \ci{replacement} is not + supported. + + All the regular expressions are pushed into a stack with the last + specified expression considered first. The first match that succeeds + is used. + + As an example, the following expression transforms paths in the form + \cb{schemas/foo/bar} to paths in the form \cb{generated/foo/bar}: + + \cb{%schemas/(.+)%generated/$1%} + + See also the REGEX AND SHELL QUOTING section below." + }; + + bool --include-regex-trace + { + "Trace the process of applying regular expressions specified with the + \cb{--include-regex} option. Use this option to find out why your + regular expressions don't do what you expected them to do." + }; + + NarrowString --guard-prefix + { + "", + "Add to generated header inclusion guards. The prefix is + transformed to upper case and characters that are illegal in a + preprocessor macro name are replaced with underscores. If this + option is not specified then the directory part of the input schema + file is used as a prefix." + }; + + // File suffixes. + // + NarrowString --hxx-suffix = ".hxx" + { + "", + "Use the provided instead of the default \cb{.hxx} to + construct the name of the header file. Note that this suffix is also + used to construct names of header files corresponding to + included/imported schemas." + }; + + NarrowString --ixx-suffix = ".ixx" + { + "", + "Use the provided instead of the default \cb{.ixx} to + construct the name of the inline file." + }; + + NarrowString --cxx-suffix = ".cxx" + { + "", + "Use the provided instead of the default \cb{.cxx} to + construct the name of the source file." + }; + + NarrowString --fwd-suffix = "-fwd.hxx" + { + "", + "Use the provided instead of the default \cb{-fwd.hxx} to + construct the name of the forward declaration file." + }; + + NarrowString --hxx-regex + { + "", + "Use the provided expression to construct the name of the header file. + is a Perl-like regular expression in the form + \c{\b{/}\i{pattern}\b{/}\i{replacement}\b{/}}. + Note that this expression is also used to construct names of header + files corresponding to included/imported schemas. See also the REGEX + AND SHELL QUOTING section below." + }; + + NarrowString --ixx-regex + { + "", + "Use the provided expression to construct the name of the inline file. + is a Perl-like regular expression in the form + \c{\b{/}\i{pattern}\b{/}\i{replacement}\b{/}}. See also the REGEX AND + SHELL QUOTING section below." + }; + + NarrowString --cxx-regex + { + "", + "Use the provided expression to construct the name of the source file. + is a Perl-like regular expression in the form + \c{\b{/}\i{pattern}\b{/}\i{replacement}\b{/}}. See also the REGEX AND + SHELL QUOTING section below." + }; + + NarrowString --fwd-regex + { + "", + "Use the provided expression to construct the name of the forward + declaration file. is a Perl-like regular expression in the + form \c{\b{/}\i{pattern}\b{/}\i{replacement}\b{/}}. See also the REGEX + AND SHELL QUOTING section below." + }; + + // Prologues/epilogues. + // + NarrowStrings --hxx-prologue + { + "", + "Insert at the beginning of the header file." + }; + + NarrowStrings --ixx-prologue + { + "", + "Insert at the beginning of the inline file." + }; + + NarrowStrings --cxx-prologue + { + "", + "Insert at the beginning of the source file." + }; + + NarrowStrings --fwd-prologue + { + "", + "Insert at the beginning of the forward declaration file." + }; + + NarrowStrings --prologue + { + "", + "Insert at the beginning of each generated file for which + there is no file-specific prologue." + }; + + NarrowStrings --hxx-epilogue + { + "", + "Insert at the end of the header file." + }; + + NarrowStrings --ixx-epilogue + { + "", + "Insert at the end of the inline file." + }; + + NarrowStrings --cxx-epilogue + { + "", + "Insert at the end of the source file." + }; + + NarrowStrings --fwd-epilogue + { + "", + "Insert at the end of the forward declaration file." + }; + + NarrowStrings --epilogue + { + "", + "Insert at the end of each generated file for which there + is no file-specific epilogue." + }; + + NarrowString --hxx-prologue-file + { + "", + "Insert the content of the at the beginning of the header file." + }; + + NarrowString --ixx-prologue-file + { + "", + "Insert the content of the at the beginning of the inline file." + }; + + NarrowString --cxx-prologue-file + { + "", + "Insert the content of the at the beginning of the source file." + }; + + NarrowString --fwd-prologue-file + { + "", + "Insert the content of the at the beginning of the forward + declaration file." + }; + + NarrowString --prologue-file + { + "", + "Insert the content of the at the beginning of each generated + file for which there is no file-specific prologue file." + }; + + NarrowString --hxx-epilogue-file + { + "", + "Insert the content of the at the end of the header file." + }; + + NarrowString --ixx-epilogue-file + { + "", + "Insert the content of the at the end of the inline file." + }; + + NarrowString --cxx-epilogue-file + { + "", + "Insert the content of the at the end of the source file." + }; + + NarrowString --fwd-epilogue-file + { + "", + "Insert the content of the at the end of the forward declaration + file." + }; + + NarrowString --epilogue-file + { + "", + "Insert the content of the at the end of each generated file + for which there is no file-specific epilogue file." + }; + + // Export options. + // + NarrowString --export-symbol + { + "", + "Insert in places where DLL export/import control statements + (\cb{__declspec(dllexport/dllimport)}) are necessary." + }; + + bool --export-xml-schema + { + "Export/import types in the XML Schema namespace using the export + symbol provided with the \cb{--export-symbol} option. The + \cb{XSD_NO_EXPORT} macro can be used to omit this code during C++ + compilation, which may be useful if you would like to use the same + generated code across multiple platforms." + }; + + bool --export-maps + { + "Export polymorphism support maps from a Win32 DLL into which this + generated code is placed. This is necessary when your type hierarchy + is split across several DLLs since otherwise each DLL will have its + own set of maps. In this situation the generated code for the DLL + which contains base types and/or substitution group heads should be + compiled with this option and the generated code for all other DLLs + should be compiled with \cb{--import-maps}. This option is only valid + together with \cb{--generate-polymorphic}. The \cb{XSD_NO_EXPORT} + macro can be used to omit this code during C++ compilation, which may + be useful if you would like to use the same generated code across + multiple platforms." + }; + + bool --import-maps + { + "Import polymorphism support maps to a Win32 DLL or executable into + which this generated code is linked. See the \cb{--export-maps} + option documentation for details. This options is only valid together + with \cb{--generate-polymorphic}. The \cb{XSD_NO_EXPORT} macro can be + used to omit this code during C++ compilation, which may be useful if + you would like to use the same generated code across multiple + platforms." + }; + + // Make dependency generation. + // + bool --generate-dep + { + "Generate \cb{make} dependency information. This option triggers the + creation of the \cb{.d} file containing the dependencies of the + generated files on the main schema file as well as all the schema + files that it includes/imports, transitively. This dependency file + is then normally included into the main \cb{makefile} to implement + automatic dependency tracking. See also the \cb{--dep-*} options. + + Note also that automatic dependency generation is not supported in + the file-per-type mode (\cb{--file-per-type}). In this case, all + the generated files are produced with a single compiler invocation + and depend on all the schemas. As a result, it is easier to establish + such a dependency manually, perhaps with the help of the + \cb{--file-list*} options." + }; + + bool --generate-dep-only + { + "Generate \cb{make} dependency information only." + }; + + bool --dep-phony + { + "Generate phony targets for included/imported schema files, causing + each to depend on nothing. Such dummy rules work around \cb{make} + errors caused by the removal of schema files without also updating + the dependency file to match." + }; + + NarrowStrings --dep-target + { + "", + "Change the target of the dependency rule. By default it contains + all the generated C++ files as well as the dependency file itself, + without any directory prefixes. If you require multiple targets, + then you can specify them as a single, space-separated argument or + you can repeat this option multiple times." + }; + + NarrowString --dep-suffix = ".d" + { + "", + "Use instead of the default \cb{.d} to construct the name of + the dependency file. See also \cb{--dep-file}." + }; + + NarrowString --dep-file + { + "", + "Use as the generated dependency file path instead of deriving + it from the input file name. Write the dependency information to + \cb{stdout} if is \cb{-}. See also \cb{--dep-regex}." + }; + + NarrowString --dep-regex + { + "", + "Use the provided expression to construct the name of the dependency + file. is a Perl-like regular expression in the form + \c{\b{/}\i{pattern}\b{/}\i{replacement}\b{/}}. See also the REGEX + AND SHELL QUOTING section below." + }; + }; +} diff --git a/xsd/cxx/parser/attribute-validation-source.cxx b/xsd/cxx/parser/attribute-validation-source.cxx new file mode 100644 index 0000000..1c873fd --- /dev/null +++ b/xsd/cxx/parser/attribute-validation-source.cxx @@ -0,0 +1,412 @@ +// file : xsd/cxx/parser/attribute-validation-source.cxx +// license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +#include + +#include +#include + +namespace CXX +{ + namespace Parser + { + namespace + { + struct Test: Traversal::Attribute, + Traversal::AnyAttribute, + Context + { + Test (Context& c) + : Context (c) + { + } + + virtual void + traverse (SemanticGraph::Attribute& a) + { + String const& name (a.name ()); + + if (a.qualified_p () && a.namespace_ ().name ()) + { + String const& ns (a.namespace_ ().name ()); + + os << "n == " << strlit (name) << " &&" << endl + << "ns == " << strlit (ns); + } + else + os << "n == " << strlit (name) << " && ns.empty ()"; + } + + virtual void + traverse (SemanticGraph::AnyAttribute& a) + { + String const& ns (a.definition_namespace ().name ()); + + for (SemanticGraph::AnyAttribute::NamespaceIterator + i (a.namespace_begin ()), e (a.namespace_end ()); i != e;) + { + if (*i == L"##any") + { + os << "!n.empty ()"; + } + else if (*i == L"##other") + { + if (ns) + { + // Note that here I assume that ##other does not include + // unqualified names in a schema with target namespace. + // This is not what the spec says but that seems to be + // the consensus. + // + os << "(!ns.empty () && ns != " << strlit (ns) << ")"; + } + else + os << "!ns.empty ()"; + } + else if (*i == L"##local") + { + os << "(ns.empty () && !n.empty ())"; + } + else if (*i == L"##targetNamespace") + { + os << "ns == " << strlit (ns); + } + else + { + os << "ns == " << strlit (*i); + } + + if (++i != e) + os << " ||" << endl; + } + } + }; + + // + // + struct PhaseOne: Traversal::Attribute, Context + { + PhaseOne (Context& c) + : Context (c), test_ (c) + { + } + + virtual void + traverse (Type& a) + { + String const& name (ename (a)); + String const& inst (emember (a)); + + SemanticGraph::Type& type (a.type ()); + String const& post (post_name (type)); + String const& ret (ret_type (type)); + + os << "if ("; + + test_.traverse (a); + + os << ")" + << "{" + << "if (this->" << inst << ")" + << "{" + << "this->" << inst << "->pre ();" + << "this->" << inst << "->_pre_impl ();" + << "this->" << inst << "->_characters (s);" + << "this->" << inst << "->_post_impl ();"; + + if (ret == L"void") + os << "this->" << inst << "->" << post << " ();" + << "this->" << name << " ();"; + else + { + // Don't create an lvalue in C++11 (think std::unique_ptr). + // In C++98 we do it for compatibility with older/broken + // compilers (e.g., IBM xlC that needs an lvalue to pass + // std::auto_ptr). + // + if (std == cxx_version::cxx98) + os << arg_type (type) << " tmp (this->" << inst << "->" << + post << " ());" + << "this->" << name << " (tmp);"; + else + os << "this->" << name << " (this->" << inst << "->" << + post << " ());"; + } + + os << "}"; + + if (!a.optional_p ()) + os << "static_cast< v_state_attr_* > (" << + "this->v_state_attr_stack_.top ())->" << name << " = true;"; + + os << "return true;" + << "}"; + } + + private: + Test test_; + }; + + + // + // + struct PhaseTwo: Traversal::AnyAttribute, Context + { + PhaseTwo (Context& c) + : Context (c), test_ (c) + { + } + + virtual void + traverse (Type& a) + { + os << "if ("; + + test_.traverse (a); + + os << ")" << endl + << "{" + << "this->_any_attribute (ns, n, s);" + << "return true;" + << "}"; + } + + private: + Test test_; + }; + + + // + // + struct AttributeStateInit: Traversal::Attribute, Context + { + AttributeStateInit (Context& c) + : Context (c) + { + } + + virtual void + traverse (Type& a) + { + if (!a.optional_p ()) + os << "as." << ename (a) << " = false;"; + } + }; + + + // + // + struct AttributeStateCheck: Traversal::Attribute, Context + { + AttributeStateCheck (Context& c) + : Context (c) + { + } + + virtual void + traverse (Type& a) + { + if (!a.optional_p ()) + { + String ns (a.qualified_p () ? a.namespace_ ().name () : String ()); + + os << "if (!as." << ename (a) << ")" << endl + << "this->_expected_attribute (" << endl + << strlit (ns) << ", " << strlit (a.name ()) << ");"; + } + } + }; + + // + // + struct Complex: Traversal::Complex, Context + { + Complex (Context& c) + : Context (c), + phase_one_ (c), + phase_two_ (c), + attribute_state_init_ (c), + attribute_state_check_ (c) + { + names_phase_one_ >> phase_one_; + names_phase_two_ >> phase_two_; + + names_attribute_state_init_ >> attribute_state_init_; + names_attribute_state_check_ >> attribute_state_check_; + } + + virtual void + traverse (Type& c) + { + bool has_att (has (c)); + bool has_any (has (c)); + + if (!has_att && !has_any) + return; + + bool has_req_att (false); + if (has_att) + { + RequiredAttributeTest test (has_req_att); + Traversal::Names names_test (test); + names (c, names_test); + } + + String const& name (ename (c)); + + os <<"// Attribute validation and dispatch functions for " << + name << "." << endl + <<"//" << endl; + + if (has_att) + { + // _attribute_impl_phase_one + // + os << "bool " << name << "::" << endl + << "_attribute_impl_phase_one (const " << string_type << + "& ns," << endl + << "const " << string_type << "& n," << endl + << "const " << string_type << "& s)" << endl + << "{"; + + names (c, names_phase_one_); + + // Nothing matched - call our base (extension) or return false + // if there is no base (or restriction (even from anyType)). + // + os << "return "; + + if (c.inherits_p () && + !c.inherits ().is_a ()) + { + os << "this->" << fq_name (c.inherits ().base ()) << + "::_attribute_impl_phase_one (ns, n, s);"; + } + else + os << "false;"; + + os << "}"; + } + + + if (has_any) + { + // _attribute_impl_phase_two + // + os << "bool " << name << "::" << endl + << "_attribute_impl_phase_two (const " << string_type << + "& ns," << endl + << "const " << string_type << "& n," << endl + << "const " << string_type << "& s)" + << "{"; + + names (c, names_phase_two_); + + // Nothing matched - call our base (extension) or return false + // if there is no base (or restriction (even from anyType)). + // + os << "return "; + + if (c.inherits_p () && + !c.inherits ().is_a ()) + { + os << "this->" << fq_name (c.inherits ().base ()) << + "::_attribute_impl_phase_two (ns, n, s);"; + } + else + os << "false;"; + + os << "}"; + } + + if (has_req_att) + { + // _pre_a_validate + // + os << "void " << name << "::" << endl + << "_pre_a_validate ()" + << "{" + << "this->v_state_attr_stack_.push ();" + << "v_state_attr_& as = *static_cast< v_state_attr_* > (" << + "this->v_state_attr_stack_.top ());" + << endl; + + names (c, names_attribute_state_init_); + + // Call our base (extension) last. + // + if (c.inherits_p () && + !c.inherits ().is_a ()) + { + os << "this->" << fq_name (c.inherits ().base ()) << + "::_pre_a_validate ();"; + } + + os << "}"; + + + // _post_a_validate + // + os << "void " << name << "::" << endl + << "_post_a_validate ()" + << "{"; + + // Call our base (extension) first. + // + if (c.inherits_p () && + !c.inherits ().is_a ()) + { + os << "this->" << fq_name (c.inherits ().base ()) << + "::_post_a_validate ();" + << endl; + } + + os << "v_state_attr_& as = *static_cast< v_state_attr_* > (" << + "this->v_state_attr_stack_.top ());" + << endl; + + names (c, names_attribute_state_check_); + + os << endl + << "this->v_state_attr_stack_.pop ();" + << "}"; + } + } + + private: + PhaseOne phase_one_; + Traversal::Names names_phase_one_; + + PhaseTwo phase_two_; + Traversal::Names names_phase_two_; + + AttributeStateInit attribute_state_init_; + Traversal::Names names_attribute_state_init_; + + AttributeStateCheck attribute_state_check_; + Traversal::Names names_attribute_state_check_; + }; + } + + void + generate_attribute_validation_source (Context& ctx) + { + Traversal::Schema schema; + + Sources sources; + Traversal::Names schema_names; + + Namespace ns (ctx); + Traversal::Names names; + + schema >> sources >> schema; + schema >> schema_names >> ns >> names; + + Complex complex (ctx); + + names >> complex; + + schema.dispatch (ctx.schema_root); + } + } +} diff --git a/xsd/cxx/parser/attribute-validation-source.hxx b/xsd/cxx/parser/attribute-validation-source.hxx new file mode 100644 index 0000000..1f19bed --- /dev/null +++ b/xsd/cxx/parser/attribute-validation-source.hxx @@ -0,0 +1,18 @@ +// file : xsd/cxx/parser/attribute-validation-source.hxx +// license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +#ifndef XSD_CXX_PARSER_ATTRIBUTE_VALIDATION_SOURCE_HXX +#define XSD_CXX_PARSER_ATTRIBUTE_VALIDATION_SOURCE_HXX + +#include + +namespace CXX +{ + namespace Parser + { + void + generate_attribute_validation_source (Context&); + } +} + +#endif // XSD_CXX_PARSER_ATTRIBUTE_VALIDATION_SOURCE_HXX diff --git a/xsd/cxx/parser/characters-validation-source.cxx b/xsd/cxx/parser/characters-validation-source.cxx new file mode 100644 index 0000000..749a4cc --- /dev/null +++ b/xsd/cxx/parser/characters-validation-source.cxx @@ -0,0 +1,73 @@ +// file : xsd/cxx/parser/characters-validation-source.cxx +// license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +#include + +#include +#include + +namespace CXX +{ + namespace Parser + { + namespace + { + // + // + struct Complex: Traversal::Complex, Context + { + Complex (Context& c) + : Context (c) + { + } + + virtual void + traverse (Type& c) + { + if (!c.mixed_p ()) + return; + + String const& name (ename (c)); + + os <<"// Character validation functions for " << name << "." << endl + <<"//" << endl; + + // _characters_impl + // + os << "bool " << name << "::" << endl + << "_characters_impl (const " << string_type << "& s)" + << "{" + << "this->_any_characters (s);" + << "return true;" + << "}"; + } + }; + } + + void + generate_characters_validation_source (Context& ctx) + { + //@@ Most of the time there is no mixed content type so + // we generate an empty namespace which looks ugly. Will + // need to implement smart namespace to handle this at + // some point. + // + Traversal::Schema schema; + + Sources sources; + Traversal::Names schema_names; + + Namespace ns (ctx); + Traversal::Names names; + + schema >> sources >> schema; + schema >> schema_names >> ns >> names; + + Complex complex (ctx); + + names >> complex; + + schema.dispatch (ctx.schema_root); + } + } +} diff --git a/xsd/cxx/parser/characters-validation-source.hxx b/xsd/cxx/parser/characters-validation-source.hxx new file mode 100644 index 0000000..909901b --- /dev/null +++ b/xsd/cxx/parser/characters-validation-source.hxx @@ -0,0 +1,18 @@ +// file : xsd/cxx/parser/characters-validation-source.hxx +// license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +#ifndef XSD_CXX_PARSER_CHARACTERS_VALIDATION_SOURCE_HXX +#define XSD_CXX_PARSER_CHARACTERS_VALIDATION_SOURCE_HXX + +#include + +namespace CXX +{ + namespace Parser + { + void + generate_characters_validation_source (Context&); + } +} + +#endif // XSD_CXX_PARSER_CHARACTERS_VALIDATION_SOURCE_HXX diff --git a/xsd/cxx/parser/driver-source.cxx b/xsd/cxx/parser/driver-source.cxx new file mode 100644 index 0000000..d1e6b7f --- /dev/null +++ b/xsd/cxx/parser/driver-source.cxx @@ -0,0 +1,775 @@ +// file : xsd/cxx/parser/driver-source.cxx +// license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +#include +#include +#include + +#include +#include + +#include +#include + +using namespace std; + +namespace CXX +{ + namespace Parser + { + namespace + { + typedef map TypeInstanceMap; + typedef set InstanceSet; + + // For base types we only want member's types, but not the + // base itself. + // + struct BaseType: Traversal::Complex, + Traversal::List, + Context + { + BaseType (Context& c, Traversal::NodeBase& def) + : Context (c), def_ (def) + { + } + + virtual void + traverse (SemanticGraph::Complex& c) + { + inherits (c); + + if (!restriction_p (c)) + names (c); + } + + virtual void + traverse (SemanticGraph::List& l) + { + def_.dispatch (l.argumented ().type ()); + } + + private: + Traversal::NodeBase& def_; + }; + + struct ParserDef: Traversal::Type, + Traversal::List, + Traversal::Complex, + + Traversal::AnyType, + Traversal::AnySimpleType, + + Traversal::Fundamental::Byte, + Traversal::Fundamental::UnsignedByte, + Traversal::Fundamental::Short, + Traversal::Fundamental::UnsignedShort, + Traversal::Fundamental::Int, + Traversal::Fundamental::UnsignedInt, + Traversal::Fundamental::Long, + Traversal::Fundamental::UnsignedLong, + Traversal::Fundamental::Integer, + Traversal::Fundamental::NonPositiveInteger, + Traversal::Fundamental::NonNegativeInteger, + Traversal::Fundamental::PositiveInteger, + Traversal::Fundamental::NegativeInteger, + + Traversal::Fundamental::Boolean, + + Traversal::Fundamental::Float, + Traversal::Fundamental::Double, + Traversal::Fundamental::Decimal, + + Traversal::Fundamental::String, + Traversal::Fundamental::NormalizedString, + Traversal::Fundamental::Token, + Traversal::Fundamental::Name, + Traversal::Fundamental::NameToken, + Traversal::Fundamental::NameTokens, + Traversal::Fundamental::NCName, + Traversal::Fundamental::Language, + + Traversal::Fundamental::QName, + + Traversal::Fundamental::Id, + Traversal::Fundamental::IdRef, + Traversal::Fundamental::IdRefs, + + Traversal::Fundamental::AnyURI, + + Traversal::Fundamental::Base64Binary, + Traversal::Fundamental::HexBinary, + + Traversal::Fundamental::Date, + Traversal::Fundamental::DateTime, + Traversal::Fundamental::Duration, + Traversal::Fundamental::Day, + Traversal::Fundamental::Month, + Traversal::Fundamental::MonthDay, + Traversal::Fundamental::Year, + Traversal::Fundamental::YearMonth, + Traversal::Fundamental::Time, + + Traversal::Fundamental::Entity, + Traversal::Fundamental::Entities, + + Context + { + ParserDef (Context& c, TypeInstanceMap& map, InstanceSet& set) + : Context (c), map_ (map), set_ (set), base_ (c, *this) + { + *this >> inherits_ >> base_ >> inherits_; + + *this >> names_; + base_ >> names_; + + names_ >> member_ >> belongs_ >> *this; + } + + virtual void + traverse (SemanticGraph::Type& t) + { + if (map_.find (&t) == map_.end ()) + { + String inst (find_instance_name (t)); + map_[&t] = inst; + + os << fq_name (t, "impl") << " " << inst << ";"; + } + } + + virtual void + traverse (SemanticGraph::List& l) + { + if (map_.find (&l) == map_.end ()) + { + String inst (find_instance_name (l)); + map_[&l] = inst; + + os << fq_name (l, "impl") << " " << inst << ";"; + + dispatch (l.argumented ().type ()); + } + } + + virtual void + traverse (SemanticGraph::Complex& c) + { + if (map_.find (&c) == map_.end ()) + { + String inst (find_instance_name (c)); + map_[&c] = inst; + + os << fq_name (c, "impl") << " " << inst << ";"; + + inherits (c); + + if (!restriction_p (c)) + names (c); + } + } + + // anyType & anySimpleType. + // + virtual void + traverse (SemanticGraph::AnyType& t) + { + fund_type (t, "any_type"); + } + + virtual void + traverse (SemanticGraph::AnySimpleType& t) + { + fund_type (t, "any_simple_type"); + } + + // Boolean. + // + virtual void + traverse (SemanticGraph::Fundamental::Boolean& t) + { + fund_type (t, "boolean"); + } + + // Integral types. + // + virtual void + traverse (SemanticGraph::Fundamental::Byte& t) + { + fund_type (t, "byte"); + } + + virtual void + traverse (SemanticGraph::Fundamental::UnsignedByte& t) + { + fund_type (t, "unsigned_byte"); + } + + virtual void + traverse (SemanticGraph::Fundamental::Short& t) + { + fund_type (t, "short"); + } + + virtual void + traverse (SemanticGraph::Fundamental::UnsignedShort& t) + { + fund_type (t, "unsigned_short"); + } + + virtual void + traverse (SemanticGraph::Fundamental::Int& t) + { + fund_type (t, "int"); + } + + virtual void + traverse (SemanticGraph::Fundamental::UnsignedInt& t) + { + fund_type (t, "unsigned_int"); + } + + virtual void + traverse (SemanticGraph::Fundamental::Long& t) + { + fund_type (t, "long"); + } + + virtual void + traverse (SemanticGraph::Fundamental::UnsignedLong& t) + { + fund_type (t, "unsigned_long"); + } + + virtual void + traverse (SemanticGraph::Fundamental::Integer& t) + { + fund_type (t, "integer"); + } + + virtual void + traverse (SemanticGraph::Fundamental::NonPositiveInteger& t) + { + fund_type (t, "non_positive_integer"); + } + + virtual void + traverse (SemanticGraph::Fundamental::NonNegativeInteger& t) + { + fund_type (t, "non_negative_integer"); + } + + virtual void + traverse (SemanticGraph::Fundamental::PositiveInteger& t) + { + fund_type (t, "positive_integer"); + } + + virtual void + traverse (SemanticGraph::Fundamental::NegativeInteger& t) + { + fund_type (t, "negative_integer"); + } + + // Floats. + // + virtual void + traverse (SemanticGraph::Fundamental::Float& t) + { + fund_type (t, "float"); + } + + virtual void + traverse (SemanticGraph::Fundamental::Double& t) + { + fund_type (t, "double"); + } + + virtual void + traverse (SemanticGraph::Fundamental::Decimal& t) + { + fund_type (t, "decimal"); + } + + // Strings. + // + virtual void + traverse (SemanticGraph::Fundamental::String& t) + { + fund_type (t, "string"); + } + + virtual void + traverse (SemanticGraph::Fundamental::NormalizedString& t) + { + fund_type (t, "normalized_string"); + } + + virtual void + traverse (SemanticGraph::Fundamental::Token& t) + { + fund_type (t, "token"); + } + + virtual void + traverse (SemanticGraph::Fundamental::NameToken& t) + { + fund_type (t, "nmtoken"); + } + + virtual void + traverse (SemanticGraph::Fundamental::NameTokens& t) + { + fund_type (t, "nmtokens"); + } + + virtual void + traverse (SemanticGraph::Fundamental::Name& t) + { + fund_type (t, "name"); + } + + virtual void + traverse (SemanticGraph::Fundamental::NCName& t) + { + fund_type (t, "ncname"); + } + + virtual void + traverse (SemanticGraph::Fundamental::Language& t) + { + fund_type (t, "language"); + } + + + // Qualified name. + // + virtual void + traverse (SemanticGraph::Fundamental::QName& t) + { + fund_type (t, "qname"); + } + + + // ID/IDREF. + // + virtual void + traverse (SemanticGraph::Fundamental::Id& t) + { + fund_type (t, "id"); + } + + virtual void + traverse (SemanticGraph::Fundamental::IdRef& t) + { + fund_type (t, "idref"); + } + + virtual void + traverse (SemanticGraph::Fundamental::IdRefs& t) + { + fund_type (t, "idrefs"); + } + + // URI. + // + virtual void + traverse (SemanticGraph::Fundamental::AnyURI& t) + { + fund_type (t, "uri"); + } + + // Binary. + // + virtual void + traverse (SemanticGraph::Fundamental::Base64Binary& t) + { + fund_type (t, "base64_binary"); + } + + virtual void + traverse (SemanticGraph::Fundamental::HexBinary& t) + { + fund_type (t, "hex_binary"); + } + + + // Date/time. + // + virtual void + traverse (SemanticGraph::Fundamental::Date& t) + { + fund_type (t, "date"); + } + + virtual void + traverse (SemanticGraph::Fundamental::DateTime& t) + { + fund_type (t, "date_time"); + } + + virtual void + traverse (SemanticGraph::Fundamental::Duration& t) + { + fund_type (t, "duration"); + } + + virtual void + traverse (SemanticGraph::Fundamental::Day& t) + { + fund_type (t, "day"); + } + + virtual void + traverse (SemanticGraph::Fundamental::Month& t) + { + fund_type (t, "month"); + } + + virtual void + traverse (SemanticGraph::Fundamental::MonthDay& t) + { + fund_type (t, "month_day"); + } + + virtual void + traverse (SemanticGraph::Fundamental::Year& t) + { + fund_type (t, "year"); + } + + virtual void + traverse (SemanticGraph::Fundamental::YearMonth& t) + { + fund_type (t, "year_month"); + } + + virtual void + traverse (SemanticGraph::Fundamental::Time& t) + { + fund_type (t, "time"); + } + + // Entity. + // + virtual void + traverse (SemanticGraph::Fundamental::Entity& t) + { + fund_type (t, "entity"); + } + + virtual void + traverse (SemanticGraph::Fundamental::Entities& t) + { + fund_type (t, "entities"); + } + + private: + virtual void + fund_type (SemanticGraph::Type& t, String const& name) + { + if (map_.find (&t) == map_.end ()) + { + String inst (find_instance_name (name)); + map_[&t] = inst; + + os << fq_name (t, "impl") << " " << inst << ";"; + } + } + + String + find_instance_name (String const& raw_name) + { + String base_name (escape (raw_name + L"_p")); + String name (base_name); + + for (size_t i (1); set_.find (name) != set_.end (); ++i) + { + std::wostringstream os; + os << i; + name = base_name + os.str (); + } + + set_.insert (name); + return name; + } + + String + find_instance_name (SemanticGraph::Type& t) + { + return find_instance_name (t.name ()); + } + + TypeInstanceMap& map_; + InstanceSet& set_; + + BaseType base_; + Traversal::Inherits inherits_; + + Traversal::Names names_; + Traversal::Member member_; + Traversal::Belongs belongs_; + }; + + struct ArgList: Traversal::Complex, + Traversal::List, + Traversal::Member, + Context + { + ArgList (Context& c, TypeInstanceMap& map) + : Context (c), map_ (map), first_ (true) + { + inherits_ >> *this; + names_ >> *this; + } + + virtual void + traverse (SemanticGraph::Complex& c) + { + inherits (c, inherits_); + + if (!restriction_p (c)) + names (c, names_); + } + + virtual void + traverse (SemanticGraph::List& l) + { + if (!first_) + os << "," << endl; + else + first_ = false; + + os << map_[&l.argumented ().type ()]; + } + + virtual void + traverse (SemanticGraph::Member& m) + { + if (skip (m)) + return; + + if (!first_) + os << "," << endl; + else + first_ = false; + + os << map_[&m.type ()]; + } + + private: + TypeInstanceMap& map_; + + Traversal::Inherits inherits_; + Traversal::Names names_; + + bool first_; + }; + + struct ParserConnect: Traversal::List, + Traversal::Complex, + Context + { + ParserConnect (Context& c, TypeInstanceMap& map) + : Context (c), map_ (map), base_ (c, *this) + { + *this >> inherits_ >> base_ >> inherits_; + + *this >> names_; + base_ >> names_; + + names_ >> member_ >> belongs_ >> *this; + } + + virtual void + traverse (SemanticGraph::List& l) + { + if (type_set_.find (&l) == type_set_.end ()) + { + os << map_[&l] << ".parsers (" << + map_[&l.argumented ().type ()] << ");" + << endl; + + type_set_.insert (&l); + } + } + + virtual void + traverse (SemanticGraph::Complex& c) + { + if (type_set_.find (&c) == type_set_.end ()) + { + if (has_members (c)) + { + os << map_[&c] << ".parsers ("; + + ArgList args (*this, map_); + args.dispatch (c); + + os << ");" + << endl; + } + + type_set_.insert (&c); + + inherits (c); + + if (!restriction_p (c)) + names (c); + } + } + + private: + bool + has_members (SemanticGraph::Complex& c) + { + using SemanticGraph::Complex; + + if (has (c)) + return true; + + if (c.inherits_p ()) + { + SemanticGraph::Type& b (c.inherits ().base ()); + + if (Complex* cb = dynamic_cast (&b)) + return has_members (*cb); + + return b.is_a (); + } + + return false; + } + + private: + TypeInstanceMap& map_; + set type_set_; + + BaseType base_; + Traversal::Inherits inherits_; + + Traversal::Names names_; + Traversal::Member member_; + Traversal::Belongs belongs_; + }; + } + + void + generate_driver_source (Context& ctx) + { + // Figure out the root element. Validator should have made sure + // it is unique. + // + SemanticGraph::Element* root (0); + { + Traversal::Schema schema; + Sources sources; + + schema >> sources >> schema; + + Traversal::Names schema_names; + Traversal::Namespace ns; + Traversal::Names ns_names; + RootElement root_element (ctx.options, root); + + schema >> schema_names >> ns >> ns_names >> root_element; + + schema.dispatch (ctx.schema_root); + } + + std::wostream& os (ctx.os); + String const& L (ctx.L); + String const& cerr (ctx.cerr_inst); + + InstanceSet set; + TypeInstanceMap map; + SemanticGraph::Type& root_type (root->type ()); + + set.insert ("doc_p"); + + os << "#include " << endl + << endl + << "int" << endl + << "main (int argc, char* argv[])" + << "{" + << "if (argc != 2)" + << "{" + << cerr << " << " << L << "\"usage: \" << argv[0] << " << + L << "\" file.xml\" << std::endl;" + << "return 1;" + << "}" + << "try" + << "{" + << "// Instantiate individual parsers." << endl + << "//" << endl; + + { + ParserDef def (ctx, map, set); + def.dispatch (root_type); + } + + os << endl + << "// Connect the parsers together." << endl + << "//" << endl; + + { + ParserConnect connect (ctx, map); + connect.dispatch (root_type); + } + + String const& root_p (map[&root_type]); + + os << "// Parse the XML document." << endl + << "//" << endl; + + if (root->namespace_().name ()) + os << ctx.xs_ns_name () << "::document doc_p (" << endl + << root_p << "," << endl + << ctx.strlit (root->namespace_().name ()) << "," << endl + << ctx.strlit (root->name ()) << ");" + << endl; + else + os << ctx.xs_ns_name () << "::document doc_p (" << root_p << ", " << + ctx.strlit (root->name ()) << ");" + << endl; + + os << root_p << ".pre ();" + << "doc_p.parse (argv[1]);"; + + String const& ret (Context::ret_type (root_type)); + String const& post (Context::post_name (root_type)); + + if (ret == L"void") + os << root_p << "." << post << " ();"; + else + { + os << Context::arg_type (root_type) << " v (" << + root_p << "." << post << " ());" + << endl; + + if (ctx.options.generate_print_impl ()) + { + PrintCall t (ctx, root->name (), "v"); + t.dispatch (root_type); + } + else + os << "// TODO" << endl + << "//" << endl; + } + + os << "}" // try + << "catch (const " << ctx.xs_ns_name () << "::exception& e)" + << "{" + << cerr << " << e << std::endl;" + << "return 1;" + << "}" + << "catch (const std::ios_base::failure&)" + << "{" + << cerr << " << argv[1] << " << + L << "\": error: io failure\" << std::endl;" + << "return 1;" + << "}" + << "}"; + } + } +} diff --git a/xsd/cxx/parser/driver-source.hxx b/xsd/cxx/parser/driver-source.hxx new file mode 100644 index 0000000..154091f --- /dev/null +++ b/xsd/cxx/parser/driver-source.hxx @@ -0,0 +1,18 @@ +// file : xsd/cxx/parser/driver-source.hxx +// license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +#ifndef XSD_CXX_PARSER_DRIVER_SOURCE_HXX +#define XSD_CXX_PARSER_DRIVER_SOURCE_HXX + +#include + +namespace CXX +{ + namespace Parser + { + void + generate_driver_source (Context&); + } +} + +#endif // XSD_CXX_PARSER_DRIVER_SOURCE_HXX diff --git a/xsd/cxx/parser/element-validation-source.cxx b/xsd/cxx/parser/element-validation-source.cxx new file mode 100644 index 0000000..b5e1e9d --- /dev/null +++ b/xsd/cxx/parser/element-validation-source.cxx @@ -0,0 +1,1600 @@ +// file : xsd/cxx/parser/element-validation-source.cxx +// license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +#include + +#include + +#include +#include + +using namespace std; + +namespace CXX +{ + namespace Parser + { + namespace + { + typedef vector Particles; + + // + // + struct ParticleTest: Traversal::Compositor, + Traversal::Element, + Traversal::Any, + Context + { + ParticleTest (Context& c) + : Context (c) + { + } + + virtual void + traverse (SemanticGraph::Element& e) + { + String const& name (e.name ()); + + if (polymorphic && e.global_p ()) + os << "("; + + if (e.qualified_p () && e.namespace_ ().name ()) + { + String const& ns (e.namespace_ ().name ()); + + os << "n == " << strlit (name) << " &&" << endl + << "ns == " << strlit (ns); + } + else + os << "n == " << strlit (name) << " && ns.empty ()"; + + + // Only a globally-defined element can be a subst-group root. + // + if (polymorphic && e.global_p ()) + { + os << ") ||" << endl + << "::xsd::cxx::parser::substitution_map_instance< " << + char_type << " > ().check (" << endl + << "ns, n, " << strlit (e.namespace_ ().name ()) << + ", " << strlit (name) << ", t)"; + } + } + + virtual void + traverse (SemanticGraph::Any& a) + { + String const& ns (a.definition_namespace ().name ()); + + // Note that we need to make sure the "flush" element (both name + // and namespace are empty) does not match any compositor. + // + for (SemanticGraph::Any::NamespaceIterator i (a.namespace_begin ()), + e (a.namespace_end ()); i != e;) + { + if (*i == L"##any") + { + os << "!n.empty ()"; + } + else if (*i == L"##other") + { + if (ns) + { + // Note that here I assume that ##other does not include + // unqualified names in a schema with target namespace. + // This is not what the spec says but that seems to be + // the consensus. + // + os << "(!ns.empty () && ns != " << strlit (ns) << ")"; + } + else + os << "!ns.empty ()"; + } + else if (*i == L"##local") + { + os << "(ns.empty () && !n.empty ())"; + } + else if (*i == L"##targetNamespace") + { + os << "ns == " << strlit (ns); + } + else + { + os << "ns == " << strlit (*i); + } + + if (++i != e) + os << " ||" << endl; + } + } + + virtual void + traverse (SemanticGraph::Compositor& c) + { + // This compositor should already have been tested for + // triviality (empty). + // + Particles const& p (c.context ().get ("prefixes")); + + bool paren (p.size () != 1); + + for (Particles::const_iterator i (p.begin ()), e (p.end ()); + i != e;) + { + if (paren) + os << "("; + + dispatch (**i); + + if (paren) + os << ")"; + + if (++i != e) + os << " ||" << endl; + } + } + }; + + + // Generates particle namespace-name pair. Used to generate + // the _expected_element call. + // + struct ParticleName: Traversal::Compositor, + Traversal::Element, + Traversal::Any, + Context + { + ParticleName (Context& c) + : Context (c) + { + } + + virtual void + traverse (SemanticGraph::Element& e) + { + String ns (e.qualified_p () ? e.namespace_ ().name () : String ()); + os << strlit (ns) << ", " << strlit (e.name ()); + } + + virtual void + traverse (SemanticGraph::Any& a) + { + String const& ns (*a.namespace_begin ()); + os << strlit (ns) << ", " << L << "\"*\""; + } + + virtual void + traverse (SemanticGraph::Compositor& c) + { + Particles const& p (c.context ().get ("prefixes")); + + dispatch (**p.begin ()); + } + }; + + + // Common base for the ParticleIn{All, Choice, Sequence} treversers. + // + struct ParticleInCompositor: Context + { + protected: + ParticleInCompositor (Context& c, SemanticGraph::Complex& type) + : Context (c), type_ (type), particle_test_ (c) + { + } + + + // Generate sub-parser setup code as well as the pre/post calls. + // + void + pre_post_calls (SemanticGraph::Particle& p) + { + using SemanticGraph::Element; + using SemanticGraph::Complex; + + if (Element* e = dynamic_cast (&p)) + { + SemanticGraph::Type& type (e->type ()); + String const& fq_type (fq_name (type)); + bool poly (polymorphic && !anonymous (type)); + + String name, inst, def_parser, map; + + if (e->context ().count("name")) + { + name = ename (*e); + + if (poly) + { + def_parser = emember (*e); + map = emember_map (*e); + inst = "p"; + } + else + inst = L"this->" + emember (*e); + } + else + { + // This is the subsequent mentioning of this element in the + // content. We need to find the first one in order to get + // to the escaped names. + // + Complex::NamesIteratorPair ip (type_.find (e->name ())); + assert (ip.first != ip.second); + Element& fe (dynamic_cast(ip.first->named ())); + + name = ename (fe); + + if (poly) + { + def_parser = emember (fe); + map = emember_map (fe); + inst = "p"; + } + else + inst = L"this->" + emember (fe); + } + + if (poly) + { + // For pre-computing length. + // + String type_id (type.name ()); + + if (String type_ns = xml_ns_name (type)) + { + type_id += L' '; + type_id += type_ns; + } + + os << fq_type << "* p = 0;" + << endl + << "if (t == 0 && this->" << def_parser << " != 0)" << endl + << inst << " = this->" << def_parser << ";" + << "else" + << "{" + << string_type << " ts (" << fq_name (type) << + "::_static_type (), " << type_id.size () << "UL);" + << endl + << "if (t == 0)" << endl + << "t = &ts;" + << endl + << "if (this->" << def_parser << " != 0 && *t == ts)" << endl + << inst << " = this->" << def_parser << ";" + << "else" + << "{"; + + // Check that the types are related by inheritance. + // + os << "if (t != &ts &&" << endl + << "!::xsd::cxx::parser::validating::" << + "inheritance_map_instance< " << char_type << + " > ().check (" << endl + << "t->data (), ts))" << endl + << "throw ::xsd::cxx::parser::dynamic_type< " << char_type << + " > (*t);" + << endl + << "if (this->" << map << " != 0)" << endl + << inst << " = dynamic_cast< " << fq_type << "* > (" << endl + << "this->" << map << "->find (*t));" + << "}" + << "}"; + } + + os << "this->" << complex_base << "::context_.top ()." << + "parser_ = " << inst << ";" + << endl + << "if (" << inst << ")" << endl + << inst << "->pre ();" + << "}" + << "else" // start + << "{"; + + if (poly) + os << fq_type << "* p =" << endl + << "dynamic_cast< " << fq_type << "* > (" << endl + << "this->" << complex_base << "::context_.top ().parser_);" + << endl; + + os << "if (" << inst << ")" + << "{"; + + String const& ret (ret_type (type)); + String const& post (post_name (type)); + + if (ret == L"void") + os << inst << "->" << post << " ();" + << "this->" << name << " ();"; + else + { + // Don't create an lvalue in C++11 (think std::unique_ptr). + // In C++98 we do it for compatibility with older/broken + // compilers (e.g., IBM xlC that needs an lvalue to pass + // std::auto_ptr). + // + if (std == cxx_version::cxx98) + os << arg_type (type) << " tmp (" << inst << "->" << + post << " ());" + << "this->" << name << " (tmp);"; + else + os << "this->" << name << " (" << inst << "->" << + post << " ());"; + } + + os << "}"; + } + else + { + os << "this->_start_any_element (ns, n, t);" + << "this->" << complex_base << "::context_.top ().any_ = true;" + << "}" + << "else" // start + << "{" + << "this->" << complex_base << "::context_.top ().any_ = false;" + << "this->_end_any_element (ns, n);"; + } + } + + protected: + SemanticGraph::Complex& type_; + ParticleTest particle_test_; + }; + + + + // The 'all' compositor can only contain elements with min={0,1}, max=1. + // + struct ParticleInAll: Traversal::Element, + ParticleInCompositor + { + ParticleInAll (Context& c, SemanticGraph::Complex& type) + : ParticleInCompositor (c, type) + { + } + + virtual void + traverse (SemanticGraph::Element& e) + { + size_t state (e.context ().get ("state")); + + if (state != 0) + os << "else "; + + os << "if ("; + + particle_test_.traverse (e); + + os << ")" + << "{" + << "if (count[" << state << "UL] == 0)" + << "{" + << "if (start)" + << "{"; + + pre_post_calls (e); + + os << "count[" << state << "UL] = 1;" + << "}" + << "}" + << "else" // count != 0 + << "{" + << "assert (start);" // Assuming well-formed XML. + + // Since there is never more content after 'all', we could have + // as well thrown here. But instead we will let the code in + // start_element handle this along with other unexpected + // elements. + // + << "state = ~0UL;" + << "}" + << "}"; + } + }; + + + // + // + struct ParticleInChoice: Traversal::Particle, + Traversal::Compositor, + ParticleInCompositor + { + ParticleInChoice (Context& c, SemanticGraph::Complex& type) + : ParticleInCompositor (c, type), particle_name_ (c) + { + } + + virtual void + traverse (SemanticGraph::Particle& p) + { + using SemanticGraph::Element; + + size_t state (p.context ().get ("state")); + + size_t min (p.min ()), max (p.max ()); + + os << "case " << state << "UL:" << endl + << "{"; + + if (max != 1) // We don't need the test if max == 1. + { + os << "if ("; + + particle_test_.dispatch (p); + + os << ")" + << "{"; + } + + os << "if (start)" + << "{"; + + pre_post_calls (p); + + switch (max) + { + case 0: + { + os << "count++;"; + break; + } + case 1: + { + // We do not need to increment count because min <= max and + // we do not generate min check for min <= 1 (see below). + // + os << "state = ~0UL;"; + break; + } + default: + { + os << "if (++count == " << max << "UL)" << endl + << "state = ~0UL;"; + } + }; + + os << "}"; // start + + // We've already moved to the final state if max == 1. + // + if (max != 1) + { + os << "}" + << "else" + << "{" + << "assert (start);"; // Assuming well-formed XML + + // Check if min cardinality requirements have been met. Since + // count is always >= 1, don't generate dead code if min <= 1. + // + if (min > 1) + { + os << "if (count < " << min << "UL)" << endl + << "this->_expected_element (" << endl; + + particle_name_.dispatch (p); + + os << "," << endl + << "ns, n);"; + } + + + os << "state = ~0UL;" + << "}"; + } + + os << "break;" + << "}"; // case + } + + virtual void + traverse (SemanticGraph::Compositor& c) + { + using SemanticGraph::Compositor; + + size_t max (c.max ()); + size_t min (c.context ().get ("effective-min")); + size_t n (c.context ().get ("comp-number")); + size_t state (c.context ().get ("state")); + + String func (c.is_a () ? + "choice_" : "sequence_"); + + os << "case " << state << "UL:" << endl + << "{" + << "unsigned long s (~0UL);" + << endl; + + bool first (true); + + for (Compositor::ContainsIterator ci (c.contains_begin ()); + ci != c.contains_end (); ++ci) + { + SemanticGraph::Particle& p (ci->particle ()); + + if (p.is_a () && !c.context ().count ("comp-number")) + continue; // Empty compositor. + + if (!p.context ().count ("prefix")) + break; + + size_t state (p.context ().get ("state")); + + if (first) + first = false; + else + os << "else "; + + os << "if ("; + + particle_test_.dispatch (p); + + os << ")" << endl + << "s = " << state << "UL;"; + } + + // This compositor. + // + os << endl + << "if (s != ~0UL)" + << "{" + << "assert (start);"; // End is handled by the sub-machine. + + switch (max) + { + case 0: + { + os << "count++;"; + break; + } + case 1: + { + // We do not need to increment count because min <= max and + // we do not generate min check for min <= 1 (see below). + // + os << "state = ~0UL;"; + break; + } + default: + { + os << "if (++count == " << max << "UL)" << endl + << "state = ~0UL;"; + } + }; + + // Delegate to the sub-machine. + // + + os << endl + << "v_state_& vs = *static_cast< v_state_* > (" << + "this->v_state_stack_.top ());" + << "v_state_descr_& vd = vs.data[vs.size++];" // push + << endl + << "vd.func = &" << ename (type_) << "::" << func << n << ";" + << "vd.state = s;" + << "vd.count = 0;" + << endl + << "this->" << func << n << " (vd.state, vd.count, ns, n, t, true);" + << "}"; + + + // Not this compositor. We've elready moved to the final state + // if max == 1. + // + if (max != 1) + { + os << "else" + << "{" + << "assert (start);"; // Assuming well-formed XML + + // Check if min cardinality requirements have been met. Since + // count is always >= 1, don't generate dead code if min <= 1. + // + if (min > 1) + { + os << "if (count < " << min << "UL)" << endl + << "this->_expected_element (" << endl; + + particle_name_.dispatch (c); + + os << "," << endl + << "ns, n);"; + } + + os << "state = ~0UL;" + << "}"; + } + + os << "break;" + << "}"; // case + } + + private: + ParticleName particle_name_; + }; + + + // + // + struct ParticleInSequence: Traversal::Particle, + Traversal::Compositor, + ParticleInCompositor + { + ParticleInSequence (Context& c, + size_t state, + size_t next_state, + SemanticGraph::Complex& type) + : ParticleInCompositor (c, type), + state_ (state), particle_name_ (c) + { + // next_state == 0 indicates the terminal state (~0UL). + // + if (next_state != 0) + { + std::wostringstream ostr; + ostr << next_state; + next_state_ = ostr.str (); + } + else + next_state_ = L"~0"; + } + + virtual void + traverse (SemanticGraph::Particle& p) + { + size_t min (p.min ()), max (p.max ()); + + os << "case " << state_ << "UL:" << endl + << "{" + << "if ("; + + particle_test_.dispatch (p); + + os << ")" + << "{"; + + // This element. + // + + os << "if (start)" + << "{"; + + pre_post_calls (p); + + switch (max) + { + case 0: + { + os << "count++;"; + break; + } + case 1: + { + os << "count = 0;" + << "state = " << next_state_ << "UL;"; + break; + } + default: + { + os << "if (++count == " << max << "UL)" + << "{" + << "count = 0;" + << "state = " << next_state_ << "UL;" + << "}"; + } + }; + + os << "}" // start + << "break;" + << "}"; + + // Not this element. + // + + os << "else" + << "{" + << "assert (start);"; // Assuming well-formed XML. + + // Check if min cardinality requirements have been met. Since + // count is always >= 0, don't generate dead code if min == 0. + // + if (min != 0) + { + os << "if (count < " << min << "UL)" << endl + << "this->_expected_element (" << endl; + + particle_name_.dispatch (p); + + os << "," << endl + << "ns, n);"; + } + + os << "count = 0;" + << "state = " << next_state_ << "UL;" + << "}" // else + << "}" // case + << "// Fall through." << endl; + } + + virtual void + traverse (SemanticGraph::Compositor& c) + { + using SemanticGraph::Compositor; + + size_t max (c.max ()); + size_t min (c.context ().get ("effective-min")); + size_t n (c.context ().get ("comp-number")); + + String func (c.is_a () ? + "choice_" : "sequence_"); + + os << "case " << state_ << "UL:" << endl + << "{" + << "unsigned long s (~0UL);" + << endl; + + bool first (true); + + for (Compositor::ContainsIterator ci (c.contains_begin ()); + ci != c.contains_end (); ++ci) + { + SemanticGraph::Particle& p (ci->particle ()); + + if (p.is_a () && !c.context ().count ("comp-number")) + continue; // Empty compositor. + + if (!p.context ().count ("prefix")) + break; + + size_t state (p.context ().get ("state")); + + if (first) + first = false; + else + os << "else "; + + os << "if ("; + + particle_test_.dispatch (p); + + os << ")" << endl + << "s = " << state << "UL;"; + } + + // This element. + // + + os << endl + << "if (s != ~0UL)" + << "{" + << "assert (start);"; // End is handled by the sub-machine. + + switch (max) + { + case 0: + { + os << "count++;" + << endl; + break; + } + case 1: + { + os << "count = 0;" + << "state = " << next_state_ << "UL;" + << endl; + break; + } + default: + { + os << "if (++count == " << max << "UL)" + << "{" + << "count = 0;" + << "state = " << next_state_ << "UL;" + << "}"; + } + }; + + // Delegate to the sub-machine. + // + + os << "v_state_& vs = *static_cast< v_state_* > (" << + "this->v_state_stack_.top ());" + << "v_state_descr_& vd = vs.data[vs.size++];" // push + << endl + << "vd.func = &" << ename (type_) << "::" << func << n << ";" + << "vd.state = s;" + << "vd.count = 0;" + << endl + << "this->" << func << n << " (vd.state, vd.count, ns, n, t, true);" + << "break;" + << "}"; + + // Not this compositor. + // + + os << "else" + << "{" + << "assert (start);"; // Assuming well-formed XML + + // Check if min cardinality requirements have been met. Since + // count is always >= 0, don't generate dead code if min == 0. + // + if (min != 0) + { + os << "if (count < " << min << "UL)" << endl + << "this->_expected_element (" << endl; + + particle_name_.dispatch (c); + + os << "," << endl + << "ns, n);"; + } + + os << "count = 0;" + << "state = " << next_state_ << "UL;" + << "}" // else + << "}" // case + << "// Fall through." << endl; + } + + private: + size_t state_; + String next_state_; + + ParticleName particle_name_; + }; + + + // + // + struct ParticleFunction: Traversal::All, + Traversal::Choice, + Traversal::Sequence, + Context + { + ParticleFunction (Context& c, SemanticGraph::Complex& type) + : Context (c), type_ (type) + { + *this >> contains_particle_ >> *this; + } + + + virtual void + traverse (SemanticGraph::All& a) + { + if (!a.context().count ("comp-number")) // Empty compositor. + return; + + using SemanticGraph::Element; + using SemanticGraph::Compositor; + + + os << "void " << ename (type_) << "::" << endl + << "all_0 (unsigned long& state," << endl + << "unsigned char* count," << endl + << "const " << string_type << "& ns," << endl + << "const " << string_type << "& n," << endl + << "const " << string_type << "* t," << endl + << "bool start)" + << "{" + << "XSD_UNUSED (t);" + << endl; + + for (Compositor::ContainsIterator ci (a.contains_begin ()), + ce (a.contains_end ()); ci != ce; ++ci) + { + ParticleInAll t (*this, type_); + t.dispatch (ci->particle ()); + } + + // Handle the flush. + // + os << "else if (n.empty () && ns.empty ())" + << "{"; + + for (Compositor::ContainsIterator ci (a.contains_begin ()), + ce (a.contains_end ()); ci != ce; ++ci) + { + if (ci->min () == 0) + continue; + + Element& e (dynamic_cast (ci->particle ())); + String ns (e.qualified_p () ? e.namespace_ ().name () : String ()); + size_t state (e.context ().get ("state")); + + os << "if (count[" << state << "UL] == 0)" << endl + << "this->_expected_element (" << endl + << strlit (ns) << ", " << + strlit (e.name ()) << ");" + << endl; + } + + os << "state = ~0UL;" + << "}" + << "else" << endl + << "state = ~0UL;" + << "}"; + } + + virtual void + traverse (SemanticGraph::Choice& c) + { + if (!c.context().count ("comp-number")) // Empty compositor. + return; + + using SemanticGraph::Compositor; + + size_t n (c.context ().get ("comp-number")); + + os << "void " << ename (type_) << "::" << endl + << "choice_" << n << " (unsigned long& state," << endl + << "unsigned long& count," << endl + << "const " << string_type << "& ns," << endl + << "const " << string_type << "& n," << endl + << "const " << string_type << "* t," << endl + << "bool start)" + << "{" + << "XSD_UNUSED (count);" + << "XSD_UNUSED (ns);" + << "XSD_UNUSED (n);" + << "XSD_UNUSED (t);" + << endl + << "switch (state)" + << "{"; + + for (Compositor::ContainsIterator ci (c.contains_begin ()), + ce (c.contains_end ()); ci != ce; ++ci) + { + SemanticGraph::Particle& p (ci->particle ()); + + if (p.is_a () && !p.context().count ("comp-number")) + continue; // Empty compositor. + + ParticleInChoice t (*this, type_); + t.dispatch (p); + } + + os << "}" // switch + << "}"; + + // Generate nested compositor functions. + // + Traversal::Choice::traverse (c); + } + + virtual void + traverse (SemanticGraph::Sequence& s) + { + if (!s.context().count ("comp-number")) // Empty compositor. + return; + + using SemanticGraph::Compositor; + + size_t n (s.context ().get ("comp-number")); + + os << "void " << ename (type_) << "::" << endl + << "sequence_" << n << " (unsigned long& state," << endl + << "unsigned long& count," << endl + << "const " << string_type << "& ns," << endl + << "const " << string_type << "& n," << endl + << "const " << string_type << "* t," << endl + << "bool start)" + << "{" + << "XSD_UNUSED (t);" + << endl + << "switch (state)" + << "{"; + + size_t state (0); + + for (Compositor::ContainsIterator ci (s.contains_begin ()), + ce (s.contains_end ()); ci != ce;) + { + SemanticGraph::Particle& p (ci->particle ()); + + if (p.is_a () && !p.context().count ("comp-number")) + { + // Empty compositor. + // + ++ci; + continue; + } + + // Find the next state. + // + do + ++ci; + while (ci != ce && + ci->particle ().is_a () && + !ci->particle ().context().count ("comp-number")); + + size_t next (ci == ce ? 0 : state + 1); + + ParticleInSequence t (*this, state++, next, type_); + t.dispatch (p); + } + + os << "case ~0UL:" << endl + << "break;" + << "}" // switch + << "}"; + + // Generate nested compositor functions. + // + Traversal::Sequence::traverse (s); + } + + private: + SemanticGraph::Complex& type_; + Traversal::ContainsParticle contains_particle_; + }; + + + // + // + struct CompositorPre: Traversal::All, + Traversal::Compositor, + Context + { + CompositorPre (Context& c) + : Context (c) + { + } + + virtual void + traverse (SemanticGraph::All& a) + { + // Clear the counts and push the initial state. + // + os << "v_all_count_.push ();" + << endl; + + SemanticGraph::Compositor& c (a); + traverse (c); + } + + virtual void + traverse (SemanticGraph::Compositor&) // Choice and sequence. + { + os << "v_state_& vs = *static_cast< v_state_* > (" << + "this->v_state_stack_.top ());" + << "v_state_descr_& vd = vs.data[vs.size++];" // push + << endl + << "vd.func = 0;" + << "vd.state = 0;" + << "vd.count = 0;"; + } + }; + + + // + // + struct CompositorStartElement: Traversal::All, + Traversal::Compositor, + Context + { + CompositorStartElement (Context& c, SemanticGraph::Complex& type) + : Context (c), type_ (type), + particle_test_ (c), particle_name_ (c) + { + } + + virtual void + traverse (SemanticGraph::All&) + { + // The 'all' state machine reaches the final state only + // on an unknown element, in which case we won't get here + // again (it would be a validation error). Note that 'all' + // compositor cannot contain nested compositors so we don't + // need to re-set vd. + // + os << "all_0 (vd->state, v_all_count_.top (), ns, n, t, true);" + << endl + << "if (vd->state != ~0UL)" << endl + << "vd->count++;" + << "else" << endl + << "return false;" // Let our parent handle this. + << endl; + } + + virtual void + traverse (SemanticGraph::Compositor& c) // Choice and sequence. + { + using SemanticGraph::Compositor; + + size_t max (c.max ()); + size_t min (c.context ().get ("effective-min")); + size_t n (c.context ().get ("comp-number")); + + String func (c.is_a () ? + "choice_" : "sequence_"); + + // Invoke the current state machine. If it reaches its + // terminal state, pop it and invoke the next one until + // we reach the top, which requires special handling. + // + os << "while (vd->func != 0)" + << "{" + << "(this->*vd->func) (vd->state, vd->count, ns, n, t, true);" + << endl + << "vd = vs.data + (vs.size - 1);" // re-acquire + << endl + << "if (vd->state == ~0UL)" << endl + << "vd = vs.data + (--vs.size - 1);" // pop + << "else" << endl + << "break;" + << "}"; + + + // Check if we got to the top. This code is pretty much the + // same as the one found in ParticleInSequence. + // + os << "if (vd->func == 0)" + << "{" + << "if (vd->state != ~0UL)" + << "{" + << "unsigned long s = ~0UL;" + << endl; + + bool first (true); + + // Note that we don't need to worry about the compositor + // being empty - this case is handled by our caller. + // + for (Compositor::ContainsIterator ci (c.contains_begin ()); + ci != c.contains_end (); ++ci) + { + SemanticGraph::Particle& p (ci->particle ()); + + if (p.is_a () && !c.context ().count ("comp-number")) + continue; // Empty compositor. + + if (!p.context ().count ("prefix")) + break; + + size_t state (p.context ().get ("state")); + + if (first) + first = false; + else + os << "else "; + + os << "if ("; + + particle_test_.dispatch (p); + + os << ")" << endl + << "s = " << state << "UL;"; + } + + os << endl + << "if (s != ~0UL)" + << "{"; + + // This element is a prefix of the root compositor. + // + + switch (max) + { + case 0: + { + os << "vd->count++;"; + break; + } + case 1: + { + os << "vd->count++;" + << "vd->state = ~0UL;"; + break; + } + default: + { + os << "if (++vd->count == " << max << "UL)" << endl + << "vd->state = ~0UL;"; + } + }; + + // Delegate to the sub-machine. + // + + os << endl + << "vd = vs.data + vs.size++;" // push + << "vd->func = &" << ename (type_) << "::" << func << n << ";" + << "vd->state = s;" + << "vd->count = 0;" + << endl + << "this->" << func << n << " (vd->state, vd->count, ns, n, t, true);" + << "}"; + + // This element is not our prefix. + // + + os << "else" + << "{"; + + // Check if min cardinality requirements have been met. Since + // count is always >= 0, don't generate dead code if min == 0. + // + if (min != 0) + { + os << "if (vd->count < " << min << "UL)" << endl + << "this->_expected_element (" << endl; + + particle_name_.dispatch (c); + + os << "," << endl + << "ns, n);"; + } + + // Return false to indicate that we are not handling this element. + // + os << "return false;" + << "}" + << "}" // if (state != ~0) + << "else" << endl + << "return false;" + << "}"; // if (function == 0) + } + + private: + SemanticGraph::Complex& type_; + ParticleTest particle_test_; + ParticleName particle_name_; + }; + + + // + // + struct CompositorEndElement: Traversal::All, + Traversal::Compositor, + Context + { + CompositorEndElement (Context& c) + : Context (c) + { + } + + virtual void + traverse (SemanticGraph::All&) + { + os << "all_0 (vd.state, v_all_count_.top (), " << + "ns, n, 0, false);" + << endl; + } + + virtual void + traverse (SemanticGraph::Compositor&) // Choice and sequence. + { + os << "assert (vd.func != 0);" + << "(this->*vd.func) (vd.state, vd.count, ns, n, 0, false);" + << endl + << "if (vd.state == ~0UL)" << endl + << "vs.size--;" // pop + << endl; + } + }; + + + // + // + struct CompositorPost: Traversal::All, + Traversal::Compositor, + Context + { + CompositorPost (Context& c) + : Context (c), particle_name_ (c) + { + } + + virtual void + traverse (SemanticGraph::All& a) + { + using SemanticGraph::Element; + + os << "v_state_& vs = *static_cast< v_state_* > (" << + "this->v_state_stack_.top ());" + << "v_state_descr_& vd = vs.data[vs.size - 1];" + << endl; + + // Flush the state machine with the empty element name. This + // allows us to detect missing content. + // + os << "if (vd.count != 0)" + << "{" + << string_type << " empty;" + << "all_0 (vd.state, v_all_count_.top (), empty, empty, 0, true);" + << "}"; + + if (a.context ().get ("effective-min") != 0) + { + os << "else" << endl + << "this->_expected_element (" << endl; + + particle_name_.dispatch (a); + + os << ");"; + } + + os << endl + << "vs.size--;" // pop + << "v_all_count_.pop ();"; + } + + virtual void + traverse (SemanticGraph::Compositor& c) // Choice and sequence. + { + size_t min (c.context ().get ("effective-min")); + + os << "v_state_& vs = *static_cast< v_state_* > (" << + "this->v_state_stack_.top ());" + << "v_state_descr_* vd = vs.data + (vs.size - 1);" + << endl; + + + // Flush unfinished state machines with the empty element name. + // This allows us to detect missing content. Note that I am + // not re-setting vd since no new compositors are pushed on + // flush. + // + os << string_type << " empty;" + << "while (vd->func != 0)" + << "{" + << "(this->*vd->func) (vd->state, vd->count, empty, empty, 0, true);" + << "assert (vd->state == ~0UL);" + << "vd = vs.data + (--vs.size - 1);" // pop + << "}"; + + // Check if min cardinality requirements have been met. Since + // count is always >= 0, don't generate dead code if min == 0. + // + if (min != 0) + { + os << "if (vd->count < " << min << "UL)" << endl + << "this->_expected_element (" << endl; + + particle_name_.dispatch (c); + + os << ");"; + } + } + + private: + ParticleName particle_name_; + }; + + + // + // + struct Complex: Traversal::Complex, Context + { + Complex (Context& c) + : Context (c) + { + } + + virtual void + traverse (Type& c) + { + // Nothing to generate if we don't have any elements and wildcards. + // + if (!has (c) && + !has_particle (c)) + return; + + using SemanticGraph::Compositor; + + String const& name (ename (c)); + Compositor& comp (c.contains_compositor ().compositor ()); + + // Don't use restriction_p here since we don't want special + // treatment of anyType. + // + bool restriction ( + c.inherits_p () && + c.inherits ().is_a ()); + + os <<"// Element validation and dispatch functions for " << + name << "." << endl + <<"//" << endl; + + // _start_element_impl + // + + os << "bool " << name << "::" << endl + << "_start_element_impl (const " << string_type << "& ns," << endl + << "const " << string_type << "& n," << endl + << "const " << string_type << "* t)" + << "{" + << "XSD_UNUSED (t);" + << endl; + + os << "v_state_& vs = *static_cast< v_state_* > (" << + "this->v_state_stack_.top ());" + << "v_state_descr_* vd = vs.data + (vs.size - 1);" + << endl; + + //@@ OPT: I don't really need to call parser_base since it always + // returns false. + // + // In case of an inheritance-by-extension, call our base first. + // We don't need to generate this code for the 'all' compositor + // because it can only inherit from the empty content model. + // States of the root machine for sequence and choice: + // + // 0 - calling base + // 1 - base returned false + // ~0 - terminal state + // + if (!restriction && !comp.is_a ()) + { + os << "if (vd->func == 0 && vd->state == 0)" + << "{" + << "if (this->"; + + if (c.inherits_p ()) + os << fq_name (c.inherits ().base ()); + else + os << complex_base; + + + os << "::_start_element_impl (ns, n, t))" << endl + << "return true;" + << "else" << endl + << "vd->state = 1;" + << "}"; + } + + { + CompositorStartElement t (*this, c); + t.dispatch (comp); + } + + os << "return true;" + << "}"; + + + // _end_element_impl + // + + os << "bool " << name << "::" << endl + << "_end_element_impl (const " << string_type << "& ns," << endl + << "const " << string_type << "& n)" + << "{"; + + os << "v_state_& vs = *static_cast< v_state_* > (" << + "this->v_state_stack_.top ());" + << "v_state_descr_& vd = vs.data[vs.size - 1];" + << endl; + + //@@ OPT: I don't really need to call parser_base since it always + // returns false. + // + // In case of an inheritance-by-extension, call our base first. + // We don't need to generate this code for the 'all' compositor + // because it can only inherit from the empty content model. + // + if (!restriction && !comp.is_a ()) + { + os << "if (vd.func == 0 && vd.state == 0)" + << "{" + << "if (!"; + + if (c.inherits_p ()) + os << fq_name (c.inherits ().base ()); + else + os << complex_base; + + os << "::_end_element_impl (ns, n))" << endl + << "assert (false);" // Start and end should match. + << "return true;" + << "}"; + } + + { + CompositorEndElement t (*this); + t.dispatch (comp); + } + + os << "return true;" + << "}"; + + + // _pre_e_validate + // + os << "void " << name << "::" << endl + << "_pre_e_validate ()" + << "{" + << "this->v_state_stack_.push ();" + << "static_cast< v_state_* > (this->v_state_stack_.top ())->" << + "size = 0;" + << endl; + + { + CompositorPre t (*this); + t.dispatch (comp); + } + + // In case of an inheritance-by-extension, call our base + // _pre_e_validate. We don't need to generate this code for the + // 'all' compositor because it can only inherit from the empty + // content model. + // + if (!restriction && !comp.is_a ()) + { + // We don't need to call parser_base's implementation + // since it does nothing. + // + if (c.inherits_p ()) + { + os << endl + << fq_name (c.inherits ().base ()) << "::_pre_e_validate ();"; + } + } + + os << "}"; + + + // _post_e_validate + // + os << "void " << name << "::" << endl + << "_post_e_validate ()" + << "{"; + + // In case of an inheritance-by-extension, call our base + // _post_e_validate. We don't need to generate this code for + // the 'all' compositor because it can only inherit from + // the empty content model. + // + if (!restriction && !comp.is_a ()) + { + // We don't need to call parser_base's implementation + // since it does nothing. + // + if (c.inherits_p ()) + { + os << fq_name (c.inherits ().base ()) << "::_post_e_validate ();" + << endl; + } + } + + { + CompositorPost t (*this); + t.dispatch (c.contains_compositor ().compositor ()); + } + + os << endl + << "this->v_state_stack_.pop ();" + << "}"; + + // + // + ParticleFunction t (*this, c); + t.dispatch (c.contains_compositor ().compositor ()); + } + }; + } + + void + generate_element_validation_source (Context& ctx) + { + ctx.os << "#include " << endl + << endl; + + Traversal::Schema schema; + + Sources sources; + Traversal::Names schema_names; + + Namespace ns (ctx); + Traversal::Names names; + + schema >> sources >> schema; + schema >> schema_names >> ns >> names; + + Complex complex (ctx); + + names >> complex; + + schema.dispatch (ctx.schema_root); + } + } +} diff --git a/xsd/cxx/parser/element-validation-source.hxx b/xsd/cxx/parser/element-validation-source.hxx new file mode 100644 index 0000000..b358aee --- /dev/null +++ b/xsd/cxx/parser/element-validation-source.hxx @@ -0,0 +1,18 @@ +// file : xsd/cxx/parser/element-validation-source.hxx +// license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +#ifndef XSD_CXX_PARSER_ELEMENT_VALIDATION_SOURCE_HXX +#define XSD_CXX_PARSER_ELEMENT_VALIDATION_SOURCE_HXX + +#include + +namespace CXX +{ + namespace Parser + { + void + generate_element_validation_source (Context&); + } +} + +#endif // XSD_CXX_PARSER_ELEMENT_VALIDATION_SOURCE_HXX diff --git a/xsd/cxx/parser/elements.cxx b/xsd/cxx/parser/elements.cxx new file mode 100644 index 0000000..63fb3d5 --- /dev/null +++ b/xsd/cxx/parser/elements.cxx @@ -0,0 +1,247 @@ +// file : xsd/cxx/parser/elements.cxx +// license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +#include + +namespace CXX +{ + namespace Parser + { + Context:: + Context (std::wostream& o, + SemanticGraph::Schema& root, + SemanticGraph::Path const& path, + options_type const& ops, + StringLiteralMap const* map, + Regex const* he, + Regex const* ie, + Regex const* hie) + : CXX::Context (o, root, path, ops, map), + options (ops), + xml_parser (xml_parser_), + simple_base (simple_base_), + complex_base (complex_base_), + list_base (list_base_), + cout_inst (cout_inst_), + cerr_inst (cerr_inst_), + parser_map (parser_map_), + std_string_type (std_string_type_), + validation (validation_), + polymorphic (polymorphic_), + hxx_expr (he), + ixx_expr (ie), + hxx_impl_expr (hie), + xml_parser_ (ops.xml_parser ()), + validation_ ((ops.xml_parser () == "expat" || + ops.generate_validation ()) && + !ops.suppress_validation ()), + polymorphic_ (ops.generate_polymorphic ()) + { + if (char_type == L"char") + std_string_type = L"::std::string"; + else if (char_type == L"wchar_t") + std_string_type = L"::std::wstring"; + else + std_string_type = L"::std::basic_string< " + char_type + L" >"; + + String xs_ns (xs_ns_name ()); + + string_type = xs_ns + L"::ro_string"; + simple_base = xs_ns + L"::simple_content"; + complex_base = xs_ns + L"::complex_content"; + list_base = xs_ns + L"::list_base"; + + cout_inst = (char_type == L"char" ? L"std::cout" : L"std::wcout"); + cerr_inst = (char_type == L"char" ? L"std::cerr" : L"std::wcerr"); + + if (polymorphic) + parser_map_ = xs_ns + L"::parser_map"; + } + + Context:: + Context (Context& c) + : CXX::Context (c), + options (c.options), + xml_parser (c.xml_parser), + simple_base (c.simple_base), + complex_base (c.complex_base), + list_base (c.list_base), + cout_inst (c.cout_inst), + cerr_inst (c.cerr_inst), + parser_map (c.parser_map), + std_string_type (c.std_string_type), + validation (c.validation), + polymorphic (c.polymorphic), + hxx_expr (c.hxx_expr), + ixx_expr (c.ixx_expr), + hxx_impl_expr (c.hxx_impl_expr) + { + } + + Context:: + Context (Context& c, std::wostream& o) + : CXX::Context (c, o), + options (c.options), + xml_parser (c.xml_parser), + simple_base (c.simple_base), + complex_base (c.complex_base), + list_base (c.list_base), + cout_inst (c.cout_inst), + cerr_inst (c.cerr_inst), + parser_map (c.parser_map), + std_string_type (c.std_string_type), + validation (c.validation), + polymorphic (c.polymorphic), + hxx_expr (c.hxx_expr), + ixx_expr (c.ixx_expr), + hxx_impl_expr (c.hxx_impl_expr) + { + } + + Content::Value Context:: + content (SemanticGraph::Complex& c) + { + using namespace SemanticGraph; + + if (c.mixed_p ()) + return Content::mixed; + + if (c.inherits_p ()) + { + Type& base (c.inherits ().base ()); + + if (Complex* cb = dynamic_cast (&base)) + return content (*cb); + + if (base.is_a ()) + return Content::complex; + + // Everyhting else (built-in type and AnySimpleType) is simple + // content. + // + return Content::simple; + } + else + return Content::complex; + } + + bool Context:: + anonymous (SemanticGraph::Type& t) + { + return t.context ().count ("anonymous"); + } + + String const& Context:: + ret_type (SemanticGraph::Type& t) + { + return t.context ().get ("ret-type"); + } + + String const& Context:: + arg_type (SemanticGraph::Type& t) + { + return t.context ().get ("arg-type"); + } + + String const& Context:: + post_name (SemanticGraph::Type& t) + { + return t.context ().get ("post"); + } + + String const& Context:: + eparser (SemanticGraph::Member& m) + { + return m.context ().get ("parser"); + } + + String const& Context:: + emember (SemanticGraph::Member& m) + { + return m.context ().get ("member"); + } + + String const& Context:: + emember_map (SemanticGraph::Member& m) + { + return m.context ().get ("member-map"); + } + + String const& Context:: + eimpl (SemanticGraph::Type& t) + { + return t.context ().get ("impl"); + } + + // Includes + // + void TypeForward:: + traverse (SemanticGraph::Type& t) + { + os << "class " << t.context ().get (name_key_) << ";"; + } + + void Includes:: + traverse_ (SemanticGraph::Uses& u) + { + // Support for weak (forward) inclusion used in the file-per-type + // compilation model. + // + SemanticGraph::Schema& s (u.schema ()); + bool weak (u.context ().count ("weak")); + + if (weak && (type_ == header || type_ == impl_header)) + { + // Generate forward declarations. We don't really need them + // in the impl files. + // + if (type_ == header) + schema_.dispatch (s); + + return; + } + + if (type_ == source && !weak) + return; + + SemanticGraph::Path path ( + s.context ().count ("renamed") + ? s.context ().get ("renamed") + : u.path ()); + path.normalize (); + + // Try to use the portable representation of the path. If that + // fails, fall back to the native representation. + // + NarrowString path_str; + try + { + path_str = path.posix_string (); + } + catch (SemanticGraph::InvalidPath const&) + { + path_str = path.string (); + } + + String inc_path; + + switch (type_) + { + case header: + case source: + { + inc_path = ctx_.hxx_expr->replace (path_str); + break; + } + case impl_header: + { + inc_path = ctx_.hxx_impl_expr->replace (path_str); + break; + } + } + + ctx_.os << "#include " << ctx_.process_include_path (inc_path) << endl + << endl; + } + } +} diff --git a/xsd/cxx/parser/elements.hxx b/xsd/cxx/parser/elements.hxx new file mode 100644 index 0000000..0015923 --- /dev/null +++ b/xsd/cxx/parser/elements.hxx @@ -0,0 +1,315 @@ +// file : xsd/cxx/parser/elements.hxx +// license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +#ifndef XSD_CXX_PARSER_ELEMENTS_HXX +#define XSD_CXX_PARSER_ELEMENTS_HXX + +#include + +#include + +#include + +#include + +#include + +namespace CXX +{ + namespace Parser + { + struct Content + { + enum Value + { + simple, + complex, + mixed + }; + }; + + // + // + class Context: public CXX::Context + { + public: + typedef cutl::re::regexsub Regex; + + typedef Parser::options options_type; + + public: + Context (std::wostream&, + SemanticGraph::Schema&, + SemanticGraph::Path const& path, + options_type const&, + StringLiteralMap const*, + Regex const* hxx_expr, + Regex const* ixx_expr, + Regex const* hxx_impl_expr); + + protected: + Context (Context& c); + Context (Context& c, std::wostream& o); + + public: + bool + restriction_p (SemanticGraph::Complex& c) const + { + if (c.inherits_p () && + c.inherits ().is_a ()) + { + // Restriction of anyType is a special case. + // + return !c.inherits ().base ().is_a (); + } + + return false; + } + + public: + static Content::Value + content (SemanticGraph::Complex&); + + public: + static bool + anonymous (SemanticGraph::Type&); + + public: + static String const& + ret_type (SemanticGraph::Type&); + + static String const& + arg_type (SemanticGraph::Type&); + + static String const& + post_name (SemanticGraph::Type&); + + public: + static String const& + eparser (SemanticGraph::Member&); + + static String const& + emember (SemanticGraph::Member&); + + static String const& + emember_map (SemanticGraph::Member&); + + public: + static String const& + eimpl (SemanticGraph::Type&); + + public: + options_type const& options; + String& xml_parser; + String& simple_base; + String& complex_base; + String& list_base; + String& cout_inst; + String& cerr_inst; + String& parser_map; + String& std_string_type; + bool& validation; + bool& polymorphic; + + Regex const* hxx_expr; + Regex const* ixx_expr; + Regex const* hxx_impl_expr; + + private: + String xml_parser_; + String simple_base_; + String complex_base_; + String list_base_; + String cout_inst_; + String cerr_inst_; + String parser_map_; + String std_string_type_; + bool validation_; + bool polymorphic_; + }; + + // + // + struct RequiredAttributeTest: Traversal::Attribute + { + RequiredAttributeTest (bool& result) + : result_ (result) + { + } + + virtual void + traverse (Type& a) + { + if (!result_ && !a.optional_p ()) + result_ = true; + } + + private: + bool& result_; + }; + + // + // + struct ParserParamDecl: Traversal::Complex, + Traversal::List, + Traversal::Member, + Context + { + ParserParamDecl (Context& c, bool name_arg) + : Context (c), first_ (true), name_arg_ (name_arg) + { + inherits_ >> *this; + names_ >> *this; + } + + virtual void + traverse (SemanticGraph::Complex& c) + { + inherits (c, inherits_); + + if (!restriction_p (c)) + names (c, names_); + } + + virtual void + traverse (SemanticGraph::List& l) + { + if (!first_) + os << "," << endl; + else + first_ = false; + + os << fq_name (l.argumented ().type ()) << "&"; + + if (name_arg_) + os << " " << ename (l) << "_item"; + else + os << " /* " << comment (l.name ()) << " item */"; + } + + virtual void + traverse (SemanticGraph::Member& m) + { + if (skip (m)) return; + + if (!first_) + os << "," << endl; + else + first_ = false; + + os << fq_name (m.type ()) << "&"; + + if (name_arg_) + os << " " << ename (m); + else + os << " /* " << comment (m.name ()) << " */"; + } + + private: + Traversal::Inherits inherits_; + Traversal::Names names_; + + bool first_; + bool name_arg_; + }; + + + // + // + struct TypeForward: Traversal::Type, Context + { + TypeForward (Context& c, char const* name_key) + : Context (c), name_key_ (name_key) + { + } + + virtual void + traverse (SemanticGraph::Type& t); + + private: + char const* name_key_; + }; + + struct Includes: Traversal::Imports, + Traversal::Includes + { + enum Type + { + header, + source, + impl_header + }; + + Includes (Context& c, Type t) + : ctx_ (c), + type_ (t), + namespace_ (c), + type_forward_ (c, t == header ? "name" : "impl") + { + schema_ >> schema_names_ >> namespace_ >> names_ >> type_forward_; + } + + virtual void + traverse (SemanticGraph::Imports& i) + { + traverse_ (i); + } + + virtual void + traverse (SemanticGraph::Includes& i) + { + traverse_ (i); + } + + private: + void + traverse_ (SemanticGraph::Uses&); + + private: + Context& ctx_; + Type type_; + + Traversal::Schema schema_; + Traversal::Names schema_names_; + Namespace namespace_; + Traversal::Names names_; + TypeForward type_forward_; + }; + + // Find root element for the test driver. + // + struct RootElement: Traversal::Element + { + typedef Parser::options options_type; + + RootElement (options_type const& options, + SemanticGraph::Element*& element) + : options_ (options), element_ (element) + { + } + + virtual void + traverse (Type& e) + { + if (options_.root_element_first ()) + { + if (element_ == 0) + element_ = &e; + } + else if (String name = options_.root_element ()) + { + if (e.name () == name) + element_ = &e; + } + else + element_ = &e; // Cover root-element-last and no option. + } + + private: + options_type const& options_; + SemanticGraph::Element*& element_; + }; + } +} + +#endif // XSD_CXX_PARSER_ELEMENTS_HXX diff --git a/xsd/cxx/parser/generator.cxx b/xsd/cxx/parser/generator.cxx new file mode 100644 index 0000000..b1acdbb --- /dev/null +++ b/xsd/cxx/parser/generator.cxx @@ -0,0 +1,1133 @@ +// file : xsd/cxx/parser/generator.cxx +// license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +#include +#include +#include + +#include + +#include +#include +#include + +#include + +#include + +#include +#include +#include + +#include +#include + +#include +#include +#include +#include + +#include +#include +#include +#include + +#include +#include +#include + +#include +#include +#include + +#include + +using std::endl; +using std::wcerr; +using std::wcout; + +using namespace XSDFrontend::SemanticGraph; + +// +// +typedef std::wifstream WideInputFileStream; +typedef std::wofstream WideOutputFileStream; +typedef std::ifstream NarrowInputFileStream; + +namespace CXX +{ + namespace + { + char const copyright_gpl[] = + "// Copyright (c) " XSD_COPYRIGHT ".\n" + "//\n" + "// This program was generated by CodeSynthesis XSD, an XML Schema to\n" + "// C++ data binding compiler.\n" + "//\n" + "// This program is free software; you can redistribute it and/or modify\n" + "// it under the terms of the GNU General Public License version 2 as\n" + "// published by the Free Software Foundation.\n" + "//\n" + "// This program is distributed in the hope that it will be useful,\n" + "// but WITHOUT ANY WARRANTY; without even the implied warranty of\n" + "// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n" + "// GNU General Public License for more details.\n" + "//\n" + "// You should have received a copy of the GNU General Public License\n" + "// along with this program; if not, write to the Free Software\n" + "// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA\n" + "//\n" + "// In addition, as a special exception, Code Synthesis gives permission\n" + "// to link this program with the Xerces-C++ library (or with modified\n" + "// versions of Xerces-C++ that use the same license as Xerces-C++), and\n" + "// distribute linked combinations including the two. You must obey the GNU\n" + "// General Public License version 2 in all respects for all of the code\n" + "// used other than Xerces-C++. If you modify this copy of the program, you\n" + "// may extend this exception to your version of the program, but you are\n" + "// not obligated to do so. If you do not wish to do so, delete this\n" + "// exception statement from your version.\n" + "//\n" + "// Furthermore, Code Synthesis makes a special exception for the Free/Libre\n" + "// and Open Source Software (FLOSS) which is described in the accompanying\n" + "// FLOSSE file.\n" + "//\n\n"; + + char const copyright_proprietary[] = + "// Copyright (c) " XSD_COPYRIGHT ".\n" + "//\n" + "// This program was generated by CodeSynthesis XSD, an XML Schema\n" + "// to C++ data binding compiler, in the Proprietary License mode.\n" + "// You should have received a proprietary license from Code Synthesis\n" + "// prior to generating this code. See the license text for conditions.\n" + "//\n\n"; + + char const copyright_impl[] = + "// Not copyrighted - public domain.\n" + "//\n" + "// This sample parser implementation was generated by CodeSynthesis XSD,\n" + "// an XML Schema to C++ data binding compiler. You may use it in your\n" + "// programs without any restrictions.\n" + "//\n\n"; + } + + void Parser::Generator:: + usage () + { + CXX::Parser::options::print_usage (wcout); + CXX::options::print_usage (wcout); + } + + namespace + { + template + void + open (S& ifs, NarrowString const& path) + { + try + { + Path fs_path (path); + ifs.open (fs_path.string ().c_str (), + std::ios_base::in | std::ios_base::binary); + + if (!ifs.is_open ()) + { + wcerr << path.c_str () << ": error: unable to open in read mode" + << endl; + + throw Parser::Generator::Failed (); + } + } + catch (InvalidPath const&) + { + wcerr << "error: '" << path.c_str () << "' is not a valid " + << "filesystem path" << endl; + + throw Parser::Generator::Failed (); + } + } + + void + append (WideOutputFileStream& os, + NarrowString const& path, + WideInputFileStream& default_is) + { + using std::ios_base; + + if (path) + { + WideInputFileStream is; + open (is, path); + os << is.rdbuf (); + } + else if (default_is.is_open ()) + { + os << default_is.rdbuf (); + default_is.seekg (0, ios_base::beg); + } + } + + void + append (WideOutputFileStream& os, + NarrowStrings const& primary, + NarrowStrings const& def) + { + NarrowStrings const& v (primary.empty () ? def : primary); + + for (NarrowStrings::const_iterator i (v.begin ()), e (v.end ()); + i != e; ++i) + { + os << i->c_str () << endl; + } + } + } + + + size_t Parser::Generator:: + generate (Parser::options const& ops, + Schema& schema, + Path const& file_path, + bool fpt, + StringLiteralMap const& string_literal_map, + bool gen_driver, + const WarningSet& disabled_warnings, + FileList& file_list, + AutoUnlinks& unlinks) + { + using std::ios_base; + + typedef cutl::re::regexsub Regex; + + try + { + bool generate_xml_schema (ops.generate_xml_schema ()); + + // We could be compiling several schemas at once in which case + // handling of the --generate-xml-schema option gets tricky: we + // will need to rely on the presence of the --extern-xml-schema + // to tell us which (fake) schema file corresponds to XML Schema. + // + if (generate_xml_schema) + { + if (NarrowString name = ops.extern_xml_schema ()) + { + if (file_path.string () != name) + generate_xml_schema = false; + } + } + + bool impl (!generate_xml_schema && + (ops.generate_noop_impl () || + ops.generate_print_impl ())); + + bool driver (gen_driver && !generate_xml_schema && + ops.generate_test_driver ()); + + // Evaluate the graph for possibility of generating something useful. + // + { + Validator validator; + if (!validator.validate ( + ops, schema, file_path, driver, disabled_warnings)) + throw Failed (); + } + + bool gen_cxx (!ops.file_list_only ()); + + // Process names. + // + if (gen_cxx) + { + NameProcessor proc; + proc.process (ops, schema, file_path, string_literal_map); + } + + bool validation ((ops.xml_parser () == "expat" || + ops.generate_validation ()) && + !ops.suppress_validation ()); + + // Compute state machine info. + // + if (gen_cxx && validation) + { + StateProcessor proc; + proc.process (schema, file_path); + } + + // Read-in type maps. + // + TypeMap::Namespaces type_map; + if (gen_cxx) + { + using namespace TypeMap; + + NarrowStrings const& files (ops.type_map ()); + + for (NarrowStrings::const_iterator f (files.begin ()); + f != files.end (); ++f ) + { + NarrowInputFileStream ifs; + open (ifs, *f); + + Lexer l (ifs, *f); + TypeMap::Parser p (l, *f); + + if (!p.parse (type_map)) + throw Failed (); + } + + // Add the built-in mappings at the end. + // + + // String-based types. + // + String char_type (ops.char_type ()); + String string_type; + + if (char_type == L"char") + string_type = L"::std::string"; + else if (char_type == L"wchar_t") + string_type = L"::std::wstring"; + else + string_type = L"::std::basic_string< " + char_type + L" >"; + + String xns; + String auto_ptr; + { + Context ctx (std::wcerr, schema, file_path, ops, 0, 0, 0, 0); + xns = ctx.xs_ns_name (); + auto_ptr = ctx.auto_ptr; + } + + String buffer (auto_ptr + L"< " + xns + L"::buffer >"); + TypeMap::Namespace xsd ("http://www\\.w3\\.org/2001/XMLSchema"); + + xsd.types_push_back ("string", string_type); + xsd.types_push_back ("normalizedString", string_type); + xsd.types_push_back ("token", string_type); + xsd.types_push_back ("Name", string_type); + xsd.types_push_back ("NMTOKEN", string_type); + xsd.types_push_back ("NMTOKENS", xns + L"::string_sequence"); + xsd.types_push_back ("NCName", string_type); + + xsd.types_push_back ("ID", string_type); + xsd.types_push_back ("IDREF", string_type); + xsd.types_push_back ("IDREFS", xns + L"::string_sequence"); + + xsd.types_push_back ("language", string_type); + xsd.types_push_back ("anyURI", string_type); + xsd.types_push_back ("QName", xns + L"::qname"); + + xsd.types_push_back ("base64Binary", buffer, buffer); + xsd.types_push_back ("hexBinary", buffer, buffer); + + xsd.types_push_back ("gDay", xns + L"::gday"); + xsd.types_push_back ("gMonth", xns + L"::gmonth"); + xsd.types_push_back ("gYear", xns + L"::gyear"); + xsd.types_push_back ("gMonthDay", xns + L"::gmonth_day"); + xsd.types_push_back ("gYearMonth", xns + L"::gyear_month"); + xsd.types_push_back ("date", xns + L"::date"); + xsd.types_push_back ("time", xns + L"::time"); + xsd.types_push_back ("dateTime", xns + L"::date_time"); + xsd.types_push_back ("duration", xns + L"::duration"); + + // Fundamental C++ types. + // + xsd.types_push_back ("boolean", "bool", "bool"); + + xsd.types_push_back ("byte", "signed char", "signed char"); + xsd.types_push_back ("unsignedByte", + "unsigned char", + "unsigned char"); + + xsd.types_push_back ("short", "short", "short"); + xsd.types_push_back ("unsignedShort", + "unsigned short", + "unsigned short"); + + xsd.types_push_back ("int", "int", "int"); + xsd.types_push_back ("unsignedInt", "unsigned int", "unsigned int"); + + xsd.types_push_back ("long", "long long", "long long"); + xsd.types_push_back ("unsignedLong", + "unsigned long long", + "unsigned long long"); + + xsd.types_push_back ("integer", "long long", "long long"); + + xsd.types_push_back ("negativeInteger", "long long", "long long"); + xsd.types_push_back ("nonPositiveInteger", "long long", "long long"); + + xsd.types_push_back ("positiveInteger", + "unsigned long long", + "unsigned long long"); + xsd.types_push_back ("nonNegativeInteger", + "unsigned long long", + "unsigned long long"); + + xsd.types_push_back ("float", "float", "float"); + xsd.types_push_back ("double", "double", "double"); + xsd.types_push_back ("decimal", "double", "double"); + + type_map.push_back (xsd); + + // Everything else maps to void. + // + TypeMap::Namespace rest (".*"); + rest.types_push_back (".*", "void", "void"); + type_map.push_back (rest); + } + + // Process types. + // + if (gen_cxx) + { + TypeProcessor proc; + proc.process (ops, schema, gen_driver, type_map); + } + + // + // + bool inline_ (ops.generate_inline () && !generate_xml_schema); + bool source (!generate_xml_schema); + + // Generate code. + // + NarrowString name (file_path.leaf ().string ()); + NarrowString skel_suffix (ops.skel_file_suffix ()); + NarrowString impl_suffix (ops.impl_file_suffix ()); + + NarrowString hxx_suffix (ops.hxx_suffix ()); + NarrowString ixx_suffix (ops.ixx_suffix ()); + NarrowString cxx_suffix (ops.cxx_suffix ()); + + Regex hxx_expr ( + ops.hxx_regex ().empty () + ? "#^(.+?)(\\.[^./\\\\]+)?$#$1" + skel_suffix + hxx_suffix + "#" + : ops.hxx_regex ()); + + Regex ixx_expr ( + ops.ixx_regex ().empty () + ? "#^(.+?)(\\.[^./\\\\]+)?$#$1" + skel_suffix + ixx_suffix + "#" + : ops.ixx_regex ()); + + Regex cxx_expr ( + ops.cxx_regex ().empty () + ? "#^(.+?)(\\.[^./\\\\]+)?$#$1" + skel_suffix + cxx_suffix + "#" + : ops.cxx_regex ()); + + + Regex hxx_impl_expr; + Regex cxx_impl_expr; + Regex cxx_driver_expr; + + if (impl || driver) + { + hxx_impl_expr = + "#^(.+?)(\\.[^./\\\\]+)?$#$1" + impl_suffix + hxx_suffix + "#"; + + cxx_impl_expr = + "#^(.+?)(\\.[^./\\\\]+)?$#$1" + impl_suffix + cxx_suffix + "#"; + + cxx_driver_expr = + "#^(.+?)(\\.[^./\\\\]+)?$#$1-driver" + cxx_suffix + "#"; + } + + if (!hxx_expr.match (name)) + { + wcerr << "error: header expression '" << + hxx_expr.regex ().str ().c_str () << "' does not match '" << + name.c_str () << "'" << endl; + throw Failed (); + } + + if (inline_ && !ixx_expr.match (name)) + { + wcerr << "error: inline expression '" << + ixx_expr.regex ().str ().c_str () << "' does not match '" << + name.c_str () << "'" << endl; + throw Failed (); + } + + if (source && !cxx_expr.match (name)) + { + wcerr << "error: source expression '" << + cxx_expr.regex ().str ().c_str () << "' does not match '" << + name.c_str () << "'" << endl; + throw Failed (); + } + + if (impl || driver) + { + if (!hxx_impl_expr.match (name)) + { + wcerr << "error: implementation header expression '" << + hxx_impl_expr.regex ().str ().c_str () << "' does not match '" << + name.c_str () << "'" << endl; + throw Failed (); + } + + if (!cxx_impl_expr.match (name)) + { + wcerr << "error: implementation source expression '" << + cxx_impl_expr.regex ().str ().c_str () << "' does not match '" << + name.c_str () << "'" << endl; + throw Failed (); + } + + if (!cxx_driver_expr.match (name)) + { + wcerr << "error: driver source expression '" << + cxx_driver_expr.regex ().str ().c_str () << "' does not match '" << + name.c_str () << "'" << endl; + throw Failed (); + } + } + + NarrowString hxx_name (hxx_expr.replace (name)); + NarrowString ixx_name (inline_ ? ixx_expr.replace (name) : NarrowString ()); + NarrowString cxx_name (source ? cxx_expr.replace (name) : NarrowString ()); + + NarrowString hxx_impl_name; + NarrowString cxx_impl_name; + NarrowString cxx_driver_name; + + if (impl || driver) + { + hxx_impl_name = hxx_impl_expr.replace (name); + cxx_impl_name = cxx_impl_expr.replace (name); + cxx_driver_name = cxx_driver_expr.replace (name); + } + + Path hxx_path (hxx_name); + Path ixx_path (ixx_name); + Path cxx_path (cxx_name); + + Path hxx_impl_path; + Path cxx_impl_path; + Path cxx_driver_path; + + if (impl || driver) + { + hxx_impl_path = Path (hxx_impl_name); + cxx_impl_path = Path (cxx_impl_name); + cxx_driver_path = Path (cxx_driver_name); + } + + Path out_dir; + + if (NarrowString dir = ops.output_dir ()) + { + try + { + out_dir = Path (dir); + } + catch (InvalidPath const&) + { + wcerr << dir.c_str () << ": error: invalid path" << endl; + throw Failed (); + } + } + + if (fpt && !generate_xml_schema) + { + // In the file-per-type mode the schema files are always local + // unless the user added the directory so that we propagate this + // to the output files. + // + Path fpt_dir (file_path.directory ()); + + if (!fpt_dir.empty ()) + out_dir /= fpt_dir; + } + + if (!out_dir.empty ()) + { + hxx_path = out_dir / hxx_path; + ixx_path = out_dir / ixx_path; + cxx_path = out_dir / cxx_path; + + if (impl || driver) + { + hxx_impl_path = out_dir / hxx_impl_path; + cxx_impl_path = out_dir / cxx_impl_path; + cxx_driver_path = out_dir /cxx_driver_path; + } + } + + // Open the impl files first so that if open fails, the skel files + // are not deleted. + // + WideOutputFileStream hxx_impl; + WideOutputFileStream cxx_impl; + WideOutputFileStream cxx_driver; + + if (impl) + { + if (gen_cxx) + { + if (!ops.force_overwrite ()) + { + WideInputFileStream tmp ( + hxx_impl_path.string ().c_str (), ios_base::in); + + if (tmp.is_open ()) + { + wcerr << hxx_impl_path << ": error: cowardly refusing to " << + "overwrite an existing file" << endl; + throw Failed (); + } + + tmp.close (); + } + + hxx_impl.open (hxx_impl_path.string ().c_str (), ios_base::out); + + if (!hxx_impl.is_open ()) + { + wcerr << hxx_impl_path << ": error: unable to open in write mode" + << endl; + throw Failed (); + } + + unlinks.add (hxx_impl_path); + } + + file_list.push_back (hxx_impl_path.string ()); + + if (gen_cxx) + { + if (!ops.force_overwrite ()) + { + WideInputFileStream tmp ( + cxx_impl_path.string ().c_str (), ios_base::in); + + if (tmp.is_open ()) + { + wcerr << cxx_impl_path << ": error: cowardly refusing to " << + "overwrite an existing file" << endl; + throw Failed (); + } + + tmp.close (); + } + + cxx_impl.open (cxx_impl_path.string ().c_str (), ios_base::out); + + if (!cxx_impl.is_open ()) + { + wcerr << cxx_impl_path << ": error: unable to open in write mode" + << endl; + throw Failed (); + } + + unlinks.add (cxx_impl_path); + } + + file_list.push_back (cxx_impl_path.string ()); + } + + if (driver) + { + if (gen_cxx) + { + if (!ops.force_overwrite ()) + { + WideInputFileStream tmp ( + cxx_driver_path.string ().c_str (), ios_base::in); + + if (tmp.is_open ()) + { + wcerr << cxx_driver_path << ": error: cowardly refusing to " << + "overwrite an existing file" << endl; + throw Failed (); + } + + tmp.close (); + } + + cxx_driver.open (cxx_driver_path.string ().c_str (), ios_base::out); + + if (!cxx_driver.is_open ()) + { + wcerr << cxx_driver_path << ": error: unable to open in write " << + "mode" << endl; + throw Failed (); + } + + unlinks.add (cxx_driver_path); + } + + file_list.push_back (cxx_driver_path.string ()); + } + + // Open the skel files. + // + WideOutputFileStream hxx; + WideOutputFileStream ixx; + WideOutputFileStream cxx; + + if (gen_cxx) + { + hxx.open (hxx_path.string ().c_str (), ios_base::out); + + if (!hxx.is_open ()) + { + wcerr << hxx_path << ": error: unable to open in write mode" << endl; + throw Failed (); + } + + unlinks.add (hxx_path); + } + + file_list.push_back (hxx_path.string ()); + + if (inline_) + { + if (gen_cxx) + { + ixx.open (ixx_path.string ().c_str (), ios_base::out); + + if (!ixx.is_open ()) + { + wcerr << ixx_path << ": error: unable to open in write mode" + << endl; + throw Failed (); + } + + unlinks.add (ixx_path); + } + + file_list.push_back (ixx_path.string ()); + } + + if (source) + { + if (gen_cxx) + { + cxx.open (cxx_path.string ().c_str (), ios_base::out); + + if (!cxx.is_open ()) + { + wcerr << cxx_path << ": error: unable to open in write mode" + << endl; + throw Failed (); + } + + unlinks.add (cxx_path); + } + + file_list.push_back (cxx_path.string ()); + } + + if (!gen_cxx) + return 0; + + // Print copyright and license. + // + char const* copyright ( + ops.proprietary_license () ? copyright_proprietary : copyright_gpl); + + hxx << copyright; + + if (inline_) + ixx << copyright; + + if (source) + cxx << copyright; + + if (impl) + { + hxx_impl << copyright_impl; + cxx_impl << copyright_impl; + } + + if (driver) + cxx_driver << copyright_impl; + + // Prologue. + // + WideInputFileStream prologue; + { + NarrowString name (ops.prologue_file ()); + + if (name) + open (prologue, name); + } + + // Epilogue. + // + WideInputFileStream epilogue; + { + NarrowString name (ops.epilogue_file ()); + + if (name) + open (epilogue, name); + } + + // SLOC counter. + // + size_t sloc_total (0); + bool show_sloc (ops.show_sloc ()); + + typedef + compiler::ostream_filter + ind_filter; + + typedef + compiler::ostream_filter + sloc_filter; + + // + // + Regex guard_expr ("/([a-z])([A-Z])/$1_$2/"); // Split words. + + NarrowString guard_prefix (ops.guard_prefix ()); + + if (!guard_prefix) + guard_prefix = file_path.directory ().string (); + + if (guard_prefix) + guard_prefix += '_'; + + // HXX + // + { + Context ctx (hxx, + schema, + file_path, + ops, + &string_literal_map, + &hxx_expr, + &ixx_expr, + &hxx_impl_expr); + + sloc_filter sloc (hxx); + + String guard (guard_expr.replace (guard_prefix + hxx_name)); + guard = ctx.escape (guard); // Make it a C++ id. + std::transform (guard.begin (), guard.end(), guard.begin (), upcase); + + hxx << "#ifndef " << guard << endl + << "#define " << guard << endl + << endl; + + if (ctx.std >= cxx_version::cxx11) + { + hxx << "#ifndef XSD_CXX11" << endl + << "#define XSD_CXX11" << endl + << "#endif" << endl + << endl; + } + + // Copy prologue. + // + hxx << "// Begin prologue." << endl + << "//" << endl; + + append (hxx, ops.hxx_prologue (), ops.prologue ()); + append (hxx, ops.hxx_prologue_file (), prologue); + + hxx << "//" << endl + << "// End prologue." << endl + << endl; + + // Version check. + // + hxx << "#include " << endl + << endl + << "#if (LIBXSD_VERSION != " << XSD_VERSION << "L)" << endl + << "#error XSD runtime version mismatch" << endl + << "#endif" << endl + << endl; + + hxx << "#include " << endl + << endl; + + // Generate. + // + { + ind_filter ind (hxx); // We don't want to indent prologues/epilogues. + + if (!generate_xml_schema) + generate_parser_forward (ctx); + + generate_parser_header (ctx, generate_xml_schema); + } + + if (inline_) + hxx << "#include " << ctx.process_include_path (ixx_name) << endl; + + hxx << "#include " << endl + << endl; + + // Copy epilogue. + // + hxx << "// Begin epilogue." << endl + << "//" << endl; + + append (hxx, ops.hxx_epilogue_file (), epilogue); + append (hxx, ops.hxx_epilogue (), ops.epilogue ()); + + hxx << "//" << endl + << "// End epilogue." << endl + << endl; + + hxx << "#endif // " << guard << endl; + + if (show_sloc) + wcerr << hxx_path << ": " << sloc.stream ().count () << endl; + + sloc_total += sloc.stream ().count (); + } + + + // IXX + // + if (inline_) + { + Context ctx (ixx, + schema, + file_path, + ops, + &string_literal_map, + &hxx_expr, + &ixx_expr, + &hxx_impl_expr); + + sloc_filter sloc (ixx); + + // Copy prologue. + // + ixx << "// Begin prologue." << endl + << "//" << endl; + + append (ixx, ops.ixx_prologue (), ops.prologue ()); + append (ixx, ops.ixx_prologue_file (), prologue); + + ixx << "//" << endl + << "// End prologue." << endl + << endl; + + // Generate. + // + { + ind_filter ind (ixx); // We don't want to indent prologues/epilogues. + generate_parser_inline (ctx); + } + + // Copy epilogue. + // + ixx << "// Begin epilogue." << endl + << "//" << endl; + + append (ixx, ops.ixx_epilogue_file (), epilogue); + append (ixx, ops.ixx_epilogue (), ops.epilogue ()); + + ixx << "//" << endl + << "// End epilogue." << endl + << endl; + + if (show_sloc) + wcerr << ixx_path << ": " << sloc.stream ().count () << endl; + + sloc_total += sloc.stream ().count (); + } + + + // CXX + // + if (source) + { + Context ctx (cxx, + schema, + file_path, + ops, + &string_literal_map, + &hxx_expr, + &ixx_expr, + &hxx_impl_expr); + + sloc_filter sloc (cxx); + + // Copy prologue. + // + cxx << "// Begin prologue." << endl + << "//" << endl; + + append (cxx, ops.cxx_prologue (), ops.prologue ()); + append (cxx, ops.cxx_prologue_file (), prologue); + + cxx << "//" << endl + << "// End prologue." << endl + << endl; + + cxx << "#include " << endl + << endl; + + cxx << "#include " << ctx.process_include_path (hxx_name) << endl + << endl; + + // Generate. + // + { + ind_filter ind (cxx); // We don't want to indent prologues/epilogues. + + if (!inline_) + generate_parser_inline (ctx); + + generate_parser_source (ctx); + + if (validation) + { + generate_element_validation_source (ctx); + generate_attribute_validation_source (ctx); + generate_characters_validation_source (ctx); + } + } + + cxx << "#include " << endl + << endl; + + // Copy epilogue. + // + cxx << "// Begin epilogue." << endl + << "//" << endl; + + append (cxx, ops.cxx_epilogue_file (), epilogue); + append (cxx, ops.cxx_epilogue (), ops.epilogue ()); + + cxx << "//" << endl + << "// End epilogue." << endl + << endl; + + if (show_sloc) + wcerr << cxx_path << ": " << sloc.stream ().count () << endl; + + sloc_total += sloc.stream ().count (); + } + + // HXX impl + // + if (impl) + { + Context ctx (hxx_impl, + schema, + file_path, + ops, + &string_literal_map, + &hxx_expr, + &ixx_expr, + &hxx_impl_expr); + + String guard (guard_expr.replace (guard_prefix + hxx_impl_name)); + guard = ctx.escape (guard); // Make it a C++ id. + std::transform (guard.begin (), guard.end(), guard.begin (), upcase); + + hxx_impl << "#ifndef " << guard << endl + << "#define " << guard << endl + << endl; + + hxx_impl << "#include " << ctx.process_include_path (hxx_name) + << endl << endl; + + { + ind_filter ind (hxx_impl); + generate_impl_header (ctx); + } + + hxx_impl << "#endif // " << guard << endl; + } + + // CXX impl + // + if (impl) + { + Context ctx (cxx_impl, + schema, + file_path, + ops, + &string_literal_map, + &hxx_expr, + &ixx_expr, + &hxx_impl_expr); + + cxx_impl << "#include " << ctx.process_include_path (hxx_impl_name) + << endl << endl; + + { + ind_filter ind (cxx_impl); + generate_impl_source (ctx); + } + } + + // CXX driver + // + if (driver) + { + Context ctx (cxx_driver, + schema, + file_path, + ops, + &string_literal_map, + &hxx_expr, + &ixx_expr, + &hxx_impl_expr); + + cxx_driver << "#include " << ctx.process_include_path (hxx_impl_name) + << endl << endl; + + { + ind_filter ind (cxx_driver); + generate_driver_source (ctx); + } + } + + return sloc_total; + } + catch (UnrepresentableCharacter const& e) + { + wcerr << "error: character at position " << e.position () << " " + << "in string '" << e.string () << "' is unrepresentable in " + << "the target encoding" << endl; + + wcerr << "info: use the --custom-literals option to provide custom " + << "string literals mapping" << endl; + + throw Failed (); + } + catch (NoNamespaceMapping const& e) + { + wcerr << e.file () << ":" << e.line () << ":" << e.column () + << ": error: unable to map XML Schema namespace '" << e.ns () + << "' to C++ namespace" << endl; + + wcerr << e.file () << ":" << e.line () << ":" << e.column () + << ": info: use the --namespace-map or --namespace-regex option " + << "to provide custom mapping" << endl; + + throw Failed (); + } + catch (InvalidNamespaceMapping const& e) + { + wcerr << "error: invalid XML to C++ namespace mapping specified: " + << "'" << e.mapping () << "': " << e.reason () << endl; + + throw Failed (); + } + catch (cutl::re::format const& e) + { + wcerr << "error: invalid regex: '" << + e.regex ().c_str () << "': " << + e.description ().c_str () << endl; + + throw Failed (); + } + catch (cutl::re::wformat const& e) + { + wcerr << "error: invalid regex: '" << + e.regex () << "': " << e.description ().c_str () << endl; + + throw Failed (); + } + } +} diff --git a/xsd/cxx/parser/generator.hxx b/xsd/cxx/parser/generator.hxx new file mode 100644 index 0000000..150cd74 --- /dev/null +++ b/xsd/cxx/parser/generator.hxx @@ -0,0 +1,45 @@ +// file : xsd/cxx/parser/generator.hxx +// license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +#ifndef XSD_CXX_PARSER_GENERATOR_HXX +#define XSD_CXX_PARSER_GENERATOR_HXX + +#include // Path +#include + +#include +#include + +#include +#include + +namespace CXX +{ + namespace Parser + { + class Generator + { + public: + static void + usage (); + + struct Failed {}; + + static size_t + generate (options const&, + XSDFrontend::SemanticGraph::Schema&, + XSDFrontend::SemanticGraph::Path const& file, + bool file_per_type, + StringLiteralMap const&, + bool gen_driver, + const WarningSet& disabled_warnings, + FileList& file_list, + AutoUnlinks& unlinks); + + private: + Generator (); + }; + } +} + +#endif // XSD_CXX_PARSER_GENERATOR_HXX diff --git a/xsd/cxx/parser/impl-header.cxx b/xsd/cxx/parser/impl-header.cxx new file mode 100644 index 0000000..be14dfa --- /dev/null +++ b/xsd/cxx/parser/impl-header.cxx @@ -0,0 +1,232 @@ +// file : xsd/cxx/parser/impl-header.cxx +// license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +#include + +#include +#include + +namespace CXX +{ + namespace Parser + { + namespace + { + struct Enumeration: Traversal::Enumeration, Context + { + Enumeration (Context& c) + : Context (c) + { + } + + virtual void + traverse (Type& e) + { + String const& name (eimpl (e)); + String const& ret (ret_type (e)); + SemanticGraph::Type& base (e.inherits ().base ()); + + os << "class " << type_exp << name << ": " << + "public virtual " << ename (e) << "," << endl + << " public " << fq_name (base, "impl") + << "{" + << "public:" << endl + << "virtual void" << endl + << "pre ();" + << endl + << "virtual " << ret << endl + << post_name (e) << " ();" + << "};"; + } + }; + + // + // + struct List: Traversal::List, Context + { + List (Context& c) + : Context (c) + { + } + + virtual void + traverse (Type& l) + { + String const& name (eimpl (l)); + SemanticGraph::Type& t (l.argumented ().type ()); + + String item (unclash (ename (l), "item")); + + os << "class " << type_exp << name << ": public virtual " << + ename (l) + << "{" + << "public:" << endl + << "virtual void" << endl + << "pre ();" + << endl; + + // item + // + String const& arg (arg_type (t)); + + os << "virtual void" << endl + << item; + + if (arg == L"void") + os << " ();"; + else + os << " (" << arg << ");"; + + os << endl; + + // post + // + String const& ret (ret_type (l)); + + os << "virtual " << ret << endl + << post_name (l) << " ();" + << "};"; + } + }; + + struct Union: Traversal::Union, Context + { + Union (Context& c) + : Context (c) + { + } + + virtual void + traverse (Type& u) + { + String const& name (eimpl (u)); + String const& ret (ret_type (u)); + + os << "class " << type_exp << name << ": public virtual " << + ename (u) + << "{" + << "public:" << endl + << "virtual void" << endl + << "pre ();" + << endl + << "virtual void" << endl + << "_characters (const " << string_type << "&);" + << endl + << "virtual " << ret << endl + << post_name (u) << " ();" + << "};"; + } + }; + + + // + // + struct ParserCallback: Traversal::Member, Context + { + ParserCallback (Context& c) + : Context (c) + { + } + + virtual void + traverse (Type& m) + { + if (skip (m)) + return; + + String const& arg (arg_type (m.type ())); + + os << "virtual void" << endl + << ename (m); + + if (arg == L"void") + os << " ();"; + else + os << " (" << arg << ");"; + + os << endl; + } + }; + + // + // + struct Complex: Traversal::Complex, Context + { + Complex (Context& c) + : Context (c), + parser_callback_ (c) + { + names_parser_callback_ >> parser_callback_; + } + + virtual void + traverse (Type& c) + { + String const& name (eimpl (c)); + String const& ret (ret_type (c)); + + os << "class " << type_exp << name << ": public virtual " << + ename (c); + + if (c.inherits_p ()) + os << "," << endl + << " public " << fq_name (c.inherits ().base (), "impl"); + + os << "{" + << "public:" << endl + << "virtual void" << endl + << "pre ();" + << endl; + + // In case of an inheritance-by-restriction, we don't need to + // generate parser callbacks, etc. since they are the same as in + // the base. + // + if (!restriction_p (c)) + { + names (c, names_parser_callback_); + } + + os << "virtual " << ret << endl + << post_name (c) << " ();" + << "};"; + } + + private: + // + // + ParserCallback parser_callback_; + Traversal::Names names_parser_callback_; + }; + } + + void + generate_impl_header (Context& ctx) + { + Traversal::Schema schema; + + Sources sources; + Includes includes (ctx, Includes::impl_header); + Traversal::Names schema_names; + + Namespace ns (ctx); + Traversal::Names names; + + schema >> includes; + schema >> sources >> schema; + schema >> schema_names >> ns >> names; + + List list (ctx); + Union union_ (ctx); + Complex complex (ctx); + Enumeration enumeration (ctx); + + names >> list; + names >> union_; + names >> complex; + names >> enumeration; + + schema.dispatch (ctx.schema_root); + } + } +} diff --git a/xsd/cxx/parser/impl-header.hxx b/xsd/cxx/parser/impl-header.hxx new file mode 100644 index 0000000..1939e05 --- /dev/null +++ b/xsd/cxx/parser/impl-header.hxx @@ -0,0 +1,18 @@ +// file : xsd/cxx/parser/impl-header.hxx +// license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +#ifndef XSD_CXX_PARSER_IMPL_HEADER_HXX +#define XSD_CXX_PARSER_IMPL_HEADER_HXX + +#include + +namespace CXX +{ + namespace Parser + { + void + generate_impl_header (Context&); + } +} + +#endif // XSD_CXX_PARSER_IMPL_HEADER_HXX diff --git a/xsd/cxx/parser/impl-source.cxx b/xsd/cxx/parser/impl-source.cxx new file mode 100644 index 0000000..80a9644 --- /dev/null +++ b/xsd/cxx/parser/impl-source.cxx @@ -0,0 +1,384 @@ +// file : xsd/cxx/parser/impl-source.cxx +// license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +#include +#include + +#include +#include + +namespace CXX +{ + namespace Parser + { + namespace + { + struct Enumeration: Traversal::Enumeration, Context + { + Enumeration (Context& c) + : Context (c) + { + } + + virtual void + traverse (Type& e) + { + String const& name (eimpl (e)); + String const& ret (ret_type (e)); + SemanticGraph::Type& base (e.inherits ().base ()); + String const& base_ret (ret_type (base)); + + os << "// " << name << endl + << "//" << endl + << endl; + + // pre + // + os << "void " << name << "::" << endl + << "pre ()" + << "{" + << "}"; + + // post + // + os << ret << " " << name << "::" << endl + << post_name (e) << " ()" + << "{"; + + if (ret == base_ret) + { + os << (ret != L"void" ? "return " : "") << + post_name (base) << " ();"; + } + else if (ret == L"void") + { + os << arg_type (base) << " v (" << post_name (base) << " ());" + << endl; + + if (options.generate_print_impl ()) + { + PrintCall t (*this, e.name (), "v"); + t.dispatch (base); + } + else + os << "// TODO" << endl + << "//" << endl; + } + else + { + if (base_ret == L"void") + os << post_name (base) << " ();"; + else + os << arg_type (base) << " v (" << post_name (base) << " ());" + << endl + << "// TODO" << endl + << "//" << endl + << "// return ... ;" << endl; + } + + os << "}"; + } + }; + + // + // + struct List: Traversal::List, Context + { + List (Context& c) + : Context (c) + { + } + + virtual void + traverse (Type& l) + { + String const& name (eimpl (l)); + SemanticGraph::Type& type (l.argumented ().type ()); + + String item (unclash (ename (l), "item")); + + os << "// " << name << endl + << "//" << endl + << endl; + + // pre + // + os << "void " << name << "::" << endl + << "pre ()" + << "{" + << "}"; + + // item + // + String const& arg (arg_type (type)); + + os << "void " << name << "::" << endl + << item; + + if (arg == L"void") + os << " ()"; + else + os << " (" << arg << " " << item << ")"; + + os << "{"; + + if (arg != L"void") + { + if (options.generate_print_impl ()) + { + PrintCall t (*this, type.name (), item); + t.dispatch (type); + } + else + os << "// TODO" << endl + << "//" << endl; + } + + os << "}"; + + // post + // + String const& ret (ret_type (l)); + + os << ret << " " << name << "::" << endl + << post_name (l) << " ()" + << "{"; + + if (ret != L"void") + os << "// TODO" << endl + << "//" << endl + << "// return ... ;" << endl; + + os << "}"; + } + }; + + // + // + struct Union: Traversal::Union, Context + { + Union (Context& c) + : Context (c) + { + } + + virtual void + traverse (Type& u) + { + String const& name (eimpl (u)); + + os << "// " << name << endl + << "//" << endl + << endl; + + // pre + // + os << "void " << name << "::" << endl + << "pre ()" + << "{" + << "}"; + + // _characters + // + os << "void " << name << "::" << endl + << "_characters (const " << string_type << "& s)" + << "{"; + + if (options.generate_print_impl ()) + os << cout_inst << " << " << strlit (u.name () + L": ") << + " << s << std::endl;"; + else + os << "// TODO" << endl + << "//" << endl; + + os << "}"; + + // post + // + String const& ret (ret_type (u)); + + os << ret << " " << name << "::" << endl + << post_name (u) << " ()" + << "{"; + + if (ret != L"void") + os << "// TODO" << endl + << "//" << endl + << "// return ... ;" << endl; + + os << "}"; + } + }; + + // + // + struct ParserCallback: Traversal::Member, Context + { + ParserCallback (Context& c) + : Context (c) + { + } + + virtual void + traverse (Type& m) + { + if (skip (m)) + return; + + String const& name (ename (m)); + String const& arg (arg_type (m.type ())); + + os << "void " << + eimpl (dynamic_cast (m.scope ())) << + "::" << endl + << name; + + if (arg == L"void") + os << " ()"; + else + os << " (" << arg << " " << name << ")"; + + os << "{"; + + if (arg != L"void") + { + if (options.generate_print_impl ()) + { + PrintCall t (*this, m.name (), name); + t.dispatch (m.type ()); + } + else + os << "// TODO" << endl + << "//" << endl; + } + + os << "}"; + } + }; + + // + // + struct Complex: Traversal::Complex, Context + { + Complex (Context& c) + : Context (c), parser_callback_ (c) + { + names_parser_callback_ >> parser_callback_; + } + + virtual void + traverse (Type& c) + { + String const& name (eimpl (c)); + + bool restriction (restriction_p (c)); + + os << "// " << name << endl + << "//" << endl + << endl; + + // pre + // + os << "void " << name << "::" << endl + << "pre ()" + << "{" + << "}"; + + // Parser callbacks. + // + if (!restriction) + names (c, names_parser_callback_); + + // post + // + String const& ret (ret_type (c)); + + os << ret << " " << name << "::" << endl + << post_name (c) << " ()" + << "{"; + + if (c.inherits_p ()) + { + SemanticGraph::Type& base (c.inherits ().base ()); + String const& base_ret (ret_type (base)); + + if (ret == base_ret) + { + os << (ret != L"void" ? "return " : "") << + post_name (base) << " ();"; + } + else if (ret == L"void") + { + os << arg_type (base) << " v (" << post_name (base) << " ());" + << endl; + + if (options.generate_print_impl ()) + { + PrintCall t (*this, c.name (), "v"); + t.dispatch (base); + } + else + os << "// TODO" << endl + << "//" << endl; + } + else + { + if (base_ret == L"void") + os << post_name (base) << " ();"; + else + os << arg_type (base) << " v (" << post_name (base) << " ());" + << endl + << "// TODO" << endl + << "//" << endl + << "// return ... ;" << endl; + } + } + else + { + if (ret != L"void") + os << "// TODO" << endl + << "//" << endl + << "// return ... ;" << endl; + } + + os << "}"; + } + + private: + // + // + ParserCallback parser_callback_; + Traversal::Names names_parser_callback_; + }; + } + + void + generate_impl_source (Context& ctx) + { + if (ctx.options.generate_print_impl ()) + ctx.os << "#include " << endl + << endl; + + Traversal::Schema schema; + Sources sources; + Traversal::Names schema_names; + Namespace ns (ctx); + Traversal::Names names; + + schema >> sources >> schema; + schema >> schema_names >> ns >> names; + + List list (ctx); + Union union_ (ctx); + Complex complex (ctx); + Enumeration enumeration (ctx); + + names >> list; + names >> union_; + names >> complex; + names >> enumeration; + + schema.dispatch (ctx.schema_root); + } + } +} diff --git a/xsd/cxx/parser/impl-source.hxx b/xsd/cxx/parser/impl-source.hxx new file mode 100644 index 0000000..0fc8060 --- /dev/null +++ b/xsd/cxx/parser/impl-source.hxx @@ -0,0 +1,18 @@ +// file : xsd/cxx/parser/impl-source.hxx +// license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +#ifndef XSD_CXX_PARSER_IMPL_SOURCE_HXX +#define XSD_CXX_PARSER_IMPL_SOURCE_HXX + +#include + +namespace CXX +{ + namespace Parser + { + void + generate_impl_source (Context&); + } +} + +#endif // XSD_CXX_PARSER_IMPL_SOURCE_HXX diff --git a/xsd/cxx/parser/name-processor.cxx b/xsd/cxx/parser/name-processor.cxx new file mode 100644 index 0000000..73710ba --- /dev/null +++ b/xsd/cxx/parser/name-processor.cxx @@ -0,0 +1,1175 @@ +// file : xsd/cxx/parser/name-processor.cxx +// license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +#include +#include +#include +#include + +#include + +#include +#include + + +using namespace std; + +namespace CXX +{ + namespace Parser + { + namespace + { + // + // + typedef set NameSet; + + class Context: public CXX::Context + { + public: + Context (Parser::options const& ops, + SemanticGraph::Schema& root, + SemanticGraph::Path const& path, + StringLiteralMap const* map) + : CXX::Context (std::wcerr, root, path, ops, map), + skel_suffix_ (ops.skel_type_suffix ()), + impl_suffix_ (ops.impl_type_suffix ()), + impl (ops.generate_noop_impl () || + ops.generate_print_impl () || + ops.generate_test_driver ()), + skel_suffix (skel_suffix_), + impl_suffix (impl_suffix_), + global_type_names (global_type_names_), + polymorphic (ops.generate_polymorphic ()) + { + } + + protected: + Context (Context& c) + : CXX::Context (c), + impl (c.impl), + skel_suffix (c.skel_suffix), + impl_suffix (c.impl_suffix), + global_type_names (c.global_type_names), + polymorphic (c.polymorphic) + { + } + + public: + String + find_name (String const& n, NameSet& set) + { + String base_name (escape (n)); + String name (base_name); + + for (size_t i (1); set.find (name) != set.end (); ++i) + { + std::wostringstream os; + os << i; + name = base_name + os.str (); + } + + set.insert (name); + return name; + } + + private: + String const skel_suffix_; + String const impl_suffix_; + + map global_type_names_; + + public: + bool const impl; + String const& skel_suffix; + String const& impl_suffix; + + map& global_type_names; + + bool polymorphic; + }; + + + // + // + struct PrimaryMember: Traversal::Member, Context + { + PrimaryMember (Context& c, NameSet& set) + : Context (c), set_ (set) + { + } + + virtual void + traverse (Type& m) + { + if (Parser::Context::skip (m)) + return; + + m.context ().set ("name", find_name (m.name (), set_)); + } + + private: + NameSet& set_; + }; + + struct DerivedMember: Traversal::Member, Context + { + DerivedMember (Context& c, NameSet& set) + : Context (c), set_ (set) + { + } + + virtual void + traverse (Type& m) + { + if (Parser::Context::skip (m)) + return; + + m.context ().set ("parser", + find_name (m.name () + L"_parser", set_)); + + String const& base (m.context ().get ("name")); + m.context ().set ("member", find_name (base + L"_parser_", set_)); + + if (polymorphic && + m.is_a () && + !m.type ().context ().count ("anonymous")) + { + m.context ().set ( + "member-map", find_name (base + L"_parser_map_", set_)); + + m.context ().set ( + "member-map-impl", + find_name (base + L"_parser_map_impl_", set_)); + } + } + + private: + NameSet& set_; + }; + + + // + // + struct MemberInRestrictionBase: Traversal::Member + { + protected: + MemberInRestrictionBase (NameSet& set, SemanticGraph::Complex& base) + : set_ (set), base_ (base) + { + } + + struct NotFound {}; + + Type& + find_member (SemanticGraph::Complex& c, Type& m) + { + using SemanticGraph::Complex; + + Complex::NamesIteratorPair r (c.find (m.name ())); + + for (; r.first != r.second; ++r.first) + { + if (r.first->named ().is_a ()) + { + Type& bm (dynamic_cast (r.first->named ())); + + if (typeid (bm) != typeid (m)) + continue; + + if (m.qualified_p ()) + { + if (bm.qualified_p () && + m.name () == bm.name () && + m.namespace_ ().name () == bm.namespace_ ().name ()) + return bm; + } + else + { + if (!bm.qualified_p () && m.name () == bm.name ()) + return bm; + } + } + } + + // If we didn't find anything, try our base. + // + if (c.inherits_p ()) + { + SemanticGraph::Type& base (c.inherits ().base ()); + + if (base.is_a ()) + return find_member (dynamic_cast (base), m); + } + + //std::wcerr << "unable to find member " << m.name () << " in " + // << c.name () << std::endl; + + throw NotFound (); + } + + protected: + NameSet& set_; + SemanticGraph::Complex& base_; + }; + + struct PrimaryMemberInRestriction: MemberInRestrictionBase, Context + { + PrimaryMemberInRestriction (Context& c, + NameSet& set, + SemanticGraph::Complex& base) + : MemberInRestrictionBase (set, base), Context (c) + { + } + + virtual void + traverse (Type& m) + { + if (Parser::Context::skip (m)) + return; + + String name; + + try + { + // Try to find corresponding member in one of our bases. + // This may fail if we use an element that substitutes + // one in our base. + // + Type& bm (find_member (base_, m)); + name = bm.context ().get ("name"); + } + catch (NotFound const&) + { + // Fall back to the standard name assignment. + // + name = find_name (m.name (), set_); + } + + m.context ().set ("name", name); + } + }; + + struct DerivedMemberInRestriction: MemberInRestrictionBase, Context + { + DerivedMemberInRestriction (Context& c, + NameSet& set, + SemanticGraph::Complex& base) + : MemberInRestrictionBase (set, base), Context (c) + { + } + + virtual void + traverse (Type& m) + { + if (Parser::Context::skip (m)) + return; + + bool poly (polymorphic && + m.is_a () && + !m.type ().context ().count ("anonymous")); + + String parser, member, member_map, member_map_impl; + + try + { + // Try to find corresponding member in one of our bases. + // This may fail if we use an element that substitutes + // one in our base. + // + Type& bm (find_member (base_, m)); + parser = bm.context ().get ("parser"); + member = bm.context ().get ("member"); + + if (poly) + { + member_map = bm.context ().get ("member-map"); + member_map_impl = bm.context ().get ("member-map-impl"); + } + } + catch (NotFound const&) + { + // Fall back to the standard name assignment. + // + String const& base (m.context ().get ("name")); + + parser = find_name (m.name () + L"_parser", set_); + member = find_name (base + L"_parser_", set_); + + if (poly) + { + member_map = find_name (base + L"_parser_map_", set_); + member_map_impl = find_name (base + L"_parser_map_impl_", set_); + } + } + + m.context ().set ("parser", parser); + m.context ().set ("member", member); + + if (poly) + { + m.context ().set ("member-map", member_map); + m.context ().set ("member-map-impl", member_map_impl); + } + } + }; + + // + // + struct Complex: Traversal::Complex, Context + { + Complex (Context& c) + : Context (c) + { + } + + virtual void + traverse (Type& c) + { + SemanticGraph::Context& cc (c.context ()); + + // Use processed name. + // + String const& name (cc.get ("name")); + + // We leave this set around to allow other mappings to use + // this information. + // + cc.set ("cxx-parser-name-processor-member-set", NameSet ()); + NameSet& member_set ( + cc.get ("cxx-parser-name-processor-member-set")); + + member_set.insert (name); + + // Add our base's members to the initial list unless we are + // inheriting by restriction in which case we need to have + // the same names as our base. + // + bool restriction (false); + + if (c.inherits_p ()) + { + // @@ What if this types name is the same as one of base's + // members? + // + SemanticGraph::Type& base (c.inherits ().base ()); + + if (base.is_a ()) + { + if (!base.context ().count ( + "cxx-parser-name-processor-member-set")) + { + dispatch (base); + } + + NameSet const& base_set ( + base.context ().get ( + "cxx-parser-name-processor-member-set")); + + member_set.insert (base_set.begin (), base_set.end ()); + + // Inheritance by restriction from anyType is a special case. + // + restriction = c.inherits ().is_a () && + !c.inherits ().base ().is_a (); + } + } + + if (restriction) + { + // First assign the "primary" names. + // + { + PrimaryMemberInRestriction member ( + *this, + member_set, + dynamic_cast ( + c.inherits ().base ())); + + Traversal::Names names (member); + + Complex::names (c, names); + } + + // Assign "derived" names. + // + { + DerivedMemberInRestriction member ( + *this, + member_set, + dynamic_cast ( + c.inherits ().base ())); + + Traversal::Names names (member); + + Complex::names (c, names); + } + } + else + { + // First assign the "primary" names. + // + { + PrimaryMember member (*this, member_set); + Traversal::Names names (member); + + Complex::names (c, names); + } + + // Assign "derived" names. + // + { + DerivedMember member (*this, member_set); + Traversal::Names names (member); + + Complex::names (c, names); + } + } + } + }; + + + // + // + struct GlobalType: Traversal::Type, Context + { + GlobalType (Context& c, NameSet& set) + : Context (c), set_ (set) + { + } + + virtual void + traverse (SemanticGraph::Type& t) + { + SemanticGraph::Context& c (t.context ()); + String const& n (t.name ()); + + String name (find_name (n + skel_suffix, set_)); + c.set ("name", name); + + // Assign the post_* name. + // + c.set ("post", find_post_name (t)); + + // Note that we do not add this name to the set so that it + // does not influence other names. + // + if (impl) + c.set ("impl", escape (n + impl_suffix)); + } + + private: + String + find_post_name (SemanticGraph::Type& t) + { + String const& n (t.name ()); + + // It is possible that our base has the same type name (just + // in a different namespaces). Avoid name clash in this case. + // + using SemanticGraph::Complex; + + Complex* c = dynamic_cast (&t); + + if (c == 0 || !c->inherits_p ()) + { + return escape (L"post_" + n); + } + else + { + NameSet set; + + // Collect all base's post_*. In some mutual inclusion cases it + // is possible that our base won't have the post name assigned + // yet. In this situation will will have to figure it out + // ourselves (we can do it since we use the "raw" type name). + // + SemanticGraph::Type* b (&c->inherits ().base ()); + + while (true) + { + if (b->context ().count ("post")) + set.insert (b->context ().get ("post")); + else + set.insert (find_post_name (*b)); + + Complex* cb (dynamic_cast (b)); + + if (cb != 0 && cb->inherits_p ()) + { + b = &cb->inherits ().base (); + continue; + } + + break; + } + + String base_name (escape (L"post_" + n)); + String post (base_name); + + for (size_t i (1); set.find (post) != set.end (); ++i) + { + std::wostringstream os; + os << i; + post = base_name + os.str (); + } + + return post; + } + } + + private: + NameSet& set_; + }; + + + struct Namespace: Traversal::Namespace, Context + { + Namespace (Context& c) + : Context (c) + { + } + + virtual void + traverse (Type& ns) + { + NameSet& type_set (global_type_names[ns.name ()]); + + GlobalType type (*this, type_set); + Traversal::Names names (type); + + Traversal::Namespace::names (ns, names); + } + }; + + + struct FundType: Traversal::AnyType, + Traversal::AnySimpleType, + + Traversal::Fundamental::Byte, + Traversal::Fundamental::UnsignedByte, + Traversal::Fundamental::Short, + Traversal::Fundamental::UnsignedShort, + Traversal::Fundamental::Int, + Traversal::Fundamental::UnsignedInt, + Traversal::Fundamental::Long, + Traversal::Fundamental::UnsignedLong, + Traversal::Fundamental::Integer, + Traversal::Fundamental::NonPositiveInteger, + Traversal::Fundamental::NonNegativeInteger, + Traversal::Fundamental::PositiveInteger, + Traversal::Fundamental::NegativeInteger, + + Traversal::Fundamental::Boolean, + + Traversal::Fundamental::Float, + Traversal::Fundamental::Double, + Traversal::Fundamental::Decimal, + + Traversal::Fundamental::String, + Traversal::Fundamental::NormalizedString, + Traversal::Fundamental::Token, + Traversal::Fundamental::Name, + Traversal::Fundamental::NameToken, + Traversal::Fundamental::NameTokens, + Traversal::Fundamental::NCName, + Traversal::Fundamental::Language, + + Traversal::Fundamental::QName, + + Traversal::Fundamental::Id, + Traversal::Fundamental::IdRef, + Traversal::Fundamental::IdRefs, + + Traversal::Fundamental::AnyURI, + + Traversal::Fundamental::Base64Binary, + Traversal::Fundamental::HexBinary, + + Traversal::Fundamental::Date, + Traversal::Fundamental::DateTime, + Traversal::Fundamental::Duration, + Traversal::Fundamental::Day, + Traversal::Fundamental::Month, + Traversal::Fundamental::MonthDay, + Traversal::Fundamental::Year, + Traversal::Fundamental::YearMonth, + Traversal::Fundamental::Time, + + Traversal::Fundamental::Entity, + Traversal::Fundamental::Entities, + + Context + { + FundType (Context& c) + : Context (c) + { + } + + // anyType & anySimpleType. + // + virtual void + traverse (SemanticGraph::AnyType& t) + { + t.context ().set ("name", make_skel_name ("any_type")); + t.context ().set ("impl", make_impl_name ("any_type")); + t.context ().set ("post", String ("post_any_type")); + } + + virtual void + traverse (SemanticGraph::AnySimpleType& t) + { + t.context ().set ("name", make_skel_name ("any_simple_type")); + t.context ().set ("impl", make_impl_name ("any_simple_type")); + t.context ().set ("post", String ("post_any_simple_type")); + } + + // Boolean. + // + virtual void + traverse (SemanticGraph::Fundamental::Boolean& t) + { + t.context ().set ("name", make_skel_name ("boolean")); + t.context ().set ("impl", make_impl_name ("boolean")); + t.context ().set ("post", String ("post_boolean")); + } + + // Integral types. + // + virtual void + traverse (SemanticGraph::Fundamental::Byte& t) + { + t.context ().set ("name", make_skel_name ("byte")); + t.context ().set ("impl", make_impl_name ("byte")); + t.context ().set ("post", String ("post_byte")); + } + + virtual void + traverse (SemanticGraph::Fundamental::UnsignedByte& t) + { + t.context ().set ("name", make_skel_name ("unsigned_byte")); + t.context ().set ("impl", make_impl_name ("unsigned_byte")); + t.context ().set ("post", String ("post_unsigned_byte")); + } + + virtual void + traverse (SemanticGraph::Fundamental::Short& t) + { + t.context ().set ("name", make_skel_name ("short")); + t.context ().set ("impl", make_impl_name ("short")); + t.context ().set ("post", String ("post_short")); + } + + virtual void + traverse (SemanticGraph::Fundamental::UnsignedShort& t) + { + t.context ().set ("name", make_skel_name ("unsigned_short")); + t.context ().set ("impl", make_impl_name ("unsigned_short")); + t.context ().set ("post", String ("post_unsigned_short")); + } + + virtual void + traverse (SemanticGraph::Fundamental::Int& t) + { + t.context ().set ("name", make_skel_name ("int")); + t.context ().set ("impl", make_impl_name ("int")); + t.context ().set ("post", String ("post_int")); + } + + virtual void + traverse (SemanticGraph::Fundamental::UnsignedInt& t) + { + t.context ().set ("name", make_skel_name ("unsigned_int")); + t.context ().set ("impl", make_impl_name ("unsigned_int")); + t.context ().set ("post", String ("post_unsigned_int")); + } + + virtual void + traverse (SemanticGraph::Fundamental::Long& t) + { + t.context ().set ("name", make_skel_name ("long")); + t.context ().set ("impl", make_impl_name ("long")); + t.context ().set ("post", String ("post_long")); + } + + virtual void + traverse (SemanticGraph::Fundamental::UnsignedLong& t) + { + t.context ().set ("name", make_skel_name ("unsigned_long")); + t.context ().set ("impl", make_impl_name ("unsigned_long")); + t.context ().set ("post", String ("post_unsigned_long")); + } + + virtual void + traverse (SemanticGraph::Fundamental::Integer& t) + { + t.context ().set ("name", make_skel_name ("integer")); + t.context ().set ("impl", make_impl_name ("integer")); + t.context ().set ("post", String ("post_integer")); + } + + virtual void + traverse (SemanticGraph::Fundamental::NonPositiveInteger& t) + { + t.context ().set ("name", make_skel_name ("non_positive_integer")); + t.context ().set ("impl", make_impl_name ("non_positive_integer")); + t.context ().set ("post", String ("post_non_positive_integer")); + } + + virtual void + traverse (SemanticGraph::Fundamental::NonNegativeInteger& t) + { + t.context ().set ("name", make_skel_name ("non_negative_integer")); + t.context ().set ("impl", make_impl_name ("non_negative_integer")); + t.context ().set ("post", String ("post_non_negative_integer")); + } + + virtual void + traverse (SemanticGraph::Fundamental::PositiveInteger& t) + { + t.context ().set ("name", make_skel_name ("positive_integer")); + t.context ().set ("impl", make_impl_name ("positive_integer")); + t.context ().set ("post", String ("post_positive_integer")); + } + + virtual void + traverse (SemanticGraph::Fundamental::NegativeInteger& t) + { + t.context ().set ("name", make_skel_name ("negative_integer")); + t.context ().set ("impl", make_impl_name ("negative_integer")); + t.context ().set ("post", String ("post_negative_integer")); + } + + // Floats. + // + virtual void + traverse (SemanticGraph::Fundamental::Float& t) + { + t.context ().set ("name", make_skel_name ("float")); + t.context ().set ("impl", make_impl_name ("float")); + t.context ().set ("post", String ("post_float")); + } + + virtual void + traverse (SemanticGraph::Fundamental::Double& t) + { + t.context ().set ("name", make_skel_name ("double")); + t.context ().set ("impl", make_impl_name ("double")); + t.context ().set ("post", String ("post_double")); + } + + virtual void + traverse (SemanticGraph::Fundamental::Decimal& t) + { + t.context ().set ("name", make_skel_name ("decimal")); + t.context ().set ("impl", make_impl_name ("decimal")); + t.context ().set ("post", String ("post_decimal")); + } + + // Strings. + // + virtual void + traverse (SemanticGraph::Fundamental::String& t) + { + t.context ().set ("name", make_skel_name ("string")); + t.context ().set ("impl", make_impl_name ("string")); + t.context ().set ("post", String ("post_string")); + } + + virtual void + traverse (SemanticGraph::Fundamental::NormalizedString& t) + { + t.context ().set ("name", make_skel_name ("normalized_string")); + t.context ().set ("impl", make_impl_name ("normalized_string")); + t.context ().set ("post", String ("post_normalized_string")); + } + + virtual void + traverse (SemanticGraph::Fundamental::Token& t) + { + t.context ().set ("name", make_skel_name ("token")); + t.context ().set ("impl", make_impl_name ("token")); + t.context ().set ("post", String ("post_token")); + } + + virtual void + traverse (SemanticGraph::Fundamental::NameToken& t) + { + t.context ().set ("name", make_skel_name ("nmtoken")); + t.context ().set ("impl", make_impl_name ("nmtoken")); + t.context ().set ("post", String ("post_nmtoken")); + } + + virtual void + traverse (SemanticGraph::Fundamental::NameTokens& t) + { + t.context ().set ("name", make_skel_name ("nmtokens")); + t.context ().set ("impl", make_impl_name ("nmtokens")); + t.context ().set ("post", String ("post_nmtokens")); + } + + virtual void + traverse (SemanticGraph::Fundamental::Name& t) + { + t.context ().set ("name", make_skel_name ("name")); + t.context ().set ("impl", make_impl_name ("name")); + t.context ().set ("post", String ("post_name")); + } + + virtual void + traverse (SemanticGraph::Fundamental::NCName& t) + { + t.context ().set ("name", make_skel_name ("ncname")); + t.context ().set ("impl", make_impl_name ("ncname")); + t.context ().set ("post", String ("post_ncname")); + } + + virtual void + traverse (SemanticGraph::Fundamental::Language& t) + { + t.context ().set ("name", make_skel_name ("language")); + t.context ().set ("impl", make_impl_name ("language")); + t.context ().set ("post", String ("post_language")); + } + + + // Qualified name. + // + virtual void + traverse (SemanticGraph::Fundamental::QName& t) + { + t.context ().set ("name", make_skel_name ("qname")); + t.context ().set ("impl", make_impl_name ("qname")); + t.context ().set ("post", String ("post_qname")); + } + + + // ID/IDREF. + // + virtual void + traverse (SemanticGraph::Fundamental::Id& t) + { + t.context ().set ("name", make_skel_name ("id")); + t.context ().set ("impl", make_impl_name ("id")); + t.context ().set ("post", String ("post_id")); + } + + virtual void + traverse (SemanticGraph::Fundamental::IdRef& t) + { + t.context ().set ("name", make_skel_name ("idref")); + t.context ().set ("impl", make_impl_name ("idref")); + t.context ().set ("post", String ("post_idref")); + } + + virtual void + traverse (SemanticGraph::Fundamental::IdRefs& t) + { + t.context ().set ("name", make_skel_name ("idrefs")); + t.context ().set ("impl", make_impl_name ("idrefs")); + t.context ().set ("post", String ("post_idrefs")); + } + + // URI. + // + virtual void + traverse (SemanticGraph::Fundamental::AnyURI& t) + { + t.context ().set ("name", make_skel_name ("uri")); + t.context ().set ("impl", make_impl_name ("uri")); + t.context ().set ("post", String ("post_uri")); + } + + // Binary. + // + virtual void + traverse (SemanticGraph::Fundamental::Base64Binary& t) + { + t.context ().set ("name", make_skel_name ("base64_binary")); + t.context ().set ("impl", make_impl_name ("base64_binary")); + t.context ().set ("post", String ("post_base64_binary")); + } + + virtual void + traverse (SemanticGraph::Fundamental::HexBinary& t) + { + t.context ().set ("name", make_skel_name ("hex_binary")); + t.context ().set ("impl", make_impl_name ("hex_binary")); + t.context ().set ("post", String ("post_hex_binary")); + } + + + // Date/time. + // + virtual void + traverse (SemanticGraph::Fundamental::Date& t) + { + t.context ().set ("name", make_skel_name ("date")); + t.context ().set ("impl", make_impl_name ("date")); + t.context ().set ("post", String ("post_date")); + } + + virtual void + traverse (SemanticGraph::Fundamental::DateTime& t) + { + t.context ().set ("name", make_skel_name ("date_time")); + t.context ().set ("impl", make_impl_name ("date_time")); + t.context ().set ("post", String ("post_date_time")); + } + + virtual void + traverse (SemanticGraph::Fundamental::Duration& t) + { + t.context ().set ("name", make_skel_name ("duration")); + t.context ().set ("impl", make_impl_name ("duration")); + t.context ().set ("post", String ("post_duration")); + } + + virtual void + traverse (SemanticGraph::Fundamental::Day& t) + { + t.context ().set ("name", make_skel_name ("gday")); + t.context ().set ("impl", make_impl_name ("gday")); + t.context ().set ("post", String ("post_gday")); + } + + virtual void + traverse (SemanticGraph::Fundamental::Month& t) + { + t.context ().set ("name", make_skel_name ("gmonth")); + t.context ().set ("impl", make_impl_name ("gmonth")); + t.context ().set ("post", String ("post_gmonth")); + } + + virtual void + traverse (SemanticGraph::Fundamental::MonthDay& t) + { + t.context ().set ("name", make_skel_name ("gmonth_day")); + t.context ().set ("impl", make_impl_name ("gmonth_day")); + t.context ().set ("post", String ("post_gmonth_day")); + } + + virtual void + traverse (SemanticGraph::Fundamental::Year& t) + { + t.context ().set ("name", make_skel_name ("gyear")); + t.context ().set ("impl", make_impl_name ("gyear")); + t.context ().set ("post", String ("post_gyear")); + } + + virtual void + traverse (SemanticGraph::Fundamental::YearMonth& t) + { + t.context ().set ("name", make_skel_name ("gyear_month")); + t.context ().set ("impl", make_impl_name ("gyear_month")); + t.context ().set ("post", String ("post_gyear_month")); + } + + virtual void + traverse (SemanticGraph::Fundamental::Time& t) + { + t.context ().set ("name", make_skel_name ("time")); + t.context ().set ("impl", make_impl_name ("time")); + t.context ().set ("post", String ("post_time")); + } + + // Entity. + // + virtual void + traverse (SemanticGraph::Fundamental::Entity& t) + { + t.context ().set ("name", make_skel_name ("entity")); + t.context ().set ("impl", make_impl_name ("entity")); + t.context ().set ("post", String ("post_entity")); + } + + virtual void + traverse (SemanticGraph::Fundamental::Entities& t) + { + t.context ().set ("name", make_skel_name ("entities")); + t.context ().set ("impl", make_impl_name ("entities")); + t.context ().set ("post", String ("post_entities")); + } + + private: + String + make_skel_name (String const& base) + { + return escape (base + skel_suffix); + } + + String + make_impl_name (String const& base) + { + return escape (base + impl_suffix); + } + }; + + // Go into sourced/included/imported schemas while making sure + // we don't process the same stuff more than once. + // + struct Uses: Traversal::Sources, + Traversal::Includes, + Traversal::Imports + { + virtual void + traverse (SemanticGraph::Sources& sr) + { + SemanticGraph::Schema& s (sr.schema ()); + + if (!s.context ().count ("cxx-parser-name-processor-seen")) + { + s.context ().set ("cxx-parser-name-processor-seen", true); + Traversal::Sources::traverse (sr); + } + } + + virtual void + traverse (SemanticGraph::Includes& i) + { + SemanticGraph::Schema& s (i.schema ()); + + if (!s.context ().count ("cxx-parser-name-processor-seen")) + { + s.context ().set ("cxx-parser-name-processor-seen", true); + Traversal::Includes::traverse (i); + } + } + + virtual void + traverse (SemanticGraph::Imports& i) + { + SemanticGraph::Schema& s (i.schema ()); + + if (!s.context ().count ("cxx-parser-name-processor-seen")) + { + s.context ().set ("cxx-parser-name-processor-seen", true); + Traversal::Imports::traverse (i); + } + } + }; + + // Go into implied schemas while making sure we don't process + // the same stuff more than once. + // + struct Implies: Traversal::Implies + { + virtual void + traverse (SemanticGraph::Implies& i) + { + SemanticGraph::Schema& s (i.schema ()); + + if (!s.context ().count ("cxx-parser-name-processor-seen")) + { + s.context ().set ("cxx-parser-name-processor-seen", true); + Traversal::Implies::traverse (i); + } + } + }; + + void + process_impl (options const& ops, + SemanticGraph::Schema& tu, + SemanticGraph::Path const& file, + StringLiteralMap const& map) + { + Context ctx (ops, tu, file, &map); + + if (tu.names_begin ()->named ().name () == + L"http://www.w3.org/2001/XMLSchema") + { + // XML Schema namespace. + // + Traversal::Schema schema; + + Traversal::Names schema_names; + Traversal::Namespace ns; + Traversal::Names ns_names; + FundType fund_type (ctx); + + schema >> schema_names >> ns >> ns_names >> fund_type; + + schema.dispatch (tu); + } + else + { + + // Pass one - assign names to fundamental types. + // + { + Traversal::Schema schema; + Implies implies; + Traversal::Schema xs_schema; + + schema >> implies >> xs_schema; + + Traversal::Names xs_schema_names; + Traversal::Namespace ns; + Traversal::Names ns_names; + FundType fund_type (ctx); + + xs_schema >> xs_schema_names >> ns >> ns_names >> fund_type; + + schema.dispatch (tu); + } + + // Pass two - assign names to global types. This pass cannot + // be combined with pass three because of possible recursive + // schema inclusions. Also note that we check first if this + // schema has already been processed which may happen in the + // file-per-type compilation mode. + // + if (!tu.context ().count ("cxx-parser-name-processor-seen")) + { + Traversal::Schema schema; + Uses uses; + + schema >> uses >> schema; + + Traversal::Names schema_names; + Namespace ns (ctx); + + schema >> schema_names >> ns; + + // Some twisted schemas do recusive self-inclusion. + // + tu.context ().set ("cxx-parser-name-processor-seen", true); + + schema.dispatch (tu); + } + + // Pass three - assign names inside complex types. Here we don't + // need to go into included/imported schemas. + // + { + Traversal::Schema schema; + Sources sources; + + schema >> sources >> schema; + + Traversal::Names schema_names; + Traversal::Namespace ns; + Traversal::Names ns_names; + + schema >> schema_names >> ns >> ns_names; + + Complex complex (ctx); + + ns_names >> complex; + + schema.dispatch (tu); + } + } + } + } + + void NameProcessor:: + process (options const& ops, + SemanticGraph::Schema& tu, + SemanticGraph::Path const& file, + StringLiteralMap const& map) + { + process_impl (ops, tu, file, map); + } + } +} diff --git a/xsd/cxx/parser/name-processor.hxx b/xsd/cxx/parser/name-processor.hxx new file mode 100644 index 0000000..f8ac28c --- /dev/null +++ b/xsd/cxx/parser/name-processor.hxx @@ -0,0 +1,30 @@ +// file : xsd/cxx/parser/name-processor.hxx +// license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +#ifndef XSD_CXX_PARSER_NAME_PROCESSOR_HXX +#define XSD_CXX_PARSER_NAME_PROCESSOR_HXX + +#include + +#include + +#include +#include + +namespace CXX +{ + namespace Parser + { + class NameProcessor + { + public: + void + process (options const&, + XSDFrontend::SemanticGraph::Schema&, + XSDFrontend::SemanticGraph::Path const& file, + StringLiteralMap const& map); + }; + } +} + +#endif // XSD_CXX_PARSER_NAME_PROCESSOR_HXX diff --git a/xsd/cxx/parser/options.cli b/xsd/cxx/parser/options.cli new file mode 100644 index 0000000..e430333 --- /dev/null +++ b/xsd/cxx/parser/options.cli @@ -0,0 +1,147 @@ +// file : xsd/cxx/parser/options.cli +// license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +include ; // std::size_t + +include ; // NarrowString, NarrowStrings + +include ; + +namespace CXX +{ + namespace Parser + { + class options: CXX::options + { + NarrowStrings --type-map + { + "", + "Read XML Schema to C++ type mapping information from . + Repeat this option to specify several type maps. Type maps are + considered in order of appearance and the first match is used. By + default all user-defined types are mapped to \cb{void}. See the + TYPE MAP section below for more information." + }; + + NarrowString --xml-parser = "xerces" + { + "", + "Use as the underlying XML parser. Valid values are + \cb{xerces} for Xerces-C++ (default) and \cb{expat} for Expat." + }; + + // Features. + // + bool --generate-validation + { + "Generate validation code. The validation code (\"perfect parser\") + ensures that instance documents conform to the schema. Validation + code is generated by default when the selected underlying XML parser + is non-validating (\cb{expat})." + }; + + bool --suppress-validation + { + "Suppress the generation of validation code. Validation is suppressed + by default when the selected underlying XML parser is validating + (\cb{xerces})." + }; + + bool --generate-polymorphic + { + "Generate polymorphism-aware code. Specify this option if you use + substitution groups or \cb{xsi:type}." + }; + + bool --generate-noop-impl + { + "Generate a sample parser implementation that does nothing (no + operation). The sample implementation can then be filled with + the application-specific code. For an input file in the form + \cb{name.xsd} this option triggers the generation of two + additional C++ files in the form: \cb{name-pimpl.hxx} (parser + implementation header file) and \cb{name-pimpl.cxx} (parser + implementation source file)." + }; + + bool --generate-print-impl + { + "Generate a sample parser implementation that prints the XML data + to \c{STDOUT}. For an input file in the form \cb{name.xsd} this + option triggers the generation of two additional C++ files in the + form: \cb{name-pimpl.hxx} (parser implementation header file) and + \cb{name-pimpl.cxx} (parser implementation source file)." + }; + + bool --generate-test-driver + { + "Generate a test driver for the sample parser implementation. For an + input file in the form \cb{name.xsd} this option triggers the + generation of an additional C++ file in the form + \cb{name-driver.cxx}." + }; + + bool --force-overwrite + { + "Force overwriting of the existing implementation and test driver + files. Use this option only if you do not mind loosing the changes + you have made in the sample implementation or test driver files." + }; + + // Root element. + // + bool --root-element-first + { + "Indicate that the first global element is the document root. This + information is used to generate the test driver for the sample + implementation." + }; + + bool --root-element-last + { + "Indicate that the last global element is the document root. This + information is used to generate the test driver for the sample + implementation." + }; + + NarrowString --root-element + { + "", + "Indicate that is the document root. This information is + used to generate the test driver for the sample implementation." + }; + + // Suffixes. + // + NarrowString --skel-type-suffix = "_pskel" + { + "", + "Use the provided instead of the default \cb{_pskel} to + construct the names of the generated parser skeletons." + }; + + NarrowString --skel-file-suffix = "-pskel" + { + "", + "Use the provided instead of the default \cb{-pskel} to + construct the names of the generated parser skeleton files." + }; + + NarrowString --impl-type-suffix = "_pimpl" + { + "", + "Use the provided instead of the default \cb{_pimpl} to + construct the names of the parser implementations for the built-in + XML Schema types as well as sample parser implementations." + }; + + NarrowString --impl-file-suffix = "-pimpl" + { + "", + "Use the provided instead of the default \cb{-pimpl} to + construct the names of the generated sample parser implementation + files." + }; + }; + } +} diff --git a/xsd/cxx/parser/parser-forward.cxx b/xsd/cxx/parser/parser-forward.cxx new file mode 100644 index 0000000..65603fd --- /dev/null +++ b/xsd/cxx/parser/parser-forward.cxx @@ -0,0 +1,110 @@ +// file : xsd/cxx/parser/parser-forward.cxx +// license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +#include + +#include +#include + +namespace CXX +{ + namespace Parser + { + namespace + { + struct Enumeration: Traversal::Enumeration, Context + { + Enumeration (Context& c) + : Context (c) + { + } + + virtual void + traverse (Type& e) + { + os << "class " << ename (e) << ";"; + } + }; + + // + // + struct List: Traversal::List, Context + { + List (Context& c) + : Context (c) + { + } + + virtual void + traverse (Type& l) + { + os << "class " << ename (l) << ";"; + } + }; + + // + // + struct Union: Traversal::Union, Context + { + Union (Context& c) + : Context (c) + { + } + + virtual void + traverse (Type& u) + { + os << "class " << ename (u) << ";"; + } + }; + + // + // + struct Complex: Traversal::Complex, Context + { + Complex (Context& c) + : Context (c) + { + } + + virtual void + traverse (Type& c) + { + os << "class " << ename (c) << ";"; + } + }; + } + + void + generate_parser_forward (Context& ctx) + { + ctx.os << "// Forward declarations" << endl + << "//" << endl; + + Traversal::Schema schema; + + Sources sources; + Traversal::Names schema_names; + + Namespace ns (ctx); + Traversal::Names names; + + schema >> sources >> schema; + schema >> schema_names >> ns >> names; + + List list (ctx); + Union union_ (ctx); + Complex complex (ctx); + Enumeration enumeration (ctx); + + names >> list; + names >> union_; + names >> complex; + names >> enumeration; + + schema.dispatch (ctx.schema_root); + + ctx.os << endl; + } + } +} diff --git a/xsd/cxx/parser/parser-forward.hxx b/xsd/cxx/parser/parser-forward.hxx new file mode 100644 index 0000000..b5345a5 --- /dev/null +++ b/xsd/cxx/parser/parser-forward.hxx @@ -0,0 +1,18 @@ +// file : xsd/cxx/parser/parser-forward.hxx +// license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +#ifndef XSD_CXX_PARSER_PARSER_FORWARD_HXX +#define XSD_CXX_PARSER_PARSER_FORWARD_HXX + +#include + +namespace CXX +{ + namespace Parser + { + void + generate_parser_forward (Context&); + } +} + +#endif // XSD_CXX_PARSER_PARSER_FORWARD_HXX diff --git a/xsd/cxx/parser/parser-header.cxx b/xsd/cxx/parser/parser-header.cxx new file mode 100644 index 0000000..327bb07 --- /dev/null +++ b/xsd/cxx/parser/parser-header.cxx @@ -0,0 +1,1440 @@ +// file : xsd/cxx/parser/parser-header.cxx +// license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +#include + +#include + +#include +#include + +using namespace std; + +namespace CXX +{ + namespace Parser + { + namespace + { + struct Enumeration: Traversal::Enumeration, Context + { + Enumeration (Context& c) + : Context (c) + { + } + + virtual void + traverse (Type& e) + { + String const& name (ename (e)); + SemanticGraph::Type& base (e.inherits ().base ()); + + os << "class " << type_exp << name << ": public virtual " << + fq_name (base) + << "{" + << "public:" << endl + << "// Parser callbacks. Override them in your " << + "implementation." << endl + << "//" << endl; + + os << "// virtual void" << endl + << "// pre ();" << endl + << endl; + + String const& ret (ret_type (e)); + + bool same (ret == ret_type (base)); + + os << "virtual " << ret << endl + << post_name (e) << " ()" << + (same || ret == L"void" ? ";" : " = 0;"); + + if (polymorphic) + { + os << endl + << "public:" << endl + << "static const " << char_type << "*" << endl + << "_static_type ();" + << endl + << "virtual const " << char_type << "*" << endl + << "_dynamic_type () const;"; + } + + os << "};"; + } + }; + + // + // + struct List: Traversal::List, Context + { + List (Context& c) + : Context (c) + { + } + + virtual void + traverse (Type& l) + { + String const& name (ename (l)); + SemanticGraph::Type& t (l.argumented ().type ()); + + String item (unclash (name, "item")); + + os << "class " << type_exp << name << ": public " << list_base + << "{" + << "public:" << endl + << "// Parser callbacks. Override them in your " << + "implementation." << endl + << "//" << endl; + + // pre + // + os << "// virtual void" << endl + << "// pre ();" << endl + << endl; + + // item + // + String const& arg (arg_type (t)); + + os << "virtual void" << endl + << item; + + if (arg == L"void") + os << " ();"; + else + os << " (" << arg << ");"; + + os << endl; + + // post + // + String const& ret (ret_type (l)); + + os << "virtual " << ret << endl + << post_name (l) << " ()" << (ret == L"void" ? ";" : " = 0;") + << endl; + + // + // + os << "// Parser construction API." << endl + << "//" << endl; + + // item_parser + // + os << "void" << endl + << unclash (name, "item_parser") << " (" << fq_name (t) << "&);" + << endl; + + // parsers + // + os << "void" << endl + << "parsers (" << fq_name (t) << "& /* item */);" + << endl; + + // c-tor + // + os << "// Constructor." << endl + << "//" << endl + << name << " ();" + << endl; + + + if (polymorphic) + { + os << "public:" << endl + << "static const " << char_type << "*" << endl + << "_static_type ();" + << endl + << "virtual const " << char_type << "*" << endl + << "_dynamic_type () const;" + << endl; + } + + // + // + os << "// Implementation." << endl + << "//" << endl + << "protected:" << endl; + + os << "virtual void" << endl + << "_xsd_parse_item (const " << string_type << "&);" + << endl; + + os << "protected:" << endl + << fq_name (t) << "* _xsd_" << item << "_;" + << "};"; + } + }; + + struct Union: Traversal::Union, Context + { + Union (Context& c) + : Context (c) + { + } + + virtual void + traverse (Type& u) + { + String const& name (ename (u)); + + os << "class " << type_exp << name << ": public " << simple_base + << "{" + << "public:" << endl + << "// Parser callbacks. Override them in your " << + "implementation." << endl + << "//" << endl; + + os << "// virtual void" << endl + << "// pre ();" << endl + << "//" << endl + << "// virtual void" << endl + << "// _characters (const " << string_type << "&);" << endl + << endl; + + String const& ret (ret_type (u)); + + os << "virtual " << ret << endl + << post_name (u) << " ()" << (ret == L"void" ? ";" : " = 0;"); + + if (polymorphic) + { + os << endl + << "public:" << endl + << "static const " << char_type << "*" << endl + << "_static_type ();" + << endl + << "virtual const " << char_type << "*" << endl + << "_dynamic_type () const;"; + } + + os << "};"; + } + }; + + + // + // + struct ParserCallback: Traversal::Member, Context + { + ParserCallback (Context& c) + : Context (c) + { + } + + virtual void + traverse (Type& m) + { + if (skip (m)) return; + + String const& arg (arg_type (m.type ())); + + os << "virtual void" << endl + << ename (m); + + if (arg == L"void") + os << " ();"; + else + os << " (" << arg << ");"; + + os << endl; + } + }; + + + // + // + struct ParserModifier: Traversal::Member, Context + { + ParserModifier (Context& c) + : Context (c) + { + } + + virtual void + traverse (Type& m) + { + if (skip (m)) + return; + + os << "void" << endl + << eparser (m) << " (" << fq_name (m.type ()) << "&);" + << endl; + + if (polymorphic && + m.is_a () && + !anonymous (m.type ())) + { + os << "void" << endl + << eparser (m) << " (const " << parser_map << "&);" + << endl; + } + } + }; + + // + // + struct ParserMember: Traversal::Member, Context + { + ParserMember (Context& c) + : Context (c) + { + } + + virtual void + traverse (Type& m) + { + if (skip (m)) + return; + + String type (fq_name (m.type ())); + + os << type << "* " << emember (m) << ";"; + + if (polymorphic && + m.is_a () && + !anonymous (m.type ())) + { + os << "const " << parser_map << "* " << emember_map (m) << ";" + << endl; + } + } + }; + + // + // + struct Particle: Traversal::All, + Traversal::Choice, + Traversal::Sequence, + Context + { + Particle (Context& c) + : Context (c) + { + *this >> contains_particle_ >> *this; + } + + + virtual void + traverse (SemanticGraph::All& a) + { + if (!a.context().count ("comp-number")) + return; + + size_t state_count (a.context().get ("state-count")); + + os << "void" << endl + << "all_0 (unsigned long& state," << endl + << "unsigned char* count," << endl + << "const " << string_type << "& ns," << endl + << "const " << string_type << "& n," << endl + << "const " << string_type << "* t," << endl + << "bool start);" + << endl + << "unsigned char v_all_first_[" << state_count << "UL];" + << "::xsd::cxx::parser::validating::all_stack v_all_count_;" + << endl; + } + + virtual void + traverse (SemanticGraph::Choice& c) + { + if (!c.context().count ("comp-number")) + return; + + size_t n (c.context ().get ("comp-number")); + + os << "void" << endl + << "choice_" << n << " (unsigned long& state," << endl + << "unsigned long& count," << endl + << "const " << string_type << "& ns," << endl + << "const " << string_type << "& n," << endl + << "const " << string_type << "* t," << endl + << "bool start);" + << endl; + + Traversal::Choice::traverse (c); + } + + virtual void + traverse (SemanticGraph::Sequence& s) + { + if (!s.context().count ("comp-number")) + return; + + size_t n (s.context ().get ("comp-number")); + + os << "void" << endl + << "sequence_" << n << " (unsigned long& state," << endl + << "unsigned long& count," << endl + << "const " << string_type << "& ns," << endl + << "const " << string_type << "& n," << endl + << "const " << string_type << "* t," << endl + << "bool start);" + << endl; + + Traversal::Sequence::traverse (s); + } + + private: + Traversal::ContainsParticle contains_particle_; + }; + + + // + // + struct AttributeValidationState: Traversal::Attribute, Context + { + AttributeValidationState (Context& c) + : Context (c) + { + } + + virtual void + traverse (Type& a) + { + if (!a.optional_p ()) + { + os << "bool " << ename (a) << ";"; + } + } + }; + + // + // + struct Complex: Traversal::Complex, Context + { + Complex (Context& c) + : Context (c), + parser_callback_ (c), + parser_member_ (c), + parser_modifier_ (c), + attribute_validation_state_ (c) + { + names_parser_callback_ >> parser_callback_; + names_parser_member_ >> parser_member_; + names_parser_modifier_ >> parser_modifier_; + names_attribute_validation_state_ >> attribute_validation_state_; + } + + virtual void + traverse (Type& c) + { + String const& name (ename (c)); + + // In case of an inheritance-by-restriction, we don't need to + // generate parser callbacks, etc. since they are the same as in + // the base. We only need the parsing/validation code. + // + bool restriction (restriction_p (c)); + + bool he (has (c)); + bool ha (has (c)); + + bool hae (has_particle (c)); + bool haa (has (c)); + + bool hra (false); // Has required attribute. + if (ha) + { + RequiredAttributeTest test (hra); + Traversal::Names names_test (test); + names (c, names_test); + } + + + // + // + os << "class " << type_exp << name << ": public "; + + if (c.inherits_p ()) + os << "virtual " << fq_name (c.inherits ().base ()); + else + os << complex_base; + + os << "{" + << "public:" << endl + << "// Parser callbacks. Override them in your " << + "implementation." << endl + << "//" << endl; + + os << "// virtual void" << endl + << "// pre ();" << endl + << endl; + + + if (!restriction && (ha || he)) + { + names (c, names_parser_callback_); + } + + String const& ret (ret_type (c)); + + bool same (c.inherits_p () && + ret == ret_type (c.inherits ().base ())); + + os << "virtual " << ret << endl + << post_name (c) << " ()" << + (same || ret == L"void" ? ";" : " = 0;") + << endl; + + // + // + if (!restriction && (he || ha)) + { + os << "// Parser construction API." << endl + << "//" << endl; + + names (c, names_parser_modifier_); + + os << "void" << endl + << "parsers ("; + + { + ParserParamDecl decl (*this, false); + decl.traverse (c); + } + + os << ");" + << endl; + } + + // Default c-tor. + // + if ((!restriction && (he || ha)) || + (validation && (he || hae || hra))) + { + os << "// Constructor." << endl + << "//" << endl + << name << " ();" + << endl; + } + + if (polymorphic) + { + os << "public:" << endl + << "static const " << char_type << "*" << endl + << "_static_type ();" + << endl + << "virtual const " << char_type << "*" << endl + << "_dynamic_type () const;" + << endl; + } + + // Implementation. + // + if (he || ha || (validation && (hae || haa))) + { + os << "// Implementation." << endl + << "//" << endl + << "protected:" << endl; + } + + // element + // + if (he || (validation && hae)) + { + // _start_element_impl + // + os << "virtual bool" << endl + << "_start_element_impl (const " << string_type << "&," << endl + << "const " << string_type << "&," << endl + << "const " << string_type << "*);" + << endl; + + // end_element + // + os << "virtual bool" << endl + << "_end_element_impl (const " << string_type << "&," << endl + << "const " << string_type << "&);" + << endl; + } + + // attribute + // + if (validation) + { + if (ha) + { + os << "virtual bool" << endl + << "_attribute_impl_phase_one (const " << string_type << + "&," << endl + << "const " << string_type << "&," << endl + << "const " << string_type << "&);" << endl + << endl; + } + + if (haa) + { + os << "virtual bool" << endl + << "_attribute_impl_phase_two (const " << string_type << + "&," << endl + << "const " << string_type << "&," << endl + << "const " << string_type << "&);" + << endl; + } + } + else + { + if (ha) + { + os << "virtual bool" << endl + << "_attribute_impl (const " << string_type << "&," << endl + << "const " << string_type << "&," << endl + << "const " << string_type << "&);" + << endl; + } + } + + // characters + // + if (validation && c.mixed_p ()) + { + os << "virtual bool" << endl + << "_characters_impl (const " << string_type << "&);" + << endl; + } + + if (!restriction && (he || ha)) + { + os << "protected:" << endl; + names (c, names_parser_member_); + os << endl; + } + + if (validation && (he || hae)) + { + size_t depth (c.context ().get ("depth")); + + os << "protected:" << endl; + + os << "struct v_state_descr_" + << "{" + << "void (" << fq_name (c) << "::*func) (" << endl + << "unsigned long&," << endl + << "unsigned long&," << endl + << "const " << string_type << "&," << endl + << "const " << string_type << "&," << endl + << "const " << string_type << "*," << endl + << "bool);" + << "unsigned long state;" + << "unsigned long count;" + << "};"; + + // Allocate one extra slot for the special state. + // + os << "struct v_state_" + << "{" + << "v_state_descr_ data[" << depth + 1 << "UL];" + << "unsigned long size;" + << "};"; + + os << "v_state_ v_state_first_;" + << "::xsd::cxx::parser::pod_stack v_state_stack_;" + << endl; + + os << "virtual void" << endl + << "_pre_e_validate ();" + << endl; + + os << "virtual void" << endl + << "_post_e_validate ();" + << endl; + + Particle t (*this); + t.dispatch (c.contains_compositor ().compositor ()); + } + + if (validation && hra) + { + os << "protected:" << endl; + + os << "struct v_state_attr_" + << "{"; + + names (c, names_attribute_validation_state_); + + os << "};"; + + os << "v_state_attr_ v_state_attr_first_;" + << "::xsd::cxx::parser::pod_stack v_state_attr_stack_;" + << endl; + + os << "virtual void" << endl + << "_pre_a_validate ();" + << endl; + + os << "virtual void" << endl + << "_post_a_validate ();" + << endl; + } + + os << "};"; + } + + private: + // + // + ParserCallback parser_callback_; + Traversal::Names names_parser_callback_; + + // + // + ParserMember parser_member_; + Traversal::Names names_parser_member_; + + // + // + ParserModifier parser_modifier_; + Traversal::Names names_parser_modifier_; + + // + // + AttributeValidationState attribute_validation_state_; + Traversal::Names names_attribute_validation_state_; + }; + + struct FundType : Context, + + Traversal::AnyType, + Traversal::AnySimpleType, + + Traversal::Fundamental::Byte, + Traversal::Fundamental::UnsignedByte, + Traversal::Fundamental::Short, + Traversal::Fundamental::UnsignedShort, + Traversal::Fundamental::Int, + Traversal::Fundamental::UnsignedInt, + Traversal::Fundamental::Long, + Traversal::Fundamental::UnsignedLong, + Traversal::Fundamental::Integer, + Traversal::Fundamental::NonPositiveInteger, + Traversal::Fundamental::NonNegativeInteger, + Traversal::Fundamental::PositiveInteger, + Traversal::Fundamental::NegativeInteger, + + Traversal::Fundamental::Boolean, + + Traversal::Fundamental::Float, + Traversal::Fundamental::Double, + Traversal::Fundamental::Decimal, + + Traversal::Fundamental::String, + Traversal::Fundamental::NormalizedString, + Traversal::Fundamental::Token, + Traversal::Fundamental::Name, + Traversal::Fundamental::NameToken, + Traversal::Fundamental::NameTokens, + Traversal::Fundamental::NCName, + Traversal::Fundamental::Language, + + Traversal::Fundamental::QName, + + Traversal::Fundamental::Id, + Traversal::Fundamental::IdRef, + Traversal::Fundamental::IdRefs, + + Traversal::Fundamental::AnyURI, + + Traversal::Fundamental::Base64Binary, + Traversal::Fundamental::HexBinary, + + Traversal::Fundamental::Date, + Traversal::Fundamental::DateTime, + Traversal::Fundamental::Duration, + Traversal::Fundamental::Day, + Traversal::Fundamental::Month, + Traversal::Fundamental::MonthDay, + Traversal::Fundamental::Year, + Traversal::Fundamental::YearMonth, + Traversal::Fundamental::Time, + + Traversal::Fundamental::Entity, + Traversal::Fundamental::Entities + { + FundType (Context& c) + : Context (c), xs_ns_ (xs_ns_name ()) + { + impl_ns_ = "::xsd::cxx::parser::"; + impl_ns_ += (validation ? L"validating" : L"non_validating"); + + if (char_type == L"char") + string_type_ = L"::std::string"; + else if (char_type == L"wchar_t") + string_type_ = L"::std::wstring"; + else + string_type_ = L"::std::basic_string< " + char_type + L" >"; + } + + // anyType & anySimpleType. + // + virtual void + traverse (SemanticGraph::AnyType& t) + { + gen_typedef (t, "void", "any_type_pskel", "any_type_pimpl"); + } + + virtual void + traverse (SemanticGraph::AnySimpleType& t) + { + gen_typedef (t, "void", + "any_simple_type_pskel", "any_simple_type_pimpl"); + } + + // Boolean. + // + virtual void + traverse (SemanticGraph::Fundamental::Boolean& t) + { + gen_typedef (t, "bool", "boolean_pskel", "boolean_pimpl"); + } + + // Integral types. + // + virtual void + traverse (SemanticGraph::Fundamental::Byte& t) + { + gen_typedef (t, "signed char", "byte_pskel", "byte_pimpl"); + } + + virtual void + traverse (SemanticGraph::Fundamental::UnsignedByte& t) + { + gen_typedef (t, "unsigned char", + "unsigned_byte_pskel", "unsigned_byte_pimpl"); + } + + virtual void + traverse (SemanticGraph::Fundamental::Short& t) + { + gen_typedef (t, "short", "short_pskel", "short_pimpl"); + } + + virtual void + traverse (SemanticGraph::Fundamental::UnsignedShort& t) + { + gen_typedef (t, "unsigned short", + "unsigned_short_pskel", "unsigned_short_pimpl"); + } + + virtual void + traverse (SemanticGraph::Fundamental::Int& t) + { + gen_typedef (t, "int", "int_pskel", "int_pimpl"); + } + + virtual void + traverse (SemanticGraph::Fundamental::UnsignedInt& t) + { + gen_typedef (t, "unsigned int", + "unsigned_int_pskel", "unsigned_int_pimpl"); + } + + virtual void + traverse (SemanticGraph::Fundamental::Long& t) + { + gen_typedef (t, "long long", "long_pskel", "long_pimpl"); + } + + virtual void + traverse (SemanticGraph::Fundamental::UnsignedLong& t) + { + gen_typedef (t, "unsigned long long", + "unsigned_long_pskel", "unsigned_long_pimpl"); + } + + virtual void + traverse (SemanticGraph::Fundamental::Integer& t) + { + gen_typedef (t, "long long", "integer_pskel", "integer_pimpl"); + } + + virtual void + traverse (SemanticGraph::Fundamental::NegativeInteger& t) + { + gen_typedef (t, "long long", + "negative_integer_pskel", "negative_integer_pimpl"); + } + + virtual void + traverse (SemanticGraph::Fundamental::NonPositiveInteger& t) + { + gen_typedef (t, "long long", + "non_positive_integer_pskel", + "non_positive_integer_pimpl"); + } + + virtual void + traverse (SemanticGraph::Fundamental::PositiveInteger& t) + { + gen_typedef (t, "unsigned long long", + "positive_integer_pskel", "positive_integer_pimpl"); + } + + virtual void + traverse (SemanticGraph::Fundamental::NonNegativeInteger& t) + { + gen_typedef (t, "unsigned long long", + "non_negative_integer_pskel", + "non_negative_integer_pimpl"); + } + + // Floats. + // + virtual void + traverse (SemanticGraph::Fundamental::Float& t) + { + gen_typedef (t, "float", "float_pskel", "float_pimpl"); + } + + virtual void + traverse (SemanticGraph::Fundamental::Double& t) + { + gen_typedef (t, "double", "double_pskel", "double_pimpl"); + } + + virtual void + traverse (SemanticGraph::Fundamental::Decimal& t) + { + gen_typedef (t, "double", "decimal_pskel", "decimal_pimpl"); + } + + // Strings. + // + virtual void + traverse (SemanticGraph::Fundamental::String& t) + { + gen_typedef (t, string_type_, "string_pskel", "string_pimpl"); + } + + virtual void + traverse (SemanticGraph::Fundamental::NormalizedString& t) + { + gen_typedef (t, string_type_, + "normalized_string_pskel", "normalized_string_pimpl"); + } + + virtual void + traverse (SemanticGraph::Fundamental::Token& t) + { + gen_typedef (t, string_type_, "token_pskel", "token_pimpl"); + } + + virtual void + traverse (SemanticGraph::Fundamental::NameToken& t) + { + nmtoken_ = gen_typedef (t, string_type_, + "nmtoken_pskel", "nmtoken_pimpl"); + } + + virtual void + traverse (SemanticGraph::Fundamental::NameTokens& t) + { + // NMTOKENS uses NMTOKEN implementation to parse individual items. + // As a result, we don't generate NMTOKENS if we didn't generate + // NMTOKEN. Here we assume NMTOKEN is handled before NMTOKENS. + // + if(nmtoken_) + gen_typedef (t, xs_ns_ + L"::string_sequence", + "nmtokens_pskel", "nmtokens_pimpl"); + } + + virtual void + traverse (SemanticGraph::Fundamental::Name& t) + { + gen_typedef (t, string_type_, "name_pskel", "name_pimpl"); + } + + virtual void + traverse (SemanticGraph::Fundamental::NCName& t) + { + gen_typedef (t, string_type_, "ncname_pskel", "ncname_pimpl"); + } + + virtual void + traverse (SemanticGraph::Fundamental::Language& t) + { + gen_typedef (t, string_type_, "language_pskel", "language_pimpl"); + } + + // Qualified name. + // + virtual void + traverse (SemanticGraph::Fundamental::QName& t) + { + gen_typedef (t, xs_ns_ + L"::qname", "qname_pskel", "qname_pimpl"); + } + + // ID/IDREF. + // + virtual void + traverse (SemanticGraph::Fundamental::Id& t) + { + gen_typedef (t, string_type_, "id_pskel", "id_pimpl"); + } + + virtual void + traverse (SemanticGraph::Fundamental::IdRef& t) + { + idref_ = gen_typedef (t, string_type_, "idref_pskel", "idref_pimpl"); + } + + virtual void + traverse (SemanticGraph::Fundamental::IdRefs& t) + { + // IDREFS uses IDREF implementation to parse individual items. + // As a result, we don't generate IDREFS if we didn't generate + // IDREF. Here we assume IDREF is handled before IDREFS. + // + if (idref_) + gen_typedef (t, xs_ns_ + L"::string_sequence", + "idrefs_pskel", "idrefs_pimpl"); + } + + // URI. + // + virtual void + traverse (SemanticGraph::Fundamental::AnyURI& t) + { + gen_typedef (t, string_type_, "uri_pskel", "uri_pimpl"); + } + + // Binary. + // + virtual void + traverse (SemanticGraph::Fundamental::Base64Binary& t) + { + String buffer (auto_ptr + L"< " + xs_ns_ + L"::buffer >"); + gen_typedef (t, buffer, + "base64_binary_pskel", "base64_binary_pimpl"); + } + + virtual void + traverse (SemanticGraph::Fundamental::HexBinary& t) + { + String buffer (auto_ptr + L"< " + xs_ns_ + L"::buffer >"); + gen_typedef (t, buffer, "hex_binary_pskel", "hex_binary_pimpl"); + } + + + // Date/time. + // + virtual void + traverse (SemanticGraph::Fundamental::Date& t) + { + gen_typedef (t, xs_ns_ + L"::date", "date_pskel", "date_pimpl"); + } + + virtual void + traverse (SemanticGraph::Fundamental::DateTime& t) + { + gen_typedef (t, xs_ns_ + L"::date_time", + "date_time_pskel", "date_time_pimpl"); + } + + virtual void + traverse (SemanticGraph::Fundamental::Duration& t) + { + gen_typedef (t, xs_ns_ + L"::duration", + "duration_pskel", "duration_pimpl"); + } + + virtual void + traverse (SemanticGraph::Fundamental::Day& t) + { + gen_typedef (t, xs_ns_ + L"::gday", "gday_pskel", "gday_pimpl"); + } + + virtual void + traverse (SemanticGraph::Fundamental::Month& t) + { + gen_typedef (t, xs_ns_ + L"::gmonth", + "gmonth_pskel", "gmonth_pimpl"); + } + + virtual void + traverse (SemanticGraph::Fundamental::MonthDay& t) + { + gen_typedef (t, xs_ns_ + L"::gmonth_day", + "gmonth_day_pskel", "gmonth_day_pimpl"); + } + + virtual void + traverse (SemanticGraph::Fundamental::Year& t) + { + gen_typedef (t, xs_ns_ + L"::gyear", "gyear_pskel", "gyear_pimpl"); + } + + virtual void + traverse (SemanticGraph::Fundamental::YearMonth& t) + { + gen_typedef (t, xs_ns_ + L"::gyear_month", + "gyear_month_pskel", "gyear_month_pimpl"); + } + + virtual void + traverse (SemanticGraph::Fundamental::Time& t) + { + gen_typedef (t, xs_ns_ + L"::time", "time_pskel", "time_pimpl"); + } + + // Entity. + // + virtual void + traverse (SemanticGraph::Fundamental::Entity&) + { + } + + virtual void + traverse (SemanticGraph::Fundamental::Entities&) + { + } + + private: + bool + gen_typedef (SemanticGraph::Type& t, + String const& type, + String const& pskel, + String const& pimpl) + { + if (ret_type (t) == type) + { + os << "typedef " << impl_ns_ << "::" << pskel << "< " << + char_type << " > " << ename (t) << ";"; + + String const& pimpl_name (t.context ().get ("impl")); + + os << "typedef " << impl_ns_ << "::" << pimpl << "< " << + char_type << " > " << pimpl_name << ";" + << endl; + + return true; + } + + return false; + } + + String xs_ns_; + String impl_ns_; + String string_type_; + + bool idref_; + bool nmtoken_; + }; + + struct FundNamespace: Namespace, Context + { + FundNamespace (Context& c) + : Namespace (c), Context (c) + { + } + + void + traverse (Type& ns) + { + pre (ns); + + String impl ("::xsd::cxx::parser::"); + impl += (validation ? L"validating" : L"non_validating"); + + String const c (char_type); + + os << "// Built-in XML Schema types mapping." << endl + << "//" << endl + << "typedef ::xsd::cxx::parser::string_sequence< " << c << + " > string_sequence;" + << "typedef ::xsd::cxx::parser::qname< " << c << " > qname;" + << "typedef ::xsd::cxx::parser::buffer buffer;" + << "typedef ::xsd::cxx::parser::time_zone time_zone;" + << "typedef ::xsd::cxx::parser::gday gday;" + << "typedef ::xsd::cxx::parser::gmonth gmonth;" + << "typedef ::xsd::cxx::parser::gyear gyear;" + << "typedef ::xsd::cxx::parser::gmonth_day gmonth_day;" + << "typedef ::xsd::cxx::parser::gyear_month gyear_month;" + << "typedef ::xsd::cxx::parser::date date;" + << "typedef ::xsd::cxx::parser::time time;" + << "typedef ::xsd::cxx::parser::date_time date_time;" + << "typedef ::xsd::cxx::parser::duration duration;" + << endl; + + os << "// Base parser skeletons." << endl + << "//" << endl + << "typedef ::xsd::cxx::parser::parser_base< " << c << + " > parser_base;" + << "typedef " << impl << "::empty_content< " << c << + " > empty_content;" + << "typedef " << impl << "::simple_content< " << c << + " > simple_content;" + << "typedef " << impl << "::complex_content< " << c << + " > complex_content;" + << "typedef " << impl << "::list_base< " << c << " > list_base;" + << endl; + + if (polymorphic) + { + os << "// Parser map interface and default implementation." << endl + << "//" << endl + << "typedef ::xsd::cxx::parser::parser_map< " << c << + " > parser_map;" + << "typedef ::xsd::cxx::parser::parser_map_impl< " << c << + " > parser_map_impl;" + << endl; + } + + os << "// Parser skeletons and implementations for the XML Schema" << endl + << "// built-in types." << endl + << "//" << endl; + + names (ns); + + os << "// Exceptions. See xsd/cxx/parser/exceptions.hxx " << + "for details." << endl + << "//" << endl + << "typedef ::xsd::cxx::parser::exception< " << + char_type << " > exception;" + << endl + << "// Parsing diagnostics." << endl + << "//" << endl + << "typedef ::xsd::cxx::parser::severity severity;" + << "typedef ::xsd::cxx::parser::error< " << c << " > error;" + << "typedef ::xsd::cxx::parser::diagnostics< " << c << + " > diagnostics;" + << "typedef ::xsd::cxx::parser::parsing< " << c << " > parsing;" + << endl; + + os << "// Error handler. See " << + "xsd/cxx/xml/error-handler.hxx for details." << endl + << "//" << endl + << "typedef ::xsd::cxx::xml::error_handler< " << c << + " > error_handler;" + << endl; + + os << "// Read-only string." << endl + << "//" << endl + << "typedef ::xsd::cxx::ro_string< " << c << " > ro_string;" + << endl; + + if (xml_parser == L"xerces") + { + os << "// Parsing flags. See " << + "xsd/cxx/parser/xerces/elements.hxx" << endl + << "// for details." << endl + << "//" << endl + << "typedef ::xsd::cxx::parser::xerces::flags flags;" + << endl; + + os << "// Parsing properties. See " << + "xsd/cxx/parser/xerces/elements.hxx" << endl + << "// for details." << endl + << "//" << endl + << "typedef ::xsd::cxx::parser::xerces::properties< " << c << + " > properties;" + << endl; + + os << "// Document type. See " << + "xsd/cxx/parser/xerces/elements.hxx" << endl + << "// for details." << endl + << "//" << endl + << "typedef ::xsd::cxx::parser::xerces::document< " << c << + " > document;" + << endl; + + } + else if (xml_parser == L"expat") + { + os << "// Document type. See " << + "xsd/cxx/parser/expat/elements.hxx" << endl + << "// for details." << endl + << "//" << endl + << "typedef ::xsd::cxx::parser::expat::document< " << c << + " > document;" + << endl; + } + + post (ns); + } + }; + } + + void + generate_parser_header (Context& ctx, bool generate_xml_schema) + { + String c (ctx.char_type); + + // + // + if (c == L"char") + { + ctx.os << "#ifndef XSD_USE_CHAR" << endl + << "#define XSD_USE_CHAR" << endl + << "#endif" << endl + << endl; + + ctx.os << "#ifndef XSD_CXX_PARSER_USE_CHAR" << endl + << "#define XSD_CXX_PARSER_USE_CHAR" << endl + << "#endif" << endl + << endl; + } + else if (c == L"wchar_t") + { + ctx.os << "#ifndef XSD_USE_WCHAR" << endl + << "#define XSD_USE_WCHAR" << endl + << "#endif" << endl + << endl; + + ctx.os << "#ifndef XSD_CXX_PARSER_USE_WCHAR" << endl + << "#define XSD_CXX_PARSER_USE_WCHAR" << endl + << "#endif" << endl + << endl; + } + + // + // + NarrowString extern_xml_schema; + + if (!generate_xml_schema) + extern_xml_schema = ctx.options.extern_xml_schema (); + + if (extern_xml_schema) + { + String name (ctx.hxx_expr->replace (extern_xml_schema)); + + ctx.os << "#include " << ctx.process_include_path (name) << endl + << endl; + + // Generate includes that came from the type map. + // + if (ctx.schema_root.context ().count ("includes")) + { + typedef set Includes; + + Includes const& is ( + ctx.schema_root.context ().get ("includes")); + + for (Includes::const_reverse_iterator i (is.rbegin ()); + i != is.rend (); ++i) + { + ctx.os << "#include " << *i << endl; + } + + ctx.os << endl; + } + } + else + { + if (ctx.char_type == L"char" && + ctx.xml_parser == L"xerces" && + ctx.char_encoding != L"custom") + { + ctx.os << "#include " << endl; + } + + ctx.os << "#include " << endl + << "#include " << endl + << "#include " << endl + << "#include " << endl; + + if (ctx.polymorphic) + ctx.os << "#include " << endl; + + if (ctx.validation) + ctx.os << "#include " << endl + << "#include " << endl + << "#include " << endl + << "#include " << endl; + else + ctx.os << "#include " << endl + << "#include " << endl + << "#include " << endl; + + ctx.os << "#include " << endl + << endl; + + // Generate includes that came from the type map. + // + if (ctx.schema_root.context ().count ("includes")) + { + typedef set Includes; + + Includes const& is ( + ctx.schema_root.context ().get ("includes")); + + for (Includes::const_reverse_iterator i (is.rbegin ()); + i != is.rend (); ++i) + { + ctx.os << "#include " << *i << endl; + } + + ctx.os << endl; + } + + // Generate fundamental types. + // + if (generate_xml_schema) + { + Traversal::Schema schema; + Traversal::Names names; + FundNamespace ns (ctx); + + schema >> names >> ns; + + Traversal::Names ns_names; + FundType type (ctx); + + ns >> ns_names >> type; + + schema.dispatch (ctx.schema_root); + } + else + { + Traversal::Schema schema, xsd; + Traversal::Implies implies; + Traversal::Names names; + FundNamespace ns (ctx); + + schema >> implies >> xsd >> names >> ns; + + Traversal::Names ns_names; + FundType type (ctx); + + ns >> ns_names >> type; + + schema.dispatch (ctx.schema_root); + } + } + + // Generate user type mapping. + // + if (!generate_xml_schema) + { + Traversal::Schema schema; + + Sources sources; + Includes includes (ctx, Includes::header); + Traversal::Names schema_names; + + Namespace ns (ctx); + Traversal::Names names; + + schema >> includes; + schema >> sources >> schema; + schema >> schema_names >> ns >> names; + + List list (ctx); + Union union_ (ctx); + Complex complex (ctx); + Enumeration enumeration (ctx); + + names >> list; + names >> union_; + names >> complex; + names >> enumeration; + + schema.dispatch (ctx.schema_root); + } + } + } +} diff --git a/xsd/cxx/parser/parser-header.hxx b/xsd/cxx/parser/parser-header.hxx new file mode 100644 index 0000000..642da40 --- /dev/null +++ b/xsd/cxx/parser/parser-header.hxx @@ -0,0 +1,18 @@ +// file : xsd/cxx/parser/parser-header.hxx +// license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +#ifndef XSD_CXX_PARSER_PARSER_HEADER_HXX +#define XSD_CXX_PARSER_PARSER_HEADER_HXX + +#include + +namespace CXX +{ + namespace Parser + { + void + generate_parser_header (Context&, bool generate_xml_schema); + } +} + +#endif // XSD_CXX_PARSER_PARSER_HEADER_HXX diff --git a/xsd/cxx/parser/parser-inline.cxx b/xsd/cxx/parser/parser-inline.cxx new file mode 100644 index 0000000..6705d5b --- /dev/null +++ b/xsd/cxx/parser/parser-inline.cxx @@ -0,0 +1,399 @@ +// file : xsd/cxx/parser/parser-inline.cxx +// license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +#include + +#include +#include + +namespace CXX +{ + namespace Parser + { + namespace + { + // + // + struct List: Traversal::List, Context + { + List (Context& c) + : Context (c) + { + } + + virtual void + traverse (Type& l) + { + String const& name (ename (l)); + SemanticGraph::Type& t (l.argumented ().type ()); + + String item (unclash (name, "item")); + + os << "// " << name << endl + << "//" << endl + << endl; + + // item_parser + // + os << inl + << "void " << name << "::" << endl + << unclash (name, "item_parser") << " (" << + fq_name (t) << "& " << item << ")" + << "{" + << "this->_xsd_" << item << "_ = &" << item << ";" + << "}"; + + // parsers + // + os << inl + << "void " << name << "::" << endl + << "parsers (" << fq_name (t) << "& " << item << ")" + << "{" + << "this->_xsd_" << item << "_ = &" << item << ";" + << "}"; + + // c-tor + // + os << inl + << name << "::" << endl + << name << " ()" << endl + << ": _xsd_" << item << "_ (0)" + << "{" + << "}"; + } + }; + + + // + // + struct ParserModifier: Traversal::Member, Context + { + ParserModifier (Context& c) + : Context (c) + { + } + + virtual void + traverse (Type& m) + { + if (skip (m)) + return; + + String const& scope (ename (m.scope ())); + String const& parser (eparser (m)); + + bool poly (polymorphic && + m.is_a () && + !anonymous (m.type ())); + + os << inl + << "void " << scope << "::" << endl + << parser << " (" << fq_name (m.type ()) << "& p)" + << "{" + << "this->" << emember (m) << " = &p;" + << "}"; + + if (poly) + { + os << inl + << "void " << scope << "::" << endl + << parser << " (const " << parser_map << "& m)" + << "{" + << "this->" << emember_map (m) << " = &m;" + << "}"; + } + } + }; + + + // + // + struct ParserMemberSet: Traversal::Member, Context + { + ParserMemberSet (Context& c) + : Context (c) + { + } + + virtual void + traverse (Type& m) + { + if (skip (m)) return; + + String const& name (ename (m)); + + os << "this->" << emember (m) << " = &" << name << ";"; + } + }; + + + // + // + struct ParserMemberInit: Traversal::Member, Context + { + ParserMemberInit (Context& c) + : Context (c), first_ (true) + { + } + + virtual void + traverse (Type& m) + { + if (skip (m)) return; + + if (first_) + first_ = false; + else + os << "," << endl << " "; + + os << emember (m) << " (0)"; + + if (polymorphic && + m.is_a () && + !anonymous (m.type ())) + { + os << "," << endl + << " " << emember_map (m) << " (0)"; + } + } + + bool + comma () const + { + return !first_; + } + + private: + bool first_; + }; + + struct ParserBaseSet: Traversal::Complex, + Traversal::List, + Context + { + ParserBaseSet (Context& c) + : Context (c), member_ (c) + { + inherits_ >> *this; + names_ >> member_; + } + + virtual void + traverse (SemanticGraph::Complex& c) + { + inherits (c, inherits_); + + if (!restriction_p (c)) + names (c, names_); + } + + virtual void + traverse (SemanticGraph::List& l) + { + String const& name (ename (l)); + String item (unclash (name, "item")); + + os << "this->_xsd_" << item << "_ = &" << name << "_item;"; + } + + private: + Traversal::Inherits inherits_; + + ParserMemberSet member_; + Traversal::Names names_; + }; + + struct Particle: Traversal::All, Context + { + Particle (Context& c) + : Context (c) + { + } + + virtual void + traverse (SemanticGraph::All& a) + { + if (!a.context().count ("comp-number")) + return; + + size_t state_count (a.context().get ("state-count")); + + os << "," << endl + << " v_all_count_ (" << state_count << "UL, v_all_first_)"; + } + }; + + // + // + struct Complex: Traversal::Complex, Context + { + Complex (Context& c) + : Context (c), + parser_modifier_ (c), + parser_base_set_ (c), + parser_member_set_ (c), + particle_ (c) + { + names_parser_modifier_ >> parser_modifier_; + inherits_parser_base_set_ >> parser_base_set_; + names_parser_member_set_ >> parser_member_set_; + } + + virtual void + traverse (Type& c) + { + bool he (has (c)); + bool ha (has (c)); + + bool hae (has_particle (c)); + + bool hra (false); // Has required attribute. + if (ha) + { + RequiredAttributeTest test (hra); + Traversal::Names names_test (test); + names (c, names_test); + } + + bool restriction (restriction_p (c)); + + if (!((!restriction && (he || ha)) || + (validation && (he || hae || hra)))) + return; + + String const& name (ename (c)); + + os << "// " << name << endl + << "//" << endl + << endl; + + if (!restriction && (he || ha)) + { + // _parser () + // + names (c, names_parser_modifier_); + + + // parsers () + // + + os << inl + << "void " << name << "::" << endl + << "parsers ("; + + { + ParserParamDecl decl (*this, true); + decl.traverse (c); + } + + os << ")" + << "{"; + + inherits (c, inherits_parser_base_set_); + names (c, names_parser_member_set_); + + os << "}"; + } + + // Default c-tor. + // + os << inl + << name << "::" << endl + << name << " ()" << endl + << ": "; + + bool comma (false); + + if (!restriction && (he || ha)) + { + ParserMemberInit member_init (*this); + Traversal::Names names_member_init (member_init); + + names (c, names_member_init); + + comma = member_init.comma (); + } + + if (validation && (he || hae)) + { + if (comma) + os << "," << endl << " "; + + os << "v_state_stack_ (sizeof (v_state_), &v_state_first_)"; + + particle_.dispatch (c.contains_compositor ().compositor ()); + + comma = true; + } + + if (validation && (hra)) + { + if (comma) + os << "," << endl << " "; + + os << "v_state_attr_stack_ (sizeof (v_state_attr_), " << + "&v_state_attr_first_)"; + } + + os << "{" + << "}"; + } + + private: + // + // + ParserModifier parser_modifier_; + Traversal::Names names_parser_modifier_; + + // + // + ParserBaseSet parser_base_set_; + Traversal::Inherits inherits_parser_base_set_; + + // + // + ParserMemberSet parser_member_set_; + Traversal::Names names_parser_member_set_; + + // + // + Particle particle_; + }; + } + + void + generate_parser_inline (Context& ctx) + { + // Emit "weak" header includes that are used in the file-per-type + // compilation model. + // + if (!ctx.options.generate_inline ()) + { + Traversal::Schema schema; + Includes includes (ctx, Includes::source); + + schema >> includes; + schema.dispatch (ctx.schema_root); + } + + Traversal::Schema schema; + + Sources sources; + Traversal::Names schema_names; + + Namespace ns (ctx); + Traversal::Names names; + + schema >> sources >> schema; + schema >> schema_names >> ns >> names; + + List list (ctx); + Complex complex (ctx); + + names >> list; + names >> complex; + + schema.dispatch (ctx.schema_root); + } + } +} diff --git a/xsd/cxx/parser/parser-inline.hxx b/xsd/cxx/parser/parser-inline.hxx new file mode 100644 index 0000000..aee0cdf --- /dev/null +++ b/xsd/cxx/parser/parser-inline.hxx @@ -0,0 +1,18 @@ +// file : xsd/cxx/parser/parser-inline.hxx +// license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +#ifndef XSD_CXX_PARSER_PARSER_INLINE_HXX +#define XSD_CXX_PARSER_PARSER_INLINE_HXX + +#include + +namespace CXX +{ + namespace Parser + { + void + generate_parser_inline (Context&); + } +} + +#endif // XSD_CXX_PARSER_PARSER_INLINE_HXX diff --git a/xsd/cxx/parser/parser-source.cxx b/xsd/cxx/parser/parser-source.cxx new file mode 100644 index 0000000..2887f96 --- /dev/null +++ b/xsd/cxx/parser/parser-source.cxx @@ -0,0 +1,957 @@ +// file : xsd/cxx/parser/parser-source.cxx +// license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +#include + +#include +#include + +namespace CXX +{ + namespace Parser + { + namespace + { + struct Enumeration: Traversal::Enumeration, Context + { + Enumeration (Context& c) + : Context (c) + { + } + + virtual void + traverse (Type& e) + { + String const& name (ename (e)); + String const& ret (ret_type (e)); + + SemanticGraph::Type& base (e.inherits ().base ()); + + bool same (ret == ret_type (base)); + + if (same || ret == L"void" || polymorphic) + { + os << "// " << name << endl + << "//" << endl + << endl; + } + + if (same || ret == L"void") + { + os << ret << " " << name << "::" << endl + << post_name (e) << " ()" + << "{"; + + if (same) + { + if (ret == L"void") + os << post_name (base) << " ();"; + else + os << "return " << post_name (base) << " ();"; + } + + os << "}"; + } + + if (polymorphic) + { + String id (e.name ()); + + if (String ns = xml_ns_name (e)) + { + id += L' '; + id += ns; + } + + os << "const " << char_type << "* " << name << "::" << endl + << "_static_type ()" + << "{" + << "return " << strlit (id) << ";" + << "}"; + + os << "const " << char_type << "* " << name << "::" << endl + << "_dynamic_type () const" + << "{" + << "return _static_type ();" + << "}"; + + if (validation) + { + bool gen (!anonymous (e)); + + // We normally don't need to enter anonymous types into + // the inheritance map. The only exception is when an + // anonymous types is defined inside an element that + // is a member of a substitution group. + // + if (!gen) + { + // The first instance that this anonymous type classifies + // is the prototype for others if any. If this type does + // not classify anything (e.g., it is a base), then we + // don't need to do anything. + // + if (e.classifies_begin () != e.classifies_end ()) + { + SemanticGraph::Instance& i ( + e.classifies_begin ()->instance ()); + + if (SemanticGraph::Element* e = + dynamic_cast (&i)) + { + if (e->substitutes_p ()) + gen = true; + } + } + } + + if (gen) + { + os << "static" << endl + << "const ::xsd::cxx::parser::validating::inheritance_map_entry< " << + char_type << " >" << endl + << "_xsd_" << name << "_inheritance_map_entry_ (" << endl + << name << "::_static_type ()," << endl + << fq_name (base) << "::_static_type ());" + << endl; + } + } + } + } + }; + + // + // + struct List: Traversal::List, Context + { + List (Context& c) + : Context (c) + { + } + + virtual void + traverse (Type& l) + { + String const& name (ename (l)); + SemanticGraph::Type& t (l.argumented ().type ()); + + String item (unclash (name, "item")); + + os << "// " << name << endl + << "//" << endl + << endl; + + // item + // + String const& arg (arg_type (t)); + + os << "void " << name << "::" << endl + << item; + + if (arg == L"void") + os << " ()"; + else + os << " (" << arg << ")"; + + os << "{" + << "}"; + + // post + // + if (ret_type (l) == L"void") + os << "void " << name << "::" << endl + << post_name (l) << " ()" + << "{" + << "}"; + + // parse_item + // + String inst (L"_xsd_" + item + L"_"); + String const& post (post_name (t)); + + os << "void " << name << "::" << endl + << "_xsd_parse_item (const " << string_type << "& v)" + << "{" + << "if (this->" << inst << ")" + << "{" + << "this->" << inst << "->pre ();" + << "this->" << inst << "->_pre_impl ();" + << "this->" << inst << "->_characters (v);" + << "this->" << inst << "->_post_impl ();"; + + if (ret_type (t) == L"void") + os << "this->" << inst << "->" << post << " ();" + << "this->" << item << " ();"; + else + os << "this->" << item << " (this->" << inst << "->" << + post << " ());"; + + os << "}" + << "}"; + + // + // + if (polymorphic) + { + String id (l.name ()); + + if (String ns = xml_ns_name (l)) + { + id += L' '; + id += ns; + } + + os << "const " << char_type << "* " << name << "::" << endl + << "_static_type ()" + << "{" + << "return " << strlit (id) << ";" + << "}"; + + os << "const " << char_type << "* " << name << "::" << endl + << "_dynamic_type () const" + << "{" + << "return _static_type ();" + << "}"; + } + } + }; + + // + // + struct Union: Traversal::Union, Context + { + Union (Context& c) + : Context (c) + { + } + + virtual void + traverse (Type& u) + { + String const& name (ename (u)); + String const& ret (ret_type (u)); + + if (ret == L"void" || polymorphic) + { + os << "// " << name << endl + << "//" << endl + << endl; + } + + if (ret == L"void") + { + os << "void " << name << "::" << endl + << post_name (u) << " ()" + << "{" + << "}"; + } + + if (polymorphic) + { + String id (u.name ()); + + if (String ns = xml_ns_name (u)) + { + id += L' '; + id += ns; + } + + os << "const " << char_type << "* " << name << "::" << endl + << "_static_type ()" + << "{" + << "return " << strlit (id) << ";" + << "}"; + + os << "const " << char_type << "* " << name << "::" << endl + << "_dynamic_type () const" + << "{" + << "return _static_type ();" + << "}"; + } + } + }; + + // + // + struct StartElement: Traversal::Element, Context + { + StartElement (Context& c) + : Context (c) + { + } + + virtual void + traverse (Type& e) + { + if (skip (e)) + return; + + bool poly (polymorphic && !anonymous (e.type ())); + + os << "if ("; + + if (poly && e.global_p ()) + os << "("; + + if (e.qualified_p () && e.namespace_ ().name ()) + { + os << "n == " << strlit (e.name ()) << " && " << + "ns == " << strlit (e.namespace_ ().name ()); + } + else + { + os << "n == " << strlit (e.name ()) << " && ns.empty ()"; + } + + // Only a globally-defined element can be a subst-group root. + // + if (poly && e.global_p ()) + { + os << ") ||" << endl + << "::xsd::cxx::parser::substitution_map_instance< " << + char_type << " > ().check (" << endl + << "ns, n, " << strlit (e.namespace_ ().name ()) << + ", " << strlit (e.name ()) << ", t)"; + } + + os << ")" + << "{"; + + String inst; + + if (poly) + { + SemanticGraph::Type& t (e.type ()); + inst = "p"; + + // For pre-computing length. + // + String type_id (t.name ()); + + if (String type_ns = xml_ns_name (t)) + { + type_id += L' '; + type_id += type_ns; + } + + String fq_type (fq_name (t)); + String const& member (emember (e)); + String const& member_map (emember_map (e)); + + os << fq_type << "* p = 0;" + << endl + << "if (t == 0 && this->" << member << " != 0)" << endl + << inst << " = this->" << member << ";" + << "else" + << "{" + << string_type << " ts (" << fq_type << + "::_static_type (), " << type_id.size () << "UL);" + << endl + << "if (t == 0)" << endl + << "t = &ts;" + << endl + << "if (this->" << member << " != 0 && *t == ts)" << endl + << inst << " = this->" << member << ";" + << "else if (this->" << member_map << " != 0)" << endl + << inst << " = dynamic_cast< " << fq_type << + "* > (" << endl + << "this->" << member_map << "->find (*t));" + << "}"; + } + else + inst = L"this->" + emember (e); + + os << "this->" << complex_base << "::context_.top ().parser_ = " << + inst << ";" + << endl + << "if (" << inst << ")" << endl + << inst << "->pre ();" // _start_element calls _pre + << endl + << "return true;" + << "}"; + } + }; + + + // + // + struct EndElement: Traversal::Element, Context + { + EndElement (Context& c) + : Context (c) + { + } + + virtual void + traverse (Type& e) + { + if (skip (e)) + return; + + bool poly (polymorphic && !anonymous (e.type ())); + String const& name (ename (e)); + + os << "if ("; + + if (poly && e.global_p ()) + os << "("; + + if (e.qualified_p () && e.namespace_ ().name ()) + { + os << "n == " << strlit (e.name ()) << " && " << + "ns == " << strlit (e.namespace_ ().name ()); + } + else + { + os << "n == " << strlit (e.name ()) << " && ns.empty ()"; + } + + // Only a globally-defined element can be a subst-group root. + // + if (poly && e.global_p ()) + { + os << ") ||" << endl + << "::xsd::cxx::parser::substitution_map_instance< " << + char_type << " > ().check (" << endl + << "ns, n, " << strlit (e.namespace_ ().name ()) << + ", " << strlit (e.name ()) << ")"; + } + + os << ")" + << "{"; + + // _end_element calls post + // + + SemanticGraph::Type& type (e.type ()); + String const& post (post_name (type)); + String inst; + + if (poly) + { + String const& fq_type (fq_name (type)); + inst = "p"; + + os << fq_type << "* p =" << endl + << "dynamic_cast< " << fq_type << "* > (" << endl + << "this->" << complex_base << "::context_.top ().parser_);" + << endl; + } + else + inst = L"this->" + emember (e); + + os << "if (" << inst << ")"; + + if (ret_type (type) == L"void") + os << "{" + << inst << "->" << post << " ();" + << "this->" << name << " ();" + << "}"; + else + os << endl + << "this->" << name << " (" << inst << "->" << post << " ());" + << endl; + + os << "return true;" + << "}"; + } + }; + + // + // + struct Attribute: Traversal::Attribute, Context + { + Attribute (Context& c) + : Context (c) + { + } + + virtual void + traverse (Type& a) + { + String const& name (ename (a)); + String const& inst (emember (a)); + + if (a.qualified_p () && a.namespace_ ().name ()) + { + os << "if (n == " << strlit (a.name ()) << " && " << + "ns == " << strlit (a.namespace_ ().name ()) << ")" + << "{"; + } + else + { + os << "if (n == " << strlit (a.name ()) << " && ns.empty ())" + << "{"; + } + + SemanticGraph::Type& type (a.type ()); + String const& post (post_name (type)); + String const& ret (ret_type (type)); + + os << "if (this->" << inst << ")" + << "{" + << "this->" << inst << "->pre ();" + << "this->" << inst << "->_pre_impl ();" + << "this->" << inst << "->_characters (v);" + << "this->" << inst << "->_post_impl ();"; + + if (ret == L"void") + os << "this->" << inst << "->" << post << " ();" + << "this->" << name << " ();"; + else + os << "this->" << name << " (this->" << inst << "->" << + post << " ());"; + + os << "}" + << "return true;" + << "}"; + } + }; + + // + // + struct ParserCallback: Traversal::Member, Context + { + ParserCallback (Context& c) + : Context (c) + { + } + + virtual void + traverse (Type& m) + { + if (skip (m)) + return; + + String const& arg (arg_type (m.type ())); + + os << "void " << ename (m.scope ()) << "::" << endl + << ename (m); + + if (arg == L"void") + os << " ()"; + else + os << " (" << arg << ")"; + + os << "{" + << "}"; + } + }; + + // + // + struct Complex: Traversal::Complex, Context + { + Complex (Context& c) + : Context (c), + parser_callback_ (c), + start_element_ (c), + end_element_ (c), + attribute_ (c) + { + names_parser_callback_ >> parser_callback_; + names_start_element_ >> start_element_; + names_end_element_ >> end_element_; + names_attribute_ >> attribute_; + } + + virtual void + traverse (Type& c) + { + bool he (has (c)); + bool ha (has (c)); + + String const& ret (ret_type (c)); + bool same (c.inherits_p () && + ret == ret_type (c.inherits ().base ())); + + String const& name (ename (c)); + + if ((he || ha || same || ret == L"void") || polymorphic) + { + os << "// " << name << endl + << "//" << endl + << endl; + } + + if (polymorphic) + { + String id (c.name ()); + + if (String ns = xml_ns_name (c)) + { + id += L' '; + id += ns; + } + + os << "const " << char_type << "* " << name << "::" << endl + << "_static_type ()" + << "{" + << "return " << strlit (id) << ";" + << "}"; + + os << "const " << char_type << "* " << name << "::" << endl + << "_dynamic_type () const" + << "{" + << "return _static_type ();" + << "}"; + + if (c.inherits_p () && validation) + { + bool gen (!anonymous (c)); + + // We normally don't need to enter anonymous types into + // the inheritance map. The only exception is when an + // anonymous types is defined inside an element that + // is a member of a substitution group. + // + if (!gen) + { + // The first instance that this anonymous type classifies + // is the prototype for others if any. If this type does + // not classify anything (e.g., it is a base), then we + // don't need to do anything. + // + if (c.classifies_begin () != c.classifies_end ()) + { + SemanticGraph::Instance& i ( + c.classifies_begin ()->instance ()); + + if (SemanticGraph::Element* e = + dynamic_cast (&i)) + { + if (e->substitutes_p ()) + gen = true; + } + } + } + + if (gen) + { + SemanticGraph::Type& base (c.inherits ().base ()); + + os << "static" << endl + << "const ::xsd::cxx::parser::validating::inheritance_map_entry< " << + char_type << " >" << endl + << "_xsd_" << name << "_inheritance_map_entry_ (" << endl + << name << "::_static_type ()," << endl + << fq_name (base) << "::_static_type ());" + << endl; + } + } + } + + if (!(he || ha || same || ret == L"void")) + return; + + // Parser callbacks. + // + if (!restriction_p (c)) + names (c, names_parser_callback_); + + if (same || ret == L"void") + { + os << ret << " " << name << "::" << endl + << post_name (c) << " ()" + << "{"; + + if (same) + { + SemanticGraph::Type& base (c.inherits ().base ()); + + if (ret == L"void") + os << post_name (base) << " ();"; + else + os << "return " << post_name (base) << " ();"; + } + + os << "}"; + } + + // The rest is parsing/validation code which is generated in + // *-validation-source.cxx. + // + if (validation) + return; + + // Don't use restriction_p here since we don't want special + // treatment of anyType. + // + bool restriction ( + c.inherits_p () && + c.inherits ().is_a ()); + + // _start_element_impl & _end_element_impl + // + if (he) + { + os << "bool " << name << "::" << endl + << "_start_element_impl (const " << string_type << "& ns," << endl + << "const " << string_type << "& n," << endl + << "const " << string_type << "* t)" + << "{" + << "XSD_UNUSED (t);" + << endl; + + if (!restriction) + { + os << "if (this->"; + + if (c.inherits_p ()) + os << fq_name (c.inherits ().base ()); + else + os << complex_base; + + os << "::_start_element_impl (ns, n, t))" << endl + << "return true;" + << endl; + } + + names (c, names_start_element_); + + os << "return false;" + << "}"; + + + // _end_element_impl + // + os << "bool " << name << "::" << endl + << "_end_element_impl (const " << string_type << "& ns," << endl + << "const " << string_type << "& n)" + << "{"; + + if (!restriction) + { + os << "if (this->"; + + if (c.inherits_p () && !restriction) + os << fq_name (c.inherits ().base ()); + else + os << complex_base; + + os << "::_end_element_impl (ns, n))" << endl + << "return true;" + << endl; + } + + names (c, names_end_element_); + + os << "return false;" + << "}"; + } + + + if (ha) + { + // _attribute_impl + // + os << "bool " << name << "::" << endl + << "_attribute_impl (const " << string_type << "& ns," << endl + << "const " << string_type << "& n," << endl + << "const " << string_type << "& v)" + << "{"; + + if (!restriction) + { + os << "if (this->"; + + if (c.inherits_p ()) + os << fq_name (c.inherits ().base ()); + else + os << complex_base; + + os << "::_attribute_impl (ns, n, v))" << endl + << "return true;" + << endl; + } + + names (c, names_attribute_); + + os << "return false;" + << "}"; + } + } + + private: + // + // + ParserCallback parser_callback_; + Traversal::Names names_parser_callback_; + + // + // + StartElement start_element_; + Traversal::Names names_start_element_; + + // + // + EndElement end_element_; + Traversal::Names names_end_element_; + + // + // + Attribute attribute_; + Traversal::Names names_attribute_; + }; + + + // Generate substitution group map entries. + // + struct GlobalElement: Traversal::Element, Context + { + GlobalElement (Context& c) + : Context (c) + { + } + + virtual void + traverse (Type& e) + { + if (e.substitutes_p ()) + { + String name (escape (e.name ())); + Type& r (e.substitutes ().root ()); + + SemanticGraph::Type& type (e.type ()); + + os << "// Substitution map entry for " << comment (e.name ()) << "." << endl + << "//" << endl + << "static" << endl + << "const ::xsd::cxx::parser::substitution_map_entry< " << + char_type << " >" << endl + << "_xsd_" << name << "_substitution_map_entry_ (" << endl + << strlit (e.namespace_ ().name ()) << "," << endl + << strlit (e.name ()) << "," << endl + << strlit (r.namespace_ ().name ()) << "," << endl + << strlit (r.name ()) << "," << endl + << fq_name (type) << "::_static_type ());" + << endl; + } + } + }; + } + + void + generate_parser_source (Context& ctx) + { + if (ctx.polymorphic) + { + ctx.os << "#include " << endl; + + if (ctx.validation) + ctx.os << "#include " << endl + << endl; + else + ctx.os << endl; + + bool import_maps (ctx.options.import_maps ()); + bool export_maps (ctx.options.export_maps ()); + + if (import_maps || export_maps) + { + ctx.os << "#ifndef XSD_NO_EXPORT" << endl + << endl + << "namespace xsd" + << "{" + << "namespace cxx" + << "{" + << "namespace parser" + << "{" + << "#ifdef _MSC_VER" << endl; + + if (export_maps) + ctx.os << "template struct __declspec (dllexport) " << + "substitution_map_init< " << ctx.char_type << " >;"; + + if (import_maps) + ctx.os << "template struct __declspec (dllimport) " << + "substitution_map_init< " << ctx.char_type << " >;"; + + if (ctx.validation && export_maps) + ctx.os << "template struct __declspec (dllexport) " << + "inheritance_map_init< " << ctx.char_type << " >;"; + + if (ctx.validation && import_maps) + ctx.os << "template struct __declspec (dllimport) " << + "inheritance_map_init< " << ctx.char_type << " >;"; + + ctx.os << "#elif defined(__GNUC__) && __GNUC__ >= 4" << endl + << "template struct __attribute__ ((visibility(\"default\"))) " << + "substitution_map_init< " << ctx.char_type << " >;"; + + if (ctx.validation) + ctx.os << "template struct __attribute__ ((visibility(\"default\"))) " << + "inheritance_map_init< " << ctx.char_type << " >;"; + + ctx.os << "#elif defined(XSD_MAP_VISIBILITY)" << endl + << "template struct XSD_MAP_VISIBILITY " << + "substitution_map_init< " << ctx.char_type << " >;"; + + if (ctx.validation) + ctx.os << "template struct XSD_MAP_VISIBILITY " << + "inheritance_map_init< " << ctx.char_type << " >;"; + + ctx.os << "#endif" << endl + << "}" // parser + << "}" // cxx + << "}" // xsd + << "#endif // XSD_NO_EXPORT" << endl + << endl; + } + + ctx.os << "static" << endl + << "const ::xsd::cxx::parser::substitution_map_init< " << + ctx.char_type << " >" << endl + << "_xsd_substitution_map_init_;" + << endl; + + if (ctx.validation) + { + ctx.os << "static" << endl + << "const ::xsd::cxx::parser::validating::inheritance_map_init< " << + ctx.char_type << " >" << endl + << "_xsd_inheritance_map_init_;" + << endl; + } + } + + // Emit "weak" header includes that are used in the file-per-type + // compilation model. + // + if (ctx.options.generate_inline ()) + { + Traversal::Schema schema; + Includes includes (ctx, Includes::source); + + schema >> includes; + schema.dispatch (ctx.schema_root); + } + + Traversal::Schema schema; + Sources sources; + Traversal::Names schema_names; + + Namespace ns (ctx); + Traversal::Names names; + + schema >> sources >> schema; + schema >> schema_names >> ns >> names; + + List list (ctx); + Union union_ (ctx); + Complex complex (ctx); + Enumeration enumeration (ctx); + GlobalElement global_element (ctx); + + names >> list; + names >> union_; + names >> complex; + names >> enumeration; + + if (ctx.polymorphic) + names >> global_element; + + schema.dispatch (ctx.schema_root); + } + } +} diff --git a/xsd/cxx/parser/parser-source.hxx b/xsd/cxx/parser/parser-source.hxx new file mode 100644 index 0000000..3598a00 --- /dev/null +++ b/xsd/cxx/parser/parser-source.hxx @@ -0,0 +1,18 @@ +// file : xsd/cxx/parser/parser-source.hxx +// license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +#ifndef XSD_CXX_PARSER_PARSER_SOURCE_HXX +#define XSD_CXX_PARSER_PARSER_SOURCE_HXX + +#include + +namespace CXX +{ + namespace Parser + { + void + generate_parser_source (Context&); + } +} + +#endif // XSD_CXX_PARSER_PARSER_SOURCE_HXX diff --git a/xsd/cxx/parser/print-impl-common.hxx b/xsd/cxx/parser/print-impl-common.hxx new file mode 100644 index 0000000..14bfbc2 --- /dev/null +++ b/xsd/cxx/parser/print-impl-common.hxx @@ -0,0 +1,641 @@ +// file : xsd/cxx/parser/print-impl-common.hxx +// license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +#ifndef XSD_CXX_PARSER_PRINT_IMPL_COMMON_HXX +#define XSD_CXX_PARSER_PRINT_IMPL_COMMON_HXX + +#include +#include + +#include + +namespace CXX +{ + namespace Parser + { + struct PrintCall: Traversal::Type, + + Traversal::Fundamental::Boolean, + + Traversal::Fundamental::Byte, + Traversal::Fundamental::UnsignedByte, + Traversal::Fundamental::Short, + Traversal::Fundamental::UnsignedShort, + Traversal::Fundamental::Int, + Traversal::Fundamental::UnsignedInt, + Traversal::Fundamental::Long, + Traversal::Fundamental::UnsignedLong, + Traversal::Fundamental::Integer, + Traversal::Fundamental::NonPositiveInteger, + Traversal::Fundamental::NonNegativeInteger, + Traversal::Fundamental::PositiveInteger, + Traversal::Fundamental::NegativeInteger, + + Traversal::Fundamental::Float, + Traversal::Fundamental::Double, + Traversal::Fundamental::Decimal, + + Traversal::Fundamental::String, + Traversal::Fundamental::NormalizedString, + Traversal::Fundamental::Token, + Traversal::Fundamental::Name, + Traversal::Fundamental::NameToken, + Traversal::Fundamental::NameTokens, + Traversal::Fundamental::NCName, + Traversal::Fundamental::Language, + + Traversal::Fundamental::QName, + + Traversal::Fundamental::Id, + Traversal::Fundamental::IdRef, + Traversal::Fundamental::IdRefs, + + Traversal::Fundamental::AnyURI, + + Traversal::Fundamental::Base64Binary, + Traversal::Fundamental::HexBinary, + + Traversal::Fundamental::Date, + Traversal::Fundamental::DateTime, + Traversal::Fundamental::Duration, + Traversal::Fundamental::Day, + Traversal::Fundamental::Month, + Traversal::Fundamental::MonthDay, + Traversal::Fundamental::Year, + Traversal::Fundamental::YearMonth, + Traversal::Fundamental::Time, + + Context + { + PrintCall (Context& c, String const& tag, String const& arg) + : Context (c), tag_ (tag), arg_ (arg) + { + } + + virtual void + traverse (SemanticGraph::Type&) + { + gen_user_type (); + } + + // Boolean. + // + virtual void + traverse (SemanticGraph::Fundamental::Boolean& t) + { + if (default_type (t, "bool")) + { + os << cout_inst << " << " << strlit (tag_ + L": ") << " << " << + arg_ << " << std::endl;"; + } + else + gen_user_type (); + } + + // Integral types. + // + virtual void + traverse (SemanticGraph::Fundamental::Byte& t) + { + if (default_type (t, "signed char")) + { + os << cout_inst << " << " << strlit (tag_ + L": ") << + " << static_cast (" << arg_ << ") << std::endl;"; + } + else + gen_user_type (); + } + + virtual void + traverse (SemanticGraph::Fundamental::UnsignedByte& t) + { + if (default_type (t, "unsigned char")) + { + os << cout_inst << " << " << strlit (tag_ + L": ") << + " << static_cast (" << arg_ << ") << std::endl;"; + } + else + gen_user_type (); + } + + virtual void + traverse (SemanticGraph::Fundamental::Short& t) + { + if (default_type (t, "short")) + { + os << cout_inst << " << " << strlit (tag_ + L": ") << " << " << + arg_ << " << std::endl;"; + } + else + gen_user_type (); + } + + virtual void + traverse (SemanticGraph::Fundamental::UnsignedShort& t) + { + if (default_type (t, "unsigned short")) + { + os << cout_inst << " << " << strlit (tag_ + L": ") << " << " << + arg_ << " << std::endl;"; + } + else + gen_user_type (); + } + + virtual void + traverse (SemanticGraph::Fundamental::Int& t) + { + if (default_type (t, "int")) + { + os << cout_inst << " << " << strlit (tag_ + L": ") << " << " << + arg_ << " << std::endl;"; + } + else + gen_user_type (); + } + + virtual void + traverse (SemanticGraph::Fundamental::UnsignedInt& t) + { + if (default_type (t, "unsigned int")) + { + os << cout_inst << " << " << strlit (tag_ + L": ") << " << " << + arg_ << " << std::endl;"; + } + else + gen_user_type (); + } + + virtual void + traverse (SemanticGraph::Fundamental::Long& t) + { + if (default_type (t, "long long")) + { + os << cout_inst << " << " << strlit (tag_ + L": ") << " << " << + arg_ << " << std::endl;"; + } + else + gen_user_type (); + } + + virtual void + traverse (SemanticGraph::Fundamental::UnsignedLong& t) + { + if (default_type (t, "unsigned long long")) + { + os << cout_inst << " << " << strlit (tag_ + L": ") << " << " << + arg_ << " << std::endl;"; + } + else + gen_user_type (); + } + + virtual void + traverse (SemanticGraph::Fundamental::Integer& t) + { + if (default_type (t, "long long")) + { + os << cout_inst << " << " << strlit (tag_ + L": ") << " << " << + arg_ << " << std::endl;"; + } + else + gen_user_type (); + } + + virtual void + traverse (SemanticGraph::Fundamental::NegativeInteger& t) + { + if (default_type (t, "long long")) + { + os << cout_inst << " << " << strlit (tag_ + L": ") << " << " << + arg_ << " << std::endl;"; + } + else + gen_user_type (); + } + + virtual void + traverse (SemanticGraph::Fundamental::NonPositiveInteger& t) + { + if (default_type (t, "long long")) + { + os << cout_inst << " << " << strlit (tag_ + L": ") << " << " << + arg_ << " << std::endl;"; + } + else + gen_user_type (); + } + + virtual void + traverse (SemanticGraph::Fundamental::PositiveInteger& t) + { + if (default_type (t, "unsigned long long")) + { + os << cout_inst << " << " << strlit (tag_ + L": ") << " << " << + arg_ << " << std::endl;"; + } + else + gen_user_type (); + } + + virtual void + traverse (SemanticGraph::Fundamental::NonNegativeInteger& t) + { + if (default_type (t, "unsigned long long")) + { + os << cout_inst << " << " << strlit (tag_ + L": ") << " << " << + arg_ << " << std::endl;"; + } + else + gen_user_type (); + } + + // Floats. + // + virtual void + traverse (SemanticGraph::Fundamental::Float& t) + { + if (default_type (t, "float")) + { + os << cout_inst << " << " << strlit (tag_ + L": ") << " << " << + arg_ << " << std::endl;"; + } + else + gen_user_type (); + } + + virtual void + traverse (SemanticGraph::Fundamental::Double& t) + { + if (default_type (t, "double")) + { + os << cout_inst << " << " << strlit (tag_ + L": ") << " << " << + arg_ << " << std::endl;"; + } + else + gen_user_type (); + } + + virtual void + traverse (SemanticGraph::Fundamental::Decimal& t) + { + if (default_type (t, "double")) + { + os << cout_inst << " << " << strlit (tag_ + L": ") << " << " << + arg_ << " << std::endl;"; + } + else + gen_user_type (); + } + + // Strings. + // + virtual void + traverse (SemanticGraph::Fundamental::String& t) + { + gen_string (t); + } + + virtual void + traverse (SemanticGraph::Fundamental::NormalizedString& t) + { + gen_string (t); + } + + virtual void + traverse (SemanticGraph::Fundamental::Token& t) + { + gen_string (t); + } + + virtual void + traverse (SemanticGraph::Fundamental::NameToken& t) + { + gen_string (t); + } + + virtual void + traverse (SemanticGraph::Fundamental::Name& t) + { + gen_string (t); + } + + virtual void + traverse (SemanticGraph::Fundamental::NCName& t) + { + gen_string (t); + } + + virtual void + traverse (SemanticGraph::Fundamental::Language& t) + { + gen_string (t); + } + + virtual void + traverse (SemanticGraph::Fundamental::Id& t) + { + gen_string (t); + } + + virtual void + traverse (SemanticGraph::Fundamental::IdRef& t) + { + gen_string (t); + } + + virtual void + traverse (SemanticGraph::Fundamental::AnyURI& t) + { + gen_string (t); + } + + // String sequences. + // + + virtual void + traverse (SemanticGraph::Fundamental::NameTokens& t) + { + gen_sequence (t); + } + + virtual void + traverse (SemanticGraph::Fundamental::IdRefs& t) + { + gen_sequence (t); + } + + // QName + // + + virtual void + traverse (SemanticGraph::Fundamental::QName& t) + { + if (default_type (t, xs_ns_name () + L"::qname")) + { + os << cout_inst << " << " << strlit (tag_ + L": ") << ";" + << endl + << "if (" << arg_ << ".prefix ().empty ())" << endl + << cout_inst << " << " << arg_ << ".name ();" + << "else" << endl + << cout_inst << " << " << arg_ << ".prefix () << " << L << + "':' << " << arg_ << ".name ();" + << endl + << cout_inst << " << std::endl;"; + } + else + gen_user_type (); + } + + // Binary. + // + virtual void + traverse (SemanticGraph::Fundamental::Base64Binary& t) + { + gen_buffer (t); + } + + virtual void + traverse (SemanticGraph::Fundamental::HexBinary& t) + { + gen_buffer (t); + } + + // Date/time. + // + virtual void + traverse (SemanticGraph::Fundamental::Date& t) + { + if (default_type (t, xs_ns_name () + L"::date")) + { + os << cout_inst << " << " << strlit (tag_ + L": ") << endl + << " << " << arg_ << ".year () << '-'" << endl + << " << " << arg_ << ".month () << '-'" << endl + << " << " << arg_ << ".day ();"; + + gen_time_zone (); + } + else + gen_user_type (); + } + + virtual void + traverse (SemanticGraph::Fundamental::DateTime& t) + { + if (default_type (t, xs_ns_name () + L"::date_time")) + { + os << cout_inst << " << " << strlit (tag_ + L": ") << endl + << " << " << arg_ << ".year () << '-'" << endl + << " << " << arg_ << ".month () << '-'" << endl + << " << " << arg_ << ".day () << 'T'" << endl + << " << " << arg_ << ".hours () << ':'" << endl + << " << " << arg_ << ".minutes () << ':'" << endl + << " << " << arg_ << ".seconds ();"; + + gen_time_zone (); + } + else + gen_user_type (); + } + + virtual void + traverse (SemanticGraph::Fundamental::Duration& t) + { + if (default_type (t, xs_ns_name () + L"::duration")) + { + os << cout_inst << " << " << strlit (tag_ + L": ") << ";" + << endl + << "if (" << arg_ << ".negative ())" << endl + << cout_inst << " << '-';" + << endl + << cout_inst << " << 'P'" << endl + << " << " << arg_ << ".years () << 'Y'" << endl + << " << " << arg_ << ".months () << 'M'" << endl + << " << " << arg_ << ".days () << " << L << "\"DT\"" << endl + << " << " << arg_ << ".hours () << 'H'" << endl + << " << " << arg_ << ".minutes () << 'M'" << endl + << " << " << arg_ << ".seconds () << 'S'" + << " << std::endl;"; + } + else + gen_user_type (); + } + + virtual void + traverse (SemanticGraph::Fundamental::Day& t) + { + if (default_type (t, xs_ns_name () + L"::gday")) + { + os << cout_inst << " << " << strlit (tag_ + L": ---") << + " << " << arg_ << ".day ();"; + + gen_time_zone (); + } + else + gen_user_type (); + } + + virtual void + traverse (SemanticGraph::Fundamental::Month& t) + { + if (default_type (t, xs_ns_name () + L"::gmonth")) + { + os << cout_inst << " << " << strlit (tag_ + L": --") << + " << " << arg_ << ".month ();"; + + gen_time_zone (); + } + else + gen_user_type (); + } + + virtual void + traverse (SemanticGraph::Fundamental::MonthDay& t) + { + if (default_type (t, xs_ns_name () + L"::gmonth_day")) + { + os << cout_inst << " << " << strlit (tag_ + L": --") << endl + << " << " << arg_ << ".month () << '-'" << endl + << " << " << arg_ << ".day ();"; + + gen_time_zone (); + } + else + gen_user_type (); + } + + virtual void + traverse (SemanticGraph::Fundamental::Year& t) + { + if (default_type (t, xs_ns_name () + L"::gyear")) + { + os << cout_inst << " << " << strlit (tag_ + L": ") << " << " << + arg_ << ".year ();"; + + gen_time_zone (); + } + else + gen_user_type (); + } + + virtual void + traverse (SemanticGraph::Fundamental::YearMonth& t) + { + if (default_type (t, xs_ns_name () + L"::gyear_month")) + { + os << cout_inst << " << " << strlit (tag_ + L": ") << endl + << " << " << arg_ << ".year () << '-'" << endl + << " << " << arg_ << ".month ();"; + + gen_time_zone (); + } + else + gen_user_type (); + } + + virtual void + traverse (SemanticGraph::Fundamental::Time& t) + { + if (default_type (t, xs_ns_name () + L"::time")) + { + os << cout_inst << " << " << strlit (tag_ + L": ") << endl + << " << " << arg_ << ".hours () << ':'" << endl + << " << " << arg_ << ".minutes () << ':'" << endl + << " << " << arg_ << ".seconds ();"; + + gen_time_zone (); + } + else + gen_user_type (); + } + + private: + bool + default_type (SemanticGraph::Type& t, String const& def_type) + { + return ret_type (t) == def_type; + } + + void + gen_user_type () + { + os << "// TODO" << endl + << "//" << endl; + } + + void + gen_string (SemanticGraph::Type& t) + { + if ((char_type == L"char" && default_type (t, "::std::string")) || + (char_type == L"wchar_t" && default_type (t, "::std::wstring"))) + { + os << cout_inst << " << " << strlit (tag_ + L": ") << " << " << + arg_ << " << std::endl;"; + } + else + gen_user_type (); + } + + void + gen_sequence (SemanticGraph::Type& t) + { + String type (xs_ns_name () + L"::string_sequence"); + + if (default_type (t, type)) + { + os << cout_inst << " << " << strlit (tag_ + L": ") << ";" + << endl; + + os << "for (" << type << "::const_iterator i (" << arg_ << + ".begin ()), e (" << arg_ << ".end ());" << endl + << "i != e;)" + << "{" + << cout_inst << " << *i++;" + << "if (i != e)" << endl + << cout_inst << " << ' ';" + << "}" + << cout_inst << " << std::endl;"; + } + else + gen_user_type (); + } + + void + gen_buffer (SemanticGraph::Type& t) + { + String type (auto_ptr + L"< " + xs_ns_name () + L"::buffer >"); + + if (default_type (t, type)) + { + os << cout_inst << " << " << strlit (tag_ + L": ") << " << " + << arg_ << "->size () << " << L << "\" bytes\" << std::endl;"; + } + else + gen_user_type (); + } + + void + gen_time_zone () + { + os << endl + << "if (" << arg_ << ".zone_present ())" + << "{" + << "if (" << arg_ << ".zone_hours () < 0)" << endl + << cout_inst << " << " << arg_ << ".zone_hours () << ':' << -" << + arg_ << ".zone_minutes ();" + << "else" << endl + << cout_inst << " << '+' << " << arg_ << ".zone_hours () << " << + "':' << " << arg_ << ".zone_minutes ();"; + + os << "}" + << cout_inst << " << std::endl;"; + } + + private: + String tag_; + String arg_; + }; + } +} + +#endif // XSD_CXX_PARSER_PRINT_IMPL_COMMON_HXX diff --git a/xsd/cxx/parser/state-processor.cxx b/xsd/cxx/parser/state-processor.cxx new file mode 100644 index 0000000..a2b8fbf --- /dev/null +++ b/xsd/cxx/parser/state-processor.cxx @@ -0,0 +1,319 @@ +// file : xsd/cxx/parser/state-processor.cxx +// license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +#include +#include + +#include + +#include + +#include +#include + +using namespace std; + +namespace CXX +{ + namespace Parser + { + namespace + { + typedef vector Particles; + + /* + void + print (Particles const& p) + { + using std::wcerr; + using std::endl; + + wcerr << "prefixes: " << endl; + + for (Particles::const_iterator i (p.begin ()); i != p.end (); ++i) + { + if (SemanticGraph::Element* e = + dynamic_cast (*i)) + { + wcerr << e->name () << endl; + } + else + { + wcerr << "" << endl; + } + } + + wcerr << endl; + } + */ + + // + // + struct Particle: Traversal::All, + Traversal::Choice, + Traversal::Sequence + { + Particle (size_t& all, + size_t& choice, + size_t& sequence, + size_t& depth) + : all_ (all), + choice_ (choice), + sequence_ (sequence), + depth_ (depth) + { + } + + virtual void + traverse (SemanticGraph::All& a) + { + using SemanticGraph::Compositor; + + // Go over particles, collecting "prefix" particles in prefixes_, + // assigning state numbers and calculating effective minOccurs. + // If all prefixes of this compositor have minOccurs = 0, then + // the compositor itself effectively has minOccurs = 0 regardless + // of the actual value specified in the schema. + // + // Note that we don't need to care about depth since the 'all' + // compositor cannot contain any nested compositors. + // + + size_t state (0); + size_t min (0); + + for (Compositor::ContainsIterator ci (a.contains_begin ()); + ci != a.contains_end (); ++ci) + { + SemanticGraph::Particle& p (ci->particle ()); + + // The 'all' compositor can only include elements. + // + prefixes_.push_back (&p); + + if (min == 0 && ci->min () != 0) + min = 1; + + p.context ().set ("prefix", true); + p.context ().set ("state", state++); + } + + if (!prefixes_.empty ()) + { + a.context ().set ("comp-number", choice_++); + a.context ().set ("prefixes", prefixes_); + a.context ().set ("state-count", size_t (prefixes_.size ())); + + // effective-min = min * actual-min + // + if (min == 1) + min = a.min (); + + a.context ().set ("effective-min", min); + + // print (prefixes_); + } + } + + virtual void + traverse (SemanticGraph::Choice& c) + { + using SemanticGraph::Compositor; + + // Go over particles, collecting "prefix" particles in prefixes_, + // assigning state numbers and calculating effective minOccurs. + // If any prefix of this compositor have minOccurs = 0, then the + // compositor itself effectively has minOccurs = 0 regardless of + // the actual value specified in the schema. + // + + size_t state (0); + size_t min (1); + + for (Compositor::ContainsIterator ci (c.contains_begin ()); + ci != c.contains_end (); ++ci) + { + SemanticGraph::Particle& p (ci->particle ()); + + if (p.is_a () || + p.is_a ()) + { + prefixes_.push_back (&p); + + if (min == 1 && ci->min () == 0) + min = 0; + } + else + { + size_t depth (0); + Particle t (all_, choice_, sequence_, depth); + t.dispatch (p); + + if (t.prefixes_.empty ()) + continue; // Skip empty compositors. + + if (++depth > depth_) // One for this compositor. + depth_ = depth; + + prefixes_.insert (prefixes_.end (), + t.prefixes_.begin (), + t.prefixes_.end ()); + + if (min == 1 && + p.context ().get ("effective-min") == 0) + min = 0; + } + + p.context ().set ("prefix", true); + p.context ().set ("state", state++); + } + + if (!prefixes_.empty ()) + { + c.context ().set ("comp-number", choice_++); + c.context ().set ("prefixes", prefixes_); + + // effective-min = min * actual-min + // + if (min == 1) + min = c.min (); + + c.context ().set ("effective-min", min); + + // print (prefixes_); + } + } + + virtual void + traverse (SemanticGraph::Sequence& s) + { + using SemanticGraph::Compositor; + + // Go over particles, collecting "prefix" particles in prefixes_, + // assigning state numbers and calculating effective minOccurs. + // If all prefixes of this compositor have minOccurs = 0, then + // the compositor itself effectively has minOccurs = 0 regardless + // of the actual value specified in the schema. + // + + bool prefix (true); + size_t state (0); + size_t min (0); + + for (Compositor::ContainsIterator ci (s.contains_begin ()); + ci != s.contains_end (); ++ci) + { + SemanticGraph::Particle& p (ci->particle ()); + + if (p.is_a () || + p.is_a ()) + { + if (prefix) + { + prefixes_.push_back (&p); + + if (ci->min () != 0) + min = 1; + } + } + else + { + size_t depth (0); + Particle t (all_, choice_, sequence_, depth); + t.dispatch (p); + + if (t.prefixes_.empty ()) + continue; // Skip empty compositors. + + if (++depth > depth_) // One for this compositor. + depth_ = depth; + + if (prefix) + { + prefixes_.insert (prefixes_.end (), + t.prefixes_.begin (), + t.prefixes_.end ()); + + if (p.context ().get ("effective-min") != 0) + min = 1; + } + } + + p.context ().set ("state", state++); + + if (prefix) + p.context ().set ("prefix", true); + + if (prefix && min != 0) + prefix = false; + } + + if (!prefixes_.empty ()) + { + s.context ().set ("comp-number", sequence_++); + s.context ().set ("prefixes", prefixes_); + + // effective-min = min * actual-min + // + if (min == 1) + min = s.min (); + + s.context ().set ("effective-min", min); + + // print (prefixes_); + } + } + + private: + Particles prefixes_; + + size_t& all_; + size_t& choice_; + size_t& sequence_; + + size_t& depth_; + }; + + + // + // + struct Complex: Traversal::Complex + { + virtual void + traverse (Type& c) + { + if (c.contains_compositor_p ()) + { + size_t all (0), choice (0), sequence (0), depth (0); + Particle t (all, choice, sequence, depth); + t.dispatch (c.contains_compositor ().compositor ()); + + // Set the maximum stack depth for this type. Used to + // allocate fixed-size state stack. + // + c.context ().set ("depth", depth + 1); + } + } + }; + } + + void StateProcessor:: + process (SemanticGraph::Schema& tu, SemanticGraph::Path const&) + { + Traversal::Schema schema; + Sources sources; + Traversal::Names schema_names; + Traversal::Namespace ns; + Traversal::Names ns_names; + + schema >> sources >> schema; + schema >> schema_names >> ns >> ns_names; + + Complex complex_type; + + ns_names >> complex_type; + + schema.dispatch (tu); + } + } +} diff --git a/xsd/cxx/parser/state-processor.hxx b/xsd/cxx/parser/state-processor.hxx new file mode 100644 index 0000000..eacc14a --- /dev/null +++ b/xsd/cxx/parser/state-processor.hxx @@ -0,0 +1,25 @@ +// file : xsd/cxx/parser/state-processor.hxx +// license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +#ifndef XSD_CXX_PARSER_STATE_PROCESSOR_HXX +#define XSD_CXX_PARSER_STATE_PROCESSOR_HXX + +#include + +#include + +namespace CXX +{ + namespace Parser + { + class StateProcessor + { + public: + void + process (XSDFrontend::SemanticGraph::Schema&, + XSDFrontend::SemanticGraph::Path const& file); + }; + } +} + +#endif // XSD_CXX_PARSER_STATE_PROCESSOR_HXX diff --git a/xsd/cxx/parser/type-processor.cxx b/xsd/cxx/parser/type-processor.cxx new file mode 100644 index 0000000..6496b2a --- /dev/null +++ b/xsd/cxx/parser/type-processor.cxx @@ -0,0 +1,347 @@ +// file : xsd/cxx/parser/type-processor.cxx +// license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +#include + +#include +#include + +#include +#include + +using namespace std; + +namespace CXX +{ + namespace Parser + { + namespace + { + // + // + struct Type: Traversal::Type + { + Type (SemanticGraph::Schema& schema, + TypeMap::Namespaces& type_map, + bool add_includes) + : schema_ (schema), + type_map_ (type_map), + add_includes_ (add_includes) + { + } + + virtual void + traverse (SemanticGraph::Type& type) + { + using TypeMap::Namespace; + using TypeMap::Namespaces; + + SemanticGraph::Context& tc (type.context ()); + + // There are two situations where we may try to process the + // same type more than once. The first is when the type is + // used in several element declarations in the same schema. + // The second situation only occurs when we are in the file- + // per-type mode. In this case the type was processed as part + // of another root schema. In the second case, while the ret + // and arg types are assumed to be the same, we need to re- + // match the type in order to add include directives to the + // new root schema. + // + bool set (true); + + if (tc.count ("ret-type")) + { + SemanticGraph::Schema* s ( + tc.get ("root-schema")); + + if (&schema_ == s) + return; + + set = false; + } + + SemanticGraph::Namespace& ns ( + dynamic_cast (type.scope ())); + + String ns_name (ns.name ()); + String t_name (type.name ()); + + //std::wcerr << "traversing: " << ns_name << "#" << t_name << endl; + + for (Namespaces::const_iterator n (type_map_.begin ()); + n != type_map_.end (); ++n) + { + // Check if the namespace matches. + // + bool ns_match; + + if (!n->xsd_name ().empty ()) + { + ns_match = n->xsd_name ().match (ns_name); + } + else + ns_match = ns_name.empty (); + + //std::wcerr << "considering ns expr: " << n->xsd_name () + // << " for " << ns_name + // << ": " << (ns_match ? "+" : "-") << endl; + + if (ns_match) + { + // Namespace matched. See if there is a type that matches. + // + for (Namespace::TypesIterator t (n->types_begin ()); + t != n->types_end (); ++t) + { + if (t->xsd_name ().match (t_name)) + { + if (set) + { + // Got a match. See if the namespace has the C++ + // namespace mapping. + // + String cxx_ns; + + if (n->has_cxx_name ()) + { + if (!n->xsd_name ().empty ()) + { + cxx_ns = n->xsd_name ().replace ( + ns_name, n->cxx_name (), true); + } + else + cxx_ns = n->cxx_name (); + + cxx_ns += L"::"; + } + + // Figure out ret and arg type names. + // + String ret_type (cxx_ns); + + ret_type += t->xsd_name ().replace ( + t_name, t->cxx_ret_name (), true); + + String arg_type; + + if (t->cxx_arg_name ()) + { + arg_type = cxx_ns; + arg_type += t->xsd_name ().replace ( + t_name, t->cxx_arg_name (), true); + } + else + { + if (ret_type == L"void") + arg_type = ret_type; + else + { + wchar_t last (ret_type[ret_type.size () - 1]); + + // If it is already a pointer or reference then use + // it as is. + // + if (last == L'*' || last == L'&') + arg_type = ret_type; + else + arg_type = L"const " + ret_type + L"&"; + } + } + + tc.set ("ret-type", ret_type); + tc.set ("arg-type", arg_type); + + //std::wcerr << t_name << " -> " << ret_type << endl; + } + + tc.set ("root-schema", &schema_); + + // See of we need to add any includes to the translations + // unit. + // + if (add_includes_) + { + if (n->includes_begin () != n->includes_end ()) + { + typedef std::set Includes; + + if (!schema_.context ().count ("includes")) + schema_.context ().set ("includes", Includes ()); + + Includes& is ( + schema_.context ().get ("includes")); + + for (Namespace::IncludesIterator i (n->includes_begin ()); + i != n->includes_end (); ++i) + { + is.insert (*i); + } + } + } + + return; + } + } + } + } + } + + private: + SemanticGraph::Schema& schema_; + TypeMap::Namespaces& type_map_; + bool add_includes_; + }; + + + // + // + struct GlobalType: Traversal::Type, + Traversal::List, + Traversal::Complex, + Traversal::Enumeration + { + GlobalType (SemanticGraph::Schema& schema, + TypeMap::Namespaces& type_map, + bool add_includes) + : type_ (schema, type_map, add_includes) + { + inherits_ >> type_; + names_ >> instance_ >> belongs_ >> type_; + argumented_ >> type_; + } + + virtual void + traverse (SemanticGraph::Type& t) + { + type_.traverse (t); + } + + virtual void + traverse (SemanticGraph::List& l) + { + type_.traverse (l); + Traversal::List::argumented (l, argumented_); + } + + virtual void + traverse (SemanticGraph::Complex& c) + { + type_.traverse (c); + Complex::inherits (c, inherits_); + Complex::names (c, names_); + } + + virtual void + traverse (SemanticGraph::Enumeration& e) + { + type_.traverse (e); + Complex::inherits (e, inherits_); + } + + private: + Parser::Type type_; + Traversal::Names names_; + Traversal::Instance instance_; + Traversal::Inherits inherits_; + Traversal::Belongs belongs_; + Traversal::Argumented argumented_; + }; + + void + process_impl (options const& ops, + XSDFrontend::SemanticGraph::Schema& tu, + bool gen_driver, + TypeMap::Namespaces& type_map) + { + if (tu.names_begin ()->named ().name () == + L"http://www.w3.org/2001/XMLSchema") + { + // XML Schema namespace. + // + Traversal::Schema schema; + + Traversal::Names schema_names; + Traversal::Namespace ns; + Traversal::Names ns_names; + GlobalType global_type (tu, type_map, true); + + schema >> schema_names >> ns >> ns_names >> global_type; + + schema.dispatch (tu); + } + else + { + // If --extern-xml-schema is specified, then we don't want + // includes from the XML Schema type map. + // + bool extern_xml_schema (ops.extern_xml_schema ()); + + // + // + Traversal::Schema schema; + Traversal::Schema xs_schema; + Sources sources; + Traversal::Implies implies; + + schema >> sources >> schema; + schema >> implies >> xs_schema; + + Traversal::Names schema_names; + Traversal::Namespace ns; + Traversal::Names ns_names; + GlobalType global_type (tu, type_map, true); + + schema >> schema_names >> ns >> ns_names >> global_type; + + Traversal::Names xs_schema_names; + Traversal::Namespace xs_ns; + Traversal::Names xs_ns_names; + GlobalType xs_global_type (tu, type_map, !extern_xml_schema); + + xs_schema >> xs_schema_names >> xs_ns >> xs_ns_names >> + xs_global_type; + + schema.dispatch (tu); + + // If we are generating the test driver, make sure the root + // element type is processed. + // + if (gen_driver && ops.generate_test_driver ()) + { + // Figure out the root element. Validator should have made sure + // it is unique. + // + SemanticGraph::Element* root (0); + { + Traversal::Schema schema; + Sources sources; + + schema >> sources >> schema; + + Traversal::Names schema_names; + Traversal::Namespace ns; + Traversal::Names ns_names; + RootElement root_element (ops, root); + + schema >> schema_names >> ns >> ns_names >> root_element; + + schema.dispatch (tu); + } + + global_type.dispatch (root->type ()); + } + } + } + } + + void TypeProcessor:: + process (options const& ops, + XSDFrontend::SemanticGraph::Schema& s, + bool gen_driver, + TypeMap::Namespaces& tm) + { + process_impl (ops, s, gen_driver, tm); + } + } +} diff --git a/xsd/cxx/parser/type-processor.hxx b/xsd/cxx/parser/type-processor.hxx new file mode 100644 index 0000000..6800024 --- /dev/null +++ b/xsd/cxx/parser/type-processor.hxx @@ -0,0 +1,31 @@ +// file : xsd/cxx/parser/type-processor.hxx +// license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +#ifndef XSD_CXX_PARSER_TYPE_PROCESSOR_HXX +#define XSD_CXX_PARSER_TYPE_PROCESSOR_HXX + +#include + +#include + +#include + +#include + +namespace CXX +{ + namespace Parser + { + class TypeProcessor + { + public: + void + process (options const&, + XSDFrontend::SemanticGraph::Schema&, + bool gen_driver, + TypeMap::Namespaces&); + }; + } +} + +#endif // XSD_CXX_PARSER_TYPE_PROCESSOR_HXX diff --git a/xsd/cxx/parser/validator.cxx b/xsd/cxx/parser/validator.cxx new file mode 100644 index 0000000..8e8161a --- /dev/null +++ b/xsd/cxx/parser/validator.cxx @@ -0,0 +1,723 @@ +// file : xsd/cxx/parser/validator.cxx +// license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +#include +#include + +#include + +#include +#include + +#include + +using namespace std; + +namespace CXX +{ + namespace Parser + { + namespace + { + class ValidationContext: public Context + { + public: + ValidationContext (SemanticGraph::Schema& root, + SemanticGraph::Path const& path, + Parser::options const& ops, + const WarningSet& disabled_warnings, + bool& valid_) + : Context (std::wcerr, root, path, ops, 0, 0, 0, 0), + disabled_warnings_ (disabled_warnings), + disabled_warnings_all_ (false), + valid (valid_), + subst_group_warning_issued (subst_group_warning_issued_), + subst_group_warning_issued_ (false) + { + } + + public: + bool + is_disabled (char const* w) + { + return disabled_warnings_all_ || + disabled_warnings_.find (w) != disabled_warnings_.end (); + } + + public: + String + xpath (SemanticGraph::Nameable& n) + { + if (n.is_a ()) + return L""; // There is a bug if you see this. + + assert (n.named_p ()); + + SemanticGraph::Scope& scope (n.scope ()); + + if (scope.is_a ()) + return n.name (); + + return xpath (scope) + L"/" + n.name (); + } + + protected: + ValidationContext (ValidationContext& c) + : Context (c), + disabled_warnings_ (c.disabled_warnings_), + disabled_warnings_all_ (c.disabled_warnings_all_), + valid (c.valid), + subst_group_warning_issued (c.subst_group_warning_issued) + { + } + + protected: + const WarningSet& disabled_warnings_; + bool disabled_warnings_all_; + bool& valid; + bool& subst_group_warning_issued; + bool subst_group_warning_issued_; + }; + + // + // + struct Any: Traversal::Any, ValidationContext + { + Any (ValidationContext& c) + : ValidationContext (c) + { + } + + struct Element: Traversal::Element, ValidationContext + { + Element (ValidationContext& c, SemanticGraph::Any& any) + : ValidationContext (c), + any_ (any), + ns_ (any.definition_namespace ().name ()) + { + } + + virtual void + traverse (SemanticGraph::Element& e) + { + if (skip (e)) return; + + using SemanticGraph::Any; + + bool q (e.qualified_p ()); + String ns (q ? e.namespace_ ().name () : ""); + + for (Any::NamespaceIterator i (any_.namespace_begin ()); + i != any_.namespace_end (); ++i) + { + bool failed (false); + + if (*i == L"##any") + { + failed = true; + } + else if (*i == L"##other") + { + if (ns_) + { + // Note that here I assume that ##other does not + // include names without target namespace. This + // is not what the spec says but that seems to be + // the consensus. + // + failed = q && ns != ns_; + } + else + { + // No target namespace. + // + failed = q && ns != L""; + } + } + else if (*i == L"##local") + { + failed = !q || ns == L""; + } + else if (*i == L"##targetNamespace") + { + failed = (q && ns_ == ns) || (!q && ns_ == L""); + } + else + { + failed = q && *i == ns; + } + + if (failed) + { + Any& a (any_); + + os << a.file () << ":" << a.line () << ":" << a.column () + << ": warning P001: namespace '" << *i << "' allows for " + << "element '" << e.name () << "'" << endl; + + os << a.file () << ":" << a.line () << ":" << a.column () + << ": warning P001: generated code may not associate element '" + << e.name () << "' correctly if it appears in place of " + << "this wildcard" << endl; + + os << e.file () << ":" << e.line () << ":" << e.column () + << ": info: element '" << e.name () << "' is defined " + << "here" << endl; + + os << a.file () << ":" << a.line () << ":" << a.column () + << ": info: turn on validation to ensure correct " + << "association" << endl; + } + } + } + + private: + SemanticGraph::Any& any_; + String ns_; + }; + + struct Complex: Traversal::Complex + { + Complex () + : up_ (true), down_ (true) + { + } + + virtual void + post (Type& c) + { + // Go down the inheritance hierarchy. + // + if (down_) + { + bool up = up_; + up_ = false; + + if (c.inherits_p ()) + dispatch (c.inherits ().base ()); + + up_ = up; + } + + // Go up the inheritance hierarchy. + // + if (up_) + { + bool down = down_; + down_ = false; + + for (Type::BegetsIterator i (c.begets_begin ()); + i != c.begets_end (); ++i) + { + dispatch (i->derived ()); + } + + down_ = down; + } + } + + private: + bool up_, down_; + }; + + virtual void + traverse (SemanticGraph::Any& a) + { + using SemanticGraph::Compositor; + + // Find our complex type. + // + Compositor* c (&a.contained_particle ().compositor ()); + + while(!c->contained_compositor_p ()) + c = &c->contained_particle ().compositor (); + + SemanticGraph::Complex& type ( + dynamic_cast ( + c->contained_compositor ().container ())); + + Complex complex; + Traversal::Names names; + Element element (*this, a); + + complex >> names >> element; + + complex.dispatch (type); + } + }; + + + // + // + struct Traverser: Traversal::Schema, + Traversal::Complex, + Traversal::Type, + Traversal::Element, + ValidationContext + { + using Schema::traverse; + + Traverser (ValidationContext& c) + : ValidationContext (c), + any_ (c) + { + *this >> sources_ >> *this; + *this >> schema_names_ >> ns_ >> names_ >> *this; + + // Any + // + if (!validation && !is_disabled ("P001")) + { + *this >> contains_compositor_ >> compositor_ >> contains_particle_; + contains_particle_ >> compositor_; + contains_particle_ >> any_; + } + } + + virtual void + traverse (SemanticGraph::Complex& c) + { + using SemanticGraph::Schema; + + traverse (static_cast (c)); + + if (c.inherits_p ()) + { + SemanticGraph::Type& t (c.inherits ().base ()); + + if (t.named_p () && + types_.find ( + t.scope ().name () + L"#" + t.name ()) == types_.end ()) + { + // Don't worry about types that are in included/imported + // schemas. + // + Schema& s (dynamic_cast (t.scope ().scope ())); + + if (&s == &schema_root || sources_p (schema_root, s)) + { + valid = false; + + wcerr << c.file () << ":" << c.line () << ":" << c.column () + << ": error: type '" << xpath (c) << "' inherits from " + << "yet undefined type '" << xpath (t) << "'" << endl; + + wcerr << t.file () << ":" << t.line () << ":" << t.column () + << ": info: '" << xpath (t) << "' is defined here" + << endl; + + wcerr << c.file () << ":" << c.line () << ":" << c.column () + << ": info: inheritance from a yet-undefined type is " + << "not supported" << endl; + + wcerr << c.file () << ":" << c.line () << ":" << c.column () + << ": info: re-arrange your schema and try again" + << endl; + } + } + } + + Complex::traverse (c); + } + + virtual void + traverse (SemanticGraph::Type& t) + { + if (t.named_p ()) + { + types_.insert (t.scope ().name () + L"#" + t.name ()); + } + } + + virtual void + traverse (SemanticGraph::Element& e) + { + if (is_disabled ("P002")) + return; + + if (e.substitutes_p () && + !options.generate_polymorphic () && + !subst_group_warning_issued) + { + subst_group_warning_issued = true; + + os << e.file () << ":" << e.line () << ":" << e.column () + << ": warning P002: substitution groups are used but " + << "--generate-polymorphic was not specified" << endl; + + os << e.file () << ":" << e.line () << ":" << e.column () + << ": info: generated code may not be able to parse " + << "some conforming instances" << endl; + } + } + + // Return true if root sources s. + // + bool + sources_p (SemanticGraph::Schema& root, SemanticGraph::Schema& s) + { + using SemanticGraph::Schema; + using SemanticGraph::Sources; + + for (Schema::UsesIterator i (root.uses_begin ()); + i != root.uses_end (); ++i) + { + if (i->is_a ()) + { + if (&i->schema () == &s || sources_p (i->schema (), s)) + return true; + } + } + + return false; + } + + private: + set types_; + + Sources sources_; + + Traversal::Names schema_names_; + Traversal::Namespace ns_; + + Traversal::Names names_; + + // Any. + // + Any any_; + Traversal::Compositor compositor_; + Traversal::ContainsParticle contains_particle_; + Traversal::ContainsCompositor contains_compositor_; + }; + + + struct AnonymousType: Traversal::Schema, + Traversal::Complex, + Traversal::Element, + Traversal::Attribute, + ValidationContext + { + using Schema::traverse; + using Complex::traverse; + + AnonymousType (ValidationContext& c) + : ValidationContext (c), + anonymous_error_issued_ (false) + { + *this >> sources_ >> *this; + *this >> schema_names_ >> ns_ >> names_ >> *this; + *this >> names_; + } + + bool + traverse_common (SemanticGraph::Member& m) + { + SemanticGraph::Type& t (m.type ()); + + if (!t.named_p () + && !t.is_a () + && !t.is_a ()) + { + if (!anonymous_error_issued_) + { + valid = false; + anonymous_error_issued_ = true; + + wcerr << t.file () + << ": error: anonymous types detected" + << endl; + + wcerr << t.file () + << ": info: " + << "anonymous types are not supported in this mapping" + << endl; + + wcerr << t.file () + << ": info: consider explicitly naming these types or " + << "remove the --preserve-anonymous option to " + << "automatically name them" + << endl; + + if (!options.show_anonymous ()) + wcerr << t.file () + << ": info: use --show-anonymous option to see these " + << "types" << endl; + } + + return true; + } + + return false; + } + + virtual void + traverse (SemanticGraph::Element& e) + { + if (skip (e)) return; + + if (traverse_common (e)) + { + if (options.show_anonymous ()) + { + wcerr << e.file () << ":" << e.line () << ":" << e.column () + << ": error: element '" << xpath (e) << "' " + << "is of anonymous type" << endl; + } + } + else + Traversal::Element::traverse (e); + } + + virtual void + traverse (SemanticGraph::Attribute& a) + { + if (traverse_common (a)) + { + if (options.show_anonymous ()) + { + wcerr << a.file () << ":" << a.line () << ":" << a.column () + << ": error: attribute '" << xpath (a) << "' " + << "is of anonymous type" << endl; + } + } + else + Traversal::Attribute::traverse (a); + } + + private: + bool anonymous_error_issued_; + + set types_; + + Sources sources_; + + Traversal::Names schema_names_; + Traversal::Namespace ns_; + + Traversal::Names names_; + }; + + struct GlobalElement: Traversal::Element, ValidationContext + { + GlobalElement (ValidationContext& c, SemanticGraph::Element*& element) + : ValidationContext (c), element_ (element) + { + } + + virtual void + traverse (Type& e) + { + if (!valid) + return; + + if (options.root_element_first ()) + { + if (element_ == 0) + element_ = &e; + } + else if (options.root_element_last ()) + { + element_ = &e; + } + else if (String name = options.root_element ()) + { + if (e.name () == name) + element_ = &e; + } + else + { + if (element_ == 0) + element_ = &e; + else + { + wcerr << schema_root.file () << ": error: unable to generate " + << "the test driver without a unique document root" + << endl; + + wcerr << schema_root.file () << ": info: use --root-element-* " + << "options to specify the document root" << endl; + + valid = false; + } + } + } + + private: + SemanticGraph::Element*& element_; + }; + + } + + bool Validator:: + validate (options const& ops, + SemanticGraph::Schema& root, + SemanticGraph::Path const& path, + bool gen_driver, + const WarningSet& disabled_warnings) + { + bool valid (true); + ValidationContext ctx (root, path, ops, disabled_warnings, valid); + + // + // + if (ops.char_type () != "char" && + ops.char_type () != "wchar_t" && + !ctx.is_disabled ("P003")) + { + wcerr << "warning P003: unknown base character type '" << + ops.char_type ().c_str () << "'" << endl; + } + + // + // + if (ops.xml_parser () != "xerces" && + ops.xml_parser () != "expat" && + !ctx.is_disabled ("P004")) + { + wcerr << "warning P004: unknown underlying XML parser '" << + ops.xml_parser ().c_str () << "'" << endl; + } + + // + // + if (ops.xml_parser () == "expat" && + ops.char_type () == "wchar_t") + { + wcerr << "error: using expat with wchar_t is not supported" + << endl; + + return false; + } + + // + // + if (ops.xml_parser () == "expat" && + !ops.char_encoding ().empty () && + ops.char_encoding () != "utf8") + { + wcerr << "error: using expat with character encoding other than " + << "utf8 is not supported" + << endl; + + return false; + } + + // + // + if (ops.generate_validation () && ops.suppress_validation ()) + { + wcerr << "error: mutually exclusive options specified: " + << "--generate-validation and --suppress-validation" + << endl; + + return false; + } + + // + // + if (ops.generate_noop_impl () && ops.generate_print_impl ()) + { + wcerr << "error: mutually exclusive options specified: " + << "--generate-noop-impl and --generate-print-impl" + << endl; + + return false; + } + + // + // + { + bool ref (ops.root_element_first ()); + bool rel (ops.root_element_last ()); + bool re (ops.root_element ()); + + if ((ref && rel) || (ref && re) || (rel && re)) + { + wcerr << "error: mutually exclusive options specified: " + << "--root-element-last, --root-element-first, and " + << "--root-element" + << endl; + + return false; + } + } + + // + // + bool import_maps (ops.import_maps ()); + bool export_maps (ops.export_maps ()); + + if (import_maps && export_maps) + { + wcerr << "error: --import-maps and --export-maps are " + << "mutually exclusive" << endl; + + return false; + } + + if (import_maps && !ctx.polymorphic) + { + wcerr << "error: --import-maps can only be specified together with " + << "--generate-polymorphic" << endl; + + return false; + } + + if (export_maps && !ctx.polymorphic) + { + wcerr << "error: --export-maps can only be specified together with " + << "--generate-polymorphic" << endl; + + return false; + } + + // Test for anonymout types. + // + { + AnonymousType traverser (ctx); + traverser.dispatch (root); + } + + + // Test the rest. + // + if (valid) + { + Traverser traverser (ctx); + traverser.dispatch (root); + } + + // Test that the document root is unique. + // + if (valid && gen_driver) + { + SemanticGraph::Element* element (0); + + Traversal::Schema schema; + Sources sources; + + schema >> sources >> schema; + + Traversal::Names schema_names; + Traversal::Namespace ns; + Traversal::Names ns_names; + GlobalElement global_element (ctx, element); + + schema >> schema_names >> ns >> ns_names >> global_element; + + schema.dispatch (root); + + if (valid && element == 0) + { + wcerr << root.file () << ": error: unable to generate the " + << "test driver without a global element (document root)" + << endl; + + valid = false; + } + } + + return valid; + } + } +} diff --git a/xsd/cxx/parser/validator.hxx b/xsd/cxx/parser/validator.hxx new file mode 100644 index 0000000..daffdc8 --- /dev/null +++ b/xsd/cxx/parser/validator.hxx @@ -0,0 +1,30 @@ +// file : xsd/cxx/parser/validator.hxx +// license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +#ifndef XSD_CXX_PARSER_VALIDATOR_HXX +#define XSD_CXX_PARSER_VALIDATOR_HXX + +#include +#include + +#include +#include + +namespace CXX +{ + namespace Parser + { + class Validator + { + public: + bool + validate (options const&, + SemanticGraph::Schema&, + SemanticGraph::Path const& tu, + bool gen_driver, + const WarningSet& disabled_warnings); + }; + } +} + +#endif // XSD_CXX_PARSER_VALIDATOR_HXX diff --git a/xsd/cxx/tree/counter.cxx b/xsd/cxx/tree/counter.cxx new file mode 100644 index 0000000..3fee0b1 --- /dev/null +++ b/xsd/cxx/tree/counter.cxx @@ -0,0 +1,265 @@ +// file : xsd/cxx/tree/counter.cxx +// license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +#include + +#include + +namespace CXX +{ + namespace Tree + { + namespace + { + struct Member: Traversal::Member + { + Member (size_t& complexity) + : complexity_ (complexity) + { + } + + virtual void + traverse (Type&) + { + complexity_++; + } + + size_t& complexity_; + }; + + struct Any: Traversal::Any, Traversal::AnyAttribute + { + Any (size_t& complexity) + : complexity_ (complexity) + { + } + + virtual void + traverse (SemanticGraph::Any&) + { + complexity_++; + } + + virtual void + traverse (SemanticGraph::AnyAttribute&) + { + complexity_++; + } + + size_t& complexity_; + }; + + struct TypeBase: Traversal::List, + Traversal::Union, + Traversal::Enumeration, + Traversal::Complex, + Context + { + TypeBase (Context& c, size_t& complexity) + : Context (c), complexity_ (complexity) + { + } + + virtual void + traverse (SemanticGraph::List&) + { + complexity_++; + } + + virtual void + traverse (SemanticGraph::Union&) + { + complexity_++; + } + + virtual void + traverse (SemanticGraph::Enumeration& e) + { + bool string_based (false); + { + IsStringBasedType t (string_based); + t.dispatch (e); + } + + complexity_ += (string_based ? 1 : 2); + } + + virtual void + traverse (SemanticGraph::Complex& c) + { + complexity_++; // One for the type itself. + + // Plus some for each member. + // + Any any (complexity_); + Member member (complexity_); + Traversal::Names names; + + names >> member; + + if (options.generate_wildcard ()) + names >> any; + + Complex::names (c, names); + } + + private: + size_t& complexity_; + }; + + + // + // + struct GlobalType: Traversal::Type, Context + + { + GlobalType (Context& c, Counts& counts) + : Context (c), counts_ (counts) + { + } + + virtual void + traverse (SemanticGraph::Type& t) + { + counts_.global_types++; + + size_t complexity (0); + TypeBase type (*this, complexity); + type.dispatch (t); + + counts_.complexity_total += complexity; + counts_.complexity.push_back (complexity); + } + + private: + Counts& counts_; + }; + + // + // + struct GlobalElement: Traversal::Element, + GlobalElementBase, + Context + { + GlobalElement (Context& c, Counts& counts) + : GlobalElementBase (c), + Context (c), + counts_ (counts), + last_ (0) + { + } + + ~GlobalElement () + { + if (last_ != 0) + { + last_->context ().set ("last", true); + count_last (); + } + } + + virtual void + traverse (Type& e) + { + // Check if the previous element we saw needs to be generated. + // + if (last_ != 0) + count_last (); + + last_ = &e; + + if (counts_.global_elements == 0) + e.context ().set ("first", true); + + counts_.global_elements++; + } + + private: + void + count_last () + { + if (generate_p (*last_)) + { + counts_.generated_global_elements++; + + size_t complexity (0); + + if (doc_root_p (*last_)) + { + if (options.generate_element_type ()) + { + complexity += 1; // For c-tors and d-tor. + + if (!options.suppress_parsing ()) + complexity += 1; + + if (options.generate_serialization ()) + complexity += 1; + } + else + { + if (!options.suppress_parsing ()) + complexity += 6; // 13 parsing functions. + + if (options.generate_serialization ()) + complexity += 4; // 8 serialization functions. + } + } + + if (complexity == 0) + { + // This element must be a substitution group members. For + // such elements we are only generating an entry in a map. + // We will assign it a complexity of 1 so that we don't + // end up with the total complexity that is less than the + // number of elements and types. + // + complexity = 1; + } + + counts_.complexity_total += complexity; + counts_.complexity.push_back (complexity); + } + } + + private: + Counts& counts_; + SemanticGraph::Element* last_; + }; + } + + Counts Counter:: + count (options const& ops, + SemanticGraph::Schema& tu, + SemanticGraph::Path const& path) + { + Counts counts; + Context ctx (std::wcerr, tu, path, ops, counts, false, 0, 0, 0, 0); + + Traversal::Schema schema; + Sources sources; + + schema >> sources >> schema; + + // The GlobalElement object destructor updates the counts, so make sure + // that this object is destroyed before we return the counts. + // + { + Traversal::Names schema_names; + Traversal::Namespace ns; + Traversal::Names ns_names; + GlobalType global_type (ctx, counts); + GlobalElement global_element (ctx, counts); + + schema >> schema_names >> ns >> ns_names; + + ns_names >> global_element; + ns_names >> global_type; + + schema.dispatch (tu); + } + + return counts; + } + } +} diff --git a/xsd/cxx/tree/counter.hxx b/xsd/cxx/tree/counter.hxx new file mode 100644 index 0000000..bc1dc79 --- /dev/null +++ b/xsd/cxx/tree/counter.hxx @@ -0,0 +1,25 @@ +// file : xsd/cxx/tree/counter.hxx +// license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +#ifndef XSD_CXX_TREE_COUNTER_HXX +#define XSD_CXX_TREE_COUNTER_HXX + +#include +#include + +namespace CXX +{ + namespace Tree + { + class Counter + { + public: + Counts + count (options const&, + SemanticGraph::Schema&, + SemanticGraph::Path const&); + }; + } +} + +#endif // XSD_CXX_TREE_COUNTER_HXX diff --git a/xsd/cxx/tree/default-value.cxx b/xsd/cxx/tree/default-value.cxx new file mode 100644 index 0000000..fd1c8c4 --- /dev/null +++ b/xsd/cxx/tree/default-value.cxx @@ -0,0 +1,1273 @@ +// file : xsd/cxx/tree/default-value.cxx +// license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +#include + +using std::hex; +using std::dec; + +namespace CXX +{ + namespace Tree + { + namespace + { + void + normalize (String& s) + { + size_t n (s.size ()); + + for (size_t i (0); i < n; ++i) + { + wchar_t& c (s[i]); + + if (c == 0x0D || // carriage return + c == 0x09 || // tab + c == 0x0A) + c = 0x20; + } + } + + void + collapse (String& s) + { + size_t n (s.size ()), j (0); + bool subs (false), trim (true); + + for (size_t i (0); i < n; ++i) + { + wchar_t c (s[i]); + + if (c == 0x20 || c == 0x09 || c == 0x0A) + subs = true; + else + { + if (subs) + { + subs = false; + + if (!trim) + s[j++] = 0x20; + } + + if (trim) + trim = false; + + s[j++] = c; + } + } + + s.resize (j); + } + + void + strip_zeros (String& s) + { + size_t n (s.size ()), i (0); + + if (n > 0 && (s[i] == '-' || s[i] == '+')) + i++; + + size_t j (i); + + bool strip (true); + + for (; i < n; ++i) + { + wchar_t c (s[i]); + + if (c == '0') + { + if (!strip) + s[j++] = c; + } + else + { + s[j++] = c; + + if (strip) + strip = false; + } + } + + if (strip && j < n) + s[j++] = '0'; // There was nothing except zeros so add one back. + + s.resize (j); + } + + void + make_float (String& s) + { + if (s.find ('.') == String::npos && + s.find ('e') == String::npos && + s.find ('E') == String::npos) + s += L".0"; + } + } + + // + // IsLiteralValue + // + + IsLiteralValue:: + IsLiteralValue (bool& r) + : IsFundamentalType (r) + { + *this >> inherits_ >> *this; + } + + void IsLiteralValue:: + traverse (SemanticGraph::Complex& c) + { + inherits (c); + } + + // + // LiteralValue + // + + LiteralValue:: + LiteralValue (Context& c) + : Context (c) + { + *this >> inherits_ >> *this; + } + + String LiteralValue:: + dispatch (SemanticGraph::Node& type, String const& value) + { + literal_.clear (); + value_ = value; + Traversal::NodeBase::dispatch (type); + return literal_; + } + + void LiteralValue:: + traverse (SemanticGraph::Complex& c) + { + inherits (c); + } + + // Boolean. + // + void LiteralValue:: + traverse (SemanticGraph::Fundamental::Boolean&) + { + collapse (value_); + literal_ = (value_ == L"true" || value_ == L"1") ? L"true" : L"false"; + } + + // Integral types. + // + void LiteralValue:: + traverse (SemanticGraph::Fundamental::Byte&) + { + collapse (value_); + strip_zeros (value_); + literal_ = value_; + } + + void LiteralValue:: + traverse (SemanticGraph::Fundamental::UnsignedByte&) + { + collapse (value_); + strip_zeros (value_); + literal_ = value_ + L"U"; + } + + void LiteralValue:: + traverse (SemanticGraph::Fundamental::Short&) + { + collapse (value_); + strip_zeros (value_); + literal_ = value_; + } + + void LiteralValue:: + traverse (SemanticGraph::Fundamental::UnsignedShort&) + { + collapse (value_); + strip_zeros (value_); + literal_ = value_ + L"U"; + } + + void LiteralValue:: + traverse (SemanticGraph::Fundamental::Int&) + { + collapse (value_); + strip_zeros (value_); + literal_ = value_; + } + + void LiteralValue:: + traverse (SemanticGraph::Fundamental::UnsignedInt&) + { + collapse (value_); + strip_zeros (value_); + literal_ = value_ + L"U"; + } + + void LiteralValue:: + traverse (SemanticGraph::Fundamental::Long&) + { + collapse (value_); + strip_zeros (value_); + literal_ = value_; + literal_ += L"LL"; + } + + void LiteralValue:: + traverse (SemanticGraph::Fundamental::UnsignedLong&) + { + collapse (value_); + strip_zeros (value_); + literal_ = value_; + literal_ += L"ULL"; + } + + void LiteralValue:: + traverse (SemanticGraph::Fundamental::Integer&) + { + collapse (value_); + strip_zeros (value_); + literal_ = value_ + L"LL"; + } + + void LiteralValue:: + traverse (SemanticGraph::Fundamental::NonPositiveInteger&) + { + collapse (value_); + strip_zeros (value_); + literal_ = value_ + L"LL"; + } + + void LiteralValue:: + traverse (SemanticGraph::Fundamental::NonNegativeInteger&) + { + collapse (value_); + strip_zeros (value_); + literal_ = value_ + L"ULL"; + } + + void LiteralValue:: + traverse (SemanticGraph::Fundamental::PositiveInteger&) + { + collapse (value_); + strip_zeros (value_); + literal_ = value_ + L"ULL"; + } + + void LiteralValue:: + traverse (SemanticGraph::Fundamental::NegativeInteger&) + { + collapse (value_); + strip_zeros (value_); + literal_ = value_ + L"LL"; + } + + // Floats. + // + void LiteralValue:: + traverse (SemanticGraph::Fundamental::Float& t) + { + collapse (value_); + + if (value_ == L"NaN") + { + literal_ = L"::std::numeric_limits< " + fq_name (t) + + L" >::quiet_NaN ()"; + } + else if (value_ == L"INF") + { + literal_ = L"::std::numeric_limits< " + fq_name (t) + + L" >::infinity ()"; + } + else if (value_ == L"-INF") + { + literal_ = L"- ::std::numeric_limits< " + fq_name (t) + + L" >::infinity ()"; + } + else + { + strip_zeros (value_); + make_float (value_); + literal_ = value_ + L"F"; + } + } + + void LiteralValue:: + traverse (SemanticGraph::Fundamental::Double& t) + { + collapse (value_); + + if (value_ == L"NaN") + { + literal_ = L"::std::numeric_limits< " + fq_name (t) + + L" >::quiet_NaN ()"; + } + else if (value_ == L"INF") + { + literal_ = L"::std::numeric_limits< " + fq_name (t) + + L" >::infinity ()"; + } + else if (value_ == L"-INF") + { + literal_ = L"- ::std::numeric_limits< " + fq_name (t) + + L" >::infinity ()"; + } + else + { + strip_zeros (value_); + make_float (value_); + literal_ = value_; + } + } + + void LiteralValue:: + traverse (SemanticGraph::Fundamental::Decimal&) + { + collapse (value_); + strip_zeros (value_); + make_float (value_); + literal_ = value_; + } + + // + // InitKind + // + + InitKind:: + InitKind (Kind& r) + : r_ (r) + { + *this >> inherits_ >> *this; + } + + void InitKind:: + traverse (SemanticGraph::List&) + { + r_ = function; + } + + void InitKind:: + traverse (SemanticGraph::Complex& c) + { + inherits (c); + } + + void InitKind:: + traverse (SemanticGraph::Fundamental::Base64Binary&) + { + r_ = data; + } + + void InitKind:: + traverse (SemanticGraph::Fundamental::HexBinary&) + { + r_ = data; + } + + void InitKind:: + traverse (SemanticGraph::Fundamental::NameTokens&) + { + r_ = function; + } + + void InitKind:: + traverse (SemanticGraph::Fundamental::IdRefs&) + { + r_ = function; + } + + void InitKind:: + traverse (SemanticGraph::Fundamental::Entities&) + { + r_ = function; + } + + // + // InitValue + // + + InitValue:: + InitValue (Context& c) + : Context (c), type_name_ (c), literal_value_ (c) + { + } + + void InitValue:: + dispatch (SemanticGraph::Node& type, String const& value) + { + value_ = value; + Traversal::NodeBase::dispatch (type); + } + + void InitValue:: + traverse (SemanticGraph::List& l) + { + collapse (value_); + + if (!value_) + return; + + SemanticGraph::Type& t (l.argumented ().type ()); + + String ov (value_); + size_t b (0); + + for (size_t e (ov.find (' ')); ; e = ov.find (' ', b)) + { + String v (ov, b, e != String::npos ? e - b : e); + + os << "{"; + type_name_.dispatch (t); + os << " tmp ("; + + String lit (literal_value_.dispatch (t, v)); + + if (lit) + os << lit; + else + { + value_ = v; + Traversal::NodeBase::dispatch (t); + } + + os << ");" + << "r.push_back (tmp);" + << "}"; + + if (e == String::npos) + break; + + b = e + 1; + } + + value_ = ov; + } + + void InitValue:: + traverse (SemanticGraph::Union&) + { + os << strlit (value_); + } + + void InitValue:: + traverse (SemanticGraph::Complex& c) + { + Traversal::NodeBase::dispatch (ultimate_base (c)); + } + + // anyType & anySimpleType. + // + void InitValue:: + traverse (SemanticGraph::AnyType& t) + { + os << fq_name (t) << " (" << strlit (value_) << ")"; + } + + void InitValue:: + traverse (SemanticGraph::AnySimpleType& t) + { + os << fq_name (t) << " (" << strlit (value_) << ")"; + } + + // Strings. + // + void InitValue:: + traverse (SemanticGraph::Fundamental::String&) + { + os << strlit (value_); + } + + void InitValue:: + traverse (SemanticGraph::Fundamental::NormalizedString&) + { + normalize (value_); + os << strlit (value_); + } + + void InitValue:: + traverse (SemanticGraph::Fundamental::Token&) + { + collapse (value_); + os << strlit (value_); + } + + void InitValue:: + traverse (SemanticGraph::Fundamental::NameToken&) + { + collapse (value_); + os << strlit (value_); + } + + void InitValue:: + traverse (SemanticGraph::Fundamental::NameTokens&) + { + string_sequence_type ( + dynamic_cast ( + xs_ns ().find ("NMTOKEN").first->named ())); + } + + void InitValue:: + traverse (SemanticGraph::Fundamental::Name&) + { + collapse (value_); + os << strlit (value_); + } + + void InitValue:: + traverse (SemanticGraph::Fundamental::NCName&) + { + collapse (value_); + os << strlit (value_); + } + + void InitValue:: + traverse (SemanticGraph::Fundamental::Language&) + { + collapse (value_); + os << strlit (value_); + } + + // Qualified name. + // + void InitValue:: + traverse (SemanticGraph::Fundamental::QName& t) + { + size_t p (value_.rfind ('#')); + + if (p != String::npos) + { + String ns (value_, 0, p); + String qname (value_, p + 1, String::npos); + + collapse (ns); + collapse (qname); + + p = qname.find (':'); + + String name; + if (p != String::npos) + name.assign (qname, p + 1, String::npos); + else + name = qname; + + os << fq_name (t) << " (" << strlit (ns) << ", " << + strlit (name) << ")"; + } + else + { + // Unqualified name. + // + collapse (value_); + os << fq_name (t) << " (" << strlit (value_) << ")"; + } + } + + // ID/IDREF. + // + void InitValue:: + traverse (SemanticGraph::Fundamental::Id&) + { + collapse (value_); + os << strlit (value_); + } + + void InitValue:: + traverse (SemanticGraph::Fundamental::IdRef&) + { + collapse (value_); + os << strlit (value_); + } + + void InitValue:: + traverse (SemanticGraph::Fundamental::IdRefs&) + { + string_sequence_type ( + dynamic_cast ( + xs_ns ().find ("IDREF").first->named ())); + } + + // URI. + // + void InitValue:: + traverse (SemanticGraph::Fundamental::AnyURI&) + { + collapse (value_); + os << strlit (value_); + } + + // Binary. + // + static unsigned char + base64_decode (wchar_t c) + { + unsigned char r = 0xFF; + + if (c >= 'A' && c <= 'Z') + r = static_cast (c - 'A'); + else if (c >= 'a' && c <= 'z') + r = static_cast (c - 'a' + 26); + else if (c >= '0' && c <= '9') + r = static_cast (c - '0' + 52); + else if (c == '+') + r = 62; + else if (c == '/') + r = 63; + + return r; + } + + void InitValue:: + traverse (SemanticGraph::Fundamental::Base64Binary& t) + { + collapse (value_); + + if (dispatch_count_++ == 0) + { + if (value_) + { + os << "unsigned char " << data_ << "[] = {"; + + // Decode. + // + size_t size (value_.size ()); + + // Remove all whitespaces. + // + { + size_t j (0); + bool subs (false); + + for (size_t i (0); i < size; ++i) + { + wchar_t c (value_[i]); + + if (c == 0x20 || c == 0x0A || c == 0x0D || c == 0x09) + subs = true; + else + { + if (subs) + subs = false; + + value_[j++] = c; + } + } + + size = j; + value_.resize (size, '\0'); + } + + // Our length should be a multiple of four. + // + size_t quad_count (size / 4); + + // Source and destination indexes. + // + size_t si (0), di (0); + + // Process all quads except the last one. + // + unsigned short v; + unsigned char b1, b2, b3, b4; + + wchar_t prev_fill (os.fill ('0')); + + for (size_t q (0); q < quad_count - 1; ++q) + { + b1 = base64_decode (value_[si++]); + b2 = base64_decode (value_[si++]); + b3 = base64_decode (value_[si++]); + b4 = base64_decode (value_[si++]); + + if (q != 0) + os << ", "; + + if (di % 9 == 0) + os << endl; + + os << hex; + + v = static_cast ((b1 << 2) | (b2 >> 4)); + os.width (2); + os << "0x" << v; + + v = static_cast ((b2 << 4) | (b3 >> 2)); + os.width (2); + os << ", 0x" << v; + + v = static_cast ((b3 << 6) | b4); + os.width (2); + os << ", 0x" << v; + + os << dec; + + di += 3; + } + + // Process the last quad. The first two octets are always there. + // + b1 = base64_decode (value_[si++]); + b2 = base64_decode (value_[si++]); + + wchar_t e3 (value_[si++]), e4 (value_[si++]); + + if (quad_count != 1) + os << ", "; + + if (di % 9 == 0) + os << endl; + + if (e4 == '=') + { + if (e3 == '=') + { + // Two pads. Last 4 bits in b2 should be zero. + // + v = static_cast ((b1 << 2) | (b2 >> 4)); + os << "0x" << hex << v << dec; + di++; + } + else + { + // One pad. Last 2 bits in b3 should be zero. + // + b3 = base64_decode (e3); + + os << hex; + + v = static_cast ((b1 << 2) | (b2 >> 4)); + os.width (2); + os << "0x" << v; + + v = static_cast ((b2 << 4) | (b3 >> 2)); + os.width (2); + os << ", 0x" << v; + + os << dec; + + di += 2; + } + } + else + { + // No pads. + // + b3 = base64_decode (e3); + b4 = base64_decode (e4); + + os << hex; + + v = static_cast ((b1 << 2) | (b2 >> 4)); + os.width (2); + os << "0x" << v; + + v = static_cast ((b2 << 4) | (b3 >> 2)); + os.width (2); + os << ", 0x" << v; + + v = static_cast ((b3 << 6) | b4); + os.width (2); + os << ", 0x" << v; + + os << dec; + + di += 3; + } + + os.fill (prev_fill); + + os << "};"; + } + } + else + { + os << fq_name (t) << " ("; + + if (value_) + os << data_ << "," << endl + << "sizeof (" << data_ << ")," << endl + << "sizeof (" << data_ << ")," << endl + << "false"; + else + os << "0"; + + + os << ")"; + } + } + + static unsigned char + hex_decode (wchar_t c) + { + unsigned char r = 0xFF; + + if (c >= '0' && c <= '9') + r = static_cast (c - '0'); + else if (c >= 'A' && c <= 'F') + r = static_cast (10 + (c - 'A')); + else if (c >= 'a' && c <= 'f') + r = static_cast (10 + (c - 'a')); + + return r; + } + + void InitValue:: + traverse (SemanticGraph::Fundamental::HexBinary& t) + { + collapse (value_); + + if (dispatch_count_++ == 0) + { + if (value_) + { + os << "unsigned char " << data_ << "[] = {"; + + // Decode. + // + size_t n (value_.size () / 2); + wchar_t prev_fill (os.fill ('0')); + + for (size_t i (0); i < n; ++i) + { + unsigned char h (hex_decode (value_[2 * i])); + unsigned char l (hex_decode (value_[2 * i + 1])); + + if (h == 0xFF || l == 0xFF) + break; + + if (i != 0) + os << ", "; + + if (i % 9 == 0) + os << endl; + + unsigned short v = static_cast ((h << 4) | l); + os.width (2); + os << "0x" << hex << v << dec; + } + + os.fill (prev_fill); + + os << "};"; + } + } + else + { + os << fq_name (t) << " ("; + + if (value_) + os << data_ << "," << endl + << "sizeof (" << data_ << ")," << endl + << "sizeof (" << data_ << ")," << endl + << "false"; + else + os << "0"; + + + os << ")"; + } + } + + // Date/time. + // + void InitValue:: + traverse (SemanticGraph::Fundamental::Date& t) + { + // date := [-]CCYY[N]*-MM-DD[Z|(+|-)HH:MM] + // + collapse (value_); + + size_t b (0); + size_t e (value_.find ('-', value_[0] == '-' ? 5 : 4)); + String year (value_, 0, e); + + b = e + 1; + String month (value_, b, 2); + + b += 3; + String day (value_, b, 2); + + strip_zeros (year); + strip_zeros (month); + strip_zeros (day); + + os << fq_name (t) << " (" << year << ", " << month << ", " << day; + time_zone (b + 2); + os << ")"; + } + + void InitValue:: + traverse (SemanticGraph::Fundamental::DateTime& t) + { + // date_time := [-]CCYY[N]*-MM-DDTHH:MM:SS[.S+][Z|(+|-)HH:MM] + // + collapse (value_); + + size_t b (0); + size_t e (value_.find ('-', value_[0] == '-' ? 5 : 4)); + String year (value_, 0, e); + b = e + 1; + + String month (value_, b, 2); + b += 3; + + String day (value_, b, 2); + b += 3; + + String hours (value_, b, 2); + b += 3; + + String minutes (value_, b, 2); + b += 3; + + e = b + 2; + for (; e < value_.size (); ++e) + { + wchar_t c (value_[e]); + + if (c == 'Z' || c == '+' || c == '-') + break; + } + + String seconds (value_, b, e - b); + + strip_zeros (year); + strip_zeros (month); + strip_zeros (day); + strip_zeros (hours); + strip_zeros (minutes); + strip_zeros (seconds); + make_float (seconds); + + os << fq_name (t) << " (" + << year << ", " << month << ", " << day << ", " + << hours << ", " << minutes << ", " << seconds; + time_zone (e); + os << ")"; + } + + namespace + { + size_t + find_delim (String const& s, size_t pos) + { + for (; pos < s.size (); ++pos) + { + wchar_t c (s[pos]); + + if (c == 'Y' || c == 'D' || c == 'M' || c == 'H' || + c == 'M' || c == 'S' || c == 'T') + break; + } + + return pos; + } + } + + void InitValue:: + traverse (SemanticGraph::Fundamental::Duration& t) + { + // duration := [-]P[nY][nM][nD][TnHnMn[.n+]S] + // + collapse (value_); + + size_t b (1), e, n (value_.size ()); + + os << fq_name (t) << " ("; + + if (value_[0] == '-') + { + os << "true, "; + b++; + } + else + os << "false, "; + + e = find_delim (value_, b); + + if (e < n && value_[e] == 'Y') + { + String v (value_, b, e - b); + strip_zeros (v); + os << v << ", "; + + b = e + 1; + e = find_delim (value_, b); + } + else + os << "0, "; + + if (e < n && value_[e] == 'M') + { + String v (value_, b, e - b); + strip_zeros (v); + os << v << ", "; + + b = e + 1; + e = find_delim (value_, b); + } + else + os << "0, "; + + if (e < n && value_[e] == 'D') + { + String v (value_, b, e - b); + strip_zeros (v); + os << v << ", "; + + b = e + 1; + e = find_delim (value_, b); + } + else + os << "0, "; + + if (e < n && value_[e] == 'T') + { + b = e + 1; + e = find_delim (value_, b); + } + + if (e < n && value_[e] == 'H') + { + String v (value_, b, e - b); + strip_zeros (v); + os << v << ", "; + + b = e + 1; + e = find_delim (value_, b); + } + else + os << "0, "; + + if (e < n && value_[e] == 'M') + { + String v (value_, b, e - b); + strip_zeros (v); + os << v << ", "; + + b = e + 1; + e = find_delim (value_, b); + } + else + os << "0, "; + + if (e < n && value_[e] == 'S') + { + String v (value_, b, e - b); + strip_zeros (v); + make_float (v); + os << v; + + b = e + 1; + e = find_delim (value_, b); + } + else + os << "0.0"; + + os << ")"; + } + + void InitValue:: + traverse (SemanticGraph::Fundamental::Day& t) + { + // gday := ---DD[Z|(+|-)HH:MM] + // + collapse (value_); + + String day (value_, 3, 2); + strip_zeros (day); + + os << fq_name (t) << " (" << day; + time_zone (5); + os << ")"; + } + + void InitValue:: + traverse (SemanticGraph::Fundamental::Month& t) + { + // gmonth := --MM[Z|(+|-)HH:MM] + // + collapse (value_); + + String month (value_, 2, 2); + strip_zeros (month); + + os << fq_name (t) << " (" << month; + time_zone (4); + os << ")"; + } + + void InitValue:: + traverse (SemanticGraph::Fundamental::MonthDay& t) + { + // gmonth_day := --MM-DD[Z|(+|-)HH:MM] + // + collapse (value_); + + String month (value_, 2, 2); + String day (value_, 5, 2); + + strip_zeros (month); + strip_zeros (day); + + os << fq_name (t) << " (" << month << ", " << day; + time_zone (7); + os << ")"; + } + + void InitValue:: + traverse (SemanticGraph::Fundamental::Year& t) + { + // gyear := [-]CCYY[N]*[Z|(+|-)HH:MM] + // + collapse (value_); + + size_t pos (value_[0] == '-' ? 5 : 4); + for (; pos < value_.size (); ++pos) + { + wchar_t c (value_[pos]); + + if (c == 'Z' || c == '+' || c == '-') + break; + } + + String year (value_, 0, pos); + strip_zeros (year); + + os << fq_name (t) << " (" << year; + time_zone (pos); + os << ")"; + } + + void InitValue:: + traverse (SemanticGraph::Fundamental::YearMonth& t) + { + // gyear_month := [-]CCYY[N]*-MM[Z|(+|-)HH:MM] + // + collapse (value_); + + size_t pos (value_.find ('-', value_[0] == '-' ? 5 : 4)); + + String year (value_, 0, pos); + String month (value_, pos + 1, 2); + + strip_zeros (year); + strip_zeros (month); + + os << fq_name (t) << " (" << year << ", " << month; + time_zone (pos + 3); + os << ")"; + } + + void InitValue:: + traverse (SemanticGraph::Fundamental::Time& t) + { + // time := HH:MM:SS[.S+][Z|(+|-)HH:MM] + // + collapse (value_); + + String hours (value_, 0, 2); + String minutes (value_, 3, 2); + + size_t e (8); + for (; e < value_.size (); ++e) + { + wchar_t c (value_[e]); + + if (c == 'Z' || c == '+' || c == '-') + break; + } + + String seconds (value_, 6, e - 6); + + strip_zeros (hours); + strip_zeros (minutes); + strip_zeros (seconds); + make_float (seconds); + + os << fq_name (t) << " (" << hours << ", " << minutes << ", " << seconds; + time_zone (e); + os << ")"; + } + + void InitValue:: + time_zone (size_t pos) + { + // time_zone := Z|(+|-)HH:MM + // + if (pos < value_.size ()) + { + String h, m; + + if (value_[pos] == 'Z') + { + h = "0"; + m = "0"; + } + else + { + if (value_[pos] == '-') + { + h = "-"; + m = "-"; + } + + h.append (value_, pos + 1, 2); + m.append (value_, pos + 4, 2); + + strip_zeros (h); + strip_zeros (m); + } + + os << ", " << h << ", " << m; + } + } + + // Entity. + // + void InitValue:: + traverse (SemanticGraph::Fundamental::Entity&) + { + collapse (value_); + os << strlit (value_); + } + + void InitValue:: + traverse (SemanticGraph::Fundamental::Entities&) + { + string_sequence_type ( + dynamic_cast ( + xs_ns ().find ("ENTITY").first->named ())); + } + + void InitValue:: + string_sequence_type (SemanticGraph::Type& t) + { + collapse (value_); + + if (!value_) + return; + + size_t b (0); + + for (size_t e (value_.find (' ')); ; e = value_.find (' ', b)) + { + String v (value_, b, e != String::npos ? e - b : e); + + os << "{"; + type_name_.dispatch (t); + os << " tmp (" << strlit (v) << ");" + << "r.push_back (tmp);" + << "}"; + + if (e == String::npos) + break; + + b = e + 1; + } + } + } +} diff --git a/xsd/cxx/tree/default-value.hxx b/xsd/cxx/tree/default-value.hxx new file mode 100644 index 0000000..149982f --- /dev/null +++ b/xsd/cxx/tree/default-value.hxx @@ -0,0 +1,363 @@ +// file : xsd/cxx/tree/default-value.hxx +// license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +#ifndef XSD_CXX_TREE_DEFAULT_VALUE_HXX +#define XSD_CXX_TREE_DEFAULT_VALUE_HXX + +#include +#include + +#include + +namespace CXX +{ + namespace Tree + { + struct IsLiteralValue: IsFundamentalType, Traversal::Complex + { + using IsFundamentalType::traverse; + + IsLiteralValue (bool& r); + + virtual void + traverse (SemanticGraph::Complex&); + + private: + Traversal::Inherits inherits_; + }; + + struct LiteralValue: Traversal::Fundamental::Byte, + Traversal::Fundamental::UnsignedByte, + Traversal::Fundamental::Short, + Traversal::Fundamental::UnsignedShort, + Traversal::Fundamental::Int, + Traversal::Fundamental::UnsignedInt, + Traversal::Fundamental::Long, + Traversal::Fundamental::UnsignedLong, + Traversal::Fundamental::Integer, + Traversal::Fundamental::NonPositiveInteger, + Traversal::Fundamental::NonNegativeInteger, + Traversal::Fundamental::PositiveInteger, + Traversal::Fundamental::NegativeInteger, + + Traversal::Fundamental::Boolean, + + Traversal::Fundamental::Float, + Traversal::Fundamental::Double, + Traversal::Fundamental::Decimal, + + Traversal::Complex, + + Context + { + using Traversal::NodeDispatcher::dispatch; + using Traversal::EdgeDispatcher::dispatch; + + LiteralValue (Context&); + + String + dispatch (SemanticGraph::Node& type, String const& value); + + // Handle inheritance. + // + virtual void + traverse (SemanticGraph::Complex&); + + // Boolean. + // + virtual void + traverse (SemanticGraph::Fundamental::Boolean&); + + // Integral types. + // + virtual void + traverse (SemanticGraph::Fundamental::Byte&); + + virtual void + traverse (SemanticGraph::Fundamental::UnsignedByte&); + + virtual void + traverse (SemanticGraph::Fundamental::Short&); + + virtual void + traverse (SemanticGraph::Fundamental::UnsignedShort&); + + virtual void + traverse (SemanticGraph::Fundamental::Int&); + + virtual void + traverse (SemanticGraph::Fundamental::UnsignedInt&); + + virtual void + traverse (SemanticGraph::Fundamental::Long&); + + virtual void + traverse (SemanticGraph::Fundamental::UnsignedLong&); + + virtual void + traverse (SemanticGraph::Fundamental::Integer&); + + virtual void + traverse (SemanticGraph::Fundamental::NonPositiveInteger&); + + virtual void + traverse (SemanticGraph::Fundamental::NonNegativeInteger&); + + virtual void + traverse (SemanticGraph::Fundamental::PositiveInteger&); + + virtual void + traverse (SemanticGraph::Fundamental::NegativeInteger&); + + // Floats. + // + virtual void + traverse (SemanticGraph::Fundamental::Float&); + + virtual void + traverse (SemanticGraph::Fundamental::Double&); + + virtual void + traverse (SemanticGraph::Fundamental::Decimal&); + + private: + String value_; + String literal_; + + Traversal::Inherits inherits_; + }; + + // Some initialization (e.g., list) need a function body while others + // (e.g., *binary) require extra data. + // + struct InitKind: Traversal::List, + Traversal::Complex, + + Traversal::Fundamental::Base64Binary, + Traversal::Fundamental::HexBinary, + + Traversal::Fundamental::NameTokens, + Traversal::Fundamental::IdRefs, + Traversal::Fundamental::Entities + { + enum Kind + { + simple, + data, + function + }; + + // Should be simple initially. + // + InitKind (Kind& r); + + virtual void + traverse (SemanticGraph::List&); + + virtual void + traverse (SemanticGraph::Complex&); + + virtual void + traverse (SemanticGraph::Fundamental::Base64Binary&); + + virtual void + traverse (SemanticGraph::Fundamental::HexBinary&); + + virtual void + traverse (SemanticGraph::Fundamental::NameTokens&); + + virtual void + traverse (SemanticGraph::Fundamental::IdRefs&); + + virtual void + traverse (SemanticGraph::Fundamental::Entities&); + + private: + Kind& r_; + Traversal::Inherits inherits_; + }; + + struct InitValue: Traversal::List, + Traversal::Union, + Traversal::Complex, + + Traversal::AnyType, + Traversal::AnySimpleType, + + Traversal::Fundamental::String, + Traversal::Fundamental::NormalizedString, + Traversal::Fundamental::Token, + Traversal::Fundamental::Name, + Traversal::Fundamental::NameToken, + Traversal::Fundamental::NameTokens, + Traversal::Fundamental::NCName, + Traversal::Fundamental::Language, + + Traversal::Fundamental::QName, + + Traversal::Fundamental::Id, + Traversal::Fundamental::IdRef, + Traversal::Fundamental::IdRefs, + + Traversal::Fundamental::AnyURI, + + Traversal::Fundamental::Base64Binary, + Traversal::Fundamental::HexBinary, + + Traversal::Fundamental::Date, + Traversal::Fundamental::DateTime, + Traversal::Fundamental::Duration, + Traversal::Fundamental::Day, + Traversal::Fundamental::Month, + Traversal::Fundamental::MonthDay, + Traversal::Fundamental::Year, + Traversal::Fundamental::YearMonth, + Traversal::Fundamental::Time, + + Traversal::Fundamental::Entity, + Traversal::Fundamental::Entities, + + Context + { + using Traversal::NodeDispatcher::dispatch; + using Traversal::EdgeDispatcher::dispatch; + + InitValue (Context&); + + void + data (String const& data) + { + data_ = data; + dispatch_count_ = 0; + } + + void + dispatch (SemanticGraph::Node& type, String const& value); + + virtual void + traverse (SemanticGraph::List&); + + virtual void + traverse (SemanticGraph::Union&); + + virtual void + traverse (SemanticGraph::Complex&); + + // anyType & anySimpleType. + // + virtual void + traverse (SemanticGraph::AnyType&); + + virtual void + traverse (SemanticGraph::AnySimpleType&); + + // Strings. + // + virtual void + traverse (SemanticGraph::Fundamental::String&); + + virtual void + traverse (SemanticGraph::Fundamental::NormalizedString&); + + virtual void + traverse (SemanticGraph::Fundamental::Token&); + + virtual void + traverse (SemanticGraph::Fundamental::NameToken&); + + virtual void + traverse (SemanticGraph::Fundamental::NameTokens&); + + virtual void + traverse (SemanticGraph::Fundamental::Name&); + + virtual void + traverse (SemanticGraph::Fundamental::NCName&); + + virtual void + traverse (SemanticGraph::Fundamental::Language&); + + // Qualified name. + // + virtual void + traverse (SemanticGraph::Fundamental::QName&); + + // ID/IDREF. + // + virtual void + traverse (SemanticGraph::Fundamental::Id&); + + virtual void + traverse (SemanticGraph::Fundamental::IdRef&); + + virtual void + traverse (SemanticGraph::Fundamental::IdRefs&); + + // URI. + // + virtual void + traverse (SemanticGraph::Fundamental::AnyURI&); + + // Binary. + // + virtual void + traverse (SemanticGraph::Fundamental::Base64Binary&); + + virtual void + traverse (SemanticGraph::Fundamental::HexBinary&); + + // Date/time. + // + virtual void + traverse (SemanticGraph::Fundamental::Date&); + + virtual void + traverse (SemanticGraph::Fundamental::DateTime&); + + virtual void + traverse (SemanticGraph::Fundamental::Duration&); + + virtual void + traverse (SemanticGraph::Fundamental::Day&); + + virtual void + traverse (SemanticGraph::Fundamental::Month&); + + virtual void + traverse (SemanticGraph::Fundamental::MonthDay&); + + virtual void + traverse (SemanticGraph::Fundamental::Year&); + + virtual void + traverse (SemanticGraph::Fundamental::YearMonth&); + + virtual void + traverse (SemanticGraph::Fundamental::Time&); + + // Entity. + // + virtual void + traverse (SemanticGraph::Fundamental::Entity&); + + virtual void + traverse (SemanticGraph::Fundamental::Entities&); + + private: + void + string_sequence_type (SemanticGraph::Type& element_type); + + void + time_zone (size_t pos); + + private: + String value_; + String data_; + size_t dispatch_count_; + MemberTypeName type_name_; + LiteralValue literal_value_; + }; + } +} + +#endif // XSD_CXX_TREE_DEFAULT_VALUE_HXX diff --git a/xsd/cxx/tree/elements.cxx b/xsd/cxx/tree/elements.cxx new file mode 100644 index 0000000..fc080c8 --- /dev/null +++ b/xsd/cxx/tree/elements.cxx @@ -0,0 +1,1409 @@ +// file : xsd/cxx/tree/elements.cxx +// license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +#include + +namespace CXX +{ + namespace Tree + { + // Context + // + Context:: + Context (std::wostream& o, + SemanticGraph::Schema& root, + SemanticGraph::Path const& path, + options_type const& ops, + Counts const& counts_, + bool generate_xml_schema__, + StringLiteralMap const* map, + Regex const* fe, + Regex const* he, + Regex const* ie) + : CXX::Context (o, root, path, ops, map), + options (ops), + counts (counts_), + any_type (any_type_), + any_simple_type (any_simple_type_), + element_type (element_type_), + container (container_), + flags_type (flags_type_), + qname_type (qname_type_), + xs_string_type (xs_string_type_), + properties_type (properties_type_), + error_handler_type (error_handler_type_), + list_stream_type (list_stream_type_), + namespace_infomap_type (namespace_infomap_type_), + parser_type (parser_type_), + std_ostream_type (std_ostream_type_), + ostream_type (ostream_type_), + istream_type (istream_type_), + xerces_ns (xerces_ns_), + dom_auto_ptr (dom_auto_ptr_), + dom_node_key (dom_node_key_), + as_double_type (as_double_type_), + as_decimal_type (as_decimal_type_), + generate_xml_schema (generate_xml_schema_), + doxygen (doxygen_), + polymorphic (ops.generate_polymorphic ()), + polymorphic_all (ops.polymorphic_type_all ()), + poly_plate (ops.polymorphic_plate ()), + detach (ops.generate_detach ()), + fwd_expr (fe), + hxx_expr (he), + ixx_expr (ie), + ns_scope (ns_scope_), + regex_custom_type_map (regex_custom_type_map_), + direct_custom_type_map (direct_custom_type_map_), + qname_type_ (L"::xsd::cxx::xml::qualified_name< " + char_type + L" >"), + parser_type_ (L"::xsd::cxx::xml::dom::parser< " + char_type + L" >"), + generate_xml_schema_ (generate_xml_schema__), + doxygen_ (ops.generate_doxygen ()), + ns_scope_stack (ns_scope_stack_), + cxx_uq_id_expr_ (L"^[a-zA-Z_]\\w*$"), + cxx_uq_id_expr (cxx_uq_id_expr_) + { + SemanticGraph::Namespace& xs (xs_ns ()); + SemanticGraph::Context& xsc (xs.context ()); + + // Cache some often-used names from the XML Schema namespace + // if names have already been processed. + // + if (xsc.count ("container")) + { + String xs_name (ns_name (xs)); + + any_type = fq_name (xs.find ("anyType").first->named ()); + any_simple_type = fq_name (xs.find ("anySimpleType").first->named ()); + xs_string_type = fq_name (xs.find ("string").first->named ()); + + container = xs_name + L"::" + xsc.get ("container"); + flags_type = xs_name + L"::" + xsc.get ("flags"); + + if (ops.generate_element_type ()) + element_type = xs_name + L"::" + xsc.get ("element-type"); + + properties_type = xs_name + L"::" + xsc.get ("properties"); + + if (!ops.suppress_parsing () || ops.generate_serialization ()) + { + error_handler_type = xs_name + L"::" + + xsc.get ("error-handler"); + } + + dom_auto_ptr_ = xs_name + (std >= cxx_version::cxx11 + ? L"::dom::unique_ptr" + : L"::dom::auto_ptr"); + + dom_node_key_ = xs_name + L"::dom::" + + xsc.get ("tree-node-key"); + + if (ops.generate_serialization ()) + { + as_double_type_ = xs_name + L"::" + + xsc.get ("as-double"); + + as_decimal_type_ = xs_name + L"::" + + xsc.get ("as-decimal"); + + list_stream_type = xs_name + L"::" + + xsc.get ("list-stream"); + + namespace_infomap_type = xs_name + L"::" + + xsc.get ("namespace-infomap"); + } + + // istream and ostream are templates and for now use the same + // names regardless of the naming convention. + // + if (!ops.generate_extraction ().empty ()) + istream_type = xs_name + L"::istream"; + + if (!ops.generate_insertion ().empty ()) + ostream_type = xs_name + L"::ostream"; + } + + // Xerces-C++ namespace. IntelliSense for some reason does not like + // it fully-qualified (maybe because it's a namespace alias). + // + if (ops.generate_intellisense ()) + xerces_ns = "xercesc"; + else + xerces_ns = "::xercesc"; + + // + // + if (char_type == L"char") + std_ostream_type_ = L"::std::ostream"; + else if (char_type == L"wchar_t") + std_ostream_type_ = L"::std::wostream"; + else + std_ostream_type_ = L"::std::basic_ostream< " + char_type + L" >"; + + // Custom type mapping. + // + + // Direct custom type mapping. + // + { + NarrowStrings const& v (ops.custom_type ()); + + for (NarrowStrings::const_iterator i (v.begin ()), + e (v.end ()); i != e; ++i) + { + String s (*i); + + if (s.empty ()) + throw InvalidCustomTypeMapping (s, "mapping string is empty"); + + // Split the string in two parts at the last '='. + // + size_t pos (s.rfind ('=')); + + // If no delimiter found then both type and base are empty. + // + if (pos == String::npos) + { + direct_custom_type_map[s].type.clear (); + direct_custom_type_map[s].base.clear (); + continue; + } + + String name (s, 0, pos); + String rest (s, pos + 1); + + // See if we've got the base part after '/'. + // + pos = rest.rfind ('/'); + + String type, base; + + if (pos != String::npos) + { + type.assign (rest, 0, pos); + base.assign (rest, pos + 1, String::npos); + } + else + type = rest; + + // type can be a potentially-qualified template-id. base is + // an unqualified C++ name. + // + + if (!base.empty () && !cxx_uq_id_expr.match (base)) + throw InvalidCustomTypeMapping (s, "invalid C++ identifier"); + + direct_custom_type_map[name].type = type; + direct_custom_type_map[name].base = base; + } + } + + // Regex custom type mapping. + // + { + NarrowStrings const& v (ops.custom_type_regex ()); + + for (NarrowStrings::const_iterator i (v.begin ()), + e (v.end ()); i != e; ++i) + { + String s (*i); + + if (s.empty ()) + throw InvalidCustomTypeMapping (s, "mapping string is empty"); + + wchar_t delimiter (s[0]); + + // First get pattern. + // + size_t pos (s.find (delimiter, 1)); + + if (pos == String::npos) + throw InvalidCustomTypeMapping ( + s, "missing pattern-substitution separator"); + + String pat (s, 1, pos - 1); + String rest (s, pos + 1); + + String type, base; + + // See if we've got type and base. + // + if (!rest.empty ()) + { + pos = rest.find (delimiter); + + if (pos == String::npos) + throw InvalidCustomTypeMapping ( + s, "missing pattern-substitution separator"); + + type.assign (rest, 0, pos); + rest = String (rest, pos + 1); + + if (!rest.empty ()) + { + pos = rest.find (delimiter); + + if (pos == String::npos) + throw InvalidCustomTypeMapping ( + s, "missing pattern-substitution separator"); + + base.assign (rest, 0, pos); + rest = String (rest, pos + 1); + + if (!rest.empty ()) + throw InvalidCustomTypeMapping (s, "invalid format"); + } + } + + regex_custom_type_map.push_back ( + RegexCustomTypeMapInfo (WideRegexPat (pat), type, base)); + } + } + } + + Context:: + Context (Context& c) + : CXX::Context (c), + options (c.options), + counts (c.counts), + any_type (c.any_type), + any_simple_type (c.any_simple_type), + element_type (c.element_type), + container (c.container), + flags_type (c.flags_type), + qname_type (c.qname_type), + xs_string_type (c.xs_string_type), + properties_type (c.properties_type), + error_handler_type (c.error_handler_type), + list_stream_type (c.list_stream_type), + namespace_infomap_type (c.namespace_infomap_type), + parser_type (c.parser_type), + std_ostream_type (c.std_ostream_type), + ostream_type (c.ostream_type), + istream_type (c.istream_type), + xerces_ns (c.xerces_ns), + dom_auto_ptr (c.dom_auto_ptr), + dom_node_key (c.dom_node_key), + as_double_type (c.as_double_type), + as_decimal_type (c.as_decimal_type), + generate_xml_schema (c.generate_xml_schema), + doxygen (c.doxygen), + polymorphic (c.polymorphic), + polymorphic_all (c.polymorphic_all), + poly_plate (c.poly_plate), + detach (c.detach), + fwd_expr (c.fwd_expr), + hxx_expr (c.hxx_expr), + ixx_expr (c.ixx_expr), + ns_scope (c.ns_scope), + regex_custom_type_map (c.regex_custom_type_map), + direct_custom_type_map (c.direct_custom_type_map), + ns_scope_stack (c.ns_scope_stack), + cxx_uq_id_expr (c.cxx_uq_id_expr) + { + } + + Context:: + Context (Context& c, std::wostream& o) + : CXX::Context (c, o), + options (c.options), + counts (c.counts), + any_type (c.any_type), + any_simple_type (c.any_simple_type), + element_type (c.element_type), + container (c.container), + flags_type (c.flags_type), + qname_type (c.qname_type), + xs_string_type (c.xs_string_type), + properties_type (c.properties_type), + error_handler_type (c.error_handler_type), + list_stream_type (c.list_stream_type), + namespace_infomap_type (c.namespace_infomap_type), + parser_type (c.parser_type), + std_ostream_type (c.std_ostream_type), + ostream_type (c.ostream_type), + istream_type (c.istream_type), + xerces_ns (c.xerces_ns), + dom_auto_ptr (c.dom_auto_ptr), + dom_node_key (c.dom_node_key), + as_double_type (c.as_double_type), + as_decimal_type (c.as_decimal_type), + generate_xml_schema (c.generate_xml_schema), + doxygen (c.doxygen), + polymorphic (c.polymorphic), + polymorphic_all (c.polymorphic_all), + poly_plate (c.poly_plate), + detach (c.detach), + fwd_expr (c.fwd_expr), + hxx_expr (c.hxx_expr), + ixx_expr (c.ixx_expr), + ns_scope (c.ns_scope), + regex_custom_type_map (c.regex_custom_type_map), + direct_custom_type_map (c.direct_custom_type_map), + ns_scope_stack (c.ns_scope_stack), + cxx_uq_id_expr (c.cxx_uq_id_expr) + { + } + + void Context:: + update_ns_scope () + { + ns_scope.clear (); + + bool first (true); + + for (NamespaceStack::iterator i (ns_scope_stack.begin ()); + i != ns_scope_stack.end (); + ++i) + { + // We only qualify names until the namespace level. + // + if (first) + first = false; + else + ns_scope += L"::"; + + ns_scope += *i; + } + } + + bool Context:: + custom_type (SemanticGraph::Type const& t, String& r) const + { + String const& name (t.name ()); + + // First search the direct mapping. + // + { + DirectCustomTypeMap::const_iterator i ( + direct_custom_type_map.find (name)); + + if (i != direct_custom_type_map.end ()) + { + r = i->second.type; + return true; + } + } + + + // Second search the regex mapping. + // + for (RegexCustomTypeMap::const_iterator + i (regex_custom_type_map.begin ()), + e (regex_custom_type_map.end ()); + i != e; ++i) + { + if (i->pat.match (name)) + { + // Empty type sub tells us to use the original name. + // + if (i->type_sub.empty ()) + { + r.clear (); + return true; + } + + r = i->pat.replace (name, i->type_sub); + return true; + } + } + + return false; + } + + String Context:: + custom_type (SemanticGraph::Type const& t) const + { + String r; + if (custom_type (t, r)) + { + // Empty type name tells us to use the original name. + // + if (r.empty ()) + r = ename (t); + } + + return r; + } + + bool Context:: + renamed_type (SemanticGraph::Type const& t, String& r) const + { + String const& name (t.name ()); + + // First search the direct mapping. + // + { + DirectCustomTypeMap::const_iterator i ( + direct_custom_type_map.find (name)); + + if (i != direct_custom_type_map.end ()) + { + r = i->second.base; + return true; + } + } + + + // Second search the regex mapping. + // + for (RegexCustomTypeMap::const_iterator + i (regex_custom_type_map.begin ()), + e (regex_custom_type_map.end ()); + i != e; ++i) + { + if (i->pat.match (name)) + { + if (!i->base_sub.empty ()) + { + r = i->pat.replace (name, i->base_sub); + } + else + r.clear (); + + return true; + } + } + + return false; + } + + void Context:: + write_annotation (SemanticGraph::Annotation& a) + { + String const& doc (a.documentation ()); + wchar_t const* s (doc.c_str ()); + size_t size (doc.size ()); + + // Remove leading and trailing whitespaces. + // + while (*s == wchar_t (0x20) || *s == wchar_t (0x0A) || + *s == wchar_t (0x0D) || *s == wchar_t (0x09)) + { + s++; + size--; + } + + if (size != 0) + { + wchar_t const* e (s + size - 1); + + while (e > s && + (*e == wchar_t (0x20) || *e == wchar_t (0x0A) || + *e == wchar_t (0x0D) || *e == wchar_t (0x09))) + --e; + + size = s <= e ? e - s + 1 : 0; + } + + if (size != 0) + { + os << " * "; + + // Go over the data, forcing newline after 80 chars and adding + // ' * ' after each new line. + // + wchar_t const* last_space (0); + wchar_t const* b (s); + wchar_t const* e (s); + bool after_newline (false); + bool rogue (false); + + for (; e < s + size; ++e) + { + unsigned int u (unicode_char (e)); // May advance e. + + // We are going to treat \v and \f as rogue here even though + // they can be present in C++ source code. + // + if (u > 127 || (u < 32 && u != '\t' && u != '\n')) + rogue = true; + + if (u == ' ' || u == '\t') + { + if (after_newline) + { + if (e == b) + b++; // Skip leading spaces after newline. + + continue; + } + else + last_space = e; + } + else if (after_newline) + { + os << " * "; + after_newline = false; + } + + if (u == '\n') + { + write_rogue_text (b, e - b + 1, rogue); + + b = e + 1; + last_space = 0; + after_newline = true; + rogue = false; + continue; + } + + if (e - b >= 70 && last_space != 0) + { + write_rogue_text (b, last_space - b, rogue); + os << endl; + + b = last_space + 1; + last_space = 0; + after_newline = true; + // Cannot reset rogue since we don't output the whole string. + } + } + + if (e != b) + write_rogue_text (b, e - b, rogue); + + if (!after_newline) + os << endl; + } + } + + void Context:: + write_rogue_text (wchar_t const* s, size_t size, bool rogue) + { + if (!rogue) + os.write (s, size); + else + { + for (wchar_t const* p (s); p < s + size; ++p) + { + unsigned int u (unicode_char (p)); // May advance p. + + // We are going to treat \v and \f as rogue here even though + // they can be present in C++ source code. + // + if (u > 127 || (u < 32 && u != '\t' && u != '\n')) + os.put ('?'); + else + os.put (static_cast (u)); + } + } + } + + bool Context:: + polymorphic_p (SemanticGraph::Type& t) + { + // IDREF templates cannot be polymorphic. + // + if (!t.named_p () && + (t.is_a () || + t.is_a ())) + return false; + + if (polymorphic_all) + { + bool fund (false); + IsFundamentalType test (fund); + test.dispatch (t); + return !fund; + } + else + return t.context ().get ("polymorphic"); + } + + bool Context:: + anonymous_substitutes_p (SemanticGraph::Type& t) + { + // IDREF templates cannot match. + // + if (!t.named_p () && + (t.is_a () || + t.is_a ())) + return false; + + // See which elements this type classifies. + // + for (SemanticGraph::Type::ClassifiesIterator i (t.classifies_begin ()), + e (t.classifies_end ()); i != e; ++i) + { + if (SemanticGraph::Element* e = + dynamic_cast (&i->instance ())) + { + if (e->substitutes_p ()) + return true; + } + } + + return false; + } + + // GenerateDefautCtor + // + GenerateDefaultCtor:: + GenerateDefaultCtor (Context& c, bool& generate, bool no_base) + : Context (c), generate_ (generate), no_base_ (no_base) + { + *this >> inherits_ >> *this; + *this >> names_ >> *this; + } + + void GenerateDefaultCtor:: + traverse (SemanticGraph::Complex& c) + { + // Make sure we figure out if we have any required members before + // we base our decision on the base type. + // + Complex::names (c, names_); + + if (!generate_) + Complex::inherits (c, inherits_); + } + + void GenerateDefaultCtor:: + traverse (SemanticGraph::Type&) + { + if (!no_base_) + generate_ = true; + } + + void GenerateDefaultCtor:: + traverse (SemanticGraph::Enumeration&) + { + if (!no_base_) + generate_ = true; + } + + void GenerateDefaultCtor:: + traverse (SemanticGraph::Element& e) + { + if (!skip (e) && min (e) == 1 && max (e) == 1) + generate_ = true; + } + + void GenerateDefaultCtor:: + traverse (SemanticGraph::Attribute& a) + { + if (min (a) == 1 && !a.fixed_p ()) + generate_ = true; + } + + void GenerateDefaultCtor:: + traverse (SemanticGraph::Any& a) + { + if (options.generate_wildcard () && + min (a) == 1 && max (a) == 1) + generate_ = true; + } + + + // GenerateFromBaseCtor + // + GenerateFromBaseCtor:: + GenerateFromBaseCtor (Context& c, bool& generate) + : generate_ (generate), + custom_ (false), + traverser_ (c, generate, custom_) + { + inherits_ >> traverser_; + } + + void GenerateFromBaseCtor:: + traverse (SemanticGraph::Complex& c) + { + inherits (c, inherits_); + + if (!generate_ && custom_) + { + // We have a customized type in the hierarchy. In this case we + // want to generate the c-tor unless base and ultimate-base are + // the same (see CtorArgs). + // + SemanticGraph::Type& b (c.inherits ().base ()); + generate_ = b.is_a () && + !b.is_a (); + } + } + + GenerateFromBaseCtor::Traverser:: + Traverser (Context& c, bool& generate, bool& custom) + : Context (c), generate_ (generate), custom_ (custom) + { + *this >> inherits_ >> *this; + *this >> names_ >> *this; + } + + void GenerateFromBaseCtor::Traverser:: + traverse (SemanticGraph::Type& t) + { + if (!custom_) + { + String tmp; + custom_ = custom_type (t, tmp); + } + } + + void GenerateFromBaseCtor::Traverser:: + traverse (SemanticGraph::Complex& c) + { + names (c, names_); + + if (!generate_) + inherits (c, inherits_); + + if (!generate_) + traverse (static_cast (c)); + } + + void GenerateFromBaseCtor::Traverser:: + traverse (SemanticGraph::Element& e) + { + if (!skip (e) && min (e) == 1 && max (e) == 1) + generate_ = true; + } + + void GenerateFromBaseCtor::Traverser:: + traverse (SemanticGraph::Attribute& a) + { + if (min (a) == 1 && !a.fixed_p ()) + generate_ = true; + } + + void GenerateFromBaseCtor::Traverser:: + traverse (SemanticGraph::Any& a) + { + if (options.generate_wildcard () && + min (a) == 1 && max (a) == 1) + generate_ = true; + } + + // HasComplexNonOptArgs + // + HasComplexPolyNonOptArgs:: + HasComplexPolyNonOptArgs (Context& c, + bool base, + bool& complex, + bool& poly, + bool& clash) + : Context (c), + complex_ (complex), + poly_ (poly), + clash_ (clash) + { + if (base) + *this >> inherits_ >> *this; + + *this >> names_ >> *this; + } + + void HasComplexPolyNonOptArgs:: + traverse (SemanticGraph::Complex& c) + { + // No optimizations: need to check every arg for clashes. + // + inherits (c, inherits_); + names (c, names_); + } + + void HasComplexPolyNonOptArgs:: + traverse (SemanticGraph::Element& e) + { + if (!skip (e) && min (e) == 1 && max (e) == 1) + { + bool poly (polymorphic && polymorphic_p (e.type ())); + + bool simple (true); + IsSimpleType t (simple); + t.dispatch (e.type ()); + + if (poly) + poly_ = true; + + if (!simple) + complex_ = true; + + if (poly && simple) + clash_ = false; + } + } + + // FromBaseCtorArg + // + FromBaseCtorArg:: + FromBaseCtorArg (Context& c, CtorArgType at, bool arg) + : Context (c), arg_type_ (at), arg_ (arg) + { + } + + void FromBaseCtorArg:: + traverse (SemanticGraph::Any& a) + { + if (!options.generate_wildcard ()) + return; + + if (min (a) == 1 && max (a) == 1) + { + String const& name (ename (a)); + + os << "," << endl + << "const " << xerces_ns << "::DOMElement&"; + + if (arg_) + os << " " << name; + } + } + + void FromBaseCtorArg:: + traverse (SemanticGraph::Element& e) + { + if (skip (e)) + return; + + if (min (e) == 1 && max (e) == 1) + { + String const& name (ename (e)); + + os << "," << endl; + + bool ptr (false); + + switch (arg_type_) + { + case CtorArgType::complex_auto_ptr: + { + bool simple (true); + IsSimpleType t (simple); + t.dispatch (e.type ()); + ptr = !simple; + break; + } + case CtorArgType::poly_auto_ptr: + { + ptr = polymorphic && polymorphic_p (e.type ()); + break; + } + case CtorArgType::type: + break; + } + + if (ptr) + os << auto_ptr << "< " << etype (e) << " >"; + else + os << "const " << etype (e) << "&"; + + if (arg_) + os << " " << name; + } + } + + void FromBaseCtorArg:: + traverse (SemanticGraph::Attribute& a) + { + // Note that we are not going to include attributes with + // default or required fixed values here. Instead we are + // going to default-initialize them. + // + if (min (a) == 1 && !a.fixed_p ()) + { + String const& name (ename (a)); + + os << "," << endl + << "const " << etype (a) << "&"; + + if (arg_) + os << " " << name; + } + } + + // CtorArgs + // + CtorArgs:: + CtorArgs (Context& c, CtorArgType at) + : Context (c), + arg_type_ (at), + base_arg_ (0), + first_ (true), + member_name_ (c) + { + *this >> inherits_ >> *this; + *this >> names_ >> *this; + } + + CtorArgs:: + CtorArgs (Context& c, CtorArgType at, String& base_arg) + : Context (c), + arg_type_ (at), + base_arg_ (&base_arg), + first_ (true), + member_name_ (c) + { + *this >> inherits_ >> *this; + *this >> names_ >> *this; + } + + void CtorArgs:: + traverse (SemanticGraph::Type& t) + { + os << comma () << "const "; + + member_name_.dispatch (t); + + os << "&"; + + if (base_arg_ != 0) + { + // IDREF templates don't have a name. + // + *base_arg_ = t.named_p () + ? (L"_xsd_" + ename (t) + L"_base") + : L"_xsd_base"; + + os << " " << *base_arg_; + } + } + + void CtorArgs:: + traverse (SemanticGraph::Enumeration& e) + { + os << comma () << "const "; + + member_name_.traverse (e); + + os << "&"; + + if (base_arg_ != 0) + { + *base_arg_ = L"_xsd_" + ename (e) + L"_base"; + + os << " " << *base_arg_; + } + } + + void CtorArgs:: + traverse (SemanticGraph::Any& a) + { + if (!options.generate_wildcard ()) + return; + + if (min (a) == 1 && max (a) == 1) + { + os << comma () << "const " << xerces_ns << "::DOMElement&"; + + if (base_arg_ != 0) + os << " " << ename (a); + } + } + + void CtorArgs:: + traverse (SemanticGraph::Element& e) + { + if (skip (e)) + return; + + if (min (e) == 1 && max (e) == 1) + { + bool ptr (false); + + switch (arg_type_) + { + case CtorArgType::complex_auto_ptr: + { + bool simple (true); + IsSimpleType t (simple); + t.dispatch (e.type ()); + ptr = !simple; + break; + } + case CtorArgType::poly_auto_ptr: + { + ptr = polymorphic && polymorphic_p (e.type ()); + break; + } + case CtorArgType::type: + break; + } + + if (ptr) + os << comma () << auto_ptr << "< " << etype (e) << " >"; + else + os << comma () << "const " << etype (e) << "&"; + + if (base_arg_ != 0) + os << " " << ename (e); + } + } + + void CtorArgs:: + traverse (SemanticGraph::Attribute& a) + { + // Note that we are not going to include attributes with + // default or required fixed values here. Instead we are + // going to default-initialize them. + // + if (min (a) == 1 && !a.fixed_p ()) + { + os << comma () << "const " << etype (a) << "&"; + + if (base_arg_ != 0) + os << " " << ename (a); + } + } + + String CtorArgs:: + comma () + { + bool tmp (first_); + first_ = false; + return tmp ? "" : ",\n"; + } + + + // CtorArgsWithoutBase + // + CtorArgsWithoutBase:: + CtorArgsWithoutBase (Context& c, CtorArgType at, bool arg, bool first) + : Context (c), arg_type_ (at), arg_ (arg), first_ (first) + { + *this >> inherits_ >> *this; + *this >> names_ >> *this; + } + + void CtorArgsWithoutBase:: + traverse (SemanticGraph::Any& a) + { + if (!options.generate_wildcard ()) + return; + + if (min (a) == 1 && max (a) == 1) + { + os << comma () << "const " << xerces_ns << "::DOMElement&"; + + if (arg_) + os << " " << ename (a); + } + } + + void CtorArgsWithoutBase:: + traverse (SemanticGraph::Element& e) + { + if (skip (e)) + return; + + if (min (e) == 1 && max (e) == 1) + { + bool ptr (false); + + switch (arg_type_) + { + case CtorArgType::complex_auto_ptr: + { + bool simple (true); + IsSimpleType t (simple); + t.dispatch (e.type ()); + ptr = !simple; + break; + } + case CtorArgType::poly_auto_ptr: + { + ptr = polymorphic && polymorphic_p (e.type ()); + break; + } + case CtorArgType::type: + break; + } + + if (ptr) + os << comma () << auto_ptr << "< " << etype (e) << " >"; + else + os << comma () << "const " << etype (e) << "&"; + + if (arg_) + os << " " << ename (e); + } + } + + void CtorArgsWithoutBase:: + traverse (SemanticGraph::Attribute& a) + { + // Note that we are not going to include attributes with + // default or required fixed values here. Instead we are + // going to default-initialize them. + // + if (min (a) == 1 && !a.fixed_p ()) + { + os << comma () << "const " << etype (a) << "&"; + + if (arg_) + os << " " << ename (a); + } + } + + String CtorArgsWithoutBase:: + comma () + { + bool tmp (first_); + first_ = false; + return tmp ? "" : ",\n"; + } + + // GlobalElementBase + // + bool GlobalElementBase:: + generate_p (SemanticGraph::Element& e) + { + if (e.substitutes_p () && ctx_.polymorphic) + return true; + + if (!doc_root_p (e)) + return false; + + // If we are not generating element types nor parsing/serialization + // code then we won't generate anything from it. + // + if (!ctx_.options.generate_element_type () && + ctx_.options.suppress_parsing () && + !ctx_.options.generate_serialization ()) + return false; + + return true; + } + + bool GlobalElementBase:: + doc_root_p (SemanticGraph::Element& e) + { + if (!ctx_.options.root_element_first () && + !ctx_.options.root_element_last () && + !ctx_.options.root_element_all () && + !ctx_.options.root_element_none () && + ctx_.options.root_element ().empty ()) + return true; // By default treat them all. + + if (ctx_.options.root_element_none ()) + return false; + + if (ctx_.options.root_element_all ()) + return true; + + if (ctx_.options.root_element_first () && + e.context ().count ("first") != 0) + return true; + + if (ctx_.options.root_element_last () && + e.context ().count ("last") != 0) + return true; + + NarrowStrings const& names (ctx_.options.root_element ()); + + // Hopefully nobody will specify more than a handful of names ;-). + // + for (NarrowStrings::const_iterator i (names.begin ()); + i != names.end (); ++i) + { + String name (*i); + + if (e.name () == name) + return true; + } + + return false; + } + + // Namespace + // + Namespace:: + Namespace (Context& c, + size_t first, + size_t last) + : CXX::Namespace (c, *this), + GlobalElementBase (c), + ctx_ (c), + first_ (first), + last_ (last), + count_ (0) + { + } + + void Namespace:: + traverse (Type& ns) + { + using SemanticGraph::Element; + + if (first_ > last_) + CXX::Namespace::traverse (ns); + else + { + bool opened (false); + + for (Type::NamesIterator i (ns.names_begin ()); + i != ns.names_end (); ++i) + { + SemanticGraph::Nameable& n (i->named ()); + + if (n.is_a () || + (n.is_a () && generate_p (dynamic_cast (n)))) + { + if (count_ >= first_ && count_ <= last_) + { + if (!opened) + { + opened = true; + pre (ns); + } + + edge_traverser ().dispatch (*i); + } + + ++count_; + } + } + + if (opened) + post (ns); + } + } + + void Namespace:: + enter (Type&, String const& name, bool) + { + ctx_.enter_ns_scope (name); + } + + void Namespace:: + leave () + { + ctx_.leave_ns_scope (); + } + + // Includes + // + void TypeForward:: + traverse (SemanticGraph::Type& t) + { + String const& name (ename (t)); + + if (String custom = custom_type (t)) + { + String new_name; + renamed_type (t, new_name); + + if (new_name) + os << "class " << new_name << ";"; + + if (custom == name) + os << "class " << name << ";"; + else + os << "typedef " << custom << " " << name << ";"; + } + else + os << "class " << name << ";"; + } + + void Includes:: + traverse_ (SemanticGraph::Uses& u) + { + // Support for weak (forward) inclusion used in the file-per-type + // compilation model. + // + Type t (type_); + bool weak (u.context ().count ("weak")); + SemanticGraph::Schema& s (u.schema ()); + + if (weak && t == header) + { + // Generate forward declarations. + // + if (forward_) + t = forward; + else + { + schema_.dispatch (s); + return; + } + } + + if (t == source && !weak) + { + if (u.user ().context ().count ("type-schema")) + { + // Strong include into a type schema -- this is a base class. + // We have already included its header in our header so it + // would seem we don't need to do anything here. There is one + // subtle issue, however: Our constructors include arguments + // for base members which we simply pass to the base. The base + // header has only forward declarations for its members. This + // is not a problem if we pass references to base members -- + // forward declarations are sufficient for this case. The + // problematic case is when we pass them as auto/unique_ptr. + // Because we pass them by value (which is done to support + // unique_ptr move semantics), the compiler needs to be able + // to destroy the member, presumably if an exception is thrown. + // And for that forward declarations are not enough. + // + // So what we are going to do here is include all the base + // member headers (transitively), just like the base's source + // file does. + // + // Note that we only do this for source since in the inline + // case the necessary files are already pulled via the the + // .ixx file includes. + // + Traversal::Schema schema; + schema >> *this; + schema.dispatch (s); + } + + return; + } + + SemanticGraph::Path path ( + s.context ().count ("renamed") + ? s.context ().get ("renamed") + : u.path ()); + path.normalize (); + + // Try to use the portable representation of the path. If that + // fails, fall back to the native representation. + // + NarrowString path_str; + try + { + path_str = path.posix_string (); + } + catch (SemanticGraph::InvalidPath const&) + { + path_str = path.string (); + } + + String inc_path; + + switch (t) + { + case forward: + { + inc_path = ctx_.fwd_expr->replace (path_str); + break; + } + case header: + case source: + { + inc_path = ctx_.hxx_expr->replace (path_str); + break; + } + case inline_: + { + if (weak) + { + inc_path = ctx_.hxx_expr->replace (path_str); + ctx_.os << "#include " << ctx_.process_include_path (inc_path) + << endl; + } + + inc_path = ctx_.ixx_expr->replace (path_str); + break; + } + } + + ctx_.os << "#include " << ctx_.process_include_path (inc_path) << endl + << endl; + } + } +} diff --git a/xsd/cxx/tree/elements.hxx b/xsd/cxx/tree/elements.hxx new file mode 100644 index 0000000..4d10def --- /dev/null +++ b/xsd/cxx/tree/elements.hxx @@ -0,0 +1,2122 @@ +// file : xsd/cxx/tree/elements.hxx +// license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +#ifndef XSD_CXX_TREE_ELEMENTS_HXX +#define XSD_CXX_TREE_ELEMENTS_HXX + +#include +#include +#include +#include +#include + +#include + +#include + +#include + +#include + +namespace CXX +{ + namespace Tree + { + struct Counts + { + Counts () + : global_types (0), + global_elements (0), + generated_global_elements (0), + complexity_total (0) + { + } + + size_t global_types; + size_t global_elements; + size_t generated_global_elements; + + // Complexity value for each global type and generated global + // element, in order. + // + std::vector complexity; + size_t complexity_total; + }; + + struct InvalidCustomTypeMapping + { + InvalidCustomTypeMapping (String const& mapping, + String const& reason) + : mapping_ (mapping), reason_ (reason) + { + } + + String const& + mapping () const + { + return mapping_; + } + + String const& + reason () const + { + return reason_; + } + + private: + String mapping_; + String reason_; + }; + + // A set of potentially qualified XML Schema type names. + // + struct TypeNameSet + { + template + TypeNameSet (I begin, I end) + { + for (; begin != end; ++begin) + insert (*begin); + } + + void + insert (String const& name) + { + size_t p (name.rfind ('#')); + + if (p == String::npos) + unames_.insert (name); + else + qnames_.insert (name); + } + + bool + find (SemanticGraph::Type& t) + { + if (!unames_.empty ()) + { + if (unames_.find (t.name ()) != unames_.end ()) + return true; + } + + if (!qnames_.empty ()) + { + if (qnames_.find (t.scope ().name () + L"#" + t.name ()) != + qnames_.end ()) + return true; + } + + return false; + } + + private: + typedef std::set StringSet; + + StringSet unames_; + StringSet qnames_; + }; + + // + // + class Context: public CXX::Context + { + public: + typedef cutl::re::regexsub Regex; + typedef cutl::re::wregex WideRegexPat; + + typedef Tree::options options_type; + + struct DirectCustomTypeMapInfo + { + DirectCustomTypeMapInfo (String const& t = L"", + String const& b = L"") + : type (t), base (b) + { + } + + String type; + String base; + }; + + struct RegexCustomTypeMapInfo + { + RegexCustomTypeMapInfo (WideRegexPat const& p, + String const& t, + String const& b) + : pat (p), type_sub (t), base_sub (b) + { + } + + WideRegexPat pat; + String type_sub; + String base_sub; + }; + + typedef std::vector RegexCustomTypeMap; + typedef std::map DirectCustomTypeMap; + + public: + Context (std::wostream& o, + SemanticGraph::Schema& root, + SemanticGraph::Path const& path, + options_type const& ops, + Counts const& counts_, + bool generate_xml_schema, + StringLiteralMap const*, + Regex const* fwd_expr, + Regex const* hxx_expr, + Regex const* ixx_expr); + + protected: + Context (Context& c); + Context (Context& c, std::wostream& o); + + // Custom type mapping. + // + public: + // Returns empty string if custom mapping is not required. + // + String + custom_type (SemanticGraph::Type const&) const; + + // Returns true if custom mapping is required. name is + // populated with the custom type name or empty if the + // original name should be used. + // + bool + custom_type (SemanticGraph::Type const&, String& name) const; + + // Returns true if this type has been renamed as part of the + // customization process. If the function returns true, the + // name string is populated with the new name or empty if + // the type should not be generated at all. + // + bool + renamed_type (SemanticGraph::Type const&, String& name) const; + + public: + // Performs a number of processing steps, including forcing a new + // line after 80 characters as well as "commentizing" the text by + // adding '* ' after each newline. + // + void + write_annotation (SemanticGraph::Annotation&); + + // + // + public: + static bool + ordered_p (SemanticGraph::Type const& t) + { + return t.context ().count ("ordered") && + t.context ().get ("ordered"); + } + + // Check if we are generating mixed support for this type. We only + // do it for ordered types. + // + static bool + mixed_p (SemanticGraph::Complex const& c) + { + return c.mixed_p () && ordered_p (c); + } + + bool + polymorphic_p (SemanticGraph::Type&); + + bool + anonymous_p (SemanticGraph::Type const& t) + { + return t.context ().count ("anonymous"); + } + + // Return true if this anonymous type is defined in an element + // that belongs to a substitution group. + // + bool + anonymous_substitutes_p (SemanticGraph::Type&); + + // Escaped names. + // + public: + // Accessor name. + // + static String const& + eaname (SemanticGraph::Member const& m) + { + return m.context ().get ("aname"); + } + + static String const& + eaname (SemanticGraph::Any const& a) + { + return a.context ().get ("aname"); + } + + static String const& + eaname (SemanticGraph::AnyAttribute const& a) + { + return a.context ().get ("aname"); + } + + // Modifier name. + // + static String const& + emname (SemanticGraph::Member const& m) + { + return m.context ().get ("mname"); + } + + static String const& + emname (SemanticGraph::Any const& a) + { + return a.context ().get ("mname"); + } + + static String const& + emname (SemanticGraph::AnyAttribute const& a) + { + return a.context ().get ("mname"); + } + + // Detach name. + // + static String const& + edname (SemanticGraph::Member const& m) + { + return m.context ().get ("dname"); + } + + // + // + static String const& + etype (SemanticGraph::Member const& m) + { + return m.context ().get ("type"); + } + + static String const& + etraits (SemanticGraph::Member const& m) + { + return m.context ().get ("traits"); + } + + static String const& + econtainer (SemanticGraph::Member const& m) + { + return m.context ().get ("container"); + } + + static String const& + econtainer (SemanticGraph::Any const& a) + { + return a.context ().get ("container"); + } + + static String const& + econtainer (SemanticGraph::AnyAttribute const& a) + { + return a.context ().get ("container"); + } + + static String const& + eiterator (SemanticGraph::Member const& m) + { + return m.context ().get ("iterator"); + } + + static String const& + eiterator (SemanticGraph::Any const& a) + { + return a.context ().get ("iterator"); + } + + static String const& + eiterator (SemanticGraph::AnyAttribute const& a) + { + return a.context ().get ("iterator"); + } + + static String const& + econst_iterator (SemanticGraph::Member const& m) + { + return m.context ().get ("const-iterator"); + } + + static String const& + econst_iterator (SemanticGraph::Any const& a) + { + return a.context ().get ("const-iterator"); + } + + static String const& + econst_iterator (SemanticGraph::AnyAttribute const& a) + { + return a.context ().get ("const-iterator"); + } + + static String const& + emember (SemanticGraph::Member const& m) + { + return m.context ().get ("member"); + } + + static String const& + emember (SemanticGraph::Any const& a) + { + return a.context ().get ("member"); + } + + static String const& + emember (SemanticGraph::AnyAttribute const& a) + { + return a.context ().get ("member"); + } + + static String const& + edefault_value (SemanticGraph::Member const& m) + { + return m.context ().get ("default-value"); + } + + static String const& + edefault_value_member (SemanticGraph::Member const& m) + { + return m.context ().get ("default-value-member"); + } + + // Underlying enum value type. + // + static String const& + evalue (SemanticGraph::Enumeration const& e) + { + return e.context ().get ("value"); + } + + // dom_document + // + static bool + edom_document_p (SemanticGraph::Complex const& c) + { + return c.context ().count ("dom-document"); + } + + static String const& + edom_document (SemanticGraph::Complex const& c) + { + return c.context ().get ("dom-document"); + } + + static bool + edom_document_member_p (SemanticGraph::Complex const& c) + { + return c.context ().count ("dom-document-member"); + } + + static String const& + edom_document_member (SemanticGraph::Complex const& c) + { + return c.context ().get ("dom-document-member"); + } + + // Parsing and serialization function names. + // + static String const& + eparser (SemanticGraph::Element const& e) + { + return e.context ().get ("parser"); + } + + static String const& + eserializer (SemanticGraph::Element const& e) + { + return e.context ().get ("serializer"); + } + + public: + void + enter_ns_scope (String const& name) + { + ns_scope_stack.push_back (name); + update_ns_scope (); + } + + void + leave_ns_scope () + { + ns_scope_stack.pop_back (); + update_ns_scope (); + } + + private: + void + update_ns_scope (); + + private: + // Write text that may contain characters that we will have + // to escape (indicated by the rogue flag). + // + void + write_rogue_text (wchar_t const* s, size_t size, bool rogue); + + public: + options_type const& options; + Counts const& counts; + String& any_type; + String& any_simple_type; + String& element_type; + String& container; + String& flags_type; + String& qname_type; + String& xs_string_type; + String& properties_type; + String& error_handler_type; + String& list_stream_type; + String& namespace_infomap_type; + String& parser_type; + String& std_ostream_type; + String& ostream_type; + String& istream_type; + String& xerces_ns; + String& dom_auto_ptr; + String& dom_node_key; + String& as_double_type; + String& as_decimal_type; + + bool& generate_xml_schema; + bool& doxygen; + bool polymorphic; + bool polymorphic_all; + unsigned long poly_plate; + bool detach; + + Regex const* fwd_expr; + Regex const* hxx_expr; + Regex const* ixx_expr; + + String& ns_scope; + + RegexCustomTypeMap& regex_custom_type_map; + DirectCustomTypeMap& direct_custom_type_map; + + private: + String any_type_; + String any_simple_type_; + String element_type_; + String container_; + String flags_type_; + String qname_type_; + String xs_string_type_; + String properties_type_; + String error_handler_type_; + String list_stream_type_; + String namespace_infomap_type_; + String parser_type_; + String std_ostream_type_; + String ostream_type_; + String istream_type_; + String xerces_ns_; + String dom_auto_ptr_; + String dom_node_key_; + String as_double_type_; + String as_decimal_type_; + + bool generate_xml_schema_; + bool doxygen_; + + typedef std::deque NamespaceStack; + typedef std::deque ScopeStack; + + String ns_scope_; + + NamespaceStack& ns_scope_stack; + NamespaceStack ns_scope_stack_; + + RegexCustomTypeMap regex_custom_type_map_; + DirectCustomTypeMap direct_custom_type_map_; + + private: + WideRegexPat const cxx_uq_id_expr_; + WideRegexPat const& cxx_uq_id_expr; + }; + + // Check whether this Schema type maps to a fundamental C++ type. + // + struct IsFundamentalType: Traversal::Fundamental::Byte, + Traversal::Fundamental::UnsignedByte, + Traversal::Fundamental::Short, + Traversal::Fundamental::UnsignedShort, + Traversal::Fundamental::Int, + Traversal::Fundamental::UnsignedInt, + Traversal::Fundamental::Long, + Traversal::Fundamental::UnsignedLong, + Traversal::Fundamental::Integer, + Traversal::Fundamental::NonPositiveInteger, + Traversal::Fundamental::NonNegativeInteger, + Traversal::Fundamental::PositiveInteger, + Traversal::Fundamental::NegativeInteger, + + Traversal::Fundamental::Boolean, + + Traversal::Fundamental::Float, + Traversal::Fundamental::Double, + Traversal::Fundamental::Decimal + + { + IsFundamentalType (bool& r) + : r_ (r) + { + } + + // Integral types. + // + virtual void + traverse (SemanticGraph::Fundamental::Byte&) + { + r_ = true; + } + + virtual void + traverse (SemanticGraph::Fundamental::UnsignedByte&) + { + r_ = true; + } + + virtual void + traverse (SemanticGraph::Fundamental::Short&) + { + r_ = true; + } + + virtual void + traverse (SemanticGraph::Fundamental::UnsignedShort&) + { + r_ = true; + } + + virtual void + traverse (SemanticGraph::Fundamental::Int&) + { + r_ = true; + } + + virtual void + traverse (SemanticGraph::Fundamental::UnsignedInt&) + { + r_ = true; + } + + virtual void + traverse (SemanticGraph::Fundamental::Long&) + { + r_ = true; + } + + virtual void + traverse (SemanticGraph::Fundamental::UnsignedLong&) + { + r_ = true; + } + + virtual void + traverse (SemanticGraph::Fundamental::Integer&) + { + r_ = true; + } + + virtual void + traverse (SemanticGraph::Fundamental::NonPositiveInteger&) + { + r_ = true; + } + + virtual void + traverse (SemanticGraph::Fundamental::NonNegativeInteger&) + { + r_ = true; + } + + virtual void + traverse (SemanticGraph::Fundamental::PositiveInteger&) + { + r_ = true; + } + + virtual void + traverse (SemanticGraph::Fundamental::NegativeInteger&) + { + r_ = true; + } + + // Boolean. + // + virtual void + traverse (SemanticGraph::Fundamental::Boolean&) + { + r_ = true; + } + + // Floats. + // + virtual void + traverse (SemanticGraph::Fundamental::Float&) + { + r_ = true; + } + + virtual void + traverse (SemanticGraph::Fundamental::Double&) + { + r_ = true; + } + + virtual void + traverse (SemanticGraph::Fundamental::Decimal&) + { + r_ = true; + } + + private: + bool& r_; + }; + + // Check whether this is a string-based type. + // + struct IsStringBasedType: Traversal::Complex, + Traversal::Union, + Traversal::Fundamental::String, + Traversal::Fundamental::NormalizedString, + Traversal::Fundamental::Token, + Traversal::Fundamental::Name, + Traversal::Fundamental::NameToken, + Traversal::Fundamental::NCName, + Traversal::Fundamental::Language + { + IsStringBasedType (bool& r) + : r_ (r) + { + *this >> inherits_ >> *this; + } + + virtual void + traverse (SemanticGraph::Complex& c) + { + inherits (c, inherits_); + } + + virtual void + traverse (SemanticGraph::Union&) + { + // Current mapping of union is string-based. + // + r_ = true; + } + + // Strings. + // + virtual void + traverse (SemanticGraph::Fundamental::String&) + { + r_ = true; + } + + virtual void + traverse (SemanticGraph::Fundamental::NormalizedString&) + { + r_ = true; + } + + virtual void + traverse (SemanticGraph::Fundamental::Token&) + { + r_ = true; + } + + virtual void + traverse (SemanticGraph::Fundamental::NameToken&) + { + r_ = true; + } + + virtual void + traverse (SemanticGraph::Fundamental::Name&) + { + r_ = true; + } + + virtual void + traverse (SemanticGraph::Fundamental::NCName&) + { + r_ = true; + } + + virtual void + traverse (SemanticGraph::Fundamental::Language&) + { + r_ = true; + } + + private: + bool& r_; + Traversal::Inherits inherits_; + }; + + + // Check whether this is a enumeration-based type. + // + struct IsEnumBasedType: Traversal::Complex + { + IsEnumBasedType (SemanticGraph::Enumeration*& e) + : enum_ (e) + { + *this >> inherits_; + + inherits_ >> *this; + inherits_ >> enum_; + } + + virtual void + traverse (SemanticGraph::Complex& c) + { + inherits (c, inherits_); + } + + private: + struct Enumeration: Traversal::Enumeration + { + Enumeration (SemanticGraph::Enumeration*& e) + : e_ (e) + { + } + + virtual void + traverse (Type& e) + { + if (e_ == 0) + e_ = &e; + } + + private: + SemanticGraph::Enumeration*& e_; + }; + + + private: + Enumeration enum_; + Traversal::Inherits inherits_; + }; + + + // + // + struct MemberTypeName : Context, + Traversal::Type, + Traversal::List, + Traversal::Union, + Traversal::Complex, + + Traversal::AnyType, + Traversal::AnySimpleType, + + Traversal::Fundamental::Byte, + Traversal::Fundamental::UnsignedByte, + Traversal::Fundamental::Short, + Traversal::Fundamental::UnsignedShort, + Traversal::Fundamental::Int, + Traversal::Fundamental::UnsignedInt, + Traversal::Fundamental::Long, + Traversal::Fundamental::UnsignedLong, + Traversal::Fundamental::Integer, + Traversal::Fundamental::NonPositiveInteger, + Traversal::Fundamental::NonNegativeInteger, + Traversal::Fundamental::PositiveInteger, + Traversal::Fundamental::NegativeInteger, + + Traversal::Fundamental::Boolean, + + Traversal::Fundamental::Float, + Traversal::Fundamental::Double, + Traversal::Fundamental::Decimal, + + Traversal::Fundamental::String, + Traversal::Fundamental::NormalizedString, + Traversal::Fundamental::Token, + Traversal::Fundamental::Name, + Traversal::Fundamental::NameToken, + Traversal::Fundamental::NameTokens, + Traversal::Fundamental::NCName, + Traversal::Fundamental::Language, + + Traversal::Fundamental::QName, + + Traversal::Fundamental::Id, + Traversal::Fundamental::IdRef, + Traversal::Fundamental::IdRefs, + + Traversal::Fundamental::AnyURI, + + Traversal::Fundamental::Base64Binary, + Traversal::Fundamental::HexBinary, + + Traversal::Fundamental::Date, + Traversal::Fundamental::DateTime, + Traversal::Fundamental::Duration, + Traversal::Fundamental::Day, + Traversal::Fundamental::Month, + Traversal::Fundamental::MonthDay, + Traversal::Fundamental::Year, + Traversal::Fundamental::YearMonth, + Traversal::Fundamental::Time, + + Traversal::Fundamental::Entity, + Traversal::Fundamental::Entities + + { + MemberTypeName (Context& c) + : Context (c) + { + } + + MemberTypeName (Context& c, std::wostream& o) + : Context (c, o) + { + } + + virtual void + traverse (SemanticGraph::Type&) + { + abort (); + } + + virtual void + traverse (SemanticGraph::List& l) + { + os << fq_name (l); + } + + virtual void + traverse (SemanticGraph::Union& u) + { + os << fq_name (u); + } + + virtual void + traverse (SemanticGraph::Complex& c) + { + os << fq_name (c); + } + + // anyType & anySimpleType. + // + virtual void + traverse (SemanticGraph::AnyType& t) + { + os << fq_name (t); + } + + virtual void + traverse (SemanticGraph::AnySimpleType& t) + { + os << fq_name (t); + } + + // Integral types. + // + virtual void + traverse (SemanticGraph::Fundamental::Byte& t) + { + os << fq_name (t); + } + + virtual void + traverse (SemanticGraph::Fundamental::UnsignedByte& t) + { + os << fq_name (t); + } + + virtual void + traverse (SemanticGraph::Fundamental::Short& t) + { + os << fq_name (t); + } + + virtual void + traverse (SemanticGraph::Fundamental::UnsignedShort& t) + { + os << fq_name (t); + } + + virtual void + traverse (SemanticGraph::Fundamental::Int& t) + { + os << fq_name (t); + } + + virtual void + traverse (SemanticGraph::Fundamental::UnsignedInt& t) + { + os << fq_name (t); + } + + virtual void + traverse (SemanticGraph::Fundamental::Long& t) + { + os << fq_name (t); + } + + virtual void + traverse (SemanticGraph::Fundamental::UnsignedLong& t) + { + os << fq_name (t); + } + + virtual void + traverse (SemanticGraph::Fundamental::Integer& t) + { + os << fq_name (t); + } + + virtual void + traverse (SemanticGraph::Fundamental::NonPositiveInteger& t) + { + os << fq_name (t); + } + + virtual void + traverse (SemanticGraph::Fundamental::NonNegativeInteger& t) + { + os << fq_name (t); + } + + virtual void + traverse (SemanticGraph::Fundamental::PositiveInteger& t) + { + os << fq_name (t); + } + + virtual void + traverse (SemanticGraph::Fundamental::NegativeInteger& t) + { + os << fq_name (t); + } + + // Boolean. + // + virtual void + traverse (SemanticGraph::Fundamental::Boolean& t) + { + os << fq_name (t); + } + + // Floats. + // + virtual void + traverse (SemanticGraph::Fundamental::Float& t) + { + os << fq_name (t); + } + + virtual void + traverse (SemanticGraph::Fundamental::Double& t) + { + os << fq_name (t); + } + + virtual void + traverse (SemanticGraph::Fundamental::Decimal& t) + { + os << fq_name (t); + } + + // Strings. + // + virtual void + traverse (SemanticGraph::Fundamental::String& t) + { + os << fq_name (t); + } + + virtual void + traverse (SemanticGraph::Fundamental::NormalizedString& t) + { + os << fq_name (t); + } + + virtual void + traverse (SemanticGraph::Fundamental::Token& t) + { + os << fq_name (t); + } + + virtual void + traverse (SemanticGraph::Fundamental::NameToken& t) + { + os << fq_name (t); + } + + virtual void + traverse (SemanticGraph::Fundamental::NameTokens& t) + { + os << fq_name (t); + } + + virtual void + traverse (SemanticGraph::Fundamental::Name& t) + { + os << fq_name (t); + } + + virtual void + traverse (SemanticGraph::Fundamental::NCName& t) + { + os << fq_name (t); + } + + virtual void + traverse (SemanticGraph::Fundamental::Language& t) + { + os << fq_name (t); + } + + + // Qualified name. + // + virtual void + traverse (SemanticGraph::Fundamental::QName& t) + { + os << fq_name (t); + } + + + // ID/IDREF. + // + virtual void + traverse (SemanticGraph::Fundamental::Id& t) + { + os << fq_name (t); + } + + virtual void + traverse (SemanticGraph::Fundamental::IdRef& t) + { + if (t.named_p ()) + { + // IDREF + // + os << fq_name (t); + } + else + { + SemanticGraph::Nameable& ncname ( + xs_ns ().find ("NCName").first->named ()); + + os << "::xsd::cxx::tree::idref< " << char_type << ", " << + fq_name (ncname) << ", " << + type_name (t.argumented ().type ()) << " >"; + } + } + + virtual void + traverse (SemanticGraph::Fundamental::IdRefs& t) + { + if (t.named_p ()) + { + // IDREFS + // + os << fq_name (t); + } + else + { + SemanticGraph::Nameable& ncname ( + xs_ns ().find ("NCName").first->named ()); + + os << "::xsd::cxx::tree::idrefs< " << char_type << ", " << + any_simple_type << ", ::xsd::cxx::tree::idref< " << + char_type << ", " << fq_name (ncname) << ", " << + type_name (t.argumented ().type ()) << " > >"; + } + } + + // URI. + // + virtual void + traverse (SemanticGraph::Fundamental::AnyURI& t) + { + os << fq_name (t); + } + + // Binary. + // + virtual void + traverse (SemanticGraph::Fundamental::Base64Binary& t) + { + os << fq_name (t); + } + + virtual void + traverse (SemanticGraph::Fundamental::HexBinary& t) + { + os << fq_name (t); + } + + + // Date/time. + // + virtual void + traverse (SemanticGraph::Fundamental::Date& t) + { + os << fq_name (t); + } + + virtual void + traverse (SemanticGraph::Fundamental::DateTime& t) + { + os << fq_name (t); + } + + virtual void + traverse (SemanticGraph::Fundamental::Duration& t) + { + os << fq_name (t); + } + + virtual void + traverse (SemanticGraph::Fundamental::Day& t) + { + os << fq_name (t); + } + + virtual void + traverse (SemanticGraph::Fundamental::Month& t) + { + os << fq_name (t); + } + + virtual void + traverse (SemanticGraph::Fundamental::MonthDay& t) + { + os << fq_name (t); + } + + virtual void + traverse (SemanticGraph::Fundamental::Year& t) + { + os << fq_name (t); + } + + virtual void + traverse (SemanticGraph::Fundamental::YearMonth& t) + { + os << fq_name (t); + } + + virtual void + traverse (SemanticGraph::Fundamental::Time& t) + { + os << fq_name (t); + } + + // Entity. + // + virtual void + traverse (SemanticGraph::Fundamental::Entity& t) + { + os << fq_name (t); + } + + virtual void + traverse (SemanticGraph::Fundamental::Entities& t) + { + os << fq_name (t); + } + + private: + // For idref/idrefs + // + String + type_name (SemanticGraph::Type& t) + { + // This type is always named. + // + std::wostringstream o; + + MemberTypeName type (*this, o); + type.dispatch (t); + + return o.str (); + } + }; + + + // + // + struct BaseTypeName : MemberTypeName + { + BaseTypeName (Context& c) + : MemberTypeName (c) + { + } + + BaseTypeName (Context& c, std::wostream& o) + : MemberTypeName (c, o) + { + } + + virtual void + fundamental_base (SemanticGraph::Type& t) + { + os << "::xsd::cxx::tree::fundamental_base< " << + fq_name (t) << ", " << char_type << ", " << + any_simple_type << " >"; + } + + // Integrals. + // + virtual void + traverse (SemanticGraph::Fundamental::Byte& t) + { + fundamental_base (t); + } + + virtual void + traverse (SemanticGraph::Fundamental::UnsignedByte& t) + { + fundamental_base (t); + } + + virtual void + traverse (SemanticGraph::Fundamental::Short& t) + { + fundamental_base (t); + } + + virtual void + traverse (SemanticGraph::Fundamental::UnsignedShort& t) + { + fundamental_base (t); + } + + virtual void + traverse (SemanticGraph::Fundamental::Int& t) + { + fundamental_base (t); + } + + virtual void + traverse (SemanticGraph::Fundamental::UnsignedInt& t) + { + fundamental_base (t); + } + + virtual void + traverse (SemanticGraph::Fundamental::Long& t) + { + fundamental_base (t); + } + + virtual void + traverse (SemanticGraph::Fundamental::UnsignedLong& t) + { + fundamental_base (t); + } + + virtual void + traverse (SemanticGraph::Fundamental::Integer& t) + { + fundamental_base (t); + } + + virtual void + traverse (SemanticGraph::Fundamental::NonPositiveInteger& t) + { + fundamental_base (t); + } + + virtual void + traverse (SemanticGraph::Fundamental::NonNegativeInteger& t) + { + fundamental_base (t); + } + + virtual void + traverse (SemanticGraph::Fundamental::PositiveInteger& t) + { + fundamental_base (t); + } + + virtual void + traverse (SemanticGraph::Fundamental::NegativeInteger& t) + { + fundamental_base (t); + } + + // Boolean. + // + virtual void + traverse (SemanticGraph::Fundamental::Boolean& t) + { + fundamental_base (t); + } + + // Floats. + // + virtual void + traverse (SemanticGraph::Fundamental::Float& t) + { + fundamental_base (t); + } + + virtual void + traverse (SemanticGraph::Fundamental::Double& t) + { + os << "::xsd::cxx::tree::fundamental_base< " << + fq_name (t) << ", " << char_type << ", " << + any_simple_type << ", " << + "::xsd::cxx::tree::schema_type::double_ >"; + } + + virtual void + traverse (SemanticGraph::Fundamental::Decimal& t) + { + os << "::xsd::cxx::tree::fundamental_base< " << + fq_name (t) << ", " << char_type << ", " << + any_simple_type << ", " << + "::xsd::cxx::tree::schema_type::decimal >"; + } + }; + + // Initial value should be true. + // + struct IsSimpleType: Traversal::Complex, + Traversal::Member, + Traversal::Any, + Traversal::AnyAttribute + { + IsSimpleType (bool& v) + : v_ (v) + { + *this >> names_ >> *this; + *this >> inherits_ >> *this; + } + + virtual void + traverse (SemanticGraph::Complex& c) + { + if (c.mixed_p ()) + v_ = false; + + if (v_) + names (c, names_); + + if (v_) + inherits (c, inherits_); + } + + virtual void + traverse (SemanticGraph::Member&) + { + v_ = false; + } + + virtual void + traverse (SemanticGraph::Any&) + { + v_ = false; + } + + virtual void + traverse (SemanticGraph::AnyAttribute&) + { + v_ = false; + } + + private: + bool& v_; + Traversal::Names names_; + Traversal::Inherits inherits_; + }; + + // Test whether we need to generate default c-tor. Note that we are not + // interested in anyAttribute since it is always mapped to a sequence. + // + struct GenerateDefaultCtor: Traversal::Complex, + Traversal::Enumeration, + Traversal::Type, + Traversal::Element, + Traversal::Attribute, + Traversal::Any, + Context + { + // generate should initially be false. + // + GenerateDefaultCtor (Context&, bool& generate, bool no_base); + + virtual void + traverse (SemanticGraph::Complex&); + + virtual void + traverse (SemanticGraph::Type&); + + virtual void + traverse (SemanticGraph::Enumeration&); + + virtual void + traverse (SemanticGraph::Element&); + + virtual void + traverse (SemanticGraph::Attribute&); + + virtual void + traverse (SemanticGraph::Any&); + + private: + bool& generate_; + bool no_base_; + + private: + Traversal::Inherits inherits_; + Traversal::Names names_; + }; + + // Test whether we need to generate from-base c-tor. + // + struct GenerateFromBaseCtor: Traversal::Complex + { + // generate should initially be false. + // + GenerateFromBaseCtor (Context& c, bool& generate); + + virtual void + traverse (SemanticGraph::Complex& c); + + private: + bool& generate_; + bool custom_; + + // Note that we are not interested in anyAttribute since it is always + // mapped to a sequence. + // + struct Traverser: Traversal::Type, + Traversal::Complex, + Traversal::Element, + Traversal::Attribute, + Traversal::Any, + Context + { + Traverser (Context& c, bool& generate, bool& custom); + + virtual void + traverse (SemanticGraph::Type&); + + virtual void + traverse (SemanticGraph::Complex&); + + virtual void + traverse (SemanticGraph::Attribute&); + + virtual void + traverse (SemanticGraph::Element&); + + virtual void + traverse (SemanticGraph::Any&); + + private: + bool& generate_; + bool& custom_; + + private: + Traversal::Inherits inherits_; + Traversal::Names names_; + } traverser_; + + Traversal::Inherits inherits_; + }; + + // Test whether the type has any non-optional element of complex + // (has attributes/elements) and polymorpjic types. + // + struct HasComplexPolyNonOptArgs: Traversal::Complex, + Traversal::Element, + Context + { + // complex and poly should initially be false. clash + // should initially be true. + // + HasComplexPolyNonOptArgs (Context& c, + bool including_base, + bool& complex, + bool& poly, + bool& clash); + + virtual void + traverse (SemanticGraph::Complex&); + + virtual void + traverse (SemanticGraph::Element&); + + private: + bool& complex_; + bool& poly_; + bool& clash_; + + Traversal::Inherits inherits_; + Traversal::Names names_; + }; + + // Contructor argument types. + // + struct CtorArgType + { + enum Value + { + type, + complex_auto_ptr, + poly_auto_ptr + }; + + CtorArgType (Value v = Value (0)) : v_ (v) {} + operator Value () const {return v_;} + + private: + Value v_; + }; + + // Immediate non-optional member. Note that AnyAttribute is always + // mapped to a sequence. + // + struct FromBaseCtorArg: Traversal::Any, + Traversal::Element, + Traversal::Attribute, + Context + { + FromBaseCtorArg (Context& c, CtorArgType, bool arg); + + virtual void + traverse (SemanticGraph::Any&); + + virtual void + traverse (SemanticGraph::Attribute&); + + virtual void + traverse (SemanticGraph::Element&); + + private: + CtorArgType arg_type_; + bool arg_; + }; + + // List of all non-optional members and a simple base. Note that + // AnyAttribute is always mapped to a sequence. + // + struct CtorArgs: Traversal::Complex, + Traversal::Enumeration, + Traversal::Type, + Traversal::Any, + Traversal::Element, + Traversal::Attribute, + Context + { + using Complex::traverse; + + // The second version outputs the argument name and stores + // in in the base_arg string. + // + CtorArgs (Context&, CtorArgType); + CtorArgs (Context&, CtorArgType, String& base_arg); + + virtual void + traverse (SemanticGraph::Type&); + + virtual void + traverse (SemanticGraph::Enumeration&); + + virtual void + traverse (SemanticGraph::Any&); + + virtual void + traverse (SemanticGraph::Attribute&); + + virtual void + traverse (SemanticGraph::Element&); + + private: + String + comma (); + + private: + CtorArgType arg_type_; + String base_; + String* base_arg_; + bool first_; + + private: + Traversal::Inherits inherits_; + Traversal::Names names_; + + MemberTypeName member_name_; + }; + + + // Check whether we need to generate c-tor without the base argument. + // + struct GenerateWithoutBaseCtor: Traversal::List, + Traversal::Union, + Traversal::Complex, + Traversal::Enumeration, + + Traversal::AnyType, + Traversal::AnySimpleType, + + Traversal::Fundamental::String, + Traversal::Fundamental::NormalizedString, + Traversal::Fundamental::Token, + + Traversal::Fundamental::NameTokens, + Traversal::Fundamental::IdRefs, + + Traversal::Fundamental::Base64Binary, + Traversal::Fundamental::HexBinary + { + // generate should initially be false. + // + GenerateWithoutBaseCtor (bool& generate) + : generate_ (generate) + { + *this >> inherits_ >> *this; + } + + virtual void + traverse (SemanticGraph::List&) + { + generate_ = true; + } + + virtual void + traverse (SemanticGraph::Union&) + { + // No default initialization. + } + + virtual void + traverse (SemanticGraph::Complex& c) + { + Complex::inherits (c); + } + + virtual void + traverse (SemanticGraph::Enumeration&) + { + // No default initialization. + } + + virtual void + traverse (SemanticGraph::AnyType&) + { + generate_ = true; + } + + virtual void + traverse (SemanticGraph::AnySimpleType&) + { + generate_ = true; + } + + virtual void + traverse (SemanticGraph::Fundamental::String&) + { + generate_ = true; + } + + virtual void + traverse (SemanticGraph::Fundamental::NormalizedString&) + { + generate_ = true; + } + + virtual void + traverse (SemanticGraph::Fundamental::Token&) + { + generate_ = true; + } + + virtual void + traverse (SemanticGraph::Fundamental::NameTokens&) + { + generate_ = true; + } + + virtual void + traverse (SemanticGraph::Fundamental::IdRefs&) + { + generate_ = true; + } + + virtual void + traverse (SemanticGraph::Fundamental::Base64Binary&) + { + generate_ = true; + } + + virtual void + traverse (SemanticGraph::Fundamental::HexBinary&) + { + generate_ = true; + } + + private: + bool& generate_; + Traversal::Inherits inherits_; + }; + + + // List of all non-optional members sans simple base. Note that + // AnyAttribute is always mapped to a sequence. + // + struct CtorArgsWithoutBase: Traversal::Complex, + Traversal::Any, + Traversal::Element, + Traversal::Attribute, + Context + { + using Complex::traverse; + + CtorArgsWithoutBase (Context& c, CtorArgType, bool arg, bool first); + + virtual void + traverse (SemanticGraph::Any&); + + virtual void + traverse (SemanticGraph::Element&); + + virtual void + traverse (SemanticGraph::Attribute&); + + private: + String + comma (); + + private: + CtorArgType arg_type_; + bool arg_; + bool first_; + + private: + Traversal::Inherits inherits_; + Traversal::Names names_; + }; + + // + // + struct GlobalElementBase + { + GlobalElementBase (Context& c) + : ctx_ (c) + { + } + + bool + generate_p (SemanticGraph::Element&); + + bool + doc_root_p (SemanticGraph::Element&); + + private: + Context& ctx_; + }; + + + // + // + struct Namespace: CXX::Namespace, + GlobalElementBase, + CXX::Namespace::ScopeTracker + { + Namespace (Context&, + size_t first = 1, + size_t last = 0); + + virtual void + traverse (Type&); + + protected: + virtual void + enter (Type&, String const& name, bool last); + + virtual void + leave (); + + protected: + Context& ctx_; + + private: + size_t first_; + size_t last_; + size_t count_; + }; + + // + // + struct DocumentedNamespace: Namespace + { + DocumentedNamespace (Context& c) + : Namespace (c) + { + } + + virtual void + enter (Type& ns, String const& name, bool last) + { + Namespace::enter (ns, name, last); + + // Only add documentation to the innermost namespace. + // + if (ctx_.doxygen && name && last) + { + ctx_.os << "/**" << endl + << " * @brief C++ namespace for the %" << + ctx_.comment (ns.name ()) << endl + << " * schema namespace." << endl + << " */" << endl; + } + } + }; + + // + // + struct TypeForward: Traversal::Type, Context + { + TypeForward (Context& c) + : Context (c) + { + } + + virtual void + traverse (SemanticGraph::Type& t); + }; + + struct Includes: Traversal::Imports, + Traversal::Includes + { + enum Type + { + forward, + header, + inline_, + source + }; + + Includes (Context& c, Type type) + : ctx_ (c), + type_ (type), + forward_ (c.options.generate_forward ()), + namespace_ (c), + type_forward_ (c) + { + schema_ >> schema_names_ >> namespace_ >> names_ >> type_forward_; + } + + virtual void + traverse (SemanticGraph::Imports& i) + { + traverse_ (i); + } + + virtual void + traverse (SemanticGraph::Includes& i) + { + traverse_ (i); + } + + private: + void + traverse_ (SemanticGraph::Uses&); + + private: + Context& ctx_; + Type type_; + bool forward_; + + Traversal::Schema schema_; + Traversal::Names schema_names_; + Namespace namespace_; + Traversal::Names names_; + TypeForward type_forward_; + }; + + // + // + struct FundIncludes: Traversal::Fundamental::Byte, + Traversal::Fundamental::UnsignedByte, + Traversal::Fundamental::Short, + Traversal::Fundamental::UnsignedShort, + Traversal::Fundamental::Int, + Traversal::Fundamental::UnsignedInt, + Traversal::Fundamental::Long, + Traversal::Fundamental::UnsignedLong, + Traversal::Fundamental::Integer, + Traversal::Fundamental::NonPositiveInteger, + Traversal::Fundamental::NonNegativeInteger, + Traversal::Fundamental::PositiveInteger, + Traversal::Fundamental::NegativeInteger, + + Traversal::Fundamental::Boolean, + + Traversal::Fundamental::Float, + Traversal::Fundamental::Double, + Traversal::Fundamental::Decimal, + Context + { + FundIncludes (Context& c, String const& prefix) + : Context (c), prefix_ (prefix), + long_ (false), unsigned_long_ (false) + { + } + + // Integral types. + // + virtual void + traverse (SemanticGraph::Fundamental::Byte& t) + { + gen_include (t, "byte.hxx"); + } + + virtual void + traverse (SemanticGraph::Fundamental::UnsignedByte& t) + { + gen_include (t, "unsigned-byte.hxx"); + } + + virtual void + traverse (SemanticGraph::Fundamental::Short& t) + { + gen_include (t, "short.hxx"); + } + + virtual void + traverse (SemanticGraph::Fundamental::UnsignedShort& t) + { + gen_include (t, "unsigned-short.hxx"); + } + + virtual void + traverse (SemanticGraph::Fundamental::Int& t) + { + gen_include (t, "int.hxx"); + } + + virtual void + traverse (SemanticGraph::Fundamental::UnsignedInt& t) + { + gen_include (t, "unsigned-int.hxx"); + } + + virtual void + traverse (SemanticGraph::Fundamental::Long& t) + { + if (!long_) + long_ = gen_include (t, "long.hxx"); + } + + virtual void + traverse (SemanticGraph::Fundamental::UnsignedLong& t) + { + if (!unsigned_long_) + unsigned_long_ = gen_include (t, "unsigned-long.hxx"); + } + + virtual void + traverse (SemanticGraph::Fundamental::Integer& t) + { + if (!long_) + long_ = gen_include (t, "long.hxx"); + } + + virtual void + traverse (SemanticGraph::Fundamental::NonPositiveInteger& t) + { + if (!long_) + long_ = gen_include (t, "long.hxx"); + } + + virtual void + traverse (SemanticGraph::Fundamental::NonNegativeInteger& t) + { + if (!unsigned_long_) + unsigned_long_ = gen_include (t, "unsigned-long.hxx"); + } + + virtual void + traverse (SemanticGraph::Fundamental::PositiveInteger& t) + { + if (!unsigned_long_) + unsigned_long_ = gen_include (t, "unsigned-long.hxx"); + } + + virtual void + traverse (SemanticGraph::Fundamental::NegativeInteger& t) + { + if (!long_) + long_ = gen_include (t, "long.hxx"); + } + + // Boolean. + // + virtual void + traverse (SemanticGraph::Fundamental::Boolean& t) + { + gen_include (t, "boolean.hxx"); + } + + // Floats. + // + virtual void + traverse (SemanticGraph::Fundamental::Float& t) + { + gen_include (t, "float.hxx"); + } + + virtual void + traverse (SemanticGraph::Fundamental::Double& t) + { + gen_include (t, "double.hxx"); + } + + virtual void + traverse (SemanticGraph::Fundamental::Decimal& t) + { + gen_include (t, "decimal.hxx"); + } + + private: + bool + gen_include (SemanticGraph::Type& t, String const& file) + { + String custom; + + // XML Schema built-in type customization is only possible when + // we are generating separate header. + // + if (generate_xml_schema && custom_type (t, custom)) + { + String new_name; + renamed_type (t, new_name); + + if (!new_name) + return false; + } + + os << "#include " + << endl; + + return true; + } + + private: + String prefix_; + bool long_; + bool unsigned_long_; + }; + } +} + +#endif // XSD_CXX_TREE_ELEMENTS_HXX diff --git a/xsd/cxx/tree/fundamental-header.hxx b/xsd/cxx/tree/fundamental-header.hxx new file mode 100644 index 0000000..0ea82cf --- /dev/null +++ b/xsd/cxx/tree/fundamental-header.hxx @@ -0,0 +1,1337 @@ +// file : xsd/cxx/tree/fundamental-header.hxx +// license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +#ifndef XSD_CXX_TREE_FUNDAMENTAL_HEADER_HXX +#define XSD_CXX_TREE_FUNDAMENTAL_HEADER_HXX + +#include +#include +#include + +#include +#include + +#include + +namespace CXX +{ + namespace Tree + { + struct FundamentalNamespace : DocumentedNamespace, + + Traversal::AnyType, + Traversal::AnySimpleType, + + Traversal::Fundamental::Byte, + Traversal::Fundamental::UnsignedByte, + Traversal::Fundamental::Short, + Traversal::Fundamental::UnsignedShort, + Traversal::Fundamental::Int, + Traversal::Fundamental::UnsignedInt, + Traversal::Fundamental::Long, + Traversal::Fundamental::UnsignedLong, + Traversal::Fundamental::Integer, + Traversal::Fundamental::NonPositiveInteger, + Traversal::Fundamental::NonNegativeInteger, + Traversal::Fundamental::PositiveInteger, + Traversal::Fundamental::NegativeInteger, + + Traversal::Fundamental::Boolean, + + Traversal::Fundamental::Float, + Traversal::Fundamental::Double, + Traversal::Fundamental::Decimal, + + Traversal::Fundamental::String, + Traversal::Fundamental::NormalizedString, + Traversal::Fundamental::Token, + Traversal::Fundamental::Name, + Traversal::Fundamental::NameToken, + Traversal::Fundamental::NameTokens, + Traversal::Fundamental::NCName, + Traversal::Fundamental::Language, + + Traversal::Fundamental::Id, + Traversal::Fundamental::IdRef, + Traversal::Fundamental::IdRefs, + + Traversal::Fundamental::AnyURI, + + Traversal::Fundamental::QName, + + Traversal::Fundamental::Base64Binary, + Traversal::Fundamental::HexBinary, + + Traversal::Fundamental::Date, + Traversal::Fundamental::DateTime, + Traversal::Fundamental::Duration, + Traversal::Fundamental::Day, + Traversal::Fundamental::Month, + Traversal::Fundamental::MonthDay, + Traversal::Fundamental::Year, + Traversal::Fundamental::YearMonth, + Traversal::Fundamental::Time, + + Traversal::Fundamental::Entity, + Traversal::Fundamental::Entities, + Context + { + using Namespace::traverse; + + FundamentalNamespace (Context& c) + : DocumentedNamespace (c), + Context (c), + export_ (c.options.export_xml_schema () && type_exp) + { + *this >> names_ >> *this; + + if (export_) + xs_ns_ = ns_name (xs_ns ()); + } + + void + gen_typedef (String const& name, + String const& type, + String const& arg1 = L"", + String const& arg2 = L"", + String const& arg3 = L"", + bool export_type = true) + { + os << "typedef " << type; + + // Use unqualified arguments since we are in the same + // namespace. + // + if (arg1) + { + os << arg1; + + if (arg2) + { + os << ", " << arg2; + + if (arg3) + os << ", " << arg3; + } + + os << " >"; + } + + os << " " << name << ";"; + + if (export_type && export_ && type.find (L'<') != String::npos) + { + String s (type); + + // Use qualified arguments. + // + if (arg1) + { + s += xs_ns_; + s += L"::"; + s += arg1; + + if (arg2) + { + s += L", "; + s += xs_ns_; + s += L"::"; + s += arg2; + + if (arg3) + { + s += L", "; + s += xs_ns_; + s += L"::"; + s += arg3; + } + } + + s += " >"; + } + + if (exports_set_.count (s) == 0) + { + exports_.push_back (s); + exports_set_.insert (s); + } + } + } + + String + built_in_type (SemanticGraph::Type& t, + String const& type, + String const& arg1 = L"", + String const& arg2 = L"", + String const& arg3 = L"") + { + String custom; + + String name (ename (t)); + + // XML Schema built-in type customization is only possible when + // we are generating separate header. + // + if (generate_xml_schema && custom_type (t, custom)) + { + if (custom.empty ()) + custom = name; + + String new_name; + renamed_type (t, new_name); + + if (new_name) + { + gen_typedef (new_name, type, arg1, arg2, arg3); + + if (doxygen) + os << endl; + } + + if (doxygen) + os << "/**" << endl + << " * @brief C++ type corresponding to the " << + comment (t.name ()) << " XML Schema" << endl + << " * built-in type." << endl + << " */" << endl; + + if (custom == name) + os << "class " << name << ";"; + else + os << "typedef " << custom << " " << name << ";"; + + if (doxygen) + os << endl; + } + else + { + // Otherwise generate simple typedef. + // + + if (doxygen) + os << "/**" << endl + << " * @brief C++ type corresponding to the " << + comment (t.name ()) << " XML Schema" << endl + << " * built-in type." << endl + << " */" << endl; + + gen_typedef (name, type, arg1, arg2, arg3); + + if (doxygen) + os << endl; + } + + return name; + } + + // anyType and anySimpleType + // + virtual void + traverse (SemanticGraph::AnyType& t) + { + os << "// anyType and anySimpleType." << endl + << "//" << endl; + + if (doxygen) + os << endl; + + type_ = built_in_type (t, "::xsd::cxx::tree::type"); + } + + virtual void + traverse (SemanticGraph::AnySimpleType& t) + { + simple_type_ = built_in_type ( + t, L"::xsd::cxx::tree::simple_type< " + char_type + L", ", type_); + + if (doxygen) + os << "/**" << endl + << " * @brief Alias for the anyType type." << endl + << " */" << endl; + + gen_typedef (xs_ns ().context().get ("container"), + "::xsd::cxx::tree::type"); + + os << endl; + + if (doxygen) + os << endl; + } + + // Integrals. + // + virtual void + traverse (SemanticGraph::Fundamental::Byte& t) + { + os << "// 8-bit" << endl + << "//" << endl; + + if (doxygen) + os << endl; + + built_in_type (t, "signed char"); + } + + virtual void + traverse (SemanticGraph::Fundamental::UnsignedByte& t) + { + built_in_type (t, "unsigned char"); + os << endl; + } + + virtual void + traverse (SemanticGraph::Fundamental::Short& t) + { + os << "// 16-bit" << endl + << "//" << endl; + + if (doxygen) + os << endl; + + built_in_type (t, "short"); + } + + virtual void + traverse (SemanticGraph::Fundamental::UnsignedShort& t) + { + built_in_type (t, "unsigned short"); + os << endl; + } + + virtual void + traverse (SemanticGraph::Fundamental::Int& t) + { + os << "// 32-bit" << endl + << "//" << endl; + + if (doxygen) + os << endl; + + built_in_type (t, "int"); + } + + virtual void + traverse (SemanticGraph::Fundamental::UnsignedInt& t) + { + built_in_type (t, "unsigned int"); + os << endl; + } + + virtual void + traverse (SemanticGraph::Fundamental::Long& t) + { + os << "// 64-bit" << endl + << "//" < ("buffer"), + L"::xsd::cxx::tree::buffer< " + char_type + L" >"); + + if (doxygen) + os << endl; + + built_in_type ( + t, + L"::xsd::cxx::tree::base64_binary< " + char_type + L", ", + simple_type_); + } + + virtual void + traverse (SemanticGraph::Fundamental::HexBinary& t) + { + built_in_type ( + t, + L"::xsd::cxx::tree::hex_binary< " + char_type + L", ", + simple_type_); + + os << endl; + } + + + // Date/time. + // + virtual void + traverse (SemanticGraph::Fundamental::Date& t) + { + os << "// Date/time." << endl + << "//" << endl; + + if (doxygen) + os << endl + << "/**" << endl + << " * @brief Time zone type." << endl + << " */" << endl; + + gen_typedef (xs_ns ().context().get ("time-zone"), + "::xsd::cxx::tree::time_zone"); + + if (doxygen) + os << endl; + + built_in_type ( + t, L"::xsd::cxx::tree::date< " + char_type + L", ", simple_type_); + } + + virtual void + traverse (SemanticGraph::Fundamental::DateTime& t) + { + built_in_type ( + t, + L"::xsd::cxx::tree::date_time< " + char_type + L", ", + simple_type_); + } + + virtual void + traverse (SemanticGraph::Fundamental::Duration& t) + { + built_in_type ( + t, + L"::xsd::cxx::tree::duration< " + char_type + L", ", + simple_type_); + } + + virtual void + traverse (SemanticGraph::Fundamental::Day& t) + { + built_in_type ( + t, L"::xsd::cxx::tree::gday< " + char_type + L", ", simple_type_); + } + + virtual void + traverse (SemanticGraph::Fundamental::Month& t) + { + built_in_type ( + t, L"::xsd::cxx::tree::gmonth< " + char_type + L", ", simple_type_); + } + + virtual void + traverse (SemanticGraph::Fundamental::MonthDay& t) + { + built_in_type ( + t, + L"::xsd::cxx::tree::gmonth_day< " + char_type + L", ", + simple_type_); + } + + virtual void + traverse (SemanticGraph::Fundamental::Year& t) + { + built_in_type ( + t, L"::xsd::cxx::tree::gyear< " + char_type + L", ", simple_type_); + } + + virtual void + traverse (SemanticGraph::Fundamental::YearMonth& t) + { + built_in_type ( + t, + L"::xsd::cxx::tree::gyear_month< " + char_type + L", ", + simple_type_); + } + + virtual void + traverse (SemanticGraph::Fundamental::Time& t) + { + built_in_type ( + t, L"::xsd::cxx::tree::time< " + char_type + L", ", simple_type_); + + os << endl; + } + + // Entity. + // + virtual void + traverse (SemanticGraph::Fundamental::Entity& t) + { + os << "// Entity." << endl + << "//" << endl; + + if (doxygen) + os << endl; + + entity_ = built_in_type ( + t, L"::xsd::cxx::tree::entity< " + char_type + L", ", ncname_); + } + + virtual void + traverse (SemanticGraph::Fundamental::Entities& t) + { + built_in_type ( + t, + L"::xsd::cxx::tree::entities< " + char_type + L", ", + simple_type_, + entity_); + + os << endl; + } + + virtual void + post (SemanticGraph::Namespace& n) + { + SemanticGraph::Context& c (xs_ns ().context()); + + bool parsing (!options.suppress_parsing ()); + bool serialization (options.generate_serialization ()); + bool element_map (options.generate_element_map ()); + + { + if (doxygen) + os << endl + << "/**" << endl + << " * @brief Content order sequence entry." << endl + << " */" << endl; + + gen_typedef (c.get ("content-order"), + "::xsd::cxx::tree::content_order"); + } + + if (options.generate_element_type ()) + { + if (doxygen) + os << "/**" << endl + << " * @brief Base class for element types." << endl + << " */" << endl; + else + os << "// Base class for element types." << endl + << "//" << endl; + + gen_typedef ( + c.get ("element-type"), + L"::xsd::cxx::tree::element_type< " + char_type + L", ", + type_); + + os << endl; + } + + if (element_map) + { + if (doxygen) + os << "/**" << endl + << " * @brief Root element map." << endl + << " */" << endl; + else + os << "// Root element map." << endl + << "//" << endl; + + gen_typedef ( + c.get ("element-map"), + L"::xsd::cxx::tree::element_map< " + char_type + L", ", + type_); + + os << endl; + } + + if (serialization) + { + os << "// Namespace information and list stream. Used in" << endl + << "// serialization functions." << endl + << "//" << endl; + + if (doxygen) + os << "/**" << endl + << " * @brief Namespace serialization information." << endl + << " */" << endl; + + gen_typedef ( + c.get ("namespace-info"), + L"::xsd::cxx::xml::dom::namespace_info< " + char_type + L" >"); + + if (doxygen) + os << endl + << "/**" << endl + << " * @brief Namespace serialization information map." << endl + << " */" << endl; + + gen_typedef (c.get ("namespace-infomap"), + L"::xsd::cxx::xml::dom::namespace_infomap< " + + char_type + L" >"); + + if (doxygen) + os << endl + << "/**" << endl + << " * @brief List serialization stream." << endl + << " */" << endl; + + gen_typedef ( + c.get ("list-stream"), + L"::xsd::cxx::tree::list_stream< " + char_type + L" >"); + + if (doxygen) + os << endl + << "/**" << endl + << " * @brief Serialization wrapper for the %double type." << endl + << " */" << endl; + + // Do not export as_double and as_decimal since they are already + // instantiated. + // + gen_typedef (c.get ("as-double"), + L"::xsd::cxx::tree::as_double< ", + double_, + "", + "", + false); + + if (doxygen) + os << endl + << "/**" << endl + << " * @brief Serialization wrapper for the %decimal type." << endl + << " */" << endl; + + gen_typedef (c.get ("as-decimal"), + L"::xsd::cxx::tree::as_decimal< ", + decimal_, + "", + "", + false); + + if (doxygen) + os << endl + << "/**" << endl + << " * @brief Simple type facet." << endl + << " */" << endl; + + gen_typedef (c.get ("facet"), "::xsd::cxx::tree::facet"); + + os << endl; + } + + //@@ Can't change names of ostream/istream since they are + // templates. + // + if (!options.generate_insertion ().empty ()) + { + if (doxygen) + os << "/**" << endl + << " * @brief Data representation output stream template." << endl + << " */" << endl; + else + os << "// Data representation output stream template." << endl + << "//" << endl; + + os << "using ::xsd::cxx::tree::ostream;" + << endl; + } + + if (!options.generate_extraction ().empty ()) + { + if (doxygen) + os << "/**" << endl + << " * @brief Data representation input stream template." << endl + << " */" << endl; + else + os << "// Data representation input stream template." << endl + << "//" << endl; + + os << "using ::xsd::cxx::tree::istream;" + << endl; + } + + os << "// Flags and properties." << endl + << "//" << endl; + + if (doxygen) + os << endl + << "/**" << endl + << " * @brief Parsing and serialization flags." << endl + << " */" << endl; + + gen_typedef (c.get ("flags"), "::xsd::cxx::tree::flags"); + + if (doxygen) + os << endl + << "/**" << endl + << " * @brief Parsing properties." << endl + << " */" << endl; + + gen_typedef (c.get ("properties"), + L"::xsd::cxx::tree::properties< " + char_type + L" >"); + os << endl; + + + // + // + if (parsing || serialization) + { + os << "// Parsing/serialization diagnostics." << endl + << "//" << endl; + + if (doxygen) + os << endl + << "/**" << endl + << " * @brief Error severity." << endl + << " */" << endl; + + gen_typedef (c.get ("severity"), + "::xsd::cxx::tree::severity"); + + if (doxygen) + os << endl + << "/**" << endl + << " * @brief Error condition." << endl + << " */" << endl; + + gen_typedef (c.get ("error"), + L"::xsd::cxx::tree::error< " + char_type + L" >"); + + if (doxygen) + os << endl + << "/**" << endl + << " * @brief List of %error conditions." << endl + << " */" << endl; + + gen_typedef (c.get ("diagnostics"), + L"::xsd::cxx::tree::diagnostics< " + char_type + L" >"); + os << endl; + } + + // + // + os << "// Exceptions." << endl + << "//" << endl; + + if (doxygen) + os << endl + << "/**" << endl + << " * @brief Root of the C++/Tree %exception hierarchy." << endl + << " */" << endl; + + gen_typedef (c.get ("exception"), + L"::xsd::cxx::tree::exception< " + char_type + L" >"); + + if (doxygen) + os << endl + << "/**" << endl + << " * @brief Exception indicating that the size argument exceeds" << + endl + << " * the capacity argument." << endl + << " */" << endl; + + gen_typedef (c.get ("bounds"), + L"::xsd::cxx::tree::bounds< " + char_type + L" >"); + + if (doxygen) + os << endl + << "/**" << endl + << " * @brief Exception indicating that a duplicate ID value" << + endl + << " * was encountered in the object model." << endl + << " */" << endl; + + gen_typedef (c.get ("duplicate-id"), + L"::xsd::cxx::tree::duplicate_id< " + char_type + L" >"); + + if (parsing) + { + if (doxygen) + os << endl + << "/**" << endl + << " * @brief Exception indicating a parsing failure." << endl + << " */" << endl; + + gen_typedef (c.get ("parsing"), + L"::xsd::cxx::tree::parsing< " + char_type + L" >"); + + if (doxygen) + os << endl + << "/**" << endl + << " * @brief Exception indicating that an expected element" << + endl + << " * was not encountered." << endl + << " */" << endl; + + gen_typedef ( + c.get ("expected-element"), + L"::xsd::cxx::tree::expected_element< " + char_type + L" >"); + } + + if (parsing || serialization) + { + if (doxygen) + os << endl + << "/**" << endl + << " * @brief Exception indicating that an unexpected " << + "element" << endl + << " * was encountered." << endl + << " */" << endl; + + gen_typedef ( + c.get ("unexpected-element"), + L"::xsd::cxx::tree::unexpected_element< " + char_type + L" >"); + } + + if (parsing) + { + if (doxygen) + os << endl + << "/**" << endl + << " * @brief Exception indicating that an expected " << + "attribute" << endl + << " * was not encountered." << endl + << " */" << endl; + + gen_typedef ( + c.get ("expected-attribute"), + L"::xsd::cxx::tree::expected_attribute< " + char_type + L" >"); + + if (doxygen) + os << endl + << "/**" << endl + << " * @brief Exception indicating that an unexpected " << + "enumerator" << endl + << " * was encountered." << endl + << " */" << endl; + + gen_typedef ( + c.get ("unexpected-enumerator"), + L"::xsd::cxx::tree::unexpected_enumerator< " + char_type + L" >"); + + if (doxygen) + os << endl + << "/**" << endl + << " * @brief Exception indicating that the text content " << + "was" << endl + << " * expected for an element." << endl + << " */" << endl; + + gen_typedef ( + c.get ("expected-text-content"), + L"::xsd::cxx::tree::expected_text_content< " + char_type + L" >"); + + if (doxygen) + os << endl + << "/**" << endl + << " * @brief Exception indicating that a prefix-namespace" << + endl + << " * mapping was not provided." << endl + << " */" << endl; + + gen_typedef ( + c.get ("no-prefix-mapping"), + L"::xsd::cxx::tree::no_prefix_mapping< " + char_type + L" >"); + } + + if (options.generate_polymorphic ()) + { + if (parsing || serialization) + { + if (doxygen) + os << endl + << "/**" << endl + << " * @brief Exception indicating that the type " << + "information" << endl + << " * is not available for a type." << endl + << " */" << endl; + + gen_typedef ( + c.get ("no-type-info"), + L"::xsd::cxx::tree::no_type_info< " + char_type + L" >"); + } + + if (parsing) + { + if (doxygen) + os << endl + << "/**" << endl + << " * @brief Exception indicating that the types are not" << + endl + << " * related by inheritance." << endl + << " */" << endl; + + gen_typedef ( + c.get ("not-derived"), + L"::xsd::cxx::tree::not_derived< " + char_type + L" >"); + } + } + + if (element_map) + { + if (doxygen) + os << endl + << "/**" << endl + << " * @brief Exception indicating that parsing or " << + "serialization" << endl + << " * information is not available for an element." << endl + << " */" << endl; + + gen_typedef ( + c.get ("no-element-info"), + L"::xsd::cxx::tree::no_element_info< " + char_type + L" >"); + } + + if (serialization) + { + if (doxygen) + os << endl + << "/**" << endl + << " * @brief Exception indicating a serialization " << + "failure." << endl + << " */" << endl; + + gen_typedef ( + c.get ("serialization"), + L"::xsd::cxx::tree::serialization< " + char_type + L" >"); + } + + os << endl; + + if (parsing || serialization) + { + if (doxygen) + os << "/**" << endl + << " * @brief Error handler callback interface." << endl + << " */" << endl; + else + os << "// Error handler callback interface." << endl + << "//" << endl; + + gen_typedef ( + c.get ("error-handler"), + L"::xsd::cxx::xml::error_handler< " + char_type + L" >"); + + os << endl; + } + + if (parsing || serialization) + { + if (doxygen) + os << "/**" << endl + << " * @brief DOM interaction." << endl + << " */" << endl; + else + os << "// DOM interaction." << endl + << "//" << endl; + + os << "namespace dom" + << "{"; + + // @@ Disregarding current naming convention by using the + // fixed name (even in C++11, template alias is not yet + // widely supported). + // + if (doxygen) + os << "/**" << endl + << " * @brief Automatic pointer for DOMDocument." << endl + << " */" << endl; + else + os << "// Automatic pointer for DOMDocument." << endl + << "//" << endl; + + if (std >= cxx_version::cxx11) + os << "using ::xsd::cxx::xml::dom::unique_ptr;"; + else + os << "using ::xsd::cxx::xml::dom::auto_ptr;"; + + os << endl; + + if (parsing) + { + if (!generate_xml_schema) + { + String g (L"XSD_CXX_TREE_TREE_NODE_KEY" + ns_name (n)); + + std::transform (g.begin (), g.end(), g.begin (), upcase); + g = escape (g); // Make it a C++ id. + + os << "#ifndef " << g << endl + << "#define " << g << endl; + } + + if (doxygen) + os << "/**" << endl + << " * @brief DOM user data key for back pointers to " << + "tree nodes." << endl + << " */" << endl; + else + os << "// DOM user data key for back pointers to tree nodes." << endl + << "//" << endl; + + os << "const XMLCh* const " << c.get ("tree-node-key") << + " = ::xsd::cxx::tree::user_data_keys::node;"; + + if (!generate_xml_schema) + os << "#endif" << endl; + } + + os << "}"; // namespace dom + } + + if (element_map) + { + if (doxygen) + os << "//@cond" << endl + << endl; + + if (!generate_xml_schema) + { + String g (L"XSD_CXX_TREE_ELEMENT_MAP_INIT" + ns_name (n)); + + std::transform (g.begin (), g.end(), g.begin (), upcase); + g = escape (g); // Make it a C++ id. + + os << "#ifndef " << g << endl + << "#define " << g << endl; + } + + os << "static" << endl + << "const ::xsd::cxx::tree::element_map_init< " << + char_type << ", " << type_ << " >" << endl + << "_xsd_element_map_init;"; + + if (!generate_xml_schema) + os << "#endif" << endl; + + if (doxygen) + os << endl + << "//@endcond" << endl; + } + + Namespace::post (n); + + // Generate exports. + // + if (export_) + { + StringSet ns_set; + + for (StringList::const_iterator i (exports_.begin ()); + i != exports_.end (); ++i) + { + String const& e (*i); + + // 12 is to skip ::xsd::cxx:: + // + ns_set.insert (String (e, 12, e.rfind (':', e.find ('<')) - 13)); + } + + os << "#ifndef XSD_NO_EXPORT" << endl + << endl + << "namespace xsd" + << "{" + << "namespace cxx" + << "{"; + + for (StringSet::const_iterator i (ns_set.begin ()); + i != ns_set.end (); ++i) + { + String const& ns (*i); + String prefix (L"::xsd::cxx::" + ns); + + size_t n (1); + for (size_t b (0), e (ns.find (':')); ; n++) + { + os << "namespace " << String (ns, b, e) + << "{"; + + if (e == String::npos) + break; + + b = e + 2; + e = ns.find (':', b); + } + + for (StringList::const_iterator i (exports_.begin ()); + i != exports_.end (); ++i) + { + String const& e (*i); + String ens (e, 12, e.rfind (':', e.find ('<')) - 13); + + if (ns == ens) + { + String type (e, e.rfind (':', e.find ('<')) + 1); + os << "template class " << type_exp << type << ";"; + } + } + + while (n--) + os << "}"; + } + + os << "}" // cxx + << "}" // xsd + << "#endif // XSD_NO_EXPORT" << endl + << endl; + } + } + + private: + typedef std::set StringSet; + typedef std::vector StringList; + + bool export_; + StringList exports_; + StringSet exports_set_; + String xs_ns_; + + Traversal::Names names_; + + String type_; + String simple_type_; + String string_; + String norm_string_; + String token_; + String nmtoken_; + String name_; + String ncname_; + String idref_; + String uri_; + String entity_; + + String double_; + String decimal_; + }; + } +} + +#endif // XSD_CXX_TREE_FUNDAMENTAL_HEADER_HXX diff --git a/xsd/cxx/tree/generator.cxx b/xsd/cxx/tree/generator.cxx new file mode 100644 index 0000000..9782b4d --- /dev/null +++ b/xsd/cxx/tree/generator.cxx @@ -0,0 +1,1268 @@ +// file : xsd/cxx/tree/generator.cxx +// license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +#include +#include +#include +#include + +#include +#include + +#include +#include +#include + +#include +#include + +#include + +#include + +#include + +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +#include +#include + +#include +#include + +#include +#include + +#include +#include +#include + +#include + +using namespace std; +using namespace cutl; +using namespace XSDFrontend::SemanticGraph; + +// +// +typedef std::wostream WideOutputStream; + +typedef std::wifstream WideInputFileStream; +typedef std::wofstream WideOutputFileStream; + +namespace CXX +{ + namespace + { + char const copyright_gpl[] = + "// Copyright (c) " XSD_COPYRIGHT ".\n" + "//\n" + "// This program was generated by CodeSynthesis XSD, an XML Schema to\n" + "// C++ data binding compiler.\n" + "//\n" + "// This program is free software; you can redistribute it and/or modify\n" + "// it under the terms of the GNU General Public License version 2 as\n" + "// published by the Free Software Foundation.\n" + "//\n" + "// This program is distributed in the hope that it will be useful,\n" + "// but WITHOUT ANY WARRANTY; without even the implied warranty of\n" + "// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n" + "// GNU General Public License for more details.\n" + "//\n" + "// You should have received a copy of the GNU General Public License\n" + "// along with this program; if not, write to the Free Software\n" + "// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA\n" + "//\n" + "// In addition, as a special exception, Code Synthesis gives permission\n" + "// to link this program with the Xerces-C++ library (or with modified\n" + "// versions of Xerces-C++ that use the same license as Xerces-C++), and\n" + "// distribute linked combinations including the two. You must obey the GNU\n" + "// General Public License version 2 in all respects for all of the code\n" + "// used other than Xerces-C++. If you modify this copy of the program, you\n" + "// may extend this exception to your version of the program, but you are\n" + "// not obligated to do so. If you do not wish to do so, delete this\n" + "// exception statement from your version.\n" + "//\n" + "// Furthermore, Code Synthesis makes a special exception for the Free/Libre\n" + "// and Open Source Software (FLOSS) which is described in the accompanying\n" + "// FLOSSE file.\n" + "//\n\n"; + + char const copyright_proprietary[] = + "// Copyright (c) " XSD_COPYRIGHT ".\n" + "//\n" + "// This program was generated by CodeSynthesis XSD, an XML Schema\n" + "// to C++ data binding compiler, in the Proprietary License mode.\n" + "// You should have received a proprietary license from Code Synthesis\n" + "// prior to generating this code. See the license text for conditions.\n" + "//\n\n"; + } + + void Tree::Generator:: + usage () + { + CXX::Tree::options::print_usage (wcout); + CXX::options::print_usage (wcout); + } + + namespace + { + void + open (WideInputFileStream& ifs, NarrowString const& path) + { + try + { + Path fs_path (path); + ifs.open (fs_path.string ().c_str (), + std::ios_base::in | std::ios_base::binary); + + if (!ifs.is_open ()) + { + wcerr << path.c_str () << ": error: unable to open in read mode" + << endl; + + throw Tree::Generator::Failed (); + } + } + catch (InvalidPath const&) + { + wcerr << "error: '" << path.c_str () << "' is not a valid " + << "filesystem path" << endl; + + throw Tree::Generator::Failed (); + } + } + + void + append (WideOutputFileStream& os, + NarrowString const& path, + WideInputFileStream& default_is) + { + using std::ios_base; + + if (path) + { + WideInputFileStream is; + open (is, path); + os << is.rdbuf (); + } + else if (default_is.is_open ()) + { + os << default_is.rdbuf (); + default_is.seekg (0, ios_base::beg); + } + } + + void + append (WideOutputFileStream& os, + NarrowStrings const& primary, + NarrowStrings const& def) + { + NarrowStrings const& v (primary.empty () ? def : primary); + + for (NarrowStrings::const_iterator i (v.begin ()), e (v.end ()); + i != e; ++i) + { + os << i->c_str () << endl; + } + } + } + + + size_t Tree::Generator:: + generate (Tree::options const& ops, + Schema& schema, + Path const& file_path, + bool fpt, + StringLiteralMap const& string_literal_map, + const WarningSet& disabled_warnings, + FileList& file_list, + AutoUnlinks& unlinks) + { + using cutl::shared_ptr; + typedef cutl::re::regexsub Regex; + + typedef vector Paths; + typedef vector > WideOutputFileStreams; + + try + { + // Do option validation. + // + if (ops.parts () < 1) + { + wcerr << "error: invalid value for option --parts: " << + ops.parts () << endl; + throw Failed (); + } + + // Get counts. + // + Counts counts; + { + Counter counter; + counts = counter.count (ops, schema, file_path); + + /* + wcerr << "global type count: " << counts.global_types << endl; + wcerr << "global element count: " << counts.global_elements << endl; + wcerr << "generated global element count: " << + counts.generated_global_elements << endl; + + wcerr << "total complexity: " << counts.complexity_total << endl; + wcerr << "complexity vector size: " << counts.complexity.size () + << endl; + */ + } + + // Evaluate the graph for possibility of generating something useful. + // + { + Validator validator; + if (!validator.validate ( + ops, schema, file_path, disabled_warnings, counts)) + throw Failed (); + } + + bool gen_cxx (!ops.generate_dep_only () && !ops.file_list_only ()); + + // Process ordered types. + // + if (gen_cxx) + { + OrderProcessor proc; + if (!proc.process (ops, schema, file_path)) + throw Failed (); + } + + // Process names. + // + if (gen_cxx) + { + NameProcessor proc; + if (!proc.process (ops, schema, file_path, string_literal_map)) + throw Failed (); + } + + // Process polymorphic types. + // + if (gen_cxx && + ops.generate_polymorphic () && + !ops.polymorphic_type_all ()) + { + PolymorphismProcessor proc; + if (!proc.process (ops, schema, file_path, disabled_warnings)) + throw Failed (); + } + + // Parts. + // + size_t parts (ops.parts ()); + size_t units (counts.global_types + counts.generated_global_elements); + size_t units_per_part (units / parts); + + if (parts != 1 && units_per_part < 1) + { + wcerr << "error: too many parts specified: " << parts << endl; + throw Failed (); + } + + size_t complexity_per_part (counts.complexity_total / parts); + + + NarrowString parts_suffix (ops.parts_suffix ()); + + // + // + bool generate_xml_schema (ops.generate_xml_schema ()); + + // We could be compiling several schemas at once in which case + // handling of the --generate-xml-schema option gets tricky: we + // will need to rely on the presence of the --extern-xml-schema + // to tell us which (fake) schema file corresponds to XML Schema. + // + if (generate_xml_schema) + { + if (NarrowString name = ops.extern_xml_schema ()) + { + if (file_path.string () != name) + generate_xml_schema = false; + } + } + + bool header (true); + bool inline_ (ops.generate_inline () && !generate_xml_schema); + bool forward (ops.generate_forward () && !generate_xml_schema); + bool source (!generate_xml_schema); + bool gen_dep ((ops.generate_dep () || ops.generate_dep_only ()) && + !generate_xml_schema); + + if (ops.generate_dep_only () && generate_xml_schema) + { + wcerr << "error: no dependency information can be generated for " + "XML Schema header" << endl; + throw Failed (); + } + + if (gen_dep && fpt) + { + wcerr << "error: dependency generation not support in the " << + "file-per-type mode" << endl; + throw Failed (); + } + + // Generate code. + // + NarrowString name (file_path.leaf ().string ()); + + NarrowString hxx_suffix (ops.hxx_suffix ()); + NarrowString ixx_suffix (ops.ixx_suffix ()); + NarrowString cxx_suffix (ops.cxx_suffix ()); + NarrowString fwd_suffix (ops.fwd_suffix ()); + NarrowString dep_suffix (ops.dep_suffix ()); + + Regex hxx_expr (ops.hxx_regex ().empty () + ? "#^(.+?)(\\.[^./\\\\]+)?$#$1" + hxx_suffix + "#" + : ops.hxx_regex ()); + + Regex ixx_expr (ops.ixx_regex ().empty () + ? "#^(.+?)(\\.[^./\\\\]+)?$#$1" + ixx_suffix + "#" + : ops.ixx_regex ()); + + Regex cxx_expr (ops.cxx_regex ().empty () + ? "#^(.+?)(\\.[^./\\\\]+)?$#$1" + cxx_suffix + "#" + : ops.cxx_regex ()); + + Regex fwd_expr (ops.fwd_regex ().empty () + ? "#^(.+?)(\\.[^./\\\\]+)?$#$1" + fwd_suffix + "#" + : ops.fwd_regex ()); + + // @@ This will blow up if --dep-file value contains backslashes (e.g., + // it's a Windows path). + // + Regex dep_expr ( + ops.dep_regex_specified () ? ops.dep_regex () : + ops.dep_file_specified () ? "#.+#" + ops.dep_file () + "#" : + "#^(.+?)(\\.[^./\\\\]+)?$#$1" + dep_suffix + "#"); + + if (header && !hxx_expr.match (name)) + { + wcerr << "error: header expression '" << + hxx_expr.regex ().str ().c_str () << "' does not match '" << + name.c_str () << "'" << endl; + throw Failed (); + } + + if (inline_ && !ixx_expr.match (name)) + { + wcerr << "error: inline expression '" << + ixx_expr.regex ().str ().c_str () << "' does not match '" << + name.c_str () << "'" << endl; + throw Failed (); + } + + if (source && parts == 1 && !cxx_expr.match (name)) + { + wcerr << "error: source expression '" << + cxx_expr.regex ().str ().c_str () << "' does not match '" << + name.c_str () << "'" << endl; + throw Failed (); + } + + if (forward && !fwd_expr.match (name)) + { + wcerr << "error: forward expression '" << + fwd_expr.regex ().str ().c_str () << "' does not match '" << + name.c_str () << "'" << endl; + throw Failed (); + } + + if (gen_dep && !dep_expr.match (name)) + { + wcerr << "error: dependency expression '" << + dep_expr.regex ().str ().c_str () << "' does not match '" << + name.c_str () << "'" << endl; + throw Failed (); + } + + NarrowString hxx_name (header ? hxx_expr.replace (name) : NarrowString ()); + NarrowString ixx_name (inline_ ? ixx_expr.replace (name) : NarrowString ()); + NarrowString fwd_name (forward ? fwd_expr.replace (name) : NarrowString ()); + NarrowString dep_name (gen_dep ? dep_expr.replace (name) : NarrowString ()); + + Path hxx_path (hxx_name); + Path ixx_path (ixx_name); + Path fwd_path (fwd_name); + Path dep_path (dep_name != "-" ? dep_name : NarrowString ()); + Paths cxx_paths; + + if (source) + { + if (parts > 1) + { + for (size_t i (0); i < parts; ++i) + { + std::ostringstream os; + os << i; + + Regex expr ( + "#^(.+?)(\\.[^./\\\\]+)?$#$1" + parts_suffix + os.str () + "$2#"); + + NarrowString part_name (expr.replace (name)); + + if (!cxx_expr.match (part_name)) + { + wcerr << "error: source expression '" << + cxx_expr.regex ().str ().c_str () << "' does not match '" << + part_name.c_str () << "'" << endl; + throw Failed (); + } + + cxx_paths.push_back (Path (cxx_expr.replace (part_name))); + } + } + else + cxx_paths.push_back (Path (cxx_expr.replace (name))); + } + + Path out_dir; + + if (NarrowString dir = ops.output_dir ()) + { + try + { + out_dir = Path (dir); + } + catch (InvalidPath const&) + { + wcerr << dir.c_str () << ": error: invalid path" << endl; + throw Failed (); + } + } + + if (fpt && !generate_xml_schema) + { + // In the file-per-type mode the schema files are always local + // unless the user added the directory so that we propagate this + // to the output files. + // + Path fpt_dir (file_path.directory ()); + + if (!fpt_dir.empty ()) + out_dir /= fpt_dir; + } + + if (!out_dir.empty ()) + { + if (!hxx_path.empty ()) hxx_path = out_dir / hxx_path; + if (!ixx_path.empty ()) ixx_path = out_dir / ixx_path; + if (!fwd_path.empty ()) fwd_path = out_dir / fwd_path; + if (!dep_path.empty () && + !dep_path.absolute ()) dep_path = out_dir / dep_path; + + for (Paths::iterator i (cxx_paths.begin ()); + i != cxx_paths.end (); ++i) + *i = out_dir / *i; + } + + // + // + WideOutputFileStream hxx; + WideOutputFileStream ixx; + WideOutputFileStream fwd; + WideOutputFileStream depf; // See dep below. + WideOutputFileStreams cxx; + + // DEP + // + if (gen_dep) + { + if (!dep_path.empty ()) + { + depf.open (dep_path.string ().c_str (), ios_base::out); + + if (!depf.is_open ()) + { + wcerr << dep_path << ": error: unable to open in write mode" + << endl; + throw Failed (); + } + + unlinks.add (dep_path); + } + + // Note: not adding to file_list. + } + + WideOutputStream& dep (gen_dep && !dep_path.empty () ? depf : wcout); + + // FWD + // + if (forward) + { + if (gen_cxx) + { + fwd.open (fwd_path.string ().c_str (), ios_base::out); + + if (!fwd.is_open ()) + { + wcerr << fwd_path << ": error: unable to open in write mode" << endl; + throw Failed (); + } + + unlinks.add (fwd_path); + } + + file_list.push_back (fwd_path.string ()); + } + + // HXX + // + if (header) + { + if (gen_cxx) + { + hxx.open (hxx_path.string ().c_str (), ios_base::out); + + if (!hxx.is_open ()) + { + wcerr << hxx_path << ": error: unable to open in write mode" << endl; + throw Failed (); + } + + unlinks.add (hxx_path); + } + + file_list.push_back (hxx_path.string ()); + } + + // IXX + // + if (inline_) + { + if (gen_cxx) + { + ixx.open (ixx_path.string ().c_str (), ios_base::out); + + if (!ixx.is_open ()) + { + wcerr << ixx_path << ": error: unable to open in write mode" << endl; + throw Failed (); + } + + unlinks.add (ixx_path); + } + + file_list.push_back (ixx_path.string ()); + } + + // CXX + // + if (source) + { + for (Paths::iterator i (cxx_paths.begin ()); + i != cxx_paths.end (); ++i) + { + if (gen_cxx) + { + shared_ptr s ( + new (shared) WideOutputFileStream ( + i->string ().c_str (), ios_base::out)); + + if (!s->is_open ()) + { + wcerr << *i << ": error: unable to open in write mode" << endl; + throw Failed (); + } + + cxx.push_back (s); + unlinks.add (*i); + } + + file_list.push_back (i->string ()); + } + } + + // Print copyright and license. + // + char const* copyright ( + ops.proprietary_license () ? copyright_proprietary : copyright_gpl); + + if (gen_cxx && header) + hxx << copyright; + + if (gen_cxx && forward) + fwd << copyright; + + if (ops.generate_doxygen ()) + { + // Use native path format. + // + hxx << "/**" << endl + << " * @file" << endl + << " * @brief Generated from " << name.c_str () << "." << endl + << " */" << endl + << endl; + + } + + if (gen_cxx && inline_) + ixx << copyright; + + if (gen_cxx && source) + { + for (WideOutputFileStreams::iterator i (cxx.begin ()); + i != cxx.end (); ++i) + **i << copyright; + } + + + // Prologue. + // + WideInputFileStream prologue; + { + NarrowString name (ops.prologue_file ()); + + if (name) + open (prologue, name); + } + + // Epilogue. + // + WideInputFileStream epilogue; + { + NarrowString name (ops.epilogue_file ()); + + if (name) + open (epilogue, name); + } + + // SLOC counter. + // + size_t sloc_total (0); + bool show_sloc (ops.show_sloc ()); + + typedef + compiler::ostream_filter + ind_filter; + + typedef + compiler::ostream_filter + sloc_filter; + + // + // + Regex guard_expr ("/([a-z])([A-Z])/$1_$2/"); // Split words. + NarrowString guard_prefix (ops.guard_prefix ()); + + if (!guard_prefix) + guard_prefix = file_path.directory ().string (); + + if (guard_prefix) + guard_prefix += '_'; + + // DEP + // + if (gen_dep) + { + NarrowString target; + NarrowStrings const& ts (ops.dep_target ()); + + if (!ts.empty ()) + { + for (NarrowStrings::const_iterator i (ts.begin ()); + i != ts.end (); ++i) + target += (target.empty () ? "" : " \\\n") + *i; + } + else + { + target = hxx_path.string (); + + if (forward) + target += " \\\n" + fwd_path.string (); + + if (inline_) + target += " \\\n" + ixx_path.string (); + + for (Paths::iterator i (cxx_paths.begin ()); + i != cxx_paths.end (); ++i) + target += " \\\n" + i->string (); + + if (!dep_path.empty ()) + target += " \\\n" + dep_path.string (); + } + + dep << target.c_str () << ':'; + + XSDFrontend::Generators::Dependencies gen; + Paths prq (gen.generate (schema, file_path)); + + for (Paths::iterator i (prq.begin ()); i != prq.end (); ++i) + dep << " \\" << endl + << " " << *i; + + dep << endl; + + // If requested, generate phony rules for included/imported schemas + // but not the main file which is the first in the list. + // + if (ops.dep_phony () && prq.size () > 1) + { + for (Paths::iterator i (prq.begin () + 1); i != prq.end (); ++i) + dep << endl + << *i << ':' << endl; + } + } + + // FWD + // + if (gen_cxx && forward) + { + Context ctx (fwd, + schema, + file_path, + ops, + counts, + generate_xml_schema, + &string_literal_map, + &fwd_expr, + &hxx_expr, + &ixx_expr); + + sloc_filter sloc (fwd); + + // Guard + // + String guard (guard_expr.replace (guard_prefix + fwd_name)); + guard = ctx.escape (guard); // make a c++ id + std::transform (guard.begin (), guard.end(), guard.begin (), upcase); + + fwd << "#ifndef " << guard << endl + << "#define " << guard << endl + << endl; + + if (ctx.std >= cxx_version::cxx11) + { + fwd << "#ifndef XSD_CXX11" << endl + << "#define XSD_CXX11" << endl + << "#endif" << endl + << endl; + } + + if (ctx.char_type == L"char") + { + fwd << "#ifndef XSD_USE_CHAR" << endl + << "#define XSD_USE_CHAR" << endl + << "#endif" << endl + << endl; + + fwd << "#ifndef XSD_CXX_TREE_USE_CHAR" << endl + << "#define XSD_CXX_TREE_USE_CHAR" << endl + << "#endif" << endl + << endl; + } + else if (ctx.char_type == L"wchar_t") + { + fwd << "#ifndef XSD_USE_WCHAR" << endl + << "#define XSD_USE_WCHAR" << endl + << "#endif" << endl + << endl; + + fwd << "#ifndef XSD_CXX_TREE_USE_WCHAR" << endl + << "#define XSD_CXX_TREE_USE_WCHAR" << endl + << "#endif" << endl + << endl; + } + + // Copy prologue. + // + fwd << "// Begin prologue." << endl + << "//" << endl; + + append (fwd, ops.fwd_prologue (), ops.prologue ()); + append (fwd, ops.fwd_prologue_file (), prologue); + + fwd << "//" << endl + << "// End prologue." << endl + << endl; + + // Version check. + // + fwd << "#include " << endl + << endl + << "#if (LIBXSD_VERSION != " << XSD_VERSION << "L)" << endl + << "#error XSD runtime version mismatch" << endl + << "#endif" << endl + << endl; + + fwd << "#include " << endl + << endl; + + // Generate. + // + { + ind_filter ind (fwd); // We don't want to indent prologues/epilogues. + generate_forward (ctx); + } + + fwd << "#include " << endl + << endl; + + // Copy epilogue. + // + fwd << "// Begin epilogue." << endl + << "//" << endl; + + append (fwd, ops.fwd_epilogue_file (), epilogue); + append (fwd, ops.fwd_epilogue (), ops.epilogue ()); + + fwd << "//" << endl + << "// End epilogue." << endl + << endl; + + fwd << "#endif // " << guard << endl; + + if (show_sloc) + wcerr << fwd_path << ": " << sloc.stream ().count () << endl; + + sloc_total += sloc.stream ().count (); + } + + // HXX + // + if (gen_cxx && header) + { + Context ctx (hxx, + schema, + file_path, + ops, + counts, + generate_xml_schema, + &string_literal_map, + &fwd_expr, + &hxx_expr, + &ixx_expr); + + sloc_filter sloc (hxx); + + // Guard + // + String guard (guard_expr.replace (guard_prefix + hxx_name)); + guard = ctx.escape (guard); // make a c++ id + std::transform (guard.begin (), guard.end(), guard.begin (), upcase); + + hxx << "#ifndef " << guard << endl + << "#define " << guard << endl + << endl; + + if (!forward) + { + if (ctx.std >= cxx_version::cxx11) + { + hxx << "#ifndef XSD_CXX11" << endl + << "#define XSD_CXX11" << endl + << "#endif" << endl + << endl; + } + + if (ctx.char_type == L"char") + { + hxx << "#ifndef XSD_USE_CHAR" << endl + << "#define XSD_USE_CHAR" << endl + << "#endif" << endl + << endl; + + hxx << "#ifndef XSD_CXX_TREE_USE_CHAR" << endl + << "#define XSD_CXX_TREE_USE_CHAR" << endl + << "#endif" << endl + << endl; + } + else if (ctx.char_type == L"wchar_t") + { + hxx << "#ifndef XSD_USE_WCHAR" << endl + << "#define XSD_USE_WCHAR" << endl + << "#endif" << endl + << endl; + + hxx << "#ifndef XSD_CXX_TREE_USE_WCHAR" << endl + << "#define XSD_CXX_TREE_USE_WCHAR" << endl + << "#endif" << endl + << endl; + } + } + else if (!generate_xml_schema) + { + // Generate it before the prologue so that we get the above + // defines. + // + hxx << "#include " << ctx.process_include_path (fwd_name) + << endl << endl; + } + + // Copy prologue. + // + hxx << "// Begin prologue." << endl + << "//" << endl; + + append (hxx, ops.hxx_prologue (), ops.prologue ()); + append (hxx, ops.hxx_prologue_file (), prologue); + + hxx << "//" << endl + << "// End prologue." << endl + << endl; + + // Version check. + // + hxx << "#include " << endl + << endl + << "#if (LIBXSD_VERSION != " << XSD_VERSION << "L)" << endl + << "#error XSD runtime version mismatch" << endl + << "#endif" << endl + << endl; + + hxx << "#include " << endl + << endl; + + // Generate. + // + { + ind_filter ind (hxx); // We don't want to indent prologues/epilogues. + + if (!generate_xml_schema && !forward) + generate_forward (ctx); + + generate_tree_header (ctx); + + if (!generate_xml_schema) + { + if (ops.generate_ostream ()) + generate_stream_header (ctx); + + if (!ops.generate_element_type () && !ops.suppress_parsing ()) + generate_parser_header (ctx); + + if (ops.generate_serialization ()) + generate_serialization_header (ctx); + + if (!ops.generate_insertion ().empty ()) + generate_stream_insertion_header (ctx); + } + } + + hxx << "#include " << endl + << endl; + + // Copy epilogue. + // + // Note that it goes before the inline file in case it defines + // something (such as a custom type) which is needed by this file. + // And if something in the epilogue needs something from the inline + // file, then it should be the inline rather than header epilogue. + // + hxx << "// Begin epilogue." << endl + << "//" << endl; + + append (hxx, ops.hxx_epilogue_file (), epilogue); + append (hxx, ops.hxx_epilogue (), ops.epilogue ()); + + hxx << "//" << endl + << "// End epilogue." << endl + << endl; + + if (inline_) + { + hxx << "#ifndef XSD_DONT_INCLUDE_INLINE" << endl + << "#include " << ctx.process_include_path (ixx_name) << endl + << "#endif // XSD_DONT_INCLUDE_INLINE" << endl + << endl; + } + + hxx << "#endif // " << guard << endl; + + if (show_sloc) + wcerr << hxx_path << ": " << sloc.stream ().count () << endl; + + sloc_total += sloc.stream ().count (); + } + + + // IXX + // + if (gen_cxx && inline_) + { + Context ctx (ixx, + schema, + file_path, + ops, + counts, + generate_xml_schema, + &string_literal_map, + &fwd_expr, + &hxx_expr, + &ixx_expr); + + sloc_filter sloc (ixx); + + // Guard + // + String guard (guard_expr.replace (guard_prefix + ixx_name)); + guard = ctx.escape (guard); // make a c++ id + std::transform (guard.begin (), guard.end(), guard.begin (), upcase); + + ixx << "#ifndef " << guard.c_str () << endl + << "#define " << guard.c_str () << endl + << endl; + + // Copy prologue. + // + ixx << "// Begin prologue." << endl + << "//" << endl; + + append (ixx, ops.ixx_prologue (), ops.prologue ()); + append (ixx, ops.ixx_prologue_file (), prologue); + + ixx << "//" << endl + << "// End prologue." << endl + << endl; + + ixx << "#include " << endl + << endl; + + // Generate. + // + { + ind_filter ind (ixx); // We don't want to indent prologues/epilogues. + generate_tree_inline (ctx, 1, 0); + } + + ixx << "#include " << endl + << endl; + + // Copy epilogue. + // + ixx << "// Begin epilogue." << endl + << "//" << endl; + + append (ixx, ops.ixx_epilogue_file (), epilogue); + append (ixx, ops.ixx_epilogue (), ops.epilogue ()); + + ixx << "//" << endl + << "// End epilogue." << endl + << endl; + + ixx << "#endif // " << guard.c_str () << endl; + + if (show_sloc) + wcerr << ixx_path << ": " << sloc.stream ().count () << endl; + + sloc_total += sloc.stream ().count (); + } + + // CXX + // + if (gen_cxx && source) + { + size_t first_unit (0); // First unit in the current part. + + for (size_t part (0); part < parts; ++part) + { + // Figure out the range of units for this part. + // + size_t last_unit (first_unit); + + if (units != 0) + { + size_t complexity (counts.complexity[last_unit]); + + while (complexity < complexity_per_part) + { + // Make sure there will be at least one unit for each part left. + // + if ((last_unit + 1) >= units || + (units - (last_unit + 1) - 1) < (parts - part - 1)) + break; + + // Check if the increase in complexity should be kept in this + // part or moved to the next. + // + size_t new_complexity ( + complexity + counts.complexity[last_unit + 1]); + + if (new_complexity > complexity_per_part) + { + if ((new_complexity - complexity_per_part) > + (counts.complexity[last_unit + 1] / 2)) + break; + } + + last_unit++; + complexity = new_complexity; + } + + if (part + 1 == parts) + { + // Last part. + // + last_unit = units - 1; + } + } + + // + // + size_t first (first_unit); + size_t last (last_unit); + + first_unit = last_unit + 1; + + //wcerr << "[" << first << ", " << last << "]: " << complexity + // << endl; + + WideOutputFileStream& os (*cxx[part]); + + Context ctx (os, + schema, + file_path, + ops, + counts, + generate_xml_schema, + &string_literal_map, + &fwd_expr, + &hxx_expr, + &ixx_expr); + + sloc_filter sloc (os); + + // Copy prologue. + // + os << "// Begin prologue." << endl + << "//" << endl; + + append (os, ops.cxx_prologue (), ops.prologue ()); + append (os, ops.cxx_prologue_file (), prologue); + + os << "//" << endl + << "// End prologue." << endl + << endl; + + os << "#include " << endl + << endl; + + os << "#include " << ctx.process_include_path (hxx_name) << endl + << endl; + + // Generate. + // + { + // We don't want to indent prologues/epilogues. + // + ind_filter ind (os); + + if (!inline_) + generate_tree_inline (ctx, first, last); + + generate_tree_source (ctx, first, last); + + if (ops.generate_ostream ()) + generate_stream_source (ctx, first, last); + + if (!ops.generate_element_type () && !ops.suppress_parsing ()) + generate_parser_source (ctx, first, last); + + if (ops.generate_serialization ()) + generate_serialization_source (ctx, first, last); + + if (!ops.generate_extraction ().empty ()) + generate_stream_extraction_source (ctx); + + if (!ops.generate_insertion ().empty ()) + generate_stream_insertion_source (ctx); + } + + os << "#include " << endl + << endl; + + // Copy epilogue. + // + os << "// Begin epilogue." << endl + << "//" << endl; + + append (os, ops.cxx_epilogue_file (), epilogue); + append (os, ops.cxx_epilogue (), ops.epilogue ()); + + os << "//" << endl + << "// End epilogue." << endl + << endl; + + if (show_sloc) + wcerr << cxx_paths[part] << ": " << sloc.stream ().count () + << endl; + + sloc_total += sloc.stream ().count (); + } + } + + return sloc_total; + } + catch (UnrepresentableCharacter const& e) + { + wcerr << "error: character at position " << e.position () << " " + << "in string '" << e.string () << "' is unrepresentable in " + << "the target encoding" << endl; + + wcerr << "info: use the --custom-literals option to provide custom " + << "string literals mapping" << endl; + + throw Failed (); + } + catch (NoNamespaceMapping const& e) + { + wcerr << e.file () << ":" << e.line () << ":" << e.column () + << ": error: unable to map XML Schema namespace '" << e.ns () + << "' to C++ namespace" << endl; + + wcerr << e.file () << ":" << e.line () << ":" << e.column () + << ": info: use the --namespace-map or --namespace-regex option " + << "to provide custom mapping" << endl; + + throw Failed (); + } + catch (InvalidNamespaceMapping const& e) + { + wcerr << "error: invalid XML to C++ namespace mapping specified: " + << "'" << e.mapping () << "': " << e.reason () << endl; + + throw Failed (); + } + catch (InvalidCustomTypeMapping const& e) + { + wcerr << "error: invalid custom type mapping specified: " + << "'" << e.mapping () << "': " << e.reason () << endl; + + throw Failed (); + } + catch (cutl::re::format const& e) + { + wcerr << "error: invalid regex: '" << + e.regex ().c_str () << "': " << + e.description ().c_str () << endl; + + throw Failed (); + } + catch (cutl::re::wformat const& e) + { + wcerr << "error: invalid regex: '" << + e.regex () << "': " << e.description ().c_str () << endl; + + throw Failed (); + } + } +} diff --git a/xsd/cxx/tree/generator.hxx b/xsd/cxx/tree/generator.hxx new file mode 100644 index 0000000..a9b96fe --- /dev/null +++ b/xsd/cxx/tree/generator.hxx @@ -0,0 +1,44 @@ +// file : xsd/cxx/tree/generator.hxx +// license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +#ifndef XSD_CXX_TREE_GENERATOR_HXX +#define XSD_CXX_TREE_GENERATOR_HXX + +#include // Path +#include + +#include +#include + +#include +#include + +namespace CXX +{ + namespace Tree + { + class Generator + { + public: + static void + usage (); + + struct Failed {}; + + static size_t + generate (options const&, + XSDFrontend::SemanticGraph::Schema&, + XSDFrontend::SemanticGraph::Path const& file, + bool file_per_type, + StringLiteralMap const&, + const WarningSet& disabled_warnings, + FileList& file_list, + AutoUnlinks& unlinks); + + private: + Generator (); + }; + } +} + +#endif // XSD_CXX_TREE_GENERATOR_HXX diff --git a/xsd/cxx/tree/name-processor.cxx b/xsd/cxx/tree/name-processor.cxx new file mode 100644 index 0000000..325870a --- /dev/null +++ b/xsd/cxx/tree/name-processor.cxx @@ -0,0 +1,2427 @@ +// file : xsd/cxx/tree/name-processor.cxx +// license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +#include +#include +#include +#include +#include + +#include + +#include +#include + +using namespace std; + +namespace CXX +{ + namespace Tree + { + namespace + { + // + // + typedef set NameSet; + + class Context: public Tree::Context + { + public: + struct Failed {}; + + Context (Tree::options const& ops, + Counts const& counts, + bool generate_xml_schema, + SemanticGraph::Schema& root, + SemanticGraph::Path const& path, + StringLiteralMap const& map) + : Tree::Context (std::wcerr, + root, + path, + ops, + counts, + generate_xml_schema, + &map, + 0, + 0, + 0), + global_type_names (global_type_names_), + global_element_names (global_element_names_), + detach (ops.generate_detach ()), + type_regex (type_regex_), + accessor_regex (accessor_regex_), + one_accessor_regex (one_accessor_regex_), + opt_accessor_regex (opt_accessor_regex_), + seq_accessor_regex (seq_accessor_regex_), + modifier_regex (modifier_regex_), + one_modifier_regex (one_modifier_regex_), + opt_modifier_regex (opt_modifier_regex_), + seq_modifier_regex (seq_modifier_regex_), + parser_regex (parser_regex_), + serializer_regex (serializer_regex_), + const_regex (const_regex_), + enumerator_regex (enumerator_regex_), + element_type_regex (element_type_regex_) + { + NarrowString tn (options.type_naming ()); + NarrowString fn (options.function_naming ()); + + // Type name regex. + // + { + // Predefined rules. The most frequently used come last: global + // names, two components (,type), three components + // (,const,iterator), and one component (value in enum). + // + if (tn == "knr") + { + type_regex.push_back ("/(?:[^ ]* )?([^,]+),([^,]+),([^,]+),([^,]+)/$1_$2_$3_$4/"); + type_regex.push_back ("/(?:[^ ]* )?([^,]+),([^,]+),([^,]+)/$1_$2_$3/"); + type_regex.push_back ("/(?:[^ ]* )?([^,]+),([^,]+)/$1_$2/"); + type_regex.push_back ("/(?:[^ ]* )?([^,]+)/$1/"); + + /* + type_regex.push_back ("/([^,]+)/$1/"); + type_regex.push_back ("/([^,]+),([^,]+),([^,]+),([^,]+)/$1_$2_$3_$4/"); + type_regex.push_back ("/([^,]+),([^,]+),([^,]+)/$1_$2_$3/"); + type_regex.push_back ("/([^,]+),([^,]+)/$1_$2/"); + type_regex.push_back ("/[^ ]* (.+)/$1/"); + */ + } + else + { + // Upper camel case or Java. + // + type_regex.push_back ("/(?:[^ ]* )?([^,]+),([^,]+),([^,]+),([^,]+)/\\u$1\\u$2\\u$3\\u$4/"); + type_regex.push_back ("/(?:[^ ]* )?([^,]+),([^,]+),([^,]+)/\\u$1\\u$2\\u$3/"); + type_regex.push_back ("/(?:[^ ]* )?([^,]+),([^,]+)/\\u$1\\u$2/"); + type_regex.push_back ("/(?:[^ ]* )?([^,]+)/\\u$1/"); + + /* + type_regex.push_back ("/([^,]+)/\\u$1/"); + type_regex.push_back ("/([^,]+),([^,]+),([^,]+),([^,]+)/\\u$1\\u$2\\u$3\\u$4/"); + type_regex.push_back ("/([^,]+),([^,]+),([^,]+)/\\u$1\\u$2\\u$3/"); + type_regex.push_back ("/([^,]+),([^,]+)/\\u$1\\u$2/"); + type_regex.push_back ("/[^ ]* (.+)/\\u$1/"); + */ + + } + + compile_regex (options.type_regex (), type_regex, "type"); + } + + // Accessor name regex. + // + { + // Predefined rules. The most frequently used come last: one + // component, three components (,default,value) and two + // component (dom,document). + // + if (fn == "knr") + { + accessor_regex.push_back ("/([^,]+),([^,]+)/$1_$2/"); + accessor_regex.push_back ("/([^,]+),([^,]+),([^,]+)/$1_$2_$3/"); + accessor_regex.push_back ("/([^,]+)/$1/"); + } + else if (fn == "lcc") + { + accessor_regex.push_back ("/([^,]+),([^,]+)/\\l$1\\u$2/"); + accessor_regex.push_back ("/([^,]+),([^,]+),([^,]+)/\\l$1\\u$2\\u$3/"); + accessor_regex.push_back ("/([^,]+)/\\l$1/"); + } + else if (fn == "ucc") + { + accessor_regex.push_back ("/([^,]+),([^,]+)/\\u$1\\u$2/"); + accessor_regex.push_back ("/([^,]+),([^,]+),([^,]+)/\\u$1\\u$2\\u$3/"); + accessor_regex.push_back ("/([^,]+)/\\u$1/"); + } + else + { + // Java: add get. + // + accessor_regex.push_back ("/([^,]+),([^,]+)/get\\u$1\\u$2/"); + accessor_regex.push_back ("/([^,]+),([^,]+),([^,]+)/get\\u$1\\u$2\\u$3/"); + accessor_regex.push_back ("/([^,]+)/get\\u$1/"); + } + + compile_regex (options.accessor_regex (), + accessor_regex, + "accessor"); + + compile_regex (options.one_accessor_regex (), + one_accessor_regex, + "one accessor"); + + compile_regex (options.opt_accessor_regex (), + opt_accessor_regex, + "optional accessor"); + + compile_regex (options.seq_accessor_regex (), + seq_accessor_regex, + "sequence accessor"); + } + + // Modifier name regex. + // + { + if (fn == "knr") + { + // any,attribute + // + modifier_regex.push_back ("/([^,]+),([^,]+)/$1_$2/"); + } + else if (fn == "lcc") + { + modifier_regex.push_back ("/([^,]+),([^,]+)/\\l$1\\u$2/"); + modifier_regex.push_back ("/([^,]+)/\\l$1/"); + } + else if (fn == "ucc") + { + modifier_regex.push_back ("/([^,]+),([^,]+)/\\u$1\\u$2/"); + modifier_regex.push_back ("/([^,]+)/\\u$1/"); + } + else + { + // Java: add set. + // + modifier_regex.push_back ("/([^,]+),([^,]+)/set\\u$1\\u$2/"); + modifier_regex.push_back ("/([^,]+)/set\\u$1/"); + modifier_regex.push_back ("/detach,([^,]+)/detach\\u$1/"); + } + + compile_regex (options.modifier_regex (), + modifier_regex, + "modifier"); + + compile_regex (options.one_modifier_regex (), + one_modifier_regex, + "one modifier"); + + compile_regex (options.opt_modifier_regex (), + opt_modifier_regex, + "optional modifier"); + + compile_regex (options.seq_modifier_regex (), + seq_modifier_regex, + "sequence modifier"); + } + + // Parser name regex. + // + { + if (fn == "lcc") + { + parser_regex.push_back ("/(.+)/\\l$1/"); + } + else if (fn == "ucc") + { + parser_regex.push_back ("/(.+)/\\u$1/"); + } + else if (fn == "java") + { + // Java: add parse. + // + parser_regex.push_back ("/(.+)/parse\\u$1/"); + } + + compile_regex (options.parser_regex (), parser_regex, "parser"); + } + + // Serializer name regex. + // + { + if (fn == "lcc") + { + serializer_regex.push_back ("/(.+)/\\l$1/"); + } + else if (fn == "ucc") + { + serializer_regex.push_back ("/(.+)/\\u$1/"); + } + else if (fn == "java") + { + // Java: add serialize. + // + serializer_regex.push_back ("/(.+)/serialize\\u$1/"); + } + + compile_regex (options.serializer_regex (), + serializer_regex, + "serializer"); + } + + // Const regex. + // + { + if (fn == "knr") + { + const_regex.push_back ("/([^,]+),([^,]+),([^,]+)/$1_$2_$3/"); + const_regex.push_back ("/([^,]+),([^,]+)/$1_$2/"); + } + else if (fn == "lcc") + { + const_regex.push_back ("/([^,]+),([^,]+),([^,]+)/\\l$1_\\u$2_\\u$3/"); + const_regex.push_back ("/([^,]+),([^,]+)/\\l$1\\u$2/"); + } + else if (fn == "ucc") + { + const_regex.push_back ("/([^,]+),([^,]+),([^,]+)/\\u$1_\\u$2_\\u$3/"); + const_regex.push_back ("/([^,]+),([^,]+)/\\u$1\\u$2/"); + } + else + { + // Java: all uppercase. + // + const_regex.push_back ("/([^,]+),([^,]+),([^,]+)/\\U$1_$2_$3/"); + const_regex.push_back ("/([^,]+),([^,]+)/\\U$1_$2/"); + } + + compile_regex (options.const_regex (), const_regex, "const"); + } + + // Enumerator name regex. + // + { + // By default map an empty enumerator to the 'empty' word. + // + enumerator_regex.push_back ("/^$/empty/"); + + compile_regex (options.enumerator_regex (), + enumerator_regex, + "enumerator"); + } + + // Element type regex. + // + compile_regex (options.element_type_regex (), + element_type_regex, + "element_type"); + } + + protected: + Context (Context& c) + : Tree::Context (c), + global_type_names (c.global_type_names), + global_element_names (c.global_element_names), + detach (c.detach), + type_regex (c.type_regex), + accessor_regex (c.accessor_regex), + one_accessor_regex (c.one_accessor_regex), + opt_accessor_regex (c.opt_accessor_regex), + seq_accessor_regex (c.seq_accessor_regex), + modifier_regex (c.modifier_regex), + one_modifier_regex (c.one_modifier_regex), + opt_modifier_regex (c.opt_modifier_regex), + seq_modifier_regex (c.seq_modifier_regex), + parser_regex (c.parser_regex), + serializer_regex (c.serializer_regex), + const_regex (c.const_regex), + enumerator_regex (c.enumerator_regex), + element_type_regex (c.element_type_regex) + { + } + + public: + typedef cutl::re::wregexsub Regex; + typedef cutl::re::wformat RegexFormat; + + struct RegexVector: vector + { + void + push_back (String const& r) + { + vector::push_back (Regex (r)); + } + }; + + String + process_regex (String const& name, + RegexVector const& rv, + String const& id) + { + bool trace (options.name_regex_trace ()); + + if (trace) + os << id << " name: '" << name << "'" << endl; + + for (RegexVector::const_reverse_iterator i (rv.rbegin ()); + i != rv.rend (); ++i) + { + if (trace) + os << "try: '" << i->regex () << "' : "; + + if (i->match (name)) + { + String r (i->replace (name)); + + if (trace) + os << "'" << r << "' : +" << endl; + + return r; + } + + if (trace) + os << '-' << endl; + } + + return name; + } + + String + process_regex (String const& name, + RegexVector const& primary, + RegexVector const& backup, + String const& id) + { + bool trace (options.name_regex_trace ()); + + if (trace) + os << id << " name: '" << name << "'" << endl; + + for (RegexVector::const_reverse_iterator i (primary.rbegin ()); + i != primary.rend (); ++i) + { + if (trace) + os << "try: '" << i->regex () << "' : "; + + if (i->match (name)) + { + String r (i->replace (name)); + + if (trace) + os << "'" << r << "' : +" << endl; + + return r; + } + + if (trace) + os << '-' << endl; + } + + for (RegexVector::const_reverse_iterator i (backup.rbegin ()); + i != backup.rend (); ++i) + { + if (trace) + os << "try: '" << i->regex () << "' : "; + + if (i->match (name)) + { + String r (i->replace (name)); + + if (trace) + os << "'" << r << "' : +" << endl; + + return r; + } + + if (trace) + os << '-' << endl; + } + + return name; + } + + String + process_regex (String const& ns, + String const& name, + RegexVector const& rv, + String const& id) + { + String s (ns + L' ' + name); + bool trace (options.name_regex_trace ()); + + if (trace) + os << id << " name: '" << s << "'" << endl; + + for (RegexVector::const_reverse_iterator i (rv.rbegin ()); + i != rv.rend (); ++i) + { + if (trace) + os << "try: '" << i->regex () << "' : "; + + if (i->match (s)) + { + String r (i->replace (s)); + + if (trace) + os << "'" << r << "' : +" << endl; + + return r; + } + + if (trace) + os << '-' << endl; + } + + return name; + } + + String + process_regex (String const& ns, + String const& name, + RegexVector const& primary, + RegexVector const& backup, + String const& id) + { + String s (ns + L' ' + name); + bool trace (options.name_regex_trace ()); + + if (trace) + os << id << " name: '" << s << "'" << endl; + + for (RegexVector::const_reverse_iterator i (primary.rbegin ()); + i != primary.rend (); ++i) + { + if (trace) + os << "try: '" << i->regex () << "' : "; + + if (i->match (s)) + { + String r (i->replace (s)); + + if (trace) + os << "'" << r << "' : +" << endl; + + return r; + } + + if (trace) + os << '-' << endl; + } + + for (RegexVector::const_reverse_iterator i (backup.rbegin ()); + i != backup.rend (); ++i) + { + if (trace) + os << "try: '" << i->regex () << "' : "; + + if (i->match (s)) + { + String r (i->replace (s)); + + if (trace) + os << "'" << r << "' : +" << endl; + + return r; + } + + if (trace) + os << '-' << endl; + } + + return name; + } + + public: + String + find_name (String const& base_name, + NameSet& set, + bool insert = true) + { + String name (base_name); + + for (size_t i (1); set.find (name) != set.end (); ++i) + { + std::wostringstream os; + os << i; + name = base_name + os.str (); + } + + if (insert) + set.insert (name); + + return name; + } + + private: + void + compile_regex (NarrowStrings const& sv, + RegexVector& rv, + String const& id) + { + for (NarrowStrings::const_iterator i (sv.begin ()); i != sv.end (); + ++i) + { + try + { + rv.push_back (*i); + } + catch (RegexFormat const& e) + { + os << "error: invalid " << id << " name regex: '" << + e.regex () << "': " << e.description ().c_str () << endl; + + throw Failed (); + } + } + } + + private: + map global_type_names_; + map global_element_names_; + + RegexVector type_regex_; + RegexVector accessor_regex_; + RegexVector one_accessor_regex_; + RegexVector opt_accessor_regex_; + RegexVector seq_accessor_regex_; + RegexVector modifier_regex_; + RegexVector one_modifier_regex_; + RegexVector opt_modifier_regex_; + RegexVector seq_modifier_regex_; + RegexVector parser_regex_; + RegexVector serializer_regex_; + RegexVector const_regex_; + RegexVector enumerator_regex_; + RegexVector element_type_regex_; + + public: + map& global_type_names; + map& global_element_names; + + bool detach; + + RegexVector& type_regex; + RegexVector& accessor_regex; + RegexVector& one_accessor_regex; + RegexVector& opt_accessor_regex; + RegexVector& seq_accessor_regex; + RegexVector& modifier_regex; + RegexVector& one_modifier_regex; + RegexVector& opt_modifier_regex; + RegexVector& seq_modifier_regex; + RegexVector& parser_regex; + RegexVector& serializer_regex; + RegexVector& const_regex; + RegexVector& enumerator_regex; + RegexVector& element_type_regex; + }; + + // + // + struct Enumerator: Traversal::Enumerator, Context + { + Enumerator (Context& c, NameSet& set) + : Context (c), set_ (set) + { + } + + virtual void + traverse (Type& e) + { + // Process the name with enumerator name regex. + // + String name ( + process_regex (e.name (), enumerator_regex, L"enumerator")); + + // Escape and unclash. + // + name = find_name (escape (name), set_); + e.context ().set ("name", name); + } + + private: + NameSet& set_; + }; + + // + // + struct Enumeration: Traversal::Enumeration, Context + { + Enumeration (Context& c) + : Context (c) + { + } + + virtual void + traverse (Type& e) + { + // Use processed name. + // + String name (e.context ().get ("name")); + + // If renamed name is empty then we are not generating + // anything for this type and name processing is not + // required. + // + if (renamed_type (e, name) && !name) + return; + + NameSet enum_set; + enum_set.insert (name); + + Enumerator enumerator (*this, enum_set); + Traversal::Names names (enumerator); + + Traversal::Enumeration::names (e, names); + + // Assign name to the value type. First process the name + // with type name regex. + // + String value_name ( + escape (process_regex ("value", type_regex, L"type"))); + e.context ().set ("value", find_name (value_name, enum_set)); + } + }; + + // + // + struct PrimaryMember: Traversal::Member, Context + { + PrimaryMember (Context& c, NameSet& name_set, NameSet& stem_set) + : Context (c), name_set_ (name_set), stem_set_ (stem_set) + { + } + + virtual void + traverse (Type& m) + { + if (Tree::Context::skip (m)) + return; + + String stem (find_name (m.name (), stem_set_)); + + m.context ().set ("stem", stem); + m.context ().set ("name", + find_name (escape (stem), name_set_, false)); + } + + private: + NameSet& name_set_; + NameSet& stem_set_; + }; + + // + // + struct DerivedMember: Traversal::Member, Context + { + DerivedMember (Context& c, NameSet& name_set) + : Context (c), name_set_ (name_set) + { + } + + virtual void + traverse (Type& m) + { + if (Tree::Context::skip (m)) + return; + + SemanticGraph::Complex& c ( + dynamic_cast (m.scope ())); + + size_t max (Tree::Context::max (m)); + size_t min (Tree::Context::min (m)); + + String const& s (m.context ().get ("stem")); + String const& b (m.context ().get ("name")); + + bool def_attr (m.default_p () && + m.is_a ()); + + // Accessors/modifiers. Note that we postpone inserting + // the names into the name_set to avoid over-escaping. + // + String an, mn; + + if (max != 1) + { + an = find_name ( + escape (process_regex (s, + seq_accessor_regex, + accessor_regex, + L"sequence accessor")), + name_set_, + false); + + mn = find_name ( + escape (process_regex (s, + seq_modifier_regex, + modifier_regex, + L"sequence modifier")), + name_set_, + false); + } + else if (min == 0 && !def_attr) + { + an = find_name ( + escape (process_regex (s, + opt_accessor_regex, + accessor_regex, + L"optional accessor")), + name_set_, + false); + + mn = find_name ( + escape (process_regex (s, + opt_modifier_regex, + modifier_regex, + L"optional modifier")), + name_set_, + false); + } + else + { + an = find_name ( + escape (process_regex (s, + one_accessor_regex, + accessor_regex, + L"one accessor")), + name_set_, + false); + + mn = find_name ( + escape (process_regex (s, + one_modifier_regex, + modifier_regex, + L"one modifier")), + name_set_, + false); + } + + m.context ().set ("aname", an); + m.context ().set ("mname", mn); + + name_set_.insert (b); + + if (an != b) + name_set_.insert (an); + + if (mn != b && mn != an) + name_set_.insert (mn); + + // Detach. + // + if (detach && max == 1 && (min == 1 || def_attr)) + { + String dn (find_name ( + escape (process_regex (L"detach," + s, + one_modifier_regex, + modifier_regex, + L"one modifier")), + name_set_)); + + m.context ().set ("dname", dn); + } + + // Types. + // + m.context ().set ( + "type", + find_name ( + escape (process_regex (s + L",type", type_regex, L"type")), + name_set_)); + + m.context ().set ( + "traits", + find_name ( + escape (process_regex (s + L",traits", type_regex, L"type")), + name_set_)); + + if (max != 1) + { + m.context ().set ( + "container", + find_name ( + escape (process_regex (s + L",sequence", type_regex, L"type")), + name_set_)); + + m.context ().set ( + "iterator", + find_name ( + escape (process_regex (s + L",iterator", type_regex, L"type")), + name_set_)); + + m.context ().set ( + "const-iterator", + find_name ( + escape ( + process_regex (s + L",const,iterator", type_regex, L"type")), + name_set_)); + } + else if (min == 0 && !def_attr) + { + m.context ().set ( + "container", + find_name ( + escape (process_regex (s + L",optional", type_regex, L"type")), + name_set_)); + } + + // Data member. + // + m.context ().set ("member", find_name (b + L"_", name_set_)); + + // Default value. + // + if (m.default_p ()) + { + bool simple (true); + + if (m.is_a ()) + { + IsSimpleType test (simple); + test.dispatch (m.type ()); + } + + if (simple) + { + String an ( + escape ( + process_regex ( + s + L",default,value", accessor_regex, L"accessor"))); + + m.context ().set ("default-value", find_name (an, name_set_)); + + bool lit (false); + { + IsLiteralValue test (lit); + test.dispatch (m.type ()); + } + + if (!lit) + { + m.context ().set ( + "default-value-member", + find_name (b + L"_default_value_", name_set_)); + } + } + } + + // Element id. + // + if (m.is_a () && ordered_p (c)) + { + String id ( + escape ( + process_regex ( + s + L",id", const_regex, L"const"))); + + m.context ().set ("ordered-id-name", find_name (id, name_set_)); + } + } + + private: + NameSet& name_set_; + }; + + + // + // + struct Any: Traversal::Any, Traversal::AnyAttribute, Context + { + Any (Context& c, + NameSet& name_set, + NameSet& stem_set, + bool& has_wildcard) + : Context (c), + name_set_ (name_set), + stem_set_ (stem_set), + has_wildcard_ (has_wildcard) + { + } + + virtual void + traverse (SemanticGraph::Any& a) + { + SemanticGraph::Complex& c ( + dynamic_cast (a.scope ())); + + size_t max (Tree::Context::max (a)); + size_t min (Tree::Context::min (a)); + + String s (find_name (L"any", stem_set_)); + + String b (find_name (escape (s), name_set_, false)); + a.context ().set ("name", b); + + // Accessors/modifiers. Note that we postpone inserting the + // names into the name_set to avoid over-escaping. + // + String an, mn; + + if (max != 1) + { + an = find_name ( + escape (process_regex (s, + seq_accessor_regex, + accessor_regex, + L"sequence accessor")), + name_set_, + false); + + mn = find_name ( + escape (process_regex (s, + seq_modifier_regex, + modifier_regex, + L"sequence modifier")), + name_set_, + false); + } + else if (min == 0) + { + an = find_name ( + escape (process_regex (s, + opt_accessor_regex, + accessor_regex, + L"optional accessor")), + name_set_, + false); + + mn = find_name ( + escape (process_regex (s, + opt_modifier_regex, + modifier_regex, + L"optional modifier")), + name_set_, + false); + } + else + { + an = find_name ( + escape (process_regex (s, + one_accessor_regex, + accessor_regex, + L"one accessor")), + name_set_, + false); + + mn = find_name ( + escape (process_regex (s, + one_modifier_regex, + modifier_regex, + L"one modifier")), + name_set_, + false); + } + + a.context ().set ("aname", an); + a.context ().set ("mname", mn); + + name_set_.insert (b); + + if (an != b) + name_set_.insert (an); + + if (mn != b && mn != an) + name_set_.insert (mn); + + // Types + // + if (max != 1) + { + a.context ().set ( + "container", + find_name ( + escape (process_regex (s + L",sequence", type_regex, L"type")), + name_set_)); + + a.context ().set ( + "iterator", + find_name ( + escape (process_regex (s + L",iterator", type_regex, L"type")), + name_set_)); + + a.context ().set ( + "const-iterator", + find_name ( + escape ( + process_regex (s + L",const,iterator", type_regex, L"type")), + name_set_)); + } + else if (min == 0) + { + a.context ().set ( + "container", + find_name ( + escape (process_regex (s + L",optional", type_regex, L"type")), + name_set_)); + } + + // Data member. + // + a.context ().set ("member", find_name (b + L"_", name_set_)); + + // Wildcard id. + // + if (ordered_p (c)) + { + String id ( + escape ( + process_regex ( + s + L",id", const_regex, L"const"))); + + a.context ().set ("ordered-id-name", find_name (id, name_set_)); + } + + if (!has_wildcard_) + has_wildcard_ = true; + } + + virtual void + traverse (SemanticGraph::AnyAttribute& a) + { + String s (find_name (L"any,attribute", stem_set_)); + + String b (find_name (escape (s), name_set_, false)); + a.context ().set ("name", b); + + // Accessors/modifiers. Note that we postpone inserting the + // names into the name_set to avoid over-escaping. + // + String an ( + find_name ( + escape (process_regex (s, accessor_regex, L"accessor")), + name_set_, + false)); + + String mn ( + find_name ( + escape (process_regex (s, modifier_regex, L"modifier")), + name_set_, + false)); + + a.context ().set ("aname", an); + a.context ().set ("mname", mn); + + name_set_.insert (b); + + if (an != b) + name_set_.insert (an); + + if (mn != b && mn != an) + name_set_.insert (mn); + + // Types + // + a.context ().set ( + "container", + find_name ( + escape (process_regex (s + L",set", type_regex, L"type")), + name_set_)); + + a.context ().set ( + "iterator", + find_name ( + escape (process_regex (s + L",iterator", type_regex, L"type")), + name_set_)); + + a.context ().set ( + "const-iterator", + find_name ( + escape ( + process_regex (s + L",const,iterator", type_regex, L"type")), + name_set_)); + + // Data member. + // + a.context ().set ("member", find_name (b + L"_", name_set_)); + + if (!has_wildcard_) + has_wildcard_ = true; + } + + private: + NameSet& name_set_; + NameSet& stem_set_; + bool& has_wildcard_; + }; + + // + // + struct Complex: Traversal::Complex, Context + { + Complex (Context& c) + : Context (c) + { + } + + virtual void + traverse (Type& c) + { + SemanticGraph::Context& ctx (c.context ()); + + // We leave this set around to allow other mappings to use + // this information. + // + ctx.set ("cxx-tree-name-processor-stem-set", NameSet ()); + ctx.set ("cxx-tree-name-processor-member-set", NameSet ()); + + // Use processed name. + // + String name (ctx.get ("name")); + + // If renamed name is empty then we are not generating + // anything for this type and name processing is not + // required. + // + if (renamed_type (c, name) && !name) + return; + + NameSet& stem_set ( + ctx.get ("cxx-tree-name-processor-stem-set")); + + NameSet& member_set ( + ctx.get ("cxx-tree-name-processor-member-set")); + + stem_set.insert (c.name ()); + member_set.insert (name); + + // Add our base's stems and members to the initial list. + // + if (c.inherits_p ()) + { + // @@ What if this types name is the same as one of base's + // members? + // + SemanticGraph::Type& base (c.inherits ().base ()); + + if (base.is_a () && + !base.is_a ()) + { + if (!base.context ().count ( + "cxx-tree-name-processor-member-set")) + { + dispatch (base); + } + + NameSet const& base_stem_set ( + base.context ().get ( + "cxx-tree-name-processor-stem-set")); + + stem_set.insert (base_stem_set.begin (), base_stem_set.end ()); + + NameSet const& base_member_set ( + base.context ().get ( + "cxx-tree-name-processor-member-set")); + + member_set.insert (base_member_set.begin (), + base_member_set.end ()); + } + } + + // First assign the "primary" names. + // + { + PrimaryMember member (*this, member_set, stem_set); + Traversal::Names names (member); + + Complex::names (c, names); + } + + // Derived names for members. + // + { + DerivedMember member (*this, member_set); + Traversal::Names names (member); + + Complex::names (c, names); + } + + // Names for the mixed content. + // + if (mixed_p (c)) + { + // Check if we already have the mixed content down inheritance + // hierarchy. + // + using SemanticGraph::Complex; + + for (Complex* p (&c); p->inherits_p ();) + { + if (Complex* b = dynamic_cast ( + &p->inherits ().base ())) + { + if (mixed_p (*b)) + { + SemanticGraph::Context& bctx (b->context ()); + ctx.set ("mixed-type", bctx.get ("mixed-type")); + ctx.set ("mixed-const-iterator", + bctx.get ("mixed-const-iterator")); + ctx.set ("mixed-ordered-id-name", + bctx.get ("mixed-ordered-id-name")); + ctx.set ("mixed-aname", bctx.get ("mixed-aname")); + ctx.set ("mixed-member", bctx.get ("mixed-member")); + ctx.set ("mixed-in-base", true); + break; + } + + p = b; + } + else + break; + } + + // If not, set up the names. + // + if (!ctx.count ("mixed-in-base")) + { + String s (find_name (L"text,content", stem_set)); + String n (find_name (escape (s), member_set, false)); + + String an (find_name ( + escape (process_regex (s, + seq_accessor_regex, + accessor_regex, + L"sequence accessor")), + member_set, + false)); + + String mn (find_name ( + escape (process_regex (s, + seq_modifier_regex, + modifier_regex, + L"sequence modifier")), + member_set, + false)); + + ctx.set ("mixed-aname", an); + ctx.set ("mixed-mname", mn); + + member_set.insert (name); + + if (an != n) + member_set.insert (an); + + if (mn != n && mn != an) + member_set.insert (mn); + + // Types. + // + ctx.set ( + "mixed-type", + find_name ( + escape (process_regex (s + L",type", type_regex, L"type")), + member_set)); + + ctx.set ( + "mixed-container", + find_name ( + escape (process_regex (s + L",sequence", type_regex, L"type")), + member_set)); + + ctx.set ( + "mixed-iterator", + find_name ( + escape (process_regex (s + L",iterator", type_regex, L"type")), + member_set)); + + ctx.set ( + "mixed-const-iterator", + find_name ( + escape ( + process_regex (s + L",const,iterator", type_regex, L"type")), + member_set)); + + // Text content id. + // + ctx.set ( + "mixed-ordered-id-name", + find_name ( + escape ( + process_regex (s + L",id", const_regex, L"const")), + member_set)); + + // Data member. + // + ctx.set ("mixed-member", find_name (n + L"_", member_set)); + } + } + + // Names for wildcards. + // + if (options.generate_wildcard ()) + { + bool has_wildcard (false); + Any any (*this, member_set, stem_set, has_wildcard); + Traversal::Names names (any); + Complex::names (c, names); + + // Assign names for dom_document. + // + if (has_wildcard) + { + // Check if we already have dom_document down inheritance + // hierarchy. + // + for (SemanticGraph::Complex* p (&c); p->inherits_p ();) + { + if (SemanticGraph::Complex* base = + dynamic_cast ( + &p->inherits ().base ())) + { + if (base->context ().count ("dom-document")) + { + c.context ().set ( + "dom-document", + base->context ().get ("dom-document")); + break; + } + + p = base; + } + else + break; + } + + // If not, set up the names. + // + if (!c.context ().count ("dom-document")) + { + String stem (find_name (L"dom,document", stem_set)); + + String an ( + escape ( + process_regex (stem, accessor_regex, L"accessor"))); + + c.context ().set ("dom-document", find_name (an, member_set)); + + c.context ().set ( + "dom-document-member", + find_name (escape (stem + L"_"), member_set)); + } + } + } + + // Names for the order container. + // + if (ordered_p (c)) + { + // Check if we already have the order container down + // inheritance hierarchy. + // + using SemanticGraph::Complex; + + for (Complex* p (&c); p->inherits_p ();) + { + if (Complex* b = dynamic_cast ( + &p->inherits ().base ())) + { + if (ordered_p (*b)) + { + SemanticGraph::Context& bctx (b->context ()); + ctx.set ("order-type", bctx.get ("order-type")); + ctx.set ("order-const-iterator", + bctx.get ("order-const-iterator")); + ctx.set ("order-aname", bctx.get ("order-aname")); + ctx.set ("order-member", bctx.get ("order-member")); + ctx.set ("order-in-base", true); + break; + } + + p = b; + } + else + break; + } + + // If not, set up the names. + // + if (!ctx.count ("order-in-base")) + { + String s (find_name (L"content,order", stem_set)); + String n (find_name (escape (s), member_set, false)); + + String an (find_name ( + escape (process_regex (s, + seq_accessor_regex, + accessor_regex, + L"sequence accessor")), + member_set, + false)); + + String mn (find_name ( + escape (process_regex (s, + seq_modifier_regex, + modifier_regex, + L"sequence modifier")), + member_set, + false)); + + ctx.set ("order-aname", an); + ctx.set ("order-mname", mn); + + member_set.insert (name); + + if (an != n) + member_set.insert (an); + + if (mn != n && mn != an) + member_set.insert (mn); + + // Types. + // + ctx.set ( + "order-type", + find_name ( + escape (process_regex (s + L",type", type_regex, L"type")), + member_set)); + + ctx.set ( + "order-container", + find_name ( + escape (process_regex (s + L",sequence", type_regex, L"type")), + member_set)); + + ctx.set ( + "order-iterator", + find_name ( + escape (process_regex (s + L",iterator", type_regex, L"type")), + member_set)); + + ctx.set ( + "order-const-iterator", + find_name ( + escape ( + process_regex (s + L",const,iterator", type_regex, L"type")), + member_set)); + + // Data member. + // + ctx.set ("order-member", find_name (n + L"_", member_set)); + } + } + } + }; + + + // + // + struct GlobalType: Traversal::Type, Context + { + GlobalType (Context& c, NameSet& set) + : Context (c), set_ (set) + { + } + + virtual void + traverse (SemanticGraph::Type& t) + { + // Process the name with type name regex. + // + String name (process_regex ( + namespace_ (t).name (), + t.name (), + type_regex, + L"type")); + + // Escape and unclash. + // + name = find_name (escape (name), set_); + t.context ().set ("name", name); + + // Also add renamed name if any. + // + if (renamed_type (t, name) && name) + set_.insert (name); + } + + private: + NameSet& set_; + }; + + + // + // + struct GlobalElement: Traversal::Element, + GlobalElementBase, + Context + { + GlobalElement (Context& c, + NameSet const& type_set, + NameSet& element_set) + : GlobalElementBase (c), + Context (c), + type_set_ (type_set), + element_set_ (element_set) + { + } + + virtual void + traverse (Type& e) + { + // First we need to figure out if we need to process this + // global element. + // + if (!generate_p (e)) + return; + + if (options.generate_element_type ()) + { + SemanticGraph::Context& ec (e.context ()); + + String name; + + if (doc_root_p (e)) + { + name = find_name ( + escape ( + process_regex ( + namespace_ (e).name (), + e.name (), + element_type_regex, + type_regex, + L"element type"))); + + // Assign inner names. + // + NameSet set; + set.insert (name); + + ec.set ( + "type", + Context::find_name ( + escape (process_regex (L"value,type", type_regex, L"type")), + set)); + + ec.set ( + "traits", + Context::find_name ( + escape (process_regex (L"value,traits", type_regex, L"type")), + set)); + + String an (Context::find_name ( + escape (process_regex ("value", + one_accessor_regex, + accessor_regex, + L"one accessor")), + set, + false)); + + String mn (Context::find_name ( + escape (process_regex ("value", + one_modifier_regex, + modifier_regex, + L"one modifier")), + set, + false)); + + ec.set ("aname", an); + ec.set ("mname", mn); + + set.insert (an); + + if (an != mn) + set.insert (mn); + + // Detach. + // + if (detach) + { + String dn (Context::find_name ( + escape (process_regex (L"detach,value", + one_modifier_regex, + modifier_regex, + L"one modifier")), + set)); + + ec.set ("dname", dn); + } + + // Assign name() and namespace_() names. + // + ec.set ( + "element-name", + Context::find_name ( + escape ( + process_regex ("name", accessor_regex, L"modifier")), + set)); + + ec.set ( + "element-ns", + Context::find_name ( + escape ( + process_regex ("namespace", accessor_regex, L"modifier")), + set)); + + // Data members. + // + ec.set ("member", Context::find_name ("value_", set)); + ec.set ("element-name-member", + Context::find_name ("name_", set)); + ec.set ("element-ns-member", + Context::find_name ("namespace__", set)); + } + else + name = find_name (escape (e.name ())); + + ec.set ("name", name); + element_set_.insert (name); + } + else + { + // Make sure the name is unique among global elements and + // does not collide with a global type name. + // + String base (find_name (escape (e.name ()))); + e.context ().set ("name", base); + + String n (e.name ()); + + // Assign the parsing function name. + // + String p; + + if (!options.suppress_parsing () && doc_root_p (e)) + { + p = find_name ( + escape ( + process_regex (n, parser_regex, L"parsing function"))); + + e.context ().set ("parser", p); + } + + // Assign the serialization function name. + // + String s; + + if (options.generate_serialization () && doc_root_p (e)) + { + s = find_name ( + escape ( + process_regex ( + n, serializer_regex, L"serialization function"))); + + e.context ().set ("serializer", s); + } + + // Add the names to the set only after processing parsing and + // serialization function names so that we do not over-escape + // them. + // + element_set_.insert (base); + + if (p && p != base) + element_set_.insert (p); + + if (s && s != base && s != p) + element_set_.insert (s); + } + } + + private: + String + find_name (String const& name) + { + String r (name); + + // If we are conflicting with a type name let's first try to + // simply append an underscore and only resort to ugly names + // like name1, etc., if this fails. + // + if (type_set_.find (r) != type_set_.end ()) + r += L"_"; + + for (size_t i (1); + element_set_.find (r) != element_set_.end () || + type_set_.find (r) != type_set_.end (); ++i) + { + std::wostringstream os; + os << i; + r = name + os.str (); + } + + return r; + } + + private: + NameSet const& type_set_; + NameSet& element_set_; + }; + + struct NamespacePassOne: Traversal::Namespace, Context + { + NamespacePassOne (Context& c) + : Context (c) + { + } + + virtual void + traverse (Type& ns) + { + NameSet& type_set (global_type_names[ns.name ()]); + + GlobalType type (*this, type_set); + Traversal::Names names (type); + + Traversal::Namespace::names (ns, names); + Traversal::Namespace::names (ns); + } + }; + + + struct NamespacePassThree: Traversal::Namespace, Context + { + NamespacePassThree (Context& c) + : Context (c) + { + } + + virtual void + traverse (Type& ns) + { + String const& name (ns.name ()); + + NameSet const& type_set (global_type_names[name]); + NameSet& element_set (global_element_names[name]); + + GlobalElement element (*this, type_set, element_set); + Traversal::Names names (element); + + Traversal::Namespace::names (ns, names); + } + }; + + + struct FundamentalNamespace: Traversal::Namespace, + + Traversal::AnyType, + Traversal::AnySimpleType, + + Traversal::Fundamental::Byte, + Traversal::Fundamental::UnsignedByte, + Traversal::Fundamental::Short, + Traversal::Fundamental::UnsignedShort, + Traversal::Fundamental::Int, + Traversal::Fundamental::UnsignedInt, + Traversal::Fundamental::Long, + Traversal::Fundamental::UnsignedLong, + Traversal::Fundamental::Integer, + Traversal::Fundamental::NonPositiveInteger, + Traversal::Fundamental::NonNegativeInteger, + Traversal::Fundamental::PositiveInteger, + Traversal::Fundamental::NegativeInteger, + + Traversal::Fundamental::Boolean, + + Traversal::Fundamental::Float, + Traversal::Fundamental::Double, + Traversal::Fundamental::Decimal, + + Traversal::Fundamental::String, + Traversal::Fundamental::NormalizedString, + Traversal::Fundamental::Token, + Traversal::Fundamental::Name, + Traversal::Fundamental::NameToken, + Traversal::Fundamental::NameTokens, + Traversal::Fundamental::NCName, + Traversal::Fundamental::Language, + + Traversal::Fundamental::Id, + Traversal::Fundamental::IdRef, + Traversal::Fundamental::IdRefs, + + Traversal::Fundamental::AnyURI, + + Traversal::Fundamental::QName, + + Traversal::Fundamental::Base64Binary, + Traversal::Fundamental::HexBinary, + + Traversal::Fundamental::Date, + Traversal::Fundamental::DateTime, + Traversal::Fundamental::Duration, + Traversal::Fundamental::Day, + Traversal::Fundamental::Month, + Traversal::Fundamental::MonthDay, + Traversal::Fundamental::Year, + Traversal::Fundamental::YearMonth, + Traversal::Fundamental::Time, + + Traversal::Fundamental::Entity, + Traversal::Fundamental::Entities, + + Context + { + using Namespace::traverse; + + FundamentalNamespace (Context& c) + : Context (c) + { + *this >> names_ >> *this; + } + + void + process_name (SemanticGraph::Type& t, String const& name) + { + String r ( + process_regex ( + namespace_ (t).name (), name, type_regex, L"type")); + + t.context ().set ("name", escape (r)); + } + + void + process_name (SemanticGraph::Namespace& n, + String const& name, + char const* key) + { + String r (process_regex (name, type_regex, L"type")); + n.context ().set (key, escape (r)); + } + + // anyType and anySimpleType + // + virtual void + traverse (SemanticGraph::AnyType& t) + { + process_name (t, "type"); + } + + virtual void + traverse (SemanticGraph::AnySimpleType& t) + { + process_name (t, "simple,type"); + } + + // Integrals. + // + virtual void + traverse (SemanticGraph::Fundamental::Byte& t) + { + process_name (t, "byte"); + } + + virtual void + traverse (SemanticGraph::Fundamental::UnsignedByte& t) + { + process_name (t, "unsigned,byte"); + } + + virtual void + traverse (SemanticGraph::Fundamental::Short& t) + { + process_name (t, "short"); + } + + virtual void + traverse (SemanticGraph::Fundamental::UnsignedShort& t) + { + process_name (t, "unsigned,short"); + } + + virtual void + traverse (SemanticGraph::Fundamental::Int& t) + { + process_name (t, "int"); + } + + virtual void + traverse (SemanticGraph::Fundamental::UnsignedInt& t) + { + process_name (t, "unsigned,int"); + } + + virtual void + traverse (SemanticGraph::Fundamental::Long& t) + { + process_name (t, "long"); + } + + virtual void + traverse (SemanticGraph::Fundamental::UnsignedLong& t) + { + process_name (t, "unsigned,long"); + } + + virtual void + traverse (SemanticGraph::Fundamental::Integer& t) + { + process_name (t, "integer"); + } + + virtual void + traverse (SemanticGraph::Fundamental::NonPositiveInteger& t) + { + process_name (t, "non,positive,integer"); + } + + virtual void + traverse (SemanticGraph::Fundamental::NonNegativeInteger& t) + { + process_name (t, "non,negative,integer"); + } + + virtual void + traverse (SemanticGraph::Fundamental::PositiveInteger& t) + { + process_name (t, "positive,integer"); + } + + virtual void + traverse (SemanticGraph::Fundamental::NegativeInteger& t) + { + process_name (t, "negative,integer"); + } + + // Boolean. + // + virtual void + traverse (SemanticGraph::Fundamental::Boolean& t) + { + process_name (t, "boolean"); + } + + // Floats. + // + virtual void + traverse (SemanticGraph::Fundamental::Float& t) + { + process_name (t, "float"); + } + + virtual void + traverse (SemanticGraph::Fundamental::Double& t) + { + process_name (t, "double"); + } + + virtual void + traverse (SemanticGraph::Fundamental::Decimal& t) + { + process_name (t, "decimal"); + } + + // Strings. + // + virtual void + traverse (SemanticGraph::Fundamental::String& t) + { + process_name (t, "string"); + } + + virtual void + traverse (SemanticGraph::Fundamental::NormalizedString& t) + { + process_name (t, "normalized,string"); + } + + virtual void + traverse (SemanticGraph::Fundamental::Token& t) + { + process_name (t, "token"); + } + + virtual void + traverse (SemanticGraph::Fundamental::NameToken& t) + { + process_name (t, "nmtoken"); + } + + virtual void + traverse (SemanticGraph::Fundamental::NameTokens& t) + { + process_name (t, "nmtokens"); + } + + virtual void + traverse (SemanticGraph::Fundamental::Name& t) + { + process_name (t, "name"); + } + + virtual void + traverse (SemanticGraph::Fundamental::NCName& t) + { + process_name (t, "ncname"); + } + + virtual void + traverse (SemanticGraph::Fundamental::Language& t) + { + process_name (t, "language"); + } + + // ID/IDREF. + // + virtual void + traverse (SemanticGraph::Fundamental::Id& t) + { + process_name (t, "id"); + } + + virtual void + traverse (SemanticGraph::Fundamental::IdRef& t) + { + process_name (t, "idref"); + } + + virtual void + traverse (SemanticGraph::Fundamental::IdRefs& t) + { + process_name (t, "idrefs"); + } + + + // URI. + // + virtual void + traverse (SemanticGraph::Fundamental::AnyURI& t) + { + process_name (t, "uri"); + } + + // Qualified name. + // + virtual void + traverse (SemanticGraph::Fundamental::QName& t) + { + process_name (t, "qname"); + } + + // Binary. + // + virtual void + traverse (SemanticGraph::Fundamental::Base64Binary& t) + { + process_name (t, "base64,binary"); + } + + virtual void + traverse (SemanticGraph::Fundamental::HexBinary& t) + { + process_name (t, "hex,binary"); + } + + + // Date/time. + // + virtual void + traverse (SemanticGraph::Fundamental::Date& t) + { + process_name (t, "date"); + } + + virtual void + traverse (SemanticGraph::Fundamental::DateTime& t) + { + process_name (t, "date,time"); + } + + virtual void + traverse (SemanticGraph::Fundamental::Duration& t) + { + process_name (t, "duration"); + } + + virtual void + traverse (SemanticGraph::Fundamental::Day& t) + { + process_name (t, "gday"); + } + + virtual void + traverse (SemanticGraph::Fundamental::Month& t) + { + process_name (t, "gmonth"); + } + + virtual void + traverse (SemanticGraph::Fundamental::MonthDay& t) + { + process_name (t, "gmonth,day"); + } + + virtual void + traverse (SemanticGraph::Fundamental::Year& t) + { + process_name (t, "gyear"); + } + + virtual void + traverse (SemanticGraph::Fundamental::YearMonth& t) + { + process_name (t, "gyear,month"); + } + + virtual void + traverse (SemanticGraph::Fundamental::Time& t) + { + process_name (t, "time"); + } + + // Entity. + // + virtual void + traverse (SemanticGraph::Fundamental::Entity& t) + { + process_name (t, "entity"); + } + + virtual void + traverse (SemanticGraph::Fundamental::Entities& t) + { + process_name (t, "entities"); + } + + virtual void + post (SemanticGraph::Namespace& n) + { + // Assign names to extra stuff in the XML Schema namespace. + // + process_name (n, "container", "container"); + process_name (n, "buffer", "buffer"); + process_name (n, "time,zone", "time-zone"); + + process_name (n, "content,order", "content-order"); + + if (options.generate_element_type ()) + process_name (n, "element,type", "element-type"); + + if (options.generate_element_map ()) + process_name (n, "element,map", "element-map"); + + if (options.generate_serialization ()) + { + process_name (n, "namespace,info", "namespace-info"); + process_name (n, "namespace,infomap", "namespace-infomap"); + process_name (n, "list,stream", "list-stream"); + process_name (n, "as,double", "as-double"); + process_name (n, "as,decimal", "as-decimal"); + process_name (n, "facet", "facet"); + } + + if (!options.generate_insertion ().empty ()) + { + process_name (n, "ostream", "ostream"); + } + + if (!options.generate_extraction ().empty ()) + { + process_name (n, "istream", "istream"); + } + + process_name (n, "flags", "flags"); + process_name (n, "properties", "properties"); + + NarrowString fn (options.function_naming ()); + + if (fn == "knr") + n.context ().set ("tree-node-key", String ("tree_node_key")); + else if (fn == "ucc") + n.context ().set ("tree-node-key", String ("TreeNodeKey")); + else + n.context ().set ("tree-node-key", String ("treeNodeKey")); + + process_name (n, "exception", "exception"); + process_name (n, "parsing", "parsing"); + process_name (n, "expected,element", "expected-element"); + process_name (n, "unexpected,element", "unexpected-element"); + process_name (n, "expected,attribute", "expected-attribute"); + process_name (n, "unexpected,enumerator", "unexpected-enumerator"); + process_name (n, "expected,text,content", "expected-text-content"); + process_name (n, "no,type,info", "no-type-info"); + process_name (n, "no,element,info", "no-element-info"); + process_name (n, "not,derived", "not-derived"); + process_name (n, "duplicate,id", "duplicate-id"); + process_name (n, "serialization", "serialization"); + process_name (n, "no,namespace,mapping", "no-namespace-mapping"); + process_name (n, "no,prefix,mapping", "no-prefix-mapping"); + process_name (n, "xsi,already,in,use", "xsi-already-in-use"); + process_name (n, "bounds", "bounds"); + + process_name (n, "severity", "severity"); + process_name (n, "error", "error"); + process_name (n, "diagnostics", "diagnostics"); + + if (!options.suppress_parsing () || + options.generate_serialization ()) + { + process_name (n, "error,handler", "error-handler"); + } + + Namespace::post (n); + } + + private: + Traversal::Names names_; + }; + + + // Go into sourced/included/imported schemas while making sure + // we don't process the same stuff more than once. + // + struct UsesPassOne: Traversal::Uses + { + virtual void + traverse (Type& u) + { + SemanticGraph::Schema& s (u.schema ()); + + if (!s.context ().count ("cxx-tree-name-processor-pass-1")) + { + s.context ().set ("cxx-tree-name-processor-pass-1", true); + Traversal::Uses::traverse (u); + } + } + }; + + struct UsesPassThree: Traversal::Uses + { + virtual void + traverse (Type& u) + { + SemanticGraph::Schema& s (u.schema ()); + + if (!s.context ().count ("cxx-tree-name-processor-pass-3")) + { + s.context ().set ("cxx-tree-name-processor-pass-3", true); + Traversal::Uses::traverse (u); + } + } + }; + + // Go into implied schemas while making sure we don't process + // the same stuff more than once. + // + struct Implies: Traversal::Implies + { + virtual void + traverse (SemanticGraph::Implies& i) + { + SemanticGraph::Schema& s (i.schema ()); + + if (!s.context ().count ("cxx-tree-name-processor-seen")) + { + s.context ().set ("cxx-tree-name-processor-seen", true); + Traversal::Implies::traverse (i); + } + } + }; + + bool + process_impl (options const& ops, + SemanticGraph::Schema& tu, + SemanticGraph::Path const& file, + StringLiteralMap const& map) + { + try + { + Counts counts; + Context ctx (ops, counts, false, tu, file, map); + + if (tu.names_begin ()->named ().name () == + L"http://www.w3.org/2001/XMLSchema") + { + // XML Schema namespace. + // + Traversal::Schema xs_schema; + Traversal::Names xs_schema_names; + FundamentalNamespace xs_ns (ctx); + + xs_schema >> xs_schema_names >> xs_ns; + + xs_schema.dispatch (tu); + } + else + { + + // Pass one - assign names to global types. This pass cannot + // be combined with pass two because of possible recursive + // schema inclusions. Also note that we check first if this + // schema has already been processed which may happen in the + // file-per-type compilation mode. + // + if (!tu.context ().count ("cxx-tree-name-processor-pass-1")) + { + Traversal::Schema schema; + Traversal::Schema xs_schema; + UsesPassOne uses; + Implies implies; + + schema >> uses >> schema; + schema >> implies >> xs_schema; + + Traversal::Names schema_names; + Traversal::Names xs_schema_names; + NamespacePassOne ns (ctx); + FundamentalNamespace xs_ns (ctx); + + schema >> schema_names >> ns; + xs_schema >> xs_schema_names >> xs_ns; + + // Some twisted schemas do recusive self-inclusion. + // + tu.context ().set ("cxx-tree-name-processor-pass-1", true); + + schema.dispatch (tu); + } + + // Pass two - assign names inside complex types. Here + // we don't need to go into included/imported schemas. + // + { + Traversal::Schema schema; + Sources sources; + + schema >> sources >> schema; + + Traversal::Names schema_names; + Traversal::Namespace ns; + Traversal::Names ns_names; + + schema >> schema_names >> ns >> ns_names; + + Complex complex (ctx); + Traversal::Enumeration enumeration; // Avoid fallback on complex. + + ns_names >> complex; + ns_names >> enumeration; + + schema.dispatch (tu); + } + + // Pass three - assign names to global elements as well as + // inside enums. Also note that we check first if this schema + // has already been processed which may happen in the file-per- + // type compilation mode. + // + if (!tu.context ().count ("cxx-tree-name-processor-pass-3")) + { + Traversal::Schema schema; + UsesPassThree uses; + + schema >> uses >> schema; + + Traversal::Names schema_names; + NamespacePassThree ns (ctx); + Traversal::Namespace ns_enum; + + schema >> schema_names; + + schema_names >> ns; + schema_names >> ns_enum; + + Traversal::Names ns_names; + Enumeration enumeration (ctx); + + ns_enum >> ns_names >> enumeration; + + // Some twisted schemas do recusive self-inclusion. + // + tu.context ().set ("cxx-tree-name-processor-pass-3", true); + + schema.dispatch (tu); + } + } + } + catch (Context::Failed const&) + { + // Diagnostics has already been issued. + // + return false; + } + + return true; + } + } + + bool NameProcessor:: + process (options const& ops, + SemanticGraph::Schema& tu, + SemanticGraph::Path const& file, + StringLiteralMap const& map) + { + return process_impl (ops, tu, file, map); + } + } +} diff --git a/xsd/cxx/tree/name-processor.hxx b/xsd/cxx/tree/name-processor.hxx new file mode 100644 index 0000000..632b05e --- /dev/null +++ b/xsd/cxx/tree/name-processor.hxx @@ -0,0 +1,28 @@ +// file : xsd/cxx/tree/name-processor.hxx +// license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +#ifndef XSD_CXX_TREE_NAME_PROCESSOR_HXX +#define XSD_CXX_TREE_NAME_PROCESSOR_HXX + +#include + +#include +#include + +namespace CXX +{ + namespace Tree + { + class NameProcessor + { + public: + bool + process (options const&, + XSDFrontend::SemanticGraph::Schema&, + XSDFrontend::SemanticGraph::Path const& file, + StringLiteralMap const&); + }; + } +} + +#endif // XSD_CXX_TREE_NAME_PROCESSOR_HXX diff --git a/xsd/cxx/tree/options.cli b/xsd/cxx/tree/options.cli new file mode 100644 index 0000000..0230429 --- /dev/null +++ b/xsd/cxx/tree/options.cli @@ -0,0 +1,479 @@ +// file : xsd/cxx/tree/options.cli +// license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +include ; // std::size_t + +include ; // NarrowString, NarrowStrings + +include ; + +namespace CXX +{ + namespace Tree + { + class options: CXX::options + { + // Polymorphism. + // + bool --generate-polymorphic + { + "Generate polymorphism-aware code. Specify this option if you use + substitution groups or \cb{xsi:type}. Use the \cb{--polymorphic-type} + or \cb{--polymorphic-type-all} option to specify which type + hierarchies are polymorphic." + }; + + NarrowStrings --polymorphic-type + { + "", + "Indicate that is a root of a polymorphic type hierarchy. The + compiler can often automatically determine which types are + polymorphic based on the substitution group declarations. However, + you may need to use this option if you are not using substitution + groups or if substitution groups are defined in another schema. You + need to specify this option when compiling every schema file that + references . The argument is an XML Schema type name + that can be optionally qualified with a namespace in the + \c{\i{namespace}\b{#}\i{name}} form." + }; + + bool --polymorphic-type-all + { + "Indicate that all types should be treated as polymorphic." + }; + + unsigned long --polymorphic-plate = 0 + { + "", + "Specify the polymorphic map plate the generated code should register + on. This functionality is primarily useful to segregate multiple + schemas that define the same polymorphic types." + }; + + // Ordered content. + // + NarrowStrings --ordered-type + { + "", + "Indicate that element order in is significant. An example + would be a complex type with unbounded choice as a content model + where the element order in XML has application-specific semantics. + For ordered types the compiler generates a special container data + member and a corresponding set of accessors and modifiers that are + used to capture the order of elements and, for mixed content, of + text. + + The argument is an XML Schema type name that can be optionally + qualified with a namespace in the \c{\i{namespace}\b{#}\i{name}} form. + Note also that you will need to specify this option when compiling + every schema file that has other ordered types derived from this + type." + }; + + bool --ordered-type-derived + { + "Automatically treat types derived from ordered bases as also + ordered. This is primarily useful if you would like to be able + to iterate over the complete content using the content order + container." + }; + + bool --ordered-type-mixed + { + "Automatically treat complex types with mixed content as ordered." + }; + + bool --ordered-type-all + { + "Indicate that element order in all types is significant." + }; + + NarrowString --order-container + { + "", + "Specify a custom class template that should be used as a container + for the content order in ordered types instead of the default + \cb{std::vector}. See \cb{--ordered-type} for more information on + ordered type. This option is primarily useful if you need to + perform more complex lookups in the content order container, for + example by element id. In this case, a container like Boost + multi-index may be more convenient. Note that if using a custom + container, you will also most likely need to include the relevant + headers using the \cb{--hxx-prologue*} options." + }; + + // Features. + // + bool --generate-serialization + { + "Generate serialization functions. Serialization functions convert + the object model back to XML." + }; + + bool --generate-ostream + { + "Generate ostream insertion operators (\cb{operator<<}) for generated + types. This allows one to easily print a fragment or the whole object + model for debugging or logging." + }; + + bool --generate-doxygen + { + "Generate documentation comments suitable for extraction by the + Doxygen documentation system. Documentation from annotations is + added to the comments if present in the schema." + }; + + bool --generate-comparison + { + "Generate comparison operators (\cb{operator==} and \cb{operator!=}) + for complex types. Comparison is performed member-wise." + }; + + bool --generate-default-ctor + { + "Generate default constructors even for types that have required + members. Required members of an instance constructed using such a + constructor are not initialized and accessing them results in + undefined behavior." + }; + + bool --generate-from-base-ctor + { + "Generate constructors that expect an instance of a base type + followed by all required members." + }; + + bool --suppress-assignment + { + "Suppress the generation of copy assignment operators for complex + types. If this option is specified, the copy assignment operators + for such types are declared private and left unimplemented." + }; + + bool --generate-detach + { + "Generate detach functions for required elements and attributes. + Detach functions for optional and sequence cardinalities are + provided by the respective containers. These functions, for + example, allow you to move sub-trees in the object model either + within the same tree or between different trees." + }; + + bool --generate-wildcard + { + "Generate accessors and modifiers as well as parsing and serialization + code for XML Schema wildcards (\cb{any} and \cb{anyAttribute}). XML + content matched by wildcards is presented as DOM fragments. Note + that you need to initialize the Xerces-C++ runtime if you are using + this option." + }; + + bool --generate-any-type + { + "Extract and store content of the XML Schema \cb{anyType} type as a + DOM fragment. Note that you need to initialize the Xerces-C++ runtime + if you are using this option." + }; + + NarrowStrings --generate-insertion + { + "", + "Generate data representation stream insertion operators for the + output stream type. Repeat this option to specify more than one + stream type. The ACE CDR stream (\cb{ACE_OutputCDR}) and RPC XDR + are recognized by the compiler and the necessary \cb{#include} + directives are automatically generated. For custom stream types use + the \cb{--hxx-prologue*} options to provide the necessary + declarations." + }; + + NarrowStrings --generate-extraction + { + "", + "Generate data representation stream extraction constructors for the + input stream type. Repeat this option to specify more than one + stream type. The ACE CDR stream (\cb{ACE_InputCDR}) and RPC XDR are + recognized by the compiler and the necessary \cb{#include} directives + are automatically generated. For custom stream types use the + \cb{--hxx-prologue*} options to provide the necessary declarations." + }; + + bool --generate-forward + { + "Generate a separate header file with forward declarations for the + types being generated." + }; + + bool --suppress-parsing + { + "Suppress the generation of the parsing functions and constructors. + Use this option to reduce the generated code size when parsing from + XML is not needed." + }; + + bool --generate-element-type + { + "Generate types instead of parsing and serialization functions for + root elements. This is primarily useful to distinguish object models + with the same root type but with different root elements." + }; + + bool --generate-element-map + { + "Generate a root element map that allows uniform parsing and + serialization of multiple root elements. This option is only valid + together with \cb{--generate-element-type}." + }; + + bool --generate-intellisense + { + "Generate workarounds for IntelliSense bugs in Visual Studio 2005 + (8.0). When this option is used, the resulting code is slightly + more verbose. IntelliSense in Visual Studio 2008 (9.0) and later + does not require these workarounds. Support for IntelliSense in + Visual Studio 2003 (7.1) is improved with this option but is + still incomplete." + }; + + bool --omit-default-attributes + { + "Omit attributes with default and fixed values from serialized XML + documents." + }; + + // Naming. + // + NarrowString --type-naming = "knr" + { + "